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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
60,000
|
js_proxy_set
|
bluesky950520[P]quickjs/quickjs.c
|
static int js_proxy_set(JSContext *ctx, JSValue obj, JSAtom atom,
JSValue value, JSValue receiver, int flags)
{
JSProxyData *s;
JSValue method, ret1, atom_val;
int ret, res;
JSValue args[4];
s = get_proxy_method(ctx, &method, obj, JS_ATOM_set);
if (!s)
return -1;
if (JS_IsUndefined(method)) {
return JS_SetPropertyInternal2(ctx, s->target, atom,
js_dup(value), receiver,
flags, NULL);
}
atom_val = JS_AtomToValue(ctx, atom);
if (JS_IsException(atom_val)) {
JS_FreeValue(ctx, method);
return -1;
}
args[0] = s->target;
args[1] = atom_val;
args[2] = value;
args[3] = receiver;
ret1 = JS_CallFree(ctx, method, s->handler, 4, args);
JS_FreeValue(ctx, atom_val);
if (JS_IsException(ret1))
return -1;
ret = JS_ToBoolFree(ctx, ret1);
if (ret) {
JSPropertyDescriptor desc;
res = JS_GetOwnPropertyInternal(ctx, &desc, JS_VALUE_GET_OBJ(s->target), atom);
if (res < 0)
return -1;
if (res) {
if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE | JS_PROP_WRITABLE)) == 0) {
if (!js_same_value(ctx, desc.value, value)) {
goto fail;
}
} else if ((desc.flags & (JS_PROP_GETSET | JS_PROP_CONFIGURABLE)) == JS_PROP_GETSET && JS_IsUndefined(desc.setter)) {
fail:
js_free_desc(ctx, &desc);
JS_ThrowTypeError(ctx, "proxy: inconsistent set");
return -1;
}
js_free_desc(ctx, &desc);
}
} else {
if ((flags & JS_PROP_THROW) ||
((flags & JS_PROP_THROW_STRICT) && is_strict_mode(ctx))) {
JS_ThrowTypeError(ctx, "proxy: cannot set property");
return -1;
}
}
return ret;
}
|
O3
|
c
|
js_proxy_set:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %r9, %r15
movq %r8, %r12
movl %ecx, %ebp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x38(%rsp), %rsi
movl $0x43, %r8d
callq 0x429e2
movq %rax, %r13
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %r13, %r13
je 0x556b6
movl 0x110(%rsp), %eax
leaq 0x100(%rsp), %rcx
movq 0x40(%rsp), %rbx
cmpl $0x3, %ebx
jne 0x55537
cmpl $-0x9, %r15d
jb 0x55506
incl (%r12)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movups (%rcx), %xmm0
movups %xmm0, (%rsp)
movl %eax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r14, %rdi
movl %ebp, %ecx
movq %r12, %r8
movq %r15, %r9
callq 0x289c7
jmp 0x556b6
movq %r12, 0x28(%rsp)
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x24ebf
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x55580
cmpl $-0x9, %ebx
jb 0x556b1
movq 0x38(%rsp), %rsi
movq 0x18(%r14), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x556b1
movq %rbx, %rdx
callq 0x259d8
jmp 0x556b1
movups (%r13), %xmm0
leaq 0x80(%rsp), %rdx
movaps %xmm0, (%rdx)
movq %rax, 0x10(%rdx)
movq %r12, 0x18(%rdx)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rdx)
movq %r15, 0x28(%rdx)
leaq 0x100(%rsp), %rcx
movups (%rcx), %xmm0
movaps %xmm0, 0x30(%rdx)
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rsi
movq 0x10(%r13), %rcx
movq 0x18(%r13), %r8
movq %rdx, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
movl $0x4, %r9d
callq 0x274f3
movq 0x30(%rsp), %rsi
movq %rdx, %rbx
cmpl $-0x9, %r12d
jb 0x55607
movq 0x18(%r14), %rdi
movl (%rsi), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %edx
jg 0x55607
movq %r12, %rdx
movq %rax, %r12
callq 0x259d8
movq %r12, %rax
cmpl $0x6, %ebx
je 0x556b1
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x27576
testl %eax, %eax
je 0x55676
movl %eax, %ebx
movq (%r13), %rdx
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %ecx
callq 0x28405
testl %eax, %eax
js 0x556b1
je 0x556f7
movl 0x48(%rsp), %eax
testb $0x13, %al
je 0x556c8
andl $0x11, %eax
cmpl $0x10, %eax
jne 0x556ea
cmpl $0x3, 0x78(%rsp)
jne 0x556ea
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x42e67
leaq 0x51cbd(%rip), %rsi # 0xa7331
jmp 0x556a7
movl 0x110(%rsp), %ecx
btl $0xe, %ecx
jb 0x556a0
xorl %eax, %eax
testw %cx, %cx
jns 0x556b6
movq 0x18(%r14), %rcx
movq 0x108(%rcx), %rcx
testq %rcx, %rcx
je 0x556b6
cmpl $0x0, 0x40(%rcx)
jns 0x556b6
leaq 0x51ca2(%rip), %rsi # 0xa7349
movq %r14, %rdi
xorl %eax, %eax
callq 0x26d97
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r14, %rdi
movq 0x28(%rsp), %rcx
movq %r15, %r8
callq 0x2aaf1
testl %eax, %eax
je 0x55660
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x42e67
movl %ebx, %eax
jmp 0x556b6
|
js_proxy_set:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov r15, r9
mov r12, r8
mov ebp, ecx
mov rcx, rdx
mov rdx, rsi
mov r14, rdi
lea rsi, [rsp+0F8h+var_C0]
mov r8d, 43h ; 'C'
call get_proxy_method
mov r13, rax
mov eax, 0FFFFFFFFh
test r13, r13
jz loc_556B6
mov eax, [rsp+0F8h+arg_10]
lea rcx, [rsp+0F8h+arg_0]
mov rbx, [rsp+0F8h+var_B8]
cmp ebx, 3
jnz short loc_55537
cmp r15d, 0FFFFFFF7h
jb short loc_55506
inc dword ptr [r12]
loc_55506:
mov rsi, [r13+0]
mov rdx, [r13+8]
movups xmm0, xmmword ptr [rcx]
movups [rsp+0F8h+var_F8], xmm0
mov [rsp+0F8h+var_E8], eax
mov [rsp+0F8h+var_E0], 0
mov rdi, r14
mov ecx, ebp
mov r8, r12
mov r9, r15
call JS_SetPropertyInternal2
jmp loc_556B6
loc_55537:
mov [rsp+0F8h+var_D0], r12
mov rdi, r14
mov esi, ebp
xor edx, edx
call __JS_AtomToValue
mov r12, rdx
cmp r12d, 6
jnz short loc_55580
cmp ebx, 0FFFFFFF7h
jb loc_556B1
mov rsi, [rsp+0F8h+var_C0]
mov rdi, [r14+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg loc_556B1
mov rdx, rbx
call js_free_value_rt
jmp loc_556B1
loc_55580:
movups xmm0, xmmword ptr [r13+0]
lea rdx, [rsp+0F8h+var_78]
movaps xmmword ptr [rdx], xmm0
mov [rdx+10h], rax
mov [rdx+18h], r12
mov rcx, [rsp+0F8h+var_D0]
mov [rdx+20h], rcx
mov [rdx+28h], r15
lea rcx, [rsp+0F8h+arg_0]
movups xmm0, xmmword ptr [rcx]
movaps xmmword ptr [rdx+30h], xmm0
mov [rsp+0F8h+var_C8], rax
mov rsi, [rsp+0F8h+var_C0]
mov rcx, [r13+10h]
mov r8, [r13+18h]
mov qword ptr [rsp+0F8h+var_F8], rdx
mov rdi, r14
mov rdx, rbx
mov r9d, 4
call JS_CallFree
mov rsi, [rsp+0F8h+var_C8]
mov rbx, rdx
cmp r12d, 0FFFFFFF7h
jb short loc_55607
mov rdi, [r14+18h]
mov edx, [rsi]
lea ecx, [rdx-1]
mov [rsi], ecx
cmp edx, 1
jg short loc_55607
mov rdx, r12
mov r12, rax
call js_free_value_rt
mov rax, r12
loc_55607:
cmp ebx, 6
jz loc_556B1
mov rdi, r14
mov rsi, rax
mov rdx, rbx
call JS_ToBoolFree
test eax, eax
jz short loc_55676
mov ebx, eax
mov rdx, [r13+0]
lea rsi, [rsp+0F8h+var_B0]
mov rdi, r14
mov ecx, ebp
call JS_GetOwnPropertyInternal
test eax, eax
js short loc_556B1
jz loc_556F7
mov eax, [rsp+0F8h+var_B0]
test al, 13h
jz short loc_556C8
and eax, 11h
cmp eax, 10h
jnz loc_556EA
cmp [rsp+0F8h+var_80], 3
jnz loc_556EA
loc_55660:
lea rsi, [rsp+0F8h+var_B0]
mov rdi, r14
call js_free_desc
lea rsi, aProxyInconsist_7; "proxy: inconsistent set"
jmp short loc_556A7
loc_55676:
mov ecx, [rsp+0F8h+arg_10]
bt ecx, 0Eh
jb short loc_556A0
xor eax, eax
test cx, cx
jns short loc_556B6
mov rcx, [r14+18h]
mov rcx, [rcx+108h]
test rcx, rcx
jz short loc_556B6
cmp dword ptr [rcx+40h], 0
jns short loc_556B6
loc_556A0:
lea rsi, aProxyCannotSet; "proxy: cannot set property"
loc_556A7:
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_556B1:
mov eax, 0FFFFFFFFh
loc_556B6:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_556C8:
mov rsi, [rsp+0F8h+var_A8]
mov rdx, [rsp+0F8h+var_A0]
mov rdi, r14
mov rcx, [rsp+0F8h+var_D0]
mov r8, r15
call js_same_value
test eax, eax
jz loc_55660
loc_556EA:
lea rsi, [rsp+0F8h+var_B0]
mov rdi, r14
call js_free_desc
loc_556F7:
mov eax, ebx
jmp short loc_556B6
|
long long js_proxy_set(
long long a1,
long long a2,
long long a3,
unsigned int a4,
_DWORD *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
__m128 a15,
unsigned int a16)
{
long long *proxy_method; // r13
double v21; // xmm4_8
double v22; // xmm5_8
long long result; // rax
long long v24; // rbx
long long v25; // rax
long long v26; // rdx
long long v27; // r8
long long v28; // r9
long long v29; // r12
_QWORD *v30; // rsi
long long v31; // rdi
int v32; // eax
long long v33; // rcx
long long v34; // rax
long long v35; // rcx
long long v36; // r8
long long v37; // r9
long long v38; // rdx
long long v39; // rbx
long long v40; // rdi
int v41; // edx
long long v42; // rdx
long long v43; // r12
unsigned int v44; // eax
long long v45; // rdx
long long v46; // r8
long long v47; // r9
__m128 v48; // xmm4
__m128 v49; // xmm5
unsigned int v50; // ebx
int v51; // eax
long long v52; // rdx
long long v53; // rcx
long long v54; // r8
long long v55; // r9
long long v56; // rcx
const char *v57; // rsi
char v58; // [rsp+0h] [rbp-F8h]
_DWORD *v59; // [rsp+28h] [rbp-D0h]
_QWORD *v60; // [rsp+30h] [rbp-C8h]
_QWORD *v61; // [rsp+38h] [rbp-C0h] BYREF
long long v62; // [rsp+40h] [rbp-B8h]
_QWORD v63[6]; // [rsp+48h] [rbp-B0h] BYREF
int v64; // [rsp+78h] [rbp-80h]
__int128 v65; // [rsp+80h] [rbp-78h] BYREF
long long v66; // [rsp+90h] [rbp-68h]
long long v67; // [rsp+98h] [rbp-60h]
_DWORD *v68; // [rsp+A0h] [rbp-58h]
long long v69; // [rsp+A8h] [rbp-50h]
__m128 v70; // [rsp+B0h] [rbp-48h]
proxy_method = (long long *)get_proxy_method(
a1,
(unsigned long long *)&v61,
a2,
a3,
67LL,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14);
result = 0xFFFFFFFFLL;
if ( !proxy_method )
return result;
v24 = v62;
if ( (_DWORD)v62 != 3 )
{
v59 = a5;
v25 = _JS_AtomToValue(a1, a4, 0);
v29 = v26;
if ( (_DWORD)v26 == 6 )
{
if ( (unsigned int)v24 >= 0xFFFFFFF7 )
{
v30 = v61;
v31 = *(_QWORD *)(a1 + 24);
v32 = *(_DWORD *)v61;
v33 = (unsigned int)(*(_DWORD *)v61 - 1);
*(_DWORD *)v61 = v33;
if ( v32 <= 1 )
js_free_value_rt(v31, v30, v24, v33, v27, v28);
}
return 0xFFFFFFFFLL;
}
v65 = *(_OWORD *)proxy_method;
v66 = v25;
v67 = v26;
v68 = v59;
v69 = a6;
v70 = a15;
v60 = (_QWORD *)v25;
v34 = JS_CallFree(a1, v61, v24, proxy_method[2], proxy_method[3], 4, (long long)&v65);
v39 = v38;
if ( (unsigned int)v29 >= 0xFFFFFFF7 )
{
v40 = *(_QWORD *)(a1 + 24);
v41 = *(_DWORD *)v60;
v35 = (unsigned int)(*(_DWORD *)v60 - 1);
*(_DWORD *)v60 = v35;
if ( v41 <= 1 )
{
v42 = v29;
v43 = v34;
js_free_value_rt(v40, v60, v42, v35, v36, v37);
v34 = v43;
}
}
if ( (_DWORD)v39 == 6 )
return 0xFFFFFFFFLL;
v44 = JS_ToBoolFree(a1, v34, v39, v35, v36, v37);
if ( !v44 )
{
v56 = a16;
if ( (a16 & 0x4000) == 0 )
{
result = 0LL;
if ( (a16 & 0x8000u) == 0 )
return result;
v56 = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 264LL);
if ( !v56 || *(int *)(v56 + 64) >= 0 )
return result;
}
v57 = "proxy: cannot set property";
goto LABEL_26;
}
v50 = v44;
LOBYTE(v51) = JS_GetOwnPropertyInternal(a1, (long long)v63, *proxy_method, a4);
if ( v51 < 0 )
return 0xFFFFFFFFLL;
if ( v51 )
{
if ( (v63[0] & 0x13) != 0 )
{
if ( (v63[0] & 0x11) == 0x10 && v64 == 3 )
goto LABEL_20;
}
else if ( !(unsigned int)js_same_value(a1, (_DWORD *)v63[1], v63[2], v59, a6) )
{
LABEL_20:
js_free_desc(a1, v63, v52, v53, v54, v55);
v57 = "proxy: inconsistent set";
LABEL_26:
JS_ThrowTypeError(a1, (long long)v57, v45, v56, v46, v47, a15, a8, a9, a10, v48, v49, a13, a14, v58);
return 0xFFFFFFFFLL;
}
js_free_desc(a1, v63, v52, v53, v54, v55);
}
return v50;
}
if ( (unsigned int)a6 >= 0xFFFFFFF7 )
++*a5;
return JS_SetPropertyInternal2(
a1,
*proxy_method,
proxy_method[1],
a4,
(long long)a5,
a6,
a15,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
a15.m128_i64[0],
a15.m128_i64[1],
a16,
0LL);
}
|
js_proxy_set:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV R15,R9
MOV R12,R8
MOV EBP,ECX
MOV RCX,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RSI,[RSP + 0x38]
MOV R8D,0x43
CALL 0x001429e2
MOV R13,RAX
MOV EAX,0xffffffff
TEST R13,R13
JZ 0x001556b6
MOV EAX,dword ptr [RSP + 0x110]
LEA RCX,[RSP + 0x100]
MOV RBX,qword ptr [RSP + 0x40]
CMP EBX,0x3
JNZ 0x00155537
CMP R15D,-0x9
JC 0x00155506
INC dword ptr [R12]
LAB_00155506:
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x10],EAX
MOV qword ptr [RSP + 0x18],0x0
MOV RDI,R14
MOV ECX,EBP
MOV R8,R12
MOV R9,R15
CALL 0x001289c7
JMP 0x001556b6
LAB_00155537:
MOV qword ptr [RSP + 0x28],R12
MOV RDI,R14
MOV ESI,EBP
XOR EDX,EDX
CALL 0x00124ebf
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00155580
CMP EBX,-0x9
JC 0x001556b1
MOV RSI,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [R14 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x001556b1
MOV RDX,RBX
CALL 0x001259d8
JMP 0x001556b1
LAB_00155580:
MOVUPS XMM0,xmmword ptr [R13]
LEA RDX,[RSP + 0x80]
MOVAPS xmmword ptr [RDX],XMM0
MOV qword ptr [RDX + 0x10],RAX
MOV qword ptr [RDX + 0x18],R12
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RDX + 0x20],RCX
MOV qword ptr [RDX + 0x28],R15
LEA RCX,[RSP + 0x100]
MOVUPS XMM0,xmmword ptr [RCX]
MOVAPS xmmword ptr [RDX + 0x30],XMM0
MOV qword ptr [RSP + 0x30],RAX
MOV RSI,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [R13 + 0x10]
MOV R8,qword ptr [R13 + 0x18]
MOV qword ptr [RSP],RDX
MOV RDI,R14
MOV RDX,RBX
MOV R9D,0x4
CALL 0x001274f3
MOV RSI,qword ptr [RSP + 0x30]
MOV RBX,RDX
CMP R12D,-0x9
JC 0x00155607
MOV RDI,qword ptr [R14 + 0x18]
MOV EDX,dword ptr [RSI]
LEA ECX,[RDX + -0x1]
MOV dword ptr [RSI],ECX
CMP EDX,0x1
JG 0x00155607
MOV RDX,R12
MOV R12,RAX
CALL 0x001259d8
MOV RAX,R12
LAB_00155607:
CMP EBX,0x6
JZ 0x001556b1
MOV RDI,R14
MOV RSI,RAX
MOV RDX,RBX
CALL 0x00127576
TEST EAX,EAX
JZ 0x00155676
MOV EBX,EAX
MOV RDX,qword ptr [R13]
LEA RSI,[RSP + 0x48]
MOV RDI,R14
MOV ECX,EBP
CALL 0x00128405
TEST EAX,EAX
JS 0x001556b1
JZ 0x001556f7
MOV EAX,dword ptr [RSP + 0x48]
TEST AL,0x13
JZ 0x001556c8
AND EAX,0x11
CMP EAX,0x10
JNZ 0x001556ea
CMP dword ptr [RSP + 0x78],0x3
JNZ 0x001556ea
LAB_00155660:
LEA RSI,[RSP + 0x48]
MOV RDI,R14
CALL 0x00142e67
LEA RSI,[0x1a7331]
JMP 0x001556a7
LAB_00155676:
MOV ECX,dword ptr [RSP + 0x110]
BT ECX,0xe
JC 0x001556a0
XOR EAX,EAX
TEST CX,CX
JNS 0x001556b6
MOV RCX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RCX + 0x108]
TEST RCX,RCX
JZ 0x001556b6
CMP dword ptr [RCX + 0x40],0x0
JNS 0x001556b6
LAB_001556a0:
LEA RSI,[0x1a7349]
LAB_001556a7:
MOV RDI,R14
XOR EAX,EAX
CALL 0x00126d97
LAB_001556b1:
MOV EAX,0xffffffff
LAB_001556b6:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001556c8:
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RDI,R14
MOV RCX,qword ptr [RSP + 0x28]
MOV R8,R15
CALL 0x0012aaf1
TEST EAX,EAX
JZ 0x00155660
LAB_001556ea:
LEA RSI,[RSP + 0x48]
MOV RDI,R14
CALL 0x00142e67
LAB_001556f7:
MOV EAX,EBX
JMP 0x001556b6
|
ulong js_proxy_set(long param_1,int8 param_2,int8 param_3,int4 param_4,
int *param_5,int8 param_6,int8 param_7,int4 param_8,uint param_9
)
{
int8 uVar1;
long lVar2;
uint uVar3;
int iVar4;
int8 *puVar5;
ulong uVar6;
int *piVar7;
int8 uVar8;
char *pcVar9;
int1 auVar10 [16];
int *local_c0;
int8 local_b8;
uint local_b0 [2];
int8 local_a8;
int8 local_a0;
int local_80;
int8 local_78;
int8 uStack_70;
int1 local_68 [16];
int *local_58;
int8 local_50;
int4 local_48;
int4 uStack_40;
puVar5 = (int8 *)get_proxy_method(param_1,&local_c0,param_2,param_3,0x43);
if (puVar5 == (int8 *)0x0) {
return 0xffffffff;
}
if ((uint)local_b8 == 3) {
if (0xfffffff6 < (uint)param_6) {
*param_5 = *param_5 + 1;
}
uVar6 = JS_SetPropertyInternal2
(param_1,*puVar5,puVar5[1],param_4,param_5,param_6,param_7,param_8,param_9,0);
return uVar6;
}
local_68 = __JS_AtomToValue(param_1,param_4,0);
uVar8 = local_68._8_8_;
piVar7 = local_68._0_8_;
uVar3 = local_68._8_4_;
if (uVar3 == 6) {
if (0xfffffff6 < (uint)local_b8) {
uVar8 = *(int8 *)(param_1 + 0x18);
iVar4 = *local_c0;
*local_c0 = iVar4 + -1;
if (iVar4 < 2) {
js_free_value_rt(uVar8,local_c0,local_b8);
}
}
}
else {
local_78 = *puVar5;
uStack_70 = puVar5[1];
local_48 = (int4)param_7;
uStack_40 = param_8;
local_58 = param_5;
local_50 = param_6;
auVar10 = JS_CallFree(param_1,local_c0,local_b8,puVar5[2],puVar5[3],4,&local_78);
if (0xfffffff6 < uVar3) {
uVar1 = *(int8 *)(param_1 + 0x18);
iVar4 = *piVar7;
*piVar7 = iVar4 + -1;
if (iVar4 < 2) {
js_free_value_rt(uVar1,piVar7,uVar8);
}
}
if (auVar10._8_4_ != 6) {
uVar3 = JS_ToBoolFree(param_1,auVar10._0_8_,auVar10._8_8_);
if (uVar3 == 0) {
if ((param_9 >> 0xe & 1) == 0) {
if (-1 < (short)param_9) {
return 0;
}
lVar2 = *(long *)(*(long *)(param_1 + 0x18) + 0x108);
if (lVar2 == 0) {
return 0;
}
if (-1 < *(int *)(lVar2 + 0x40)) {
return 0;
}
}
pcVar9 = "proxy: cannot set property";
}
else {
iVar4 = JS_GetOwnPropertyInternal(param_1,local_b0,*puVar5,param_4);
if (iVar4 < 0) {
return 0xffffffff;
}
if (iVar4 == 0) {
return (ulong)uVar3;
}
if ((local_b0[0] & 0x13) == 0) {
iVar4 = js_same_value(param_1,local_a8,local_a0,param_5,param_6);
if (iVar4 != 0) goto LAB_001556ea;
}
else if (((local_b0[0] & 0x11) != 0x10) || (local_80 != 3)) {
LAB_001556ea:
js_free_desc(param_1,local_b0);
return (ulong)uVar3;
}
js_free_desc(param_1,local_b0);
pcVar9 = "proxy: inconsistent set";
}
JS_ThrowTypeError(param_1,pcVar9);
}
}
return 0xffffffff;
}
|
|
60,001
|
string_buffer_widen
|
bluesky950520[P]quickjs/quickjs.c
|
static no_inline int string_buffer_widen(StringBuffer *s, int size)
{
JSString *str;
size_t slack;
int i;
if (s->error_status)
return -1;
str = js_realloc2(s->ctx, s->str, sizeof(JSString) + (size << 1), &slack);
if (!str)
return string_buffer_set_error(s);
size += slack >> 1;
for(i = s->len; i-- > 0;) {
str->u.str16[i] = str->u.str8[i];
}
s->is_wide_char = 1;
s->size = size;
s->str = str;
return 0;
}
|
O2
|
c
|
string_buffer_widen:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $-0x1
popq %rbp
cmpl $0x0, 0x1c(%rdi)
jne 0x39ffd
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
leal (%r14,%r14), %eax
movslq %eax, %rdx
addq $0x18, %rdx
leaq 0x8(%rsp), %rcx
callq 0x172b1
testq %rax, %rax
je 0x39ff5
movq 0x8(%rsp), %rcx
shrq %rcx
movl 0x10(%rbx), %edx
testl %edx, %edx
jle 0x39fe0
movzbl 0x17(%rax,%rdx), %esi
movw %si, 0x16(%rax,%rdx,2)
decq %rdx
jmp 0x39fcd
addl %r14d, %ecx
movl $0x1, 0x18(%rbx)
movl %ecx, 0x14(%rbx)
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0x39ffd
movq %rbx, %rdi
callq 0x39f6d
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
string_buffer_widen:
push rbp
push r14
push rbx
sub rsp, 10h
push 0FFFFFFFFFFFFFFFFh
pop rbp
cmp dword ptr [rdi+1Ch], 0
jnz short loc_39FFD
mov r14d, esi
mov rbx, rdi
mov rdi, [rdi]
mov rsi, [rbx+8]
lea eax, [r14+r14]
movsxd rdx, eax
add rdx, 18h
lea rcx, [rsp+28h+var_20]
call js_realloc2
test rax, rax
jz short loc_39FF5
mov rcx, [rsp+28h+var_20]
shr rcx, 1
mov edx, [rbx+10h]
loc_39FCD:
test edx, edx
jle short loc_39FE0
movzx esi, byte ptr [rax+rdx+17h]
mov [rax+rdx*2+16h], si
dec rdx
jmp short loc_39FCD
loc_39FE0:
add ecx, r14d
mov dword ptr [rbx+18h], 1
mov [rbx+14h], ecx
mov [rbx+8], rax
xor ebp, ebp
jmp short loc_39FFD
loc_39FF5:
mov rdi, rbx
call string_buffer_set_error
loc_39FFD:
mov eax, ebp
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
|
long long string_buffer_widen(long long a1, int a2)
{
unsigned int v2; // ebp
long long v3; // rax
unsigned long long v4; // rcx
long long i; // rdx
unsigned long long v7[4]; // [rsp+8h] [rbp-20h] BYREF
v2 = -1;
if ( !*(_DWORD *)(a1 + 28) )
{
v3 = js_realloc2(*(_QWORD *)a1, *(_QWORD *)(a1 + 8), 2 * a2 + 24LL, v7);
if ( v3 )
{
v4 = v7[0] >> 1;
for ( i = *(unsigned int *)(a1 + 16); (int)i > 0; --i )
*(_WORD *)(v3 + 2 * i + 22) = *(unsigned __int8 *)(v3 + i + 23);
*(_DWORD *)(a1 + 24) = 1;
*(_DWORD *)(a1 + 20) = a2 + v4;
*(_QWORD *)(a1 + 8) = v3;
return 0;
}
else
{
string_buffer_set_error(a1);
}
}
return v2;
}
|
string_buffer_widen:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
PUSH -0x1
POP RBP
CMP dword ptr [RDI + 0x1c],0x0
JNZ 0x00139ffd
MOV R14D,ESI
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV RSI,qword ptr [RBX + 0x8]
LEA EAX,[R14 + R14*0x1]
MOVSXD RDX,EAX
ADD RDX,0x18
LEA RCX,[RSP + 0x8]
CALL 0x001172b1
TEST RAX,RAX
JZ 0x00139ff5
MOV RCX,qword ptr [RSP + 0x8]
SHR RCX,0x1
MOV EDX,dword ptr [RBX + 0x10]
LAB_00139fcd:
TEST EDX,EDX
JLE 0x00139fe0
MOVZX ESI,byte ptr [RAX + RDX*0x1 + 0x17]
MOV word ptr [RAX + RDX*0x2 + 0x16],SI
DEC RDX
JMP 0x00139fcd
LAB_00139fe0:
ADD ECX,R14D
MOV dword ptr [RBX + 0x18],0x1
MOV dword ptr [RBX + 0x14],ECX
MOV qword ptr [RBX + 0x8],RAX
XOR EBP,EBP
JMP 0x00139ffd
LAB_00139ff5:
MOV RDI,RBX
CALL 0x00139f6d
LAB_00139ffd:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
int4 string_buffer_widen(int8 *param_1,int param_2)
{
long lVar1;
ulong uVar2;
int4 uVar3;
ulong local_20;
uVar3 = 0xffffffff;
if (*(int *)((long)param_1 + 0x1c) == 0) {
lVar1 = js_realloc2(*param_1,param_1[1],(long)(param_2 * 2) + 0x18,&local_20);
if (lVar1 == 0) {
string_buffer_set_error(param_1);
}
else {
for (uVar2 = (ulong)*(uint *)(param_1 + 2); 0 < (int)uVar2; uVar2 = uVar2 - 1) {
*(ushort *)(lVar1 + 0x16 + uVar2 * 2) = (ushort)*(byte *)(lVar1 + 0x17 + uVar2);
}
*(int4 *)(param_1 + 3) = 1;
*(int *)((long)param_1 + 0x14) = (int)(local_20 >> 1) + param_2;
param_1[1] = lVar1;
uVar3 = 0;
}
}
return uVar3;
}
|
|
60,002
|
JS_ReadDate
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue JS_ReadDate(BCReaderState *s)
{
JSContext *ctx = s->ctx;
JSValue val, obj = JS_UNDEFINED;
val = JS_ReadObjectRec(s);
if (JS_IsException(val))
goto fail;
if (!JS_IsNumber(val)) {
JS_ThrowTypeError(ctx, "Number tag expected for date");
goto fail;
}
obj = JS_NewObjectProtoClass(ctx, ctx->class_proto[JS_CLASS_DATE],
JS_CLASS_DATE);
if (JS_IsException(obj))
goto fail;
if (BC_add_object_ref(s, obj))
goto fail;
JS_SetObjectData(ctx, obj, val);
return obj;
fail:
JS_FreeValue(ctx, val);
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
JS_ReadDate:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbp
movq (%rdi), %r14
callq 0x32909
movq %rax, %r12
movq %rdx, %r15
movl $0x3, %ebx
cmpl $0x6, %r15d
jne 0x46d6d
xorl %r13d, %r13d
jmp 0x46ddb
testl %r15d, %r15d
je 0x46d78
cmpl $0x7, %r15d
jne 0x46dc7
movq 0x40(%r14), %rax
movq 0xa0(%rax), %rsi
movq 0xa8(%rax), %rdx
movq %r14, %rdi
movl $0xa, %ecx
callq 0x20f05
movq %rax, %r13
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x46ddb
movq %rbp, %rdi
movq %r13, %rsi
callq 0x47091
testl %eax, %eax
jne 0x46ddb
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x36e62
jmp 0x46e01
leaq 0x58c63(%rip), %rsi # 0x9fa31
xorl %r13d, %r13d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1d8c6
movl $0x6, %ebx
xorl %r13d, %r13d
movq %r13, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
JS_ReadDate:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbp, rdi
mov r14, [rdi]
call JS_ReadObjectRec
mov r12, rax
mov r15, rdx
mov ebx, 3
cmp r15d, 6
jnz short loc_46D6D
xor r13d, r13d
jmp short loc_46DDB
loc_46D6D:
test r15d, r15d
jz short loc_46D78
cmp r15d, 7
jnz short loc_46DC7
loc_46D78:
mov rax, [r14+40h]
mov rsi, [rax+0A0h]
mov rdx, [rax+0A8h]
mov rdi, r14
mov ecx, 0Ah
call JS_NewObjectProtoClass
mov r13, rax
mov rbx, rdx
cmp ebx, 6
jz short loc_46DDB
mov rdi, rbp
mov rsi, r13
call BC_add_object_ref1
test eax, eax
jnz short loc_46DDB
mov rdi, r14
mov rsi, r13
mov rdx, rbx
mov rcx, r12
mov r8, r15
call JS_SetObjectData
jmp short loc_46E01
loc_46DC7:
lea rsi, aNumberTagExpec; "Number tag expected for date"
xor r13d, r13d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
loc_46DDB:
mov rdi, [r14+18h]
mov rsi, r12
mov rdx, r15
call JS_FreeValueRT
mov rdi, [r14+18h]
mov rsi, r13
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
xor r13d, r13d
loc_46E01:
mov rax, r13
mov rdx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_DWORD * JS_ReadDate(
long long *a1,
long long a2,
long long 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
long long v15; // r14
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
_DWORD *ObjectRec; // r12
__m128 v21; // xmm4
__m128 v22; // xmm5
long long v23; // r15
long long v24; // rbx
_DWORD *v25; // r13
long long v26; // rax
long long v27; // rdx
long long v28; // r9
double v29; // xmm4_8
double v30; // xmm5_8
char v32; // [rsp-8h] [rbp-38h]
v32 = v14;
v15 = *a1;
ObjectRec = (_DWORD *)JS_ReadObjectRec((long long)a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, a4, a5, a6);
v23 = v16;
v24 = 3LL;
if ( (_DWORD)v16 == 6 )
{
v25 = 0LL;
LABEL_9:
JS_FreeValueRT(*(_QWORD *)(v15 + 24), ObjectRec, v23);
JS_FreeValueRT(*(_QWORD *)(v15 + 24), v25, v24);
return 0LL;
}
if ( (_DWORD)v16 && (_DWORD)v16 != 7 )
{
v25 = 0LL;
JS_ThrowTypeError(
v15,
(long long)"Number tag expected for date",
v16,
v17,
v18,
v19,
a7,
a8,
a9,
a10,
v21,
v22,
a13,
a14,
v32);
goto LABEL_9;
}
v26 = JS_NewObjectProtoClass(
v15,
*(_QWORD *)(*(_QWORD *)(v15 + 64) + 160LL),
*(_QWORD *)(*(_QWORD *)(v15 + 64) + 168LL),
0xAu);
v25 = (_DWORD *)v26;
v24 = v27;
if ( (_DWORD)v27 == 6 || (unsigned int)BC_add_object_ref1(a1, v26) )
goto LABEL_9;
JS_SetObjectData(v15, (long long)v25, v24, ObjectRec, v23, a7, a8, a9, a10, v29, v30, a13, a14, v28, v32);
return v25;
}
|
JS_ReadDate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBP,RDI
MOV R14,qword ptr [RDI]
CALL 0x00132909
MOV R12,RAX
MOV R15,RDX
MOV EBX,0x3
CMP R15D,0x6
JNZ 0x00146d6d
XOR R13D,R13D
JMP 0x00146ddb
LAB_00146d6d:
TEST R15D,R15D
JZ 0x00146d78
CMP R15D,0x7
JNZ 0x00146dc7
LAB_00146d78:
MOV RAX,qword ptr [R14 + 0x40]
MOV RSI,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RAX + 0xa8]
MOV RDI,R14
MOV ECX,0xa
CALL 0x00120f05
MOV R13,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00146ddb
MOV RDI,RBP
MOV RSI,R13
CALL 0x00147091
TEST EAX,EAX
JNZ 0x00146ddb
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R12
MOV R8,R15
CALL 0x00136e62
JMP 0x00146e01
LAB_00146dc7:
LEA RSI,[0x19fa31]
XOR R13D,R13D
MOV RDI,R14
XOR EAX,EAX
CALL 0x00122567
LAB_00146ddb:
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R12
MOV RDX,R15
CALL 0x0011d8c6
MOV RDI,qword ptr [R14 + 0x18]
MOV RSI,R13
MOV RDX,RBX
CALL 0x0011d8c6
MOV EBX,0x6
XOR R13D,R13D
LAB_00146e01:
MOV RAX,R13
MOV RDX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16] JS_ReadDate(long *param_1)
{
long lVar1;
int iVar2;
int1 auVar3 [16];
int1 auVar4 [16];
lVar1 = *param_1;
auVar3 = JS_ReadObjectRec();
iVar2 = auVar3._8_4_;
if (iVar2 == 6) {
auVar4 = ZEXT816(3) << 0x40;
}
else if ((iVar2 == 0) || (iVar2 == 7)) {
auVar4 = JS_NewObjectProtoClass
(lVar1,*(int8 *)(*(long *)(lVar1 + 0x40) + 0xa0),
*(int8 *)(*(long *)(lVar1 + 0x40) + 0xa8),10);
if ((auVar4._8_4_ != 6) && (iVar2 = BC_add_object_ref1(param_1,auVar4._0_8_), iVar2 == 0)) {
JS_SetObjectData(lVar1,auVar4._0_8_,auVar4._8_8_,auVar3._0_8_,auVar3._8_8_);
return auVar4;
}
}
else {
auVar4 = ZEXT816(3) << 0x40;
JS_ThrowTypeError(lVar1,"Number tag expected for date");
}
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),auVar3._0_8_,auVar3._8_8_);
JS_FreeValueRT(*(int8 *)(lVar1 + 0x18),auVar4._0_8_,auVar4._8_8_);
return ZEXT816(6) << 0x40;
}
|
|
60,003
|
flux::parser::Parser::error(flux::lexer::Token const&, std::basic_string_view<char, std::char_traits<char>>)
|
kvthweatt[P]FluxLang/src/parser/parser.cpp
|
void Parser::error(const lexer::Token& token, std::string_view message) {
if (panicMode_) return;
std::stringstream ss;
ss << message;
common::SourcePosition start = token.start();
common::SourcePosition end = token.end();
output::SourceLocation location(
tokenizer_.errors().errors().empty() ?
"" : tokenizer_.errors().errors()[0].location().filename,
start.line,
start.column
);
errors_.addError(common::ErrorCode::PARSER_ERROR, ss.str(), location);
}
|
O3
|
cpp
|
flux::parser::Parser::error(flux::lexer::Token const&, std::basic_string_view<char, std::char_traits<char>>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
cmpb $0x0, 0xe0(%rdi)
jne 0x14448
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x61b0
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x62c0
movdqu 0x18(%r14), %xmm0
movq (%rbx), %rcx
movq 0x38(%rcx), %rdx
leaq 0x14fb1(%rip), %rax # 0x29356
cmpq 0x40(%rcx), %rdx
je 0x143b5
movq 0x30(%rdx), %rcx
movq 0x38(%rdx), %rdx
jmp 0x143ba
xorl %ecx, %ecx
movq %rax, %rdx
pshufd $0xe8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,2,3]
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %xmm0, 0x30(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq %rcx, 0x48(%rsp)
leaq 0x68(%rsp), %rsi
movq %rsp, %rdi
callq 0x63c0
addq $0xc8, %rbx
movq (%rsp), %rcx
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %r8
movq %rbx, %rdi
movl $0x8, %esi
callq 0x8e82
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1442a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6280
movq 0x24b57(%rip), %rsi # 0x38f88
leaq 0x50(%rsp), %rdi
callq 0x61f0
leaq 0xd0(%rsp), %rdi
callq 0x60d0
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1447c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6280
jmp 0x1447c
jmp 0x14479
movq %rax, %rbx
movq 0x24b05(%rip), %rsi # 0x38f88
leaq 0x50(%rsp), %rdi
callq 0x61f0
leaq 0xd0(%rsp), %rdi
callq 0x60d0
movq %rbx, %rdi
callq 0x6440
|
_ZN4flux6parser6Parser5errorERKNS_5lexer5TokenESt17basic_string_viewIcSt11char_traitsIcEE:
push r15
push r14
push r12
push rbx
sub rsp, 1D8h
cmp byte ptr [rdi+0E0h], 0
jnz loc_14448
mov r12, rcx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rdi, [rsp+1F8h+var_1A8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
lea rdi, [rsp+1F8h+var_198]
mov rsi, r12
mov rdx, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
movdqu xmm0, xmmword ptr [r14+18h]
mov rcx, [rbx]
mov rdx, [rcx+38h]
lea rax, unk_29356
cmp rdx, [rcx+40h]
jz short loc_143B5
mov rcx, [rdx+30h]
mov rdx, [rdx+38h]
jmp short loc_143BA
loc_143B5:
xor ecx, ecx
mov rdx, rax
loc_143BA:
pshufd xmm0, xmm0, 0E8h
mov [rsp+1F8h+var_1D8], rcx
mov [rsp+1F8h+var_1D0], rdx
movq [rsp+1F8h+var_1C8], xmm0
xor ecx, ecx
mov [rsp+1F8h+var_1C0], rcx
mov [rsp+1F8h+var_1B8], rax
mov [rsp+1F8h+var_1B0], rcx
lea rsi, [rsp+1F8h+var_190]
mov rdi, rsp
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
add rbx, 0C8h
mov rcx, [rsp+1F8h+var_1F8]
mov rdx, [rsp+1F8h+var_1F0]
lea r8, [rsp+1F8h+var_1D8]
mov rdi, rbx
mov esi, 8
call _ZN4flux6common14ErrorCollector8addErrorENS0_9ErrorCodeESt17basic_string_viewIcSt11char_traitsIcEERKNS_6output14SourceLocationE; flux::common::ErrorCollector::addError(flux::common::ErrorCode,std::string_view,flux::output::SourceLocation const&)
lea rax, [rsp+1F8h+var_1E8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1442A
mov rsi, [rsp+1F8h+var_1E8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1442A:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1F8h+var_1A8]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+1F8h+var_128]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_14448:
add rsp, 1D8h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_1447C
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_1447C
jmp short $+2
loc_14479:
mov rbx, rax
loc_1447C:
mov rsi, cs:_ZTTNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_48]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED2Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
lea rdi, [rsp+arg_C8]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
|
void flux::parser::Parser::error(_BYTE *a1, long long a2, long long a3, long long a4)
{
__m128i v6; // xmm0
long long v7; // rdx
long long v8; // rcx
void *v9; // rdx
void *v10[2]; // [rsp+0h] [rbp-1F8h] BYREF
long long v11; // [rsp+10h] [rbp-1E8h] BYREF
_QWORD v12[6]; // [rsp+20h] [rbp-1D8h] BYREF
_BYTE v13[16]; // [rsp+50h] [rbp-1A8h] BYREF
_BYTE v14[8]; // [rsp+60h] [rbp-198h] BYREF
_BYTE v15[104]; // [rsp+68h] [rbp-190h] BYREF
_BYTE v16[296]; // [rsp+D0h] [rbp-128h] BYREF
if ( !a1[224] )
{
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v13);
std::__ostream_insert<char,std::char_traits<char>>(v14, a4, a3);
v6 = _mm_loadu_si128((const __m128i *)(a2 + 24));
v7 = *(_QWORD *)(*(_QWORD *)a1 + 56LL);
if ( v7 == *(_QWORD *)(*(_QWORD *)a1 + 64LL) )
{
v8 = 0LL;
v9 = &unk_29356;
}
else
{
v8 = *(_QWORD *)(v7 + 48);
v9 = *(void **)(v7 + 56);
}
v12[0] = v8;
v12[1] = v9;
v12[2] = _mm_shuffle_epi32(v6, 232).m128i_u64[0];
v12[3] = 0LL;
v12[4] = &unk_29356;
v12[5] = 0LL;
std::stringbuf::str(v10, v15);
flux::common::ErrorCollector::addError((long long)(a1 + 200), 8, (long long)v10[1], (long long)v10[0], (long long)v12);
if ( v10[0] != &v11 )
operator delete(v10[0], v11 + 1);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(
v13,
&`VTT for'std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>);
std::ios_base::~ios_base((std::ios_base *)v16);
}
}
|
error:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1d8
CMP byte ptr [RDI + 0xe0],0x0
JNZ 0x00114448
MOV R12,RCX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x50]
CALL 0x001061b0
LEA RDI,[RSP + 0x60]
LAB_00114386:
MOV RSI,R12
MOV RDX,R15
CALL 0x001062c0
MOVDQU XMM0,xmmword ptr [R14 + 0x18]
MOV RCX,qword ptr [RBX]
MOV RDX,qword ptr [RCX + 0x38]
LEA RAX,[0x129356]
CMP RDX,qword ptr [RCX + 0x40]
JZ 0x001143b5
MOV RCX,qword ptr [RDX + 0x30]
MOV RDX,qword ptr [RDX + 0x38]
JMP 0x001143ba
LAB_001143b5:
XOR ECX,ECX
MOV RDX,RAX
LAB_001143ba:
PSHUFD XMM0,XMM0,0xe8
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],RDX
MOVQ qword ptr [RSP + 0x30],XMM0
XOR ECX,ECX
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RCX
LEA RSI,[RSP + 0x68]
LAB_001143e5:
MOV RDI,RSP
CALL 0x001063c0
ADD RBX,0xc8
MOV RCX,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
LAB_001143fd:
LEA R8,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x8
CALL 0x00108e82
LAB_0011440f:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0011442a
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00106280
LAB_0011442a:
MOV RSI,qword ptr [0x00138f88]
LEA RDI,[RSP + 0x50]
CALL 0x001061f0
LEA RDI,[RSP + 0xd0]
CALL 0x001060d0
LAB_00114448:
ADD RSP,0x1d8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* flux::parser::Parser::error(flux::lexer::Token const&, std::basic_string_view<char,
std::char_traits<char> >) */
void flux::parser::Parser::error(long *param_1,long param_2,long param_3,char *param_4)
{
long lVar1;
long *local_1f8;
int8 local_1f0;
long local_1e8 [2];
int8 local_1d8;
int *local_1d0;
int8 local_1c8;
int8 local_1c0;
int *local_1b8;
int8 local_1b0;
stringstream local_1a8 [16];
ostream local_198 [112];
ios_base local_128 [264];
if ((char)param_1[0x1c] == '\0') {
std::__cxx11::stringstream::stringstream(local_1a8);
/* try { // try from 00114386 to 00114390 has its CatchHandler @ 00114479 */
std::__ostream_insert<char,std::char_traits<char>>(local_198,param_4,param_3);
lVar1 = *(long *)(*param_1 + 0x38);
if (lVar1 == *(long *)(*param_1 + 0x40)) {
local_1d8 = 0;
local_1d0 = &DAT_00129356;
}
else {
local_1d8 = *(int8 *)(lVar1 + 0x30);
local_1d0 = *(int **)(lVar1 + 0x38);
}
local_1c8 = CONCAT44(*(int4 *)(param_2 + 0x20),*(int4 *)(param_2 + 0x18));
local_1c0 = 0;
local_1b8 = &DAT_00129356;
local_1b0 = 0;
/* try { // try from 001143e5 to 001143ec has its CatchHandler @ 00114477 */
std::__cxx11::stringbuf::str();
/* try { // try from 001143fd to 0011440e has its CatchHandler @ 00114457 */
common::ErrorCollector::addError(param_1 + 0x19,8,local_1f0,local_1f8,&local_1d8);
if (local_1f8 != local_1e8) {
operator_delete(local_1f8,local_1e8[0] + 1);
}
std::__cxx11::stringstream::~stringstream(local_1a8);
std::ios_base::~ios_base(local_128);
}
return;
}
|
|
60,004
|
ma_apply_redo_bitmap_new_page
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_apply_redo_bitmap_new_page(MARIA_HA *info,
LSN lsn __attribute__ ((unused)),
const uchar *header)
{
MARIA_SHARE *share= info->s;
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
my_bool error;
pgcache_page_no_t from, to, min_from;
DBUG_ENTER("_ma_apply_redo_bitmap_new_page");
from= page_korr(header);
to= page_korr(header + PAGE_STORE_SIZE);
DBUG_PRINT("info", ("from: %lu to: %lu", (ulong)from, (ulong)to));
if ((from > to) ||
(from % bitmap->pages_covered) != 0 ||
(to % bitmap->pages_covered) != 0)
{
error= TRUE; /* corrupted log record */
goto err;
}
min_from= (share->state.state.data_file_length / bitmap->block_size - 1) /
bitmap->pages_covered + 1;
min_from*= bitmap->pages_covered;
if (from < min_from)
{
DBUG_PRINT("info", ("overwrite bitmap pages from %lu", (ulong)min_from));
/*
We have to overwrite. It could be that there was a bitmap page in
memory, covering a data page which went to disk, then crash: the
bitmap page is now full of zeros and is ==min_from, we have to overwrite
it with correct checksum.
*/
}
share->state.changed|= STATE_CHANGED;
bzero(info->buff, bitmap->block_size);
if (!(error=
_ma_bitmap_create_missing_into_pagecache(share, bitmap, from, to,
info->buff)))
share->state.state.data_file_length= (to + 1) * bitmap->block_size;
err:
DBUG_RETURN(error);
}
|
O3
|
c
|
ma_apply_redo_bitmap_new_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl (%rdx), %eax
movl 0x5(%rdx), %ecx
movzbl 0x4(%rdx), %r12d
shlq $0x20, %r12
orq %rax, %r12
movzbl 0x9(%rdx), %r14d
shlq $0x20, %r14
orq %rcx, %r14
movb $0x1, %bl
cmpq %r14, %r12
ja 0x54c61
movq %rdi, %r13
movq (%rdi), %r15
movq 0xb48(%r15), %rcx
movq %r12, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x54c61
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
jne 0x54c61
orb $0x1, 0x170(%r15)
leaq 0xa10(%r15), %rax
movq %rax, -0x30(%rbp)
movq 0x378(%r13), %rdi
movl 0xb44(%r15), %edx
xorl %esi, %esi
callq 0x292a0
movq 0x378(%r13), %r8
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x54c72
testb %al, %al
jne 0x54c61
incq %r14
movl 0xb44(%r15), %eax
imulq %r14, %rax
movq %rax, 0x40(%r15)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_apply_redo_bitmap_new_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov eax, [rdx]
mov ecx, [rdx+5]
movzx r12d, byte ptr [rdx+4]
shl r12, 20h
or r12, rax
movzx r14d, byte ptr [rdx+9]
shl r14, 20h
or r14, rcx
mov bl, 1
cmp r12, r14
ja loc_54C61
mov r13, rdi
mov r15, [rdi]
mov rcx, [r15+0B48h]
mov rax, r12
xor edx, edx
div rcx
test rdx, rdx
jnz short loc_54C61
mov rax, r14
xor edx, edx
div rcx
test rdx, rdx
jnz short loc_54C61
or byte ptr [r15+170h], 1
lea rax, [r15+0A10h]
mov [rbp+var_30], rax
mov rdi, [r13+378h]
mov edx, [r15+0B44h]
xor esi, esi
call _memset
mov r8, [r13+378h]
mov rdi, r15
mov rsi, [rbp+var_30]
mov rdx, r12
mov rcx, r14
call _ma_bitmap_create_missing_into_pagecache
test al, al
jnz short loc_54C61
inc r14
mov eax, [r15+0B44h]
imul rax, r14
mov [r15+40h], rax
xor ebx, ebx
loc_54C61:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_apply_redo_bitmap_new_page(_QWORD *a1, long long a2, unsigned int *a3)
{
unsigned int v3; // ebx
unsigned long long v4; // r12
unsigned long long v5; // r14
long long v6; // r15
unsigned long long v7; // rcx
v4 = *a3 | ((unsigned long long)*((unsigned __int8 *)a3 + 4) << 32);
v5 = *(unsigned int *)((char *)a3 + 5) | ((unsigned long long)*((unsigned __int8 *)a3 + 9) << 32);
LOBYTE(v3) = 1;
if ( v4 <= v5 )
{
v6 = *a1;
v7 = *(_QWORD *)(*a1 + 2888LL);
if ( !(v4 % v7) && !(v5 % v7) )
{
*(_BYTE *)(v6 + 368) |= 1u;
memset(a1[111], 0LL, *(unsigned int *)(v6 + 2884));
if ( !(unsigned __int8)ma_bitmap_create_missing_into_pagecache(v6, v6 + 2576, v4, v5, a1[111]) )
{
*(_QWORD *)(v6 + 64) = (v5 + 1) * *(unsigned int *)(v6 + 2884);
return 0;
}
}
}
return v3;
}
|
_ma_apply_redo_bitmap_new_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EAX,dword ptr [RDX]
MOV ECX,dword ptr [RDX + 0x5]
MOVZX R12D,byte ptr [RDX + 0x4]
SHL R12,0x20
OR R12,RAX
MOVZX R14D,byte ptr [RDX + 0x9]
SHL R14,0x20
OR R14,RCX
MOV BL,0x1
CMP R12,R14
JA 0x00154c61
MOV R13,RDI
MOV R15,qword ptr [RDI]
MOV RCX,qword ptr [R15 + 0xb48]
MOV RAX,R12
XOR EDX,EDX
DIV RCX
TEST RDX,RDX
JNZ 0x00154c61
MOV RAX,R14
XOR EDX,EDX
DIV RCX
TEST RDX,RDX
JNZ 0x00154c61
OR byte ptr [R15 + 0x170],0x1
LEA RAX,[R15 + 0xa10]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [R13 + 0x378]
MOV EDX,dword ptr [R15 + 0xb44]
XOR ESI,ESI
CALL 0x001292a0
MOV R8,qword ptr [R13 + 0x378]
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R12
MOV RCX,R14
CALL 0x00154c72
TEST AL,AL
JNZ 0x00154c61
INC R14
MOV EAX,dword ptr [R15 + 0xb44]
IMUL RAX,R14
MOV qword ptr [R15 + 0x40],RAX
XOR EBX,EBX
LAB_00154c61:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _ma_apply_redo_bitmap_new_page(long *param_1,int8 param_2,uint5 *param_3)
{
long lVar1;
char cVar2;
int8 unaff_RBX;
ulong uVar3;
ulong uVar4;
ulong uVar5;
uVar4 = (ulong)*param_3;
uVar5 = (ulong)*(uint5 *)((long)param_3 + 5);
uVar3 = CONCAT71((int7)((ulong)unaff_RBX >> 8),1);
if (uVar4 <= uVar5) {
lVar1 = *param_1;
if ((uVar4 % *(ulong *)(lVar1 + 0xb48) == 0) && (uVar5 % *(ulong *)(lVar1 + 0xb48) == 0)) {
*(byte *)(lVar1 + 0x170) = *(byte *)(lVar1 + 0x170) | 1;
memset((void *)param_1[0x6f],0,(ulong)*(uint *)(lVar1 + 0xb44));
cVar2 = _ma_bitmap_create_missing_into_pagecache
(lVar1,lVar1 + 0xa10,uVar4,uVar5,param_1[0x6f]);
if (cVar2 == '\0') {
*(ulong *)(lVar1 + 0x40) = (ulong)*(uint *)(lVar1 + 0xb44) * (uVar5 + 1);
uVar3 = 0;
}
}
}
return uVar3 & 0xffffffff;
}
|
|
60,005
|
stbi_load_16_from_memory
|
llama.cpp/examples/llava/../../common/stb_image.h
|
STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
}
|
O3
|
c
|
stbi_load_16_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x21316
addq $0xe8, %rsp
retq
|
stbi_load_16_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
mov qword ptr [rax+10h], 0
xor r10d, r10d
mov [rax+30h], r10d
mov [rax+0B8h], r10d
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rsi, esi
add rsi, rdi
mov [rax+0D8h], rsi
mov [rax+0C8h], rsi
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8d, r9d
call _ZL32stbi__load_and_postprocess_16bitP13stbi__contextPiS1_S1_i; stbi__load_and_postprocess_16bit(stbi__context *,int *,int *,int *,int)
add rsp, 0E8h
retn
|
_WORD * stbi_load_16_from_memory(long long a1, int a2, int *a3, int *a4, int *a5, unsigned int a6)
{
_BYTE v7[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v8; // [rsp+18h] [rbp-D0h]
int v9; // [rsp+38h] [rbp-B0h]
int v10; // [rsp+C0h] [rbp-28h]
long long v11; // [rsp+C8h] [rbp-20h]
long long v12; // [rsp+D0h] [rbp-18h]
long long v13; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v8 = 0LL;
v9 = 0;
v10 = 0;
v13 = a1;
v11 = a1;
v14 = a1 + a2;
v12 = v14;
return stbi__load_and_postprocess_16bit((long long)v7, a3, a4, a5, a6);
}
|
stbi_load_16_from_memory:
SUB RSP,0xe8
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x10],0x0
XOR R10D,R10D
MOV dword ptr [RAX + 0x30],R10D
MOV dword ptr [RAX + 0xb8],R10D
MOV qword ptr [RAX + 0xd0],RDI
MOV qword ptr [RAX + 0xc0],RDI
MOVSXD RSI,ESI
ADD RSI,RDI
MOV qword ptr [RAX + 0xd8],RSI
MOV qword ptr [RAX + 0xc8],RSI
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8D,R9D
CALL 0x00121316
ADD RSP,0xe8
RET
|
void stbi_load_16_from_memory
(long param_1,int param_2,int *param_3,int *param_4,int *param_5,int param_6)
{
stbi__context local_e0 [16];
int8 local_d0;
int4 local_b0;
int4 local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_d0 = 0;
local_b0 = 0;
local_28 = 0;
local_18 = param_2 + param_1;
local_20 = param_1;
local_10 = param_1;
local_8 = local_18;
stbi__load_and_postprocess_16bit(local_e0,param_3,param_4,param_5,param_6);
return;
}
|
|
60,006
|
decode_bytes
|
eloqsql/storage/myisam/mi_packrec.c
|
static void decode_bytes(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
reg1 uint bits,low_byte;
reg3 uint16 *pos;
reg4 uint table_bits,table_and;
MI_DECODE_TREE *decode_tree;
decode_tree=rec->huff_tree;
bits=bit_buff->bits; /* Save in reg for quicker access */
table_bits=decode_tree->quick_table_bits;
table_and= (1 << table_bits)-1;
do
{
if (bits < table_bits)
{
if (bit_buff->pos > bit_buff->end+1)
{
bit_buff->error=1;
return; /* Can't be right */
}
#if BITS_SAVED == 32
bit_buff->current_byte= (bit_buff->current_byte << 24) |
(((uint) ((uchar) bit_buff->pos[2]))) |
(((uint) ((uchar) bit_buff->pos[1])) << 8) |
(((uint) ((uchar) bit_buff->pos[0])) << 16);
bit_buff->pos+=3;
bits+=24;
#else
if (bits) /* We must have at leasts 9 bits */
{
bit_buff->current_byte= (bit_buff->current_byte << 8) |
(uint) ((uchar) bit_buff->pos[0]);
bit_buff->pos++;
bits+=8;
}
else
{
bit_buff->current_byte= ((uint) ((uchar) bit_buff->pos[0]) << 8) |
((uint) ((uchar) bit_buff->pos[1]));
bit_buff->pos+=2;
bits+=16;
}
#endif
}
/* First use info in quick_table */
low_byte=(bit_buff->current_byte >> (bits - table_bits)) & table_and;
low_byte=decode_tree->table[low_byte];
if (low_byte & IS_CHAR)
{
*to++ = (low_byte & 255); /* Found char in quick table */
bits-= ((low_byte >> 8) & 31); /* Remove bits used */
}
else
{ /* Map through rest of decode-table */
pos=decode_tree->table+low_byte;
bits-=table_bits;
for (;;)
{
if (bits < 8)
{ /* We don't need to check end */
#if BITS_SAVED == 32
bit_buff->current_byte= (bit_buff->current_byte << 24) |
(((uint) ((uchar) bit_buff->pos[2]))) |
(((uint) ((uchar) bit_buff->pos[1])) << 8) |
(((uint) ((uchar) bit_buff->pos[0])) << 16);
bit_buff->pos+=3;
bits+=24;
#else
bit_buff->current_byte= (bit_buff->current_byte << 8) |
(uint) ((uchar) bit_buff->pos[0]);
bit_buff->pos+=1;
bits+=8;
#endif
}
low_byte=(uint) (bit_buff->current_byte >> (bits-8));
decode_bytes_test_bit(0);
decode_bytes_test_bit(1);
decode_bytes_test_bit(2);
decode_bytes_test_bit(3);
decode_bytes_test_bit(4);
decode_bytes_test_bit(5);
decode_bytes_test_bit(6);
decode_bytes_test_bit(7);
bits-=8;
}
*to++ = (uchar) *pos;
}
} while (to != end);
bit_buff->bits=bits;
return;
}
|
O3
|
c
|
decode_bytes:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rax
movq 0x28(%rdi), %r8
movl 0x4(%rsi), %ebx
movl 0x8(%r8), %edi
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
movl %edi, %ecx
shll %cl, %r9d
notl %r9d
cmpl %edi, %ebx
jae 0x82d0b
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %r10
incq %r10
cmpq %r10, %rcx
ja 0x82eaa
movl (%rsi), %r10d
shll $0x18, %r10d
movzbl 0x2(%rcx), %r11d
orl %r10d, %r11d
movzbl 0x1(%rcx), %r14d
shll $0x8, %r14d
orl %r11d, %r14d
movzbl (%rcx), %r10d
shll $0x10, %r10d
orl %r14d, %r10d
movl %r10d, (%rsi)
addq $0x3, %rcx
movq %rcx, 0x8(%rsi)
addl $0x18, %ebx
jmp 0x82d0e
movl (%rsi), %r10d
movl %ebx, %ecx
subl %edi, %ecx
movl %r10d, %r11d
shrl %cl, %r11d
andl %r9d, %r11d
movq (%r8), %r14
movzwl (%r14,%r11,2), %r11d
testw %r11w, %r11w
js 0x82e61
cmpl $0x7, %ecx
ja 0x82d67
shll $0x18, %r10d
movq 0x8(%rsi), %rbx
movzbl 0x2(%rbx), %r15d
orl %r10d, %r15d
movzbl 0x1(%rbx), %r12d
shll $0x8, %r12d
orl %r15d, %r12d
movzbl (%rbx), %r10d
shll $0x10, %r10d
orl %r12d, %r10d
movl %r10d, (%rsi)
addq $0x3, %rbx
movq %rbx, 0x8(%rsi)
orl $0x18, %ecx
movl %ecx, %ebx
movzwl %r11w, %ecx
leaq (%r14,%rcx,2), %r15
leal -0x8(%rbx), %ecx
movl %r10d, %r14d
shrl %cl, %r14d
movl %r14d, %r12d
shrl $0x6, %r12d
andl $0x2, %r12d
movswq (%r15,%r12), %r11
testq %r11, %r11
js 0x82e72
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
shrl $0x5, %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e76
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
shrl $0x4, %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e7b
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
shrl $0x3, %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e80
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
shrl $0x2, %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e85
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
shrl %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e8a
addq %r12, %r15
leaq (%r15,%r11,2), %r15
movl %r14d, %r12d
andl $0x2, %r12d
movswq (%r12,%r15), %r11
testq %r11, %r11
js 0x82e8f
addq %r12, %r15
leaq (%r15,%r11,2), %r11
andl $0x1, %r14d
leaq (%r11,%r14,2), %r14
movzwl (%r14), %r11d
testw %r11w, %r11w
jns 0x82d2d
jmp 0x82e94
movzwl %r11w, %ecx
movb %r11b, (%rdx)
shrl $0x8, %ecx
andl $0x1f, %ecx
subl %ecx, %ebx
jmp 0x82e99
decl %ebx
jmp 0x82e92
addl $-0x2, %ebx
jmp 0x82e92
addl $-0x3, %ebx
jmp 0x82e92
addl $-0x4, %ebx
jmp 0x82e92
addl $-0x5, %ebx
jmp 0x82e92
addl $-0x6, %ebx
jmp 0x82e92
addl $-0x7, %ebx
movl %ebx, %ecx
movb %r11b, (%rdx)
movl %ecx, %ebx
incq %rdx
cmpq %rax, %rdx
jne 0x82cbd
movl %ebx, 0x4(%rsi)
jmp 0x82eb1
movl $0x1, 0x28(%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
decode_bytes_0:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rax, rcx
mov r8, [rdi+28h]
mov ebx, [rsi+4]
mov edi, [r8+8]
mov r9d, 0FFFFFFFFh
mov ecx, edi
shl r9d, cl
not r9d
loc_82CBD:
cmp ebx, edi
jnb short loc_82D0B
mov rcx, [rsi+8]
mov r10, [rsi+10h]
inc r10
cmp rcx, r10
ja loc_82EAA
mov r10d, [rsi]
shl r10d, 18h
movzx r11d, byte ptr [rcx+2]
or r11d, r10d
movzx r14d, byte ptr [rcx+1]
shl r14d, 8
or r14d, r11d
movzx r10d, byte ptr [rcx]
shl r10d, 10h
or r10d, r14d
mov [rsi], r10d
add rcx, 3
mov [rsi+8], rcx
add ebx, 18h
jmp short loc_82D0E
loc_82D0B:
mov r10d, [rsi]
loc_82D0E:
mov ecx, ebx
sub ecx, edi
mov r11d, r10d
shr r11d, cl
and r11d, r9d
mov r14, [r8]
movzx r11d, word ptr [r14+r11*2]
test r11w, r11w
js loc_82E61
loc_82D2D:
cmp ecx, 7
ja short loc_82D67
shl r10d, 18h
mov rbx, [rsi+8]
movzx r15d, byte ptr [rbx+2]
or r15d, r10d
movzx r12d, byte ptr [rbx+1]
shl r12d, 8
or r12d, r15d
movzx r10d, byte ptr [rbx]
shl r10d, 10h
or r10d, r12d
mov [rsi], r10d
add rbx, 3
mov [rsi+8], rbx
or ecx, 18h
loc_82D67:
mov ebx, ecx
movzx ecx, r11w
lea r15, [r14+rcx*2]
lea ecx, [rbx-8]
mov r14d, r10d
shr r14d, cl
mov r12d, r14d
shr r12d, 6
and r12d, 2
movsx r11, word ptr [r15+r12]
test r11, r11
js loc_82E72
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
shr r12d, 5
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js loc_82E76
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
shr r12d, 4
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js loc_82E7B
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
shr r12d, 3
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js loc_82E80
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
shr r12d, 2
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js short loc_82E85
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
shr r12d, 1
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js short loc_82E8A
add r15, r12
lea r15, [r15+r11*2]
mov r12d, r14d
and r12d, 2
movsx r11, word ptr [r12+r15]
test r11, r11
js short loc_82E8F
add r15, r12
lea r11, [r15+r11*2]
and r14d, 1
lea r14, [r11+r14*2]
movzx r11d, word ptr [r14]
test r11w, r11w
jns loc_82D2D
jmp short loc_82E94
loc_82E61:
movzx ecx, r11w
mov [rdx], r11b
shr ecx, 8
and ecx, 1Fh
sub ebx, ecx
jmp short loc_82E99
loc_82E72:
dec ebx
jmp short loc_82E92
loc_82E76:
add ebx, 0FFFFFFFEh
jmp short loc_82E92
loc_82E7B:
add ebx, 0FFFFFFFDh
jmp short loc_82E92
loc_82E80:
add ebx, 0FFFFFFFCh
jmp short loc_82E92
loc_82E85:
add ebx, 0FFFFFFFBh
jmp short loc_82E92
loc_82E8A:
add ebx, 0FFFFFFFAh
jmp short loc_82E92
loc_82E8F:
add ebx, 0FFFFFFF9h
loc_82E92:
mov ecx, ebx
loc_82E94:
mov [rdx], r11b
mov ebx, ecx
loc_82E99:
inc rdx
cmp rdx, rax
jnz loc_82CBD
mov [rsi+4], ebx
jmp short loc_82EB1
loc_82EAA:
mov dword ptr [rsi+28h], 1
loc_82EB1:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
_BYTE * decode_bytes_0(long long a1, long long a2, _BYTE *a3, _BYTE *a4)
{
_BYTE *result; // rax
long long v5; // r8
unsigned int v6; // ebx
unsigned int v7; // edi
unsigned __int8 *v8; // rcx
unsigned int v9; // r10d
unsigned int v10; // ecx
_WORD *v11; // r14
long long v12; // r11
unsigned __int8 *v13; // rbx
unsigned int v14; // ebx
_WORD *v15; // r15
unsigned int v16; // r14d
long long v17; // r12
long long v18; // r15
long long v19; // r12
long long v20; // r15
long long v21; // r12
long long v22; // r15
long long v23; // r12
long long v24; // r15
long long v25; // r12
long long v26; // r15
long long v27; // r12
long long v28; // r15
long long v29; // r12
unsigned int v30; // ebx
result = a4;
v5 = *(_QWORD *)(a1 + 40);
v6 = *(_DWORD *)(a2 + 4);
v7 = *(_DWORD *)(v5 + 8);
while ( 1 )
{
if ( v6 >= v7 )
{
v9 = *(_DWORD *)a2;
goto LABEL_6;
}
v8 = *(unsigned __int8 **)(a2 + 8);
if ( (unsigned long long)v8 > *(_QWORD *)(a2 + 16) + 1LL )
break;
v9 = (*(_DWORD *)a2 << 24) | v8[2] | (v8[1] << 8) | (*v8 << 16);
*(_DWORD *)a2 = v9;
*(_QWORD *)(a2 + 8) = v8 + 3;
v6 += 24;
LABEL_6:
v10 = v6 - v7;
v11 = *(_WORD **)v5;
LOWORD(v12) = *(_WORD *)(*(_QWORD *)v5 + 2LL * (~(-1 << v7) & (v9 >> (v6 - v7))));
if ( (v12 & 0x8000u) != 0LL )
{
*a3 = v12;
v6 -= BYTE1(v12) & 0x1F;
}
else
{
while ( 1 )
{
if ( v10 <= 7 )
{
v13 = *(unsigned __int8 **)(a2 + 8);
v9 = (v9 << 24) | v13[2] | (v13[1] << 8) | (*v13 << 16);
*(_DWORD *)a2 = v9;
*(_QWORD *)(a2 + 8) = v13 + 3;
v10 |= 0x18u;
}
v14 = v10;
v15 = &v11[(unsigned __int16)v12];
v10 -= 8;
v16 = v9 >> v10;
v17 = (v9 >> v10 >> 6) & 2;
v12 = *(__int16 *)((char *)v15 + v17);
if ( v12 < 0 )
{
v30 = v14 - 1;
goto LABEL_26;
}
v18 = (long long)&v15[v12] + v17;
v19 = (v16 >> 5) & 2;
v12 = *(__int16 *)(v19 + v18);
if ( v12 < 0 )
{
v30 = v14 - 2;
goto LABEL_26;
}
v20 = v19 + v18 + 2 * v12;
v21 = (v16 >> 4) & 2;
v12 = *(__int16 *)(v21 + v20);
if ( v12 < 0 )
{
v30 = v14 - 3;
goto LABEL_26;
}
v22 = v21 + v20 + 2 * v12;
v23 = (v16 >> 3) & 2;
v12 = *(__int16 *)(v23 + v22);
if ( v12 < 0 )
{
v30 = v14 - 4;
goto LABEL_26;
}
v24 = v23 + v22 + 2 * v12;
v25 = (v16 >> 2) & 2;
v12 = *(__int16 *)(v25 + v24);
if ( v12 < 0 )
{
v30 = v14 - 5;
goto LABEL_26;
}
v26 = v25 + v24 + 2 * v12;
v27 = (v16 >> 1) & 2;
v12 = *(__int16 *)(v27 + v26);
if ( v12 < 0 )
{
v30 = v14 - 6;
goto LABEL_26;
}
v28 = v27 + v26 + 2 * v12;
v29 = v16 & 2;
v12 = *(__int16 *)(v29 + v28);
if ( v12 < 0 )
break;
v11 = (_WORD *)(v29 + v28 + 2 * v12 + 2LL * (v16 & 1));
LOWORD(v12) = *v11;
if ( (__int16)*v11 < 0 )
goto LABEL_27;
}
v30 = v14 - 7;
LABEL_26:
v10 = v30;
LABEL_27:
*a3 = v12;
v6 = v10;
}
if ( ++a3 == result )
{
*(_DWORD *)(a2 + 4) = v6;
return result;
}
}
*(_DWORD *)(a2 + 40) = 1;
return result;
}
|
decode_bytes:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RAX,RCX
MOV R8,qword ptr [RDI + 0x28]
MOV EBX,dword ptr [RSI + 0x4]
MOV EDI,dword ptr [R8 + 0x8]
MOV R9D,0xffffffff
MOV ECX,EDI
SHL R9D,CL
NOT R9D
LAB_00182cbd:
CMP EBX,EDI
JNC 0x00182d0b
MOV RCX,qword ptr [RSI + 0x8]
MOV R10,qword ptr [RSI + 0x10]
INC R10
CMP RCX,R10
JA 0x00182eaa
MOV R10D,dword ptr [RSI]
SHL R10D,0x18
MOVZX R11D,byte ptr [RCX + 0x2]
OR R11D,R10D
MOVZX R14D,byte ptr [RCX + 0x1]
SHL R14D,0x8
OR R14D,R11D
MOVZX R10D,byte ptr [RCX]
SHL R10D,0x10
OR R10D,R14D
MOV dword ptr [RSI],R10D
ADD RCX,0x3
MOV qword ptr [RSI + 0x8],RCX
ADD EBX,0x18
JMP 0x00182d0e
LAB_00182d0b:
MOV R10D,dword ptr [RSI]
LAB_00182d0e:
MOV ECX,EBX
SUB ECX,EDI
MOV R11D,R10D
SHR R11D,CL
AND R11D,R9D
MOV R14,qword ptr [R8]
MOVZX R11D,word ptr [R14 + R11*0x2]
TEST R11W,R11W
JS 0x00182e61
LAB_00182d2d:
CMP ECX,0x7
JA 0x00182d67
SHL R10D,0x18
MOV RBX,qword ptr [RSI + 0x8]
MOVZX R15D,byte ptr [RBX + 0x2]
OR R15D,R10D
MOVZX R12D,byte ptr [RBX + 0x1]
SHL R12D,0x8
OR R12D,R15D
MOVZX R10D,byte ptr [RBX]
SHL R10D,0x10
OR R10D,R12D
MOV dword ptr [RSI],R10D
ADD RBX,0x3
MOV qword ptr [RSI + 0x8],RBX
OR ECX,0x18
LAB_00182d67:
MOV EBX,ECX
MOVZX ECX,R11W
LEA R15,[R14 + RCX*0x2]
LEA ECX,[RBX + -0x8]
MOV R14D,R10D
SHR R14D,CL
MOV R12D,R14D
SHR R12D,0x6
AND R12D,0x2
MOVSX R11,word ptr [R15 + R12*0x1]
TEST R11,R11
JS 0x00182e72
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
SHR R12D,0x5
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e76
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
SHR R12D,0x4
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e7b
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
SHR R12D,0x3
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e80
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
SHR R12D,0x2
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e85
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
SHR R12D,0x1
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e8a
ADD R15,R12
LEA R15,[R15 + R11*0x2]
MOV R12D,R14D
AND R12D,0x2
MOVSX R11,word ptr [R12 + R15*0x1]
TEST R11,R11
JS 0x00182e8f
ADD R15,R12
LEA R11,[R15 + R11*0x2]
AND R14D,0x1
LEA R14,[R11 + R14*0x2]
MOVZX R11D,word ptr [R14]
TEST R11W,R11W
JNS 0x00182d2d
JMP 0x00182e94
LAB_00182e61:
MOVZX ECX,R11W
MOV byte ptr [RDX],R11B
SHR ECX,0x8
AND ECX,0x1f
SUB EBX,ECX
JMP 0x00182e99
LAB_00182e72:
DEC EBX
JMP 0x00182e92
LAB_00182e76:
ADD EBX,-0x2
JMP 0x00182e92
LAB_00182e7b:
ADD EBX,-0x3
JMP 0x00182e92
LAB_00182e80:
ADD EBX,-0x4
JMP 0x00182e92
LAB_00182e85:
ADD EBX,-0x5
JMP 0x00182e92
LAB_00182e8a:
ADD EBX,-0x6
JMP 0x00182e92
LAB_00182e8f:
ADD EBX,-0x7
LAB_00182e92:
MOV ECX,EBX
LAB_00182e94:
MOV byte ptr [RDX],R11B
MOV EBX,ECX
LAB_00182e99:
INC RDX
CMP RDX,RAX
JNZ 0x00182cbd
MOV dword ptr [RSI + 0x4],EBX
JMP 0x00182eb1
LAB_00182eaa:
MOV dword ptr [RSI + 0x28],0x1
LAB_00182eb1:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void decode_bytes(long param_1,uint *param_2,int1 *param_3,int1 *param_4)
{
ushort uVar1;
uint uVar2;
int8 *puVar3;
byte *pbVar4;
long lVar5;
uint uVar6;
uint uVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
ulong uVar11;
uint uVar12;
ushort *puVar13;
puVar3 = *(int8 **)(param_1 + 0x28);
uVar7 = param_2[1];
uVar2 = *(uint *)(puVar3 + 1);
do {
if (uVar7 < uVar2) {
pbVar4 = *(byte **)(param_2 + 2);
if ((byte *)(*(long *)(param_2 + 4) + 1) < pbVar4) {
param_2[10] = 1;
return;
}
uVar8 = (uint)*pbVar4 << 0x10 | (uint)pbVar4[1] << 8 | (uint)pbVar4[2] | *param_2 << 0x18;
*param_2 = uVar8;
*(byte **)(param_2 + 2) = pbVar4 + 3;
uVar7 = uVar7 + 0x18;
}
else {
uVar8 = *param_2;
}
uVar6 = uVar7 - uVar2;
puVar13 = (ushort *)*puVar3;
uVar1 = puVar13[uVar8 >> ((byte)uVar6 & 0x1f) & ~(-1 << ((byte)uVar2 & 0x1f))];
uVar10 = (ulong)uVar1;
if ((short)uVar1 < 0) {
*param_3 = (char)uVar1;
uVar7 = uVar7 - (uVar1 >> 8 & 0x1f);
}
else {
do {
uVar7 = uVar6;
if (uVar6 < 8) {
pbVar4 = *(byte **)(param_2 + 2);
uVar8 = (uint)*pbVar4 << 0x10 | (uint)pbVar4[1] << 8 | (uint)pbVar4[2] | uVar8 << 0x18;
*param_2 = uVar8;
*(byte **)(param_2 + 2) = pbVar4 + 3;
uVar7 = uVar6 | 0x18;
}
uVar6 = uVar7 - 8;
uVar12 = uVar8 >> ((byte)uVar6 & 0x1f);
uVar11 = (ulong)(uVar12 >> 6 & 2);
uVar9 = (ulong)*(short *)((long)puVar13 + uVar11 + uVar10 * 2);
if ((long)uVar9 < 0) {
uVar10 = uVar9;
uVar7 = uVar7 - 1;
break;
}
lVar5 = uVar9 * 2 + uVar11 + uVar10 * 2;
uVar9 = (ulong)(uVar12 >> 5 & 2);
uVar10 = (ulong)*(short *)((long)puVar13 + uVar9 + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 2;
break;
}
lVar5 = uVar10 * 2 + uVar9 + lVar5;
uVar9 = (ulong)(uVar12 >> 4 & 2);
uVar10 = (ulong)*(short *)((long)puVar13 + uVar9 + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 3;
break;
}
lVar5 = uVar10 * 2 + uVar9 + lVar5;
uVar9 = (ulong)(uVar12 >> 3 & 2);
uVar10 = (ulong)*(short *)((long)puVar13 + uVar9 + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 4;
break;
}
lVar5 = uVar10 * 2 + uVar9 + lVar5;
uVar9 = (ulong)(uVar12 >> 2 & 2);
uVar10 = (ulong)*(short *)((long)puVar13 + uVar9 + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 5;
break;
}
lVar5 = uVar10 * 2 + uVar9 + lVar5;
uVar9 = (ulong)(uVar12 >> 1 & 2);
uVar10 = (ulong)*(short *)((long)puVar13 + uVar9 + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 6;
break;
}
lVar5 = uVar10 * 2 + uVar9 + lVar5;
uVar10 = (ulong)*(short *)((long)puVar13 + (ulong)(uVar12 & 2) + lVar5);
if ((long)uVar10 < 0) {
uVar7 = uVar7 - 7;
break;
}
puVar13 = (ushort *)
((long)puVar13 +
(ulong)(uVar12 & 1) * 2 + uVar10 * 2 + (ulong)(uVar12 & 2) + lVar5);
uVar10 = (ulong)*puVar13;
uVar7 = uVar6;
} while (-1 < (short)*puVar13);
*param_3 = (char)uVar10;
}
param_3 = param_3 + 1;
if (param_3 == param_4) {
param_2[1] = uVar7;
return;
}
} while( true );
}
|
|
60,007
|
pvio_socket_keepalive
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
int pvio_socket_keepalive(MARIADB_PVIO *pvio)
{
int opt= 1;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
return setsockopt(csock->socket, SOL_SOCKET, SO_KEEPALIVE,
#ifndef _WIN32
(const void *)&opt, sizeof(opt));
#else
(char *)&opt, (int)sizeof(opt));
#endif
}
|
O0
|
c
|
pvio_socket_keepalive:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4223c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x42245
movl $0x1, -0x4(%rbp)
jmp 0x42272
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x1, %esi
movl $0x9, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
callq 0x13770
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
pvio_socket_keepalive:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], 1
mov [rbp+var_20], 0
cmp [rbp+var_10], 0
jz short loc_4223C
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_42245
loc_4223C:
mov [rbp+var_4], 1
jmp short loc_42272
loc_42245:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov edi, [rax]
mov esi, 1
mov edx, 9
lea rcx, [rbp+var_14]
mov r8d, 4
call _setsockopt
mov [rbp+var_4], eax
loc_42272:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long pvio_socket_keepalive(_QWORD *a1)
{
int v2; // [rsp+Ch] [rbp-14h] BYREF
_QWORD *v3; // [rsp+10h] [rbp-10h]
v3 = a1;
v2 = 1;
if ( a1 && *v3 )
return (unsigned int)setsockopt(*(unsigned int *)*v3, 1LL, 9LL, &v2, 4LL);
else
return 1;
}
|
pvio_socket_keepalive:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],0x1
MOV qword ptr [RBP + -0x20],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0014223c
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00142245
LAB_0014223c:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00142272
LAB_00142245:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX]
MOV ESI,0x1
MOV EDX,0x9
LEA RCX,[RBP + -0x14]
MOV R8D,0x4
CALL 0x00113770
MOV dword ptr [RBP + -0x4],EAX
LAB_00142272:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int pvio_socket_keepalive(long *param_1)
{
int4 local_1c;
long *local_18;
int local_c;
local_1c = 1;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 1;
}
else {
local_18 = param_1;
local_c = setsockopt(*(int *)*param_1,1,9,&local_1c,4);
}
return local_c;
}
|
|
60,008
|
maria_page_crc_set_normal
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= share->block_size - CRC_SIZE;
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_normal");
DBUG_PRINT("info", ("Page %lu crc: %lu", (ulong) page_no, (ulong)crc));
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + data_length, crc);
DBUG_RETURN(0);
}
|
O3
|
c
|
maria_page_crc_set_normal:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rbx
movl 0x8(%rdi), %eax
movq 0x10(%rdi), %rcx
movl 0x7bc(%rcx), %r14d
addl $-0x4, %r14d
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa95ec
cmpl $-0x3, %eax
movl $0xfffffffd, %ecx # imm = 0xFFFFFFFD
cmovbl %eax, %ecx
movslq %r14d, %rax
movl %ecx, (%rbx,%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
maria_page_crc_set_normal:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, [rdi]
mov eax, [rdi+8]
mov rcx, [rdi+10h]
mov r14d, [rcx+7BCh]
add r14d, 0FFFFFFFCh
mov edi, eax
mov rsi, rbx
mov rdx, r14
call my_checksum
cmp eax, 0FFFFFFFDh
mov ecx, 0FFFFFFFDh
cmovb ecx, eax
movsxd rax, r14d
mov [rbx+rax], ecx
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long maria_page_crc_set_normal(long long *a1)
{
long long v1; // rbx
int v2; // r14d
unsigned int v3; // eax
int v4; // ecx
v1 = *a1;
v2 = *(_DWORD *)(a1[2] + 1980) - 4;
v3 = my_checksum(*((unsigned int *)a1 + 2), *a1);
v4 = -3;
if ( v3 < 0xFFFFFFFD )
v4 = v3;
*(_DWORD *)(v1 + v2) = v4;
return 0LL;
}
|
maria_page_crc_set_normal:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,qword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x8]
MOV RCX,qword ptr [RDI + 0x10]
MOV R14D,dword ptr [RCX + 0x7bc]
ADD R14D,-0x4
MOV EDI,EAX
MOV RSI,RBX
MOV RDX,R14
CALL 0x001a95ec
CMP EAX,-0x3
MOV ECX,0xfffffffd
CMOVC ECX,EAX
MOVSXD RAX,R14D
MOV dword ptr [RBX + RAX*0x1],ECX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 maria_page_crc_set_normal(long *param_1)
{
long lVar1;
uint uVar2;
uint uVar3;
int iVar4;
lVar1 = *param_1;
iVar4 = *(int *)(param_1[2] + 0x7bc) + -4;
uVar2 = my_checksum((int)param_1[1],lVar1,iVar4);
uVar3 = 0xfffffffd;
if (uVar2 < 0xfffffffd) {
uVar3 = uVar2;
}
*(uint *)(lVar1 + iVar4) = uVar3;
return 0;
}
|
|
60,009
|
NumbersPanelImpl::updateViewport(ImVec2 const&)
|
LumonMDR/src/UI/Widgets/NumbersPanel.cpp
|
bool updateViewport(const ImVec2& windowSize)
{
static bool viewportInit = false;
bool viewportChanged = !viewportInit;
// Handle arrow key input
if (ImGui::IsKeyPressed(ImGuiKey_LeftArrow)) {
panelOffset.x += controlSettings.arrowSensitivity;
viewportChanged = true;
} else if (ImGui::IsKeyPressed(ImGuiKey_RightArrow)) {
panelOffset.x -= controlSettings.arrowSensitivity;
viewportChanged = true;
}
if (ImGui::IsKeyPressed(ImGuiKey_UpArrow)) {
panelOffset.y += controlSettings.arrowSensitivity;
viewportChanged = true;
} else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow)) {
panelOffset.y -= controlSettings.arrowSensitivity;
viewportChanged = true;
}
// Handle zoom
if (ImGui::IsKeyPressed(ImGuiKey_Comma)) {
panelScale -= controlSettings.zoomSensitivity;
viewportChanged = true;
} else if (ImGui::IsKeyPressed(ImGuiKey_Period)) {
panelScale += controlSettings.zoomSensitivity;
viewportChanged = true;
}
panelScale = std::clamp(panelScale, displaySettings.minZoomScale, displaySettings.maxZoomScale);
if (viewportChanged) {
// Clamp movement to within grid boundaries
float gridWidthScaled = gridSize * displaySettings.gridSpacing * panelScale;
float gridHeightScaled = gridSize * displaySettings.gridSpacing * panelScale;
float minOffsetX = -gridWidthScaled + windowSize.x;
float maxOffsetX = 0;
float minOffsetY = -gridHeightScaled + windowSize.y - displayPresets.numberWindowBufferTop;
float maxOffsetY = displayPresets.numberWindowBufferTop;
if (!viewportInit) {
// Start at center of grid
panelOffset.x = (windowSize.x - gridWidthScaled) / 2.0f / panelScale;
panelOffset.y = (windowSize.y - gridHeightScaled) / 2.0f / panelScale;
}
panelOffset.x = std::clamp(panelOffset.x, minOffsetX / panelScale, maxOffsetX / panelScale);
panelOffset.y = std::clamp(panelOffset.y, minOffsetY / panelScale, maxOffsetY / panelScale);
}
viewportInit = true;
return viewportChanged;
}
|
O3
|
cpp
|
NumbersPanelImpl::updateViewport(ImVec2 const&):
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0xc80e0(%rip), %bpl # 0xdc613
movl $0x201, %edi # imm = 0x201
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x14555
movss 0xb8(%rbx), %xmm0
addss 0x38(%rbx), %xmm0
jmp 0x14575
movl $0x202, %edi # imm = 0x202
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x1457f
movss 0x38(%rbx), %xmm0
subss 0xb8(%rbx), %xmm0
movss %xmm0, 0x38(%rbx)
movb $0x1, %bpl
jmp 0x14583
xorb $0x1, %bpl
movl $0x203, %edi # imm = 0x203
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x145a5
movss 0xb8(%rbx), %xmm0
addss 0x3c(%rbx), %xmm0
jmp 0x145c5
movl $0x204, %edi # imm = 0x204
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x145cd
movss 0x3c(%rbx), %xmm0
subss 0xb8(%rbx), %xmm0
movss %xmm0, 0x3c(%rbx)
movb $0x1, %bpl
movl $0x255, %edi # imm = 0x255
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x145ef
movss 0x40(%rbx), %xmm0
subss 0xbc(%rbx), %xmm0
jmp 0x1460f
movl $0x257, %edi # imm = 0x257
movl $0x1, %esi
callq 0x35a3d
testb %al, %al
je 0x14619
movss 0xbc(%rbx), %xmm0
addss 0x40(%rbx), %xmm0
movss %xmm0, 0x40(%rbx)
movb $0x1, %bpl
jmp 0x1461e
movss 0x40(%rbx), %xmm0
ucomiss 0x7c(%rbx), %xmm0
movl $0x7c, %eax
movl $0x40, %ecx
cmovaq %rax, %rcx
movss 0x80(%rbx), %xmm1
ucomiss %xmm0, %xmm1
movl $0x80, %eax
cmovbeq %rcx, %rax
movss (%rbx,%rax), %xmm0
movss %xmm0, 0x40(%rbx)
testb %bpl, %bpl
je 0x146d0
xorps %xmm1, %xmm1
cvtsi2ssl 0x8(%rbx), %xmm1
mulss 0x70(%rbx), %xmm1
mulss %xmm0, %xmm1
movsd (%r14), %xmm3
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
subps %xmm1, %xmm3
movss 0xc0(%rbx), %xmm4
movaps %xmm3, %xmm1
shufps $0x55, %xmm3, %xmm1 # xmm1 = xmm1[1,1],xmm3[1,1]
subss %xmm4, %xmm1
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
cmpb $0x0, 0xc7f85(%rip) # 0xdc613
jne 0x1469f
movaps 0x8ac59(%rip), %xmm2 # 0x9f2f0
mulps %xmm3, %xmm2
divps %xmm0, %xmm2
jmp 0x146a4
movsd 0x38(%rbx), %xmm2
movlhps %xmm3, %xmm1 # xmm1 = xmm1[0],xmm3[0]
shufps $0xe2, %xmm3, %xmm1 # xmm1 = xmm1[2,0],xmm3[2,3]
divps %xmm0, %xmm1
movq %xmm4, %xmm3 # xmm3 = xmm4[0],zero
xorps %xmm4, %xmm4
shufps $0xe2, %xmm4, %xmm3 # xmm3 = xmm3[2,0],xmm4[2,3]
divps %xmm0, %xmm3
minps %xmm2, %xmm3
cmpltps %xmm1, %xmm2
andps %xmm2, %xmm1
andnps %xmm3, %xmm2
orps %xmm1, %xmm2
movlps %xmm2, 0x38(%rbx)
movb $0x1, 0xc7f3c(%rip) # 0xdc613
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN16NumbersPanelImpl14updateViewportERK6ImVec2:
push rbp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov bpl, cs:_ZZN16NumbersPanelImpl14updateViewportERK6ImVec2E12viewportInit; NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit
mov edi, 201h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_14555
movss xmm0, dword ptr [rbx+0B8h]
addss xmm0, dword ptr [rbx+38h]
jmp short loc_14575
loc_14555:
mov edi, 202h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_1457F
movss xmm0, dword ptr [rbx+38h]
subss xmm0, dword ptr [rbx+0B8h]
loc_14575:
movss dword ptr [rbx+38h], xmm0
mov bpl, 1
jmp short loc_14583
loc_1457F:
xor bpl, 1
loc_14583:
mov edi, 203h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_145A5
movss xmm0, dword ptr [rbx+0B8h]
addss xmm0, dword ptr [rbx+3Ch]
jmp short loc_145C5
loc_145A5:
mov edi, 204h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_145CD
movss xmm0, dword ptr [rbx+3Ch]
subss xmm0, dword ptr [rbx+0B8h]
loc_145C5:
movss dword ptr [rbx+3Ch], xmm0
mov bpl, 1
loc_145CD:
mov edi, 255h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_145EF
movss xmm0, dword ptr [rbx+40h]
subss xmm0, dword ptr [rbx+0BCh]
jmp short loc_1460F
loc_145EF:
mov edi, 257h
mov esi, 1
call _ZN5ImGui12IsKeyPressedE8ImGuiKeyb; ImGui::IsKeyPressed(ImGuiKey,bool)
test al, al
jz short loc_14619
movss xmm0, dword ptr [rbx+0BCh]
addss xmm0, dword ptr [rbx+40h]
loc_1460F:
movss dword ptr [rbx+40h], xmm0
mov bpl, 1
jmp short loc_1461E
loc_14619:
movss xmm0, dword ptr [rbx+40h]
loc_1461E:
ucomiss xmm0, dword ptr [rbx+7Ch]
mov eax, 7Ch ; '|'
mov ecx, 40h ; '@'
cmova rcx, rax
movss xmm1, dword ptr [rbx+80h]
ucomiss xmm1, xmm0
mov eax, 80h
cmovbe rax, rcx
movss xmm0, dword ptr [rbx+rax]
movss dword ptr [rbx+40h], xmm0
test bpl, bpl
jz short loc_146D0
xorps xmm1, xmm1
cvtsi2ss xmm1, dword ptr [rbx+8]
mulss xmm1, dword ptr [rbx+70h]
mulss xmm1, xmm0
movsd xmm3, qword ptr [r14]
shufps xmm1, xmm1, 0
subps xmm3, xmm1
movss xmm4, dword ptr [rbx+0C0h]
movaps xmm1, xmm3
shufps xmm1, xmm3, 55h ; 'U'
subss xmm1, xmm4
shufps xmm0, xmm0, 0
cmp cs:_ZZN16NumbersPanelImpl14updateViewportERK6ImVec2E12viewportInit, 0; NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit
jnz short loc_1469F
movaps xmm2, cs:xmmword_9F2F0
mulps xmm2, xmm3
divps xmm2, xmm0
jmp short loc_146A4
loc_1469F:
movsd xmm2, qword ptr [rbx+38h]
loc_146A4:
movlhps xmm1, xmm3
shufps xmm1, xmm3, 0E2h
divps xmm1, xmm0
movq xmm3, xmm4
xorps xmm4, xmm4
shufps xmm3, xmm4, 0E2h
divps xmm3, xmm0
minps xmm3, xmm2
cmpltps xmm2, xmm1
andps xmm1, xmm2
andnps xmm2, xmm3
orps xmm2, xmm1
movlps qword ptr [rbx+38h], xmm2
loc_146D0:
mov cs:_ZZN16NumbersPanelImpl14updateViewportERK6ImVec2E12viewportInit, 1; NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit
mov eax, ebp
pop rbx
pop r14
pop rbp
retn
|
long long NumbersPanelImpl::updateViewport(long long a1, unsigned long long *a2)
{
unsigned int v2; // ebp
char v3; // bp
float v4; // xmm0_4
float v5; // xmm0_4
float v6; // xmm0_4
long long v7; // rcx
long long v8; // rax
__m128 v9; // xmm0
__m128 v10; // xmm1
__m128 v11; // xmm3
__m128i v12; // xmm4
__m128 v13; // xmm1
__m128 v14; // xmm0
__m128 v15; // xmm2
__m128 v16; // xmm1
__m128 v17; // xmm3
__m128 v18; // xmm2
v3 = NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit;
if ( (unsigned __int8)ImGui::IsKeyPressed(513LL, 1LL) )
{
v4 = *(float *)(a1 + 184) + *(float *)(a1 + 56);
LABEL_5:
*(float *)(a1 + 56) = v4;
LOBYTE(v2) = 1;
goto LABEL_7;
}
if ( (unsigned __int8)ImGui::IsKeyPressed(514LL, 1LL) )
{
v4 = *(float *)(a1 + 56) - *(float *)(a1 + 184);
goto LABEL_5;
}
LOBYTE(v2) = v3 ^ 1;
LABEL_7:
if ( (unsigned __int8)ImGui::IsKeyPressed(515LL, 1LL) )
{
v5 = *(float *)(a1 + 184) + *(float *)(a1 + 60);
}
else
{
if ( !(unsigned __int8)ImGui::IsKeyPressed(516LL, 1LL) )
goto LABEL_12;
v5 = *(float *)(a1 + 60) - *(float *)(a1 + 184);
}
*(float *)(a1 + 60) = v5;
LOBYTE(v2) = 1;
LABEL_12:
if ( (unsigned __int8)ImGui::IsKeyPressed(597LL, 1LL) )
{
v6 = *(float *)(a1 + 64) - *(float *)(a1 + 188);
LABEL_16:
*(float *)(a1 + 64) = v6;
LOBYTE(v2) = 1;
goto LABEL_18;
}
if ( (unsigned __int8)ImGui::IsKeyPressed(599LL, 1LL) )
{
v6 = *(float *)(a1 + 188) + *(float *)(a1 + 64);
goto LABEL_16;
}
v6 = *(float *)(a1 + 64);
LABEL_18:
v7 = 64LL;
if ( v6 > *(float *)(a1 + 124) )
v7 = 124LL;
v8 = 128LL;
if ( *(float *)(a1 + 128) <= v6 )
v8 = v7;
v9 = (__m128)*(unsigned int *)(a1 + v8);
*(_DWORD *)(a1 + 64) = v9.m128_i32[0];
if ( (_BYTE)v2 )
{
v10 = 0LL;
v10.m128_f32[0] = (float)((float)*(int *)(a1 + 8) * *(float *)(a1 + 112)) * v9.m128_f32[0];
v11 = _mm_sub_ps((__m128)*a2, _mm_shuffle_ps(v10, v10, 0));
v12 = (__m128i)*(unsigned int *)(a1 + 192);
v13 = _mm_shuffle_ps(v11, v11, 85);
v13.m128_f32[0] = v13.m128_f32[0] - *(float *)v12.m128i_i32;
v14 = _mm_shuffle_ps(v9, v9, 0);
if ( NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit )
v15 = (__m128)*(unsigned long long *)(a1 + 56);
else
v15 = _mm_div_ps(_mm_mul_ps((__m128)xmmword_9F2F0, v11), v14);
v16 = _mm_div_ps(_mm_shuffle_ps(_mm_movelh_ps(v13, v11), v11, 226), v14);
v17 = _mm_min_ps(_mm_div_ps(_mm_shuffle_ps((__m128)_mm_move_epi64(v12), (__m128)0LL, 226), v14), v15);
v18 = _mm_cmplt_ps(v15, v16);
_mm_storel_ps((double *)(a1 + 56), _mm_or_ps(_mm_andnot_ps(v18, v17), _mm_and_ps(v16, v18)));
}
NumbersPanelImpl::updateViewport(ImVec2 const&)::viewportInit = 1;
return v2;
}
|
updateViewport:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV BPL,byte ptr [0x001dc613]
MOV EDI,0x201
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x00114555
MOVSS XMM0,dword ptr [RBX + 0xb8]
ADDSS XMM0,dword ptr [RBX + 0x38]
JMP 0x00114575
LAB_00114555:
MOV EDI,0x202
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x0011457f
MOVSS XMM0,dword ptr [RBX + 0x38]
SUBSS XMM0,dword ptr [RBX + 0xb8]
LAB_00114575:
MOVSS dword ptr [RBX + 0x38],XMM0
MOV BPL,0x1
JMP 0x00114583
LAB_0011457f:
XOR BPL,0x1
LAB_00114583:
MOV EDI,0x203
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x001145a5
MOVSS XMM0,dword ptr [RBX + 0xb8]
ADDSS XMM0,dword ptr [RBX + 0x3c]
JMP 0x001145c5
LAB_001145a5:
MOV EDI,0x204
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x001145cd
MOVSS XMM0,dword ptr [RBX + 0x3c]
SUBSS XMM0,dword ptr [RBX + 0xb8]
LAB_001145c5:
MOVSS dword ptr [RBX + 0x3c],XMM0
MOV BPL,0x1
LAB_001145cd:
MOV EDI,0x255
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x001145ef
MOVSS XMM0,dword ptr [RBX + 0x40]
SUBSS XMM0,dword ptr [RBX + 0xbc]
JMP 0x0011460f
LAB_001145ef:
MOV EDI,0x257
MOV ESI,0x1
CALL 0x00135a3d
TEST AL,AL
JZ 0x00114619
MOVSS XMM0,dword ptr [RBX + 0xbc]
ADDSS XMM0,dword ptr [RBX + 0x40]
LAB_0011460f:
MOVSS dword ptr [RBX + 0x40],XMM0
MOV BPL,0x1
JMP 0x0011461e
LAB_00114619:
MOVSS XMM0,dword ptr [RBX + 0x40]
LAB_0011461e:
UCOMISS XMM0,dword ptr [RBX + 0x7c]
MOV EAX,0x7c
MOV ECX,0x40
CMOVA RCX,RAX
MOVSS XMM1,dword ptr [RBX + 0x80]
UCOMISS XMM1,XMM0
MOV EAX,0x80
CMOVBE RAX,RCX
MOVSS XMM0,dword ptr [RBX + RAX*0x1]
MOVSS dword ptr [RBX + 0x40],XMM0
TEST BPL,BPL
JZ 0x001146d0
XORPS XMM1,XMM1
CVTSI2SS XMM1,dword ptr [RBX + 0x8]
MULSS XMM1,dword ptr [RBX + 0x70]
MULSS XMM1,XMM0
MOVSD XMM3,qword ptr [R14]
SHUFPS XMM1,XMM1,0x0
SUBPS XMM3,XMM1
MOVSS XMM4,dword ptr [RBX + 0xc0]
MOVAPS XMM1,XMM3
SHUFPS XMM1,XMM3,0x55
SUBSS XMM1,XMM4
SHUFPS XMM0,XMM0,0x0
CMP byte ptr [0x001dc613],0x0
JNZ 0x0011469f
MOVAPS XMM2,xmmword ptr [0x0019f2f0]
MULPS XMM2,XMM3
DIVPS XMM2,XMM0
JMP 0x001146a4
LAB_0011469f:
MOVSD XMM2,qword ptr [RBX + 0x38]
LAB_001146a4:
MOVLHPS XMM1,XMM3
SHUFPS XMM1,XMM3,0xe2
DIVPS XMM1,XMM0
MOVQ XMM3,XMM4
XORPS XMM4,XMM4
SHUFPS XMM3,XMM4,0xe2
DIVPS XMM3,XMM0
MINPS XMM3,XMM2
CMPLTPS XMM2,XMM1
ANDPS XMM1,XMM2
ANDNPS XMM2,XMM3
ORPS XMM2,XMM1
MOVLPS qword ptr [RBX + 0x38],XMM2
LAB_001146d0:
MOV byte ptr [0x001dc613],0x1
MOV EAX,EBP
POP RBX
POP R14
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* NumbersPanelImpl::updateViewport(ImVec2 const&) */
int4 __thiscall NumbersPanelImpl::updateViewport(NumbersPanelImpl *this,ImVec2 *param_1)
{
int1 auVar1 [16];
int1 auVar2 [16];
char cVar3;
char cVar4;
long lVar5;
long lVar6;
int4 uVar7;
int8 unaff_RBP;
int7 uVar9;
ulong uVar8;
uint uVar10;
uint uVar11;
float fVar12;
float fVar13;
int1 auVar14 [16];
int1 auVar15 [16];
int1 auVar16 [16];
float fVar17;
float fVar19;
int1 auVar18 [16];
cVar4 = updateViewport(ImVec2_const&)::viewportInit;
uVar9 = (int7)((ulong)unaff_RBP >> 8);
cVar3 = ImGui::IsKeyPressed(0x201,1);
if (cVar3 == '\0') {
cVar3 = ImGui::IsKeyPressed(0x202,1);
if (cVar3 != '\0') {
fVar12 = *(float *)(this + 0x38) - *(float *)(this + 0xb8);
goto LAB_00114575;
}
uVar8 = CONCAT71(uVar9,cVar4) ^ 1;
}
else {
fVar12 = *(float *)(this + 0xb8) + *(float *)(this + 0x38);
LAB_00114575:
*(float *)(this + 0x38) = fVar12;
uVar8 = CONCAT71(uVar9,1);
}
cVar4 = ImGui::IsKeyPressed(0x203,1);
if (cVar4 == '\0') {
cVar4 = ImGui::IsKeyPressed(0x204,1);
if (cVar4 != '\0') {
fVar12 = *(float *)(this + 0x3c) - *(float *)(this + 0xb8);
goto LAB_001145c5;
}
}
else {
fVar12 = *(float *)(this + 0xb8) + *(float *)(this + 0x3c);
LAB_001145c5:
*(float *)(this + 0x3c) = fVar12;
uVar8 = CONCAT71((int7)(uVar8 >> 8),1);
}
uVar7 = (int4)uVar8;
cVar4 = ImGui::IsKeyPressed(0x255,1);
if (cVar4 == '\0') {
cVar4 = ImGui::IsKeyPressed(599,1);
if (cVar4 == '\0') {
fVar12 = *(float *)(this + 0x40);
goto LAB_0011461e;
}
fVar12 = *(float *)(this + 0xbc) + *(float *)(this + 0x40);
}
else {
fVar12 = *(float *)(this + 0x40) - *(float *)(this + 0xbc);
}
*(float *)(this + 0x40) = fVar12;
uVar7 = (int4)CONCAT71((int7)(uVar8 >> 8),1);
LAB_0011461e:
lVar6 = 0x40;
if (*(float *)(this + 0x7c) <= fVar12 && fVar12 != *(float *)(this + 0x7c)) {
lVar6 = 0x7c;
}
lVar5 = 0x80;
if (*(float *)(this + 0x80) <= fVar12) {
lVar5 = lVar6;
}
fVar12 = *(float *)(this + lVar5);
*(float *)(this + 0x40) = fVar12;
if ((char)uVar7 != '\0') {
fVar13 = (float)*(int *)(this + 8) * *(float *)(this + 0x70) * fVar12;
fVar17 = (float)*(int8 *)param_1 - fVar13;
fVar19 = (float)((ulong)*(int8 *)param_1 >> 0x20) - fVar13;
if (updateViewport(ImVec2_const&)::viewportInit == '\0') {
auVar18._0_4_ = (float)DAT_0019f2f0 * fVar17;
auVar18._4_4_ = DAT_0019f2f0._4_4_ * fVar19;
auVar18._8_4_ = _UNK_0019f2f8 * (0.0 - fVar13);
auVar18._12_4_ = _UNK_0019f2fc * (0.0 - fVar13);
auVar15._4_4_ = fVar12;
auVar15._0_4_ = fVar12;
auVar15._8_4_ = fVar12;
auVar15._12_4_ = fVar12;
auVar16 = divps(auVar18,auVar15);
}
else {
auVar16._8_8_ = 0;
auVar16._0_8_ = *(ulong *)(this + 0x38);
}
auVar14._4_4_ = fVar19 - *(float *)(this + 0xc0);
auVar14._0_4_ = fVar17;
auVar14._8_4_ = 0.0 - fVar13;
auVar14._12_4_ = 0.0 - fVar13;
auVar1._4_4_ = fVar12;
auVar1._0_4_ = fVar12;
auVar1._8_4_ = fVar12;
auVar1._12_4_ = fVar12;
auVar15 = divps(auVar14,auVar1);
auVar2._4_4_ = fVar12;
auVar2._0_4_ = fVar12;
auVar2._8_4_ = fVar12;
auVar2._12_4_ = fVar12;
auVar18 = divps(ZEXT416((uint)*(float *)(this + 0xc0)) << 0x20,auVar2);
auVar18 = minps(auVar18,auVar16);
uVar10 = -(uint)(auVar16._0_4_ < auVar15._0_4_);
uVar11 = -(uint)(auVar16._4_4_ < auVar15._4_4_);
*(ulong *)(this + 0x38) =
CONCAT44(~uVar11 & auVar18._4_4_,~uVar10 & auVar18._0_4_) |
CONCAT44((uint)auVar15._4_4_ & uVar11,(uint)auVar15._0_4_ & uVar10);
}
updateViewport(ImVec2_const&)::viewportInit = 1;
return uVar7;
}
|
|
60,010
|
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation const&)
|
giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc
|
void ReportInvalidTestSuiteType(const char* test_suite_name,
const CodeLocation& code_location) {
Message errors;
errors
<< "Attempted redefinition of test suite " << test_suite_name << ".\n"
<< "All tests in the same test suite must use the same test fixture\n"
<< "class. However, in test suite " << test_suite_name << ", you tried\n"
<< "to define a test using a fixture class different from the one\n"
<< "used earlier. This can happen if the two fixture classes are\n"
<< "from different namespaces and have the same name. You should\n"
<< "probably rename one of the classes to put the tests into different\n"
<< "test suites.";
GTEST_LOG_(ERROR) << FormatFileLocation(code_location.file.c_str(),
code_location.line)
<< " " << errors.GetString();
}
|
O1
|
cpp
|
testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x1cd64
movq (%rbx), %rbx
leaq 0x10(%rbx), %r15
leaq 0x21cd2(%rip), %rsi # 0x42f8b
movl $0x25, %edx
movq %r15, %rdi
callq 0x85b0
testq %r12, %r12
je 0x212db
movq %r12, %rdi
callq 0x8200
movq %rax, %rdx
movq %r12, %rsi
jmp 0x212e7
movl $0x6, %edx
leaq 0x1f302(%rip), %rsi # 0x405e9
movq %r15, %rdi
callq 0x85b0
leaq 0x21f2e(%rip), %rsi # 0x43224
movl $0x2, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21a05(%rip), %rsi # 0x42d0f
movl $0x40, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21b17(%rip), %rsi # 0x42e35
movl $0x1f, %edx
movq %r15, %rdi
callq 0x85b0
testq %r12, %r12
je 0x2133d
movq %r12, %rdi
callq 0x8200
movq %rax, %rdx
jmp 0x21349
movl $0x6, %edx
leaq 0x1f2a0(%rip), %r12 # 0x405e9
movq %r15, %rdi
movq %r12, %rsi
callq 0x85b0
leaq 0x21c56(%rip), %rsi # 0x42fb1
movl $0xc, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21c4f(%rip), %rsi # 0x42fbe
movl $0x3e, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21c7a(%rip), %rsi # 0x42ffd
movl $0x3d, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21ca4(%rip), %rsi # 0x4303b
movl $0x3d, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21cce(%rip), %rsi # 0x43079
movl $0x43, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x21b9e(%rip), %rsi # 0x42f5d
movl $0xc, %edx
movq %r15, %rdi
callq 0x85b0
leaq 0x2133a(%rip), %rdx # 0x4270d
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0xb0b, %ecx # imm = 0xB0B
callq 0x16e72
movq (%r14), %rsi
movl 0x20(%r14), %edx
leaq 0x38(%rsp), %rdi
callq 0x169a6
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x37bdf(%rip), %rdi # 0x58fe8
callq 0x85b0
movq %rax, %r14
leaq 0x2172d(%rip), %rsi # 0x42b45
movl $0x1, %edx
movq %rax, %rdi
callq 0x85b0
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x1cfc7
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rdi
callq 0x85b0
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2145f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2147a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0xc(%rsp), %rdi
callq 0x16fb4
testq %rbx, %rbx
je 0x21492
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x214ca
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x214ca
jmp 0x214c7
movq %rax, %rbx
jmp 0x214e5
jmp 0x214f1
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x214e5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x84e0
leaq 0xc(%rsp), %rdi
callq 0x16fb4
jmp 0x214f4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x21504
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8990
|
_ZN7testing8internal26ReportInvalidTestSuiteTypeEPKcRKNS0_12CodeLocationE:
push r15; __int64
push r14; int
push r12; void *
push rbx; int
sub rsp, 58h
mov r14, rsi
mov r12, rdi
lea rbx, [rsp+78h+var_68]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rbx, [rbx]
lea r15, [rbx+10h]
lea rsi, aAttemptedRedef; "Attempted redefinition of test suite "
mov edx, 25h ; '%'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r12, r12
jz short loc_212DB
mov rdi, r12
call _strlen
mov rdx, rax
mov rsi, r12
jmp short loc_212E7
loc_212DB:
mov edx, 6
lea rsi, aNull; "(null)"
loc_212E7:
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aNoteRandomizin+32h; ".\n"
mov edx, 2
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aAllTestsInTheS; "All tests in the same test suite must u"...
mov edx, 40h ; '@'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aClassHoweverIn; "class. However, in test suite "
mov edx, 1Fh
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r12, r12
jz short loc_2133D
mov rdi, r12
call _strlen
mov rdx, rax
jmp short loc_21349
loc_2133D:
mov edx, 6
lea r12, aNull; "(null)"
loc_21349:
mov rdi, r15
mov rsi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aYouTried; ", you tried\n"
mov edx, 0Ch
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aToDefineATestU; "to define a test using a fixture class "...
mov edx, 3Eh ; '>'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aUsedEarlierThi; "used earlier. This can happen if the tw"...
mov edx, 3Dh ; '='
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aFromDifferentN; "from different namespaces and have the "...
mov edx, 3Dh ; '='
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aProbablyRename; "probably rename one of the classes to p"...
mov edx, 43h ; 'C'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rsi, aOfTheClassesTo+2Fh; "test suites."
mov edx, 0Ch
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+78h+var_6C]
mov esi, 2
mov ecx, 0B0Bh
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rsi, [r14]; int
mov edx, [r14+20h]; int
lea rdi, [rsp+78h+var_40]; int
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
mov rsi, qword ptr [rsp+78h+var_40]
mov rdx, [rsp+78h+var_38]
mov rdi, cs:_ZSt4cerr_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
lea rsi, asc_42B43+2; " "
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+78h+var_60]
mov rsi, rbx
call _ZN7testing8internal20StringStreamToStringEPNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEE; testing::internal::StringStreamToString(std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>> *)
mov rsi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_58]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rax, [rsp+78h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2145F
mov rsi, [rsp+78h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2145F:
lea rax, [rsp+78h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2147A
mov rsi, [rsp+78h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2147A:
lea rdi, [rsp+78h+var_6C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
test rbx, rbx
jz short loc_21492
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
loc_21492:
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_214CA
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_214CA
jmp short loc_214C7
mov rbx, rax
jmp short loc_214E5
jmp short loc_214F1
loc_214C7:
mov rbx, rax
loc_214CA:
lea rax, [rsp+arg_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_214E5
mov rsi, [rsp+arg_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_214E5:
lea rdi, [rsp+arg_4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_214F4
loc_214F1:
mov rbx, rax
loc_214F4:
mov rdi, [rsp+arg_8]
test rdi, rdi
jz short loc_21504
mov rax, [rdi]
call qword ptr [rax+8]
loc_21504:
mov rdi, rbx
call __Unwind_Resume
|
void testing::internal::ReportInvalidTestSuiteType(const char *a1, long long a2)
{
const char *v3; // r12
long long v4; // rbx
long long v5; // rdx
const char *v6; // rsi
long long v7; // rdx
long long v8; // r14
void *v9; // rsi
long long v10; // rdx
long long v11; // rcx
int v12; // [rsp+Ch] [rbp-6Ch] BYREF
long long v13; // [rsp+10h] [rbp-68h] BYREF
void *v14[2]; // [rsp+18h] [rbp-60h] BYREF
long long v15; // [rsp+28h] [rbp-50h] BYREF
int v16[2]; // [rsp+38h] [rbp-40h] BYREF
long long v17; // [rsp+40h] [rbp-38h]
long long v18; // [rsp+48h] [rbp-30h] BYREF
v3 = a1;
testing::Message::Message((testing::Message *)&v13);
v4 = v13;
std::__ostream_insert<char,std::char_traits<char>>(v13 + 16, "Attempted redefinition of test suite ", 37LL);
if ( a1 )
{
v5 = strlen(a1);
v6 = a1;
}
else
{
v5 = 6LL;
v6 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, v6, v5);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, ".\n", 2LL);
std::__ostream_insert<char,std::char_traits<char>>(
v4 + 16,
"All tests in the same test suite must use the same test fixture\n",
64LL);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, "class. However, in test suite ", 31LL);
if ( a1 )
{
v7 = strlen(a1);
}
else
{
v7 = 6LL;
v3 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, v3, v7);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, ", you tried\n", 12LL);
std::__ostream_insert<char,std::char_traits<char>>(
v4 + 16,
"to define a test using a fixture class different from the one\n",
62LL);
std::__ostream_insert<char,std::char_traits<char>>(
v4 + 16,
"used earlier. This can happen if the two fixture classes are\n",
61LL);
std::__ostream_insert<char,std::char_traits<char>>(
v4 + 16,
"from different namespaces and have the same name. You should\n",
61LL);
std::__ostream_insert<char,std::char_traits<char>>(
v4 + 16,
"probably rename one of the classes to put the tests into different\n",
67LL);
std::__ostream_insert<char,std::char_traits<char>>(v4 + 16, "test suites.", 12LL);
testing::internal::GTestLog::GTestLog(
&v12,
2,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc",
2827);
testing::internal::FormatFileLocation[abi:cxx11]((long long)v16, *(const char **)a2, *(_DWORD *)(a2 + 32));
v8 = std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, *(_QWORD *)v16, v17);
std::__ostream_insert<char,std::char_traits<char>>(v8, " ", 1LL);
testing::internal::StringStreamToString((long long)v14, v4);
v9 = v14[0];
std::__ostream_insert<char,std::char_traits<char>>(v8, v14[0], v14[1]);
if ( v14[0] != &v15 )
{
v9 = (void *)(v15 + 1);
operator delete(v14[0], v15 + 1);
}
if ( *(long long **)v16 != &v18 )
{
v9 = (void *)(v18 + 1);
operator delete(*(void **)v16, v18 + 1);
}
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)&v12, (long long)v9, v10, v11);
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
}
|
ReportInvalidTestSuiteType:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV R12,RDI
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
CALL 0x0011cd64
MOV RBX,qword ptr [RBX]
LEA R15,[RBX + 0x10]
LAB_001212b2:
LEA RSI,[0x142f8b]
MOV EDX,0x25
MOV RDI,R15
CALL 0x001085b0
TEST R12,R12
JZ 0x001212db
MOV RDI,R12
CALL 0x00108200
MOV RDX,RAX
MOV RSI,R12
JMP 0x001212e7
LAB_001212db:
MOV EDX,0x6
LEA RSI,[0x1405e9]
LAB_001212e7:
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x143224]
MOV EDX,0x2
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x142d0f]
MOV EDX,0x40
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x142e35]
MOV EDX,0x1f
MOV RDI,R15
CALL 0x001085b0
TEST R12,R12
JZ 0x0012133d
MOV RDI,R12
CALL 0x00108200
MOV RDX,RAX
JMP 0x00121349
LAB_0012133d:
MOV EDX,0x6
LEA R12,[0x1405e9]
LAB_00121349:
MOV RDI,R15
MOV RSI,R12
CALL 0x001085b0
LEA RSI,[0x142fb1]
MOV EDX,0xc
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x142fbe]
MOV EDX,0x3e
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x142ffd]
MOV EDX,0x3d
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x14303b]
MOV EDX,0x3d
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x143079]
MOV EDX,0x43
MOV RDI,R15
CALL 0x001085b0
LEA RSI,[0x142f5d]
MOV EDX,0xc
MOV RDI,R15
CALL 0x001085b0
LAB_001213cc:
LEA RDX,[0x14270d]
LEA RDI,[RSP + 0xc]
MOV ESI,0x2
MOV ECX,0xb0b
CALL 0x00116e72
MOV RSI,qword ptr [R14]
MOV EDX,dword ptr [R14 + 0x20]
LAB_001213ee:
LEA RDI,[RSP + 0x38]
CALL 0x001169a6
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
LAB_00121402:
MOV RDI,qword ptr [0x00158fe8]
CALL 0x001085b0
MOV R14,RAX
LEA RSI,[0x142b45]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001085b0
LAB_00121425:
LEA RDI,[RSP + 0x18]
MOV RSI,RBX
CALL 0x0011cfc7
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
LAB_0012143c:
MOV RDI,R14
CALL 0x001085b0
LAB_00121444:
LEA RAX,[RSP + 0x28]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012145f
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001084e0
LAB_0012145f:
LEA RAX,[RSP + 0x48]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012147a
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x001084e0
LAB_0012147a:
LEA RDI,[RSP + 0xc]
CALL 0x00116fb4
TEST RBX,RBX
JZ 0x00121492
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x8]
LAB_00121492:
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
|
/* testing::internal::ReportInvalidTestSuiteType(char const*, testing::internal::CodeLocation
const&) */
void testing::internal::ReportInvalidTestSuiteType(char *param_1,CodeLocation *param_2)
{
size_t sVar1;
ostream *poVar2;
char *pcVar3;
GTestLog local_6c [4];
long *local_68;
long *local_60;
long local_58;
long local_50 [2];
long *local_40;
long local_38;
long local_30 [2];
Message::Message((Message *)&local_68);
poVar2 = (ostream *)(local_68 + 2);
/* try { // try from 001212b2 to 001213cb has its CatchHandler @ 001214f1 */
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"Attempted redefinition of test suite ",0x25);
if (param_1 == (char *)0x0) {
sVar1 = 6;
pcVar3 = "(null)";
}
else {
sVar1 = strlen(param_1);
pcVar3 = param_1;
}
std::__ostream_insert<char,std::char_traits<char>>(poVar2,pcVar3,sVar1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,".\n",2);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"All tests in the same test suite must use the same test fixture\n",0x40);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"class. However, in test suite ",0x1f);
if (param_1 == (char *)0x0) {
sVar1 = 6;
param_1 = "(null)";
}
else {
sVar1 = strlen(param_1);
}
std::__ostream_insert<char,std::char_traits<char>>(poVar2,param_1,sVar1);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,", you tried\n",0xc);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"to define a test using a fixture class different from the one\n",0x3e);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"used earlier. This can happen if the two fixture classes are\n",0x3d);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"from different namespaces and have the same name. You should\n",0x3d);
std::__ostream_insert<char,std::char_traits<char>>
(poVar2,"probably rename one of the classes to put the tests into different\n",0x43);
std::__ostream_insert<char,std::char_traits<char>>(poVar2,"test suites.",0xc);
/* try { // try from 001213cc to 001213e6 has its CatchHandler @ 001214c5 */
GTestLog::GTestLog(local_6c,2,
"/workspace/llm4binary/github/2025_star3/giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc"
,0xb0b);
/* try { // try from 001213ee to 001213f7 has its CatchHandler @ 001214c0 */
FormatFileLocation_abi_cxx11_((internal *)&local_40,*(char **)param_2,*(int *)(param_2 + 0x20));
/* try { // try from 00121402 to 00121424 has its CatchHandler @ 001214c7 */
poVar2 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00158fe8,(char *)local_40,local_38);
std::__ostream_insert<char,std::char_traits<char>>(poVar2," ",1);
/* try { // try from 00121425 to 00121431 has its CatchHandler @ 001214be */
StringStreamToString((stringstream *)&local_60);
/* try { // try from 0012143c to 00121443 has its CatchHandler @ 0012149e */
std::__ostream_insert<char,std::char_traits<char>>(poVar2,(char *)local_60,local_58);
if (local_60 != local_50) {
operator_delete(local_60,local_50[0] + 1);
}
if (local_40 != local_30) {
operator_delete(local_40,local_30[0] + 1);
}
GTestLog::~GTestLog(local_6c);
if (local_68 != (long *)0x0) {
(**(code **)(*local_68 + 8))(local_68);
}
return;
}
|
|
60,011
|
simple_key_cache_read
|
eloqsql/mysys/mf_keycache.c
|
uchar *simple_key_cache_read(SIMPLE_KEY_CACHE_CB *keycache,
File file, my_off_t filepos, int level,
uchar *buff, uint length,
uint block_length __attribute__((unused)),
int return_buffer __attribute__((unused)))
{
my_bool locked_and_incremented= FALSE;
int error=0;
uchar *start= buff;
DBUG_ENTER("simple_key_cache_read");
DBUG_PRINT("enter", ("fd: %u pos: %lu length: %u",
(uint) file, (ulong) filepos, length));
if (keycache->key_cache_inited)
{
/* Key cache is used */
reg1 BLOCK_LINK *block;
uint read_length;
uint offset;
int page_st;
if (MYSQL_KEYCACHE_READ_START_ENABLED())
{
MYSQL_KEYCACHE_READ_START(my_filename(file), length,
(ulong) (keycache->blocks_used *
keycache->key_cache_block_size),
(ulong) (keycache->blocks_unused *
keycache->key_cache_block_size));
}
/*
When the key cache is once initialized, we use the cache_lock to
reliably distinguish the cases of normal operation, resizing, and
disabled cache. We always increment and decrement
'cnt_for_resize_op' so that a resizer can wait for pending I/O.
*/
keycache_pthread_mutex_lock(&keycache->cache_lock);
/*
Cache resizing has two phases: Flushing and re-initializing. In
the flush phase read requests are allowed to bypass the cache for
blocks not in the cache. find_key_block() returns NULL in this
case.
After the flush phase new I/O requests must wait until the
re-initialization is done. The re-initialization can be done only
if no I/O request is in progress. The reason is that
key_cache_block_size can change. With enabled cache, I/O is done
in chunks of key_cache_block_size. Every chunk tries to use a
cache block first. If the block size changes in the middle, a
block could be missed and old data could be read.
*/
while (keycache->in_resize && !keycache->resize_in_flush)
wait_on_queue(&keycache->resize_queue, &keycache->cache_lock);
/* Register the I/O for the next resize. */
inc_counter_for_resize_op(keycache);
locked_and_incremented= TRUE;
/* Requested data may not always be aligned to cache blocks. */
offset= (uint) (filepos % keycache->key_cache_block_size);
/* Read data in key_cache_block_size increments */
do
{
/* Cache could be disabled in a later iteration. */
if (!keycache->can_be_used)
{
KEYCACHE_DBUG_PRINT("key_cache_read", ("keycache cannot be used"));
goto no_key_cache;
}
/* Start reading at the beginning of the cache block. */
filepos-= offset;
/* Do not read beyond the end of the cache block. */
read_length= length;
set_if_smaller(read_length, keycache->key_cache_block_size-offset);
KEYCACHE_DBUG_ASSERT(read_length > 0);
/* Request the cache block that matches file/pos. */
keycache->global_cache_r_requests++;
MYSQL_KEYCACHE_READ_BLOCK(keycache->key_cache_block_size);
block=find_key_block(keycache, file, filepos, level, 0, &page_st);
if (!block)
{
/*
This happens only for requests submitted during key cache
resize. The block is not in the cache and shall not go in.
Read directly from file.
*/
keycache->global_cache_read++;
keycache_pthread_mutex_unlock(&keycache->cache_lock);
error= (my_pread(file, (uchar*) buff, read_length,
filepos + offset, MYF(MY_NABP)) != 0);
keycache_pthread_mutex_lock(&keycache->cache_lock);
goto next_block;
}
if (!(block->status & BLOCK_ERROR))
{
if (page_st == PAGE_TO_BE_READ)
{
MYSQL_KEYCACHE_READ_MISS();
read_block_primary(keycache, block,
keycache->key_cache_block_size, read_length+offset);
}
else if (page_st == PAGE_WAIT_TO_BE_READ)
{
MYSQL_KEYCACHE_READ_MISS();
/* The requested page is to be read into the block buffer */
read_block_secondary(keycache, block);
/*
A secondary request must now have the block assigned to the
requested file block.
*/
DBUG_ASSERT(block->hash_link->file == file);
DBUG_ASSERT(block->hash_link->diskpos == filepos);
}
else if (block->length < read_length + offset)
{
/*
Impossible if nothing goes wrong:
this could only happen if we are using a file with
small key blocks and are trying to read outside the file
*/
my_errno= -1;
block->status|= BLOCK_ERROR;
}
else
{
MYSQL_KEYCACHE_READ_HIT();
}
}
/* block status may have added BLOCK_ERROR in the above 'if'. */
if (!(block->status & BLOCK_ERROR))
{
{
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
#endif
/* Copy data from the cache buffer */
memcpy(buff, block->buffer+offset, (size_t) read_length);
#if !defined(SERIALIZED_READ_FROM_CACHE)
keycache_pthread_mutex_lock(&keycache->cache_lock);
DBUG_ASSERT(block->status & (BLOCK_READ | BLOCK_IN_USE));
#endif
}
}
remove_reader(block);
/* Error injection for coverage testing. */
DBUG_EXECUTE_IF("key_cache_read_block_error",
block->status|= BLOCK_ERROR;);
/* Do not link erroneous blocks into the LRU ring, but free them. */
if (!(block->status & BLOCK_ERROR))
{
/*
Link the block into the LRU ring if it's the last submitted
request for the block. This enables eviction for the block.
*/
unreg_request(keycache, block, 1);
}
else
{
free_block(keycache, block);
error= 1;
break;
}
next_block:
buff+= read_length;
filepos+= read_length+offset;
offset= 0;
} while ((length-= read_length));
if (MYSQL_KEYCACHE_READ_DONE_ENABLED())
{
MYSQL_KEYCACHE_READ_DONE((ulong) (keycache->blocks_used *
keycache->key_cache_block_size),
(ulong) (keycache->blocks_unused *
keycache->key_cache_block_size));
}
goto end;
}
KEYCACHE_DBUG_PRINT("key_cache_read", ("keycache not initialized"));
no_key_cache:
/* Key cache is not used */
keycache->global_cache_r_requests++;
keycache->global_cache_read++;
if (locked_and_incremented)
keycache_pthread_mutex_unlock(&keycache->cache_lock);
if (my_pread(file, (uchar*) buff, length, filepos, MYF(MY_NABP)))
error= 1;
if (locked_and_incremented)
keycache_pthread_mutex_lock(&keycache->cache_lock);
end:
if (locked_and_incremented)
{
dec_counter_for_resize_op(keycache);
keycache_pthread_mutex_unlock(&keycache->cache_lock);
}
DBUG_PRINT("exit", ("error: %d", error ));
DBUG_RETURN(error ? (uchar*) 0 : start);
}
|
O0
|
c
|
simple_key_cache_read:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movb $0x0, -0x2d(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xe2f89
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xe327f
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x71034(%rip), %rsi # 0x153fdc
movl $0xaf2, %edx # imm = 0xAF2
callq 0xe3360
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x55(%rbp)
je 0xe2fd4
movq -0x8(%rbp), %rax
cmpb $0x0, 0x2(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x55(%rbp)
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0xe2fdd
jmp 0xe2ffa
movq -0x8(%rbp), %rdi
addq $0x108, %rdi # imm = 0x108
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
callq 0xe33d0
jmp 0xe2fb2
movq -0x8(%rbp), %rdi
callq 0xe3480
movb $0x1, -0x2d(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x50(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, 0x3(%rax)
jne 0xe302f
jmp 0xe3028
jmp 0xe302a
jmp 0xe3285
movl -0x50(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
subl -0x50(%rbp), %ecx
cmpl %ecx, %eax
jbe 0xe3063
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
subl -0x50(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0xe3065
jmp 0xe3067
jmp 0xe3069
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x150(%rax)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
xorl %r8d, %r8d
leaq -0x54(%rbp), %r9
callq 0xe34a0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xe311b
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x158(%rax)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe3d80
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x4c(%rbp), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl -0x50(%rbp), %eax
addq %rax, %rcx
movl $0x4, %r8d
callq 0xf4620
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x70ed0(%rip), %rsi # 0x153fdc
movl $0xb29, %edx # imm = 0xB29
callq 0xe3360
jmp 0xe323f
movq -0x48(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe319a
cmpl $0x1, -0x54(%rbp)
jne 0xe314c
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movl -0x4c(%rbp), %ecx
addl -0x50(%rbp), %ecx
callq 0xe3de0
jmp 0xe3198
cmpl $0x2, -0x54(%rbp)
jne 0xe3167
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe3ee0
jmp 0xe3161
jmp 0xe3163
jmp 0xe3165
jmp 0xe3196
movq -0x48(%rbp), %rax
movl 0x4c(%rax), %eax
movl -0x4c(%rbp), %ecx
addl -0x50(%rbp), %ecx
cmpl %ecx, %eax
jae 0xe3192
callq 0xf6080
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq -0x48(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x50(%rax)
jmp 0xe3194
jmp 0xe3194
jmp 0xe3196
jmp 0xe3198
jmp 0xe319a
movq -0x48(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe31f9
jmp 0xe31ab
jmp 0xe31ad
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe3d80
movq -0x28(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rsi
movl -0x50(%rbp), %eax
addq %rax, %rsi
movl -0x4c(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x70df1(%rip), %rsi # 0x153fdc
movl $0xb5e, %edx # imm = 0xB5E
callq 0xe3360
jmp 0xe31f7
jmp 0xe31f9
movq -0x48(%rbp), %rdi
callq 0xe3f20
jmp 0xe3204
movq -0x48(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xe3227
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl $0x1, %edx
callq 0xe3f80
jmp 0xe323d
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe4110
movl $0x1, -0x34(%rbp)
jmp 0xe327a
jmp 0xe323f
movl -0x4c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x4c(%rbp), %eax
addl -0x50(%rbp), %eax
movl %eax, %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x4c(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0xe301c
jmp 0xe3313
jmp 0xe3281
jmp 0xe3283
jmp 0xe3285
movq -0x8(%rbp), %rax
movq 0x150(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x150(%rax)
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x158(%rax)
cmpb $0x0, -0x2d(%rbp)
je 0xe32c7
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe3d80
movl -0xc(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
movl $0x4, %r8d
callq 0xf4620
cmpq $0x0, %rax
je 0xe32ef
movl $0x1, -0x34(%rbp)
cmpb $0x0, -0x2d(%rbp)
je 0xe3311
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
leaq 0x70cd5(%rip), %rsi # 0x153fdc
movl $0xb96, %edx # imm = 0xB96
callq 0xe3360
jmp 0xe3313
cmpb $0x0, -0x2d(%rbp)
je 0xe3332
movq -0x8(%rbp), %rdi
callq 0xe4280
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
callq 0xe3d80
jmp 0xe3334
jmp 0xe3336
jmp 0xe3338
cmpl $0x0, -0x34(%rbp)
je 0xe3346
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xe334e
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
|
simple_key_cache_read:
push rbp
mov rbp, rsp
sub rsp, 70h
mov eax, [rbp+arg_8]
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_2C], r9d
mov [rbp+var_2D], 0
mov [rbp+var_34], 0
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
jmp short $+2
loc_E2F89:
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jz loc_E327F
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0AF2h
call inline_mysql_mutex_lock_24
loc_E2FB2:
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax+1]
xor eax, eax
cmp ecx, 0
mov [rbp+var_55], al
jz short loc_E2FD4
mov rax, [rbp+var_8]
cmp byte ptr [rax+2], 0
setnz al
xor al, 0FFh
mov [rbp+var_55], al
loc_E2FD4:
mov al, [rbp+var_55]
test al, 1
jnz short loc_E2FDD
jmp short loc_E2FFA
loc_E2FDD:
mov rdi, [rbp+var_8]
add rdi, 108h
mov rsi, [rbp+var_8]
add rsi, 0C0h
call wait_on_queue
jmp short loc_E2FB2
loc_E2FFA:
mov rdi, [rbp+var_8]
call inc_counter_for_resize_op_0
mov [rbp+var_2D], 1
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+18h]
xor edx, edx
div rcx
mov eax, edx
mov [rbp+var_50], eax
loc_E301C:
mov rax, [rbp+var_8]
cmp byte ptr [rax+3], 0
jnz short loc_E302F
jmp short $+2
loc_E3028:
jmp short $+2
loc_E302A:
jmp loc_E3285
loc_E302F:
mov eax, [rbp+var_50]
mov ecx, eax
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_2C]
mov [rbp+var_4C], eax
mov eax, [rbp+var_4C]
mov rcx, [rbp+var_8]
mov ecx, [rcx+18h]
sub ecx, [rbp+var_50]
cmp eax, ecx
jbe short loc_E3063
mov rax, [rbp+var_8]
mov eax, [rax+18h]
sub eax, [rbp+var_50]
mov [rbp+var_4C], eax
loc_E3063:
jmp short $+2
loc_E3065:
jmp short $+2
loc_E3067:
jmp short $+2
loc_E3069:
mov rax, [rbp+var_8]
mov rcx, [rax+150h]
add rcx, 1
mov [rax+150h], rcx
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_1C]
xor r8d, r8d
lea r9, [rbp+var_54]
call find_key_block
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jnz short loc_E311B
mov rax, [rbp+var_8]
mov rcx, [rax+158h]
add rcx, 1
mov [rax+158h], rcx
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
mov edi, [rbp+var_C]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_4C]
mov edx, eax
mov rcx, [rbp+var_18]
mov eax, [rbp+var_50]
add rcx, rax
mov r8d, 4
call my_pread
cmp rax, 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_34], eax
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B29h
call inline_mysql_mutex_lock_24
jmp loc_E323F
loc_E311B:
mov rax, [rbp+var_48]
mov eax, [rax+50h]
and eax, 1
cmp eax, 0
jnz short loc_E319A
cmp [rbp+var_54], 1
jnz short loc_E314C
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+18h]
mov ecx, [rbp+var_4C]
add ecx, [rbp+var_50]
call read_block_primary
jmp short loc_E3198
loc_E314C:
cmp [rbp+var_54], 2
jnz short loc_E3167
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
call read_block_secondary
jmp short $+2
loc_E3161:
jmp short $+2
loc_E3163:
jmp short $+2
loc_E3165:
jmp short loc_E3196
loc_E3167:
mov rax, [rbp+var_48]
mov eax, [rax+4Ch]
mov ecx, [rbp+var_4C]
add ecx, [rbp+var_50]
cmp eax, ecx
jnb short loc_E3192
call _my_thread_var
mov dword ptr [rax], 0FFFFFFFFh
mov rax, [rbp+var_48]
mov ecx, [rax+50h]
or ecx, 1
mov [rax+50h], ecx
jmp short loc_E3194
loc_E3192:
jmp short $+2
loc_E3194:
jmp short $+2
loc_E3196:
jmp short $+2
loc_E3198:
jmp short $+2
loc_E319A:
mov rax, [rbp+var_48]
mov eax, [rax+50h]
and eax, 1
cmp eax, 0
jnz short loc_E31F9
jmp short $+2
loc_E31AB:
jmp short $+2
loc_E31AD:
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
mov rdi, [rbp+var_28]
mov rax, [rbp+var_48]
mov rsi, [rax+40h]
mov eax, [rbp+var_50]
add rsi, rax
mov eax, [rbp+var_4C]
mov edx, eax
call _memcpy
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B5Eh
call inline_mysql_mutex_lock_24
jmp short $+2
loc_E31F7:
jmp short $+2
loc_E31F9:
mov rdi, [rbp+var_48]
call remove_reader_0
jmp short $+2
loc_E3204:
mov rax, [rbp+var_48]
mov eax, [rax+50h]
and eax, 1
cmp eax, 0
jnz short loc_E3227
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov edx, 1
call unreg_request_0
jmp short loc_E323D
loc_E3227:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
call free_block_0
mov [rbp+var_34], 1
jmp short loc_E327A
loc_E323D:
jmp short $+2
loc_E323F:
mov ecx, [rbp+var_4C]
mov rax, [rbp+var_28]
mov ecx, ecx
add rax, rcx
mov [rbp+var_28], rax
mov eax, [rbp+var_4C]
add eax, [rbp+var_50]
mov eax, eax
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov [rbp+var_50], 0
mov ecx, [rbp+var_4C]
mov eax, [rbp+var_2C]
sub eax, ecx
mov [rbp+var_2C], eax
cmp eax, 0
jnz loc_E301C
loc_E327A:
jmp loc_E3313
loc_E327F:
jmp short $+2
loc_E3281:
jmp short $+2
loc_E3283:
jmp short $+2
loc_E3285:
mov rax, [rbp+var_8]
mov rcx, [rax+150h]
add rcx, 1
mov [rax+150h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+158h]
add rcx, 1
mov [rax+158h], rcx
cmp [rbp+var_2D], 0
jz short loc_E32C7
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
loc_E32C7:
mov edi, [rbp+var_C]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_2C]
mov edx, eax
mov rcx, [rbp+var_18]
mov r8d, 4
call my_pread
cmp rax, 0
jz short loc_E32EF
mov [rbp+var_34], 1
loc_E32EF:
cmp [rbp+var_2D], 0
jz short loc_E3311
mov rdi, [rbp+var_8]
add rdi, 0C0h
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B96h
call inline_mysql_mutex_lock_24
loc_E3311:
jmp short $+2
loc_E3313:
cmp [rbp+var_2D], 0
jz short loc_E3332
mov rdi, [rbp+var_8]
call dec_counter_for_resize_op_0
mov rdi, [rbp+var_8]
add rdi, 0C0h
call inline_mysql_mutex_unlock_25
loc_E3332:
jmp short $+2
loc_E3334:
jmp short $+2
loc_E3336:
jmp short $+2
loc_E3338:
cmp [rbp+var_34], 0
jz short loc_E3346
xor eax, eax
mov [rbp+var_60], rax
jmp short loc_E334E
loc_E3346:
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
loc_E334E:
mov rax, [rbp+var_60]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
add rsp, 70h
pop rbp
retn
|
long long simple_key_cache_read(
_BYTE *a1,
unsigned int a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned int a6)
{
_BYTE *v6; // rdi
const char *v7; // rsi
char v10; // [rsp+1Bh] [rbp-55h]
int v11; // [rsp+1Ch] [rbp-54h] BYREF
unsigned int v12; // [rsp+20h] [rbp-50h]
unsigned int v13; // [rsp+24h] [rbp-4Ch]
long long key_block; // [rsp+28h] [rbp-48h]
long long v15; // [rsp+30h] [rbp-40h]
BOOL v16; // [rsp+3Ch] [rbp-34h]
char v17; // [rsp+43h] [rbp-2Dh]
unsigned int v18; // [rsp+44h] [rbp-2Ch]
long long v19; // [rsp+48h] [rbp-28h]
unsigned int v20; // [rsp+54h] [rbp-1Ch]
unsigned long long v21; // [rsp+58h] [rbp-18h]
unsigned int v22; // [rsp+64h] [rbp-Ch]
_BYTE *v23; // [rsp+68h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v17 = 0;
v16 = 0;
v15 = a5;
if ( *a1 )
{
inline_mysql_mutex_lock_24(v23 + 192, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 2802LL);
while ( 1 )
{
v10 = 0;
if ( v23[1] )
v10 = ~(v23[2] != 0);
if ( (v10 & 1) == 0 )
break;
wait_on_queue(v23 + 264, v23 + 192);
}
inc_counter_for_resize_op_0(v23);
v17 = 1;
v12 = v21 % *((unsigned int *)v23 + 6);
while ( v23[3] )
{
v21 -= v12;
v13 = v18;
if ( v18 > *((_DWORD *)v23 + 6) - v12 )
v13 = *((_DWORD *)v23 + 6) - v12;
++*((_QWORD *)v23 + 42);
v6 = v23;
v7 = (const char *)v22;
key_block = find_key_block(v23, v22, v21, v20, 0LL, &v11);
if ( key_block )
{
if ( (*(_DWORD *)(key_block + 80) & 1) == 0 )
{
if ( v11 == 1 )
{
read_block_primary(v23, key_block, *((unsigned int *)v23 + 6), v12 + v13);
}
else if ( v11 == 2 )
{
read_block_secondary(v23, key_block);
}
else if ( *(_DWORD *)(key_block + 76) < v12 + v13 )
{
*(_DWORD *)my_thread_var(v6, v7) = -1;
*(_DWORD *)(key_block + 80) |= 1u;
}
}
if ( (*(_DWORD *)(key_block + 80) & 1) == 0 )
{
inline_mysql_mutex_unlock_25(v23 + 192);
memcpy(v19, v12 + *(_QWORD *)(key_block + 64), v13);
inline_mysql_mutex_lock_24(v23 + 192, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 2910LL);
}
remove_reader_0(key_block);
if ( (*(_DWORD *)(key_block + 80) & 1) != 0 )
{
free_block_0(v23, key_block);
v16 = 1;
goto LABEL_33;
}
unreg_request_0(v23, key_block, 1LL);
}
else
{
++*((_QWORD *)v23 + 43);
inline_mysql_mutex_unlock_25(v23 + 192);
v16 = my_pread(v22, v19, v13, v12 + v21, 4LL) != 0;
inline_mysql_mutex_lock_24(v23 + 192, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 2857LL);
}
v19 += v13;
v21 += v12 + v13;
v12 = 0;
v18 -= v13;
if ( !v18 )
goto LABEL_33;
}
}
++*((_QWORD *)v23 + 42);
++*((_QWORD *)v23 + 43);
if ( v17 )
inline_mysql_mutex_unlock_25(v23 + 192);
if ( my_pread(v22, v19, v18, v21, 4LL) )
v16 = 1;
if ( v17 )
inline_mysql_mutex_lock_24(v23 + 192, "/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c", 2966LL);
LABEL_33:
if ( v17 )
{
dec_counter_for_resize_op_0(v23);
inline_mysql_mutex_unlock_25(v23 + 192);
}
if ( v16 )
return 0LL;
else
return v15;
}
|
simple_key_cache_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV EAX,dword ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV dword ptr [RBP + -0x2c],R9D
MOV byte ptr [RBP + -0x2d],0x0
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x001e2f89
LAB_001e2f89:
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JZ 0x001e327f
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x253fdc]
MOV EDX,0xaf2
CALL 0x001e3360
LAB_001e2fb2:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX + 0x1]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x55],AL
JZ 0x001e2fd4
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x2],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x55],AL
LAB_001e2fd4:
MOV AL,byte ptr [RBP + -0x55]
TEST AL,0x1
JNZ 0x001e2fdd
JMP 0x001e2ffa
LAB_001e2fdd:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x108
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
CALL 0x001e33d0
JMP 0x001e2fb2
LAB_001e2ffa:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001e3480
MOV byte ptr [RBP + -0x2d],0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x18]
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RBP + -0x50],EAX
LAB_001e301c:
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x3],0x0
JNZ 0x001e302f
JMP 0x001e3028
LAB_001e3028:
JMP 0x001e302a
LAB_001e302a:
JMP 0x001e3285
LAB_001e302f:
MOV EAX,dword ptr [RBP + -0x50]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x4c],EAX
MOV EAX,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,dword ptr [RBP + -0x50]
CMP EAX,ECX
JBE 0x001e3063
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x18]
SUB EAX,dword ptr [RBP + -0x50]
MOV dword ptr [RBP + -0x4c],EAX
LAB_001e3063:
JMP 0x001e3065
LAB_001e3065:
JMP 0x001e3067
LAB_001e3067:
JMP 0x001e3069
LAB_001e3069:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x150]
ADD RCX,0x1
MOV qword ptr [RAX + 0x150],RCX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
XOR R8D,R8D
LEA R9,[RBP + -0x54]
CALL 0x001e34a0
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001e311b
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x158]
ADD RCX,0x1
MOV qword ptr [RAX + 0x158],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e3d80
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x4c]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x50]
ADD RCX,RAX
MOV R8D,0x4
CALL 0x001f4620
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x34],EAX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x253fdc]
MOV EDX,0xb29
CALL 0x001e3360
JMP 0x001e323f
LAB_001e311b:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001e319a
CMP dword ptr [RBP + -0x54],0x1
JNZ 0x001e314c
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x4c]
ADD ECX,dword ptr [RBP + -0x50]
CALL 0x001e3de0
JMP 0x001e3198
LAB_001e314c:
CMP dword ptr [RBP + -0x54],0x2
JNZ 0x001e3167
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x001e3ee0
JMP 0x001e3161
LAB_001e3161:
JMP 0x001e3163
LAB_001e3163:
JMP 0x001e3165
LAB_001e3165:
JMP 0x001e3196
LAB_001e3167:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x4c]
MOV ECX,dword ptr [RBP + -0x4c]
ADD ECX,dword ptr [RBP + -0x50]
CMP EAX,ECX
JNC 0x001e3192
CALL 0x001f6080
MOV dword ptr [RAX],0xffffffff
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x1
MOV dword ptr [RAX + 0x50],ECX
JMP 0x001e3194
LAB_001e3192:
JMP 0x001e3194
LAB_001e3194:
JMP 0x001e3196
LAB_001e3196:
JMP 0x001e3198
LAB_001e3198:
JMP 0x001e319a
LAB_001e319a:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001e31f9
JMP 0x001e31ab
LAB_001e31ab:
JMP 0x001e31ad
LAB_001e31ad:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e3d80
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RAX + 0x40]
MOV EAX,dword ptr [RBP + -0x50]
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x4c]
MOV EDX,EAX
CALL 0x0012a090
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x253fdc]
MOV EDX,0xb5e
CALL 0x001e3360
JMP 0x001e31f7
LAB_001e31f7:
JMP 0x001e31f9
LAB_001e31f9:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001e3f20
JMP 0x001e3204
LAB_001e3204:
MOV RAX,qword ptr [RBP + -0x48]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x001e3227
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV EDX,0x1
CALL 0x001e3f80
JMP 0x001e323d
LAB_001e3227:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x001e4110
MOV dword ptr [RBP + -0x34],0x1
JMP 0x001e327a
LAB_001e323d:
JMP 0x001e323f
LAB_001e323f:
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x4c]
ADD EAX,dword ptr [RBP + -0x50]
MOV EAX,EAX
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x50],0x0
MOV ECX,dword ptr [RBP + -0x4c]
MOV EAX,dword ptr [RBP + -0x2c]
SUB EAX,ECX
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001e301c
LAB_001e327a:
JMP 0x001e3313
LAB_001e327f:
JMP 0x001e3281
LAB_001e3281:
JMP 0x001e3283
LAB_001e3283:
JMP 0x001e3285
LAB_001e3285:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x150]
ADD RCX,0x1
MOV qword ptr [RAX + 0x150],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x158]
ADD RCX,0x1
MOV qword ptr [RAX + 0x158],RCX
CMP byte ptr [RBP + -0x2d],0x0
JZ 0x001e32c7
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e3d80
LAB_001e32c7:
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x2c]
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x18]
MOV R8D,0x4
CALL 0x001f4620
CMP RAX,0x0
JZ 0x001e32ef
MOV dword ptr [RBP + -0x34],0x1
LAB_001e32ef:
CMP byte ptr [RBP + -0x2d],0x0
JZ 0x001e3311
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
LEA RSI,[0x253fdc]
MOV EDX,0xb96
CALL 0x001e3360
LAB_001e3311:
JMP 0x001e3313
LAB_001e3313:
CMP byte ptr [RBP + -0x2d],0x0
JZ 0x001e3332
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001e4280
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
CALL 0x001e3d80
LAB_001e3332:
JMP 0x001e3334
LAB_001e3334:
JMP 0x001e3336
LAB_001e3336:
JMP 0x001e3338
LAB_001e3338:
CMP dword ptr [RBP + -0x34],0x0
JZ 0x001e3346
XOR EAX,EAX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001e334e
LAB_001e3346:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LAB_001e334e:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RSP,0x70
POP RBP
RET
|
void * simple_key_cache_read
(char *param_1,int4 param_2,ulong param_3,int4 param_4,void *param_5,
uint param_6)
{
int4 *puVar1;
long lVar2;
bool bVar3;
void *local_68;
int local_5c;
uint local_58;
uint local_54;
long local_50;
void *local_48;
uint local_3c;
char local_35;
uint local_34;
void *local_30;
int4 local_24;
ulong local_20;
int4 local_14;
char *local_10;
local_35 = '\0';
local_3c = 0;
local_48 = param_5;
local_34 = param_6;
local_30 = param_5;
local_24 = param_4;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
if (*param_1 == '\0') {
LAB_001e3285:
*(long *)(local_10 + 0x150) = *(long *)(local_10 + 0x150) + 1;
*(long *)(local_10 + 0x158) = *(long *)(local_10 + 0x158) + 1;
if (local_35 != '\0') {
inline_mysql_mutex_unlock(local_10 + 0xc0);
}
lVar2 = my_pread(local_14,local_30,local_34,local_20,4);
if (lVar2 != 0) {
local_3c = 1;
}
if (local_35 != '\0') {
inline_mysql_mutex_lock
(local_10 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xb96);
}
}
else {
inline_mysql_mutex_lock
(param_1 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0xaf2);
while( true ) {
bVar3 = false;
if (local_10[1] != '\0') {
bVar3 = local_10[2] == '\0';
}
if (!bVar3) break;
wait_on_queue(local_10 + 0x108,local_10 + 0xc0);
}
inc_counter_for_resize_op(local_10);
local_35 = '\x01';
local_58 = (uint)(local_20 % (ulong)*(uint *)(local_10 + 0x18));
do {
if (local_10[3] == '\0') goto LAB_001e3285;
local_20 = local_20 - local_58;
local_54 = local_34;
if (*(int *)(local_10 + 0x18) - local_58 < local_34) {
local_54 = *(int *)(local_10 + 0x18) - local_58;
}
*(long *)(local_10 + 0x150) = *(long *)(local_10 + 0x150) + 1;
local_50 = find_key_block(local_10,local_14,local_20,local_24,0,&local_5c);
if (local_50 == 0) {
*(long *)(local_10 + 0x158) = *(long *)(local_10 + 0x158) + 1;
inline_mysql_mutex_unlock(local_10 + 0xc0);
lVar2 = my_pread(local_14,local_30,local_54,local_20 + local_58);
local_3c = (uint)(lVar2 != 0);
inline_mysql_mutex_lock
(local_10 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xb29);
}
else {
if ((*(uint *)(local_50 + 0x50) & 1) == 0) {
if (local_5c == 1) {
read_block_primary(local_10,local_50,*(int4 *)(local_10 + 0x18),
local_54 + local_58);
}
else if (local_5c == 2) {
read_block_secondary(local_10,local_50);
}
else if (*(uint *)(local_50 + 0x4c) < local_54 + local_58) {
puVar1 = (int4 *)_my_thread_var();
*puVar1 = 0xffffffff;
*(uint *)(local_50 + 0x50) = *(uint *)(local_50 + 0x50) | 1;
}
}
if ((*(uint *)(local_50 + 0x50) & 1) == 0) {
inline_mysql_mutex_unlock(local_10 + 0xc0);
memcpy(local_30,(void *)(*(long *)(local_50 + 0x40) + (ulong)local_58),(ulong)local_54);
inline_mysql_mutex_lock
(local_10 + 0xc0,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0xb5e);
}
remove_reader(local_50);
if ((*(uint *)(local_50 + 0x50) & 1) != 0) {
free_block(local_10,local_50);
local_3c = 1;
break;
}
unreg_request(local_10,local_50,1);
}
local_30 = (void *)((long)local_30 + (ulong)local_54);
local_20 = (local_54 + local_58) + local_20;
local_58 = 0;
local_34 = local_34 - local_54;
} while (local_34 != 0);
}
if (local_35 != '\0') {
dec_counter_for_resize_op(local_10);
inline_mysql_mutex_unlock(local_10 + 0xc0);
}
if (local_3c == 0) {
local_68 = local_48;
}
else {
local_68 = (void *)0x0;
}
return local_68;
}
|
|
60,012
|
mysql_stmt_execute_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_execute_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_execute,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/*
If eg. mysql_change_user(), stmt->mysql will be NULL.
In this case, we cannot block.
*/
if (!stmt->mysql)
{
*ret= mysql_stmt_execute(stmt);
return 0;
})
}
|
O0
|
c
|
mysql_stmt_execute_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3ca08
movq -0x18(%rbp), %rdi
callq 0x2bbf0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3cb19
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xf2(%rip), %rsi # 0x3cb30
leaq -0x30(%rbp), %rdx
callq 0x3f180
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x3ca76
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3cb19
cmpl $0x0, -0x1c(%rbp)
jge 0x3cb05
jmp 0x3ca82
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x23436(%rip), %rax # 0x5fee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x23414(%rip), %rax # 0x5fef0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x3cb12
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_stmt_execute_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_3CA08
mov rdi, [rbp+var_18]
call mysql_stmt_execute
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 0
jmp loc_3CB19
loc_3CA08:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_execute_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_3CA76
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3CB19
loc_3CA76:
cmp [rbp+var_1C], 0
jge loc_3CB05
jmp short $+2
loc_3CA82:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_3CB12
loc_3CB05:
mov rax, [rbp+var_28]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
loc_3CB12:
mov [rbp+var_4], 0
loc_3CB19:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long mysql_stmt_execute_start(_DWORD *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
unsigned int *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
_DWORD *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(unsigned int **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_execute_start_internal, &v3);
*((_BYTE *)v4 + 21) = 0;
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[2];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
}
else
{
*v7 = mysql_stmt_execute(v6);
return 0;
}
}
|
mysql_stmt_execute_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x0013ca08
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012bbf0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013cb19
LAB_0013ca08:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x13cb30]
LEA RDX,[RBP + -0x30]
CALL 0x0013f180
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x0013ca76
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013cb19
LAB_0013ca76:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x0013cb05
JMP 0x0013ca82
LAB_0013ca82:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x15fee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x15fef0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x0013cb12
LAB_0013cb05:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
LAB_0013cb12:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013cb19:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_execute_start(int4 *param_1,long param_2)
{
int4 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int4 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_execute(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_execute_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0015ff30,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = local_30[2];
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
|
|
60,013
|
common_log::common_log(unsigned long)
|
monkey531[P]llama/common/log.cpp
|
common_log(size_t capacity) {
file = nullptr;
prefix = false;
timestamps = false;
running = false;
t_start = t_us();
// initial message size - will be expanded if longer messages arrive
entries.resize(capacity);
for (auto & entry : entries) {
entry.msg.resize(256);
}
head = 0;
tail = 0;
resume();
}
|
O3
|
cpp
|
common_log::common_log(unsigned long):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %r14, %rdi
callq 0x1ac60
leaq 0x78(%rbx), %r15
xorl %eax, %eax
movq %rax, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0xb0(%rbx)
movq %rax, 0xc0(%rbx)
movq %rax, 0x60(%rbx)
movl $0x0, 0x67(%rbx)
callq 0x1a090
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
movq %rdx, 0x70(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xcc0b4
movq 0x78(%rbx), %r12
movq 0x80(%rbx), %r13
cmpq %r13, %r12
je 0xcc050
leaq 0x10(%r12), %rdi
movl $0x100, %esi # imm = 0x100
callq 0x7e430
addq $0x30, %r12
jmp 0xcc036
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movq %rbx, %rdi
callq 0xcbad2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xcc06e
movq %rax, %r12
leaq 0xb0(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xcc08f
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %r15, %rdi
callq 0xcc0f6
movq %r14, %rdi
callq 0x1b040
cmpq $0x0, 0x28(%rbx)
jne 0xcc0ae
movq %r12, %rdi
callq 0x1afd0
callq 0x1a220
nop
|
_ZN10common_logC2Em:
push r15
push r14
push r13
push r12
push rbx
mov r12, rsi
mov rbx, rdi
lea r14, [rdi+30h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, r14; this
call __ZNSt18condition_variableC1Ev; std::condition_variable::condition_variable(void)
lea r15, [rbx+78h]
xor eax, eax
mov [rbx+88h], rax
xorps xmm0, xmm0
movups xmmword ptr [rbx+78h], xmm0
movups xmmword ptr [rbx+0B0h], xmm0
mov [rbx+0C0h], rax
mov [rbx+60h], rax
mov dword ptr [rbx+67h], 0
call __ZNSt6chrono3_V212system_clock3nowEv; std::chrono::_V2::system_clock::now(void)
mov rcx, 20C49BA5E353F7CFh
imul rcx
mov rax, rdx
shr rax, 3Fh
sar rdx, 7
add rdx, rax
mov [rbx+70h], rdx
mov rdi, r15
mov rsi, r12
call _ZNSt6vectorI16common_log_entrySaIS0_EE6resizeEm; std::vector<common_log_entry>::resize(ulong)
mov r12, [rbx+78h]
mov r13, [rbx+80h]
loc_CC036:
cmp r12, r13
jz short loc_CC050
lea rdi, [r12+10h]
mov esi, 100h
call _ZNSt6vectorIcSaIcEE6resizeEm; std::vector<char>::resize(ulong)
add r12, 30h ; '0'
jmp short loc_CC036
loc_CC050:
xorps xmm0, xmm0
movups xmmword ptr [rbx+90h], xmm0
mov rdi, rbx; this
call _ZN10common_log6resumeEv; common_log::resume(void)
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short $+2
loc_CC06E:
mov r12, rax
lea rax, [rbx+0B0h]
mov rdi, [rax]; void *
test rdi, rdi
jz short loc_CC08F
mov rsi, [rbx+0C0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CC08F:
mov rdi, r15
call _ZNSt6vectorI16common_log_entrySaIS0_EED2Ev; std::vector<common_log_entry>::~vector()
mov rdi, r14; this
call __ZNSt18condition_variableD1Ev; std::condition_variable::~condition_variable()
cmp qword ptr [rbx+28h], 0
jnz short loc_CC0AE
mov rdi, r12
call __Unwind_Resume
loc_CC0AE:
call __ZSt9terminatev; std::terminate(void)
|
void common_log::common_log(common_log *this, long long a2)
{
std::condition_variable *v3; // rdi
long long v4; // r12
long long v5; // r13
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 1) = 0LL;
*(_OWORD *)this = 0LL;
v3 = (common_log *)((char *)this + 48);
std::condition_variable::condition_variable(v3);
*((_QWORD *)this + 17) = 0LL;
*(_OWORD *)((char *)this + 120) = 0LL;
*((_OWORD *)this + 11) = 0LL;
*((_QWORD *)this + 24) = 0LL;
*((_QWORD *)this + 12) = 0LL;
*(_DWORD *)((char *)this + 103) = 0;
*((_QWORD *)this + 14) = std::chrono::_V2::system_clock::now(v3) / 1000LL;
std::vector<common_log_entry>::resize((char *)this + 120, a2);
v4 = *((_QWORD *)this + 15);
v5 = *((_QWORD *)this + 16);
while ( v4 != v5 )
{
std::vector<char>::resize((_QWORD *)(v4 + 16), 0x100uLL);
v4 += 48LL;
}
*((_OWORD *)this + 9) = 0LL;
common_log::resume(this);
}
|
common_log:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R12,RSI
MOV RBX,RDI
LEA R14,[RDI + 0x30]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,R14
CALL 0x0011ac60
LEA R15,[RBX + 0x78]
XOR EAX,EAX
MOV qword ptr [RBX + 0x88],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x78],XMM0
MOVUPS xmmword ptr [RBX + 0xb0],XMM0
MOV qword ptr [RBX + 0xc0],RAX
MOV qword ptr [RBX + 0x60],RAX
MOV dword ptr [RBX + 0x67],0x0
CALL 0x0011a090
MOV RCX,0x20c49ba5e353f7cf
IMUL RCX
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0x7
ADD RDX,RAX
MOV qword ptr [RBX + 0x70],RDX
LAB_001cc020:
MOV RDI,R15
MOV RSI,R12
CALL 0x001cc0b4
MOV R12,qword ptr [RBX + 0x78]
MOV R13,qword ptr [RBX + 0x80]
LAB_001cc036:
CMP R12,R13
JZ 0x001cc050
LEA RDI,[R12 + 0x10]
LAB_001cc040:
MOV ESI,0x100
CALL 0x0017e430
ADD R12,0x30
JMP 0x001cc036
LAB_001cc050:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x90],XMM0
LAB_001cc05a:
MOV RDI,RBX
CALL 0x001cbad2
LAB_001cc062:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* common_log::common_log(unsigned long) */
void __thiscall common_log::common_log(common_log *this,ulong param_1)
{
long lVar1;
long lVar2;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
std::condition_variable::condition_variable((condition_variable *)(this + 0x30));
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0xb0) = 0;
*(int8 *)(this + 0xb8) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 0x60) = 0;
*(int4 *)(this + 0x67) = 0;
lVar2 = std::chrono::_V2::system_clock::now();
*(long *)(this + 0x70) = lVar2 / 1000;
/* try { // try from 001cc020 to 001cc02a has its CatchHandler @ 001cc06c */
std::vector<common_log_entry,std::allocator<common_log_entry>>::resize
((vector<common_log_entry,std::allocator<common_log_entry>> *)(this + 0x78),param_1);
lVar1 = *(long *)(this + 0x80);
for (lVar2 = *(long *)(this + 0x78); lVar2 != lVar1; lVar2 = lVar2 + 0x30) {
/* try { // try from 001cc040 to 001cc049 has its CatchHandler @ 001cc06e */
std::vector<char,std::allocator<char>>::resize
((vector<char,std::allocator<char>> *)(lVar2 + 0x10),0x100);
}
*(int8 *)(this + 0x90) = 0;
*(int8 *)(this + 0x98) = 0;
/* try { // try from 001cc05a to 001cc061 has its CatchHandler @ 001cc06c */
resume(this);
return;
}
|
|
60,014
|
my_b_seq_read
|
eloqsql/mysys/mf_iocache.c
|
static int _my_b_seq_read(IO_CACHE *info, uchar *Buffer, size_t Count)
{
size_t length, diff_length, save_count, max_length;
my_off_t pos_in_file;
save_count=Count;
lock_append_buffer(info);
/* pos_in_file always point on where info->buffer was read */
if ((pos_in_file=info->pos_in_file +
(size_t) (info->read_end - info->buffer)) >= info->end_of_file)
goto read_append_buffer;
/*
With read-append cache we must always do a seek before we read,
because the write could have moved the file pointer astray
*/
if (mysql_file_seek(info->file, pos_in_file, MY_SEEK_SET, MYF(0)) == MY_FILEPOS_ERROR)
{
info->error= -1;
unlock_append_buffer(info);
return (1);
}
info->seek_not_done=0;
diff_length= (size_t) (pos_in_file & (IO_SIZE-1));
/* now the second stage begins - read from file descriptor */
if (Count >= (size_t) (IO_SIZE+(IO_SIZE-diff_length)))
{
/* Fill first intern buffer */
size_t read_length;
length= IO_ROUND_DN(Count) - diff_length;
if ((read_length= mysql_file_read(info->file,Buffer, length,
info->myflags)) == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
Count-=read_length;
Buffer+=read_length;
pos_in_file+=read_length;
if (read_length != length)
{
/*
We only got part of data; Read the rest of the data from the
write buffer
*/
goto read_append_buffer;
}
diff_length=0;
}
max_length= info->read_length-diff_length;
if (max_length > (info->end_of_file - pos_in_file))
max_length= (size_t) (info->end_of_file - pos_in_file);
if (!max_length)
{
if (Count)
goto read_append_buffer;
length=0; /* Didn't read any more chars */
}
else
{
length= mysql_file_read(info->file,info->buffer, max_length, info->myflags);
if (length == (size_t) -1)
{
info->error= -1;
unlock_append_buffer(info);
return 1;
}
if (length < Count)
{
memcpy(Buffer, info->buffer, length);
Count -= length;
Buffer += length;
/*
added the line below to make
DBUG_ASSERT(pos_in_file==info->end_of_file) pass.
otherwise this does not appear to be needed
*/
pos_in_file += length;
goto read_append_buffer;
}
}
unlock_append_buffer(info);
info->read_pos=info->buffer+Count;
info->read_end=info->buffer+length;
info->pos_in_file=pos_in_file;
memcpy(Buffer,info->buffer,(size_t) Count);
return 0;
read_append_buffer:
/*
Read data from the current write buffer.
Count should never be == 0 here (The code will work even if count is 0)
*/
{
/* First copy the data to Count */
size_t len_in_buff = (size_t) (info->write_pos - info->append_read_pos);
size_t copy_len;
size_t transfer_len;
DBUG_ASSERT(info->append_read_pos <= info->write_pos);
copy_len=MY_MIN(Count, len_in_buff);
memcpy(Buffer, info->append_read_pos, copy_len);
info->append_read_pos += copy_len;
Count -= copy_len;
if (Count)
info->error= (int) (save_count - Count);
/* Fill read buffer with data from write buffer */
memcpy(info->buffer, info->append_read_pos,
(size_t) (transfer_len=len_in_buff - copy_len));
info->read_pos= info->buffer;
info->read_end= info->buffer+transfer_len;
info->append_read_pos=info->write_pos;
info->pos_in_file=pos_in_file+copy_len;
info->end_of_file+=len_in_buff;
}
unlock_append_buffer(info);
return Count ? 1 : 0;
}
|
O0
|
c
|
my_b_seq_read:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq 0x7817b(%rip), %rsi # 0x15d3d6
movl $0x54c, %edx # imm = 0x54C
callq 0xe4730
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0xe5295
jmp 0xe553c
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x48(%rbp), %rcx
leaq 0x7812c(%rip), %rdi # 0x15d3d6
movl $0x557, %esi # imm = 0x557
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xe31d0
cmpq $-0x1, %rax
jne 0xe52e9
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe4860
movl $0x1, -0x4(%rbp)
jmp 0xe565e
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x48(%rbp), %rax
andq $0xfff, %rax # imm = 0xFFF
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x1000, %ecx # imm = 0x1000
subq -0x30(%rbp), %rcx
addq $0x1000, %rcx # imm = 0x1000
cmpq %rcx, %rax
jb 0xe53d5
movabsq $0xfffff000, %rax # imm = 0xFFFFF000
andq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x7807a(%rip), %rdi # 0x15d3d6
movl $0x569, %esi # imm = 0x569
callq 0xe5be0
movq %rax, -0x50(%rbp)
cmpq $-0x1, %rax
jne 0xe5397
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe4860
movl $0x1, -0x4(%rbp)
jmp 0xe565e
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xe53cd
jmp 0xe553c
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq -0x48(%rbp), %rcx
cmpq %rcx, %rax
jbe 0xe540d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xe542d
cmpq $0x0, -0x20(%rbp)
je 0xe5420
jmp 0xe553c
movq $0x0, -0x28(%rbp)
jmp 0xe54db
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x40(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
leaq 0x77f81(%rip), %rdi # 0x15d3d6
movl $0x589, %esi # imm = 0x589
callq 0xe5be0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xe5491
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe4860
movl $0x1, -0x4(%rbp)
jmp 0xe565e
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xe54d9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0x2a0c0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xe553c
jmp 0xe54db
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe4860
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0c0
movl $0x0, -0x4(%rbp)
jmp 0xe565e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x58(%rbp)
jmp 0xe5555
movq -0x20(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0xe5569
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0xe5571
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x60(%rbp), %rdx
callq 0x2a0c0
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq -0x60(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe55c8
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe4(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x58(%rbp), %rdx
subq -0x60(%rbp), %rdx
movq %rdx, -0x68(%rbp)
callq 0x2a0c0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x48(%rbp), %rcx
addq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0xe4860
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_my_b_seq_read:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 54Ch
call inline_mysql_mutex_lock_24
mov rax, [rbp+var_10]
mov rax, [rax]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov rdx, [rbp+var_10]
mov rdx, [rdx+20h]
sub rcx, rdx
add rax, rcx
mov [rbp+var_48], rax
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jb short loc_E5295
jmp loc_E553C
loc_E5295:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_48]
lea rdi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 557h
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E52E9
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_25
mov [rbp+var_4], 1
jmp loc_E565E
loc_E52E9:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
mov rax, [rbp+var_48]
and rax, 0FFFh
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov ecx, 1000h
sub rcx, [rbp+var_30]
add rcx, 1000h
cmp rax, rcx
jb loc_E53D5
mov rax, 0FFFFF000h
and rax, [rbp+var_20]
sub rax, [rbp+var_30]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_28]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 569h
call inline_mysql_file_read_5
mov [rbp+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E5397
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_25
mov [rbp+var_4], 1
jmp loc_E565E
loc_E5397:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_50]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
mov rax, [rbp+var_50]
cmp rax, [rbp+var_28]
jz short loc_E53CD
jmp loc_E553C
loc_E53CD:
mov [rbp+var_30], 0
loc_E53D5:
mov rax, [rbp+var_10]
mov rax, [rax+0F0h]
sub rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
mov rcx, [rcx+8]
sub rcx, [rbp+var_48]
cmp rax, rcx
jbe short loc_E540D
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rax, [rbp+var_48]
mov [rbp+var_40], rax
loc_E540D:
cmp [rbp+var_40], 0
jnz short loc_E542D
cmp [rbp+var_20], 0
jz short loc_E5420
jmp loc_E553C
loc_E5420:
mov [rbp+var_28], 0
jmp loc_E54DB
loc_E542D:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8, [rbp+var_40]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
lea rdi, aWorkspaceLlm4b_39; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 589h
call inline_mysql_file_read_5
mov [rbp+var_28], rax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
jnz short loc_E5491
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_25
mov [rbp+var_4], 1
jmp loc_E565E
loc_E5491:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_20]
jnb short loc_E54D9
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_28]
call _memcpy
mov rcx, [rbp+var_28]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_48]
mov [rbp+var_48], rax
jmp short loc_E553C
loc_E54D9:
jmp short $+2
loc_E54DB:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_25
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+20h]
mov rdx, [rbp+var_20]
call _memcpy
mov [rbp+var_4], 0
jmp loc_E565E
loc_E553C:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+38h]
sub rax, rcx
mov [rbp+var_58], rax
jmp short $+2
loc_E5555:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_58]
jnb short loc_E5569
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
jmp short loc_E5571
loc_E5569:
mov rax, [rbp+var_58]
mov [rbp+var_70], rax
loc_E5571:
mov rax, [rbp+var_70]
mov [rbp+var_60], rax
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_60]
call _memcpy
mov rcx, [rbp+var_60]
mov rax, [rbp+var_10]
add rcx, [rax+38h]
mov [rax+38h], rcx
mov rcx, [rbp+var_60]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_E55C8
mov rax, [rbp+var_38]
sub rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax+0E4h], ecx
loc_E55C8:
mov rax, [rbp+var_10]
mov rdi, [rax+20h]
mov rax, [rbp+var_10]
mov rsi, [rax+38h]
mov rdx, [rbp+var_58]
sub rdx, [rbp+var_60]
mov [rbp+var_68], rdx
call _memcpy
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
add rcx, [rbp+var_68]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_10]
mov [rax+38h], rcx
mov rcx, [rbp+var_48]
add rcx, [rbp+var_60]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
call inline_mysql_mutex_unlock_25
mov rdx, [rbp+var_20]
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_E565E:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
_BOOL8 my_b_seq_read(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-70h]
unsigned long long v5; // [rsp+18h] [rbp-58h]
long long v6; // [rsp+20h] [rbp-50h]
unsigned long long v7; // [rsp+28h] [rbp-48h]
unsigned long long v8; // [rsp+30h] [rbp-40h]
int v9; // [rsp+38h] [rbp-38h]
unsigned long long v10; // [rsp+40h] [rbp-30h]
unsigned long long v11; // [rsp+48h] [rbp-28h]
unsigned long long v12; // [rsp+48h] [rbp-28h]
unsigned long long v13; // [rsp+50h] [rbp-20h]
unsigned long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
v15 = a2;
v13 = a3;
v9 = a3;
inline_mysql_mutex_lock_24(a1 + 80, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c", 0x54Cu);
v7 = *(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 32) + *(_QWORD *)a1;
if ( v7 >= *(_QWORD *)(a1 + 8) )
goto LABEL_18;
if ( inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x557u,
*(_DWORD *)(a1 + 212),
v7,
0,
0LL) == -1 )
goto LABEL_14;
*(_DWORD *)(a1 + 224) = 0;
v10 = v7 & 0xFFF;
if ( v13 >= 4096 - v10 + 4096 )
{
v11 = ((unsigned int)v13 & 0xFFFFF000) - v10;
v6 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1385LL,
*(unsigned int *)(a1 + 212),
a2,
v11,
*(_QWORD *)(a1 + 248));
if ( v6 == -1 )
goto LABEL_14;
v13 -= v6;
v15 = a2 + v6;
v7 += v6;
if ( v6 != v11 )
goto LABEL_18;
v10 = 0LL;
}
v8 = *(_QWORD *)(a1 + 240) - v10;
if ( v8 > *(_QWORD *)(a1 + 8) - v7 )
v8 = *(_QWORD *)(a1 + 8) - v7;
if ( v8 )
{
v12 = inline_mysql_file_read_5(
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
1417LL,
*(unsigned int *)(a1 + 212),
*(_QWORD *)(a1 + 32),
v8,
*(_QWORD *)(a1 + 248));
if ( v12 == -1LL )
{
LABEL_14:
*(_DWORD *)(a1 + 228) = -1;
inline_mysql_mutex_unlock_25(a1 + 80);
return 1;
}
if ( v12 >= v13 )
{
LABEL_17:
inline_mysql_mutex_unlock_25(a1 + 80);
*(_QWORD *)(a1 + 16) = v13 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v12 + *(_QWORD *)(a1 + 32);
*(_QWORD *)a1 = v7;
memcpy(v15, *(_QWORD *)(a1 + 32), v13);
return 0;
}
memcpy(v15, *(_QWORD *)(a1 + 32), v12);
v13 -= v12;
v15 += v12;
v7 += v12;
}
else if ( !v13 )
{
v12 = 0LL;
goto LABEL_17;
}
LABEL_18:
v5 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
if ( v13 >= v5 )
v4 = *(_QWORD *)(a1 + 64) - *(_QWORD *)(a1 + 56);
else
v4 = v13;
memcpy(v15, *(_QWORD *)(a1 + 56), v4);
*(_QWORD *)(a1 + 56) += v4;
v14 = v13 - v4;
if ( v14 )
*(_DWORD *)(a1 + 228) = v9 - v14;
memcpy(*(_QWORD *)(a1 + 32), *(_QWORD *)(a1 + 56), v5 - v4);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 24) = v5 - v4 + *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 56) = *(_QWORD *)(a1 + 64);
*(_QWORD *)a1 = v4 + v7;
*(_QWORD *)(a1 + 8) += v5;
inline_mysql_mutex_unlock_25(a1 + 80);
return v14 != 0;
}
|
_my_b_seq_read:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[0x25d3d6]
MOV EDX,0x54c
CALL 0x001e4730
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x20]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JC 0x001e5295
JMP 0x001e553c
LAB_001e5295:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x48]
LEA RDI,[0x25d3d6]
MOV ESI,0x557
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001e31d0
CMP RAX,-0x1
JNZ 0x001e52e9
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e4860
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e565e
LAB_001e52e9:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
MOV RAX,qword ptr [RBP + -0x48]
AND RAX,0xfff
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,0x1000
SUB RCX,qword ptr [RBP + -0x30]
ADD RCX,0x1000
CMP RAX,RCX
JC 0x001e53d5
MOV RAX,0xfffff000
AND RAX,qword ptr [RBP + -0x20]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x25d3d6]
MOV ESI,0x569
CALL 0x001e5be0
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,-0x1
JNZ 0x001e5397
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e4860
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e565e
LAB_001e5397:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x001e53cd
JMP 0x001e553c
LAB_001e53cd:
MOV qword ptr [RBP + -0x30],0x0
LAB_001e53d5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf0]
SUB RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,qword ptr [RBP + -0x48]
CMP RAX,RCX
JBE 0x001e540d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x40],RAX
LAB_001e540d:
CMP qword ptr [RBP + -0x40],0x0
JNZ 0x001e542d
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e5420
JMP 0x001e553c
LAB_001e5420:
MOV qword ptr [RBP + -0x28],0x0
JMP 0x001e54db
LAB_001e542d:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
LEA RDI,[0x25d3d6]
MOV ESI,0x589
CALL 0x001e5be0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],-0x1
JNZ 0x001e5491
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e4860
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e565e
LAB_001e5491:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001e54d9
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x0012a0c0
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001e553c
LAB_001e54d9:
JMP 0x001e54db
LAB_001e54db:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e4860
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0c0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e565e
LAB_001e553c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001e5555
LAB_001e5555:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x58]
JNC 0x001e5569
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x001e5571
LAB_001e5569:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x70],RAX
LAB_001e5571:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x60]
CALL 0x0012a0c0
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x38]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e55c8
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],ECX
LAB_001e55c8:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RBP + -0x58]
SUB RDX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RDX
CALL 0x0012a0c0
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
ADD RCX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RBP + -0x48]
ADD RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
CALL 0x001e4860
MOV RDX,qword ptr [RBP + -0x20]
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001e565e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
bool _my_b_seq_read(ulong *param_1,void *param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
long lVar3;
size_t local_78;
ulong local_50;
ulong local_48;
ulong local_38;
ulong local_30;
ulong local_28;
void *local_20;
inline_mysql_mutex_lock
(param_1 + 10,"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x54c);
local_50 = *param_1 + (param_1[3] - param_1[4]);
local_28 = param_3;
local_20 = param_2;
if (local_50 < param_1[1]) {
lVar3 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x557,
*(int4 *)((long)param_1 + 0xd4),local_50,0,0);
if (lVar3 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
*(int4 *)(param_1 + 0x1c) = 0;
local_38 = local_50 & 0xfff;
if (0x2000 - local_38 <= param_3) {
lVar3 = (param_3 & 0xfffff000) - local_38;
lVar1 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x569,
*(int4 *)((long)param_1 + 0xd4),param_2,lVar3,param_1[0x1f]);
if (lVar1 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
local_28 = param_3 - lVar1;
local_20 = (void *)(lVar1 + (long)param_2);
local_50 = lVar1 + local_50;
if (lVar1 != lVar3) goto LAB_001e553c;
local_38 = 0;
}
local_48 = param_1[0x1e] - local_38;
if (param_1[1] - local_50 < local_48) {
local_48 = param_1[1] - local_50;
}
if (local_48 == 0) {
if (local_28 == 0) {
local_30 = 0;
LAB_001e54db:
inline_mysql_mutex_unlock(param_1 + 10);
param_1[2] = param_1[4] + local_28;
param_1[3] = param_1[4] + local_30;
*param_1 = local_50;
memcpy(local_20,(void *)param_1[4],local_28);
return false;
}
}
else {
local_30 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x589,
*(int4 *)((long)param_1 + 0xd4),param_1[4],local_48,param_1[0x1f])
;
if (local_30 == 0xffffffffffffffff) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
inline_mysql_mutex_unlock(param_1 + 10);
return true;
}
if (local_28 <= local_30) goto LAB_001e54db;
memcpy(local_20,(void *)param_1[4],local_30);
local_28 = local_28 - local_30;
local_20 = (void *)(local_30 + (long)local_20);
local_50 = local_30 + local_50;
}
}
LAB_001e553c:
uVar2 = param_1[8] - param_1[7];
local_78 = uVar2;
if (local_28 < uVar2) {
local_78 = local_28;
}
memcpy(local_20,(void *)param_1[7],local_78);
param_1[7] = local_78 + param_1[7];
lVar3 = local_28 - local_78;
if (lVar3 != 0) {
*(int *)((long)param_1 + 0xe4) = (int)param_3 - (int)lVar3;
}
memcpy((void *)param_1[4],(void *)param_1[7],uVar2 - local_78);
param_1[2] = param_1[4];
param_1[3] = param_1[4] + (uVar2 - local_78);
param_1[7] = param_1[8];
*param_1 = local_50 + local_78;
param_1[1] = uVar2 + param_1[1];
inline_mysql_mutex_unlock(param_1 + 10);
return lVar3 != 0;
}
|
|
60,015
|
nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment()
|
monkey531[P]llama/common/json.hpp
|
bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
case '\r':
case char_traits<char_type>::eof():
case '\0':
return true;
default:
break;
}
}
}
// multi-line comments skip input until */ is read
case '*':
{
while (true)
{
switch (get())
{
case char_traits<char_type>::eof():
case '\0':
{
error_message = "invalid comment; missing closing '*/'";
return false;
}
case '*':
{
switch (get())
{
case '/':
return true;
default:
{
unget();
continue;
}
}
}
default:
continue;
}
}
}
// unexpected character after reading '/'
default:
{
error_message = "invalid comment; expecting '/' or '*' after '/'";
return false;
}
}
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::lexer<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>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::scan_comment():
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x415a6
cmpl $0x2f, %eax
je 0x40d6e
cmpl $0x2a, %eax
jne 0x40d8b
movq %rbx, %rdi
callq 0x415a6
cmpl $0x2a, %eax
je 0x40d57
incl %eax
cmpl $0x2, %eax
jae 0x40d41
jmp 0x40d94
movq %rbx, %rdi
callq 0x415a6
cmpl $0x2f, %eax
je 0x40d87
movq %rbx, %rdi
callq 0x4161c
jmp 0x40d41
movl $0x4803, %ebp # imm = 0x4803
movq %rbx, %rdi
callq 0x415a6
incl %eax
cmpl $0xf, %eax
jae 0x40d73
btl %eax, %ebp
jae 0x40d73
movb $0x1, %al
jmp 0x40da1
leaq 0x71545(%rip), %rax # 0xb22d7
jmp 0x40d9b
leaq 0x71516(%rip), %rax # 0xb22b1
movq %rax, 0x70(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE12scan_commentEv:
push rbp
push rbx
push rax
mov rbx, rdi
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_40D6E
cmp eax, 2Ah ; '*'
jnz short loc_40D8B
loc_40D41:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Ah ; '*'
jz short loc_40D57
inc eax
cmp eax, 2
jnb short loc_40D41
jmp short loc_40D94
loc_40D57:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
cmp eax, 2Fh ; '/'
jz short loc_40D87
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5ungetEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(void)
jmp short loc_40D41
loc_40D6E:
mov ebp, 4803h
loc_40D73:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE3getEv; nlohmann::json_abi_v3_11_3::detail::lexer<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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(void)
inc eax
cmp eax, 0Fh
jnb short loc_40D73
bt ebp, eax
jnb short loc_40D73
loc_40D87:
mov al, 1
jmp short loc_40DA1
loc_40D8B:
lea rax, aInvalidComment; "invalid comment; expecting '/' or '*' a"...
jmp short loc_40D9B
loc_40D94:
lea rax, aInvalidComment_0; "invalid comment; missing closing '*/'"
loc_40D9B:
mov [rbx+70h], rax
xor eax, eax
loc_40DA1:
add rsp, 8
pop rbx
pop rbp
retn
|
char nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::scan_comment(
long long a1)
{
int v1; // eax
int v2; // eax
int v3; // ebp
unsigned int v4; // eax
const char *v6; // rax
v1 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( v1 == 47 )
{
v3 = 18435;
do
{
do
v4 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1)
+ 1;
while ( v4 >= 0xF );
}
while ( !_bittest(&v3, v4) );
return 1;
}
else
{
if ( v1 == 42 )
{
do
{
while ( 1 )
{
v2 = nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1);
if ( v2 != 42 )
break;
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get(a1) == 47 )
return 1;
nlohmann::json_abi_v3_11_3::detail::lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::unget(a1);
}
}
while ( (unsigned int)(v2 + 1) >= 2 );
v6 = "invalid comment; missing closing '*/'";
}
else
{
v6 = "invalid comment; expecting '/' or '*' after '/'";
}
*(_QWORD *)(a1 + 112) = v6;
return 0;
}
}
|
scan_comment:
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x001415a6
CMP EAX,0x2f
JZ 0x00140d6e
CMP EAX,0x2a
JNZ 0x00140d8b
LAB_00140d41:
MOV RDI,RBX
CALL 0x001415a6
CMP EAX,0x2a
JZ 0x00140d57
INC EAX
CMP EAX,0x2
JNC 0x00140d41
JMP 0x00140d94
LAB_00140d57:
MOV RDI,RBX
CALL 0x001415a6
CMP EAX,0x2f
JZ 0x00140d87
MOV RDI,RBX
CALL 0x0014161c
JMP 0x00140d41
LAB_00140d6e:
MOV EBP,0x4803
LAB_00140d73:
MOV RDI,RBX
CALL 0x001415a6
INC EAX
CMP EAX,0xf
JNC 0x00140d73
BT EBP,EAX
JNC 0x00140d73
LAB_00140d87:
MOV AL,0x1
JMP 0x00140da1
LAB_00140d8b:
LEA RAX,[0x1b22d7]
JMP 0x00140d9b
LAB_00140d94:
LEA RAX,[0x1b22b1]
LAB_00140d9b:
MOV qword ptr [RBX + 0x70],RAX
XOR EAX,EAX
LAB_00140da1:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer<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>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::scan_comment() */
int8 __thiscall
nlohmann::json_abi_v3_11_3::detail::
lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::scan_comment(lexer<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>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
int iVar1;
int8 uVar2;
char *pcVar3;
iVar1 = get(this);
if (iVar1 == 0x2f) {
do {
do {
iVar1 = get(this);
} while (0xe < iVar1 + 1U);
} while ((0x4803U >> (iVar1 + 1U & 0x1f) & 1) == 0);
LAB_00140d87:
uVar2 = 1;
}
else {
if (iVar1 == 0x2a) {
do {
while (iVar1 = get(this), iVar1 == 0x2a) {
iVar1 = get(this);
if (iVar1 == 0x2f) goto LAB_00140d87;
unget(this);
}
} while (1 < iVar1 + 1U);
pcVar3 = "invalid comment; missing closing \'*/\'";
}
else {
pcVar3 = "invalid comment; expecting \'/\' or \'*\' after \'/\'";
}
*(char **)(this + 0x70) = pcVar3;
uVar2 = 0;
}
return uVar2;
}
|
|
60,016
|
mysql_ssl_set
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
int STDCALL
mysql_ssl_set(MYSQL *mysql __attribute__((unused)),
const char *key __attribute__((unused)),
const char *cert __attribute__((unused)),
const char *ca __attribute__((unused)),
const char *capath __attribute__((unused)),
const char *cipher __attribute__((unused)))
{
#ifdef HAVE_TLS
char enable= 1;
return (mysql_optionsv(mysql, MYSQL_OPT_SSL_ENFORCE, &enable) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_KEY, key) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CERT, cert) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CA, ca) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CAPATH, capath) |
mysql_optionsv(mysql, MYSQL_OPT_SSL_CIPHER, cipher)) ? 1 : 0;
#else
return 0;
#endif
}
|
O0
|
c
|
mysql_ssl_set:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x8(%rbp), %rdi
movl $0x26, %esi
leaq -0x31(%rbp), %rdx
movb $0x0, %al
callq 0x18340
movl %eax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x19, %esi
movb $0x0, %al
callq 0x18340
movl %eax, %ecx
movl -0x48(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1a, %esi
movb $0x0, %al
callq 0x18340
movl %eax, %ecx
movl -0x44(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x1b, %esi
movb $0x0, %al
callq 0x18340
movl %eax, %ecx
movl -0x40(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0x1c, %esi
movb $0x0, %al
callq 0x18340
movl %eax, %ecx
movl -0x3c(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x1d, %esi
movb $0x0, %al
callq 0x18340
movl -0x38(%rbp), %edx
orl %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
|
mysql_ssl_set:
push rbp
mov rbp, rsp
sub rsp, 50h
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 [rbp+var_30], r9
mov [rbp+var_31], 1
mov rdi, [rbp+var_8]
mov esi, 26h ; '&'
lea rdx, [rbp+var_31]
mov al, 0
call mysql_optionsv
mov [rbp+var_48], eax
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov esi, 19h
mov al, 0
call mysql_optionsv
mov ecx, eax
mov eax, [rbp+var_48]
or eax, ecx
mov [rbp+var_44], eax
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_18]
mov esi, 1Ah
mov al, 0
call mysql_optionsv
mov ecx, eax
mov eax, [rbp+var_44]
or eax, ecx
mov [rbp+var_40], eax
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_20]
mov esi, 1Bh
mov al, 0
call mysql_optionsv
mov ecx, eax
mov eax, [rbp+var_40]
or eax, ecx
mov [rbp+var_3C], eax
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_28]
mov esi, 1Ch
mov al, 0
call mysql_optionsv
mov ecx, eax
mov eax, [rbp+var_3C]
or eax, ecx
mov [rbp+var_38], eax
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_30]
mov esi, 1Dh
mov al, 0
call mysql_optionsv
mov edx, [rbp+var_38]
or edx, eax
xor eax, eax
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
add rsp, 50h
pop rbp
retn
|
_BOOL8 mysql_ssl_set(long long a1, _DWORD *a2, _DWORD *a3, _DWORD *a4, _DWORD *a5, _DWORD *a6)
{
int v7; // [rsp+8h] [rbp-48h]
int v8; // [rsp+Ch] [rbp-44h]
int v9; // [rsp+10h] [rbp-40h]
int v10; // [rsp+14h] [rbp-3Ch]
int v11; // [rsp+18h] [rbp-38h]
char v12; // [rsp+1Fh] [rbp-31h] BYREF
_DWORD *v13; // [rsp+20h] [rbp-30h]
_DWORD *v14; // [rsp+28h] [rbp-28h]
_DWORD *v15; // [rsp+30h] [rbp-20h]
_DWORD *v16; // [rsp+38h] [rbp-18h]
_DWORD *v17; // [rsp+40h] [rbp-10h]
long long v18; // [rsp+48h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v12 = 1;
v7 = mysql_optionsv(a1, 38, &v12);
v8 = mysql_optionsv(v18, 25, v17) | v7;
v9 = mysql_optionsv(v18, 26, v16) | v8;
v10 = mysql_optionsv(v18, 27, v15) | v9;
v11 = mysql_optionsv(v18, 28, v14) | v10;
return ((unsigned int)mysql_optionsv(v18, 29, v13) | v11) != 0;
}
|
mysql_ssl_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
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 qword ptr [RBP + -0x30],R9
MOV byte ptr [RBP + -0x31],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,0x26
LEA RDX,[RBP + -0x31]
MOV AL,0x0
CALL 0x00118340
MOV dword ptr [RBP + -0x48],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV ESI,0x19
MOV AL,0x0
CALL 0x00118340
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x48]
OR EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x18]
MOV ESI,0x1a
MOV AL,0x0
CALL 0x00118340
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x44]
OR EAX,ECX
MOV dword ptr [RBP + -0x40],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x20]
MOV ESI,0x1b
MOV AL,0x0
CALL 0x00118340
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x40]
OR EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x28]
MOV ESI,0x1c
MOV AL,0x0
CALL 0x00118340
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x3c]
OR EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x30]
MOV ESI,0x1d
MOV AL,0x0
CALL 0x00118340
MOV EDX,dword ptr [RBP + -0x38]
OR EDX,EAX
XOR EAX,EAX
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
ADD RSP,0x50
POP RBP
RET
|
bool mysql_ssl_set(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int1 local_39;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
local_39 = 1;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
iVar1 = mysql_optionsv(param_1,0x26,&local_39);
iVar2 = mysql_optionsv(local_10,0x19,local_18);
iVar3 = mysql_optionsv(local_10,0x1a,local_20);
iVar4 = mysql_optionsv(local_10,0x1b,local_28);
iVar5 = mysql_optionsv(local_10,0x1c,local_30);
iVar6 = mysql_optionsv(local_10,0x1d,local_38);
return ((((iVar1 != 0 || iVar2 != 0) || iVar3 != 0) || iVar4 != 0) || iVar5 != 0) || iVar6 != 0;
}
|
|
60,017
|
my_rw_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_rdlock(my_rw_lock_t *rwp)
{
pthread_mutex_lock(&rwp->lock);
/* active or queued writers */
while (( rwp->state < 0 ) || rwp->waiters)
pthread_cond_wait( &rwp->readers, &rwp->lock);
rwp->state++;
pthread_mutex_unlock(&rwp->lock);
return(0);
}
|
O3
|
c
|
my_rw_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x28560
leaq 0x28(%rbx), %r14
movl 0x88(%rbx), %eax
testl %eax, %eax
js 0x5e74a
cmpl $0x0, 0x8c(%rbx)
je 0x5e757
movq %r14, %rdi
movq %rbx, %rsi
callq 0x285e0
jmp 0x5e737
incl %eax
movl %eax, 0x88(%rbx)
movq %rbx, %rdi
callq 0x28270
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_rdlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
lea r14, [rbx+28h]
loc_5E737:
mov eax, [rbx+88h]
test eax, eax
js short loc_5E74A
cmp dword ptr [rbx+8Ch], 0
jz short loc_5E757
loc_5E74A:
mov rdi, r14
mov rsi, rbx
call _pthread_cond_wait
jmp short loc_5E737
loc_5E757:
inc eax
mov [rbx+88h], eax
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_rdlock(long long a1)
{
int v1; // eax
pthread_mutex_lock(a1);
while ( 1 )
{
v1 = *(_DWORD *)(a1 + 136);
if ( v1 >= 0 && !*(_DWORD *)(a1 + 140) )
break;
pthread_cond_wait(a1 + 40, a1);
}
*(_DWORD *)(a1 + 136) = v1 + 1;
pthread_mutex_unlock(a1);
return 0LL;
}
|
my_rw_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x00128560
LEA R14,[RBX + 0x28]
LAB_0015e737:
MOV EAX,dword ptr [RBX + 0x88]
TEST EAX,EAX
JS 0x0015e74a
CMP dword ptr [RBX + 0x8c],0x0
JZ 0x0015e757
LAB_0015e74a:
MOV RDI,R14
MOV RSI,RBX
CALL 0x001285e0
JMP 0x0015e737
LAB_0015e757:
INC EAX
MOV dword ptr [RBX + 0x88],EAX
MOV RDI,RBX
CALL 0x00128270
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
while ((*(int *)((long)param_1 + 0x88) < 0 || (*(int *)((long)param_1 + 0x8c) != 0))) {
pthread_cond_wait((pthread_cond_t *)(param_1 + 1),param_1);
}
*(int *)((long)param_1 + 0x88) = *(int *)((long)param_1 + 0x88) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
60,018
|
alaya::SequentialStorageTest_RemoveTest_Test::~SequentialStorageTest_RemoveTest_Test()
|
AlayaLite/tests/storage/sequential_storage_test.cpp
|
TEST_F(SequentialStorageTest, RemoveTest) {
alaya::SequentialStorage<int, uint32_t> storage;
storage.init(sizeof(int), 10, 64);
int data1 = 42;
uint32_t id1 = storage.insert(&data1);
EXPECT_TRUE(storage.is_valid(id1));
storage.remove(id1);
EXPECT_FALSE(storage.is_valid(id1));
}
|
O0
|
cpp
|
alaya::SequentialStorageTest_RemoveTest_Test::~SequentialStorageTest_RemoveTest_Test():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf9c0
movq 0x8(%rsp), %rax
leaq 0x8a7fc(%rip), %rcx # 0x9a7e0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
|
_ZN5alaya37SequentialStorageTest_RemoveTest_TestC2Ev:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]; this
mov [rsp+18h+var_10], rdi
call _ZN5alaya21SequentialStorageTestC2Ev; alaya::SequentialStorageTest::SequentialStorageTest(void)
mov rax, [rsp+18h+var_10]
lea rcx, _ZTVN5alaya37SequentialStorageTest_RemoveTest_TestE; `vtable for'alaya::SequentialStorageTest_RemoveTest_Test
add rcx, 10h
mov [rax], rcx
add rsp, 18h
retn
|
alaya::SequentialStorageTest_RemoveTest_Test * alaya::SequentialStorageTest_RemoveTest_Test::SequentialStorageTest_RemoveTest_Test(
alaya::SequentialStorageTest_RemoveTest_Test *this)
{
alaya::SequentialStorageTest_RemoveTest_Test *result; // rax
alaya::SequentialStorageTest::SequentialStorageTest(this);
result = this;
*(_QWORD *)this = &`vtable for'alaya::SequentialStorageTest_RemoveTest_Test + 2;
return result;
}
|
SequentialStorageTest_RemoveTest_Test:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0010f9c0
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x19a7e0]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x18
RET
|
/* alaya::SequentialStorageTest_RemoveTest_Test::SequentialStorageTest_RemoveTest_Test() */
void __thiscall
alaya::SequentialStorageTest_RemoveTest_Test::SequentialStorageTest_RemoveTest_Test
(SequentialStorageTest_RemoveTest_Test *this)
{
SequentialStorageTest::SequentialStorageTest((SequentialStorageTest *)this);
*(int ***)this = &PTR__SequentialStorageTest_RemoveTest_Test_0019a7f0;
return;
}
|
|
60,019
|
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>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/json.hpp
|
iterator find(const key_type& key)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
}
|
O2
|
cpp
|
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>>>>::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x7f061
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b054
testb %al, %al
jne 0x7f05e
addq $0x30, %r14
jmp 0x7f040
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findERSH_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_7F040:
mov rax, [r15+8]
cmp r14, rax
jz short loc_7F061
mov rdi, r14
mov rsi, rbx
call _ZSteqIcEN9__gnu_cxx11__enable_ifIXsr9__is_charIT_EE7__valueEbE6__typeERKNSt7__cxx1112basic_stringIS2_St11char_traitsIS2_ESaIS2_EEESC_
test al, al
jnz short loc_7F05E
add r14, 30h ; '0'
jmp short loc_7F040
loc_7F05E:
mov rax, r14
loc_7F061:
pop rbx
pop r14
pop r15
retn
|
_QWORD * nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>::find(
long long a1,
_QWORD *a2)
{
_QWORD *i; // r14
_QWORD *result; // rax
for ( i = *(_QWORD **)a1; ; i += 6 )
{
result = *(_QWORD **)(a1 + 8);
if ( i == result )
break;
if ( std::operator==<char>(i, a2) )
return i;
}
return result;
}
|
find:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_0017f040:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x0017f061
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013b054
TEST AL,AL
JNZ 0x0017f05e
ADD R14,0x30
JMP 0x0017f040
LAB_0017f05e:
MOV RAX,R14
LAB_0017f061:
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,
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::less<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> > > >::find(std::__cxx11::string const&) */
string * __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,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::less<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>>>>
::find(ordered_map<std::__cxx11::string,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::less<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>>>>
*this,string *param_1)
{
char cVar1;
string *psVar2;
string *psVar3;
psVar3 = *(string **)this;
while ((psVar2 = *(string **)(this + 8), psVar3 != *(string **)(this + 8) &&
(cVar1 = std::operator==(psVar3,param_1), psVar2 = psVar3, cVar1 == '\0'))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
|
|
60,020
|
my_hash_sort_ucs2_bin
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_ucs2_bin(CHARSET_INFO *cs,
const uchar *key, size_t len, ulong *nr1, ulong *nr2)
{
size_t lengthsp= my_lengthsp_mb2(cs, (const char *) key, len);
my_hash_sort_ucs2_nopad_bin(cs, key, lengthsp, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_ucs2_bin:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0xca6d9
cmpb $0x20, -0x1(%rsi,%rax)
jne 0xca6d1
leaq -0x2(%rax), %rdx
cmpb $0x0, -0x2(%rsi,%rax)
je 0xca6b6
movq (%rcx), %rdx
movq (%r8), %rdi
jmp 0xca6e5
movq (%rcx), %rdx
movq (%r8), %rdi
cmpq $0x1, %rax
jne 0xca718
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rax
movl %edx, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rdx, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rdx
addq $0x3, %rdi
incq %rsi
cmpq %rax, %rsi
jb 0xca6ec
popq %rbp
movq %rdx, (%rcx)
movq %rdi, (%r8)
retq
|
my_hash_sort_ucs2_bin:
mov rax, rdx
cmp rdx, 2
jl short loc_CA6D9
cmp byte ptr [rsi+rax-1], 20h ; ' '
jnz short loc_CA6D1
lea rdx, [rax-2]
cmp byte ptr [rsi+rax-2], 0
jz short my_hash_sort_ucs2_bin
loc_CA6D1:
mov rdx, [rcx]
mov rdi, [r8]
jmp short loc_CA6E5
loc_CA6D9:
mov rdx, [rcx]
mov rdi, [r8]
cmp rax, 1
jnz short loc_CA718
loc_CA6E5:
push rbp
mov rbp, rsp
add rax, rsi
loc_CA6EC:
mov r9d, edx
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rdx
shl r9, 8
add r9, r10
xor rdx, r9
add rdi, 3
inc rsi
cmp rsi, rax
jb short loc_CA6EC
pop rbp
loc_CA718:
mov [rcx], rdx
mov [r8], rdi
retn
|
unsigned long long my_hash_sort_ucs2_bin(
long long a1,
unsigned long long a2,
long long a3,
long long *a4,
long long *a5)
{
unsigned long long result; // rax
long long v6; // rdx
long long v7; // rdi
while ( 1 )
{
result = a3;
if ( a3 < 2 )
break;
if ( *(_BYTE *)(a2 + a3 - 1) == 32 )
{
a3 -= 2LL;
if ( !*(_BYTE *)(a2 + result - 2) )
continue;
}
v6 = *a4;
v7 = *a5;
goto LABEL_6;
}
v6 = *a4;
v7 = *a5;
if ( result != 1 )
goto LABEL_8;
LABEL_6:
result += a2;
do
{
v6 ^= (v7 + (v6 & 0x3F)) * *(unsigned __int8 *)a2 + (v6 << 8);
v7 += 3LL;
++a2;
}
while ( a2 < result );
LABEL_8:
*a4 = v6;
*a5 = v7;
return result;
}
|
my_hash_sort_ucs2_bin:
MOV RAX,RDX
CMP RDX,0x2
JL 0x001ca6d9
CMP byte ptr [RSI + RAX*0x1 + -0x1],0x20
JNZ 0x001ca6d1
LEA RDX,[RAX + -0x2]
CMP byte ptr [RSI + RAX*0x1 + -0x2],0x0
JZ 0x001ca6b6
LAB_001ca6d1:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
JMP 0x001ca6e5
LAB_001ca6d9:
MOV RDX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
CMP RAX,0x1
JNZ 0x001ca718
LAB_001ca6e5:
PUSH RBP
MOV RBP,RSP
ADD RAX,RSI
LAB_001ca6ec:
MOV R9D,EDX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RDX
SHL R9,0x8
ADD R9,R10
XOR RDX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RAX
JC 0x001ca6ec
POP RBP
LAB_001ca718:
MOV qword ptr [RCX],RDX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
ulong uVar3;
long lVar4;
do {
lVar2 = param_3;
if (lVar2 < 2) {
uVar3 = *param_4;
lVar4 = *param_5;
if (lVar2 != 1) goto LAB_001ca718;
goto LAB_001ca6e5;
}
} while ((param_2[lVar2 + -1] == 0x20) && (param_3 = lVar2 + -2, param_2[lVar2 + -2] == 0));
uVar3 = *param_4;
lVar4 = *param_5;
LAB_001ca6e5:
pbVar1 = param_2 + lVar2;
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar4);
lVar4 = lVar4 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar1);
LAB_001ca718:
*param_4 = uVar3;
*param_5 = lVar4;
return;
}
|
|
60,021
|
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceData.cpp
|
void
SurfaceData::invalidate() {
// Release any attached memory before marking as invalid:
_irregPatch = 0;
_isValid = false;
}
|
O1
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate():
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x78(%rdi), %rdi
movups %xmm0, 0x70(%rbx)
testq %rdi, %rdi
je 0x9c85f
callq 0x39a60
andb $-0x2, 0x6c(%rbx)
popq %rbx
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Bfr8internal11SurfaceData10invalidateEv:
push rbx
mov rbx, rdi
xorps xmm0, xmm0
mov rdi, [rdi+78h]
movups xmmword ptr [rbx+70h], xmm0
test rdi, rdi
jz short loc_9C85F
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9C85F:
and byte ptr [rbx+6Ch], 0FEh
pop rbx
retn
|
long long OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate(
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData *this)
{
long long v2; // rdi
long long result; // rax
v2 = *((_QWORD *)this + 15);
*((_OWORD *)this + 7) = 0LL;
if ( v2 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
*((_BYTE *)this + 108) &= ~1u;
return result;
}
|
invalidate:
PUSH RBX
MOV RBX,RDI
XORPS XMM0,XMM0
MOV RDI,qword ptr [RDI + 0x78]
MOVUPS xmmword ptr [RBX + 0x70],XMM0
TEST RDI,RDI
JZ 0x0019c85f
CALL 0x00139a60
LAB_0019c85f:
AND byte ptr [RBX + 0x6c],0xfe
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate() */
void __thiscall OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate(SurfaceData *this)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
this_00 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x78);
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
this[0x6c] = (SurfaceData)((byte)this[0x6c] & 0xfe);
return;
}
|
|
60,022
|
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceData.cpp
|
void
SurfaceData::invalidate() {
// Release any attached memory before marking as invalid:
_irregPatch = 0;
_isValid = false;
}
|
O3
|
cpp
|
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate():
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq 0x78(%rdi), %rdi
movups %xmm0, 0x70(%rbx)
testq %rdi, %rdi
je 0x9f33f
callq 0x39a40
andb $-0x2, 0x6c(%rbx)
popq %rbx
retq
nop
|
_ZN10OpenSubdiv6v3_6_03Bfr8internal11SurfaceData10invalidateEv:
push rbx
mov rbx, rdi
xorps xmm0, xmm0
mov rdi, [rdi+78h]
movups xmmword ptr [rbx+70h], xmm0
test rdi, rdi
jz short loc_9F33F
call __ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9F33F:
and byte ptr [rbx+6Ch], 0FEh
pop rbx
retn
|
long long OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate(
OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData *this)
{
long long v2; // rdi
long long result; // rax
v2 = *((_QWORD *)this + 15);
*((_OWORD *)this + 7) = 0LL;
if ( v2 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release();
*((_BYTE *)this + 108) &= ~1u;
return result;
}
|
invalidate:
PUSH RBX
MOV RBX,RDI
XORPS XMM0,XMM0
MOV RDI,qword ptr [RDI + 0x78]
MOVUPS xmmword ptr [RBX + 0x70],XMM0
TEST RDI,RDI
JZ 0x0019f33f
CALL 0x00139a40
LAB_0019f33f:
AND byte ptr [RBX + 0x6c],0xfe
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate() */
void __thiscall OpenSubdiv::v3_6_0::Bfr::internal::SurfaceData::invalidate(SurfaceData *this)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
this_00 = *(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x78);
*(int8 *)(this + 0x70) = 0;
*(int8 *)(this + 0x78) = 0;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
this[0x6c] = (SurfaceData)((byte)this[0x6c] & 0xfe);
return;
}
|
|
60,023
|
ssux_lock::psi_wr_lock(char const*, unsigned int)
|
eloqsql/storage/innobase/sync/srw_lock.cc
|
void ssux_lock::psi_wr_lock(const char *file, unsigned line)
{
PSI_rwlock_locker_state state;
const bool nowait= lock.wr_lock_try();
if (PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, pfs_psi,
nowait ? PSI_RWLOCK_TRYEXCLUSIVELOCK : PSI_RWLOCK_EXCLUSIVELOCK,
file, line))
{
if (!nowait)
lock.wr_lock();
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, 0);
}
else if (!nowait)
lock.wr_lock();
}
|
O0
|
cpp
|
ssux_lock::psi_wr_lock(char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
callq 0x292c0
movq -0x60(%rbp), %rcx
andb $0x1, %al
movb %al, -0x49(%rbp)
leaq 0x1ac64c(%rip), %rax # 0x1d4830
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq (%rcx), %rsi
movb -0x49(%rbp), %dil
movl $0x6, %edx
movl $0x9, %ecx
testb $0x1, %dil
cmovnel %ecx, %edx
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
callq *%rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x2824d
testb $0x1, -0x49(%rbp)
jne 0x28232
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x258e0
leaq 0x1ac5f7(%rip), %rax # 0x1d4830
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x58(%rbp), %rdi
xorl %esi, %esi
callq *%rax
jmp 0x28262
testb $0x1, -0x49(%rbp)
jne 0x28260
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x258e0
jmp 0x28262
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN9ssux_lock11psi_wr_lockEPKcj:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rdi, [rbp+var_8]
mov [rbp+var_60], rdi
add rdi, 8
call _ZN14ssux_lock_implILb0EE11wr_lock_tryEv; ssux_lock_impl<false>::wr_lock_try(void)
mov rcx, [rbp+var_60]
and al, 1
mov [rbp+var_49], al
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rsi, [rcx]
mov dil, [rbp+var_49]
mov edx, 6
mov ecx, 9
test dil, 1
cmovnz edx, ecx
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
call rax
mov [rbp+var_58], rax
cmp [rbp+var_58], 0
jz short loc_2824D
test [rbp+var_49], 1
jnz short loc_28232
mov rdi, [rbp+var_60]
add rdi, 8
call _ZN14ssux_lock_implILb0EE7wr_lockEv; ssux_lock_impl<false>::wr_lock(void)
loc_28232:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_58]
xor esi, esi
call rax
jmp short loc_28262
loc_2824D:
test [rbp+var_49], 1
jnz short loc_28260
mov rdi, [rbp+var_60]
add rdi, 8
call _ZN14ssux_lock_implILb0EE7wr_lockEv; ssux_lock_impl<false>::wr_lock(void)
loc_28260:
jmp short $+2
loc_28262:
add rsp, 60h
pop rbp
retn
|
long long ssux_lock::psi_wr_lock(ssux_lock *this, const char *a2, unsigned int a3)
{
long long v3; // rdx
long long result; // rax
long long v5; // [rsp+8h] [rbp-58h]
char v6; // [rsp+17h] [rbp-49h]
_BYTE v7[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v8; // [rsp+4Ch] [rbp-14h]
const char *v9; // [rsp+50h] [rbp-10h]
ssux_lock *v10; // [rsp+58h] [rbp-8h]
v10 = this;
v9 = a2;
v8 = a3;
v6 = ssux_lock_impl<false>::wr_lock_try((char *)this + 8) & 1;
v3 = 6LL;
if ( v6 )
v3 = 9LL;
result = ((long long ( *)(_BYTE *, _QWORD, long long, const char *, _QWORD))PSI_server[54])(
v7,
*(_QWORD *)this,
v3,
v9,
v8);
v5 = result;
if ( result )
{
if ( (v6 & 1) == 0 )
ssux_lock_impl<false>::wr_lock((long long)this + 8);
return ((long long ( *)(long long, _QWORD))PSI_server[53])(v5, 0LL);
}
else if ( (v6 & 1) == 0 )
{
return ssux_lock_impl<false>::wr_lock((long long)this + 8);
}
return result;
}
|
psi_wr_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x60],RDI
ADD RDI,0x8
CALL 0x001292c0
MOV RCX,qword ptr [RBP + -0x60]
AND AL,0x1
MOV byte ptr [RBP + -0x49],AL
LEA RAX,[0x2d4830]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RSI,qword ptr [RCX]
MOV DIL,byte ptr [RBP + -0x49]
MOV EDX,0x6
MOV ECX,0x9
TEST DIL,0x1
CMOVNZ EDX,ECX
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
CALL RAX
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x58],0x0
JZ 0x0012824d
TEST byte ptr [RBP + -0x49],0x1
JNZ 0x00128232
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
CALL 0x001258e0
LAB_00128232:
LEA RAX,[0x2d4830]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1a8]
MOV RDI,qword ptr [RBP + -0x58]
XOR ESI,ESI
CALL RAX
JMP 0x00128262
LAB_0012824d:
TEST byte ptr [RBP + -0x49],0x1
JNZ 0x00128260
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x8
CALL 0x001258e0
LAB_00128260:
JMP 0x00128262
LAB_00128262:
ADD RSP,0x60
POP RBP
RET
|
/* ssux_lock::psi_wr_lock(char const*, unsigned int) */
void __thiscall ssux_lock::psi_wr_lock(ssux_lock *this,char *param_1,uint param_2)
{
byte bVar1;
long lVar2;
int8 uVar3;
int1 local_50 [52];
uint local_1c;
char *local_18;
ssux_lock *local_10;
local_1c = param_2;
local_18 = param_1;
local_10 = this;
bVar1 = ssux_lock_impl<false>::wr_lock_try((ssux_lock_impl<false> *)(this + 8));
bVar1 = bVar1 & 1;
uVar3 = 6;
if (bVar1 != 0) {
uVar3 = 9;
}
lVar2 = (**(code **)(PSI_server + 0x1b0))(local_50,*(int8 *)this,uVar3,local_18,local_1c);
if (lVar2 == 0) {
if (bVar1 == 0) {
ssux_lock_impl<false>::wr_lock((ssux_lock_impl<false> *)(this + 8));
}
}
else {
if (bVar1 == 0) {
ssux_lock_impl<false>::wr_lock((ssux_lock_impl<false> *)(this + 8));
}
(**(code **)(PSI_server + 0x1a8))(lVar2,0);
}
return;
}
|
|
60,024
|
gguf_set_tensor_type
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void gguf_set_tensor_type(struct gguf_context * ctx, const char * name, enum ggml_type type) {
const int64_t tensor_id = gguf_find_tensor(ctx, name);
if (tensor_id < 0) {
GGML_ABORT("tensor not found: %s", name);
}
struct ggml_tensor * tensor = &ctx->info[tensor_id].t;
const size_t type_size = ggml_type_size(type);
const int64_t blck_size = ggml_blck_size(type);
tensor->type = type;
GGML_ASSERT(tensor->ne[0] % blck_size == 0 && "tensor row size not divisible by block size of new type");
tensor->nb[0] = type_size;
tensor->nb[1] = tensor->nb[0]*(tensor->ne[0]/blck_size);
for (int i = 2; i < GGML_MAX_DIMS; i++) {
tensor->nb[i] = tensor->nb[i - 1]*tensor->ne[i - 1];
}
// update offsets
const int64_t n_tensors = gguf_get_n_tensors(ctx);
for (int64_t i = tensor_id + 1; i < n_tensors; ++i) {
ctx->info[i].offset = ctx->info[i - 1].offset + GGML_PAD(ggml_nbytes(&ctx->info[i - 1].t), ctx->alignment);
}
}
|
O1
|
cpp
|
gguf_set_tensor_type:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x17200
testq %rax, %rax
js 0x3f2d7
movq %rax, %r14
movq 0x20(%rbx), %r13
imulq $0x158, %rax, %r12 # imm = 0x158
movl %ebp, %edi
callq 0x16fd0
movq %rax, %r15
movl %ebp, %edi
callq 0x17aa0
movq %rax, %rcx
movl %ebp, (%r13,%r12)
movq 0x10(%r13,%r12), %rax
cqto
idivq %rcx
testq %rdx, %rdx
jne 0x3f2ef
leaq (%r12,%r13), %rcx
movq %r15, 0x30(%rcx)
imulq %r15, %rax
movq %rax, 0x38(%rcx)
leaq (%r12,%r13), %rax
addq $0x40, %rax
movq -0x8(%rax), %rcx
xorl %edx, %edx
imulq -0x28(%rax,%rdx,8), %rcx
movq %rcx, (%rax,%rdx,8)
incq %rdx
cmpq $0x2, %rdx
jne 0x3f24d
movq 0x28(%rbx), %rcx
subq 0x20(%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x7d05f417d05f417d, %rax # imm = 0x82FA0BE82FA0BE83
imulq %rcx, %rax
leaq 0x1(%r14), %rcx
cmpq %rax, %rcx
jge 0x3f2c8
notq %r14
addq %rax, %r14
movq 0x20(%rbx), %rdi
movq 0x150(%rdi,%r12), %r15
addq %r12, %rdi
callq 0x161c0
movq 0x20(%rbx), %rcx
movq 0x38(%rbx), %rdx
addq %rdx, %rax
decq %rax
negq %rdx
andq %rax, %rdx
addq %r15, %rdx
movq %rdx, 0x2a8(%rcx,%r12)
addq $0x158, %r12 # imm = 0x158
decq %r14
jne 0x3f289
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ab47(%rip), %rdi # 0x59e25
leaq 0x1b116(%rip), %rdx # 0x5a3fb
movl $0x456, %esi # imm = 0x456
movq %r15, %rcx
jmp 0x3f309
leaq 0x1ab2f(%rip), %rdi # 0x59e25
leaq 0xb35d(%rip), %rdx # 0x4a65a
leaq 0x1b10c(%rip), %rcx # 0x5a410
movl $0x45d, %esi # imm = 0x45D
xorl %eax, %eax
callq 0x17c70
|
gguf_set_tensor_type:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, edx
mov r15, rsi
mov rbx, rdi
call _gguf_find_tensor
test rax, rax
js loc_3F2D7
mov r14, rax
mov r13, [rbx+20h]
imul r12, rax, 158h
mov edi, ebp
call _ggml_type_size
mov r15, rax
mov edi, ebp
call _ggml_blck_size
mov rcx, rax
mov [r13+r12+0], ebp
mov rax, [r13+r12+10h]
cqo
idiv rcx
test rdx, rdx
jnz loc_3F2EF
lea rcx, [r12+r13]
mov [rcx+30h], r15
imul rax, r15
mov [rcx+38h], rax
lea rax, [r12+r13]
add rax, 40h ; '@'
mov rcx, [rax-8]
xor edx, edx
loc_3F24D:
imul rcx, [rax+rdx*8-28h]
mov [rax+rdx*8], rcx
inc rdx
cmp rdx, 2
jnz short loc_3F24D
mov rcx, [rbx+28h]
sub rcx, [rbx+20h]
sar rcx, 3
mov rax, 82FA0BE82FA0BE83h
imul rax, rcx
lea rcx, [r14+1]
cmp rcx, rax
jge short loc_3F2C8
not r14
add r14, rax
loc_3F289:
mov rdi, [rbx+20h]
mov r15, [rdi+r12+150h]
add rdi, r12
call _ggml_nbytes
mov rcx, [rbx+20h]
mov rdx, [rbx+38h]
add rax, rdx
dec rax
neg rdx
and rdx, rax
add rdx, r15
mov [rcx+r12+2A8h], rdx
add r12, 158h
dec r14
jnz short loc_3F289
loc_3F2C8:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F2D7:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aTensorNotFound; "tensor not found: %s"
mov esi, 456h
mov rcx, r15
jmp short loc_3F309
loc_3F2EF:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNe0BlckS; "tensor->ne[0] % blck_size == 0 && \"ten"...
mov esi, 45Dh
loc_3F309:
xor eax, eax
call _ggml_abort
|
long long gguf_set_tensor_type(_QWORD *a1, long long a2, unsigned int a3)
{
int v4; // r15d
long long tensor; // rax
int v7; // r8d
int v8; // r9d
long long v9; // r14
long long v10; // r13
long long v11; // r12
long long v12; // r15
char *v13; // rax
long long v14; // rax
long long v15; // rt2
long long v16; // rcx
long long v17; // rax
long long v18; // rcx
long long i; // rdx
long long result; // rax
long long v21; // r14
long long v22; // rdi
long long v23; // r15
unsigned long long v24; // rax
long long v25; // rdx
const char *v26; // rdx
int v27; // esi
const char *v28; // rcx
v4 = a2;
tensor = gguf_find_tensor((long long)a1, a2);
if ( tensor < 0 )
{
v26 = "tensor not found: %s";
v27 = 1110;
LODWORD(v28) = v4;
goto LABEL_11;
}
v9 = tensor;
v10 = a1[4];
v11 = 344 * tensor;
v12 = ggml_type_size(a3);
v13 = ggml_blck_size(a3);
*(_DWORD *)(v10 + v11) = a3;
v15 = *(_QWORD *)(v10 + v11 + 16) % (long long)v13;
v14 = *(_QWORD *)(v10 + v11 + 16) / (long long)v13;
if ( v15 )
{
v26 = "GGML_ASSERT(%s) failed";
v28 = "tensor->ne[0] % blck_size == 0 && \"tensor row size not divisible by block size of new type\"";
v27 = 1117;
LABEL_11:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
v27,
(_DWORD)v26,
(_DWORD)v28,
v7,
v8);
}
v16 = v11 + v10;
*(_QWORD *)(v16 + 48) = v12;
*(_QWORD *)(v16 + 56) = v12 * v14;
v17 = v11 + v10 + 64;
v18 = *(_QWORD *)(v11 + v10 + 56);
for ( i = 0LL; i != 2; ++i )
{
v18 *= *(_QWORD *)(v17 + 8 * i - 40);
*(_QWORD *)(v17 + 8 * i) = v18;
}
result = 0x82FA0BE82FA0BE83LL * ((long long)(a1[5] - a1[4]) >> 3);
if ( v9 + 1 < result )
{
v21 = result + ~v9;
do
{
v22 = a1[4];
v23 = *(_QWORD *)(v22 + v11 + 336);
v24 = ggml_nbytes((long long *)(v11 + v22));
v25 = a1[7];
result = v25 + v24 - 1;
*(_QWORD *)(a1[4] + v11 + 680) = v23 + (result & -v25);
v11 += 344LL;
--v21;
}
while ( v21 );
}
return result;
}
|
gguf_set_tensor_type:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,EDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x00117200
TEST RAX,RAX
JS 0x0013f2d7
MOV R14,RAX
MOV R13,qword ptr [RBX + 0x20]
IMUL R12,RAX,0x158
MOV EDI,EBP
CALL 0x00116fd0
MOV R15,RAX
MOV EDI,EBP
CALL 0x00117aa0
MOV RCX,RAX
MOV dword ptr [R13 + R12*0x1],EBP
MOV RAX,qword ptr [R13 + R12*0x1 + 0x10]
CQO
IDIV RCX
TEST RDX,RDX
JNZ 0x0013f2ef
LEA RCX,[R12 + R13*0x1]
MOV qword ptr [RCX + 0x30],R15
IMUL RAX,R15
MOV qword ptr [RCX + 0x38],RAX
LEA RAX,[R12 + R13*0x1]
ADD RAX,0x40
MOV RCX,qword ptr [RAX + -0x8]
XOR EDX,EDX
LAB_0013f24d:
IMUL RCX,qword ptr [RAX + RDX*0x8 + -0x28]
MOV qword ptr [RAX + RDX*0x8],RCX
INC RDX
CMP RDX,0x2
JNZ 0x0013f24d
MOV RCX,qword ptr [RBX + 0x28]
SUB RCX,qword ptr [RBX + 0x20]
SAR RCX,0x3
MOV RAX,-0x7d05f417d05f417d
IMUL RAX,RCX
LEA RCX,[R14 + 0x1]
CMP RCX,RAX
JGE 0x0013f2c8
NOT R14
ADD R14,RAX
LAB_0013f289:
MOV RDI,qword ptr [RBX + 0x20]
MOV R15,qword ptr [RDI + R12*0x1 + 0x150]
ADD RDI,R12
CALL 0x001161c0
MOV RCX,qword ptr [RBX + 0x20]
MOV RDX,qword ptr [RBX + 0x38]
ADD RAX,RDX
DEC RAX
NEG RDX
AND RDX,RAX
ADD RDX,R15
MOV qword ptr [RCX + R12*0x1 + 0x2a8],RDX
ADD R12,0x158
DEC R14
JNZ 0x0013f289
LAB_0013f2c8:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f2d7:
LEA RDI,[0x159e25]
LEA RDX,[0x15a3fb]
MOV ESI,0x456
MOV RCX,R15
JMP 0x0013f309
LAB_0013f2ef:
LEA RDI,[0x159e25]
LEA RDX,[0x14a65a]
LEA RCX,[0x15a410]
MOV ESI,0x45d
LAB_0013f309:
XOR EAX,EAX
CALL 0x00117c70
|
void gguf_set_tensor_type(long param_1,char *param_2,int4 param_3)
{
ulong uVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
char *pcVar6;
int8 uVar7;
long lVar8;
uVar1 = gguf_find_tensor();
if ((long)uVar1 < 0) {
pcVar6 = "tensor not found: %s";
uVar7 = 0x456;
}
else {
lVar4 = *(long *)(param_1 + 0x20);
lVar8 = uVar1 * 0x158;
lVar2 = ggml_type_size(param_3);
lVar3 = ggml_blck_size(param_3);
*(int4 *)(lVar4 + lVar8) = param_3;
lVar5 = *(long *)(lVar4 + 0x10 + lVar8);
if (lVar5 % lVar3 == 0) {
*(long *)(lVar8 + lVar4 + 0x30) = lVar2;
*(long *)(lVar8 + lVar4 + 0x38) = (lVar5 / lVar3) * lVar2;
lVar4 = lVar8 + lVar4;
lVar5 = *(long *)(lVar4 + 0x38);
lVar2 = 0;
do {
lVar5 = lVar5 * *(long *)(lVar4 + 0x18 + lVar2 * 8);
*(long *)(lVar4 + 0x40 + lVar2 * 8) = lVar5;
lVar2 = lVar2 + 1;
} while (lVar2 != 2);
lVar4 = (*(long *)(param_1 + 0x28) - *(long *)(param_1 + 0x20) >> 3) * -0x7d05f417d05f417d;
if ((long)(uVar1 + 1) < lVar4) {
lVar4 = ~uVar1 + lVar4;
do {
lVar5 = *(long *)(*(long *)(param_1 + 0x20) + 0x150 + lVar8);
lVar2 = ggml_nbytes(*(long *)(param_1 + 0x20) + lVar8);
*(ulong *)(*(long *)(param_1 + 0x20) + 0x2a8 + lVar8) =
(-*(long *)(param_1 + 0x38) & (lVar2 + *(long *)(param_1 + 0x38)) - 1U) + lVar5;
lVar8 = lVar8 + 0x158;
lVar4 = lVar4 + -1;
} while (lVar4 != 0);
}
return;
}
pcVar6 = "GGML_ASSERT(%s) failed";
param_2 =
"tensor->ne[0] % blck_size == 0 && \"tensor row size not divisible by block size of new type\"";
uVar7 = 0x45d;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",uVar7,
pcVar6,param_2);
}
|
|
60,025
|
spdlog::details::registry::set_default_logger(std::shared_ptr<spdlog::logger>)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/details/registry-inl.h
|
SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger) {
std::lock_guard<std::mutex> lock(logger_map_mutex_);
if (new_default_logger != nullptr) {
loggers_[new_default_logger->name()] = new_default_logger;
}
default_logger_ = std::move(new_default_logger);
}
|
O0
|
c
|
spdlog::details::registry::set_default_logger(std::shared_ptr<spdlog::logger>):
subq $0x58, %rsp
movq %rsi, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x40fd0
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x41f10
xorb $-0x1, %al
testb $0x1, %al
jne 0x3c3cd
jmp 0x3c435
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
addq $0x78, %rax
movq %rax, 0x10(%rsp)
callq 0x41c80
movq %rax, %rdi
callq 0x3c0a0
movq %rax, 0x18(%rsp)
jmp 0x3c3f4
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x41f40
movq %rax, 0x8(%rsp)
jmp 0x3c40a
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x41b00
jmp 0x3c435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x41090
jmp 0x3c45a
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
addq $0x130, %rdi # imm = 0x130
callq 0x41a90
leaq 0x40(%rsp), %rdi
callq 0x41090
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
|
_ZN6spdlog7details8registry18set_default_loggerESt10shared_ptrINS_6loggerEE:
sub rsp, 58h
mov [rsp+58h+var_30], rsi
mov [rsp+58h+var_8], rdi
mov [rsp+58h+var_10], rsi
mov rsi, [rsp+58h+var_8]
mov [rsp+58h+var_38], rsi
lea rdi, [rsp+58h+var_18]
call _ZNSt10lock_guardISt5mutexEC2ERS0_; std::lock_guard<std::mutex>::lock_guard(std::mutex&)
mov rdi, [rsp+58h+var_30]
xor eax, eax
mov esi, eax
call _ZSteqIN6spdlog6loggerEEbRKSt10shared_ptrIT_EDn; std::operator==<spdlog::logger>(std::shared_ptr<spdlog::logger> const&,decltype(nullptr))
xor al, 0FFh
test al, 1
jnz short loc_3C3CD
jmp short loc_3C435
loc_3C3CD:
mov rdi, [rsp+58h+var_30]
mov rax, [rsp+58h+var_38]
add rax, 78h ; 'x'
mov [rsp+58h+var_48], rax
call _ZNKSt19__shared_ptr_accessIN6spdlog6loggerELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<spdlog::logger,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rdi, rax
call _ZNK6spdlog6logger4nameB5cxx11Ev; spdlog::logger::name(void)
mov [rsp+58h+var_40], rax
jmp short $+2
loc_3C3F4:
mov rsi, [rsp+58h+var_40]
mov rdi, [rsp+58h+var_48]
call _ZNSt13unordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt10shared_ptrIN6spdlog6loggerEESt4hashIS5_ESt8equal_toIS5_ESaISt4pairIKS5_S9_EEEixERSF_; std::unordered_map<std::string,std::shared_ptr<spdlog::logger>>::operator[](std::string const&)
mov [rsp+58h+var_50], rax
jmp short $+2
loc_3C40A:
mov rsi, [rsp+58h+var_30]
mov rdi, [rsp+58h+var_50]
call _ZNSt10shared_ptrIN6spdlog6loggerEEaSERKS2_; std::shared_ptr<spdlog::logger>::operator=(std::shared_ptr<spdlog::logger> const&)
jmp short loc_3C435
mov rcx, rax
mov eax, edx
mov [rsp+arg_30], rcx
mov [rsp+arg_2C], eax
lea rdi, [rsp+arg_38]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
jmp short loc_3C45A
loc_3C435:
mov rsi, [rsp+58h+var_30]
mov rdi, [rsp+58h+var_38]
add rdi, 130h
call _ZNSt10shared_ptrIN6spdlog6loggerEEaSEOS2_; std::shared_ptr<spdlog::logger>::operator=(std::shared_ptr<spdlog::logger>&&)
lea rdi, [rsp+58h+var_18]
call _ZNSt10lock_guardISt5mutexED2Ev; std::lock_guard<std::mutex>::~lock_guard()
add rsp, 58h
retn
loc_3C45A:
mov rdi, [rsp+arg_30]
call __Unwind_Resume
|
long long spdlog::details::registry::set_default_logger(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+8h] [rbp-50h]
long long v5; // [rsp+18h] [rbp-40h]
_BYTE v6[8]; // [rsp+40h] [rbp-18h] BYREF
long long v7; // [rsp+48h] [rbp-10h]
long long v8; // [rsp+50h] [rbp-8h]
v8 = a1;
v7 = a2;
std::lock_guard<std::mutex>::lock_guard(v6, a1);
if ( (std::operator==<spdlog::logger>(a2, 0LL) & 1) == 0 )
{
v2 = std::__shared_ptr_access<spdlog::logger,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(a2);
v5 = spdlog::logger::name[abi:cxx11](v2);
v4 = std::unordered_map<std::string,std::shared_ptr<spdlog::logger>>::operator[](a1 + 120, v5);
std::shared_ptr<spdlog::logger>::operator=(v4, a2);
}
std::shared_ptr<spdlog::logger>::operator=(a1 + 304, a2);
return std::lock_guard<std::mutex>::~lock_guard(v6);
}
|
set_default_logger:
SUB RSP,0x58
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV RSI,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x20],RSI
LEA RDI,[RSP + 0x40]
CALL 0x00140fd0
MOV RDI,qword ptr [RSP + 0x28]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00141f10
XOR AL,0xff
TEST AL,0x1
JNZ 0x0013c3cd
JMP 0x0013c435
LAB_0013c3cd:
MOV RDI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x78
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00141c80
MOV RDI,RAX
LAB_0013c3e8:
CALL 0x0013c0a0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0013c3f4
LAB_0013c3f4:
MOV RSI,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00141f40
LAB_0013c403:
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0013c40a
LAB_0013c40a:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x00141b00
JMP 0x0013c435
LAB_0013c435:
MOV RSI,qword ptr [RSP + 0x28]
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x130
CALL 0x00141a90
LEA RDI,[RSP + 0x40]
CALL 0x00141090
ADD RSP,0x58
RET
|
/* spdlog::details::registry::set_default_logger(std::shared_ptr<spdlog::logger>) */
void __thiscall
spdlog::details::registry::set_default_logger
(registry *this,
__shared_ptr_access<spdlog::logger,(__gnu_cxx::_Lock_policy)2,false,false> *param_2)
{
bool bVar1;
logger *this_00;
string *psVar2;
shared_ptr<spdlog::logger> *this_01;
lock_guard<std::mutex> local_18 [8];
__shared_ptr_access<spdlog::logger,(__gnu_cxx::_Lock_policy)2,false,false> *local_10;
registry *local_8;
local_10 = param_2;
local_8 = this;
std::lock_guard<std::mutex>::lock_guard(local_18,(mutex *)this);
bVar1 = std::operator==(param_2,(_func_decltype_nullptr *)0x0);
if (((bVar1 ^ 0xffU) & 1) != 0) {
this_00 = (logger *)
std::__shared_ptr_access<spdlog::logger,(__gnu_cxx::_Lock_policy)2,false,false>::
operator->(param_2);
/* try { // try from 0013c3e8 to 0013c402 has its CatchHandler @ 0013c41b */
psVar2 = (string *)logger::name_abi_cxx11_(this_00);
this_01 = (shared_ptr<spdlog::logger> *)
std::
unordered_map<std::__cxx11::string,std::shared_ptr<spdlog::logger>,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<spdlog::logger>>>>
::operator[]((unordered_map<std::__cxx11::string,std::shared_ptr<spdlog::logger>,std::hash<std::__cxx11::string>,std::equal_to<std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string_const,std::shared_ptr<spdlog::logger>>>>
*)(this + 0x78),psVar2);
std::shared_ptr<spdlog::logger>::operator=(this_01,param_2);
}
std::shared_ptr<spdlog::logger>::operator=((shared_ptr<spdlog::logger> *)(this + 0x130),param_2);
std::lock_guard<std::mutex>::~lock_guard(local_18);
return;
}
|
|
60,026
|
js_global_unescape
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_global_unescape(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue str;
StringBuffer b_s, *b = &b_s;
JSString *p;
int i, len, c, n;
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return str;
string_buffer_init(ctx, b, 0);
p = JS_VALUE_GET_STRING(str);
for (i = 0, len = p->len; i < len; i++) {
c = string_get(p, i);
if (c == '%') {
if (i + 6 <= len
&& string_get(p, i + 1) == 'u'
&& (n = string_get_hex(p, i + 2, 4)) >= 0) {
c = n;
i += 6 - 1;
} else
if (i + 3 <= len
&& (n = string_get_hex(p, i + 1, 2)) >= 0) {
c = n;
i += 3 - 1;
}
}
string_buffer_putc16(b, c);
}
JS_FreeValue(ctx, str);
return string_buffer_end(b);
}
|
O1
|
c
|
js_global_unescape:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
xorl %ecx, %ecx
callq 0x26ec9
movq %rax, (%rsp)
cmpl $0x6, %edx
je 0x79084
movq %rdx, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rsp)
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1ff5f
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x79093
movq (%rsp), %r15
movl $0x7fffffff, %r13d # imm = 0x7FFFFFFF
andl 0x4(%r15), %r13d
je 0x79063
leal -0x6(%r13), %ebp
leal -0x3(%r13), %r14d
xorl %ebx, %ebx
leaq 0x18(%rsp), %r12
movq 0x4(%r15), %rcx
movslq %ebx, %rax
testl %ecx, %ecx
js 0x78fe1
movzbl 0x18(%r15,%rax), %esi
jmp 0x78fe7
movzwl 0x18(%r15,%rax,2), %esi
cmpl $0x25, %esi
jne 0x79050
cmpl %ebp, %ebx
jg 0x79022
testl %ecx, %ecx
js 0x78ffc
movzbl 0x19(%r15,%rax), %eax
jmp 0x79002
movzwl 0x1a(%r15,%rax,2), %eax
cmpl $0x75, %eax
jne 0x79022
leal 0x2(%rbx), %esi
movq %r15, %rdi
movl $0x4, %edx
callq 0x791fa
testl %eax, %eax
js 0x79022
movl %eax, %esi
addl $0x5, %ebx
jmp 0x79050
movl $0x25, %esi
cmpl %r14d, %ebx
jg 0x79050
leal 0x1(%rbx), %esi
movq %r15, %rdi
movl $0x2, %edx
callq 0x791fa
movl %eax, %esi
leal 0x2(%rbx), %eax
testl %esi, %esi
cmovsl %ebx, %eax
movl $0x25, %ecx
cmovsl %ecx, %esi
movl %eax, %ebx
movq %r12, %rdi
callq 0x46bcb
incl %ebx
cmpl %r13d, %ebx
jl 0x78fce
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rdx
callq 0x1ccb2
leaq 0x18(%rsp), %rdi
callq 0x32830
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, 0x2c(%rsp)
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x78fab
|
js_global_unescape:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
xor ecx, ecx
call JS_ToStringInternal
mov [rsp+68h+var_68], rax
cmp edx, 6
jz loc_79084
mov [rsp+68h+var_58], rdx
mov [rsp+68h+var_50], rbx
xorps xmm0, xmm0
movups [rsp+68h+var_40], xmm0
mov [rsp+68h+var_60], rbx
mov rdi, rbx
xor esi, esi
xor edx, edx
call js_alloc_string
mov [rsp+68h+var_48], rax
test rax, rax
jz loc_79093
loc_78FAB:
mov r15, [rsp+68h+var_68]
mov r13d, 7FFFFFFFh
and r13d, [r15+4]
jz loc_79063
lea ebp, [r13-6]
lea r14d, [r13-3]
xor ebx, ebx
lea r12, [rsp+68h+var_50]
loc_78FCE:
mov rcx, [r15+4]
movsxd rax, ebx
test ecx, ecx
js short loc_78FE1
movzx esi, byte ptr [r15+rax+18h]
jmp short loc_78FE7
loc_78FE1:
movzx esi, word ptr [r15+rax*2+18h]
loc_78FE7:
cmp esi, 25h ; '%'
jnz short loc_79050
cmp ebx, ebp
jg short loc_79022
test ecx, ecx
js short loc_78FFC
movzx eax, byte ptr [r15+rax+19h]
jmp short loc_79002
loc_78FFC:
movzx eax, word ptr [r15+rax*2+1Ah]
loc_79002:
cmp eax, 75h ; 'u'
jnz short loc_79022
lea esi, [rbx+2]
mov rdi, r15
mov edx, 4
call string_get_hex
test eax, eax
js short loc_79022
mov esi, eax
add ebx, 5
jmp short loc_79050
loc_79022:
mov esi, 25h ; '%'
cmp ebx, r14d
jg short loc_79050
lea esi, [rbx+1]
mov rdi, r15
mov edx, 2
call string_get_hex
mov esi, eax
lea eax, [rbx+2]
test esi, esi
cmovs eax, ebx
mov ecx, 25h ; '%'
cmovs esi, ecx
mov ebx, eax
loc_79050:
mov rdi, r12
call string_buffer_putc16
inc ebx
cmp ebx, r13d
jl loc_78FCE
loc_79063:
mov rsi, [rsp+68h+var_68]
mov rax, [rsp+68h+var_60]
mov rdi, [rax+18h]
mov rdx, [rsp+68h+var_58]
call JS_FreeValueRT
lea rdi, [rsp+68h+var_50]
call string_buffer_end
loc_79084:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_79093:
mov dword ptr [rsp+68h+var_40+4], 0
mov dword ptr [rsp+68h+var_40+0Ch], 0FFFFFFFFh
jmp loc_78FAB
|
_DWORD * js_global_unescape(
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)
{
_DWORD *result; // rax
long long v15; // rdx
int v16; // r13d
int i; // ebx
long long v18; // rcx
signed int hex; // esi
int v20; // eax
int v21; // eax
int v22; // eax
_DWORD *v23; // [rsp+0h] [rbp-68h]
long long v24; // [rsp+10h] [rbp-58h]
long long v25; // [rsp+18h] [rbp-50h] BYREF
__int128 v27; // [rsp+28h] [rbp-40h]
result = (_DWORD *)JS_ToStringInternal(a1, *a13, a13[1], 0, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9);
v23 = result;
if ( (_DWORD)v15 != 6 )
{
v24 = v15;
v25 = a1;
v27 = 0LL;
if ( !js_alloc_string(a1, 0LL, 0) )
{
DWORD1(v27) = 0;
HIDWORD(v27) = -1;
}
v16 = v23[1] & 0x7FFFFFFF;
if ( v16 )
{
for ( i = 0; i < v16; ++i )
{
v18 = *(_QWORD *)(v23 + 1);
if ( (int)v18 < 0 )
hex = *((unsigned __int16 *)v23 + i + 12);
else
hex = *((unsigned __int8 *)v23 + i + 24);
if ( hex == 37 )
{
if ( i <= v16 - 6
&& ((int)v18 < 0 ? (v20 = *((unsigned __int16 *)v23 + i + 13)) : (v20 = *((unsigned __int8 *)v23 + i + 25)),
v20 == 117 && (v21 = string_get_hex(v23, (unsigned int)(i + 2), 4LL), v21 >= 0)) )
{
hex = v21;
i += 5;
}
else
{
hex = 37;
if ( i <= v16 - 3 )
{
hex = string_get_hex(v23, (unsigned int)(i + 1), 2LL);
v22 = i + 2;
if ( hex < 0 )
{
v22 = i;
hex = 37;
}
i = v22;
}
}
}
string_buffer_putc16((long long)&v25, hex);
}
}
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v23, v24);
return string_buffer_end((long long)&v25);
}
return result;
}
|
js_global_unescape:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
XOR ECX,ECX
CALL 0x00126ec9
MOV qword ptr [RSP],RAX
CMP EDX,0x6
JZ 0x00179084
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RBX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x28],XMM0
MOV qword ptr [RSP + 0x8],RBX
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011ff5f
MOV qword ptr [RSP + 0x20],RAX
TEST RAX,RAX
JZ 0x00179093
LAB_00178fab:
MOV R15,qword ptr [RSP]
MOV R13D,0x7fffffff
AND R13D,dword ptr [R15 + 0x4]
JZ 0x00179063
LEA EBP,[R13 + -0x6]
LEA R14D,[R13 + -0x3]
XOR EBX,EBX
LEA R12,[RSP + 0x18]
LAB_00178fce:
MOV RCX,qword ptr [R15 + 0x4]
MOVSXD RAX,EBX
TEST ECX,ECX
JS 0x00178fe1
MOVZX ESI,byte ptr [R15 + RAX*0x1 + 0x18]
JMP 0x00178fe7
LAB_00178fe1:
MOVZX ESI,word ptr [R15 + RAX*0x2 + 0x18]
LAB_00178fe7:
CMP ESI,0x25
JNZ 0x00179050
CMP EBX,EBP
JG 0x00179022
TEST ECX,ECX
JS 0x00178ffc
MOVZX EAX,byte ptr [R15 + RAX*0x1 + 0x19]
JMP 0x00179002
LAB_00178ffc:
MOVZX EAX,word ptr [R15 + RAX*0x2 + 0x1a]
LAB_00179002:
CMP EAX,0x75
JNZ 0x00179022
LEA ESI,[RBX + 0x2]
MOV RDI,R15
MOV EDX,0x4
CALL 0x001791fa
TEST EAX,EAX
JS 0x00179022
MOV ESI,EAX
ADD EBX,0x5
JMP 0x00179050
LAB_00179022:
MOV ESI,0x25
CMP EBX,R14D
JG 0x00179050
LEA ESI,[RBX + 0x1]
MOV RDI,R15
MOV EDX,0x2
CALL 0x001791fa
MOV ESI,EAX
LEA EAX,[RBX + 0x2]
TEST ESI,ESI
CMOVS EAX,EBX
MOV ECX,0x25
CMOVS ESI,ECX
MOV EBX,EAX
LAB_00179050:
MOV RDI,R12
CALL 0x00146bcb
INC EBX
CMP EBX,R13D
JL 0x00178fce
LAB_00179063:
MOV RSI,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
CALL 0x0011ccb2
LEA RDI,[RSP + 0x18]
CALL 0x00132830
LAB_00179084:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00179093:
MOV dword ptr [RSP + 0x2c],0x0
MOV dword ptr [RSP + 0x34],0xffffffff
JMP 0x00178fab
|
void js_global_unescape(long param_1)
{
ushort uVar1;
uint uVar2;
long lVar3;
long lVar4;
int iVar5;
int iVar6;
int iVar7;
int8 *in_R8;
uint uVar8;
int1 auVar9 [16];
long local_50;
long local_48;
ulong local_40;
int8 uStack_38;
auVar9 = JS_ToStringInternal(param_1,*in_R8,in_R8[1],0);
lVar3 = auVar9._0_8_;
if (auVar9._8_4_ != 6) {
local_40 = 0;
uStack_38 = 0;
local_50 = param_1;
local_48 = js_alloc_string(param_1,0,0);
if (local_48 == 0) {
local_40 = local_40 & 0xffffffff;
uStack_38 = CONCAT44(0xffffffff,(int4)uStack_38);
}
uVar8 = *(uint *)(lVar3 + 4) & 0x7fffffff;
if (uVar8 != 0) {
iVar7 = 0;
do {
lVar4 = (long)iVar7;
iVar5 = (int)*(int8 *)(lVar3 + 4);
if (iVar5 < 0) {
uVar2 = (uint)*(ushort *)(lVar3 + 0x18 + lVar4 * 2);
}
else {
uVar2 = (uint)*(byte *)(lVar3 + 0x18 + lVar4);
}
iVar6 = iVar7;
if (uVar2 == 0x25) {
if (iVar7 <= (int)(uVar8 - 6)) {
if (iVar5 < 0) {
uVar1 = *(ushort *)(lVar3 + 0x1a + lVar4 * 2);
}
else {
uVar1 = (ushort)*(byte *)(lVar3 + 0x19 + lVar4);
}
if ((uVar1 == 0x75) && (uVar2 = string_get_hex(lVar3,iVar7 + 2,4), -1 < (int)uVar2)) {
iVar6 = iVar7 + 5;
goto LAB_00179050;
}
}
uVar2 = 0x25;
if (iVar7 <= (int)(uVar8 - 3)) {
uVar2 = string_get_hex(lVar3,iVar7 + 1,2);
iVar6 = iVar7 + 2;
if ((int)uVar2 < 0) {
uVar2 = 0x25;
iVar6 = iVar7;
}
}
}
LAB_00179050:
string_buffer_putc16(&local_50,uVar2);
iVar7 = iVar6 + 1;
} while (iVar7 < (int)uVar8);
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),lVar3,auVar9._8_8_);
string_buffer_end(&local_50);
}
return;
}
|
|
60,027
|
js_object_set___proto__
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_object_set___proto__(JSContext *ctx, JSValue this_val,
JSValue proto)
{
if (JS_IsUndefined(this_val) || JS_IsNull(this_val))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (!JS_IsObject(proto) && !JS_IsNull(proto))
return JS_UNDEFINED;
if (JS_SetPrototypeInternal(ctx, this_val, proto, TRUE) < 0)
return JS_EXCEPTION;
else
return JS_UNDEFINED;
}
|
O2
|
c
|
js_object_set___proto__:
pushq %rax
movl %edx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x633bd
callq 0x21191
pushq $0x6
jmp 0x633e1
cmpl $0x2, %r8d
je 0x633c9
cmpl $-0x1, %r8d
jne 0x633df
pushq $0x1
popq %r9
callq 0x203b9
shrl $0x1f, %eax
leaq (%rax,%rax,2), %rdx
addq $0x3, %rdx
jmp 0x633e2
pushq $0x3
popq %rdx
xorl %eax, %eax
popq %rcx
retq
|
js_object_set___proto__:
push rax
mov eax, edx
and eax, 0FFFFFFFEh
cmp eax, 2
jnz short loc_633BD
call JS_ThrowTypeErrorNotAnObject
push 6
jmp short loc_633E1
loc_633BD:
cmp r8d, 2
jz short loc_633C9
cmp r8d, 0FFFFFFFFh
jnz short loc_633DF
loc_633C9:
push 1
pop r9
call JS_SetPrototypeInternal
shr eax, 1Fh
lea rdx, [rax+rax*2]
add rdx, 3
jmp short loc_633E2
loc_633DF:
push 3
loc_633E1:
pop rdx
loc_633E2:
xor eax, eax
pop rcx
retn
|
long long js_object_set___proto__(
long long a1,
long long a2,
long long a3,
_DWORD *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
if ( (a3 & 0xFFFFFFFE) == 2 )
{
JS_ThrowTypeErrorNotAnObject(a1, a7, a8, a9, a10, a11, a12, a13, a14, a2, a3, (long long)a4, a5, a6, v14);
}
else if ( (_DWORD)a5 == 2 || (_DWORD)a5 == -1 )
{
JS_SetPrototypeInternal(a1, a2, a3, a4, a5, 1LL, a7, a8, a9, a10, a11, a12, a13, a14);
}
return 0LL;
}
|
js_object_set___proto__:
PUSH RAX
MOV EAX,EDX
AND EAX,0xfffffffe
CMP EAX,0x2
JNZ 0x001633bd
CALL 0x00121191
PUSH 0x6
JMP 0x001633e1
LAB_001633bd:
CMP R8D,0x2
JZ 0x001633c9
CMP R8D,-0x1
JNZ 0x001633df
LAB_001633c9:
PUSH 0x1
POP R9
CALL 0x001203b9
SHR EAX,0x1f
LEA RDX,[RAX + RAX*0x2]
ADD RDX,0x3
JMP 0x001633e2
LAB_001633df:
PUSH 0x3
LAB_001633e1:
POP RDX
LAB_001633e2:
XOR EAX,EAX
POP RCX
RET
|
int1 [16]
js_object_set___proto__
(int8 param_1,int8 param_2,uint param_3,int8 param_4,int param_5)
{
int1 auVar1 [16];
uint uVar2;
int8 uStack_10;
if ((param_3 & 0xfffffffe) == 2) {
JS_ThrowTypeErrorNotAnObject();
uStack_10 = 6;
}
else if ((param_5 == 2) || (param_5 == -1)) {
uVar2 = JS_SetPrototypeInternal();
uStack_10 = (ulong)(uVar2 >> 0x1f) * 3 + 3;
}
else {
uStack_10 = 3;
}
auVar1._8_8_ = 0;
auVar1._0_8_ = uStack_10;
return auVar1 << 0x40;
}
|
|
60,028
|
ha_s3::external_lock(THD*, int)
|
eloqsql/storage/maria/ha_s3.cc
|
int ha_s3::external_lock(THD * thd, int lock_type)
{
int error;
DBUG_ENTER("ha_s3::external_lock");
error= ha_maria::external_lock(thd, lock_type);
if (in_alter_table == S3_ADD_PARTITION && !error && lock_type == F_UNLCK)
{
/*
This was a new partition. All data is now copied to the table
so it's time to move it to S3)
*/
MARIA_SHARE *share= file->s;
uint org_open_count;
/* First, flush all data to the Aria table */
if (flush_pagecache_blocks(share->pagecache, &share->kfile,
FLUSH_RELEASE))
error= my_errno;
if (flush_pagecache_blocks(share->pagecache, &share->bitmap.file,
FLUSH_RELEASE))
error= my_errno;
org_open_count= share->state.open_count;
if (share->global_changed)
share->state.open_count--;
if (_ma_state_info_write(share, MA_STATE_INFO_WRITE_DONT_MOVE_OFFSET |
MA_STATE_INFO_WRITE_LOCK))
error= my_errno;
share->state.open_count= org_open_count;
if (!error)
{
S3_INFO to_s3_info;
char database[NAME_LEN+1], *name= file->s->open_file_name.str;
ms3_st *s3_client;
/* Copy data to S3 */
if (s3_info_init(&to_s3_info, name, database, sizeof(database)-1))
DBUG_RETURN(HA_ERR_UNSUPPORTED);
if (!(s3_client= s3_open_connection(&to_s3_info)))
DBUG_RETURN(HA_ERR_NO_CONNECTION);
/*
Note that if error is set, then the empty temp table was not
removed
*/
error= move_table_to_s3(s3_client, &to_s3_info, name, 1);
s3_deinit(s3_client);
maria_delete_table_files(name, 1, 0);
}
}
DBUG_RETURN(error);
}
|
O3
|
cpp
|
ha_s3::external_lock(THD*, int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x170, %rsp # imm = 0x170
movl %edx, %r15d
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
callq 0xa630
movl %eax, %ebx
cmpl $0x2, %r15d
jne 0xb557
testl %ebx, %ebx
jne 0xb557
cmpl $0x2, 0x7d0(%r14)
jne 0xb557
movq 0x4e8(%r14), %rax
movq (%rax), %r15
movq 0x600(%r15), %rdi
leaq 0x750(%r15), %rsi
xorl %ebx, %ebx
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa6f0
testl %eax, %eax
je 0xb474
callq 0xa590
movl (%rax), %ebx
movq 0x600(%r15), %rdi
leaq 0xa50(%r15), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa6f0
testl %eax, %eax
je 0xb49c
callq 0xa590
movl (%rax), %ebx
movl 0x16c(%r15), %r12d
cmpb $0x0, 0x7df(%r15)
je 0xb4b9
leal -0x1(%r12), %eax
movl %eax, 0x16c(%r15)
movq %r15, %rdi
movl $0x5, %esi
callq 0xa770
testl %eax, %eax
je 0xb4d1
callq 0xa590
movl (%rax), %ebx
movl %r12d, 0x16c(%r15)
testl %ebx, %ebx
jne 0xb557
movq 0x4e8(%r14), %rax
movq (%rax), %rax
movq 0x5e0(%rax), %r14
leaq -0x190(%rbp), %rdi
leaq -0xf0(%rbp), %rdx
movq %r14, %rsi
callq 0xacd0
movl $0x8a, %ebx
testb %al, %al
jne 0xb557
leaq -0x190(%rbp), %rdi
callq 0xa580
testq %rax, %rax
je 0xb552
movq %rax, %r15
leaq -0x190(%rbp), %rsi
movq %rax, %rdi
movq %r14, %rdx
movl $0x1, %ecx
callq 0xafbb
movl %eax, %ebx
movq %r15, %rdi
callq 0xa110
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa370
jmp 0xb557
movl $0x9d, %ebx
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0xb578
movl %ebx, %eax
addq $0x170, %rsp # imm = 0x170
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xa620
nop
|
_ZN5ha_s313external_lockEP3THDi:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 170h
mov r15d, edx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
call __ZN8ha_maria13external_lockEP3THDi; ha_maria::external_lock(THD *,int)
mov ebx, eax
cmp r15d, 2
jnz loc_B557
test ebx, ebx
jnz loc_B557
cmp dword ptr [r14+7D0h], 2
jnz loc_B557
mov rax, [r14+4E8h]
mov r15, [rax]
mov rdi, [r15+600h]
lea rsi, [r15+750h]
xor ebx, ebx
mov edx, 1
xor ecx, ecx
xor r8d, r8d
call _flush_pagecache_blocks_with_filter
test eax, eax
jz short loc_B474
call __my_thread_var
mov ebx, [rax]
loc_B474:
mov rdi, [r15+600h]
lea rsi, [r15+0A50h]
mov edx, 1
xor ecx, ecx
xor r8d, r8d
call _flush_pagecache_blocks_with_filter
test eax, eax
jz short loc_B49C
call __my_thread_var
mov ebx, [rax]
loc_B49C:
mov r12d, [r15+16Ch]
cmp byte ptr [r15+7DFh], 0
jz short loc_B4B9
lea eax, [r12-1]
mov [r15+16Ch], eax
loc_B4B9:
mov rdi, r15
mov esi, 5
call __ma_state_info_write
test eax, eax
jz short loc_B4D1
call __my_thread_var
mov ebx, [rax]
loc_B4D1:
mov [r15+16Ch], r12d
test ebx, ebx
jnz short loc_B557
mov rax, [r14+4E8h]
mov rax, [rax]
mov r14, [rax+5E0h]
lea rdi, [rbp+var_190]
lea rdx, [rbp+var_F0]
mov rsi, r14
call _ZL12s3_info_initP7s3_infoPKcPcm; s3_info_init(s3_info *,char const*,char *,ulong)
mov ebx, 8Ah
test al, al
jnz short loc_B557
lea rdi, [rbp+var_190]
call _s3_open_connection
test rax, rax
jz short loc_B552
mov r15, rax
lea rsi, [rbp+var_190]
mov rdi, rax
mov rdx, r14
mov ecx, 1
call _ZL16move_table_to_s3P6ms3_stP7s3_infoPKcb; move_table_to_s3(ms3_st *,s3_info *,char const*,bool)
mov ebx, eax
mov rdi, r15
call _s3_deinit
mov rdi, r14
mov esi, 1
xor edx, edx
call _maria_delete_table_files
jmp short loc_B557
loc_B552:
mov ebx, 9Dh
loc_B557:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_B578
mov eax, ebx
add rsp, 170h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B578:
call ___stack_chk_fail
|
long long ha_s3::external_lock(long long a1, long long a2, int a3)
{
unsigned int v5; // ebx
long long *v6; // rax
long long v7; // r15
long long v8; // rdi
long long v9; // rdi
int v10; // r12d
long long v11; // r14
long long v12; // rax
long long v13; // r15
_QWORD v15[20]; // [rsp+0h] [rbp-190h] BYREF
_BYTE v16[200]; // [rsp+A0h] [rbp-F0h] BYREF
unsigned long long v17; // [rsp+168h] [rbp-28h]
v17 = __readfsqword(0x28u);
v5 = ha_maria::external_lock();
if ( a3 == 2 && !v5 && *(_DWORD *)(a1 + 2000) == 2 )
{
v6 = *(long long **)(a1 + 1256);
v7 = *v6;
v8 = *(_QWORD *)(*v6 + 1536);
v5 = 0;
if ( (unsigned int)flush_pagecache_blocks_with_filter(v8, *v6 + 1872, 1LL, 0LL, 0LL) )
v5 = *(_DWORD *)_my_thread_var(v8);
v9 = *(_QWORD *)(v7 + 1536);
if ( (unsigned int)flush_pagecache_blocks_with_filter(v9, v7 + 2640, 1LL, 0LL, 0LL) )
v5 = *(_DWORD *)_my_thread_var(v9);
v10 = *(_DWORD *)(v7 + 364);
if ( *(_BYTE *)(v7 + 2015) )
*(_DWORD *)(v7 + 364) = v10 - 1;
if ( (unsigned int)_ma_state_info_write(v7, 5LL) )
v5 = *(_DWORD *)_my_thread_var(v7);
*(_DWORD *)(v7 + 364) = v10;
if ( !v5 )
{
v11 = *(_QWORD *)(**(_QWORD **)(a1 + 1256) + 1504LL);
v5 = 138;
if ( !(unsigned __int8)s3_info_init((long long)v15, v11, (long long)v16) )
{
v12 = s3_open_connection(v15);
if ( v12 )
{
v13 = v12;
v5 = move_table_to_s3(v12, v15, v11, 1);
s3_deinit(v13);
maria_delete_table_files(v11, 1LL, 0LL);
}
else
{
return 157;
}
}
}
}
return v5;
}
|
external_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x170
MOV R15D,EDX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x0010a630
MOV EBX,EAX
CMP R15D,0x2
JNZ 0x0010b557
TEST EBX,EBX
JNZ 0x0010b557
CMP dword ptr [R14 + 0x7d0],0x2
JNZ 0x0010b557
MOV RAX,qword ptr [R14 + 0x4e8]
MOV R15,qword ptr [RAX]
MOV RDI,qword ptr [R15 + 0x600]
LEA RSI,[R15 + 0x750]
XOR EBX,EBX
MOV EDX,0x1
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0010a6f0
TEST EAX,EAX
JZ 0x0010b474
CALL 0x0010a590
MOV EBX,dword ptr [RAX]
LAB_0010b474:
MOV RDI,qword ptr [R15 + 0x600]
LEA RSI,[R15 + 0xa50]
MOV EDX,0x1
XOR ECX,ECX
XOR R8D,R8D
CALL 0x0010a6f0
TEST EAX,EAX
JZ 0x0010b49c
CALL 0x0010a590
MOV EBX,dword ptr [RAX]
LAB_0010b49c:
MOV R12D,dword ptr [R15 + 0x16c]
CMP byte ptr [R15 + 0x7df],0x0
JZ 0x0010b4b9
LEA EAX,[R12 + -0x1]
MOV dword ptr [R15 + 0x16c],EAX
LAB_0010b4b9:
MOV RDI,R15
MOV ESI,0x5
CALL 0x0010a770
TEST EAX,EAX
JZ 0x0010b4d1
CALL 0x0010a590
MOV EBX,dword ptr [RAX]
LAB_0010b4d1:
MOV dword ptr [R15 + 0x16c],R12D
TEST EBX,EBX
JNZ 0x0010b557
MOV RAX,qword ptr [R14 + 0x4e8]
MOV RAX,qword ptr [RAX]
MOV R14,qword ptr [RAX + 0x5e0]
LEA RDI,[RBP + -0x190]
LEA RDX,[RBP + -0xf0]
MOV RSI,R14
CALL 0x0010acd0
MOV EBX,0x8a
TEST AL,AL
JNZ 0x0010b557
LEA RDI,[RBP + -0x190]
CALL 0x0010a580
TEST RAX,RAX
JZ 0x0010b552
MOV R15,RAX
LEA RSI,[RBP + -0x190]
MOV RDI,RAX
MOV RDX,R14
MOV ECX,0x1
CALL 0x0010afbb
MOV EBX,EAX
MOV RDI,R15
CALL 0x0010a110
MOV RDI,R14
MOV ESI,0x1
XOR EDX,EDX
CALL 0x0010a370
JMP 0x0010b557
LAB_0010b552:
MOV EBX,0x9d
LAB_0010b557:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x0010b578
MOV EAX,EBX
ADD RSP,0x170
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0010b578:
CALL 0x0010a620
|
/* ha_s3::external_lock(THD*, int) */
int __thiscall ha_s3::external_lock(ha_s3 *this,THD *param_1,int param_2)
{
long lVar1;
char *pcVar2;
char cVar3;
int iVar4;
int iVar5;
int iVar6;
int *piVar7;
ms3_st *pmVar8;
ulong uVar9;
long in_FS_OFFSET;
s3_info local_198 [160];
char local_f8 [200];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
iVar4 = ha_maria::external_lock((THD *)this,(int)param_1);
if (((param_2 == 2) && (iVar4 == 0)) && (*(int *)(this + 2000) == 2)) {
lVar1 = **(long **)(this + 0x4e8);
iVar4 = 0;
iVar5 = flush_pagecache_blocks_with_filter(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,1,0,0);
if (iVar5 != 0) {
piVar7 = (int *)_my_thread_var();
iVar4 = *piVar7;
}
uVar9 = 0;
iVar5 = flush_pagecache_blocks_with_filter(*(int8 *)(lVar1 + 0x600),lVar1 + 0xa50,1,0,0);
if (iVar5 != 0) {
piVar7 = (int *)_my_thread_var();
iVar4 = *piVar7;
}
iVar5 = *(int *)(lVar1 + 0x16c);
if (*(char *)(lVar1 + 0x7df) != '\0') {
*(int *)(lVar1 + 0x16c) = iVar5 + -1;
}
iVar6 = _ma_state_info_write(lVar1,5);
if (iVar6 != 0) {
piVar7 = (int *)_my_thread_var();
iVar4 = *piVar7;
}
*(int *)(lVar1 + 0x16c) = iVar5;
if (iVar4 == 0) {
pcVar2 = *(char **)(**(long **)(this + 0x4e8) + 0x5e0);
cVar3 = s3_info_init(local_198,pcVar2,local_f8,uVar9);
iVar4 = 0x8a;
if (cVar3 == '\0') {
pmVar8 = (ms3_st *)s3_open_connection(local_198);
if (pmVar8 == (ms3_st *)0x0) {
iVar4 = 0x9d;
}
else {
iVar4 = move_table_to_s3(pmVar8,local_198,pcVar2,true);
s3_deinit(pmVar8);
maria_delete_table_files(pcVar2,1,0);
}
}
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return iVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
60,029
|
gguf_set_kv
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void gguf_set_kv(struct gguf_context * ctx, const struct gguf_context * src) {
const int64_t n_kv = gguf_get_n_kv(src);
for (int64_t i = 0; i < n_kv; ++i) {
const struct gguf_kv & kv = src->kv[i];
if (!kv.is_array) {
switch (kv.get_type()) {
case GGUF_TYPE_UINT8: gguf_set_val_u8 (ctx, kv.get_key().c_str(), kv.get_val<uint8_t>()); break;
case GGUF_TYPE_INT8: gguf_set_val_i8 (ctx, kv.get_key().c_str(), kv.get_val<int8_t>()); break;
case GGUF_TYPE_UINT16: gguf_set_val_u16 (ctx, kv.get_key().c_str(), kv.get_val<uint16_t>()); break;
case GGUF_TYPE_INT16: gguf_set_val_i16 (ctx, kv.get_key().c_str(), kv.get_val<int16_t>()); break;
case GGUF_TYPE_UINT32: gguf_set_val_u32 (ctx, kv.get_key().c_str(), kv.get_val<uint32_t>()); break;
case GGUF_TYPE_INT32: gguf_set_val_i32 (ctx, kv.get_key().c_str(), kv.get_val<int32_t>()); break;
case GGUF_TYPE_FLOAT32: gguf_set_val_f32 (ctx, kv.get_key().c_str(), kv.get_val<float>()); break;
case GGUF_TYPE_UINT64: gguf_set_val_u64 (ctx, kv.get_key().c_str(), kv.get_val<uint64_t>()); break;
case GGUF_TYPE_INT64: gguf_set_val_i64 (ctx, kv.get_key().c_str(), kv.get_val<int64_t>()); break;
case GGUF_TYPE_FLOAT64: gguf_set_val_f64 (ctx, kv.get_key().c_str(), kv.get_val<double>()); break;
case GGUF_TYPE_BOOL: gguf_set_val_bool(ctx, kv.get_key().c_str(), kv.get_val<bool>()); break;
case GGUF_TYPE_STRING: gguf_set_val_str (ctx, kv.get_key().c_str(), kv.get_val<std::string>().c_str()); break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
continue;
}
const size_t ne = kv.get_ne();
switch (kv.get_type()) {
case GGUF_TYPE_UINT8:
case GGUF_TYPE_INT8:
case GGUF_TYPE_UINT16:
case GGUF_TYPE_INT16:
case GGUF_TYPE_UINT32:
case GGUF_TYPE_INT32:
case GGUF_TYPE_FLOAT32:
case GGUF_TYPE_UINT64:
case GGUF_TYPE_INT64:
case GGUF_TYPE_FLOAT64:
case GGUF_TYPE_BOOL: {
gguf_set_arr_data(ctx, kv.get_key().c_str(), kv.get_type(), kv.data.data(), ne);
} break;
case GGUF_TYPE_STRING: {
std::vector<const char *> tmp(ne);
for (size_t j = 0; j < ne; ++j) {
tmp[j] = kv.data_string[j].c_str();
}
gguf_set_arr_str(ctx, kv.get_key().c_str(), tmp.data(), ne);
} break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
}
}
|
O2
|
cpp
|
gguf_set_kv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
xorl %r12d, %r12d
testq %rax, %rax
cmovleq %r12, %r15
cmpq %r15, %r12
je 0x40a2c
movq 0x8(%rbx), %rax
imulq $0x58, %r12, %rcx
leaq (%rax,%rcx), %rbp
cmpb $0x0, 0x20(%rax,%rcx)
je 0x40826
movq %rbp, %rdi
callq 0x1c880
movl 0x24(%rbp), %edx
cmpl $0xc, %edx
ja 0x40a50
movq %rax, %r13
movl $0x1cff, %eax # imm = 0x1CFF
btl %edx, %eax
jae 0x40861
movq (%rbp), %rsi
movq 0x28(%rbp), %rcx
movq %r14, %rdi
movq %r13, %r8
callq 0x1d7c0
incq %r12
jmp 0x407d1
movl 0x24(%rbp), %eax
cmpq $0xc, %rax
ja 0x40a3b
leaq 0x19d3a(%rip), %rcx # 0x5a574
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1c450
movzbl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e570
jmp 0x40821
cmpl $0x8, %edx
jne 0x40a50
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
leaq 0xf(%rsp), %rdx
callq 0x1dbd0
xorl %eax, %eax
movq %r13, %rcx
subq $0x1, %rcx
jb 0x408c0
movq 0x40(%rbp), %rdx
movq (%rdx,%rax,4), %rdx
movq 0x10(%rsp), %rsi
movq %rdx, (%rsi,%rax)
addq $0x8, %rax
jmp 0x40881
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1da80
movsd (%rax), %xmm0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d720
jmp 0x40821
movq (%rbp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r13, %rcx
callq 0x1d850
leaq 0x10(%rsp), %rdi
callq 0x1c4b0
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1ce70
movq (%rax), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1ea80
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1ec40
movq (%rax), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c600
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1da70
movq (%rax), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d710
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1d000
movl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d980
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1d1b0
movsbl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e750
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1cd90
movl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1df60
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1dec0
movzwl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e800
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1d6f0
movzbl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c050
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1e3d0
movswl (%rax), %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1d5e0
jmp 0x40821
movq (%rbp), %r13
movq %rbp, %rdi
xorl %esi, %esi
callq 0x1c6c0
movss (%rax), %xmm0
movq %r14, %rdi
movq %r13, %rsi
callq 0x1e760
jmp 0x40821
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19ed3(%rip), %rdi # 0x5a915
leaq 0x1a47b(%rip), %rdx # 0x5aec4
movl $0x422, %esi # imm = 0x422
jmp 0x40a63
leaq 0x19ebe(%rip), %rdi # 0x5a915
leaq 0x1a466(%rip), %rdx # 0x5aec4
movl $0x43f, %esi # imm = 0x43F
xorl %eax, %eax
callq 0x1e770
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1c4b0
movq %rbx, %rdi
callq 0x1e9b0
|
gguf_set_kv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
mov rax, [rsi+10h]
sub rax, [rsi+8]
push 58h ; 'X'
pop rcx
cqo
idiv rcx
mov r15, rax
xor r12d, r12d
test rax, rax
cmovle r15, r12
loc_407D1:
cmp r12, r15
jz loc_40A2C
mov rax, [rbx+8]
imul rcx, r12, 58h ; 'X'
lea rbp, [rax+rcx]
cmp byte ptr [rax+rcx+20h], 0
jz short loc_40826
mov rdi, rbp; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
mov edx, [rbp+24h]
cmp edx, 0Ch
ja loc_40A50
mov r13, rax
mov eax, 1CFFh
bt eax, edx
jnb short loc_40861
mov rsi, [rbp+0]
mov rcx, [rbp+28h]
mov rdi, r14
mov r8, r13
call _gguf_set_arr_data
loc_40821:
inc r12
jmp short loc_407D1
loc_40826:
mov eax, [rbp+24h]
cmp rax, 0Ch; switch 13 cases
ja def_40841; jumptable 0000000000040841 default case, case 9
lea rcx, jpt_40841
movsxd rax, ds:(jpt_40841 - 5A574h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_40843:
mov r13, [rbp+0]; jumptable 0000000000040841 case 0
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIhEERKT_m; gguf_kv::get_val<uchar>(ulong)
movzx edx, byte ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_u8
jmp short loc_40821
loc_40861:
cmp edx, 8
jnz loc_40A50
lea rdi, [rsp+58h+var_48]
mov rsi, r13
lea rdx, [rsp+58h+var_49]
call __ZNSt6vectorIPKcSaIS1_EEC2EmRKS2_; std::vector<char const*>::vector(ulong,std::allocator<char const*> const&)
xor eax, eax
mov rcx, r13
loc_40881:
sub rcx, 1
jb short loc_408C0
mov rdx, [rbp+40h]
mov rdx, [rdx+rax*4]
mov rsi, [rsp+58h+var_48]
mov [rsi+rax], rdx
add rax, 8
jmp short loc_40881
loc_4089E:
mov r13, [rbp+0]; jumptable 0000000000040841 case 12
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIdEERKT_m; gguf_kv::get_val<double>(ulong)
movsd xmm0, qword ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_f64
jmp loc_40821
loc_408C0:
mov rsi, [rbp+0]
mov rdx, [rsp+58h+var_48]
mov rdi, r14
mov rcx, r13
call _gguf_set_arr_str
lea rdi, [rsp+58h+var_48]
call __ZNSt12_Vector_baseIPKcSaIS1_EED2Ev; std::_Vector_base<char const*>::~_Vector_base()
jmp loc_40821
loc_408E3:
mov r13, [rbp+0]; jumptable 0000000000040841 case 10
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valImEERKT_m; gguf_kv::get_val<ulong>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_u64
jmp loc_40821
loc_40904:
mov r13, [rbp+0]; jumptable 0000000000040841 case 11
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIlEERKT_m; gguf_kv::get_val<long>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_i64
jmp loc_40821
loc_40925:
mov r13, [rbp+0]; jumptable 0000000000040841 case 8
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_str
jmp loc_40821
loc_40946:
mov r13, [rbp+0]; jumptable 0000000000040841 case 4
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIjEERKT_m; gguf_kv::get_val<uint>(ulong)
mov edx, [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_u32
jmp loc_40821
loc_40966:
mov r13, [rbp+0]; jumptable 0000000000040841 case 1
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIaEERKT_m; gguf_kv::get_val<signed char>(ulong)
movsx edx, byte ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_i8
jmp loc_40821
loc_40987:
mov r13, [rbp+0]; jumptable 0000000000040841 case 5
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIiEERKT_m; gguf_kv::get_val<int>(ulong)
mov edx, [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_i32
jmp loc_40821
loc_409A7:
mov r13, [rbp+0]; jumptable 0000000000040841 case 2
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valItEERKT_m; gguf_kv::get_val<ushort>(ulong)
movzx edx, word ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_u16
jmp loc_40821
loc_409C8:
mov r13, [rbp+0]; jumptable 0000000000040841 case 7
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIbEERKT_m; gguf_kv::get_val<bool>(ulong)
movzx edx, byte ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_bool
jmp loc_40821
loc_409E9:
mov r13, [rbp+0]; jumptable 0000000000040841 case 3
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIsEERKT_m; gguf_kv::get_val<short>(ulong)
movsx edx, word ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_i16
jmp loc_40821
loc_40A0A:
mov r13, [rbp+0]; jumptable 0000000000040841 case 6
mov rdi, rbp
xor esi, esi
call __ZNK7gguf_kv7get_valIfEERKT_m; gguf_kv::get_val<float>(ulong)
movss xmm0, dword ptr [rax]
mov rdi, r14
mov rsi, r13
call _gguf_set_val_f32
jmp loc_40821
loc_40A2C:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_40841:
lea rdi, aWorkspaceLlm4b_5; jumptable 0000000000040841 default case, case 9
lea rdx, aInvalidType; "invalid type"
mov esi, 422h
jmp short loc_40A63
loc_40A50:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aInvalidType; "invalid type"
mov esi, 43Fh
loc_40A63:
xor eax, eax
call _ggml_abort
mov rbx, rax
lea rdi, [rsp+58h+var_48]
call __ZNSt12_Vector_baseIPKcSaIS1_EED2Ev; std::_Vector_base<char const*>::~_Vector_base()
mov rdi, rbx
call __Unwind_Resume
|
long long gguf_set_kv(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long result; // rax
long long v15; // r15
long long v16; // r12
long long v17; // rax
long long v18; // rcx
long long v19; // rbp
long long ne; // rax
unsigned int v21; // edx
long long v22; // r13
int v23; // eax
long long v24; // r13
char *v25; // rax
double v26; // xmm4_8
double v27; // xmm5_8
double v28; // xmm4_8
double v29; // xmm5_8
long long v30; // rax
long long v31; // rcx
long long v33; // r13
double v34; // xmm4_8
double v35; // xmm5_8
long long v36; // r13
long long *v37; // rax
double v38; // xmm4_8
double v39; // xmm5_8
long long v40; // r13
long long *v41; // rax
double v42; // xmm4_8
double v43; // xmm5_8
long long v44; // r13
long long *v45; // rax
double v46; // xmm4_8
double v47; // xmm5_8
long long v48; // r13
unsigned int *v49; // rax
double v50; // xmm4_8
double v51; // xmm5_8
long long v52; // r13
char *v53; // rax
double v54; // xmm4_8
double v55; // xmm5_8
long long v56; // r13
int *v57; // rax
double v58; // xmm4_8
double v59; // xmm5_8
long long v60; // r13
__int16 *v61; // rax
double v62; // xmm4_8
double v63; // xmm5_8
long long v64; // r13
char *v65; // rax
double v66; // xmm4_8
double v67; // xmm5_8
long long v68; // r13
__int16 *v69; // rax
double v70; // xmm4_8
double v71; // xmm5_8
long long v72; // r13
double v73; // xmm4_8
double v74; // xmm5_8
int v75; // esi
char v76; // [rsp+0h] [rbp-58h]
char v77; // [rsp+Fh] [rbp-49h] BYREF
long long v78[9]; // [rsp+10h] [rbp-48h] BYREF
result = (*(_QWORD *)(a2 + 16) - *(_QWORD *)(a2 + 8)) / 88LL;
v15 = result;
v16 = 0LL;
if ( result <= 0 )
v15 = 0LL;
while ( v16 != v15 )
{
v17 = *(_QWORD *)(a2 + 8);
v18 = 88 * v16;
v19 = v17 + 88 * v16;
if ( !*(_BYTE *)(v19 + 32) )
{
switch ( *(_DWORD *)(v19 + 36) )
{
case 0:
v24 = *(_QWORD *)v19;
v25 = (char *)gguf_kv::get_val<unsigned char>(v19, 0LL);
result = gguf_set_val_u8(a1, v24, *v25, a3, a4, a5, a6, v26, v27, a9, a10);
goto LABEL_8;
case 1:
v52 = *(_QWORD *)v19;
v53 = (char *)gguf_kv::get_val<signed char>(v19, 0LL);
result = gguf_set_val_i8(a1, v52, *v53, a3, a4, a5, a6, v54, v55, a9, a10);
goto LABEL_8;
case 2:
v60 = *(_QWORD *)v19;
v61 = (__int16 *)gguf_kv::get_val<unsigned short>(v19, 0LL);
result = gguf_set_val_u16(a1, v60, *v61, a3, a4, a5, a6, v62, v63, a9, a10);
goto LABEL_8;
case 3:
v68 = *(_QWORD *)v19;
v69 = (__int16 *)gguf_kv::get_val<short>(v19, 0LL);
result = gguf_set_val_i16(a1, v68, *v69, a3, a4, a5, a6, v70, v71, a9, a10);
goto LABEL_8;
case 4:
v48 = *(_QWORD *)v19;
v49 = (unsigned int *)gguf_kv::get_val<unsigned int>(v19, 0LL);
result = gguf_set_val_u32(a1, v48, *v49, a3, a4, a5, a6, v50, v51, a9, a10);
goto LABEL_8;
case 5:
v56 = *(_QWORD *)v19;
v57 = (int *)gguf_kv::get_val<int>(v19, 0LL);
result = gguf_set_val_i32(a1, v56, *v57, a3, a4, a5, a6, v58, v59, a9, a10);
goto LABEL_8;
case 6:
v72 = *(_QWORD *)v19;
a3 = (__m128)*(unsigned int *)gguf_kv::get_val<float>(v19, 0LL);
result = gguf_set_val_f32(a1, v72, a3, a4, a5, a6, v73, v74, a9, a10);
goto LABEL_8;
case 7:
v64 = *(_QWORD *)v19;
v65 = (char *)gguf_kv::get_val<bool>(v19, 0LL);
result = gguf_set_val_bool(a1, v64, *v65, a3, a4, a5, a6, v66, v67, a9, a10);
goto LABEL_8;
case 8:
v44 = *(_QWORD *)v19;
v45 = (long long *)gguf_kv::get_val<std::string>(v19, 0LL);
result = gguf_set_val_str(a1, v44, *v45, a3, a4, a5, a6, v46, v47, a9, a10);
goto LABEL_8;
case 0xA:
v36 = *(_QWORD *)v19;
v37 = (long long *)gguf_kv::get_val<unsigned long>(v19, 0LL);
result = gguf_set_val_u64(a1, v36, *v37, a3, a4, a5, a6, v38, v39, a9, a10);
goto LABEL_8;
case 0xB:
v40 = *(_QWORD *)v19;
v41 = (long long *)gguf_kv::get_val<long>(v19, 0LL);
result = gguf_set_val_i64(a1, v40, *v41, a3, a4, a5, a6, v42, v43, a9, a10);
goto LABEL_8;
case 0xC:
v33 = *(_QWORD *)v19;
a3 = (__m128)*(unsigned long long *)gguf_kv::get_val<double>(v19, 0LL);
result = gguf_set_val_f64(a1, v33, a3, a4, a5, a6, v34, v35, a9, a10);
goto LABEL_8;
default:
v75 = 1058;
goto LABEL_30;
}
}
ne = gguf_kv::get_ne((gguf_kv *)(v17 + 88 * v16));
v21 = *(_DWORD *)(v19 + 36);
if ( v21 > 0xC )
{
LABEL_29:
v75 = 1087;
LABEL_30:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
v75,
(long long)"invalid type",
v18,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v76);
}
v22 = ne;
v23 = 7423;
if ( _bittest(&v23, v21) )
{
result = gguf_set_arr_data(
a1,
*(_QWORD *)v19,
v21,
*(_QWORD *)(v19 + 40),
v22,
a3,
a4,
a5,
a6,
*(double *)a7.m128_u64,
*(double *)a8.m128_u64,
a9,
a10);
}
else
{
if ( v21 != 8 )
goto LABEL_29;
std::vector<char const*>::vector(v78, v22, &v77);
v30 = 0LL;
v31 = v22;
while ( v31-- != 0 )
{
*(_QWORD *)(v78[0] + v30) = *(_QWORD *)(*(_QWORD *)(v19 + 64) + 4 * v30);
v30 += 8LL;
}
gguf_set_arr_str(a1, *(_QWORD *)v19, v78[0], v22, a3, a4, a5, a6, v28, v29, a9, a10);
result = std::_Vector_base<char const*>::~_Vector_base(v78);
}
LABEL_8:
++v16;
}
return result;
}
|
gguf_set_kv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RSI + 0x10]
SUB RAX,qword ptr [RSI + 0x8]
PUSH 0x58
POP RCX
CQO
IDIV RCX
MOV R15,RAX
XOR R12D,R12D
TEST RAX,RAX
CMOVLE R15,R12
LAB_001407d1:
CMP R12,R15
JZ 0x00140a2c
MOV RAX,qword ptr [RBX + 0x8]
IMUL RCX,R12,0x58
LEA RBP,[RAX + RCX*0x1]
CMP byte ptr [RAX + RCX*0x1 + 0x20],0x0
JZ 0x00140826
MOV RDI,RBP
CALL 0x0011c880
MOV EDX,dword ptr [RBP + 0x24]
CMP EDX,0xc
JA 0x00140a50
MOV R13,RAX
MOV EAX,0x1cff
BT EAX,EDX
JNC 0x00140861
MOV RSI,qword ptr [RBP]
MOV RCX,qword ptr [RBP + 0x28]
MOV RDI,R14
MOV R8,R13
CALL 0x0011d7c0
LAB_00140821:
INC R12
JMP 0x001407d1
LAB_00140826:
MOV EAX,dword ptr [RBP + 0x24]
CMP RAX,0xc
JA 0x00140a3b
LEA RCX,[0x15a574]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011c450
MOVZX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011e570
JMP 0x00140821
LAB_00140861:
CMP EDX,0x8
JNZ 0x00140a50
LEA RDI,[RSP + 0x10]
MOV RSI,R13
LEA RDX,[RSP + 0xf]
CALL 0x0011dbd0
XOR EAX,EAX
MOV RCX,R13
LAB_00140881:
SUB RCX,0x1
JC 0x001408c0
MOV RDX,qword ptr [RBP + 0x40]
MOV RDX,qword ptr [RDX + RAX*0x4]
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RSI + RAX*0x1],RDX
ADD RAX,0x8
JMP 0x00140881
caseD_c:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011da80
MOVSD XMM0,qword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011d720
JMP 0x00140821
LAB_001408c0:
MOV RSI,qword ptr [RBP]
MOV RDX,qword ptr [RSP + 0x10]
LAB_001408c9:
MOV RDI,R14
MOV RCX,R13
CALL 0x0011d850
LAB_001408d4:
LEA RDI,[RSP + 0x10]
CALL 0x0011c4b0
JMP 0x00140821
caseD_a:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011ce70
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011ea80
JMP 0x00140821
caseD_b:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011ec40
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011c600
JMP 0x00140821
caseD_8:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011da70
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011d710
JMP 0x00140821
caseD_4:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011d000
MOV EDX,dword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011d980
JMP 0x00140821
caseD_1:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011d1b0
MOVSX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011e750
JMP 0x00140821
caseD_5:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011cd90
MOV EDX,dword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011df60
JMP 0x00140821
caseD_2:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011dec0
MOVZX EDX,word ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011e800
JMP 0x00140821
caseD_7:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011d6f0
MOVZX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011c050
JMP 0x00140821
caseD_3:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011e3d0
MOVSX EDX,word ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011d5e0
JMP 0x00140821
caseD_6:
MOV R13,qword ptr [RBP]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0011c6c0
MOVSS XMM0,dword ptr [RAX]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011e760
JMP 0x00140821
LAB_00140a2c:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_9:
LEA RDI,[0x15a915]
LEA RDX,[0x15aec4]
MOV ESI,0x422
JMP 0x00140a63
LAB_00140a50:
LEA RDI,[0x15a915]
LEA RDX,[0x15aec4]
MOV ESI,0x43f
LAB_00140a63:
XOR EAX,EAX
CALL 0x0011e770
|
void gguf_set_kv(int8 param_1,long param_2)
{
gguf_kv *this;
uint uVar1;
long lVar2;
ulong uVar3;
uchar *puVar4;
long lVar5;
double *pdVar6;
ulong *puVar7;
long *plVar8;
string *psVar9;
uint *puVar10;
signed *psVar11;
int *piVar12;
ushort *puVar13;
bool *pbVar14;
short *psVar15;
float *pfVar16;
ulong uVar17;
int8 uVar18;
long lVar19;
bool bVar20;
allocator local_49;
long local_48 [3];
lVar2 = (*(long *)(param_2 + 0x10) - *(long *)(param_2 + 8)) / 0x58;
lVar19 = 0;
if (lVar2 < 1) {
lVar2 = lVar19;
}
do {
if (lVar19 == lVar2) {
return;
}
this = (gguf_kv *)(*(long *)(param_2 + 8) + lVar19 * 0x58);
if (*(char *)(*(long *)(param_2 + 8) + 0x20 + lVar19 * 0x58) == '\0') {
switch(*(int4 *)(this + 0x24)) {
case 0:
uVar18 = *(int8 *)this;
puVar4 = gguf_kv::get_val<unsigned_char>(this,0);
gguf_set_val_u8(param_1,uVar18,*puVar4);
break;
case 1:
uVar18 = *(int8 *)this;
psVar11 = gguf_kv::get_val<signed_char>(this,0);
gguf_set_val_i8(param_1,uVar18,(int)(char)*psVar11);
break;
case 2:
uVar18 = *(int8 *)this;
puVar13 = gguf_kv::get_val<unsigned_short>(this,0);
gguf_set_val_u16(param_1,uVar18,*puVar13);
break;
case 3:
uVar18 = *(int8 *)this;
psVar15 = gguf_kv::get_val<short>(this,0);
gguf_set_val_i16(param_1,uVar18,(int)*psVar15);
break;
case 4:
uVar18 = *(int8 *)this;
puVar10 = gguf_kv::get_val<unsigned_int>(this,0);
gguf_set_val_u32(param_1,uVar18,*puVar10);
break;
case 5:
uVar18 = *(int8 *)this;
piVar12 = gguf_kv::get_val<int>(this,0);
gguf_set_val_i32(param_1,uVar18,*piVar12);
break;
case 6:
pfVar16 = gguf_kv::get_val<float>(this,0);
gguf_set_val_f32(*pfVar16,param_1);
break;
case 7:
uVar18 = *(int8 *)this;
pbVar14 = gguf_kv::get_val<bool>(this,0);
gguf_set_val_bool(param_1,uVar18,*pbVar14);
break;
case 8:
uVar18 = *(int8 *)this;
psVar9 = gguf_kv::get_val<std::__cxx11::string>(this,0);
gguf_set_val_str(param_1,uVar18,*(int8 *)psVar9);
break;
default:
uVar18 = 0x422;
goto LAB_00140a63;
case 10:
uVar18 = *(int8 *)this;
puVar7 = gguf_kv::get_val<unsigned_long>(this,0);
gguf_set_val_u64(param_1,uVar18,*puVar7);
break;
case 0xb:
uVar18 = *(int8 *)this;
plVar8 = gguf_kv::get_val<long>(this,0);
gguf_set_val_i64(param_1,uVar18,*plVar8);
break;
case 0xc:
pdVar6 = gguf_kv::get_val<double>(this,0);
gguf_set_val_f64(*pdVar6,param_1);
}
}
else {
uVar3 = gguf_kv::get_ne(this);
uVar1 = *(uint *)(this + 0x24);
if (0xc < uVar1) {
LAB_00140a50:
uVar18 = 0x43f;
LAB_00140a63:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
uVar18,"invalid type");
}
if ((0x1cffU >> (uVar1 & 0x1f) & 1) == 0) {
if (uVar1 != 8) goto LAB_00140a50;
std::vector<char_const*,std::allocator<char_const*>>::vector
((vector<char_const*,std::allocator<char_const*>> *)local_48,uVar3,&local_49);
lVar5 = 0;
uVar17 = uVar3;
while (bVar20 = uVar17 != 0, uVar17 = uVar17 - 1, bVar20) {
*(int8 *)(local_48[0] + lVar5) = *(int8 *)(*(long *)(this + 0x40) + lVar5 * 4)
;
lVar5 = lVar5 + 8;
}
/* try { // try from 001408c9 to 001408d3 has its CatchHandler @ 00140a6a */
gguf_set_arr_str(param_1,*(int8 *)this,local_48[0],uVar3);
std::_Vector_base<char_const*,std::allocator<char_const*>>::~_Vector_base
((_Vector_base<char_const*,std::allocator<char_const*>> *)local_48);
}
else {
gguf_set_arr_data(param_1,*(int8 *)this,uVar1,*(int8 *)(this + 0x28),uVar3);
}
}
lVar19 = lVar19 + 1;
} while( true );
}
|
|
60,030
|
gguf_set_kv
|
ngxson[P]ggml-easy/ggml/src/gguf.cpp
|
void gguf_set_kv(struct gguf_context * ctx, const struct gguf_context * src) {
const int64_t n_kv = gguf_get_n_kv(src);
for (int64_t i = 0; i < n_kv; ++i) {
const struct gguf_kv & kv = src->kv[i];
if (!kv.is_array) {
switch (kv.get_type()) {
case GGUF_TYPE_UINT8: gguf_set_val_u8 (ctx, kv.get_key().c_str(), kv.get_val<uint8_t>()); break;
case GGUF_TYPE_INT8: gguf_set_val_i8 (ctx, kv.get_key().c_str(), kv.get_val<int8_t>()); break;
case GGUF_TYPE_UINT16: gguf_set_val_u16 (ctx, kv.get_key().c_str(), kv.get_val<uint16_t>()); break;
case GGUF_TYPE_INT16: gguf_set_val_i16 (ctx, kv.get_key().c_str(), kv.get_val<int16_t>()); break;
case GGUF_TYPE_UINT32: gguf_set_val_u32 (ctx, kv.get_key().c_str(), kv.get_val<uint32_t>()); break;
case GGUF_TYPE_INT32: gguf_set_val_i32 (ctx, kv.get_key().c_str(), kv.get_val<int32_t>()); break;
case GGUF_TYPE_FLOAT32: gguf_set_val_f32 (ctx, kv.get_key().c_str(), kv.get_val<float>()); break;
case GGUF_TYPE_UINT64: gguf_set_val_u64 (ctx, kv.get_key().c_str(), kv.get_val<uint64_t>()); break;
case GGUF_TYPE_INT64: gguf_set_val_i64 (ctx, kv.get_key().c_str(), kv.get_val<int64_t>()); break;
case GGUF_TYPE_FLOAT64: gguf_set_val_f64 (ctx, kv.get_key().c_str(), kv.get_val<double>()); break;
case GGUF_TYPE_BOOL: gguf_set_val_bool(ctx, kv.get_key().c_str(), kv.get_val<bool>()); break;
case GGUF_TYPE_STRING: gguf_set_val_str (ctx, kv.get_key().c_str(), kv.get_val<std::string>().c_str()); break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
continue;
}
const size_t ne = kv.get_ne();
switch (kv.get_type()) {
case GGUF_TYPE_UINT8:
case GGUF_TYPE_INT8:
case GGUF_TYPE_UINT16:
case GGUF_TYPE_INT16:
case GGUF_TYPE_UINT32:
case GGUF_TYPE_INT32:
case GGUF_TYPE_FLOAT32:
case GGUF_TYPE_UINT64:
case GGUF_TYPE_INT64:
case GGUF_TYPE_FLOAT64:
case GGUF_TYPE_BOOL: {
gguf_set_arr_data(ctx, kv.get_key().c_str(), kv.get_type(), kv.data.data(), ne);
} break;
case GGUF_TYPE_STRING: {
std::vector<const char *> tmp(ne);
for (size_t j = 0; j < ne; ++j) {
tmp[j] = kv.data_string[j].c_str();
}
gguf_set_arr_str(ctx, kv.get_key().c_str(), tmp.data(), ne);
} break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
}
}
|
O3
|
cpp
|
gguf_set_kv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rsi), %rax
subq 0x8(%rsi), %rax
testq %rax, %rax
jle 0x3edeb
movq %rsi, %rbx
movq %rdi, %r14
shrq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r15 # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %r15
cmpq $0x1, %r15
adcq $0x0, %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
imulq $0x58, %r12, %rcx
leaq (%rax,%rcx), %r13
cmpb $0x0, 0x20(%rax,%rcx)
je 0x3ebd1
movq %r13, %rdi
callq 0x16620
movq %rax, %rbp
movl 0x24(%r13), %edx
cmpl $0x8, %edx
jb 0x3ebb1
leal -0xa(%rdx), %eax
cmpl $0x3, %eax
jae 0x3ec0d
movq (%r13), %rsi
movq 0x28(%r13), %rcx
movq %r14, %rdi
movq %rbp, %r8
callq 0x17120
incq %r12
cmpq %r15, %r12
jne 0x3eb82
jmp 0x3edeb
movl 0x24(%r13), %eax
cmpq $0xc, %rax
ja 0x3edfa
leaq 0x1ae5e(%rip), %rcx # 0x59a44
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x162d0
movzbl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17ae0
jmp 0x3ebc4
cmpl $0x8, %edx
jne 0x3ee0f
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
leaq 0xf(%rsp), %rdx
callq 0x17410
testq %rbp, %rbp
je 0x3ec4c
xorl %eax, %eax
movq %rbp, %rcx
movq 0x40(%r13), %rdx
movq (%rdx,%rax,4), %rdx
movq 0x10(%rsp), %rsi
movq %rdx, (%rsi,%rax)
addq $0x8, %rax
decq %rcx
jne 0x3ec32
movq (%r13), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbp, %rcx
callq 0x171a0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ebc4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x17070
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17320
movsd (%rax), %xmm0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17090
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x16a70
movq (%rax), %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17ed0
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17ff0
movq (%rax), %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16410
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17310
movq (%rax), %rdx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17080
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x16bb0
movl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17280
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x16d10
movsbl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17c40
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x169c0
movl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x176a0
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17620
movzwl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17cd0
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17060
movzbl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16040
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x17980
movswl (%rax), %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x16fa0
jmp 0x3ebc4
movq (%r13), %rbp
movq %r13, %rdi
xorl %esi, %esi
callq 0x164c0
movss (%rax), %xmm0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x17c50
jmp 0x3ebc4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1afe4(%rip), %rdi # 0x59de5
leaq 0x1b58c(%rip), %rdx # 0x5a394
movl $0x422, %esi # imm = 0x422
jmp 0x3ee22
leaq 0x1afcf(%rip), %rdi # 0x59de5
leaq 0x1b577(%rip), %rdx # 0x5a394
movl $0x43f, %esi # imm = 0x43F
xorl %eax, %eax
callq 0x17c60
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ee43
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x17070
movq %rbx, %rdi
callq 0x17e20
|
gguf_set_kv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rax, [rsi+10h]
sub rax, [rsi+8]
test rax, rax
jle loc_3EDEB
mov rbx, rsi
mov r14, rdi
shr rax, 3
mov r15, 2E8BA2E8BA2E8BA3h
imul r15, rax
cmp r15, 1
adc r15, 0
xor r12d, r12d
loc_3EB82:
mov rax, [rbx+8]
imul rcx, r12, 58h ; 'X'
lea r13, [rax+rcx]
cmp byte ptr [rax+rcx+20h], 0
jz short loc_3EBD1
mov rdi, r13; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
mov rbp, rax
mov edx, [r13+24h]
cmp edx, 8
jb short loc_3EBB1
lea eax, [rdx-0Ah]
cmp eax, 3
jnb short loc_3EC0D
loc_3EBB1:
mov rsi, [r13+0]
mov rcx, [r13+28h]
mov rdi, r14
mov r8, rbp
call _gguf_set_arr_data
loc_3EBC4:
inc r12
cmp r12, r15
jnz short loc_3EB82
jmp loc_3EDEB
loc_3EBD1:
mov eax, [r13+24h]
cmp rax, 0Ch; switch 13 cases
ja def_3EBED; jumptable 000000000003EBED default case, case 9
lea rcx, jpt_3EBED
movsxd rax, ds:(jpt_3EBED - 59A44h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_3EBEF:
mov rbp, [r13+0]; jumptable 000000000003EBED case 0
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIhEERKT_m; gguf_kv::get_val<uchar>(ulong)
movzx edx, byte ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_u8
jmp short loc_3EBC4
loc_3EC0D:
cmp edx, 8
jnz loc_3EE0F
lea rdi, [rsp+58h+var_48]
mov rsi, rbp
lea rdx, [rsp+58h+var_49]
call __ZNSt6vectorIPKcSaIS1_EEC2EmRKS2_; std::vector<char const*>::vector(ulong,std::allocator<char const*> const&)
test rbp, rbp
jz short loc_3EC4C
xor eax, eax
mov rcx, rbp
loc_3EC32:
mov rdx, [r13+40h]
mov rdx, [rdx+rax*4]
mov rsi, [rsp+58h+var_48]
mov [rsi+rax], rdx
add rax, 8
dec rcx
jnz short loc_3EC32
loc_3EC4C:
mov rsi, [r13+0]
mov rdx, [rsp+58h+var_48]
mov rdi, r14
mov rcx, rbp
call _gguf_set_arr_str
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz loc_3EBC4
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_3EBC4
loc_3EC80:
mov rbp, [r13+0]; jumptable 000000000003EBED case 12
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIdEERKT_m; gguf_kv::get_val<double>(ulong)
movsd xmm0, qword ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_f64
jmp loc_3EBC4
loc_3ECA2:
mov rbp, [r13+0]; jumptable 000000000003EBED case 10
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valImEERKT_m; gguf_kv::get_val<ulong>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_u64
jmp loc_3EBC4
loc_3ECC3:
mov rbp, [r13+0]; jumptable 000000000003EBED case 11
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIlEERKT_m; gguf_kv::get_val<long>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_i64
jmp loc_3EBC4
loc_3ECE4:
mov rbp, [r13+0]; jumptable 000000000003EBED case 8
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rdx, [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_str
jmp loc_3EBC4
loc_3ED05:
mov rbp, [r13+0]; jumptable 000000000003EBED case 4
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIjEERKT_m; gguf_kv::get_val<uint>(ulong)
mov edx, [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_u32
jmp loc_3EBC4
loc_3ED25:
mov rbp, [r13+0]; jumptable 000000000003EBED case 1
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIaEERKT_m; gguf_kv::get_val<signed char>(ulong)
movsx edx, byte ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_i8
jmp loc_3EBC4
loc_3ED46:
mov rbp, [r13+0]; jumptable 000000000003EBED case 5
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIiEERKT_m; gguf_kv::get_val<int>(ulong)
mov edx, [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_i32
jmp loc_3EBC4
loc_3ED66:
mov rbp, [r13+0]; jumptable 000000000003EBED case 2
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valItEERKT_m; gguf_kv::get_val<ushort>(ulong)
movzx edx, word ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_u16
jmp loc_3EBC4
loc_3ED87:
mov rbp, [r13+0]; jumptable 000000000003EBED case 7
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIbEERKT_m; gguf_kv::get_val<bool>(ulong)
movzx edx, byte ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_bool
jmp loc_3EBC4
loc_3EDA8:
mov rbp, [r13+0]; jumptable 000000000003EBED case 3
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIsEERKT_m; gguf_kv::get_val<short>(ulong)
movsx edx, word ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_i16
jmp loc_3EBC4
loc_3EDC9:
mov rbp, [r13+0]; jumptable 000000000003EBED case 6
mov rdi, r13
xor esi, esi
call __ZNK7gguf_kv7get_valIfEERKT_m; gguf_kv::get_val<float>(ulong)
movss xmm0, dword ptr [rax]
mov rdi, r14
mov rsi, rbp
call _gguf_set_val_f32
jmp loc_3EBC4
loc_3EDEB:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
def_3EBED:
lea rdi, aWorkspaceLlm4b_5; jumptable 000000000003EBED default case, case 9
lea rdx, aInvalidType; "invalid type"
mov esi, 422h
jmp short loc_3EE22
loc_3EE0F:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aInvalidType; "invalid type"
mov esi, 43Fh
loc_3EE22:
xor eax, eax
call _ggml_abort
mov rbx, rax
mov rdi, [rsp+58h+var_48]; void *
test rdi, rdi
jz short loc_3EE43
mov rsi, [rsp+58h+var_38]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3EE43:
mov rdi, rbx
call __Unwind_Resume
|
void gguf_set_kv(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
unsigned long long v6; // rax
long long v7; // r15
long long v8; // r12
long long v9; // rax
int v10; // ecx
long long v11; // r13
long long ne; // rbp
unsigned int v13; // edx
long long v14; // rbp
char *v15; // rax
long long v16; // rax
long long v17; // rcx
long long v18; // rbp
double *v19; // rax
long long v20; // rbp
long long *v21; // rax
long long v22; // rbp
long long *v23; // rax
long long v24; // rbp
long long *v25; // rax
long long v26; // rbp
unsigned int *v27; // rax
long long v28; // rbp
char *v29; // rax
long long v30; // rbp
int *v31; // rax
long long v32; // rbp
__int16 *v33; // rax
long long v34; // rbp
char *v35; // rax
long long v36; // rbp
__int16 *v37; // rax
long long v38; // rbp
float *v39; // rax
int v40; // esi
char v41; // [rsp+Fh] [rbp-49h] BYREF
void *v42[9]; // [rsp+10h] [rbp-48h] BYREF
if ( (long long)(*(_QWORD *)(a2 + 16) - *(_QWORD *)(a2 + 8)) > 0 )
{
v6 = *(_QWORD *)(a2 + 16) - *(_QWORD *)(a2 + 8);
v7 = (0x2E8BA2E8BA2E8BA3LL * (v6 >> 3) == 0) + 0x2E8BA2E8BA2E8BA3LL * (v6 >> 3);
v8 = 0LL;
do
{
v9 = *(_QWORD *)(a2 + 8);
v10 = 88 * v8;
v11 = v9 + 88 * v8;
if ( !*(_BYTE *)(v11 + 32) )
{
switch ( *(_DWORD *)(v11 + 36) )
{
case 0:
v14 = *(_QWORD *)v11;
v15 = (char *)gguf_kv::get_val<unsigned char>(v11, 0LL);
gguf_set_val_u8(a1, v14, *v15);
goto LABEL_7;
case 1:
v28 = *(_QWORD *)v11;
v29 = (char *)gguf_kv::get_val<signed char>(v11, 0LL);
gguf_set_val_i8(a1, v28, *v29);
goto LABEL_7;
case 2:
v32 = *(_QWORD *)v11;
v33 = (__int16 *)gguf_kv::get_val<unsigned short>(v11, 0LL);
gguf_set_val_u16(a1, v32, *v33);
goto LABEL_7;
case 3:
v36 = *(_QWORD *)v11;
v37 = (__int16 *)gguf_kv::get_val<short>(v11, 0LL);
gguf_set_val_i16(a1, v36, *v37);
goto LABEL_7;
case 4:
v26 = *(_QWORD *)v11;
v27 = (unsigned int *)gguf_kv::get_val<unsigned int>(v11, 0LL);
gguf_set_val_u32(a1, v26, *v27);
goto LABEL_7;
case 5:
v30 = *(_QWORD *)v11;
v31 = (int *)gguf_kv::get_val<int>(v11, 0LL);
gguf_set_val_i32(a1, v30, *v31);
goto LABEL_7;
case 6:
v38 = *(_QWORD *)v11;
v39 = (float *)gguf_kv::get_val<float>(v11, 0LL);
gguf_set_val_f32(a1, v38, *v39);
goto LABEL_7;
case 7:
v34 = *(_QWORD *)v11;
v35 = (char *)gguf_kv::get_val<bool>(v11, 0LL);
gguf_set_val_bool(a1, v34, *v35);
goto LABEL_7;
case 8:
v24 = *(_QWORD *)v11;
v25 = (long long *)gguf_kv::get_val<std::string>(v11, 0LL);
gguf_set_val_str(a1, v24, *v25);
goto LABEL_7;
case 0xA:
v20 = *(_QWORD *)v11;
v21 = (long long *)gguf_kv::get_val<unsigned long>(v11, 0LL);
gguf_set_val_u64(a1, v20, *v21);
goto LABEL_7;
case 0xB:
v22 = *(_QWORD *)v11;
v23 = (long long *)gguf_kv::get_val<long>(v11, 0LL);
gguf_set_val_i64(a1, v22, *v23);
goto LABEL_7;
case 0xC:
v18 = *(_QWORD *)v11;
v19 = (double *)gguf_kv::get_val<double>(v11, 0LL);
gguf_set_val_f64(a1, v18, *v19);
goto LABEL_7;
default:
v40 = 1058;
goto LABEL_31;
}
}
ne = gguf_kv::get_ne((gguf_kv *)(v9 + 88 * v8));
v13 = *(_DWORD *)(v11 + 36);
if ( v13 >= 8 && v13 - 10 >= 3 )
{
if ( v13 != 8 )
{
v40 = 1087;
LABEL_31:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
v40,
(unsigned int)"invalid type",
v10,
a5,
a6);
}
std::vector<char const*>::vector(v42, ne, &v41);
if ( ne )
{
v16 = 0LL;
v17 = ne;
do
{
*(_QWORD *)((char *)v42[0] + v16) = *(_QWORD *)(*(_QWORD *)(v11 + 64) + 4 * v16);
v16 += 8LL;
--v17;
}
while ( v17 );
}
gguf_set_arr_str(a1, *(_QWORD *)v11, (long long)v42[0], ne);
if ( v42[0] )
operator delete(v42[0], (char *)v42[2] - (char *)v42[0]);
}
else
{
gguf_set_arr_data(a1, *(_QWORD *)v11, v13, *(_QWORD *)(v11 + 40), ne);
}
LABEL_7:
++v8;
}
while ( v8 != v7 );
}
}
|
gguf_set_kv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RAX,qword ptr [RSI + 0x10]
SUB RAX,qword ptr [RSI + 0x8]
TEST RAX,RAX
JLE 0x0013edeb
MOV RBX,RSI
MOV R14,RDI
SHR RAX,0x3
MOV R15,0x2e8ba2e8ba2e8ba3
IMUL R15,RAX
CMP R15,0x1
ADC R15,0x0
XOR R12D,R12D
LAB_0013eb82:
MOV RAX,qword ptr [RBX + 0x8]
IMUL RCX,R12,0x58
LEA R13,[RAX + RCX*0x1]
CMP byte ptr [RAX + RCX*0x1 + 0x20],0x0
JZ 0x0013ebd1
MOV RDI,R13
CALL 0x00116620
MOV RBP,RAX
MOV EDX,dword ptr [R13 + 0x24]
CMP EDX,0x8
JC 0x0013ebb1
LEA EAX,[RDX + -0xa]
CMP EAX,0x3
JNC 0x0013ec0d
LAB_0013ebb1:
MOV RSI,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x28]
MOV RDI,R14
MOV R8,RBP
CALL 0x00117120
LAB_0013ebc4:
INC R12
CMP R12,R15
JNZ 0x0013eb82
JMP 0x0013edeb
LAB_0013ebd1:
MOV EAX,dword ptr [R13 + 0x24]
CMP RAX,0xc
JA 0x0013edfa
LEA RCX,[0x159a44]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x001162d0
MOVZX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117ae0
JMP 0x0013ebc4
LAB_0013ec0d:
CMP EDX,0x8
JNZ 0x0013ee0f
LEA RDI,[RSP + 0x10]
MOV RSI,RBP
LEA RDX,[RSP + 0xf]
CALL 0x00117410
TEST RBP,RBP
JZ 0x0013ec4c
XOR EAX,EAX
MOV RCX,RBP
LAB_0013ec32:
MOV RDX,qword ptr [R13 + 0x40]
MOV RDX,qword ptr [RDX + RAX*0x4]
MOV RSI,qword ptr [RSP + 0x10]
MOV qword ptr [RSI + RAX*0x1],RDX
ADD RAX,0x8
DEC RCX
JNZ 0x0013ec32
LAB_0013ec4c:
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0013ec55:
MOV RDI,R14
MOV RCX,RBP
CALL 0x001171a0
LAB_0013ec60:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0013ebc4
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x00117070
JMP 0x0013ebc4
caseD_c:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117320
MOVSD XMM0,qword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117090
JMP 0x0013ebc4
caseD_a:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00116a70
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117ed0
JMP 0x0013ebc4
caseD_b:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117ff0
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00116410
JMP 0x0013ebc4
caseD_8:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117310
MOV RDX,qword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117080
JMP 0x0013ebc4
caseD_4:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00116bb0
MOV EDX,dword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117280
JMP 0x0013ebc4
caseD_1:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00116d10
MOVSX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117c40
JMP 0x0013ebc4
caseD_5:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x001169c0
MOV EDX,dword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x001176a0
JMP 0x0013ebc4
caseD_2:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117620
MOVZX EDX,word ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117cd0
JMP 0x0013ebc4
caseD_7:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117060
MOVZX EDX,byte ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00116040
JMP 0x0013ebc4
caseD_3:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x00117980
MOVSX EDX,word ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00116fa0
JMP 0x0013ebc4
caseD_6:
MOV RBP,qword ptr [R13]
MOV RDI,R13
XOR ESI,ESI
CALL 0x001164c0
MOVSS XMM0,dword ptr [RAX]
MOV RDI,R14
MOV RSI,RBP
CALL 0x00117c50
JMP 0x0013ebc4
LAB_0013edeb:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_9:
LEA RDI,[0x159de5]
LEA RDX,[0x15a394]
MOV ESI,0x422
JMP 0x0013ee22
LAB_0013ee0f:
LEA RDI,[0x159de5]
LEA RDX,[0x15a394]
MOV ESI,0x43f
LAB_0013ee22:
XOR EAX,EAX
CALL 0x00117c60
|
void gguf_set_kv(int8 param_1,long param_2)
{
gguf_kv *this;
uint uVar1;
ulong uVar2;
allocator *paVar3;
uchar *puVar4;
long lVar5;
double *pdVar6;
ulong *puVar7;
long *plVar8;
string *psVar9;
uint *puVar10;
char *pcVar11;
int *piVar12;
ushort *puVar13;
bool *pbVar14;
short *psVar15;
float *pfVar16;
allocator *paVar17;
int8 uVar18;
long lVar19;
long lVar20;
void *local_48 [2];
long local_38;
uVar2 = *(long *)(param_2 + 0x10) - *(long *)(param_2 + 8);
if (0 < (long)uVar2) {
lVar20 = (uVar2 >> 3) * 0x2e8ba2e8ba2e8ba3;
lVar19 = 0;
do {
this = (gguf_kv *)(*(long *)(param_2 + 8) + lVar19 * 0x58);
if (*(char *)(*(long *)(param_2 + 8) + 0x20 + lVar19 * 0x58) == '\0') {
switch(*(int4 *)(this + 0x24)) {
case 0:
uVar18 = *(int8 *)this;
puVar4 = gguf_kv::get_val<unsigned_char>(this,0);
gguf_set_val_u8(param_1,uVar18,*puVar4);
break;
case 1:
uVar18 = *(int8 *)this;
pcVar11 = gguf_kv::get_val<signed_char>(this,0);
gguf_set_val_i8(param_1,uVar18,(int)*pcVar11);
break;
case 2:
uVar18 = *(int8 *)this;
puVar13 = gguf_kv::get_val<unsigned_short>(this,0);
gguf_set_val_u16(param_1,uVar18,*puVar13);
break;
case 3:
uVar18 = *(int8 *)this;
psVar15 = gguf_kv::get_val<short>(this,0);
gguf_set_val_i16(param_1,uVar18,(int)*psVar15);
break;
case 4:
uVar18 = *(int8 *)this;
puVar10 = gguf_kv::get_val<unsigned_int>(this,0);
gguf_set_val_u32(param_1,uVar18,*puVar10);
break;
case 5:
uVar18 = *(int8 *)this;
piVar12 = gguf_kv::get_val<int>(this,0);
gguf_set_val_i32(param_1,uVar18,*piVar12);
break;
case 6:
pfVar16 = gguf_kv::get_val<float>(this,0);
gguf_set_val_f32(*pfVar16,param_1);
break;
case 7:
uVar18 = *(int8 *)this;
pbVar14 = gguf_kv::get_val<bool>(this,0);
gguf_set_val_bool(param_1,uVar18,*pbVar14);
break;
case 8:
uVar18 = *(int8 *)this;
psVar9 = gguf_kv::get_val<std::__cxx11::string>(this,0);
gguf_set_val_str(param_1,uVar18,*(int8 *)psVar9);
break;
default:
uVar18 = 0x422;
LAB_0013ee22:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/gguf.cpp",
uVar18,"invalid type");
case 10:
uVar18 = *(int8 *)this;
puVar7 = gguf_kv::get_val<unsigned_long>(this,0);
gguf_set_val_u64(param_1,uVar18,*puVar7);
break;
case 0xb:
uVar18 = *(int8 *)this;
plVar8 = gguf_kv::get_val<long>(this,0);
gguf_set_val_i64(param_1,uVar18,*plVar8);
break;
case 0xc:
pdVar6 = gguf_kv::get_val<double>(this,0);
gguf_set_val_f64(*pdVar6,param_1);
}
}
else {
paVar3 = (allocator *)gguf_kv::get_ne(this);
uVar1 = *(uint *)(this + 0x24);
if ((uVar1 < 8) || (uVar1 - 10 < 3)) {
gguf_set_arr_data(param_1,*(int8 *)this,uVar1,*(int8 *)(this + 0x28),paVar3);
}
else {
if (uVar1 != 8) {
uVar18 = 0x43f;
goto LAB_0013ee22;
}
std::vector<char_const*,std::allocator<char_const*>>::vector((ulong)local_48,paVar3);
if (paVar3 != (allocator *)0x0) {
lVar5 = 0;
paVar17 = paVar3;
do {
*(int8 *)((long)local_48[0] + lVar5) =
*(int8 *)(*(long *)(this + 0x40) + lVar5 * 4);
lVar5 = lVar5 + 8;
paVar17 = paVar17 + -1;
} while (paVar17 != (allocator *)0x0);
}
/* try { // try from 0013ec55 to 0013ec5f has its CatchHandler @ 0013ee29 */
gguf_set_arr_str(param_1,*(int8 *)this,local_48[0],paVar3);
if (local_48[0] != (void *)0x0) {
operator_delete(local_48[0],local_38 - (long)local_48[0]);
}
}
}
lVar19 = lVar19 + 1;
} while (lVar19 != lVar20 + (ulong)(lVar20 == 0));
}
return;
}
|
|
60,031
|
ma_write_init_block_record
|
eloqsql/storage/maria/ma_blockrec.c
|
MARIA_RECORD_POS _ma_write_init_block_record(MARIA_HA *info,
const uchar *record)
{
DBUG_ENTER("_ma_write_init_block_record");
calc_record_size(info, record, &info->cur_row);
if (allocate_and_write_block_record(info, record,
&info->cur_row, LSN_ERROR))
DBUG_RETURN(HA_OFFSET_ERROR);
DBUG_RETURN(info->cur_row.lastpos);
}
|
O0
|
c
|
ma_write_init_block_record:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
callq 0x750b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq $0x80, %rdx
movl $0x1, %ecx
callq 0x756d0
cmpb $0x0, %al
je 0x75095
jmp 0x7508b
movq $-0x1, -0x8(%rbp)
jmp 0x750a6
jmp 0x75097
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
|
_ma_write_init_block_record:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
add rdx, 80h
call calc_record_size
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_10]
add rdx, 80h
mov ecx, 1
call allocate_and_write_block_record
cmp al, 0
jz short loc_75095
jmp short $+2
loc_7508B:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_750A6
loc_75095:
jmp short $+2
loc_75097:
mov rax, [rbp+var_10]
mov rax, [rax+98h]
mov [rbp+var_8], rax
loc_750A6:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long ma_write_init_block_record(long long a1, long long a2)
{
calc_record_size(a1, a2, a1 + 128);
if ( (unsigned __int8)allocate_and_write_block_record(a1, a2, a1 + 128, 1LL) )
return -1LL;
else
return *(_QWORD *)(a1 + 152);
}
|
_ma_write_init_block_record:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x80
CALL 0x001750b0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0x80
MOV ECX,0x1
CALL 0x001756d0
CMP AL,0x0
JZ 0x00175095
JMP 0x0017508b
LAB_0017508b:
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x001750a6
LAB_00175095:
JMP 0x00175097
LAB_00175097:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RBP + -0x8],RAX
LAB_001750a6:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
int8 _ma_write_init_block_record(long param_1,int8 param_2)
{
char cVar1;
int8 local_10;
calc_record_size(param_1,param_2,param_1 + 0x80);
cVar1 = allocate_and_write_block_record(param_1,param_2,param_1 + 0x80,1);
if (cVar1 == '\0') {
local_10 = *(int8 *)(param_1 + 0x98);
}
else {
local_10 = 0xffffffffffffffff;
}
return local_10;
}
|
|
60,032
|
glyph_traverse_func
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c
|
static void glyph_traverse_func(void* closure, plutovg_path_command_t command, const plutovg_point_t* points, int npoints)
{
plutovg_path_t* path = (plutovg_path_t*)(closure);
switch(command) {
case PLUTOVG_PATH_COMMAND_MOVE_TO:
plutovg_path_move_to(path, points[0].x, points[0].y);
break;
case PLUTOVG_PATH_COMMAND_LINE_TO:
plutovg_path_line_to(path, points[0].x, points[0].y);
break;
case PLUTOVG_PATH_COMMAND_CUBIC_TO:
plutovg_path_cubic_to(path, points[0].x, points[0].y, points[1].x, points[1].y, points[2].x, points[2].y);
break;
case PLUTOVG_PATH_COMMAND_CLOSE:
assert(false);
}
}
|
O0
|
c
|
glyph_traverse_func:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x57bda
movq -0x30(%rbp), %rax
leaq 0x35e16(%rip), %rcx # 0x8d950
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
callq 0x5fea0
jmp 0x57bda
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
callq 0x60020
jmp 0x57bda
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movq -0x18(%rbp), %rax
movss 0x4(%rax), %xmm1
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm2
movq -0x18(%rbp), %rax
movss 0xc(%rax), %xmm3
movq -0x18(%rbp), %rax
movss 0x10(%rax), %xmm4
movq -0x18(%rbp), %rax
movss 0x14(%rax), %xmm5
callq 0x60230
jmp 0x57bda
leaq 0x349dd(%rip), %rdi # 0x8c59f
leaq 0x35f87(%rip), %rsi # 0x8db50
movl $0x12c, %edx # imm = 0x12C
leaq 0x364a9(%rip), %rcx # 0x8e07e
callq 0xb210
addq $0x30, %rsp
popq %rbp
retq
|
glyph_traverse_func:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov eax, [rbp+var_C]
mov [rbp+var_30], rax
sub rax, 3; switch 4 cases
ja def_57B41; jumptable 0000000000057B41 default case
mov rax, [rbp+var_30]
lea rcx, jpt_57B41
movsxd rax, ds:(jpt_57B41 - 8D950h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_57B43:
mov rdi, [rbp+var_28]; jumptable 0000000000057B41 case 0
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+4]
call plutovg_path_move_to
jmp short def_57B41; jumptable 0000000000057B41 default case
loc_57B5F:
mov rdi, [rbp+var_28]; jumptable 0000000000057B41 case 1
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+4]
call plutovg_path_line_to
jmp short def_57B41; jumptable 0000000000057B41 default case
loc_57B7B:
mov rdi, [rbp+var_28]; jumptable 0000000000057B41 case 2
mov rax, [rbp+var_18]
movss xmm0, dword ptr [rax]
mov rax, [rbp+var_18]
movss xmm1, dword ptr [rax+4]
mov rax, [rbp+var_18]
movss xmm2, dword ptr [rax+8]
mov rax, [rbp+var_18]
movss xmm3, dword ptr [rax+0Ch]
mov rax, [rbp+var_18]
movss xmm4, dword ptr [rax+10h]
mov rax, [rbp+var_18]
movss xmm5, dword ptr [rax+14h]
call plutovg_path_cubic_to
jmp short def_57B41; jumptable 0000000000057B41 default case
loc_57BBB:
lea rdi, aFalse; jumptable 0000000000057B41 case 3
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
mov edx, 12Ch
lea rcx, aVoidGlyphTrave; "void glyph_traverse_func(void *, plutov"...
call ___assert_fail
def_57B41:
add rsp, 30h; jumptable 0000000000057B41 default case
pop rbp
retn
|
long long glyph_traverse_func(long long a1, unsigned int a2, float *a3)
{
long long result; // rax
result = a2;
switch ( a2 )
{
case 0u:
result = plutovg_path_move_to(a1, *a3, a3[1]);
break;
case 1u:
result = plutovg_path_line_to(a1, *a3, a3[1]);
break;
case 2u:
result = plutovg_path_cubic_to(a1, *a3, a3[1], a3[2], a3[3], a3[4], a3[5]);
break;
case 3u:
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c",
300LL,
"void glyph_traverse_func(void *, plutovg_path_command_t, const plutovg_point_t *, int)");
default:
return result;
}
return result;
}
|
glyph_traverse_func:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x30],RAX
SUB RAX,0x3
JA 0x00157bda
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[0x18d950]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x4]
CALL 0x0015fea0
JMP 0x00157bda
caseD_1:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x4]
CALL 0x00160020
JMP 0x00157bda
caseD_2:
MOV RDI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM0,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM1,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM2,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM3,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM4,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOVSS XMM5,dword ptr [RAX + 0x14]
CALL 0x00160230
JMP 0x00157bda
caseD_3:
LEA RDI,[0x18c59f]
LEA RSI,[0x18db50]
MOV EDX,0x12c
LEA RCX,[0x18e07e]
CALL 0x0010b210
default:
ADD RSP,0x30
POP RBP
RET
|
void glyph_traverse_func(int8 param_1,int4 param_2,int4 *param_3)
{
switch(param_2) {
case 0:
plutovg_path_move_to(*param_3,param_3[1],param_1);
break;
case 1:
plutovg_path_line_to(*param_3,param_3[1],param_1);
break;
case 2:
plutovg_path_cubic_to(*param_3,param_3[1],param_3[2],param_3[3],param_3[4],param_3[5],param_1);
break;
case 3:
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c"
,300,
"void glyph_traverse_func(void *, plutovg_path_command_t, const plutovg_point_t *, int)"
);
}
return;
}
|
|
60,033
|
glyph_traverse_func
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c
|
static void glyph_traverse_func(void* closure, plutovg_path_command_t command, const plutovg_point_t* points, int npoints)
{
plutovg_path_t* path = (plutovg_path_t*)(closure);
switch(command) {
case PLUTOVG_PATH_COMMAND_MOVE_TO:
plutovg_path_move_to(path, points[0].x, points[0].y);
break;
case PLUTOVG_PATH_COMMAND_LINE_TO:
plutovg_path_line_to(path, points[0].x, points[0].y);
break;
case PLUTOVG_PATH_COMMAND_CUBIC_TO:
plutovg_path_cubic_to(path, points[0].x, points[0].y, points[1].x, points[1].y, points[2].x, points[2].y);
break;
case PLUTOVG_PATH_COMMAND_CLOSE:
assert(false);
}
}
|
O1
|
c
|
glyph_traverse_func:
cmpl $0x3, %esi
ja 0x2590f
movl %esi, %eax
leaq 0x1f126(%rip), %rcx # 0x449fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
jmp 0x2a28b
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
movss 0x8(%rdx), %xmm2
movss 0xc(%rdx), %xmm3
movss 0x10(%rdx), %xmm4
movss 0x14(%rdx), %xmm5
jmp 0x2a452
retq
movss (%rdx), %xmm0
movss 0x4(%rdx), %xmm1
jmp 0x2a349
pushq %rax
leaq 0x1dcc3(%rip), %rdi # 0x435e9
leaq 0x1f29b(%rip), %rsi # 0x44bc8
leaq 0x1f72c(%rip), %rcx # 0x45060
movl $0x12c, %edx # imm = 0x12C
callq 0xa200
|
glyph_traverse_func:
cmp esi, 3; switch 4 cases
ja short def_258DD; jumptable 00000000000258DD default case
mov eax, esi
lea rcx, jpt_258DD
movsxd rax, ds:(jpt_258DD - 449FCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_258DF:
movss xmm0, dword ptr [rdx]; jumptable 00000000000258DD case 0
movss xmm1, dword ptr [rdx+4]
jmp plutovg_path_move_to
loc_258ED:
movss xmm0, dword ptr [rdx]; jumptable 00000000000258DD case 2
movss xmm1, dword ptr [rdx+4]
movss xmm2, dword ptr [rdx+8]
movss xmm3, dword ptr [rdx+0Ch]
movss xmm4, dword ptr [rdx+10h]
movss xmm5, dword ptr [rdx+14h]
jmp plutovg_path_cubic_to
def_258DD:
retn; jumptable 00000000000258DD default case
loc_25910:
movss xmm0, dword ptr [rdx]; jumptable 00000000000258DD case 1
movss xmm1, dword ptr [rdx+4]
jmp plutovg_path_line_to
loc_2591E:
push rax; jumptable 00000000000258DD case 3
lea rdi, aFalse; "false"
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlyphTrave; "void glyph_traverse_func(void *, plutov"...
mov edx, 12Ch
call ___assert_fail
|
long long glyph_traverse_func(long long a1, unsigned int a2, float *a3)
{
long long result; // rax
result = a2;
switch ( a2 )
{
case 0u:
result = plutovg_path_move_to(a1, *a3, a3[1]);
break;
case 1u:
result = plutovg_path_line_to(a1, *a3, a3[1]);
break;
case 2u:
result = plutovg_path_cubic_to(a1, *a3, a3[1], a3[2], a3[3], a3[4], a3[5]);
break;
case 3u:
__assert_fail(
"false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c",
300LL,
"void glyph_traverse_func(void *, plutovg_path_command_t, const plutovg_point_t *, int)");
default:
return result;
}
return result;
}
|
glyph_traverse_func:
CMP ESI,0x3
JA 0x0012590f
MOV EAX,ESI
LEA RCX,[0x1449fc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDX + 0x4]
JMP 0x0012a28b
caseD_2:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDX + 0x4]
MOVSS XMM2,dword ptr [RDX + 0x8]
MOVSS XMM3,dword ptr [RDX + 0xc]
MOVSS XMM4,dword ptr [RDX + 0x10]
MOVSS XMM5,dword ptr [RDX + 0x14]
JMP 0x0012a452
LAB_0012590f:
RET
caseD_1:
MOVSS XMM0,dword ptr [RDX]
MOVSS XMM1,dword ptr [RDX + 0x4]
JMP 0x0012a349
caseD_3:
PUSH RAX
LEA RDI,[0x1435e9]
LEA RSI,[0x144bc8]
LEA RCX,[0x145060]
MOV EDX,0x12c
CALL 0x0010a200
|
void glyph_traverse_func(int8 param_1,int4 param_2,int4 *param_3)
{
switch(param_2) {
case 0:
plutovg_path_move_to(*param_3,param_3[1]);
return;
case 1:
plutovg_path_line_to(*param_3,param_3[1]);
return;
case 2:
plutovg_path_cubic_to(*param_3,param_3[1],param_3[2],param_3[3],param_3[4],param_3[5]);
return;
case 3:
/* WARNING: Subroutine does not return */
__assert_fail("false",
"/workspace/llm4binary/github/2025_star3/dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-font.c"
,300,
"void glyph_traverse_func(void *, plutovg_path_command_t, const plutovg_point_t *, int)"
);
default:
return;
}
}
|
|
60,034
|
parse_device_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
monkey531[P]llama/common/arg.cpp
|
static std::vector<ggml_backend_dev_t> parse_device_list(const std::string & value) {
std::vector<ggml_backend_dev_t> devices;
auto dev_names = string_split<std::string>(value, ',');
if (dev_names.empty()) {
throw std::invalid_argument("no devices specified");
}
if (dev_names.size() == 1 && dev_names[0] == "none") {
devices.push_back(nullptr);
} else {
for (const auto & device : dev_names) {
auto * dev = ggml_backend_dev_by_name(device.c_str());
if (!dev || ggml_backend_dev_type(dev) != GGML_BACKEND_DEVICE_TYPE_GPU) {
throw std::invalid_argument(string_format("invalid device: %s", device.c_str()));
}
devices.push_back(dev);
}
devices.push_back(nullptr);
}
return devices;
}
|
O2
|
cpp
|
parse_device_list(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsp, %rdi
pushq $0x2c
popq %rdx
callq 0x35439
movq (%rsp), %r14
movq 0x8(%rsp), %r12
cmpq %r12, %r14
je 0x36c7a
movq %r12, %rax
subq %r14, %rax
cmpq $0x20, %rax
jne 0x36bcc
leaq 0x745e3(%rip), %rsi # 0xab187
movq %r14, %rdi
callq 0x391b2
testb %al, %al
je 0x36bc3
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x45e74
jmp 0x36c17
movq (%rsp), %r14
movq 0x8(%rsp), %r12
leaq 0x18(%rsp), %r15
cmpq %r12, %r14
je 0x36c06
movq (%r14), %rdi
callq 0x230f0
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x36c2f
movq %rax, %rdi
callq 0x23170
cmpl $0x1, %eax
jne 0x36c2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x45e56
addq $0x20, %r14
jmp 0x36bd1
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
movq %rbx, %rdi
callq 0x45e74
movq %rsp, %rdi
callq 0x26e4a
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r15
movq (%r14), %rdx
leaq 0x795c7(%rip), %rsi # 0xb020b
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
callq 0x53597
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x23f10
xorl %ebp, %ebp
movq 0xc5367(%rip), %rsi # 0xfbfd0
movq 0xc5340(%rip), %rdx # 0xfbfb0
movq %r15, %rdi
callq 0x23ef0
jmp 0x36caa
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %r15
leaq 0x7956a(%rip), %rsi # 0xb01f6
movq %rax, %rdi
callq 0x240b0
movq 0xc5335(%rip), %rsi # 0xfbfd0
movq 0xc530e(%rip), %rdx # 0xfbfb0
movq %r15, %rdi
callq 0x23ef0
jmp 0x36cd8
jmp 0x36cd8
jmp 0x36ccb
jmp 0x36cd8
movq %rax, %r14
jmp 0x36ce3
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x241b8
testb %bpl, %bpl
jne 0x36cce
jmp 0x36cdb
movq %rax, %r14
movq %r15, %rdi
callq 0x23680
jmp 0x36cdb
movq %rax, %r14
movq %rsp, %rdi
callq 0x26e4a
movq %rbx, %rdi
callq 0x27b2c
movq %r14, %rdi
callq 0x23f80
nop
|
_ZL17parse_device_listRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
mov rdi, rsp
push 2Ch ; ','
pop rdx
call _ZL12string_splitINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEESt6vectorIT_SaIS7_EERKS5_c; string_split<std::string>(std::string const&,char)
mov r14, [rsp+68h+var_68]
mov r12, [rsp+68h+var_60]
cmp r14, r12
jz loc_36C7A
mov rax, r12
sub rax, r14
cmp rax, 20h ; ' '
jnz short loc_36BCC
lea rsi, aNone; "none"
mov rdi, r14
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jz short loc_36BC3
lea rsi, [rsp+68h+var_48]
and qword ptr [rsi], 0
mov rdi, rbx
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<ggml_backend_device *>::emplace_back<ggml_backend_device *>(ggml_backend_device * &&)
jmp short loc_36C17
loc_36BC3:
mov r14, [rsp+68h+var_68]
mov r12, [rsp+68h+var_60]
loc_36BCC:
lea r15, [rsp+68h+var_50]
loc_36BD1:
cmp r14, r12
jz short loc_36C06
mov rdi, [r14]
call _ggml_backend_dev_by_name
mov [rsp+68h+var_50], rax
test rax, rax
jz short loc_36C2F
mov rdi, rax
call _ggml_backend_dev_type
cmp eax, 1
jnz short loc_36C2F
mov rdi, rbx
mov rsi, r15
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE9push_backERKS1_; std::vector<ggml_backend_device *>::push_back(ggml_backend_device * const&)
add r14, 20h ; ' '
jmp short loc_36BD1
loc_36C06:
lea rsi, [rsp+68h+var_48]
and qword ptr [rsi], 0
mov rdi, rbx
call _ZNSt6vectorIP19ggml_backend_deviceSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<ggml_backend_device *>::emplace_back<ggml_backend_device *>(ggml_backend_device * &&)
loc_36C17:
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, rbx
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_36C2F:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
mov rdx, [r14]
lea rsi, aInvalidDeviceS; "invalid device: %s"
lea rdi, [rsp+68h+var_48]
xor eax, eax
call _Z13string_formatB5cxx11PKcz; string_format(char const*,...)
mov bpl, 1
lea rsi, [rsp+68h+var_48]
mov rdi, r15
call __ZNSt16invalid_argumentC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::invalid_argument::invalid_argument(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt16invalid_argumentD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_36CAA
loc_36C7A:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aNoDevicesSpeci; "no devices specified"
mov rdi, rax; this
call __ZNSt16invalid_argumentC1EPKc; std::invalid_argument::invalid_argument(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt16invalid_argumentD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_36CAA:
jmp short loc_36CD8
jmp short loc_36CD8
jmp short loc_36CCB
jmp short loc_36CD8
mov r14, rax
jmp short loc_36CE3
mov r14, rax
lea rdi, [rsp+68h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_36CCE
jmp short loc_36CDB
loc_36CCB:
mov r14, rax
loc_36CCE:
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_36CDB
loc_36CD8:
mov r14, rax
loc_36CDB:
mov rdi, rsp
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_36CE3:
mov rdi, rbx
call _ZNSt12_Vector_baseIP19ggml_backend_deviceSaIS1_EED2Ev; std::_Vector_base<ggml_backend_device *>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
|
long long parse_device_list(long long a1, long long a2)
{
_QWORD *v2; // r14
_QWORD *v3; // r12
long long v4; // rax
void *v6; // r15
int v7; // ecx
int v8; // r8d
int v9; // r9d
std::invalid_argument *exception; // r15
_QWORD *v11; // [rsp+0h] [rbp-68h] BYREF
_QWORD *v12; // [rsp+8h] [rbp-60h]
long long v13; // [rsp+18h] [rbp-50h] BYREF
_QWORD v14[9]; // [rsp+20h] [rbp-48h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
string_split<std::string>((long long)&v11, a2, 0x2Cu);
v2 = v11;
v3 = v12;
if ( v11 == v12 )
{
exception = (std::invalid_argument *)__cxa_allocate_exception(0x10uLL);
std::invalid_argument::invalid_argument(exception, "no devices specified");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::invalid_argument,
(void (*)(void *))&std::invalid_argument::~invalid_argument);
}
if ( (char *)v12 - (char *)v11 == 32 )
{
if ( (unsigned __int8)std::operator==<char>(v11, "none") )
goto LABEL_9;
v2 = v11;
v3 = v12;
}
while ( v2 != v3 )
{
v4 = ggml_backend_dev_by_name(*v2);
v13 = v4;
if ( !v4 || (unsigned int)ggml_backend_dev_type(v4) != 1 )
{
v6 = __cxa_allocate_exception(0x10uLL);
string_format[abi:cxx11]((unsigned int)v14, (unsigned int)"invalid device: %s", *v2, v7, v8, v9);
std::invalid_argument::invalid_argument(v6, v14);
__cxa_throw(
v6,
(struct type_info *)&`typeinfo for'std::invalid_argument,
(void (*)(void *))&std::invalid_argument::~invalid_argument);
}
std::vector<ggml_backend_device *>::push_back(a1, &v13);
v2 += 4;
}
LABEL_9:
v14[0] = 0LL;
std::vector<ggml_backend_device *>::emplace_back<ggml_backend_device *>(a1, v14);
std::vector<std::string>::~vector((long long)&v11);
return a1;
}
|
parse_device_list:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
LAB_00136b74:
MOV RDI,RSP
PUSH 0x2c
POP RDX
CALL 0x00135439
MOV R14,qword ptr [RSP]
MOV R12,qword ptr [RSP + 0x8]
CMP R14,R12
JZ 0x00136c7a
MOV RAX,R12
SUB RAX,R14
CMP RAX,0x20
JNZ 0x00136bcc
LEA RSI,[0x1ab187]
MOV RDI,R14
CALL 0x001391b2
TEST AL,AL
JZ 0x00136bc3
LEA RSI,[RSP + 0x20]
AND qword ptr [RSI],0x0
LAB_00136bb9:
MOV RDI,RBX
CALL 0x00145e74
JMP 0x00136c17
LAB_00136bc3:
MOV R14,qword ptr [RSP]
MOV R12,qword ptr [RSP + 0x8]
LAB_00136bcc:
LEA R15,[RSP + 0x18]
LAB_00136bd1:
CMP R14,R12
JZ 0x00136c06
MOV RDI,qword ptr [R14]
LAB_00136bd9:
CALL 0x001230f0
MOV qword ptr [RSP + 0x18],RAX
TEST RAX,RAX
JZ 0x00136c2f
MOV RDI,RAX
CALL 0x00123170
CMP EAX,0x1
JNZ 0x00136c2f
MOV RDI,RBX
MOV RSI,R15
CALL 0x00145e56
ADD R14,0x20
JMP 0x00136bd1
LAB_00136c06:
LEA RSI,[RSP + 0x20]
AND qword ptr [RSI],0x0
LAB_00136c0f:
MOV RDI,RBX
CALL 0x00145e74
LAB_00136c17:
MOV RDI,RSP
CALL 0x00126e4a
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00136c2f:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R15,RAX
MOV RDX,qword ptr [R14]
LAB_00136c3d:
LEA RSI,[0x1b020b]
LEA RDI,[RSP + 0x20]
XOR EAX,EAX
CALL 0x00153597
MOV BPL,0x1
LAB_00136c53:
LEA RSI,[RSP + 0x20]
MOV RDI,R15
CALL 0x00123f10
XOR EBP,EBP
MOV RSI,qword ptr [0x001fbfd0]
MOV RDX,qword ptr [0x001fbfb0]
MOV RDI,R15
CALL 0x00123ef0
LAB_00136c7a:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV R15,RAX
LAB_00136c85:
LEA RSI,[0x1b01f6]
MOV RDI,RAX
CALL 0x001240b0
LAB_00136c94:
MOV RSI,qword ptr [0x001fbfd0]
MOV RDX,qword ptr [0x001fbfb0]
MOV RDI,R15
CALL 0x00123ef0
|
/* parse_device_list(std::__cxx11::string const&) */
string * parse_device_list(string *param_1)
{
bool bVar1;
int iVar2;
invalid_argument *piVar3;
char in_SIL;
string *psVar4;
string *psVar5;
string *local_68;
string *local_60;
ggml_backend_device *local_50;
ggml_backend_device *local_48 [4];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
/* try { // try from 00136b74 to 00136b7e has its CatchHandler @ 00136cb2 */
string_split<std::__cxx11::string>((string *)&local_68,in_SIL);
if (local_68 == local_60) {
piVar3 = (invalid_argument *)__cxa_allocate_exception(0x10);
/* try { // try from 00136c85 to 00136c93 has its CatchHandler @ 00136cae */
std::invalid_argument::invalid_argument(piVar3,"no devices specified");
/* try { // try from 00136c94 to 00136ca9 has its CatchHandler @ 00136cac */
/* WARNING: Subroutine does not return */
__cxa_throw(piVar3,PTR_typeinfo_001fbfd0,PTR__invalid_argument_001fbfb0);
}
psVar4 = local_60;
psVar5 = local_68;
if (((long)local_60 - (long)local_68 == 0x20) &&
(bVar1 = std::operator==(local_68,"none"), psVar4 = local_60, psVar5 = local_68, bVar1)) {
local_48[0] = (ggml_backend_device *)0x0;
/* try { // try from 00136bb9 to 00136bc0 has its CatchHandler @ 00136caa */
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::
emplace_back<ggml_backend_device*>
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,local_48
);
}
else {
for (; psVar5 != psVar4; psVar5 = psVar5 + 0x20) {
/* try { // try from 00136bd9 to 00136bff has its CatchHandler @ 00136cd8 */
local_50 = (ggml_backend_device *)ggml_backend_dev_by_name(*(int8 *)psVar5);
if ((local_50 == (ggml_backend_device *)0x0) ||
(iVar2 = ggml_backend_dev_type(local_50), iVar2 != 1)) {
piVar3 = (invalid_argument *)__cxa_allocate_exception(0x10);
/* try { // try from 00136c3d to 00136c4f has its CatchHandler @ 00136ccb */
string_format_abi_cxx11_((char *)local_48,"invalid device: %s",*(int8 *)psVar5);
/* try { // try from 00136c53 to 00136c77 has its CatchHandler @ 00136cb7 */
std::invalid_argument::invalid_argument(piVar3,(string *)local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(piVar3,PTR_typeinfo_001fbfd0,PTR__invalid_argument_001fbfb0);
}
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::push_back
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,
&local_50);
}
local_48[0] = (ggml_backend_device *)0x0;
/* try { // try from 00136c0f to 00136c16 has its CatchHandler @ 00136cb0 */
std::vector<ggml_backend_device*,std::allocator<ggml_backend_device*>>::
emplace_back<ggml_backend_device*>
((vector<ggml_backend_device*,std::allocator<ggml_backend_device*>> *)param_1,local_48
);
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
return param_1;
}
|
|
60,035
|
minja::SequenceNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
for (const auto& child : children) child->render(out, context);
}
|
O2
|
cpp
|
minja::SequenceNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rdi), %r15
movq 0x28(%rdi), %r12
cmpq %r12, %r15
je 0x78223
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7332e
addq $0x10, %r15
jmp 0x7820a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK5minja12SequenceNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r15, [rdi+20h]
mov r12, [rdi+28h]
loc_7820A:
cmp r15, r12
jz short loc_78223
mov rdi, [r15]
mov rsi, r14
mov rdx, rbx
call _ZNK5minja12TemplateNode6renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE; minja::TemplateNode::render(std::ostringstream &,std::shared_ptr<minja::Context> const&)
add r15, 10h
jmp short loc_7820A
loc_78223:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long minja::SequenceNode::do_render(long long a1)
{
long long ( ****v1)(_QWORD); // r15
long long ( ****v2)(_QWORD); // r12
long long result; // rax
v1 = *(long long ( *****)(_QWORD))(a1 + 32);
v2 = *(long long ( *****)(_QWORD))(a1 + 40);
while ( v1 != v2 )
{
result = minja::TemplateNode::render(*v1);
v1 += 2;
}
return result;
}
|
do_render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R15,qword ptr [RDI + 0x20]
MOV R12,qword ptr [RDI + 0x28]
LAB_0017820a:
CMP R15,R12
JZ 0x00178223
MOV RDI,qword ptr [R15]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0017332e
ADD R15,0x10
JMP 0x0017820a
LAB_00178223:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::SequenceNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context>
const&) const */
void minja::SequenceNode::do_render(ostringstream *param_1,shared_ptr *param_2)
{
int8 *puVar1;
int8 *puVar2;
puVar1 = *(int8 **)(param_1 + 0x28);
for (puVar2 = *(int8 **)(param_1 + 0x20); puVar2 != puVar1; puVar2 = puVar2 + 2) {
TemplateNode::render((ostringstream *)*puVar2,param_2);
}
return;
}
|
|
60,036
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
monkey531[P]llama/common/minja.hpp
|
static std::string error_location_suffix(const std::string & source, size_t pos) {
auto get_line = [&](size_t line) {
auto start = source.begin();
for (size_t i = 1; i < line; ++i) {
start = std::find(start, source.end(), '\n') + 1;
}
auto end = std::find(start, source.end(), '\n');
return std::string(start, end);
};
auto start = source.begin();
auto end = source.end();
auto it = start + pos;
auto line = std::count(start, it, '\n') + 1;
auto max_line = std::count(start, end, '\n') + 1;
auto col = pos - std::string(start, it).rfind('\n');
std::ostringstream out;
out << " at row " << line << ", column " << col << ":\n";
if (line > 1) out << get_line(line - 1) << "\n";
out << get_line(line) << "\n";
out << std::string(col - 1, ' ') << "^\n";
if (line < max_line) out << get_line(line + 1) << "\n";
return out.str();
}
|
O0
|
cpp
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
subq $0x358, %rsp # imm = 0x358
movq %rdi, 0x70(%rsp)
movq %rdi, %rax
movq %rax, 0x78(%rsp)
movq %rdi, 0x350(%rsp)
movq %rsi, 0x348(%rsp)
movq %rdx, 0x340(%rsp)
movq 0x348(%rsp), %rax
movq %rax, 0x338(%rsp)
movq 0x348(%rsp), %rdi
callq 0x5c400
movq %rax, 0x330(%rsp)
movq 0x348(%rsp), %rdi
callq 0x5d4b0
movq %rax, 0x328(%rsp)
movq 0x340(%rsp), %rsi
leaq 0x330(%rsp), %rdi
callq 0x118250
movq %rax, 0x320(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x310(%rsp)
movq 0x320(%rsp), %rax
movq %rax, 0x308(%rsp)
movb $0xa, 0x307(%rsp)
movq 0x310(%rsp), %rdi
movq 0x308(%rsp), %rsi
leaq 0x307(%rsp), %rdx
callq 0x14f5d0
incq %rax
movq %rax, 0x318(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x2f0(%rsp)
movq 0x328(%rsp), %rax
movq %rax, 0x2e8(%rsp)
movb $0xa, 0x2e7(%rsp)
movq 0x2f0(%rsp), %rdi
movq 0x2e8(%rsp), %rsi
leaq 0x2e7(%rsp), %rdx
callq 0x14f5d0
incq %rax
movq %rax, 0x2f8(%rsp)
movq 0x340(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x330(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movq 0x320(%rsp), %rax
movq %rax, 0x2a8(%rsp)
leaq 0x2a7(%rsp), %rdi
movq %rdi, 0x88(%rsp)
callq 0x5d2b0
movq 0x88(%rsp), %rcx
movq 0x2b0(%rsp), %rsi
movq 0x2a8(%rsp), %rdx
leaq 0x2b8(%rsp), %rdi
callq 0xf17b0
jmp 0xff18f
leaq 0x2b8(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl $0xa, %esi
movq $-0x1, %rdx
callq 0x5c850
movq 0x50(%rsp), %rdi
movq %rax, %rcx
movq 0x80(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x58(%rsp)
callq 0x5d858
leaq 0x2a7(%rsp), %rdi
callq 0x5d830
movq 0x58(%rsp), %rax
movq %rax, 0x2d8(%rsp)
leaq 0x118(%rsp), %rdi
movq %rdi, 0x60(%rsp)
callq 0x5d280
movq 0x60(%rsp), %rdi
leaq 0x11b61c(%rip), %rsi # 0x21a81e
callq 0x5cb00
movq %rax, 0x68(%rsp)
jmp 0xff20e
movq 0x68(%rsp), %rdi
movq 0x318(%rsp), %rsi
callq 0x5c720
movq %rax, 0x48(%rsp)
jmp 0xff227
movq 0x48(%rsp), %rdi
leaq 0x1177dc(%rip), %rsi # 0x216a0f
callq 0x5cb00
movq %rax, 0x40(%rsp)
jmp 0xff23f
movq 0x40(%rsp), %rdi
movq 0x2d8(%rsp), %rsi
callq 0x5d480
movq %rax, 0x38(%rsp)
jmp 0xff258
movq 0x38(%rsp), %rdi
leaq 0x11f3ca(%rip), %rsi # 0x21e62e
callq 0x5cb00
jmp 0xff26b
cmpq $0x1, 0x318(%rsp)
jle 0xff33f
movq 0x318(%rsp), %rdx
decq %rdx
leaq 0xf8(%rsp), %rdi
leaq 0x338(%rsp), %rsi
callq 0xff660
jmp 0xff29c
leaq 0x118(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x5c5c0
movq %rax, 0x30(%rsp)
jmp 0xff2b8
movq 0x30(%rsp), %rdi
leaq 0x11647a(%rip), %rsi # 0x21573e
callq 0x5cb00
jmp 0xff2cb
leaq 0xf8(%rsp), %rdi
callq 0x5d858
jmp 0xff33f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0x2a7(%rsp), %rdi
callq 0x5d830
jmp 0xff566
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
jmp 0xff559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x5d858
jmp 0xff559
movq 0x318(%rsp), %rdx
leaq 0xd8(%rsp), %rdi
leaq 0x338(%rsp), %rsi
callq 0xff660
jmp 0xff35e
leaq 0x118(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x5c5c0
movq %rax, 0x28(%rsp)
jmp 0xff37a
movq 0x28(%rsp), %rdi
leaq 0x1163b8(%rip), %rsi # 0x21573e
callq 0x5cb00
jmp 0xff38d
leaq 0xd8(%rsp), %rdi
callq 0x5d858
movq 0x2d8(%rsp), %rax
decq %rax
movq %rax, 0x18(%rsp)
leaq 0xb7(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x5d2b0
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
leaq 0xb8(%rsp), %rdi
movl $0x20, %edx
callq 0x6f8e0
jmp 0xff3da
leaq 0x118(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x5c5c0
movq %rax, 0x10(%rsp)
jmp 0xff3f6
movq 0x10(%rsp), %rdi
leaq 0x11b425(%rip), %rsi # 0x21a827
callq 0x5cb00
jmp 0xff409
leaq 0xb8(%rsp), %rdi
callq 0x5d858
leaq 0xb7(%rsp), %rdi
callq 0x5d830
movq 0x318(%rsp), %rax
cmpq 0x2f8(%rsp), %rax
jge 0xff52b
movq 0x318(%rsp), %rdx
incq %rdx
leaq 0x90(%rsp), %rdi
leaq 0x338(%rsp), %rsi
callq 0xff660
jmp 0xff45b
leaq 0x118(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x5c5c0
movq %rax, 0x8(%rsp)
jmp 0xff477
movq 0x8(%rsp), %rdi
leaq 0x1162bb(%rip), %rsi # 0x21573e
callq 0x5cb00
jmp 0xff48a
leaq 0x90(%rsp), %rdi
callq 0x5d858
jmp 0xff52b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x5d858
jmp 0xff559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
jmp 0xff4f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x5d858
leaq 0xb7(%rsp), %rdi
callq 0x5d830
jmp 0xff559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x298(%rsp)
movl %eax, 0x294(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5d858
jmp 0xff559
movq 0x70(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x5d6f0
jmp 0xff53f
leaq 0x118(%rsp), %rdi
callq 0x5d170
movq 0x78(%rsp), %rax
addq $0x358, %rsp # imm = 0x358
retq
leaq 0x118(%rsp), %rdi
callq 0x5d170
movq 0x298(%rsp), %rdi
callq 0x5ccd0
nopw %cs:(%rax,%rax)
|
_ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm:
sub rsp, 358h
mov [rsp+358h+var_2E8], rdi
mov rax, rdi
mov [rsp+358h+var_2E0], rax
mov [rsp+358h+var_8], rdi
mov [rsp+358h+var_10], rsi
mov [rsp+358h+var_18], rdx
mov rax, [rsp+358h+var_10]
mov [rsp+358h+var_20], rax
mov rdi, [rsp+358h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5beginEv; std::string::begin(void)
mov [rsp+358h+var_28], rax
mov rdi, [rsp+358h+var_10]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE3endEv; std::string::end(void)
mov [rsp+358h+var_30], rax
mov rsi, [rsp+358h+var_18]
lea rdi, [rsp+358h+var_28]
call _ZNK9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEplEl; __gnu_cxx::__normal_iterator<char const*,std::string>::operator+(long)
mov [rsp+358h+var_38], rax
mov rax, [rsp+358h+var_28]
mov [rsp+358h+var_48], rax
mov rax, [rsp+358h+var_38]
mov [rsp+358h+var_50], rax
mov [rsp+358h+var_51], 0Ah
mov rdi, [rsp+358h+var_48]
mov rsi, [rsp+358h+var_50]
lea rdx, [rsp+358h+var_51]
call _ZSt5countIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEcENSt15iterator_traitsIT_E15difference_typeESC_SC_RKT0_; std::count<__gnu_cxx::__normal_iterator<char const*,std::string>,char>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,char const&)
inc rax
mov [rsp+358h+var_40], rax
mov rax, [rsp+358h+var_28]
mov [rsp+358h+var_68], rax
mov rax, [rsp+358h+var_30]
mov [rsp+358h+var_70], rax
mov [rsp+358h+var_71], 0Ah
mov rdi, [rsp+358h+var_68]
mov rsi, [rsp+358h+var_70]
lea rdx, [rsp+358h+var_71]
call _ZSt5countIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEcENSt15iterator_traitsIT_E15difference_typeESC_SC_RKT0_; std::count<__gnu_cxx::__normal_iterator<char const*,std::string>,char>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,char const&)
inc rax
mov [rsp+358h+var_60], rax
mov rax, [rsp+358h+var_18]
mov [rsp+358h+var_2D8], rax
mov rax, [rsp+358h+var_28]
mov [rsp+358h+var_A8], rax
mov rax, [rsp+358h+var_38]
mov [rsp+358h+var_B0], rax
lea rdi, [rsp+358h+var_B1]
mov [rsp+358h+var_2D0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rcx, [rsp+358h+var_2D0]
mov rsi, [rsp+358h+var_A8]
mov rdx, [rsp+358h+var_B0]
lea rdi, [rsp+358h+var_A0]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IN9__gnu_cxx17__normal_iteratorIPKcS4_EEvEET_SB_RKS3_; std::string::basic_string<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::allocator<char> const&)
jmp short $+2
loc_FF18F:
lea rdi, [rsp+358h+var_A0]
mov [rsp+358h+var_308], rdi
mov esi, 0Ah
mov rdx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5rfindEcm; std::string::rfind(char,ulong)
mov rdi, [rsp+358h+var_308]; void *
mov rcx, rax
mov rax, [rsp+358h+var_2D8]
sub rax, rcx
mov [rsp+358h+var_300], rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+358h+var_B1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rax, [rsp+358h+var_300]
mov [rsp+358h+var_80], rax
lea rdi, [rsp+358h+var_240]
mov [rsp+358h+var_2F8], rdi
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rdi, [rsp+358h+var_2F8]
lea rsi, aAtRow; " at row "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+358h+var_2F0], rax
jmp short $+2
loc_FF20E:
mov rdi, [rsp+358h+var_2F0]
mov rsi, [rsp+358h+var_40]
call __ZNSolsEl; std::ostream::operator<<(long)
mov [rsp+358h+var_310], rax
jmp short $+2
loc_FF227:
mov rdi, [rsp+358h+var_310]
lea rsi, aColumn; ", column "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rsp+358h+var_318], rax
jmp short $+2
loc_FF23F:
mov rdi, [rsp+358h+var_318]
mov rsi, [rsp+358h+var_80]
call __ZNSolsEm; std::ostream::operator<<(ulong)
mov [rsp+358h+var_320], rax
jmp short $+2
loc_FF258:
mov rdi, [rsp+358h+var_320]
lea rsi, aJsonSchemaConv+1Dh; ":\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_FF26B:
cmp [rsp+358h+var_40], 1
jle loc_FF33F
mov rdx, [rsp+358h+var_40]
dec rdx
lea rdi, [rsp+358h+var_260]
lea rsi, [rsp+358h+var_20]
call _ZZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clB5cxx11Em; minja::error_location_suffix(std::string const&,ulong)::$_0::operator()(ulong)
jmp short $+2
loc_FF29C:
lea rdi, [rsp+358h+var_240]
lea rsi, [rsp+358h+var_260]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+358h+var_328], rax
jmp short $+2
loc_FF2B8:
mov rdi, [rsp+358h+var_328]
lea rsi, aExampleSpecifi+26h; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_FF2CB:
lea rdi, [rsp+358h+var_260]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_FF33F
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
lea rdi, [rsp+arg_29F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_FF566
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
jmp loc_FF559
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
lea rdi, [rsp+arg_F0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_FF559
loc_FF33F:
mov rdx, [rsp+358h+var_40]
lea rdi, [rsp+358h+var_280]
lea rsi, [rsp+358h+var_20]
call _ZZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clB5cxx11Em; minja::error_location_suffix(std::string const&,ulong)::$_0::operator()(ulong)
jmp short $+2
loc_FF35E:
lea rdi, [rsp+358h+var_240]
lea rsi, [rsp+358h+var_280]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+358h+var_330], rax
jmp short $+2
loc_FF37A:
mov rdi, [rsp+358h+var_330]
lea rsi, aExampleSpecifi+26h; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_FF38D:
lea rdi, [rsp+358h+var_280]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rax, [rsp+358h+var_80]
dec rax
mov [rsp+358h+var_340], rax
lea rdi, [rsp+358h+var_2A1]
mov [rsp+358h+var_338], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+358h+var_340]
mov rcx, [rsp+358h+var_338]
lea rdi, [rsp+358h+var_2A0]
mov edx, 20h ; ' '
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEmcRKS3_; std::string::basic_string<std::allocator<char>>(ulong,char,std::allocator<char> const&)
jmp short $+2
loc_FF3DA:
lea rdi, [rsp+358h+var_240]
lea rsi, [rsp+358h+var_2A0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+358h+var_348], rax
jmp short $+2
loc_FF3F6:
mov rdi, [rsp+358h+var_348]
lea rsi, asc_21A827; "^\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_FF409:
lea rdi, [rsp+358h+var_2A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+358h+var_2A1]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rax, [rsp+358h+var_40]
cmp rax, [rsp+358h+var_60]
jge loc_FF52B
mov rdx, [rsp+358h+var_40]
inc rdx
lea rdi, [rsp+358h+var_2C8]
lea rsi, [rsp+358h+var_20]
call _ZZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clB5cxx11Em; minja::error_location_suffix(std::string const&,ulong)::$_0::operator()(ulong)
jmp short $+2
loc_FF45B:
lea rdi, [rsp+358h+var_240]
lea rsi, [rsp+358h+var_2C8]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
mov [rsp+358h+var_350], rax
jmp short $+2
loc_FF477:
mov rdi, [rsp+358h+var_350]
lea rsi, aExampleSpecifi+26h; "\n"
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
jmp short $+2
loc_FF48A:
lea rdi, [rsp+358h+var_2C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_FF52B
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
lea rdi, [rsp+arg_D0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp loc_FF559
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
jmp short loc_FF4F9
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
lea rdi, [rsp+arg_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_FF4F9:
lea rdi, [rsp+arg_AF]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_FF559
mov rcx, rax
mov eax, edx
mov [rsp+arg_290], rcx
mov [rsp+arg_28C], eax
lea rdi, [rsp+arg_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_FF559
loc_FF52B:
mov rdi, [rsp+358h+var_2E8]
lea rsi, [rsp+358h+var_240]
call __ZNKSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEE3strEv; std::ostringstream::str(void)
jmp short $+2
loc_FF53F:
lea rdi, [rsp+358h+var_240]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
mov rax, [rsp+358h+var_2E0]
add rsp, 358h
retn
loc_FF559:
lea rdi, [rsp+arg_110]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
loc_FF566:
mov rdi, [rsp+arg_290]
call __Unwind_Resume
|
long long minja::error_location_suffix(long long a1, long long a2, long long a3)
{
int v3; // ecx
int v4; // r8d
int v5; // r9d
int v6; // ecx
int v7; // r8d
int v8; // r9d
long long v10; // [rsp+8h] [rbp-350h]
long long v11; // [rsp+10h] [rbp-348h]
long long v12; // [rsp+18h] [rbp-340h]
long long v13; // [rsp+28h] [rbp-330h]
long long v14; // [rsp+30h] [rbp-328h]
long long v15; // [rsp+38h] [rbp-320h]
long long v16; // [rsp+40h] [rbp-318h]
long long v17; // [rsp+48h] [rbp-310h]
long long v18; // [rsp+58h] [rbp-300h]
long long v19; // [rsp+68h] [rbp-2F0h]
long long v20; // [rsp+80h] [rbp-2D8h]
_BYTE v21[39]; // [rsp+90h] [rbp-2C8h] BYREF
char v22; // [rsp+B7h] [rbp-2A1h] BYREF
_BYTE v23[32]; // [rsp+B8h] [rbp-2A0h] BYREF
_BYTE v24[32]; // [rsp+D8h] [rbp-280h] BYREF
_BYTE v25[32]; // [rsp+F8h] [rbp-260h] BYREF
_BYTE v26[399]; // [rsp+118h] [rbp-240h] BYREF
char v27; // [rsp+2A7h] [rbp-B1h] BYREF
long long v28; // [rsp+2A8h] [rbp-B0h]
long long v29; // [rsp+2B0h] [rbp-A8h]
_BYTE v30[32]; // [rsp+2B8h] [rbp-A0h] BYREF
long long v31; // [rsp+2D8h] [rbp-80h]
char v32; // [rsp+2E7h] [rbp-71h] BYREF
long long v33; // [rsp+2E8h] [rbp-70h]
long long v34; // [rsp+2F0h] [rbp-68h]
long long v35; // [rsp+2F8h] [rbp-60h]
char v36; // [rsp+307h] [rbp-51h] BYREF
long long v37; // [rsp+308h] [rbp-50h]
long long v38; // [rsp+310h] [rbp-48h]
long long v39; // [rsp+318h] [rbp-40h]
long long v40; // [rsp+320h] [rbp-38h]
long long v41; // [rsp+328h] [rbp-30h]
long long v42; // [rsp+330h] [rbp-28h] BYREF
long long v43; // [rsp+338h] [rbp-20h] BYREF
long long v44; // [rsp+340h] [rbp-18h]
long long v45; // [rsp+348h] [rbp-10h]
long long v46; // [rsp+350h] [rbp-8h]
v46 = a1;
v45 = a2;
v44 = a3;
v43 = a2;
v42 = std::string::begin(a2);
v41 = std::string::end(a2);
v40 = __gnu_cxx::__normal_iterator<char const*,std::string>::operator+(&v42, v44);
v38 = v42;
v37 = v40;
v36 = 10;
v39 = std::count<__gnu_cxx::__normal_iterator<char const*,std::string>,char>(v42, v40, &v36) + 1;
v34 = v42;
v33 = v41;
v32 = 10;
v35 = std::count<__gnu_cxx::__normal_iterator<char const*,std::string>,char>(v42, v41, &v32) + 1;
v20 = v44;
v29 = v42;
v28 = v40;
std::allocator<char>::allocator();
std::string::basic_string<__gnu_cxx::__normal_iterator<char const*,std::string>,void>(
(long long)v30,
v29,
v28,
(long long)&v27);
v18 = v20 - std::string::rfind(v30, 10LL, -1LL);
std::string::~string(v30);
std::allocator<char>::~allocator(&v27);
v31 = v18;
std::ostringstream::basic_ostringstream(v26);
v19 = std::operator<<<std::char_traits<char>>(v26, " at row ");
v17 = std::ostream::operator<<(v19, v39);
v16 = std::operator<<<std::char_traits<char>>(v17, ", column ");
v15 = std::ostream::operator<<(v16, v31);
std::operator<<<std::char_traits<char>>(v15, ":\n");
if ( v39 > 1 )
{
minja::error_location_suffix(std::string const&,unsigned long)::$_0::operator()[abi:cxx11](
(unsigned int)v25,
(unsigned int)&v43,
v39 - 1,
v3,
v4,
v5);
v14 = std::operator<<<char>(v26, v25);
std::operator<<<std::char_traits<char>>(v14, "\n");
std::string::~string(v25);
}
minja::error_location_suffix(std::string const&,unsigned long)::$_0::operator()[abi:cxx11](
(unsigned int)v24,
(unsigned int)&v43,
v39,
v3,
v4,
v5);
v13 = std::operator<<<char>(v26, v24);
std::operator<<<std::char_traits<char>>(v13, "\n");
std::string::~string(v24);
v12 = v31 - 1;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v23, v12, 32, (long long)&v22);
v11 = std::operator<<<char>(v26, v23);
std::operator<<<std::char_traits<char>>(v11, "^\n");
std::string::~string(v23);
std::allocator<char>::~allocator(&v22);
if ( v39 < v35 )
{
minja::error_location_suffix(std::string const&,unsigned long)::$_0::operator()[abi:cxx11](
(unsigned int)v21,
(unsigned int)&v43,
v39 + 1,
v6,
v7,
v8);
v10 = std::operator<<<char>(v26, v21);
std::operator<<<std::char_traits<char>>(v10, "\n");
std::string::~string(v21);
}
std::ostringstream::str(a1, v26);
std::ostringstream::~ostringstream(v26);
return a1;
}
|
error_location_suffix:
SUB RSP,0x358
MOV qword ptr [RSP + 0x70],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x78],RAX
MOV qword ptr [RSP + 0x350],RDI
MOV qword ptr [RSP + 0x348],RSI
MOV qword ptr [RSP + 0x340],RDX
MOV RAX,qword ptr [RSP + 0x348]
MOV qword ptr [RSP + 0x338],RAX
MOV RDI,qword ptr [RSP + 0x348]
CALL 0x0015c400
MOV qword ptr [RSP + 0x330],RAX
MOV RDI,qword ptr [RSP + 0x348]
CALL 0x0015d4b0
MOV qword ptr [RSP + 0x328],RAX
MOV RSI,qword ptr [RSP + 0x340]
LEA RDI,[RSP + 0x330]
CALL 0x00218250
MOV qword ptr [RSP + 0x320],RAX
MOV RAX,qword ptr [RSP + 0x330]
MOV qword ptr [RSP + 0x310],RAX
MOV RAX,qword ptr [RSP + 0x320]
MOV qword ptr [RSP + 0x308],RAX
MOV byte ptr [RSP + 0x307],0xa
MOV RDI,qword ptr [RSP + 0x310]
MOV RSI,qword ptr [RSP + 0x308]
LEA RDX,[RSP + 0x307]
CALL 0x0024f5d0
INC RAX
MOV qword ptr [RSP + 0x318],RAX
MOV RAX,qword ptr [RSP + 0x330]
MOV qword ptr [RSP + 0x2f0],RAX
MOV RAX,qword ptr [RSP + 0x328]
MOV qword ptr [RSP + 0x2e8],RAX
MOV byte ptr [RSP + 0x2e7],0xa
MOV RDI,qword ptr [RSP + 0x2f0]
MOV RSI,qword ptr [RSP + 0x2e8]
LEA RDX,[RSP + 0x2e7]
CALL 0x0024f5d0
INC RAX
MOV qword ptr [RSP + 0x2f8],RAX
MOV RAX,qword ptr [RSP + 0x340]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x330]
MOV qword ptr [RSP + 0x2b0],RAX
MOV RAX,qword ptr [RSP + 0x320]
MOV qword ptr [RSP + 0x2a8],RAX
LEA RDI,[RSP + 0x2a7]
MOV qword ptr [RSP + 0x88],RDI
CALL 0x0015d2b0
MOV RCX,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x2b0]
MOV RDX,qword ptr [RSP + 0x2a8]
LAB_001ff180:
LEA RDI,[RSP + 0x2b8]
CALL 0x001f17b0
LAB_001ff18d:
JMP 0x001ff18f
LAB_001ff18f:
LEA RDI,[RSP + 0x2b8]
MOV qword ptr [RSP + 0x50],RDI
MOV ESI,0xa
MOV RDX,-0x1
CALL 0x0015c850
MOV RDI,qword ptr [RSP + 0x50]
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x80]
SUB RAX,RCX
MOV qword ptr [RSP + 0x58],RAX
CALL 0x0015d858
LEA RDI,[RSP + 0x2a7]
CALL 0x0015d830
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x2d8],RAX
LEA RDI,[RSP + 0x118]
MOV qword ptr [RSP + 0x60],RDI
CALL 0x0015d280
MOV RDI,qword ptr [RSP + 0x60]
LAB_001ff1fb:
LEA RSI,[0x31a81e]
CALL 0x0015cb00
MOV qword ptr [RSP + 0x68],RAX
JMP 0x001ff20e
LAB_001ff20e:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x318]
CALL 0x0015c720
MOV qword ptr [RSP + 0x48],RAX
JMP 0x001ff227
LAB_001ff227:
MOV RDI,qword ptr [RSP + 0x48]
LEA RSI,[0x316a0f]
CALL 0x0015cb00
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001ff23f
LAB_001ff23f:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x2d8]
CALL 0x0015d480
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001ff258
LAB_001ff258:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[0x31e62e]
CALL 0x0015cb00
JMP 0x001ff26b
LAB_001ff26b:
CMP qword ptr [RSP + 0x318],0x1
JLE 0x001ff33f
MOV RDX,qword ptr [RSP + 0x318]
DEC RDX
LEA RDI,[RSP + 0xf8]
LEA RSI,[RSP + 0x338]
CALL 0x001ff660
JMP 0x001ff29c
LAB_001ff29c:
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0xf8]
CALL 0x0015c5c0
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001ff2b8
LAB_001ff2b8:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x31573e]
CALL 0x0015cb00
JMP 0x001ff2cb
LAB_001ff2cb:
LEA RDI,[RSP + 0xf8]
CALL 0x0015d858
JMP 0x001ff33f
LAB_001ff33f:
MOV RDX,qword ptr [RSP + 0x318]
LAB_001ff347:
LEA RDI,[RSP + 0xd8]
LEA RSI,[RSP + 0x338]
CALL 0x001ff660
JMP 0x001ff35e
LAB_001ff35e:
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0xd8]
CALL 0x0015c5c0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001ff37a
LAB_001ff37a:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x31573e]
CALL 0x0015cb00
JMP 0x001ff38d
LAB_001ff38d:
LEA RDI,[RSP + 0xd8]
CALL 0x0015d858
MOV RAX,qword ptr [RSP + 0x2d8]
DEC RAX
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0xb7]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x0015d2b0
MOV RSI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
LAB_001ff3c6:
LEA RDI,[RSP + 0xb8]
MOV EDX,0x20
CALL 0x0016f8e0
JMP 0x001ff3da
LAB_001ff3da:
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0xb8]
CALL 0x0015c5c0
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001ff3f6
LAB_001ff3f6:
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[0x31a827]
CALL 0x0015cb00
JMP 0x001ff409
LAB_001ff409:
LEA RDI,[RSP + 0xb8]
CALL 0x0015d858
LEA RDI,[RSP + 0xb7]
CALL 0x0015d830
MOV RAX,qword ptr [RSP + 0x318]
CMP RAX,qword ptr [RSP + 0x2f8]
JGE 0x001ff52b
MOV RDX,qword ptr [RSP + 0x318]
INC RDX
LAB_001ff444:
LEA RDI,[RSP + 0x90]
LEA RSI,[RSP + 0x338]
CALL 0x001ff660
JMP 0x001ff45b
LAB_001ff45b:
LEA RDI,[RSP + 0x118]
LEA RSI,[RSP + 0x90]
CALL 0x0015c5c0
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001ff477
LAB_001ff477:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x31573e]
CALL 0x0015cb00
JMP 0x001ff48a
LAB_001ff48a:
LEA RDI,[RSP + 0x90]
CALL 0x0015d858
JMP 0x001ff52b
LAB_001ff52b:
MOV RDI,qword ptr [RSP + 0x70]
LEA RSI,[RSP + 0x118]
CALL 0x0015d6f0
LAB_001ff53d:
JMP 0x001ff53f
LAB_001ff53f:
LEA RDI,[RSP + 0x118]
CALL 0x0015d170
MOV RAX,qword ptr [RSP + 0x78]
ADD RSP,0x358
RET
|
/* minja::error_location_suffix(std::__cxx11::string const&, unsigned long) */
minja * __thiscall minja::error_location_suffix(minja *this,string *param_1,ulong param_2)
{
long lVar1;
ostream *poVar2;
ulong uVar3;
string local_2c8 [39];
allocator local_2a1;
string local_2a0 [32];
string local_280 [32];
string local_260 [32];
ostringstream local_240 [399];
allocator<char> local_b1;
int8 local_b0;
int8 local_a8;
string local_a0 [32];
ulong local_80;
int1 local_71;
int8 local_70;
int8 local_68;
long local_60;
int1 local_51;
int8 local_50;
int8 local_48;
long local_40;
int8 local_38;
int8 local_30;
int8 local_28;
string *local_20;
ulong local_18;
string *local_10;
minja *local_8;
local_20 = param_1;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
local_28 = std::__cxx11::string::begin();
local_30 = std::__cxx11::string::end();
local_50 = __gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>::operator+
((__normal_iterator<char_const*,std::__cxx11::string> *)&local_28,local_18);
local_48 = local_28;
local_51 = 10;
local_38 = local_50;
local_40 = std::count<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,char>
(local_28,local_50,&local_51);
local_40 = local_40 + 1;
local_68 = local_28;
local_70 = local_30;
local_71 = 10;
local_60 = std::count<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,char>
(local_28,local_30,&local_71);
uVar3 = local_18;
local_60 = local_60 + 1;
local_a8 = local_28;
local_b0 = local_38;
std::allocator<char>::allocator();
/* try { // try from 001ff180 to 001ff18c has its CatchHandler @ 001ff2da */
std::__cxx11::string::string<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,void>
(local_a0,local_a8,local_b0,&local_b1);
lVar1 = std::__cxx11::string::rfind((char)local_a0,10);
std::__cxx11::string::~string(local_a0);
std::allocator<char>::~allocator(&local_b1);
local_80 = uVar3 - lVar1;
std::__cxx11::ostringstream::ostringstream(local_240);
/* try { // try from 001ff1fb to 001ff299 has its CatchHandler @ 001ff300 */
poVar2 = std::operator<<((ostream *)local_240," at row ");
poVar2 = (ostream *)std::ostream::operator<<(poVar2,local_40);
poVar2 = std::operator<<(poVar2,", column ");
poVar2 = (ostream *)std::ostream::operator<<(poVar2,local_80);
std::operator<<(poVar2,":\n");
if (1 < local_40) {
error_location_suffix(std::__cxx11::string_const&,unsigned_long)::$_0::operator()[abi_cxx11_
((ulong)local_260);
/* try { // try from 001ff29c to 001ff2c8 has its CatchHandler @ 001ff319 */
poVar2 = std::operator<<((ostream *)local_240,local_260);
std::operator<<(poVar2,"\n");
std::__cxx11::string::~string(local_260);
}
/* try { // try from 001ff347 to 001ff35b has its CatchHandler @ 001ff300 */
error_location_suffix(std::__cxx11::string_const&,unsigned_long)::$_0::operator()[abi_cxx11_
((ulong)local_280);
/* try { // try from 001ff35e to 001ff38a has its CatchHandler @ 001ff49c */
poVar2 = std::operator<<((ostream *)local_240,local_280);
std::operator<<(poVar2,"\n");
std::__cxx11::string::~string(local_280);
uVar3 = local_80 - 1;
std::allocator<char>::allocator();
/* try { // try from 001ff3c6 to 001ff3d7 has its CatchHandler @ 001ff4c2 */
std::__cxx11::string::string<std::allocator<char>>(local_2a0,uVar3,' ',&local_2a1);
/* try { // try from 001ff3da to 001ff406 has its CatchHandler @ 001ff4d8 */
poVar2 = std::operator<<((ostream *)local_240,local_2a0);
std::operator<<(poVar2,"^\n");
std::__cxx11::string::~string(local_2a0);
std::allocator<char>::~allocator((allocator<char> *)&local_2a1);
if (local_40 < local_60) {
/* try { // try from 001ff444 to 001ff458 has its CatchHandler @ 001ff300 */
error_location_suffix(std::__cxx11::string_const&,unsigned_long)::$_0::operator()[abi_cxx11_
((ulong)local_2c8);
/* try { // try from 001ff45b to 001ff487 has its CatchHandler @ 001ff508 */
poVar2 = std::operator<<((ostream *)local_240,local_2c8);
std::operator<<(poVar2,"\n");
std::__cxx11::string::~string(local_2c8);
}
/* try { // try from 001ff52b to 001ff53c has its CatchHandler @ 001ff300 */
std::__cxx11::ostringstream::str();
std::__cxx11::ostringstream::~ostringstream(local_240);
return this;
}
|
|
60,037
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
monkey531[P]llama/common/minja.hpp
|
static std::string error_location_suffix(const std::string & source, size_t pos) {
auto get_line = [&](size_t line) {
auto start = source.begin();
for (size_t i = 1; i < line; ++i) {
start = std::find(start, source.end(), '\n') + 1;
}
auto end = std::find(start, source.end(), '\n');
return std::string(start, end);
};
auto start = source.begin();
auto end = source.end();
auto it = start + pos;
auto line = std::count(start, it, '\n') + 1;
auto max_line = std::count(start, end, '\n') + 1;
auto col = pos - std::string(start, it).rfind('\n');
std::ostringstream out;
out << " at row " << line << ", column " << col << ":\n";
if (line > 1) out << get_line(line - 1) << "\n";
out << get_line(line) << "\n";
out << std::string(col - 1, ' ') << "^\n";
if (line < max_line) out << get_line(line + 1) << "\n";
return out.str();
}
|
O2
|
cpp
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %r14
pushq $0x1
popq %rbp
leaq 0x6(%rsp), %r13
movq (%r12), %rax
movq (%rax), %rsi
addq 0x8(%rax), %rsi
cmpq %r15, %rbp
jae 0xa2ddf
movb $0xa, 0x6(%rsp)
movq %r14, %rdi
movq %r13, %rdx
callq 0x75664
movq %rax, %r14
incq %r14
incq %rbp
jmp 0xa2db4
leaq 0x7(%rsp), %rdx
movb $0xa, (%rdx)
movq %r14, %rdi
callq 0x75664
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x55cf4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clB5cxx11Em_0:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rax, [rsi]
mov r14, [rax]
push 1
pop rbp
lea r13, [rsp+38h+var_32]
loc_A2DB4:
mov rax, [r12]
mov rsi, [rax]
add rsi, [rax+8]
cmp rbp, r15
jnb short loc_A2DDF
mov [rsp+38h+var_32], 0Ah
mov rdi, r14
mov rdx, r13
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
mov r14, rax
inc r14
inc rbp
jmp short loc_A2DB4
loc_A2DDF:
lea rdx, [rsp+38h+var_31]
mov byte ptr [rdx], 0Ah
mov rdi, r14
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
lea rcx, [rbx+10h]
mov [rbx], rcx
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * minja::error_location_suffix(std::string const&,unsigned long)::$_0::operator()[abi:cxx11](
_QWORD *a1,
_BYTE ***a2,
unsigned long long a3)
{
long long v3; // rax
_BYTE *v6; // r14
unsigned long long i; // rbp
long long v8; // rsi
_BYTE *v9; // rax
_WORD v11[25]; // [rsp+0h] [rbp-32h] BYREF
v11[0] = HIWORD(v3);
v6 = **a2;
for ( i = 1LL; ; ++i )
{
v8 = (long long)&(**a2)[(_QWORD)(*a2)[1]];
if ( i >= a3 )
break;
LOBYTE(v11[0]) = 10;
v6 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
(long long)v6,
v8,
(char *)v11)
+ 1;
}
HIBYTE(v11[0]) = 10;
v9 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
(long long)v6,
v8,
(char *)v11 + 1);
*a1 = a1 + 2;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)a1, v6, (long long)v9);
return a1;
}
|
operator()[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RAX]
PUSH 0x1
POP RBP
LEA R13,[RSP + 0x6]
LAB_001a2db4:
MOV RAX,qword ptr [R12]
MOV RSI,qword ptr [RAX]
ADD RSI,qword ptr [RAX + 0x8]
CMP RBP,R15
JNC 0x001a2ddf
MOV byte ptr [RSP + 0x6],0xa
MOV RDI,R14
MOV RDX,R13
CALL 0x00175664
MOV R14,RAX
INC R14
INC RBP
JMP 0x001a2db4
LAB_001a2ddf:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0xa
MOV RDI,R14
CALL 0x00175664
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x00155cf4
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* operator()[abi:cxx11](unsigned long) const */
ulong minja::error_location_suffix(std::__cxx11::string_const&,unsigned_long)::$_0::
operator()[abi_cxx11_(ulong param_1)
{
int8 in_RAX;
long lVar1;
int8 uVar2;
ulong in_RDX;
ulong uVar3;
long *in_RSI;
long lVar4;
int8 uStack_38;
lVar1 = *(long *)*in_RSI;
uStack_38 = in_RAX;
for (uVar3 = 1; lVar4 = *(long *)*in_RSI + ((long *)*in_RSI)[1], uVar3 < in_RDX; uVar3 = uVar3 + 1
) {
uStack_38._0_7_ = CONCAT16(10,(int6)uStack_38);
lVar1 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar1,lVar4,(long)&uStack_38 + 6);
lVar1 = lVar1 + 1;
}
uStack_38 = CONCAT17(10,(int7)uStack_38);
uVar2 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar1,lVar4);
*(ulong *)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar1,uVar2);
return param_1;
}
|
|
60,038
|
cli::matchable::matchable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
msxemulator/build_O0/_deps/picotool-src/cli.h
|
explicit matchable(string name) : _name(std::move(name)) {}
|
O0
|
c
|
cli::matchable::matchable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x16485c(%rip), %rax # 0x1dd8e0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
leaq 0x57(%rsp), %rsi
callq 0x759b0
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x75a40
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x18(%rsp)
callq 0xf380
movq 0x28(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, 0x20(%rsp)
callq 0xf7f0
movq 0x28(%rsp), %rax
movl $0x1, 0x88(%rax)
movl $0x1, 0x8c(%rax)
movb $0x0, 0x90(%rax)
movb $0x0, 0x91(%rax)
addq $0x98, %rax
movq %rax, 0x30(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xf9f0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
leaq 0x104bdc(%rip), %rsi # 0x17dd05
callq 0xf7c0
jmp 0x79130
leaq 0x56(%rsp), %rdi
callq 0xf630
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0xf630
movq 0x20(%rsp), %rdi
callq 0xfb10
movq 0x18(%rsp), %rdi
callq 0xfb10
movq 0x8(%rsp), %rdi
callq 0x59280
movq (%rsp), %rdi
callq 0x75a80
movq 0x48(%rsp), %rdi
callq 0xf9e0
nopl (%rax,%rax)
|
_ZN3cli9matchableC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 68h
mov [rsp+68h+var_58], rsi
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
mov rdi, [rsp+68h+var_8]
mov [rsp+68h+var_40], rdi
lea rax, off_1DD8E0
mov [rdi], rax
add rdi, 8
mov [rsp+68h+var_68], rdi
lea rsi, [rsp+68h+var_11]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EEC2IN3cli9matchable6actionMUlRKS5_E_EvEEOT_
mov rdi, [rsp+68h+var_40]
add rdi, 28h ; '('
mov [rsp+68h+var_60], rdi
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEEC2Ev; std::function<std::string ()(void)>::function(void)
mov rsi, [rsp+68h+var_58]
mov rdi, [rsp+68h+var_40]
add rdi, 48h ; 'H'
mov [rsp+68h+var_50], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EOS4_; std::string::basic_string(std::string&&)
mov rdi, [rsp+68h+var_40]
add rdi, 68h ; 'h'
mov [rsp+68h+var_48], rdi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov rax, [rsp+68h+var_40]
mov dword ptr [rax+88h], 1
mov dword ptr [rax+8Ch], 1
mov byte ptr [rax+90h], 0
mov byte ptr [rax+91h], 0
add rax, 98h
mov [rsp+68h+var_38], rax
lea rdi, [rsp+68h+var_12]
mov [rsp+68h+var_30], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+68h+var_38]
mov rdx, [rsp+68h+var_30]
lea rsi, unk_17DD05
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_; std::string::basic_string(char const*,std::allocator<char> const&)
jmp short $+2
loc_79130:
lea rdi, [rsp+68h+var_12]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
add rsp, 68h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_40], rcx
mov [rsp+arg_3C], eax
lea rdi, [rsp+arg_4E]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+arg_10]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov rdi, [rsp+arg_0]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEvEED2Ev; std::function<std::string ()(void)>::~function()
mov rdi, [rsp+0]
call _ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EED2Ev; std::function<std::string ()(std::string)>::~function()
mov rdi, [rsp+arg_40]
call __Unwind_Resume
|
long long cli::matchable::matchable(long long a1, long long a2)
{
char v3; // [rsp+56h] [rbp-12h] BYREF
char v4; // [rsp+57h] [rbp-11h] BYREF
long long v5; // [rsp+58h] [rbp-10h]
long long v6; // [rsp+60h] [rbp-8h]
v6 = a1;
v5 = a2;
*(_QWORD *)a1 = off_1DD8E0;
ZNSt8functionIFNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EEC2IN3cli9matchable6actionMUlRKS5_E_EvEEOT_(
(std::_Function_base *)(a1 + 8),
(long long)&v4);
std::function<std::string ()(void)>::function((std::_Function_base *)(a1 + 40));
std::string::basic_string(a1 + 72, a2);
std::string::basic_string(a1 + 104);
*(_DWORD *)(a1 + 136) = 1;
*(_DWORD *)(a1 + 140) = 1;
*(_BYTE *)(a1 + 144) = 0;
*(_BYTE *)(a1 + 145) = 0;
std::allocator<char>::allocator(&v3, a2);
std::string::basic_string(a1 + 152, &unk_17DD05, &v3);
return std::allocator<char>::~allocator(&v3);
}
|
matchable:
SUB RSP,0x68
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RDI
LEA RAX,[0x2dd8e0]
MOV qword ptr [RDI],RAX
ADD RDI,0x8
MOV qword ptr [RSP],RDI
LEA RSI,[RSP + 0x57]
CALL 0x001759b0
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x28
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00175a40
MOV RSI,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x48
MOV qword ptr [RSP + 0x18],RDI
CALL 0x0010f380
MOV RDI,qword ptr [RSP + 0x28]
ADD RDI,0x68
MOV qword ptr [RSP + 0x20],RDI
CALL 0x0010f7f0
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RAX + 0x88],0x1
MOV dword ptr [RAX + 0x8c],0x1
MOV byte ptr [RAX + 0x90],0x0
MOV byte ptr [RAX + 0x91],0x0
ADD RAX,0x98
MOV qword ptr [RSP + 0x30],RAX
LEA RDI,[RSP + 0x56]
MOV qword ptr [RSP + 0x38],RDI
CALL 0x0010f9f0
MOV RDI,qword ptr [RSP + 0x30]
MOV RDX,qword ptr [RSP + 0x38]
LAB_00179122:
LEA RSI,[0x27dd05]
CALL 0x0010f7c0
LAB_0017912e:
JMP 0x00179130
LAB_00179130:
LEA RDI,[RSP + 0x56]
CALL 0x0010f630
ADD RSP,0x68
RET
|
/* cli::matchable::matchable(std::__cxx11::string) */
void __thiscall cli::matchable::matchable(matchable *this,string *param_2)
{
allocator local_12;
_lambda_std____cxx11__string_const___1_ local_11;
string *local_10;
matchable *local_8;
*(int ***)this = &PTR__matchable_002dd8e0;
local_10 = param_2;
local_8 = this;
std::function<std::__cxx11::string(std::__cxx11::string)>::
function<cli::matchable::action::_lambda(std::__cxx11::string_const&)_1_,void>
((function<std::__cxx11::string(std::__cxx11::string)> *)(this + 8),&local_11);
std::function<std::__cxx11::string()>::function((function<std::__cxx11::string()> *)(this + 0x28))
;
std::__cxx11::string::string((string *)(this + 0x48),param_2);
std::__cxx11::string::string((string *)(this + 0x68));
*(int4 *)(this + 0x88) = 1;
*(int4 *)(this + 0x8c) = 1;
this[0x90] = (matchable)0x0;
this[0x91] = (matchable)0x0;
std::allocator<char>::allocator();
/* try { // try from 00179122 to 0017912d has its CatchHandler @ 0017913f */
std::__cxx11::string::string((string *)(this + 0x98),"",&local_12);
std::allocator<char>::~allocator((allocator<char> *)&local_12);
return;
}
|
|
60,039
|
get_binlog_end_pos(binlog_send_info*, st_io_cache*, st_log_info*)
|
eloqsql/sql/sql_repl.cc
|
static my_off_t get_binlog_end_pos(binlog_send_info *info,
IO_CACHE* log,
LOG_INFO* linfo)
{
my_off_t log_pos= my_b_tell(log);
/**
* get current binlog end pos
*/
mysql_bin_log.lock_binlog_end_pos();
char binlog_end_pos_filename[FN_REFLEN];
my_off_t end_pos= mysql_bin_log.get_binlog_end_pos(binlog_end_pos_filename);
mysql_bin_log.unlock_binlog_end_pos();
do
{
if (strcmp(binlog_end_pos_filename, linfo->log_file_name) != 0)
{
/**
* this file is not active, since it's not written to again,
* it safe to check file length and use that as end_pos
*/
end_pos= my_b_filelength(log);
if (log_pos == end_pos)
return 0; // already at end of file inactive file
else
return end_pos; // return size of inactive file
}
else
{
/**
* this is the active file
*/
if (log_pos < end_pos)
{
/**
* there is data available to read
*/
return end_pos;
}
/**
* check if we should wait for more data
*/
if ((info->flags & BINLOG_DUMP_NON_BLOCK) ||
(info->thd->variables.server_id == 0))
{
info->should_stop= true;
return 0;
}
/**
* flush data before waiting
*/
if (net_flush(info->net))
{
info->errmsg= "failed on net_flush()";
info->error= ER_UNKNOWN_ERROR;
return 1;
}
if (wait_new_events(info, linfo, binlog_end_pos_filename, &end_pos))
return 1;
}
} while (!should_stop(info));
return 0;
}
|
O0
|
cpp
|
get_binlog_end_pos(binlog_send_info*, st_io_cache*, st_log_info*):
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp # imm = 0x250
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
movq %rdx, -0x230(%rbp)
movq -0x228(%rbp), %rdi
callq 0x92ccd0
movq %rax, -0x238(%rbp)
leaq 0x13cf741(%rip), %rdi # 0x1cff238
callq 0x9329a0
leaq -0x210(%rbp), %rsi
leaq 0x13cf72e(%rip), %rdi # 0x1cff238
callq 0x9329d0
movq %rax, -0x240(%rbp)
leaq 0x13cf71b(%rip), %rdi # 0x1cff238
callq 0x932a20
leaq -0x210(%rbp), %rdi
movq -0x230(%rbp), %rsi
callq 0x759f50
cmpl $0x0, %eax
je 0x92fb80
movq -0x228(%rbp), %rdi
callq 0x12afdf0
movq %rax, -0x240(%rbp)
movq -0x238(%rbp), %rax
cmpq -0x240(%rbp), %rax
jne 0x92fb6d
movq $0x0, -0x218(%rbp)
jmp 0x92fc93
movq -0x240(%rbp), %rax
movq %rax, -0x218(%rbp)
jmp 0x92fc93
movq -0x238(%rbp), %rax
cmpq -0x240(%rbp), %rax
jae 0x92fba3
movq -0x240(%rbp), %rax
movq %rax, -0x218(%rbp)
jmp 0x92fc93
movq -0x220(%rbp), %rax
movzwl 0x254(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x92fbd1
movq -0x220(%rbp), %rax
movq 0x180(%rax), %rax
cmpq $0x0, 0xaf8(%rax)
jne 0x92fbef
movq -0x220(%rbp), %rax
movb $0x1, 0x899(%rax)
movq $0x0, -0x218(%rbp)
jmp 0x92fc93
movq -0x220(%rbp), %rax
movq 0x188(%rax), %rdi
callq 0xd765f0
cmpb $0x0, %al
je 0x92fc39
movq -0x220(%rbp), %rax
leaq 0xa68501(%rip), %rcx # 0x1398115
movq %rcx, 0x268(%rax)
movq -0x220(%rbp), %rax
movl $0x451, 0x260(%rax) # imm = 0x451
movq $0x1, -0x218(%rbp)
jmp 0x92fc93
movq -0x220(%rbp), %rdi
movq -0x230(%rbp), %rsi
leaq -0x210(%rbp), %rdx
leaq -0x240(%rbp), %rcx
callq 0x9301f0
cmpl $0x0, %eax
je 0x92fc6c
movq $0x1, -0x218(%rbp)
jmp 0x92fc93
jmp 0x92fc6e
jmp 0x92fc70
movq -0x220(%rbp), %rdi
xorl %esi, %esi
callq 0x928f40
xorb $-0x1, %al
testb $0x1, %al
jne 0x92fb22
movq $0x0, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x248(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x92fcc3
movq -0x248(%rbp), %rax
addq $0x250, %rsp # imm = 0x250
popq %rbp
retq
callq 0x758480
nopl (%rax,%rax)
|
_ZL18get_binlog_end_posP16binlog_send_infoP11st_io_cacheP11st_log_info:
push rbp
mov rbp, rsp
sub rsp, 250h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
mov [rbp+var_230], rdx
mov rdi, [rbp+var_228]
call _ZL9my_b_tellPK11st_io_cache_1; my_b_tell(st_io_cache const*)
mov [rbp+var_238], rax
lea rdi, mysql_bin_log; this
call _ZN13MYSQL_BIN_LOG19lock_binlog_end_posEv; MYSQL_BIN_LOG::lock_binlog_end_pos(void)
lea rsi, [rbp+var_210]; char *
lea rdi, mysql_bin_log; this
call _ZNK13MYSQL_BIN_LOG18get_binlog_end_posEPc; MYSQL_BIN_LOG::get_binlog_end_pos(char *)
mov [rbp+var_240], rax
lea rdi, mysql_bin_log; this
call _ZN13MYSQL_BIN_LOG21unlock_binlog_end_posEv; MYSQL_BIN_LOG::unlock_binlog_end_pos(void)
loc_92FB22:
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_230]
call _strcmp
cmp eax, 0
jz short loc_92FB80
mov rdi, [rbp+var_228]
call my_b_filelength
mov [rbp+var_240], rax
mov rax, [rbp+var_238]
cmp rax, [rbp+var_240]
jnz short loc_92FB6D
mov [rbp+var_218], 0
jmp loc_92FC93
loc_92FB6D:
mov rax, [rbp+var_240]
mov [rbp+var_218], rax
jmp loc_92FC93
loc_92FB80:
mov rax, [rbp+var_238]
cmp rax, [rbp+var_240]
jnb short loc_92FBA3
mov rax, [rbp+var_240]
mov [rbp+var_218], rax
jmp loc_92FC93
loc_92FBA3:
mov rax, [rbp+var_220]
movzx eax, word ptr [rax+254h]
and eax, 1
cmp eax, 0
jnz short loc_92FBD1
mov rax, [rbp+var_220]
mov rax, [rax+180h]
cmp qword ptr [rax+0AF8h], 0
jnz short loc_92FBEF
loc_92FBD1:
mov rax, [rbp+var_220]
mov byte ptr [rax+899h], 1
mov [rbp+var_218], 0
jmp loc_92FC93
loc_92FBEF:
mov rax, [rbp+var_220]
mov rdi, [rax+188h]
call net_flush
cmp al, 0
jz short loc_92FC39
mov rax, [rbp+var_220]
lea rcx, aFailedOnNetFlu; "failed on net_flush()"
mov [rax+268h], rcx
mov rax, [rbp+var_220]
mov dword ptr [rax+260h], 451h
mov [rbp+var_218], 1
jmp short loc_92FC93
loc_92FC39:
mov rdi, [rbp+var_220]; binlog_send_info *
mov rsi, [rbp+var_230]; st_log_info *
lea rdx, [rbp+var_210]; char *
lea rcx, [rbp+var_240]; unsigned __int64 *
call _ZL15wait_new_eventsP16binlog_send_infoP11st_log_infoPcPy; wait_new_events(binlog_send_info *,st_log_info *,char *,ulong long *)
cmp eax, 0
jz short loc_92FC6C
mov [rbp+var_218], 1
jmp short loc_92FC93
loc_92FC6C:
jmp short $+2
loc_92FC6E:
jmp short $+2
loc_92FC70:
mov rdi, [rbp+var_220]
xor esi, esi
call _ZL11should_stopP16binlog_send_infob; should_stop(binlog_send_info *,bool)
xor al, 0FFh
test al, 1
jnz loc_92FB22
mov [rbp+var_218], 0
loc_92FC93:
mov rax, [rbp+var_218]
mov [rbp+var_248], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_92FCC3
mov rax, [rbp+var_248]
add rsp, 250h
pop rbp
retn
loc_92FCC3:
call ___stack_chk_fail
|
unsigned long long get_binlog_end_pos(binlog_send_info *a1, long long a2, st_log_info *a3)
{
unsigned long long binlog_end_pos; // [rsp+10h] [rbp-240h] BYREF
unsigned long long v5; // [rsp+18h] [rbp-238h]
st_log_info *v6; // [rsp+20h] [rbp-230h]
long long v7; // [rsp+28h] [rbp-228h]
binlog_send_info *v8; // [rsp+30h] [rbp-220h]
char v10[520]; // [rsp+40h] [rbp-210h] BYREF
unsigned long long v11; // [rsp+248h] [rbp-8h]
v11 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
v6 = a3;
v5 = my_b_tell(a2);
MYSQL_BIN_LOG::lock_binlog_end_pos((MYSQL_BIN_LOG *)&mysql_bin_log);
binlog_end_pos = MYSQL_BIN_LOG::get_binlog_end_pos((MYSQL_BIN_LOG *)&mysql_bin_log, v10);
MYSQL_BIN_LOG::unlock_binlog_end_pos((MYSQL_BIN_LOG *)&mysql_bin_log);
while ( !(unsigned int)strcmp(v10, v6) )
{
if ( v5 < binlog_end_pos )
return binlog_end_pos;
if ( (*((_WORD *)v8 + 298) & 1) != 0 || !*(_QWORD *)(*((_QWORD *)v8 + 48) + 2808LL) )
{
*((_BYTE *)v8 + 2201) = 1;
return 0LL;
}
if ( (unsigned __int8)net_flush(*((_QWORD *)v8 + 49)) )
{
*((_QWORD *)v8 + 77) = "failed on net_flush()";
*((_DWORD *)v8 + 152) = 1105;
return 1LL;
}
if ( (unsigned int)wait_new_events(v8, v6, v10, &binlog_end_pos) )
return 1LL;
if ( (should_stop(v8, 0) & 1) != 0 )
return 0LL;
}
binlog_end_pos = my_b_filelength(v7);
if ( v5 == binlog_end_pos )
return 0LL;
else
return binlog_end_pos;
}
|
charset:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
POP RBP
RET
|
/* Load_data_param::charset() const */
int8 __thiscall Load_data_param::charset(Load_data_param *this)
{
return *(int8 *)this;
}
|
|
60,040
|
ma_alloc_dynamic
|
eloqsql/libmariadb/libmariadb/ma_array.c
|
unsigned char *ma_alloc_dynamic(DYNAMIC_ARRAY *array)
{
if (array->elements == array->max_element)
{
char *new_ptr;
if (!(new_ptr=(char*) realloc(array->buffer,(array->max_element+
array->alloc_increment)*
array->size_of_element)))
return 0;
array->buffer=new_ptr;
array->max_element+=array->alloc_increment;
}
return (unsigned char *)array->buffer+(array->elements++ * array->size_of_element);
}
|
O0
|
c
|
ma_alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x42d02
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13700
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x42ce6
movq $0x0, -0x8(%rbp)
jmp 0x42d29
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_alloc_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz short loc_42D02
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
call _realloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_42CE6
mov [rbp+var_8], 0
jmp short loc_42D29
loc_42CE6:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+0Ch]
mov [rax+0Ch], ecx
loc_42D02:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_42D29:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long ma_alloc_dynamic(long long *a1)
{
long long v1; // rax
int v2; // ecx
long long v4; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)a1 + 2) != *((_DWORD *)a1 + 3) )
goto LABEL_5;
v4 = realloc(*a1, (unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))));
if ( v4 )
{
*a1 = v4;
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
LABEL_5:
v1 = *a1;
v2 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 2) = v2 + 1;
return (unsigned int)(*((_DWORD *)a1 + 5) * v2) + v1;
}
return 0LL;
}
|
ma_alloc_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x00142d02
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
CALL 0x00113700
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00142ce6
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00142d29
LAB_00142ce6:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
LAB_00142d02:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x8],ESI
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_00142d29:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long ma_alloc_dynamic(long *param_1)
{
long lVar1;
void *pvVar2;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
pvVar2 = realloc((void *)*param_1,
(ulong)(uint)((*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14)));
if (pvVar2 == (void *)0x0) {
return 0;
}
*param_1 = (long)pvVar2;
*(int *)((long)param_1 + 0xc) = (int)param_1[2] + *(int *)((long)param_1 + 0xc);
}
lVar1 = param_1[1];
*(int *)(param_1 + 1) = (int)lVar1 + 1;
return *param_1 + (ulong)(uint)((int)lVar1 * *(int *)((long)param_1 + 0x14));
}
|
|
60,041
|
spdlog::details::a_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h
|
void format(const details::log_msg &, const std::tm &tm_time, memory_buf_t &dest) override {
string_view_t field_value{days[static_cast<size_t>(tm_time.tm_wday)]};
ScopedPadder p(field_value.size(), padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
}
|
O0
|
c
|
spdlog::details::a_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movslq 0x18(%rax), %rsi
leaq 0x110f06(%rip), %rdi # 0x178788
callq 0x558f0
movq (%rax), %rax
leaq 0x28(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
movq 0x58(%rsp), %rdi
callq 0x14280
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x28(%rsp), %rdi
callq 0x244a0
movq 0x8(%rsp), %rdx
movq %rax, %rsi
addq $0x8, %rdx
movq 0x38(%rsp), %rcx
leaq 0x27(%rsp), %rdi
callq 0x4c850
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3b4e0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN6spdlog7details11a_formatterINS0_18null_scoped_padderEE6formatERKNS0_7log_msgERK2tmRN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE:
sub rsp, 68h
mov [rsp+68h+var_18], rdi
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_28], rdx
mov [rsp+68h+var_30], rcx
mov rax, [rsp+68h+var_18]
mov [rsp+68h+var_60], rax
mov rax, [rsp+68h+var_28]
movsxd rsi, dword ptr [rax+18h]
lea rdi, _ZN6spdlog7detailsL4daysE; spdlog::details::days
call _ZNSt5arrayIPKcLm7EEixEm; std::array<char const*,7ul>::operator[](ulong)
mov rax, [rax]
lea rcx, [rsp+68h+var_40]
mov [rsp+68h+var_8], rcx
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_68], rax
mov rcx, [rsp+68h+var_10]
mov [rax], rcx
mov rdi, [rsp+68h+var_10]
call _strlen
mov rcx, rax
mov rax, [rsp+68h+var_68]
mov [rax+8], rcx
lea rdi, [rsp+68h+var_40]
call _ZNK3fmt3v1017basic_string_viewIcE4sizeEv; fmt::v10::basic_string_view<char>::size(void)
mov rdx, [rsp+68h+var_60]
mov rsi, rax
add rdx, 8
mov rcx, [rsp+68h+var_30]
lea rdi, [rsp+68h+var_41]
call _ZN6spdlog7details18null_scoped_padderC2EmRKNS0_12padding_infoERN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::null_scoped_padder::null_scoped_padder(ulong,spdlog::details::padding_info const&,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
mov rax, [rsp+68h+var_40]
mov [rsp+68h+var_58], rax
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_50], rax
mov rdx, [rsp+68h+var_30]
mov rdi, [rsp+68h+var_58]
mov rsi, [rsp+68h+var_50]
call _ZN6spdlog7details10fmt_helper18append_string_viewEN3fmt3v1017basic_string_viewIcEERNS3_19basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::fmt_helper::append_string_view(fmt::v10::basic_string_view<char>,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
add rsp, 68h
retn
|
long long spdlog::details::a_formatter<spdlog::details::null_scoped_padder>::format(
long long a1,
long long a2,
long long a3,
_QWORD *a4)
{
long long v4; // rax
long long v6; // [rsp+28h] [rbp-40h] BYREF
long long v7; // [rsp+30h] [rbp-38h]
_QWORD *v8; // [rsp+38h] [rbp-30h]
long long v9; // [rsp+40h] [rbp-28h]
long long v10; // [rsp+48h] [rbp-20h]
long long v11; // [rsp+50h] [rbp-18h]
long long v12; // [rsp+58h] [rbp-10h]
long long *v13; // [rsp+60h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
v4 = *(_QWORD *)std::array<char const*,7ul>::operator[]((long long)spdlog::details::days, *(int *)(a3 + 24));
v13 = &v6;
v12 = v4;
v6 = v4;
v7 = strlen(v4);
fmt::v10::basic_string_view<char>::size((long long)&v6);
spdlog::details::null_scoped_padder::null_scoped_padder();
return spdlog::details::fmt_helper::append_string_view(v6, v7, v8);
}
|
format:
SUB RSP,0x68
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x38],RCX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOVSXD RSI,dword ptr [RAX + 0x18]
LEA RDI,[0x278788]
CALL 0x001558f0
MOV RAX,qword ptr [RAX]
LEA RCX,[RSP + 0x28]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP],RAX
MOV RCX,qword ptr [RSP + 0x58]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00114280
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
MOV qword ptr [RAX + 0x8],RCX
LEA RDI,[RSP + 0x28]
CALL 0x001244a0
MOV RDX,qword ptr [RSP + 0x8]
MOV RSI,RAX
ADD RDX,0x8
MOV RCX,qword ptr [RSP + 0x38]
LEA RDI,[RSP + 0x27]
CALL 0x0014c850
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x18],RAX
MOV RDX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x0013b4e0
ADD RSP,0x68
RET
|
/* spdlog::details::a_formatter<spdlog::details::null_scoped_padder>::format(spdlog::details::log_msg
const&, tm const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::a_formatter<spdlog::details::null_scoped_padder>::format
(a_formatter<spdlog::details::null_scoped_padder> *this,log_msg *param_1,tm *param_2,
basic_memory_buffer *param_3)
{
int8 *puVar1;
ulong uVar2;
null_scoped_padder local_41;
fmt_helper *local_40;
size_t local_38;
basic_memory_buffer *local_30;
tm *local_28;
log_msg *local_20;
a_formatter<spdlog::details::null_scoped_padder> *local_18;
fmt_helper *local_10;
fmt_helper **local_8;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_18 = this;
puVar1 = (int8 *)
std::array<char_const*,7ul>::operator[]
((array<char_const*,7ul> *)days,(long)param_2->tm_wday);
local_40 = (fmt_helper *)*puVar1;
local_8 = &local_40;
local_10 = local_40;
local_38 = strlen((char *)local_40);
uVar2 = fmt::v10::basic_string_view<char>::size((basic_string_view<char> *)&local_40);
null_scoped_padder::null_scoped_padder(&local_41,uVar2,(padding_info *)(this + 8),local_30);
fmt_helper::append_string_view(local_40,local_38,local_30);
return;
}
|
|
60,042
|
unicode_prop1
|
bluesky950520[P]quickjs/libunicode.c
|
static int unicode_prop1(CharRange *cr, int prop_idx)
{
const uint8_t *p, *p_end;
uint32_t c, c0, b, bit;
p = unicode_prop_table[prop_idx];
p_end = p + unicode_prop_len_table[prop_idx];
c = 0;
bit = 0;
while (p < p_end) {
c0 = c;
b = *p++;
if (b < 64) {
c += (b >> 3) + 1;
if (bit) {
if (cr_add_interval(cr, c0, c))
return -1;
}
bit ^= 1;
c0 = c;
c += (b & 7) + 1;
} else if (b >= 0x80) {
c += b - 0x80 + 1;
} else if (b < 0x60) {
c += (((b - 0x40) << 8) | p[0]) + 1;
p++;
} else {
c += (((b - 0x60) << 16) | (p[0] << 8) | p[1]) + 1;
p += 2;
}
if (bit) {
if (cr_add_interval(cr, c0, c))
return -1;
}
bit ^= 1;
}
return 0;
}
|
O1
|
c
|
unicode_prop1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x32802(%rip), %rcx # 0xccc10
movq (%rcx,%rax,8), %r15
leaq 0x11a57(%rip), %rcx # 0xabe70
movzwl (%rcx,%rax,2), %edi
addq %r15, %rdi
xorl %ebp, %ebp
xorl %r12d, %r12d
movq %rdi, (%rsp)
leaq 0x1(%r15), %r13
movzbl (%r15), %r14d
cmpl $0x3f, %r14d
ja 0x9a49a
movl %r14d, %eax
shrl $0x3, %eax
leal (%r12,%rax), %r8d
incl %r8d
testl %ebp, %ebp
je 0x9a488
movl (%rbx), %esi
addl $0x2, %esi
cmpl 0x4(%rbx), %esi
jle 0x9a46c
movq %rbx, %rdi
movq %r8, %r15
callq 0x98670
movq %r15, %r8
movq (%rsp), %rdi
testl %eax, %eax
jne 0x9a543
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %r12d, (%rax,%rcx,4)
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %r8d, (%rax,%rcx,4)
xorl $0x1, %ebp
andl $0x7, %r14d
addl %r8d, %r14d
incl %r14d
movq %r13, %r15
jmp 0x9a4f0
testb %r14b, %r14b
js 0x9a4c1
movzbl (%r13), %eax
cmpb $0x5f, %r14b
ja 0x9a4cd
shll $0x8, %r14d
addl %r12d, %r14d
addl %eax, %r14d
addl $0xffffc001, %r14d # imm = 0xFFFFC001
addq $0x2, %r15
jmp 0x9a4ed
addl %r12d, %r14d
addl $-0x7f, %r14d
movq %r13, %r15
jmp 0x9a4ed
shll $0x10, %r14d
shll $0x8, %eax
movzbl 0x2(%r15), %ecx
addl %r12d, %r14d
addl %eax, %r14d
addl %ecx, %r14d
addl $0xffa00001, %r14d # imm = 0xFFA00001
addq $0x3, %r15
movl %r12d, %r8d
testl %ebp, %ebp
je 0x9a530
movl (%rbx), %esi
addl $0x2, %esi
cmpl 0x4(%rbx), %esi
jle 0x9a514
movq %rbx, %rdi
movq %r8, %r12
callq 0x98670
movq %r12, %r8
movq (%rsp), %rdi
testl %eax, %eax
jne 0x9a543
movq 0x8(%rbx), %rax
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %r8d, (%rax,%rcx,4)
movslq (%rbx), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
movl %r14d, (%rax,%rcx,4)
xorl $0x1, %ebp
movl %r14d, %r12d
cmpq %rdi, %r15
jb 0x9a429
xorl %eax, %eax
jmp 0x9a548
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
unicode_prop1:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
movsxd rax, esi
lea rcx, unicode_prop_table
mov r15, [rcx+rax*8]
lea rcx, unicode_prop_len_table
movzx edi, word ptr [rcx+rax*2]
add rdi, r15
xor ebp, ebp
xor r12d, r12d
mov [rsp+38h+var_38], rdi
loc_9A429:
lea r13, [r15+1]
movzx r14d, byte ptr [r15]
cmp r14d, 3Fh ; '?'
ja short loc_9A49A
mov eax, r14d
shr eax, 3
lea r8d, [r12+rax]
inc r8d
test ebp, ebp
jz short loc_9A488
mov esi, [rbx]
add esi, 2
cmp esi, [rbx+4]
jle short loc_9A46C
mov rdi, rbx
mov r15, r8
call cr_realloc
mov r8, r15
mov rdi, [rsp+38h+var_38]
test eax, eax
jnz loc_9A543
loc_9A46C:
mov rax, [rbx+8]
movsxd rcx, dword ptr [rbx]
lea edx, [rcx+1]
mov [rbx], edx
mov [rax+rcx*4], r12d
movsxd rcx, dword ptr [rbx]
lea edx, [rcx+1]
mov [rbx], edx
mov [rax+rcx*4], r8d
loc_9A488:
xor ebp, 1
and r14d, 7
add r14d, r8d
inc r14d
mov r15, r13
jmp short loc_9A4F0
loc_9A49A:
test r14b, r14b
js short loc_9A4C1
movzx eax, byte ptr [r13+0]
cmp r14b, 5Fh ; '_'
ja short loc_9A4CD
shl r14d, 8
add r14d, r12d
add r14d, eax
add r14d, 0FFFFC001h
add r15, 2
jmp short loc_9A4ED
loc_9A4C1:
add r14d, r12d
add r14d, 0FFFFFF81h
mov r15, r13
jmp short loc_9A4ED
loc_9A4CD:
shl r14d, 10h
shl eax, 8
movzx ecx, byte ptr [r15+2]
add r14d, r12d
add r14d, eax
add r14d, ecx
add r14d, 0FFA00001h
add r15, 3
loc_9A4ED:
mov r8d, r12d
loc_9A4F0:
test ebp, ebp
jz short loc_9A530
mov esi, [rbx]
add esi, 2
cmp esi, [rbx+4]
jle short loc_9A514
mov rdi, rbx
mov r12, r8
call cr_realloc
mov r8, r12
mov rdi, [rsp+38h+var_38]
test eax, eax
jnz short loc_9A543
loc_9A514:
mov rax, [rbx+8]
movsxd rcx, dword ptr [rbx]
lea edx, [rcx+1]
mov [rbx], edx
mov [rax+rcx*4], r8d
movsxd rcx, dword ptr [rbx]
lea edx, [rcx+1]
mov [rbx], edx
mov [rax+rcx*4], r14d
loc_9A530:
xor ebp, 1
mov r12d, r14d
cmp r15, rdi
jb loc_9A429
xor eax, eax
jmp short loc_9A548
loc_9A543:
mov eax, 0FFFFFFFFh
loc_9A548:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long unicode_prop1(int *a1, int a2)
{
unsigned __int8 *v3; // r15
unsigned __int8 *v4; // rdi
int v5; // ebp
int v6; // r12d
unsigned int v7; // r14d
int v8; // r8d
int v9; // esi
int v10; // eax
long long v11; // rax
long long v12; // rcx
long long v13; // rcx
int v14; // r14d
int v15; // eax
int v16; // esi
int v17; // r12d
int v18; // eax
long long v19; // rax
long long v20; // rcx
long long v21; // rcx
unsigned __int8 *v23; // [rsp+0h] [rbp-38h]
v3 = (unsigned __int8 *)*(&unicode_prop_table + a2);
v4 = &v3[unicode_prop_len_table[a2]];
v5 = 0;
v6 = 0;
v23 = v4;
while ( 1 )
{
v7 = *v3;
if ( v7 <= 0x3F )
break;
if ( (v7 & 0x80u) != 0 )
{
v14 = v6 + v7 - 127;
++v3;
}
else
{
v15 = v3[1];
if ( (unsigned __int8)v7 > 0x5Fu )
{
v14 = v3[2] + (v15 << 8) + v6 + (v7 << 16) - 6291455;
v3 += 3;
}
else
{
v14 = v15 + v6 + (v7 << 8) - 0x3FFF;
v3 += 2;
}
}
v8 = v6;
LABEL_14:
if ( v5 )
{
v16 = *a1 + 2;
if ( v16 > a1[1] )
{
v17 = v8;
v18 = cr_realloc((long long)a1, v16);
v8 = v17;
v4 = v23;
if ( v18 )
return 0xFFFFFFFFLL;
}
v19 = *((_QWORD *)a1 + 1);
v20 = *a1;
*a1 = v20 + 1;
*(_DWORD *)(v19 + 4 * v20) = v8;
v21 = *a1;
*a1 = v21 + 1;
*(_DWORD *)(v19 + 4 * v21) = v14;
}
v5 ^= 1u;
v6 = v14;
if ( v3 >= v4 )
return 0LL;
}
v8 = v6 + (v7 >> 3) + 1;
if ( !v5 )
{
LABEL_7:
v5 ^= 1u;
v14 = v8 + (v7 & 7) + 1;
++v3;
goto LABEL_14;
}
v9 = *a1 + 2;
if ( v9 <= a1[1] || (v10 = cr_realloc((long long)a1, v9), v8 = v6 + (v7 >> 3) + 1, v4 = v23, !v10) )
{
v11 = *((_QWORD *)a1 + 1);
v12 = *a1;
*a1 = v12 + 1;
*(_DWORD *)(v11 + 4 * v12) = v6;
v13 = *a1;
*a1 = v13 + 1;
*(_DWORD *)(v11 + 4 * v13) = v8;
goto LABEL_7;
}
return 0xFFFFFFFFLL;
}
|
unicode_prop1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSXD RAX,ESI
LEA RCX,[0x1ccc10]
MOV R15,qword ptr [RCX + RAX*0x8]
LEA RCX,[0x1abe70]
MOVZX EDI,word ptr [RCX + RAX*0x2]
ADD RDI,R15
XOR EBP,EBP
XOR R12D,R12D
MOV qword ptr [RSP],RDI
LAB_0019a429:
LEA R13,[R15 + 0x1]
MOVZX R14D,byte ptr [R15]
CMP R14D,0x3f
JA 0x0019a49a
MOV EAX,R14D
SHR EAX,0x3
LEA R8D,[R12 + RAX*0x1]
INC R8D
TEST EBP,EBP
JZ 0x0019a488
MOV ESI,dword ptr [RBX]
ADD ESI,0x2
CMP ESI,dword ptr [RBX + 0x4]
JLE 0x0019a46c
MOV RDI,RBX
MOV R15,R8
CALL 0x00198670
MOV R8,R15
MOV RDI,qword ptr [RSP]
TEST EAX,EAX
JNZ 0x0019a543
LAB_0019a46c:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RCX,dword ptr [RBX]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RAX + RCX*0x4],R12D
MOVSXD RCX,dword ptr [RBX]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RAX + RCX*0x4],R8D
LAB_0019a488:
XOR EBP,0x1
AND R14D,0x7
ADD R14D,R8D
INC R14D
MOV R15,R13
JMP 0x0019a4f0
LAB_0019a49a:
TEST R14B,R14B
JS 0x0019a4c1
MOVZX EAX,byte ptr [R13]
CMP R14B,0x5f
JA 0x0019a4cd
SHL R14D,0x8
ADD R14D,R12D
ADD R14D,EAX
ADD R14D,0xffffc001
ADD R15,0x2
JMP 0x0019a4ed
LAB_0019a4c1:
ADD R14D,R12D
ADD R14D,-0x7f
MOV R15,R13
JMP 0x0019a4ed
LAB_0019a4cd:
SHL R14D,0x10
SHL EAX,0x8
MOVZX ECX,byte ptr [R15 + 0x2]
ADD R14D,R12D
ADD R14D,EAX
ADD R14D,ECX
ADD R14D,0xffa00001
ADD R15,0x3
LAB_0019a4ed:
MOV R8D,R12D
LAB_0019a4f0:
TEST EBP,EBP
JZ 0x0019a530
MOV ESI,dword ptr [RBX]
ADD ESI,0x2
CMP ESI,dword ptr [RBX + 0x4]
JLE 0x0019a514
MOV RDI,RBX
MOV R12,R8
CALL 0x00198670
MOV R8,R12
MOV RDI,qword ptr [RSP]
TEST EAX,EAX
JNZ 0x0019a543
LAB_0019a514:
MOV RAX,qword ptr [RBX + 0x8]
MOVSXD RCX,dword ptr [RBX]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RAX + RCX*0x4],R8D
MOVSXD RCX,dword ptr [RBX]
LEA EDX,[RCX + 0x1]
MOV dword ptr [RBX],EDX
MOV dword ptr [RAX + RCX*0x4],R14D
LAB_0019a530:
XOR EBP,0x1
MOV R12D,R14D
CMP R15,RDI
JC 0x0019a429
XOR EAX,EAX
JMP 0x0019a548
LAB_0019a543:
MOV EAX,0xffffffff
LAB_0019a548:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 unicode_prop1(int *param_1,int param_2)
{
byte bVar1;
byte bVar2;
ushort uVar3;
byte *pbVar4;
long lVar5;
bool bVar6;
int iVar7;
int iVar8;
int iVar9;
uint uVar10;
byte *pbVar11;
byte *pbVar12;
pbVar4 = *(byte **)(unicode_prop_table + (long)param_2 * 8);
uVar3 = *(ushort *)(unicode_prop_len_table + (long)param_2 * 2);
bVar6 = false;
iVar9 = 0;
pbVar11 = pbVar4;
do {
pbVar12 = pbVar11 + 1;
bVar1 = *pbVar11;
uVar10 = (uint)bVar1;
if (bVar1 < 0x40) {
iVar8 = iVar9 + (uint)(bVar1 >> 3) + 1;
if (bVar6) {
if ((param_1[1] < *param_1 + 2) && (iVar7 = cr_realloc(param_1), iVar7 != 0)) {
return 0xffffffff;
}
lVar5 = *(long *)(param_1 + 2);
iVar7 = *param_1;
*param_1 = iVar7 + 1;
*(int *)(lVar5 + (long)iVar7 * 4) = iVar9;
iVar9 = *param_1;
*param_1 = iVar9 + 1;
*(int *)(lVar5 + (long)iVar9 * 4) = iVar8;
}
bVar6 = (bool)(bVar6 ^ 1);
iVar9 = (uVar10 & 7) + iVar8 + 1;
}
else {
iVar8 = iVar9;
if ((char)bVar1 < '\0') {
iVar9 = (uint)bVar1 + iVar9 + -0x7f;
}
else {
bVar2 = *pbVar12;
if (bVar1 < 0x60) {
pbVar12 = pbVar11 + 2;
iVar9 = uVar10 * 0x100 + iVar9 + (uint)bVar2 + -0x3fff;
}
else {
pbVar12 = pbVar11 + 3;
iVar9 = uVar10 * 0x10000 + iVar9 + (uint)bVar2 * 0x100 + (uint)pbVar11[2] + -0x5fffff;
}
}
}
if (bVar6) {
if ((param_1[1] < *param_1 + 2) && (iVar7 = cr_realloc(param_1), iVar7 != 0)) {
return 0xffffffff;
}
lVar5 = *(long *)(param_1 + 2);
iVar7 = *param_1;
*param_1 = iVar7 + 1;
*(int *)(lVar5 + (long)iVar7 * 4) = iVar8;
iVar8 = *param_1;
*param_1 = iVar8 + 1;
*(int *)(lVar5 + (long)iVar8 * 4) = iVar9;
}
bVar6 = (bool)(bVar6 ^ 1);
pbVar11 = pbVar12;
if (pbVar4 + uVar3 <= pbVar12) {
return 0;
}
} while( true );
}
|
|
60,043
|
make_ftype
|
eloqsql/mysys/my_fopen.c
|
static void make_ftype(register char * to, register int flag)
{
/* check some possible invalid combinations */
DBUG_ASSERT((flag & (O_TRUNC | O_APPEND)) != (O_TRUNC | O_APPEND));
DBUG_ASSERT((flag & (O_WRONLY | O_RDWR)) != (O_WRONLY | O_RDWR));
if ((flag & (O_RDONLY|O_WRONLY)) == O_WRONLY)
*to++= (flag & O_APPEND) ? 'a' : 'w';
else if (flag & O_RDWR)
{
/* Add '+' after theese */
if (flag & (O_TRUNC | O_CREAT))
*to++= 'w';
else if (flag & O_APPEND)
*to++= 'a';
else
*to++= 'r';
*to++= '+';
}
else
*to++= 'r';
if (flag & FILE_BINARY)
*to++='b';
if (O_CLOEXEC)
*to++= 'e';
*to='\0';
}
|
O0
|
c
|
make_ftype:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
jmp 0x832bd
jmp 0x832bf
jmp 0x832c1
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x832fd
movl -0xc(%rbp), %edx
andl $0x400, %edx # imm = 0x400
movl $0x77, %eax
movl $0x61, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x83386
movl -0xc(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x83372
movl -0xc(%rbp), %eax
andl $0x240, %eax # imm = 0x240
cmpl $0x0, %eax
je 0x83329
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x77, (%rax)
jmp 0x8335e
movl -0xc(%rbp), %eax
andl $0x400, %eax # imm = 0x400
cmpl $0x0, %eax
je 0x8334a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x61, (%rax)
jmp 0x8335c
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x72, (%rax)
jmp 0x8335e
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x2b, (%rax)
jmp 0x83384
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x72, (%rax)
jmp 0x83386
movl -0xc(%rbp), %eax
andl $0x0, %eax
cmpl $0x0, %eax
je 0x833a3
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x62, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x65, (%rax)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nop
|
make_ftype:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
jmp short $+2
loc_832BD:
jmp short $+2
loc_832BF:
jmp short $+2
loc_832C1:
mov eax, [rbp+var_C]
and eax, 1
cmp eax, 1
jnz short loc_832FD
mov edx, [rbp+var_C]
and edx, 400h
mov eax, 77h ; 'w'
mov ecx, 61h ; 'a'
cmp edx, 0
cmovnz eax, ecx
mov cl, al
mov rax, [rbp+var_8]
mov rdx, rax
add rdx, 1
mov [rbp+var_8], rdx
mov [rax], cl
jmp loc_83386
loc_832FD:
mov eax, [rbp+var_C]
and eax, 2
cmp eax, 0
jz short loc_83372
mov eax, [rbp+var_C]
and eax, 240h
cmp eax, 0
jz short loc_83329
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 77h ; 'w'
jmp short loc_8335E
loc_83329:
mov eax, [rbp+var_C]
and eax, 400h
cmp eax, 0
jz short loc_8334A
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 61h ; 'a'
jmp short loc_8335C
loc_8334A:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 72h ; 'r'
loc_8335C:
jmp short $+2
loc_8335E:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 2Bh ; '+'
jmp short loc_83384
loc_83372:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 72h ; 'r'
loc_83384:
jmp short $+2
loc_83386:
mov eax, [rbp+var_C]
and eax, 0
cmp eax, 0
jz short loc_833A3
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 62h ; 'b'
loc_833A3:
mov rax, [rbp+var_8]
mov rcx, rax
add rcx, 1
mov [rbp+var_8], rcx
mov byte ptr [rax], 65h ; 'e'
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
pop rbp
retn
|
_BYTE * make_ftype(char *a1, __int16 a2)
{
char v2; // al
_BYTE *v3; // rax
_BYTE *result; // rax
_BYTE *v5; // [rsp+4h] [rbp-8h]
_BYTE *v6; // [rsp+4h] [rbp-8h]
if ( (a2 & 1) == 1 )
{
v2 = 119;
if ( (a2 & 0x400) != 0 )
v2 = 97;
v5 = a1 + 1;
*a1 = v2;
}
else if ( (a2 & 2) != 0 )
{
if ( (a2 & 0x240) != 0 )
{
v6 = a1 + 1;
*a1 = 119;
}
else
{
v6 = a1 + 1;
if ( (a2 & 0x400) != 0 )
*a1 = 97;
else
*a1 = 114;
}
v3 = v6;
v5 = v6 + 1;
*v3 = 43;
}
else
{
v5 = a1 + 1;
*a1 = 114;
}
*v5 = 101;
result = v5 + 1;
v5[1] = 0;
return result;
}
|
make_ftype:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
JMP 0x001832bd
LAB_001832bd:
JMP 0x001832bf
LAB_001832bf:
JMP 0x001832c1
LAB_001832c1:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1
CMP EAX,0x1
JNZ 0x001832fd
MOV EDX,dword ptr [RBP + -0xc]
AND EDX,0x400
MOV EAX,0x77
MOV ECX,0x61
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x8],RDX
MOV byte ptr [RAX],CL
JMP 0x00183386
LAB_001832fd:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00183372
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x240
CMP EAX,0x0
JZ 0x00183329
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x77
JMP 0x0018335e
LAB_00183329:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x400
CMP EAX,0x0
JZ 0x0018334a
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x61
JMP 0x0018335c
LAB_0018334a:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x72
LAB_0018335c:
JMP 0x0018335e
LAB_0018335e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x2b
JMP 0x00183384
LAB_00183372:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x72
LAB_00183384:
JMP 0x00183386
LAB_00183386:
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x0
CMP EAX,0x0
JZ 0x001833a3
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x62
LAB_001833a3:
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x8],RCX
MOV byte ptr [RAX],0x65
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00183391) */
void make_ftype(int1 *param_1,uint param_2)
{
int1 uVar1;
int1 *local_10;
if ((param_2 & 1) == 1) {
uVar1 = 0x77;
if ((param_2 & 0x400) != 0) {
uVar1 = 0x61;
}
*param_1 = uVar1;
local_10 = param_1 + 1;
}
else if ((param_2 & 2) == 0) {
local_10 = param_1 + 1;
*param_1 = 0x72;
}
else {
if ((param_2 & 0x240) == 0) {
if ((param_2 & 0x400) == 0) {
*param_1 = 0x72;
}
else {
*param_1 = 0x61;
}
}
else {
*param_1 = 0x77;
}
local_10 = param_1 + 1;
*local_10 = 0x2b;
local_10 = param_1 + 2;
}
*local_10 = 0x65;
local_10[1] = 0;
return;
}
|
|
60,044
|
mi_keyseg_write
|
eloqsql/storage/myisam/mi_open.c
|
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
{
uchar buff[HA_KEYSEG_SIZE];
uchar *ptr=buff;
ulong pos;
*ptr++= keyseg->type;
*ptr++= keyseg->language & 0xFF; /* Collation ID, low byte */
*ptr++= keyseg->null_bit;
*ptr++= keyseg->bit_start;
*ptr++= keyseg->language >> 8; /* Collation ID, high byte */
*ptr++= keyseg->bit_length;
mi_int2store(ptr,keyseg->flag); ptr+=2;
mi_int2store(ptr,keyseg->length); ptr+=2;
mi_int4store(ptr,keyseg->start); ptr+=4;
pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
mi_int4store(ptr, pos);
ptr+=4;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
}
|
O0
|
c
|
mi_keyseg_write:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x24(%rbp)
movq %rsi, -0x30(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb 0x18(%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movzwl 0x16(%rax), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb 0x19(%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb 0x1a(%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movzwl 0x16(%rax), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movb 0x1b(%rax), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movzwl 0x12(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x44(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0x14(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x48(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x50(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x50(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x50(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x19(%rax), %eax
cmpl $0x0, %eax
je 0xb9ba3
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0xb9bae
movq -0x30(%rbp), %rax
movzwl 0x10(%rax), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movb -0x58(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x3(%rax)
movb -0x57(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0x56(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0x55(%rbp), %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %edx
movq -0x38(%rbp), %r8
leaq -0x20(%rbp), %rcx
subq %rcx, %r8
leaq 0x99f78(%rip), %rdi # 0x153b7f
movl $0x4a2, %esi # imm = 0x4A2
movl $0x4, %r9d
callq 0xb8b00
testq %rax, %rax
setne %al
movzbl %al, %eax
movl %eax, -0x60(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb9c3e
movl -0x60(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
|
mi_keyseg_write:
push rbp
mov rbp, rsp
sub rsp, 60h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
lea rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov cl, [rax+18h]
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+16h]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
mov cl, [rax+19h]
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
mov cl, [rax+1Ah]
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+16h]
sar eax, 8
mov cl, al
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
mov cl, [rax+1Bh]
mov rax, [rbp+var_38]
mov rdx, rax
add rdx, 1
mov [rbp+var_38], rdx
mov [rax], cl
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+12h]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
mov cl, al
mov rax, [rbp+var_38]
mov [rax+1], cl
mov eax, [rbp+var_44]
shr eax, 8
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+14h]
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
mov cl, al
mov rax, [rbp+var_38]
mov [rax+1], cl
mov eax, [rbp+var_48]
shr eax, 8
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov eax, [rax+8]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov cl, al
mov rax, [rbp+var_38]
mov [rax+3], cl
mov rax, [rbp+var_50]
shr rax, 8
mov cl, al
mov rax, [rbp+var_38]
mov [rax+2], cl
mov rax, [rbp+var_50]
shr rax, 10h
mov cl, al
mov rax, [rbp+var_38]
mov [rax+1], cl
mov rax, [rbp+var_50]
shr rax, 18h
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_38]
add rax, 4
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+19h]
cmp eax, 0
jz short loc_B9BA3
mov rax, [rbp+var_30]
mov eax, [rax+0Ch]
mov [rbp+var_5C], eax
jmp short loc_B9BAE
loc_B9BA3:
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+10h]
mov [rbp+var_5C], eax
loc_B9BAE:
mov eax, [rbp+var_5C]
mov eax, eax
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_58], rax
mov cl, byte ptr [rbp+var_58]
mov rax, [rbp+var_38]
mov [rax+3], cl
mov cl, byte ptr [rbp+var_58+1]
mov rax, [rbp+var_38]
mov [rax+2], cl
mov cl, byte ptr [rbp+var_58+2]
mov rax, [rbp+var_38]
mov [rax+1], cl
mov cl, byte ptr [rbp+var_58+3]
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_38]
add rax, 4
mov [rbp+var_38], rax
mov edx, [rbp+var_24]
mov r8, [rbp+var_38]
lea rcx, [rbp+var_20]
sub r8, rcx
lea rdi, aWorkspaceLlm4b_29; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4A2h
mov r9d, 4
call inline_mysql_file_write_2
test rax, rax
setnz al
movzx eax, al
mov [rbp+var_60], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B9C3E
mov eax, [rbp+var_60]
add rsp, 60h
pop rbp
retn
loc_B9C3E:
call ___stack_chk_fail
|
_BOOL8 mi_keyseg_write(unsigned int a1, long long a2)
{
__int16 v2; // kr00_2
__int16 v3; // kr02_2
int v5; // [rsp+4h] [rbp-5Ch]
int v6; // [rsp+10h] [rbp-50h]
_BYTE v7[18]; // [rsp+40h] [rbp-20h] BYREF
_BYTE v8[14]; // [rsp+52h] [rbp-Eh] BYREF
*(_QWORD *)&v8[6] = __readfsqword(0x28u);
v7[0] = *(_BYTE *)(a2 + 24);
v7[1] = *(_WORD *)(a2 + 22);
v7[2] = *(_BYTE *)(a2 + 25);
v7[3] = *(_BYTE *)(a2 + 26);
v7[4] = HIBYTE(*(_WORD *)(a2 + 22));
v7[5] = *(_BYTE *)(a2 + 27);
v2 = *(_WORD *)(a2 + 18);
v7[6] = HIBYTE(v2);
v7[7] = v2;
v3 = *(_WORD *)(a2 + 20);
v7[8] = HIBYTE(v3);
v7[9] = v3;
v6 = *(_DWORD *)(a2 + 8);
v7[12] = BYTE1(v6);
v7[13] = v6;
v7[10] = HIBYTE(v6);
v7[11] = BYTE2(v6);
if ( *(_BYTE *)(a2 + 25) )
v5 = *(_DWORD *)(a2 + 12);
else
v5 = *(unsigned __int16 *)(a2 + 16);
v7[16] = BYTE1(v5);
v7[17] = v5;
v7[14] = HIBYTE(v5);
v7[15] = BYTE2(v5);
return inline_mysql_file_write_2(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x4A2u,
a1,
(long long)v7,
v8 - v7,
4LL) != 0;
}
|
mi_keyseg_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
LEA RAX,[RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,byte ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x16]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,byte ptr [RAX + 0x19]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,byte ptr [RAX + 0x1a]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x16]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOV CL,byte ptr [RAX + 0x1b]
MOV RAX,qword ptr [RBP + -0x38]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x38],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x12]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x44]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x48]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x3],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x2],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x50]
SHR RAX,0x18
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x19]
CMP EAX,0x0
JZ 0x001b9ba3
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x001b9bae
LAB_001b9ba3:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x5c],EAX
LAB_001b9bae:
MOV EAX,dword ptr [RBP + -0x5c]
MOV EAX,EAX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x58],RAX
MOV CL,byte ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x3],CL
MOV CL,byte ptr [RBP + -0x57]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x2],CL
MOV CL,byte ptr [RBP + -0x56]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],CL
MOV CL,byte ptr [RBP + -0x55]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x4
MOV qword ptr [RBP + -0x38],RAX
MOV EDX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x38]
LEA RCX,[RBP + -0x20]
SUB R8,RCX
LEA RDI,[0x253b7f]
MOV ESI,0x4a2
MOV R9D,0x4
CALL 0x001b8b00
TEST RAX,RAX
SETNZ AL
MOVZX EAX,AL
MOV dword ptr [RBP + -0x60],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b9c3e
MOV EAX,dword ptr [RBP + -0x60]
ADD RSP,0x60
POP RBP
RET
LAB_001b9c3e:
CALL 0x0012a270
|
bool mi_keyseg_write(int4 param_1,long param_2)
{
int4 uVar1;
long lVar2;
long in_FS_OFFSET;
uint local_64;
int1 local_60;
int1 uStack_5f;
int1 uStack_5e;
int1 uStack_5d;
int1 local_28;
int1 local_27;
int1 local_26;
int1 local_25;
int1 local_24;
int1 local_23;
int1 local_22;
int1 local_21;
int1 local_20;
int1 local_1f;
int1 local_1e;
int1 local_1d;
int1 local_1c;
int1 local_1b;
int1 local_1a;
int1 local_19;
int1 local_18;
int1 local_17;
int1 auStack_16 [6];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = *(int1 *)(param_2 + 0x18);
local_27 = (int1)*(int2 *)(param_2 + 0x16);
local_26 = *(int1 *)(param_2 + 0x19);
local_25 = *(int1 *)(param_2 + 0x1a);
local_24 = (int1)((ushort)*(int2 *)(param_2 + 0x16) >> 8);
local_23 = *(int1 *)(param_2 + 0x1b);
local_21 = (int1)*(int2 *)(param_2 + 0x12);
local_22 = (int1)((ushort)*(int2 *)(param_2 + 0x12) >> 8);
local_1f = (int1)*(int2 *)(param_2 + 0x14);
local_20 = (int1)((ushort)*(int2 *)(param_2 + 0x14) >> 8);
uVar1 = *(int4 *)(param_2 + 8);
local_1b = (int1)uVar1;
local_1c = (int1)((uint)uVar1 >> 8);
local_1d = (int1)((uint)uVar1 >> 0x10);
local_1e = (int1)((uint)uVar1 >> 0x18);
if (*(char *)(param_2 + 0x19) == '\0') {
local_64 = (uint)*(ushort *)(param_2 + 0x10);
}
else {
local_64 = *(uint *)(param_2 + 0xc);
}
local_60 = (int1)local_64;
local_17 = local_60;
uStack_5f = (int1)(local_64 >> 8);
local_18 = uStack_5f;
uStack_5e = (int1)(local_64 >> 0x10);
local_19 = uStack_5e;
uStack_5d = (int1)(local_64 >> 0x18);
local_1a = uStack_5d;
lVar2 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",0x4a2,
param_1,&local_28,auStack_16 + -(long)&local_28,4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return lVar2 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
60,045
|
bc_get_u32
|
bluesky950520[P]quickjs/quickjs.c
|
static __maybe_unused int bc_get_u32(BCReaderState *s, uint32_t *pval)
{
uint32_t v;
if (unlikely(s->buf_end - s->ptr < 4)) {
*pval = 0; /* avoid warning */
return bc_read_error_end(s);
}
v = get_u32(s->ptr);
if (is_be())
v = bswap32(v);
*pval = v;
s->ptr += 4;
return 0;
}
|
O0
|
c
|
bc_get_u32:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
cmpq $0x4, %rax
setl %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x78ff6
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0x791d0
movl %eax, 0x24(%rsp)
jmp 0x79042
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x5def0
movl %eax, 0xc(%rsp)
callq 0x2b9a0
cmpb $0x0, %al
je 0x7901e
movl 0xc(%rsp), %edi
callq 0x78b70
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
bc_get_u32:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov rax, [rax+18h]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+10h]
sub rax, rcx
cmp rax, 4
setl al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_78FF6
mov rax, [rsp+28h+var_18]
mov dword ptr [rax], 0
mov rdi, [rsp+28h+var_10]
call bc_read_error_end
mov [rsp+28h+var_4], eax
jmp short loc_79042
loc_78FF6:
mov rax, [rsp+28h+var_10]
mov rdi, [rax+10h]
call get_u32
mov [rsp+28h+var_1C], eax
call is_be_0
cmp al, 0
jz short loc_7901E
mov edi, [rsp+28h+var_1C]
call bswap32
mov [rsp+28h+var_1C], eax
loc_7901E:
mov ecx, [rsp+28h+var_1C]
mov rax, [rsp+28h+var_18]
mov [rax], ecx
mov rax, [rsp+28h+var_10]
mov rcx, [rax+10h]
add rcx, 4
mov [rax+10h], rcx
mov [rsp+28h+var_4], 0
loc_79042:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
|
long long bc_get_u32(long long a1, int *a2)
{
int u32; // [rsp+Ch] [rbp-1Ch]
if ( (long long)(*(_QWORD *)(a1 + 24) - *(_QWORD *)(a1 + 16)) >= 4 )
{
u32 = get_u32(*(unsigned int **)(a1 + 16));
if ( is_be_0() )
u32 = bswap32(u32);
*a2 = u32;
*(_QWORD *)(a1 + 16) += 4LL;
return 0;
}
else
{
*a2 = 0;
return (unsigned int)bc_read_error_end(a1);
}
}
|
bc_get_u32:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x10]
SUB RAX,RCX
CMP RAX,0x4
SETL AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00178ff6
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],0x0
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001791d0
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00179042
LAB_00178ff6:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0015def0
MOV dword ptr [RSP + 0xc],EAX
CALL 0x0012b9a0
CMP AL,0x0
JZ 0x0017901e
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00178b70
MOV dword ptr [RSP + 0xc],EAX
LAB_0017901e:
MOV ECX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RSP + 0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RAX + 0x10]
ADD RCX,0x4
MOV qword ptr [RAX + 0x10],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_00179042:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 bc_get_u32(long param_1,int4 *param_2)
{
char cVar1;
int4 local_1c;
int4 local_4;
if (*(long *)(param_1 + 0x18) - *(long *)(param_1 + 0x10) < 4) {
*param_2 = 0;
local_4 = bc_read_error_end(param_1);
}
else {
local_1c = get_u32(*(int8 *)(param_1 + 0x10));
cVar1 = is_be();
if (cVar1 != '\0') {
local_1c = bswap32(local_1c);
}
*param_2 = local_1c;
*(long *)(param_1 + 0x10) = *(long *)(param_1 + 0x10) + 4;
local_4 = 0;
}
return local_4;
}
|
|
60,046
|
push_state
|
bluesky950520[P]quickjs/libregexp.c
|
static int push_state(REExecContext *s,
uint8_t **capture,
StackInt *stack, size_t stack_len,
const uint8_t *pc, const uint8_t *cptr,
REExecStateEnum type, size_t count)
{
REExecState *rs;
uint8_t *new_stack;
size_t new_size, i, n;
StackInt *stack_buf;
if (unlikely((s->state_stack_len + 1) > s->state_stack_size)) {
/* reallocate the stack */
new_size = s->state_stack_size * 3 / 2;
if (new_size < 8)
new_size = 8;
new_stack = lre_realloc(s->opaque, s->state_stack, new_size * s->state_size);
if (!new_stack)
return -1;
s->state_stack_size = new_size;
s->state_stack = new_stack;
}
rs = (REExecState *)(s->state_stack + s->state_stack_len * s->state_size);
s->state_stack_len++;
rs->type = type;
rs->count = count;
rs->stack_len = stack_len;
rs->cptr = cptr;
rs->pc = pc;
n = 2 * s->capture_count;
for(i = 0; i < n; i++)
rs->buf[i] = capture[i];
stack_buf = (StackInt *)(rs->buf + n);
for(i = 0; i < stack_len; i++)
stack_buf[i] = stack[i];
return 0;
}
|
O1
|
c
|
push_state:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
movq 0x40(%rdi), %rdi
movq 0x48(%rbp), %rax
incq %rax
cmpq %rdi, %rax
ja 0x97460
movq 0x48(%rsp), %rcx
movl 0x40(%rsp), %edx
movq 0x38(%rbp), %rsi
movq 0x48(%rbp), %rdi
movq 0x30(%rbp), %r8
imulq %rdi, %r8
leaq (%rsi,%r8), %rax
incq %rdi
movq %rdi, 0x48(%rbp)
movb %dl, (%rsi,%r8)
movq %rcx, 0x8(%rsi,%r8)
movb %bl, 0x1(%rsi,%r8)
movq %r13, 0x10(%rsi,%r8)
movq %r12, 0x18(%rsi,%r8)
movl 0x14(%rbp), %edx
leal (%rdx,%rdx), %ecx
movslq %ecx, %rcx
testl %edx, %edx
je 0x9742c
cmpq $0x1, %rcx
movq %rcx, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movq (%r15,%rsi,8), %rdi
movq %rdi, 0x20(%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x9741b
testq %rbx, %rbx
je 0x9744f
leaq (%rax,%rcx,8), %rcx
addq $0x20, %rcx
xorl %eax, %eax
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0x9743d
jmp 0x97451
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x40(%rbp), %rdx
movq %rbp, %rsi
callq 0x13918
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testb $0x1, %cl
je 0x973c5
jmp 0x97451
nop
|
push_state:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov r12, r8
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov rbp, rdi
mov rdi, [rdi+40h]
mov rax, [rbp+48h]
inc rax
cmp rax, rdi
ja loc_97460
loc_973C5:
mov rcx, [rsp+38h+arg_8]
mov edx, [rsp+38h+arg_0]
mov rsi, [rbp+38h]
mov rdi, [rbp+48h]
mov r8, [rbp+30h]
imul r8, rdi
lea rax, [rsi+r8]
inc rdi
mov [rbp+48h], rdi
mov [rsi+r8], dl
mov [rsi+r8+8], rcx
mov [rsi+r8+1], bl
mov [rsi+r8+10h], r13
mov [rsi+r8+18h], r12
mov edx, [rbp+14h]
lea ecx, [rdx+rdx]
movsxd rcx, ecx
test edx, edx
jz short loc_9742C
cmp rcx, 1
mov rdx, rcx
adc rdx, 0
xor esi, esi
loc_9741B:
mov rdi, [r15+rsi*8]
mov [rax+rsi*8+20h], rdi
inc rsi
cmp rdx, rsi
jnz short loc_9741B
loc_9742C:
test rbx, rbx
jz short loc_9744F
lea rcx, [rax+rcx*8]
add rcx, 20h ; ' '
xor eax, eax
xor edx, edx
loc_9743D:
mov rsi, [r14+rdx*8]
mov [rcx+rdx*8], rsi
inc rdx
cmp rbx, rdx
jnz short loc_9743D
jmp short loc_97451
loc_9744F:
xor eax, eax
loc_97451:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_97460:
lea rdx, [rbp+40h]
mov rsi, rbp
call push_state_cold_1
mov ecx, eax
mov eax, 0FFFFFFFFh
test cl, 1
jz loc_973C5
jmp short loc_97451
|
long long push_state(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7,
long long a8)
{
unsigned long long v14; // rdi
long long v15; // rdi
long long v16; // rax
int v17; // edx
long long v18; // rcx
long long v19; // rsi
long long v20; // rcx
long long result; // rax
long long v22; // rdx
char v23; // cl
v14 = *(_QWORD *)(a1 + 64);
if ( *(_QWORD *)(a1 + 72) + 1LL <= v14
|| (v23 = push_state_cold_1(v14, (_QWORD *)a1, (unsigned long long *)(a1 + 64)), result = 0xFFFFFFFFLL, (v23 & 1) == 0) )
{
v15 = *(_QWORD *)(a1 + 72);
v16 = *(_QWORD *)(a1 + 56) + v15 * *(_QWORD *)(a1 + 48);
*(_QWORD *)(a1 + 72) = v15 + 1;
*(_BYTE *)v16 = a7;
*(_QWORD *)(v16 + 8) = a8;
*(_BYTE *)(v16 + 1) = a4;
*(_QWORD *)(v16 + 16) = a6;
*(_QWORD *)(v16 + 24) = a5;
v17 = *(_DWORD *)(a1 + 20);
v18 = 2 * v17;
if ( v17 )
{
v19 = 0LL;
do
{
*(_QWORD *)(v16 + 8 * v19 + 32) = *(_QWORD *)(a2 + 8 * v19);
++v19;
}
while ( (v18 == 0) + v18 != v19 );
}
if ( a4 )
{
v20 = v16 + 8 * v18 + 32;
result = 0LL;
v22 = 0LL;
do
{
*(_QWORD *)(v20 + 8 * v22) = *(_QWORD *)(a3 + 8 * v22);
++v22;
}
while ( a4 != v22 );
}
else
{
return 0LL;
}
}
return result;
}
|
push_state:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV R12,R8
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV RBP,RDI
MOV RDI,qword ptr [RDI + 0x40]
MOV RAX,qword ptr [RBP + 0x48]
INC RAX
CMP RAX,RDI
JA 0x00197460
LAB_001973c5:
MOV RCX,qword ptr [RSP + 0x48]
MOV EDX,dword ptr [RSP + 0x40]
MOV RSI,qword ptr [RBP + 0x38]
MOV RDI,qword ptr [RBP + 0x48]
MOV R8,qword ptr [RBP + 0x30]
IMUL R8,RDI
LEA RAX,[RSI + R8*0x1]
INC RDI
MOV qword ptr [RBP + 0x48],RDI
MOV byte ptr [RSI + R8*0x1],DL
MOV qword ptr [RSI + R8*0x1 + 0x8],RCX
MOV byte ptr [RSI + R8*0x1 + 0x1],BL
MOV qword ptr [RSI + R8*0x1 + 0x10],R13
MOV qword ptr [RSI + R8*0x1 + 0x18],R12
MOV EDX,dword ptr [RBP + 0x14]
LEA ECX,[RDX + RDX*0x1]
MOVSXD RCX,ECX
TEST EDX,EDX
JZ 0x0019742c
CMP RCX,0x1
MOV RDX,RCX
ADC RDX,0x0
XOR ESI,ESI
LAB_0019741b:
MOV RDI,qword ptr [R15 + RSI*0x8]
MOV qword ptr [RAX + RSI*0x8 + 0x20],RDI
INC RSI
CMP RDX,RSI
JNZ 0x0019741b
LAB_0019742c:
TEST RBX,RBX
JZ 0x0019744f
LEA RCX,[RAX + RCX*0x8]
ADD RCX,0x20
XOR EAX,EAX
XOR EDX,EDX
LAB_0019743d:
MOV RSI,qword ptr [R14 + RDX*0x8]
MOV qword ptr [RCX + RDX*0x8],RSI
INC RDX
CMP RBX,RDX
JNZ 0x0019743d
JMP 0x00197451
LAB_0019744f:
XOR EAX,EAX
LAB_00197451:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00197460:
LEA RDX,[RBP + 0x40]
MOV RSI,RBP
CALL 0x00113918
MOV ECX,EAX
MOV EAX,0xffffffff
TEST CL,0x1
JZ 0x001973c5
JMP 0x00197451
|
int8
push_state(long param_1,long param_2,long param_3,long param_4,int8 param_5,int8 param_6
,int1 param_7,int8 param_8)
{
long lVar1;
uint uVar2;
long lVar3;
long lVar4;
long lVar5;
if ((*(ulong *)(param_1 + 0x40) < *(long *)(param_1 + 0x48) + 1U) &&
(uVar2 = push_state_cold_1(*(ulong *)(param_1 + 0x40),param_1,param_1 + 0x40), (uVar2 & 1) != 0
)) {
return 0xffffffff;
}
lVar1 = *(long *)(param_1 + 0x38);
lVar5 = *(long *)(param_1 + 0x30) * *(long *)(param_1 + 0x48);
*(long *)(param_1 + 0x48) = *(long *)(param_1 + 0x48) + 1;
*(int1 *)(lVar1 + lVar5) = param_7;
*(int8 *)(lVar1 + 8 + lVar5) = param_8;
*(char *)(lVar1 + 1 + lVar5) = (char)param_4;
*(int8 *)(lVar1 + 0x10 + lVar5) = param_6;
*(int8 *)(lVar1 + 0x18 + lVar5) = param_5;
lVar3 = (long)(*(int *)(param_1 + 0x14) * 2);
if (*(int *)(param_1 + 0x14) != 0) {
lVar4 = 0;
do {
*(int8 *)(lVar1 + lVar5 + 0x20 + lVar4 * 8) = *(int8 *)(param_2 + lVar4 * 8);
lVar4 = lVar4 + 1;
} while (lVar3 + (ulong)(lVar3 == 0) != lVar4);
}
if (param_4 != 0) {
lVar4 = 0;
do {
*(int8 *)(lVar1 + lVar5 + lVar3 * 8 + 0x20 + lVar4 * 8) =
*(int8 *)(param_3 + lVar4 * 8);
lVar4 = lVar4 + 1;
} while (param_4 != lVar4);
}
return 0;
}
|
|
60,047
|
push_state
|
bluesky950520[P]quickjs/libregexp.c
|
static int push_state(REExecContext *s,
uint8_t **capture,
StackInt *stack, size_t stack_len,
const uint8_t *pc, const uint8_t *cptr,
REExecStateEnum type, size_t count)
{
REExecState *rs;
uint8_t *new_stack;
size_t new_size, i, n;
StackInt *stack_buf;
if (unlikely((s->state_stack_len + 1) > s->state_stack_size)) {
/* reallocate the stack */
new_size = s->state_stack_size * 3 / 2;
if (new_size < 8)
new_size = 8;
new_stack = lre_realloc(s->opaque, s->state_stack, new_size * s->state_size);
if (!new_stack)
return -1;
s->state_stack_size = new_size;
s->state_stack = new_stack;
}
rs = (REExecState *)(s->state_stack + s->state_stack_len * s->state_size);
s->state_stack_len++;
rs->type = type;
rs->count = count;
rs->stack_len = stack_len;
rs->cptr = cptr;
rs->pc = pc;
n = 2 * s->capture_count;
for(i = 0; i < n; i++)
rs->buf[i] = capture[i];
stack_buf = (StackInt *)(rs->buf + n);
for(i = 0; i < stack_len; i++)
stack_buf[i] = stack[i];
return 0;
}
|
O3
|
c
|
push_state:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rdx
leaq 0x1(%rdx), %rsi
cmpq %rax, %rsi
ja 0x99d30
movq 0x38(%rbp), %rax
movq 0x48(%rsp), %rdi
imulq 0x30(%rbp), %rdx
movl 0x40(%rsp), %r8d
leaq (%rax,%rdx), %rcx
movq %rsi, 0x48(%rbp)
movb %r8b, (%rax,%rdx)
movq %rdi, 0x8(%rax,%rdx)
movb %bl, 0x1(%rax,%rdx)
movq %r13, 0x10(%rax,%rdx)
movq %r12, 0x18(%rax,%rdx)
movl 0x14(%rbp), %edx
leal (%rdx,%rdx), %eax
cltq
testl %edx, %edx
je 0x99cfc
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movq (%r15,%rsi,8), %rdi
movq %rdi, 0x20(%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x99ceb
testq %rbx, %rbx
je 0x99d1f
leaq (%rcx,%rax,8), %rcx
addq $0x20, %rcx
xorl %eax, %eax
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movq %rsi, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbx
jne 0x99d0d
jmp 0x99d21
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq (%rax,%rax,2), %rax
shrq %rax
cmpq $0x9, %rax
movl $0x8, %ecx
cmovaeq %rax, %rcx
movq 0x28(%rbp), %rdi
movq 0x38(%rbp), %rsi
movq 0x30(%rbp), %rdx
movq %rcx, (%rsp)
imulq %rcx, %rdx
callq 0x3375b
testq %rax, %rax
je 0x99d7b
movq (%rsp), %rcx
movq %rcx, 0x40(%rbp)
movq %rax, 0x38(%rbp)
movq 0x48(%rbp), %rdx
leaq 0x1(%rdx), %rsi
jmp 0x99ca4
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x99d21
nop
|
push_state:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r13, r9
mov r12, r8
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov rbp, rdi
mov rax, [rdi+40h]
mov rdx, [rdi+48h]
lea rsi, [rdx+1]
cmp rsi, rax
ja loc_99D30
mov rax, [rbp+38h]
loc_99CA4:
mov rdi, [rsp+38h+arg_8]
imul rdx, [rbp+30h]
mov r8d, [rsp+38h+arg_0]
lea rcx, [rax+rdx]
mov [rbp+48h], rsi
mov [rax+rdx], r8b
mov [rax+rdx+8], rdi
mov [rax+rdx+1], bl
mov [rax+rdx+10h], r13
mov [rax+rdx+18h], r12
mov edx, [rbp+14h]
lea eax, [rdx+rdx]
cdqe
test edx, edx
jz short loc_99CFC
cmp rax, 1
mov rdx, rax
adc rdx, 0
xor esi, esi
loc_99CEB:
mov rdi, [r15+rsi*8]
mov [rcx+rsi*8+20h], rdi
inc rsi
cmp rdx, rsi
jnz short loc_99CEB
loc_99CFC:
test rbx, rbx
jz short loc_99D1F
lea rcx, [rcx+rax*8]
add rcx, 20h ; ' '
xor eax, eax
xor edx, edx
loc_99D0D:
mov rsi, [r14+rdx*8]
mov [rcx+rdx*8], rsi
inc rdx
cmp rbx, rdx
jnz short loc_99D0D
jmp short loc_99D21
loc_99D1F:
xor eax, eax
loc_99D21:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_99D30:
lea rax, [rax+rax*2]
shr rax, 1
cmp rax, 9
mov ecx, 8
cmovnb rcx, rax
mov rdi, [rbp+28h]
mov rsi, [rbp+38h]
mov rdx, [rbp+30h]
mov [rsp+38h+var_38], rcx
imul rdx, rcx
call lre_realloc
test rax, rax
jz short loc_99D7B
mov rcx, [rsp+38h+var_38]
mov [rbp+40h], rcx
mov [rbp+38h], rax
mov rdx, [rbp+48h]
lea rsi, [rdx+1]
jmp loc_99CA4
loc_99D7B:
mov eax, 0FFFFFFFFh
jmp short loc_99D21
|
long long push_state(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7,
long long a8)
{
unsigned long long v13; // rax
long long v14; // rdx
long long v15; // rsi
long long v16; // rax
long long v17; // rcx
int v18; // edx
long long v19; // rax
long long v20; // rsi
long long v21; // rcx
long long result; // rax
long long v23; // rdx
unsigned long long v24; // rax
long long v25; // rcx
long long v26; // [rsp+0h] [rbp-38h]
v13 = *(_QWORD *)(a1 + 64);
v14 = *(_QWORD *)(a1 + 72);
v15 = v14 + 1;
if ( v14 + 1 > v13 )
{
v24 = (3 * v13) >> 1;
v25 = 8LL;
if ( v24 >= 9 )
v25 = v24;
v26 = v25;
v16 = lre_realloc(*(_QWORD *)(a1 + 40), *(_QWORD *)(a1 + 56), v25 * *(_QWORD *)(a1 + 48));
if ( !v16 )
return 0xFFFFFFFFLL;
*(_QWORD *)(a1 + 64) = v26;
*(_QWORD *)(a1 + 56) = v16;
v14 = *(_QWORD *)(a1 + 72);
v15 = v14 + 1;
}
else
{
v16 = *(_QWORD *)(a1 + 56);
}
v17 = v16 + *(_QWORD *)(a1 + 48) * v14;
*(_QWORD *)(a1 + 72) = v15;
*(_BYTE *)v17 = a7;
*(_QWORD *)(v17 + 8) = a8;
*(_BYTE *)(v17 + 1) = a4;
*(_QWORD *)(v17 + 16) = a6;
*(_QWORD *)(v17 + 24) = a5;
v18 = *(_DWORD *)(a1 + 20);
v19 = 2 * v18;
if ( v18 )
{
v20 = 0LL;
do
{
*(_QWORD *)(v17 + 8 * v20 + 32) = *(_QWORD *)(a2 + 8 * v20);
++v20;
}
while ( (v19 == 0) + v19 != v20 );
}
if ( !a4 )
return 0LL;
v21 = v17 + 8 * v19 + 32;
result = 0LL;
v23 = 0LL;
do
{
*(_QWORD *)(v21 + 8 * v23) = *(_QWORD *)(a3 + 8 * v23);
++v23;
}
while ( a4 != v23 );
return result;
}
|
push_state:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R13,R9
MOV R12,R8
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV RBP,RDI
MOV RAX,qword ptr [RDI + 0x40]
MOV RDX,qword ptr [RDI + 0x48]
LEA RSI,[RDX + 0x1]
CMP RSI,RAX
JA 0x00199d30
MOV RAX,qword ptr [RBP + 0x38]
LAB_00199ca4:
MOV RDI,qword ptr [RSP + 0x48]
IMUL RDX,qword ptr [RBP + 0x30]
MOV R8D,dword ptr [RSP + 0x40]
LEA RCX,[RAX + RDX*0x1]
MOV qword ptr [RBP + 0x48],RSI
MOV byte ptr [RAX + RDX*0x1],R8B
MOV qword ptr [RAX + RDX*0x1 + 0x8],RDI
MOV byte ptr [RAX + RDX*0x1 + 0x1],BL
MOV qword ptr [RAX + RDX*0x1 + 0x10],R13
MOV qword ptr [RAX + RDX*0x1 + 0x18],R12
MOV EDX,dword ptr [RBP + 0x14]
LEA EAX,[RDX + RDX*0x1]
CDQE
TEST EDX,EDX
JZ 0x00199cfc
CMP RAX,0x1
MOV RDX,RAX
ADC RDX,0x0
XOR ESI,ESI
LAB_00199ceb:
MOV RDI,qword ptr [R15 + RSI*0x8]
MOV qword ptr [RCX + RSI*0x8 + 0x20],RDI
INC RSI
CMP RDX,RSI
JNZ 0x00199ceb
LAB_00199cfc:
TEST RBX,RBX
JZ 0x00199d1f
LEA RCX,[RCX + RAX*0x8]
ADD RCX,0x20
XOR EAX,EAX
XOR EDX,EDX
LAB_00199d0d:
MOV RSI,qword ptr [R14 + RDX*0x8]
MOV qword ptr [RCX + RDX*0x8],RSI
INC RDX
CMP RBX,RDX
JNZ 0x00199d0d
JMP 0x00199d21
LAB_00199d1f:
XOR EAX,EAX
LAB_00199d21:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00199d30:
LEA RAX,[RAX + RAX*0x2]
SHR RAX,0x1
CMP RAX,0x9
MOV ECX,0x8
CMOVNC RCX,RAX
MOV RDI,qword ptr [RBP + 0x28]
MOV RSI,qword ptr [RBP + 0x38]
MOV RDX,qword ptr [RBP + 0x30]
MOV qword ptr [RSP],RCX
IMUL RDX,RCX
CALL 0x0013375b
TEST RAX,RAX
JZ 0x00199d7b
MOV RCX,qword ptr [RSP]
MOV qword ptr [RBP + 0x40],RCX
MOV qword ptr [RBP + 0x38],RAX
MOV RDX,qword ptr [RBP + 0x48]
LEA RSI,[RDX + 0x1]
JMP 0x00199ca4
LAB_00199d7b:
MOV EAX,0xffffffff
JMP 0x00199d21
|
int8
push_state(long param_1,long param_2,long param_3,long param_4,int8 param_5,int8 param_6
,int1 param_7,int8 param_8)
{
long lVar1;
ulong uVar2;
long lVar3;
ulong uVar4;
long lVar5;
long lVar6;
lVar5 = *(long *)(param_1 + 0x48);
uVar4 = lVar5 + 1;
if (*(ulong *)(param_1 + 0x40) < uVar4) {
uVar2 = *(ulong *)(param_1 + 0x40) * 3 >> 1;
uVar4 = 8;
if (8 < uVar2) {
uVar4 = uVar2;
}
lVar3 = lre_realloc(*(int8 *)(param_1 + 0x28),*(int8 *)(param_1 + 0x38),
*(long *)(param_1 + 0x30) * uVar4);
if (lVar3 == 0) {
return 0xffffffff;
}
*(ulong *)(param_1 + 0x40) = uVar4;
*(long *)(param_1 + 0x38) = lVar3;
lVar5 = *(long *)(param_1 + 0x48);
uVar4 = lVar5 + 1;
}
else {
lVar3 = *(long *)(param_1 + 0x38);
}
lVar5 = lVar5 * *(long *)(param_1 + 0x30);
*(ulong *)(param_1 + 0x48) = uVar4;
*(int1 *)(lVar3 + lVar5) = param_7;
*(int8 *)(lVar3 + 8 + lVar5) = param_8;
*(char *)(lVar3 + 1 + lVar5) = (char)param_4;
*(int8 *)(lVar3 + 0x10 + lVar5) = param_6;
*(int8 *)(lVar3 + 0x18 + lVar5) = param_5;
lVar1 = (long)(*(int *)(param_1 + 0x14) * 2);
if (*(int *)(param_1 + 0x14) != 0) {
lVar6 = 0;
do {
*(int8 *)(lVar3 + lVar5 + 0x20 + lVar6 * 8) = *(int8 *)(param_2 + lVar6 * 8);
lVar6 = lVar6 + 1;
} while (lVar1 + (ulong)(lVar1 == 0) != lVar6);
}
if (param_4 != 0) {
lVar6 = 0;
do {
*(int8 *)(lVar3 + lVar5 + lVar1 * 8 + 0x20 + lVar6 * 8) =
*(int8 *)(param_3 + lVar6 * 8);
lVar6 = lVar6 + 1;
} while (param_4 != lVar6);
}
return 0;
}
|
|
60,048
|
gguf_get_tensor_size
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp
|
size_t gguf_get_tensor_size(const struct gguf_context * ctx, int64_t tensor_id) {
GGML_ASSERT(tensor_id >= 0 && tensor_id < gguf_get_n_tensors(ctx));
return ggml_nbytes(&ctx->info[tensor_id].t);
}
|
O1
|
cpp
|
gguf_get_tensor_size:
pushq %rax
testq %rsi, %rsi
js 0x3f7d5
movq %rdi, %rax
movq 0x20(%rdi), %rdi
movq 0x28(%rax), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $-0x7d05f417d05f417d, %rcx # imm = 0x82FA0BE82FA0BE83
imulq %rcx, %rdx
cmpq %rsi, %rdx
jle 0x3f7d5
movq 0x28(%rax), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %rcx, %rax
cmpq %rsi, %rax
jbe 0x3f7d0
imulq $0x158, %rsi, %rax # imm = 0x158
addq %rax, %rdi
popq %rax
jmp 0x171c0
callq 0x19e71
leaq 0x1d811(%rip), %rdi # 0x5cfed
leaq 0xcdde(%rip), %rdx # 0x4c5c1
leaq 0x1dd66(%rip), %rcx # 0x5d550
movl $0x391, %esi # imm = 0x391
xorl %eax, %eax
callq 0x18ce0
|
gguf_get_tensor_size:
push rax
test rsi, rsi
js short loc_3F7D5
mov rax, rdi
mov rdi, [rdi+20h]
mov rdx, [rax+28h]
sub rdx, rdi
sar rdx, 3
mov rcx, 82FA0BE82FA0BE83h
imul rdx, rcx
cmp rdx, rsi
jle short loc_3F7D5
mov rax, [rax+28h]
sub rax, rdi
sar rax, 3
imul rax, rcx
cmp rax, rsi
jbe short loc_3F7D0
imul rax, rsi, 158h
add rdi, rax
pop rax
jmp _ggml_nbytes
loc_3F7D0:
call gguf_get_tensor_size_cold_1
loc_3F7D5:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorId0Tenso; "tensor_id >= 0 && tensor_id < gguf_get_"...
mov esi, 391h
xor eax, eax
call _ggml_abort
|
unsigned long long gguf_get_tensor_size(long long a1, signed long long a2, long long a3, long long a4, int a5, int a6)
{
long long v7; // rdi
if ( a2 < 0 || (v7 = *(_QWORD *)(a1 + 32), (long long)(0x82FA0BE82FA0BE83LL * ((*(_QWORD *)(a1 + 40) - v7) >> 3)) <= a2) )
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
913,
(unsigned int)"GGML_ASSERT(%s) failed",
(unsigned int)"tensor_id >= 0 && tensor_id < gguf_get_n_tensors(ctx)",
a5,
a6);
if ( 0x82FA0BE82FA0BE83LL * ((*(_QWORD *)(a1 + 40) - v7) >> 3) <= a2 )
gguf_get_tensor_size_cold_1();
return ggml_nbytes((unsigned int *)(344 * a2 + v7));
}
|
gguf_get_tensor_size:
PUSH RAX
TEST RSI,RSI
JS 0x0013f7d5
MOV RAX,RDI
MOV RDI,qword ptr [RDI + 0x20]
MOV RDX,qword ptr [RAX + 0x28]
SUB RDX,RDI
SAR RDX,0x3
MOV RCX,-0x7d05f417d05f417d
IMUL RDX,RCX
CMP RDX,RSI
JLE 0x0013f7d5
MOV RAX,qword ptr [RAX + 0x28]
SUB RAX,RDI
SAR RAX,0x3
IMUL RAX,RCX
CMP RAX,RSI
JBE 0x0013f7d0
IMUL RAX,RSI,0x158
ADD RDI,RAX
POP RAX
JMP 0x001171c0
LAB_0013f7d0:
CALL 0x00119e71
LAB_0013f7d5:
LEA RDI,[0x15cfed]
LEA RDX,[0x14c5c1]
LEA RCX,[0x15d550]
MOV ESI,0x391
XOR EAX,EAX
CALL 0x00118ce0
|
void gguf_get_tensor_size(long param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
long lVar3;
if (-1 < (long)param_2) {
lVar1 = *(long *)(param_1 + 0x20);
lVar3 = (*(long *)(param_1 + 0x28) - lVar1 >> 3) * -0x7d05f417d05f417d;
if (lVar3 - param_2 != 0 && (long)param_2 <= lVar3) {
uVar2 = (*(long *)(param_1 + 0x28) - lVar1 >> 3) * -0x7d05f417d05f417d;
if (param_2 <= uVar2 && uVar2 - param_2 != 0) {
ggml_nbytes(lVar1 + param_2 * 0x158);
return;
}
gguf_get_tensor_size_cold_1();
}
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
0x391,"GGML_ASSERT(%s) failed","tensor_id >= 0 && tensor_id < gguf_get_n_tensors(ctx)")
;
}
|
|
60,049
|
minja::Value::operator-() const
|
llama.cpp/common/minja/minja.hpp
|
Value operator-() const {
if (is_number_integer())
return -get<int64_t>();
else
return -get<double>();
}
|
O3
|
cpp
|
minja::Value::operator-() const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x40(%rsi), %al
addb $-0x5, %al
leaq 0x40(%rdi), %r14
movq %rsi, %rdi
cmpb $0x1, %al
ja 0x970c6
callq 0x790b6
negq %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rax, %rsi
callq 0x32192
jmp 0x970f0
callq 0x75d7c
xorps 0x2e00e(%rip), %xmm0 # 0xc50e0
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm1, 0x20(%rbx)
movups %xmm1, 0x30(%rbx)
movups %xmm1, 0x40(%rbx)
movq %r14, %rdi
callq 0x31aea
movq %r14, %rdi
movl $0x1, %esi
callq 0x732fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZNK5minja5ValuengEv:
push r14
push rbx
push rax
mov rbx, rdi
mov al, [rsi+40h]
add al, 0FBh
lea r14, [rdi+40h]
mov rdi, rsi
cmp al, 1
ja short loc_970C6
call _ZNK5minja5Value3getIlEET_v; minja::Value::get<long>(void)
neg rax
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
movups xmmword ptr [rbx+40h], xmm0
mov rdi, r14
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::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>::number_integer_t)
jmp short loc_970F0
loc_970C6:
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
xorps xmm0, cs:xmmword_C50E0
xorps xmm1, xmm1
movups xmmword ptr [rbx], xmm1
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx+20h], xmm1
movups xmmword ptr [rbx+30h], xmm1
movups xmmword ptr [rbx+40h], xmm1
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::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>::number_float_t)
loc_970F0:
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 rax, rbx
add rsp, 8
pop rbx
pop r14
retn
|
_OWORD * minja::Value::operator-(_OWORD *a1, long long a2)
{
unsigned __int8 *v2; // r14
long long v3; // rax
double v4; // xmm0_8
v2 = (unsigned __int8 *)(a1 + 4);
if ( (unsigned __int8)(*(_BYTE *)(a2 + 64) - 5) > 1u )
{
v4 = minja::Value::get<double>((_QWORD *)a2);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
a1[3] = 0LL;
a1[4] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<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>>(
v2,
-v4);
}
else
{
v3 = minja::Value::get<long>((_QWORD *)a2);
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
a1[3] = 0LL;
a1[4] = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::construct<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>>(
v2,
-v3);
}
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 *)v2);
return a1;
}
|
operator-:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV AL,byte ptr [RSI + 0x40]
ADD AL,0xfb
LEA R14,[RDI + 0x40]
MOV RDI,RSI
CMP AL,0x1
JA 0x001970c6
CALL 0x001790b6
NEG RAX
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
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOV RDI,R14
MOV RSI,RAX
CALL 0x00132192
JMP 0x001970f0
LAB_001970c6:
CALL 0x00175d7c
XORPS XMM0,xmmword ptr [0x001c50e0]
XORPS XMM1,XMM1
MOVUPS xmmword ptr [RBX],XMM1
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX + 0x20],XMM1
MOVUPS xmmword ptr [RBX + 0x30],XMM1
MOVUPS xmmword ptr [RBX + 0x40],XMM1
MOV RDI,R14
CALL 0x00131aea
LAB_001970f0:
MOV RDI,R14
MOV ESI,0x1
CALL 0x001732fc
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* minja::Value::TEMPNAMEPLACEHOLDERVALUE() const */
Value * __thiscall minja::Value::operator-(Value *this)
{
Value *pVVar1;
double dVar2;
long lVar3;
Value *in_RSI;
uint uVar4;
pVVar1 = this + 0x40;
if ((byte)((char)in_RSI[0x40] - 5U) < 2) {
lVar3 = get<long>(in_RSI);
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
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>>
(pVVar1,-lVar3);
}
else {
dVar2 = get<double>(in_RSI);
uVar4 = SUB84(dVar2,0) ^ _DAT_001c50e0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
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>>
(uVar4,pVVar1);
}
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(pVVar1,0));
return this;
}
|
|
60,050
|
Engine::evaluatePieceSquareTables(chess::Board const&, bool)
|
Razamindset[P]pawnstar-chess-engine/src/engine/eval.cpp
|
int Engine::evaluatePieceSquareTables(const Board& board, bool isEndGame) {
int eval = 0;
for (Square sq = 0; sq < 64; sq++) {
Piece piece = board.at(sq);
if (piece.type() == PieceType::NONE) continue;
int index =
(piece.color() == Color::WHITE) ? sq.index() : mirrorIndex(sq.index());
int squareValue = 0;
switch (piece.type()) {
case PAWN:
squareValue = PAWN_TABLE[index];
break;
case KNIGHT:
squareValue = KNIGHT_TABLE[index];
break;
case BISHOP:
squareValue = BISHOP_TABLE[index];
break;
case ROOK:
squareValue = ROOK_TABLE[index];
break;
case QUEEN:
squareValue = QUEEN_TABLE[index];
break;
case KING:
squareValue =
isEndGame ? KING_END_TABLE[index] : KING_MIDDLE_TABLE[index];
break;
}
eval += (piece.color() == Color::WHITE) ? squareValue : -squareValue;
}
return eval;
}
|
O0
|
cpp
|
Engine::evaluatePieceSquareTables(chess::Board const&, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
callq 0x43a0
leaq -0x20(%rbp), %rdi
movl $0x40, %esi
callq 0x43a0
leaq -0x1c(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4e50
testb $0x1, %al
jne 0x1f60d
jmp 0x1f7cb
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0xa5b0
movb %al, -0x21(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x9fb0
movb %al, -0x29(%rbp)
leaq -0x2a(%rbp), %rdi
movl $0x6, %esi
callq 0xa0b0
leaq -0x29(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0xa590
testb $0x1, %al
jne 0x1f64f
jmp 0x1f654
jmp 0x1f7b8
leaq -0x21(%rbp), %rdi
callq 0xa030
movb %al, -0x31(%rbp)
leaq -0x32(%rbp), %rdi
xorl %esi, %esi
callq 0x5e10
leaq -0x31(%rbp), %rdi
leaq -0x32(%rbp), %rsi
callq 0x7da0
testb $0x1, %al
jne 0x1f67e
jmp 0x1f68c
leaq -0x1c(%rbp), %rdi
callq 0x4d40
movl %eax, -0x44(%rbp)
jmp 0x1f69f
leaq -0x1c(%rbp), %rdi
callq 0x4d40
movl %eax, %edi
callq 0x1fca0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x9fb0
movb %al, -0x39(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xa120
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x1f, %eax
ja 0x1f775
movq -0x50(%rbp), %rax
leaq 0x6333(%rip), %rcx # 0x25a10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movslq -0x30(%rbp), %rcx
leaq 0x699f(%rip), %rax # 0x26090
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f775
movslq -0x30(%rbp), %rcx
leaq 0x638c(%rip), %rax # 0x25a90
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f775
movslq -0x30(%rbp), %rcx
leaq 0x6479(%rip), %rax # 0x25b90
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f775
movslq -0x30(%rbp), %rcx
leaq 0x6566(%rip), %rax # 0x25c90
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f775
movslq -0x30(%rbp), %rcx
leaq 0x6653(%rip), %rax # 0x25d90
movl (%rax,%rcx,4), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f775
testb $0x1, -0x11(%rbp)
je 0x1f75e
movslq -0x30(%rbp), %rcx
leaq 0x673a(%rip), %rax # 0x25e90
movl (%rax,%rcx,4), %eax
movl %eax, -0x54(%rbp)
jmp 0x1f76f
movslq -0x30(%rbp), %rcx
leaq 0x6827(%rip), %rax # 0x25f90
movl (%rax,%rcx,4), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xa030
movb %al, -0x3a(%rbp)
leaq -0x3b(%rbp), %rdi
xorl %esi, %esi
callq 0x5e10
leaq -0x3a(%rbp), %rdi
leaq -0x3b(%rbp), %rsi
callq 0x7da0
testb $0x1, %al
jne 0x1f79f
jmp 0x1f7a7
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x1f7af
xorl %eax, %eax
subl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
callq 0xa650
movl %eax, -0x40(%rbp)
jmp 0x1f5e9
movl -0x18(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ZN6Engine25evaluatePieceSquareTablesERKN5chess5BoardEb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
and al, 1
mov [rbp+var_11], al
mov [rbp+var_18], 0
lea rdi, [rbp+var_1C]; this
xor esi, esi; int
call _ZN5chess6SquareC2Ei; chess::Square::Square(int)
loc_1F5E9:
lea rdi, [rbp+var_20]; this
mov esi, 40h ; '@'; int
call _ZN5chess6SquareC2Ei; chess::Square::Square(int)
lea rdi, [rbp+var_1C]
lea rsi, [rbp+var_20]
call _ZNK5chess6SquareltERKS0_; chess::Square::operator<(chess::Square const&)
test al, 1
jnz short loc_1F60D
jmp loc_1F7CB
loc_1F60D:
mov rdi, [rbp+var_10]
mov eax, [rbp+var_1C]
mov [rbp+var_28], eax
mov esi, [rbp+var_28]
call _ZNK5chess5Board2atINS_5PieceEEET_NS_6SquareE; chess::Board::at<chess::Piece>(chess::Square)
mov [rbp+var_21], al
lea rdi, [rbp+var_21]; this
call _ZNK5chess5Piece4typeEv; chess::Piece::type(void)
mov [rbp+var_29], al
lea rdi, [rbp+var_2A]
mov esi, 6
call _ZN5chess9PieceTypeC2ENS0_10underlyingE; chess::PieceType::PieceType(chess::PieceType::underlying)
lea rdi, [rbp+var_29]
lea rsi, [rbp+var_2A]
call _ZNK5chess9PieceTypeeqERKS0_; chess::PieceType::operator==(chess::PieceType const&)
test al, 1
jnz short loc_1F64F
jmp short loc_1F654
loc_1F64F:
jmp loc_1F7B8
loc_1F654:
lea rdi, [rbp+var_21]; this
call _ZNK5chess5Piece5colorEv; chess::Piece::color(void)
mov [rbp+var_31], al
lea rdi, [rbp+var_32]
xor esi, esi
call _ZN5chess5ColorC2ENS0_10underlyingE; chess::Color::Color(chess::Color::underlying)
lea rdi, [rbp+var_31]
lea rsi, [rbp+var_32]
call _ZNK5chess5ColoreqERKS0_; chess::Color::operator==(chess::Color const&)
test al, 1
jnz short loc_1F67E
jmp short loc_1F68C
loc_1F67E:
lea rdi, [rbp+var_1C]; this
call _ZNK5chess6Square5indexEv; chess::Square::index(void)
mov [rbp+var_44], eax
jmp short loc_1F69F
loc_1F68C:
lea rdi, [rbp+var_1C]; this
call _ZNK5chess6Square5indexEv; chess::Square::index(void)
mov edi, eax; int
call _Z11mirrorIndexi; mirrorIndex(int)
mov [rbp+var_44], eax
loc_1F69F:
mov eax, [rbp+var_44]
mov [rbp+var_30], eax
mov [rbp+var_38], 0
lea rdi, [rbp+var_21]; this
call _ZNK5chess5Piece4typeEv; chess::Piece::type(void)
mov [rbp+var_39], al
lea rdi, [rbp+var_39]
call _ZNK5chess9PieceTypecviEv; chess::PieceType::operator int(void)
dec eax; switch 32 cases
mov ecx, eax
mov [rbp+var_50], rcx
sub eax, 1Fh
ja def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
mov rax, [rbp+var_50]
lea rcx, jpt_1F6E4
movsxd rax, ds:(jpt_1F6E4 - 25A10h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1F6E6:
movsxd rcx, [rbp+var_30]; jumptable 000000000001F6E4 case 1
lea rax, _ZL10PAWN_TABLE; PAWN_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_38], eax
jmp short def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
loc_1F6F9:
movsxd rcx, [rbp+var_30]; jumptable 000000000001F6E4 case 2
lea rax, _ZL12KNIGHT_TABLE; KNIGHT_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_38], eax
jmp short def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
loc_1F70C:
movsxd rcx, [rbp+var_30]; jumptable 000000000001F6E4 case 4
lea rax, _ZL12BISHOP_TABLE; BISHOP_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_38], eax
jmp short def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
loc_1F71F:
movsxd rcx, [rbp+var_30]; jumptable 000000000001F6E4 case 8
lea rax, _ZL10ROOK_TABLE; ROOK_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_38], eax
jmp short def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
loc_1F732:
movsxd rcx, [rbp+var_30]; jumptable 000000000001F6E4 case 16
lea rax, _ZL11QUEEN_TABLE; QUEEN_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_38], eax
jmp short def_1F6E4; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
loc_1F745:
test [rbp+var_11], 1; jumptable 000000000001F6E4 case 32
jz short loc_1F75E
movsxd rcx, [rbp+var_30]
lea rax, _ZL14KING_END_TABLE; KING_END_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_54], eax
jmp short loc_1F76F
loc_1F75E:
movsxd rcx, [rbp+var_30]
lea rax, _ZL17KING_MIDDLE_TABLE; KING_MIDDLE_TABLE
mov eax, [rax+rcx*4]
mov [rbp+var_54], eax
loc_1F76F:
mov eax, [rbp+var_54]
mov [rbp+var_38], eax
def_1F6E4:
lea rdi, [rbp+var_21]; jumptable 000000000001F6E4 default case, cases 3,5-7,9-15,17-31
call _ZNK5chess5Piece5colorEv; chess::Piece::color(void)
mov [rbp+var_3A], al
lea rdi, [rbp+var_3B]
xor esi, esi
call _ZN5chess5ColorC2ENS0_10underlyingE; chess::Color::Color(chess::Color::underlying)
lea rdi, [rbp+var_3A]
lea rsi, [rbp+var_3B]
call _ZNK5chess5ColoreqERKS0_; chess::Color::operator==(chess::Color const&)
test al, 1
jnz short loc_1F79F
jmp short loc_1F7A7
loc_1F79F:
mov eax, [rbp+var_38]
mov [rbp+var_58], eax
jmp short loc_1F7AF
loc_1F7A7:
xor eax, eax
sub eax, [rbp+var_38]
mov [rbp+var_58], eax
loc_1F7AF:
mov eax, [rbp+var_58]
add eax, [rbp+var_18]
mov [rbp+var_18], eax
loc_1F7B8:
lea rdi, [rbp+var_1C]
xor esi, esi
call _ZN5chess6SquareppEi; chess::Square::operator++(int)
mov [rbp+var_40], eax
jmp loc_1F5E9
loc_1F7CB:
mov eax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
|
long long Engine::evaluatePieceSquareTables(Engine *this, const chess::Board *a2, char a3)
{
int v3; // eax
int v5; // [rsp+8h] [rbp-58h]
int v6; // [rsp+Ch] [rbp-54h]
int v7; // [rsp+1Ch] [rbp-44h]
char v8; // [rsp+25h] [rbp-3Bh] BYREF
char v9; // [rsp+26h] [rbp-3Ah] BYREF
char v10; // [rsp+27h] [rbp-39h] BYREF
int v11; // [rsp+28h] [rbp-38h]
char v12; // [rsp+2Eh] [rbp-32h] BYREF
char v13; // [rsp+2Fh] [rbp-31h] BYREF
int v14; // [rsp+30h] [rbp-30h]
char v15; // [rsp+36h] [rbp-2Ah] BYREF
char v16; // [rsp+37h] [rbp-29h] BYREF
int v17; // [rsp+38h] [rbp-28h]
char v18; // [rsp+3Fh] [rbp-21h] BYREF
int v19; // [rsp+40h] [rbp-20h] BYREF
int v20; // [rsp+44h] [rbp-1Ch] BYREF
unsigned int v21; // [rsp+48h] [rbp-18h]
char v22; // [rsp+4Fh] [rbp-11h]
const chess::Board *v23; // [rsp+50h] [rbp-10h]
Engine *v24; // [rsp+58h] [rbp-8h]
v24 = this;
v23 = a2;
v22 = a3 & 1;
v21 = 0;
chess::Square::Square((chess::Square *)&v20, 0);
while ( 1 )
{
chess::Square::Square((chess::Square *)&v19, 64);
if ( !chess::Square::operator<(&v20, &v19) )
return v21;
v17 = v20;
v18 = chess::Board::at<chess::Piece>((long long)v23, v20);
v16 = chess::Piece::type((chess::Piece *)&v18);
chess::PieceType::PieceType(&v15, 6);
if ( !chess::PieceType::operator==(&v16, &v15) )
{
v13 = chess::Piece::color((chess::Piece *)&v18);
chess::Color::Color(&v12, 0);
if ( chess::Color::operator==(&v13, &v12) )
{
v7 = chess::Square::index((chess::Square *)&v20);
}
else
{
v3 = chess::Square::index((chess::Square *)&v20);
v7 = mirrorIndex(v3);
}
v14 = v7;
v11 = 0;
v10 = chess::Piece::type((chess::Piece *)&v18);
switch ( (unsigned int)chess::PieceType::operator int((unsigned __int8 *)&v10) )
{
case 1u:
v11 = PAWN_TABLE[v14];
break;
case 2u:
v11 = KNIGHT_TABLE[v14];
break;
case 4u:
v11 = BISHOP_TABLE[v14];
break;
case 8u:
v11 = ROOK_TABLE[v14];
break;
case 0x10u:
v11 = QUEEN_TABLE[v14];
break;
case 0x20u:
if ( (v22 & 1) != 0 )
v6 = KING_END_TABLE[v14];
else
v6 = KING_MIDDLE_TABLE[v14];
v11 = v6;
break;
default:
break;
}
v9 = chess::Piece::color((chess::Piece *)&v18);
chess::Color::Color(&v8, 0);
if ( chess::Color::operator==(&v9, &v8) )
v5 = v11;
else
v5 = -v11;
v21 += v5;
}
chess::Square::operator++((unsigned int *)&v20);
}
}
|
evaluatePieceSquareTables:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],0x0
LEA RDI,[RBP + -0x1c]
XOR ESI,ESI
CALL 0x001043a0
LAB_0011f5e9:
LEA RDI,[RBP + -0x20]
MOV ESI,0x40
CALL 0x001043a0
LEA RDI,[RBP + -0x1c]
LEA RSI,[RBP + -0x20]
CALL 0x00104e50
TEST AL,0x1
JNZ 0x0011f60d
JMP 0x0011f7cb
LAB_0011f60d:
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x28],EAX
MOV ESI,dword ptr [RBP + -0x28]
CALL 0x0010a5b0
MOV byte ptr [RBP + -0x21],AL
LEA RDI,[RBP + -0x21]
CALL 0x00109fb0
MOV byte ptr [RBP + -0x29],AL
LEA RDI,[RBP + -0x2a]
MOV ESI,0x6
CALL 0x0010a0b0
LEA RDI,[RBP + -0x29]
LEA RSI,[RBP + -0x2a]
CALL 0x0010a590
TEST AL,0x1
JNZ 0x0011f64f
JMP 0x0011f654
LAB_0011f64f:
JMP 0x0011f7b8
LAB_0011f654:
LEA RDI,[RBP + -0x21]
CALL 0x0010a030
MOV byte ptr [RBP + -0x31],AL
LEA RDI,[RBP + -0x32]
XOR ESI,ESI
CALL 0x00105e10
LEA RDI,[RBP + -0x31]
LEA RSI,[RBP + -0x32]
CALL 0x00107da0
TEST AL,0x1
JNZ 0x0011f67e
JMP 0x0011f68c
LAB_0011f67e:
LEA RDI,[RBP + -0x1c]
CALL 0x00104d40
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0011f69f
LAB_0011f68c:
LEA RDI,[RBP + -0x1c]
CALL 0x00104d40
MOV EDI,EAX
CALL 0x0011fca0
MOV dword ptr [RBP + -0x44],EAX
LAB_0011f69f:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x30],EAX
MOV dword ptr [RBP + -0x38],0x0
LEA RDI,[RBP + -0x21]
CALL 0x00109fb0
MOV byte ptr [RBP + -0x39],AL
LEA RDI,[RBP + -0x39]
CALL 0x0010a120
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,0x1f
JA 0x0011f775
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[0x125a10]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x126090]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011f775
caseD_2:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125a90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011f775
caseD_4:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125b90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011f775
caseD_8:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125c90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011f775
caseD_10:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125d90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x38],EAX
JMP 0x0011f775
caseD_20:
TEST byte ptr [RBP + -0x11],0x1
JZ 0x0011f75e
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125e90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0011f76f
LAB_0011f75e:
MOVSXD RCX,dword ptr [RBP + -0x30]
LEA RAX,[0x125f90]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV dword ptr [RBP + -0x54],EAX
LAB_0011f76f:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x38],EAX
caseD_3:
LEA RDI,[RBP + -0x21]
CALL 0x0010a030
MOV byte ptr [RBP + -0x3a],AL
LEA RDI,[RBP + -0x3b]
XOR ESI,ESI
CALL 0x00105e10
LEA RDI,[RBP + -0x3a]
LEA RSI,[RBP + -0x3b]
CALL 0x00107da0
TEST AL,0x1
JNZ 0x0011f79f
JMP 0x0011f7a7
LAB_0011f79f:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x58],EAX
JMP 0x0011f7af
LAB_0011f7a7:
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x58],EAX
LAB_0011f7af:
MOV EAX,dword ptr [RBP + -0x58]
ADD EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EAX
LAB_0011f7b8:
LEA RDI,[RBP + -0x1c]
XOR ESI,ESI
CALL 0x0010a650
MOV dword ptr [RBP + -0x40],EAX
JMP 0x0011f5e9
LAB_0011f7cb:
MOV EAX,dword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
/* Engine::evaluatePieceSquareTables(chess::Board const&, bool) */
int __thiscall Engine::evaluatePieceSquareTables(Engine *this,Board *param_1,bool param_2)
{
int iVar1;
ulong uVar2;
int local_60;
int local_5c;
int local_4c;
Color local_43;
Color local_42;
PieceType local_41;
int local_40;
Color local_3a;
Color local_39;
int local_38;
PieceType local_32;
PieceType local_31;
int4 local_30;
Piece local_29;
Square local_28 [4];
int4 local_24;
int local_20;
byte local_19;
Board *local_18;
Engine *local_10;
local_20 = 0;
local_19 = param_2;
local_18 = param_1;
local_10 = this;
chess::Square::Square((Square *)&local_24,0);
while( true ) {
chess::Square::Square(local_28,0x40);
uVar2 = chess::Square::operator<((Square *)&local_24,local_28);
if ((uVar2 & 1) == 0) break;
local_30 = local_24;
local_29 = (Piece)chess::Board::at<chess::Piece>(local_18,local_24);
local_31 = (PieceType)chess::Piece::type(&local_29);
chess::PieceType::PieceType(&local_32,6);
uVar2 = chess::PieceType::operator==(&local_31,&local_32);
if ((uVar2 & 1) == 0) {
local_39 = (Color)chess::Piece::color(&local_29);
chess::Color::Color(&local_3a,0);
uVar2 = chess::Color::operator==(&local_39,&local_3a);
if ((uVar2 & 1) == 0) {
iVar1 = chess::Square::index((Square *)&local_24);
local_4c = mirrorIndex(iVar1);
}
else {
local_4c = chess::Square::index((Square *)&local_24);
}
local_38 = local_4c;
local_40 = 0;
local_41 = (PieceType)chess::Piece::type(&local_29);
iVar1 = chess::PieceType::operator_cast_to_int(&local_41);
switch(iVar1) {
case 1:
local_40 = *(int *)(PAWN_TABLE + (long)local_38 * 4);
break;
case 2:
local_40 = *(int *)(KNIGHT_TABLE + (long)local_38 * 4);
break;
case 4:
local_40 = *(int *)(BISHOP_TABLE + (long)local_38 * 4);
break;
case 8:
local_40 = *(int *)(ROOK_TABLE + (long)local_38 * 4);
break;
case 0x10:
local_40 = *(int *)(QUEEN_TABLE + (long)local_38 * 4);
break;
case 0x20:
if ((local_19 & 1) == 0) {
local_5c = *(int *)(KING_MIDDLE_TABLE + (long)local_38 * 4);
}
else {
local_5c = *(int *)(KING_END_TABLE + (long)local_38 * 4);
}
local_40 = local_5c;
}
local_42 = (Color)chess::Piece::color(&local_29);
chess::Color::Color(&local_43,0);
uVar2 = chess::Color::operator==(&local_42,&local_43);
if ((uVar2 & 1) == 0) {
local_60 = -local_40;
}
else {
local_60 = local_40;
}
local_20 = local_60 + local_20;
}
chess::Square::operator++((Square *)&local_24,0);
}
return local_20;
}
|
|
60,051
|
ethash_keccak256
|
corpus-core[P]colibri-stateless/build_O3/_deps/ethhash_external-src/lib/keccak/keccak.c
|
union ethash_hash256 ethash_keccak256(const uint8_t* data, size_t size)
{
union ethash_hash256 hash;
keccak(hash.word64s, 256, data, size);
return hash;
}
|
O3
|
c
|
ethash_keccak256:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, (%rsp)
leaq 0x10(%rsp), %r14
movl $0xc8, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x21120
cmpq $0x88, %r15
jb 0x4f467
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r12, %rbp
xorl %ebx, %ebx
movq (%rbp,%rbx), %rax
xorq %rax, 0x10(%rsp,%rbx)
addq $0x8, %rbx
cmpq $0x88, %rbx
jne 0x4f428
movq %r13, %rdi
callq *0x6ede8(%rip) # 0xbe230
addq $-0x88, %r15
leaq (%rbx,%rbp), %r12
cmpq $0x88, %r15
jae 0x4f423
addq %rbx, %rbp
movq %rbp, %r12
movq 0x8(%rsp), %rbx
cmpq $0x8, %r15
jb 0x4f48b
leaq 0x10(%rsp), %r14
movq (%r12), %rax
xorq %rax, (%r14)
addq $0x8, %r14
addq $0x8, %r12
addq $-0x8, %r15
cmpq $0x7, %r15
ja 0x4f472
testq %r15, %r15
je 0x4f4a6
xorl %eax, %eax
movb (%r12,%rax), %cl
movb %cl, (%rsp,%rax)
incq %rax
cmpq %rax, %r15
jne 0x4f492
addq %rsp, %rax
jmp 0x4f4a9
movq %rsp, %rax
movb $0x1, (%rax)
movq (%rsp), %rax
xorq %rax, (%r14)
leaq 0x10(%rsp), %r14
xorb $-0x80, 0x87(%r14)
movq %r14, %rdi
callq *0x6ed67(%rip) # 0xbe230
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ethash_keccak256:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov [rsp+108h+var_108], 0
lea r14, [rsp+108h+var_F8]
mov edx, 0C8h
mov rdi, r14
xor esi, esi
call _memset
cmp r15, 88h
jb short loc_4F467
mov [rsp+108h+var_100], rbx
lea r13, [rsp+108h+var_F8]
loc_4F423:
mov rbp, r12
xor ebx, ebx
loc_4F428:
mov rax, [rbp+rbx+0]
xor [rsp+rbx+108h+var_F8], rax
add rbx, 8
cmp rbx, 88h
jnz short loc_4F428
mov rdi, r13
call cs:keccakf1600_best
add r15, 0FFFFFFFFFFFFFF78h
lea r12, [rbx+rbp]
cmp r15, 88h
jnb short loc_4F423
add rbp, rbx
mov r12, rbp
mov rbx, [rsp+108h+var_100]
loc_4F467:
cmp r15, 8
jb short loc_4F48B
lea r14, [rsp+108h+var_F8]
loc_4F472:
mov rax, [r12]
xor [r14], rax
add r14, 8
add r12, 8
add r15, 0FFFFFFFFFFFFFFF8h
cmp r15, 7
ja short loc_4F472
loc_4F48B:
test r15, r15
jz short loc_4F4A6
xor eax, eax
loc_4F492:
mov cl, [r12+rax]
mov byte ptr [rsp+rax+108h+var_108], cl
inc rax
cmp r15, rax
jnz short loc_4F492
add rax, rsp
jmp short loc_4F4A9
loc_4F4A6:
mov rax, rsp
loc_4F4A9:
mov byte ptr [rax], 1
mov rax, [rsp+108h+var_108]
xor [r14], rax
lea r14, [rsp+108h+var_F8]
xor byte ptr [r14+87h], 80h
mov rdi, r14
call cs:keccakf1600_best
movaps xmm0, xmmword ptr [r14]
movaps xmm1, xmmword ptr [r14+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov rax, rbx
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_OWORD * ethash_keccak256(_OWORD *a1, _QWORD *a2, unsigned long long a3)
{
_OWORD *v5; // rbx
_QWORD *v6; // r14
_QWORD *v7; // rbp
long long i; // rbx
long long v9; // rax
long long *v10; // rax
__int128 v11; // xmm0
long long v13; // [rsp+0h] [rbp-108h] BYREF
_OWORD *v14; // [rsp+8h] [rbp-100h]
_OWORD v15[8]; // [rsp+10h] [rbp-F8h] BYREF
char v16; // [rsp+97h] [rbp-71h]
v5 = a1;
v13 = 0LL;
v6 = v15;
memset(v15, 0LL, 200LL);
if ( a3 >= 0x88 )
{
v14 = a1;
do
{
v7 = a2;
for ( i = 0LL; i != 17; ++i )
*(_QWORD *)((char *)v15 + i * 8) ^= a2[i];
keccakf1600_best();
a3 -= 136LL;
a2 += 17;
}
while ( a3 >= 0x88 );
a2 = v7 + 17;
v5 = v14;
}
if ( a3 >= 8 )
{
v6 = v15;
do
{
*v6++ ^= *a2++;
a3 -= 8LL;
}
while ( a3 > 7 );
}
if ( a3 )
{
v9 = 0LL;
do
{
*((_BYTE *)&v13 + v9) = *((_BYTE *)a2 + v9);
++v9;
}
while ( a3 != v9 );
v10 = (long long *)((char *)&v13 + v9);
}
else
{
v10 = &v13;
}
*(_BYTE *)v10 = 1;
*v6 ^= v13;
v16 ^= 0x80u;
keccakf1600_best();
v11 = v15[0];
v5[1] = v15[1];
*v5 = v11;
return v5;
}
|
ethash_keccak256:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV qword ptr [RSP],0x0
LEA R14,[RSP + 0x10]
MOV EDX,0xc8
MOV RDI,R14
XOR ESI,ESI
CALL 0x00121120
CMP R15,0x88
JC 0x0014f467
MOV qword ptr [RSP + 0x8],RBX
LEA R13,[RSP + 0x10]
LAB_0014f423:
MOV RBP,R12
XOR EBX,EBX
LAB_0014f428:
MOV RAX,qword ptr [RBP + RBX*0x1]
XOR qword ptr [RSP + RBX*0x1 + 0x10],RAX
ADD RBX,0x8
CMP RBX,0x88
JNZ 0x0014f428
MOV RDI,R13
CALL qword ptr [0x001be230]
ADD R15,-0x88
LEA R12,[RBX + RBP*0x1]
CMP R15,0x88
JNC 0x0014f423
ADD RBP,RBX
MOV R12,RBP
MOV RBX,qword ptr [RSP + 0x8]
LAB_0014f467:
CMP R15,0x8
JC 0x0014f48b
LEA R14,[RSP + 0x10]
LAB_0014f472:
MOV RAX,qword ptr [R12]
XOR qword ptr [R14],RAX
ADD R14,0x8
ADD R12,0x8
ADD R15,-0x8
CMP R15,0x7
JA 0x0014f472
LAB_0014f48b:
TEST R15,R15
JZ 0x0014f4a6
XOR EAX,EAX
LAB_0014f492:
MOV CL,byte ptr [R12 + RAX*0x1]
MOV byte ptr [RSP + RAX*0x1],CL
INC RAX
CMP R15,RAX
JNZ 0x0014f492
ADD RAX,RSP
JMP 0x0014f4a9
LAB_0014f4a6:
MOV RAX,RSP
LAB_0014f4a9:
MOV byte ptr [RAX],0x1
MOV RAX,qword ptr [RSP]
XOR qword ptr [R14],RAX
LEA R14,[RSP + 0x10]
XOR byte ptr [R14 + 0x87],0x80
MOV RDI,R14
CALL qword ptr [0x001be230]
MOVAPS XMM0,xmmword ptr [R14]
MOVAPS XMM1,xmmword ptr [R14 + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV RAX,RBX
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong * ethash_keccak256(ulong *param_1,ulong *param_2,ulong param_3)
{
ulong uVar1;
ulong uVar2;
int8 *puVar3;
long lVar4;
ulong *puVar5;
ulong *__s;
int8 local_108;
ulong *local_100;
ulong local_f8 [16];
byte local_71;
puVar3 = &local_108;
local_108 = 0;
__s = local_f8;
memset(__s,0,200);
if (0x87 < param_3) {
local_100 = param_1;
do {
puVar5 = param_2;
lVar4 = 0;
do {
*(ulong *)((long)local_f8 + lVar4) =
*(ulong *)((long)local_f8 + lVar4) ^ *(ulong *)((long)puVar5 + lVar4);
lVar4 = lVar4 + 8;
} while (lVar4 != 0x88);
(*(code *)keccakf1600_best)(local_f8);
param_3 = param_3 - 0x88;
param_2 = puVar5 + 0x11;
} while (0x87 < param_3);
param_2 = puVar5 + 0x11;
param_1 = local_100;
}
if (7 < param_3) {
__s = local_f8;
do {
*__s = *__s ^ *param_2;
__s = __s + 1;
param_2 = param_2 + 1;
param_3 = param_3 - 8;
} while (7 < param_3);
}
if (param_3 != 0) {
uVar1 = 0;
do {
uVar2 = uVar1;
*(int1 *)((long)&local_108 + uVar2) = *(int1 *)((long)param_2 + uVar2);
uVar1 = uVar2 + 1;
} while (param_3 != uVar2 + 1);
puVar3 = (int8 *)((long)&local_108 + uVar2 + 1);
}
*(int1 *)puVar3 = 1;
*__s = *__s ^ local_108;
local_71 = local_71 ^ 0x80;
(*(code *)keccakf1600_best)(local_f8);
param_1[2] = local_f8[2];
param_1[3] = local_f8[3];
*param_1 = local_f8[0];
param_1[1] = local_f8[1];
return param_1;
}
|
|
60,052
|
my_malloc
|
eloqsql/mysys/my_malloc.c
|
void *my_malloc(PSI_memory_key key, size_t size, myf my_flags)
{
my_memory_header *mh;
void *point;
DBUG_ENTER("my_malloc");
DBUG_PRINT("my",("size: %zu flags: %lu", size, my_flags));
compile_time_assert(sizeof(my_memory_header) <= HEADER_SIZE);
if (!(my_flags & (MY_WME | MY_FAE)))
my_flags|= my_global_flags;
/* Safety */
if (!size)
size=1;
if (size > SIZE_T_MAX - 1024L*1024L*16L) /* Wrong call */
DBUG_RETURN(0);
/* We have to align size as we store MY_THREAD_SPECIFIC flag in the LSB */
size= ALIGN_SIZE(size);
if (DBUG_EVALUATE_IF("simulate_out_of_memory", 1, 0))
mh= NULL;
else
mh= (my_memory_header*) sf_malloc(size + HEADER_SIZE, my_flags);
if (mh == NULL)
{
my_errno=errno;
if (my_flags & MY_FAE)
error_handler_hook=fatal_error_handler_hook;
if (my_flags & (MY_FAE+MY_WME))
my_error(EE_OUTOFMEMORY, MYF(ME_BELL+ME_ERROR_LOG+ME_FATAL),size);
if (my_flags & MY_FAE)
abort();
point= NULL;
}
else
{
int flag= MY_TEST(my_flags & MY_THREAD_SPECIFIC);
mh->m_size= size | flag;
mh->m_key= PSI_CALL_memory_alloc(key, size, & mh->m_owner);
update_malloc_size(size + HEADER_SIZE, flag);
point= HEADER_TO_USER(mh);
if (my_flags & MY_ZEROFILL)
bzero(point, size);
else
TRASH_ALLOC(point, size);
}
DBUG_PRINT("exit",("ptr: %p", point));
DBUG_RETURN(point);
}
|
O0
|
c
|
my_malloc:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xf3a05
jmp 0xf3a07
jmp 0xf3a09
movq -0x20(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
jne 0xf3a29
leaq 0xb8f4ca(%rip), %rax # 0xc82ee8
movq (%rax), %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf3a38
movq $0x1, -0x18(%rbp)
cmpq $-0x1000001, -0x18(%rbp) # imm = 0xFEFFFFFF
jbe 0xf3a51
jmp 0xf3a44
movq $0x0, -0x8(%rbp)
jmp 0xf3ba8
movq -0x18(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x2a6c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xf3af6
callq 0x2a750
movl (%rax), %eax
movl %eax, -0x38(%rbp)
callq 0xf6250
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
andq $0x8, %rax
cmpq $0x0, %rax
je 0xf3ab3
leaq 0x1cc2d2(%rip), %rax # 0x2bfd78
movq (%rax), %rcx
leaq 0x1cc2c0(%rip), %rax # 0x2bfd70
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
andq $0x18, %rax
cmpq $0x0, %rax
je 0xf3ad6
movq -0x18(%rbp), %rdx
movl $0x5, %edi
movl $0x1044, %esi # imm = 0x1044
movb $0x0, %al
callq 0xefa80
movq -0x20(%rbp), %rax
andq $0x8, %rax
cmpq $0x0, %rax
je 0xf3ae9
callq 0x2a5d0
movq $0x0, -0x30(%rbp)
jmp 0xf3b9a
movq -0x20(%rbp), %rdx
andq $0x10000, %rdx # imm = 0x10000
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rax
orq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x1cc71c(%rip), %rax # 0x2c0248
movq (%rax), %rax
movq 0x3e0(%rax), %rax
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq *%rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0x1cc1cd(%rip), %rax # 0x2bfd20
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movl -0x34(%rbp), %ecx
movsbl %cl, %esi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0xf3b8e
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2a2b0
jmp 0xf3b98
jmp 0xf3b90
jmp 0xf3b92
jmp 0xf3b94
jmp 0xf3b96
jmp 0xf3b98
jmp 0xf3b9a
jmp 0xf3b9c
jmp 0xf3b9e
jmp 0xf3ba0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_malloc:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_F3A05:
jmp short $+2
loc_F3A07:
jmp short $+2
loc_F3A09:
mov rax, [rbp+var_20]
and rax, 18h
cmp rax, 0
jnz short loc_F3A29
lea rax, my_global_flags
mov rax, [rax]
or rax, [rbp+var_20]
mov [rbp+var_20], rax
loc_F3A29:
cmp [rbp+var_18], 0
jnz short loc_F3A38
mov [rbp+var_18], 1
loc_F3A38:
cmp [rbp+var_18], 0FFFFFFFFFEFFFFFFh
jbe short loc_F3A51
jmp short $+2
loc_F3A44:
mov [rbp+var_8], 0
jmp loc_F3BA8
loc_F3A51:
mov rax, [rbp+var_18]
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
add rdi, 18h
call _malloc
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_F3AF6
call ___errno_location
mov eax, [rax]
mov [rbp+var_38], eax
call _my_thread_var
mov ecx, [rbp+var_38]
mov [rax], ecx
mov rax, [rbp+var_20]
and rax, 8
cmp rax, 0
jz short loc_F3AB3
lea rax, fatal_error_handler_hook
mov rcx, [rax]
lea rax, error_handler_hook
mov [rax], rcx
loc_F3AB3:
mov rax, [rbp+var_20]
and rax, 18h
cmp rax, 0
jz short loc_F3AD6
mov rdx, [rbp+var_18]
mov edi, 5
mov esi, 1044h
mov al, 0
call my_error
loc_F3AD6:
mov rax, [rbp+var_20]
and rax, 8
cmp rax, 0
jz short loc_F3AE9
call _abort
loc_F3AE9:
mov [rbp+var_30], 0
jmp loc_F3B9A
loc_F3AF6:
mov rdx, [rbp+var_20]
and rdx, 10000h
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_34], eax
mov rcx, [rbp+var_18]
movsxd rax, [rbp+var_34]
or rcx, rax
mov rax, [rbp+var_28]
mov [rax+8], rcx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+3E0h]
mov edi, [rbp+var_C]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_28]
call rax
mov ecx, eax
mov rax, [rbp+var_28]
mov [rax+10h], ecx
mov rax, cs:update_malloc_size
mov rdi, [rbp+var_18]
add rdi, 18h
mov ecx, [rbp+var_34]
movsx esi, cl
call rax ; dummy
mov rax, [rbp+var_28]
add rax, 18h
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
and rax, 20h
cmp rax, 0
jz short loc_F3B8E
mov rdi, [rbp+var_30]
mov rdx, [rbp+var_18]
xor esi, esi
call _memset
jmp short loc_F3B98
loc_F3B8E:
jmp short $+2
loc_F3B90:
jmp short $+2
loc_F3B92:
jmp short $+2
loc_F3B94:
jmp short $+2
loc_F3B96:
jmp short $+2
loc_F3B98:
jmp short $+2
loc_F3B9A:
jmp short $+2
loc_F3B9C:
jmp short $+2
loc_F3B9E:
jmp short $+2
loc_F3BA0:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_F3BA8:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long my_malloc(unsigned int a1, const char *a2, int a3)
{
long long v3; // rdi
long long v4; // rdx
int v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+10h] [rbp-30h]
long long v8; // [rsp+18h] [rbp-28h]
int v9; // [rsp+20h] [rbp-20h]
unsigned long long v10; // [rsp+28h] [rbp-18h]
unsigned long long v11; // [rsp+28h] [rbp-18h]
v10 = (unsigned long long)a2;
v9 = a3;
if ( (a3 & 0x18) == 0 )
v9 = a3 | my_global_flags;
if ( !a2 )
v10 = 1LL;
if ( v10 > 0xFFFFFFFFFEFFFFFFLL )
return 0LL;
v11 = (v10 + 7) & 0xFFFFFFFFFFFFFFF8LL;
v3 = v11 + 24;
v8 = malloc(v11 + 24);
if ( v8 )
{
*(_QWORD *)(v8 + 8) = ((v9 & 0x10000) != 0) | v11;
*(_DWORD *)(v8 + 16) = ((long long ( *)(_QWORD, unsigned long long, long long))PSI_server[124])(a1, v11, v8);
update_malloc_size(v11 + 24, (v9 & 0x10000) != 0);
v7 = v8 + 24;
if ( (v9 & 0x20) != 0 )
memset(v7, 0LL, v11);
}
else
{
v6 = *(_DWORD *)__errno_location();
*(_DWORD *)my_thread_var(v3, a2) = v6;
if ( (v9 & 8) != 0 )
error_handler_hook = fatal_error_handler_hook[0];
if ( (v9 & 0x18) != 0 )
{
v3 = 5LL;
a2 = (_BYTE *)(&stru_1030 + 20);
my_error(5u, 4164LL, v11);
}
if ( (v9 & 8) != 0 )
abort(v3, a2, v4);
return 0LL;
}
return v7;
}
|
my_malloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x001f3a05
LAB_001f3a05:
JMP 0x001f3a07
LAB_001f3a07:
JMP 0x001f3a09
LAB_001f3a09:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x18
CMP RAX,0x0
JNZ 0x001f3a29
LEA RAX,[0xd82ee8]
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
LAB_001f3a29:
CMP qword ptr [RBP + -0x18],0x0
JNZ 0x001f3a38
MOV qword ptr [RBP + -0x18],0x1
LAB_001f3a38:
CMP qword ptr [RBP + -0x18],-0x1000001
JBE 0x001f3a51
JMP 0x001f3a44
LAB_001f3a44:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001f3ba8
LAB_001f3a51:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x0012a6c0
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001f3af6
CALL 0x0012a750
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
CALL 0x001f6250
MOV ECX,dword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x8
CMP RAX,0x0
JZ 0x001f3ab3
LEA RAX,[0x3bfd78]
MOV RCX,qword ptr [RAX]
LEA RAX,[0x3bfd70]
MOV qword ptr [RAX],RCX
LAB_001f3ab3:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x18
CMP RAX,0x0
JZ 0x001f3ad6
MOV RDX,qword ptr [RBP + -0x18]
MOV EDI,0x5
MOV ESI,0x1044
MOV AL,0x0
CALL 0x001efa80
LAB_001f3ad6:
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x8
CMP RAX,0x0
JZ 0x001f3ae9
CALL 0x0012a5d0
LAB_001f3ae9:
MOV qword ptr [RBP + -0x30],0x0
JMP 0x001f3b9a
LAB_001f3af6:
MOV RDX,qword ptr [RBP + -0x20]
AND RDX,0x10000
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RCX,qword ptr [RBP + -0x18]
MOVSXD RAX,dword ptr [RBP + -0x34]
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],RCX
LEA RAX,[0x3c0248]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3e0]
MOV EDI,dword ptr [RBP + -0xc]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
CALL RAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [0x003bfd20]
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
MOV ECX,dword ptr [RBP + -0x34]
MOVSX ESI,CL
CALL RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
AND RAX,0x20
CMP RAX,0x0
JZ 0x001f3b8e
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x0012a2b0
JMP 0x001f3b98
LAB_001f3b8e:
JMP 0x001f3b90
LAB_001f3b90:
JMP 0x001f3b92
LAB_001f3b92:
JMP 0x001f3b94
LAB_001f3b94:
JMP 0x001f3b96
LAB_001f3b96:
JMP 0x001f3b98
LAB_001f3b98:
JMP 0x001f3b9a
LAB_001f3b9a:
JMP 0x001f3b9c
LAB_001f3b9c:
JMP 0x001f3b9e
LAB_001f3b9e:
JMP 0x001f3ba0
LAB_001f3ba0:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_001f3ba8:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
void * my_malloc(int4 param_1,ulong param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
ulong __n;
int *piVar3;
void *local_38;
ulong local_28;
ulong local_20;
void *local_10;
local_28 = param_3;
if ((param_3 & 0x18) == 0) {
local_28 = my_global_flags | param_3;
}
local_20 = param_2;
if (param_2 == 0) {
local_20 = 1;
}
if (local_20 < 0xffffffffff000000) {
__n = local_20 + 7 & 0xfffffffffffffff8;
local_38 = malloc(__n + 0x18);
if (local_38 == (void *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((local_28 & 8) != 0) {
error_handler_hook = fatal_error_handler_hook;
}
if ((local_28 & 0x18) != 0) {
my_error(5,0x1044,__n);
}
if ((local_28 & 8) != 0) {
/* WARNING: Subroutine does not return */
abort();
}
local_38 = (void *)0x0;
}
else {
*(ulong *)((long)local_38 + 8) = __n | (long)(int)(uint)((local_28 & 0x10000) != 0);
uVar2 = (**(code **)(PSI_server + 0x3e0))(param_1,__n,local_38);
*(int4 *)((long)local_38 + 0x10) = uVar2;
(*(code *)update_malloc_size)(__n + 0x18);
local_38 = (void *)((long)local_38 + 0x18);
if ((local_28 & 0x20) != 0) {
memset(local_38,0,__n);
}
}
local_10 = local_38;
}
else {
local_10 = (void *)0x0;
}
return local_10;
}
|
|
60,053
|
bf_mul_pow_radix
|
bluesky950520[P]quickjs/libbf.c
|
int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
slimb_t expn, limb_t prec, bf_flags_t flags)
{
int ret, expn_sign, overflow;
slimb_t e, extra_bits, prec1, ziv_extra_bits;
bf_t B_s, *B = &B_s;
if (T->len == 0) {
return bf_set(r, T);
} else if (expn == 0) {
ret = bf_set(r, T);
ret |= bf_round(r, prec, flags);
return ret;
}
e = expn;
expn_sign = 0;
if (e < 0) {
e = -e;
expn_sign = 1;
}
bf_init(r->ctx, B);
if (prec == BF_PREC_INF) {
/* infinite precision: only used if the result is known to be exact */
ret = bf_pow_ui_ui(B, radix, e, BF_PREC_INF, BF_RNDN);
if (expn_sign) {
ret |= bf_div(r, T, B, T->len * LIMB_BITS, BF_RNDN);
} else {
ret |= bf_mul(r, T, B, BF_PREC_INF, BF_RNDN);
}
} else {
ziv_extra_bits = 16;
for(;;) {
prec1 = prec + ziv_extra_bits;
/* XXX: correct overflow/underflow handling */
/* XXX: rigorous error analysis needed */
extra_bits = ceil_log2(e) * 2 + 1;
ret = bf_pow_ui_ui(B, radix, e, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
overflow = !bf_is_finite(B);
/* XXX: if bf_pow_ui_ui returns an exact result, can stop
after the next operation */
if (expn_sign)
ret |= bf_div(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
else
ret |= bf_mul(r, T, B, prec1 + extra_bits, BF_RNDN | BF_FLAG_EXT_EXP);
if (ret & BF_ST_MEM_ERROR)
break;
if ((ret & BF_ST_INEXACT) &&
!bf_can_round(r, prec, flags & BF_RND_MASK, prec1) &&
!overflow) {
/* and more precision and retry */
ziv_extra_bits = ziv_extra_bits + (ziv_extra_bits / 2);
} else {
/* XXX: need to use __bf_round() to pass the inexact
flag for the subnormal case */
ret = bf_round(r, prec, flags) | (ret & BF_ST_INEXACT);
break;
}
}
}
bf_delete(B);
return ret;
}
|
O0
|
c
|
bf_mul_pow_radix:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xeb735
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xe62c0
movl %eax, 0x94(%rsp)
jmp 0xeba04
cmpq $0x0, 0x70(%rsp)
jne 0xeb784
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xe62c0
movl %eax, 0x60(%rsp)
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
callq 0xe6d10
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x94(%rsp)
jmp 0xeba04
jmp 0xeb786
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x0, 0x5c(%rsp)
cmpq $0x0, 0x50(%rsp)
jge 0xeb7b4
xorl %eax, %eax
subq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movl $0x1, 0x5c(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xe5f70
movabsq $0x3fffffffffffffff, %rax # imm = 0x3FFFFFFFFFFFFFFF
cmpq %rax, 0x68(%rsp)
jne 0xeb875
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x50(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
xorl %r8d, %r8d
callq 0xeba20
movl %eax, 0x60(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0xeb841
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x80(%rsp), %rax
movq 0x18(%rax), %rcx
shlq $0x6, %rcx
xorl %r8d, %r8d
callq 0xea3d0
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xeb870
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movabsq $0x3fffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFFF
xorl %r8d, %r8d
callq 0xe8680
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xeb9ef
movq $0x10, 0x38(%rsp)
movq 0x68(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xebad0
shll %eax
addl $0x1, %eax
cltq
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xeba20
movl %eax, 0x60(%rsp)
movq 0x8(%rsp), %rdi
callq 0xeaf60
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x58(%rsp)
cmpl $0x0, 0x5c(%rsp)
je 0xeb921
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xea3d0
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
jmp 0xeb953
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x40(%rsp), %rcx
addq 0x48(%rsp), %rcx
movl $0x7e0, %r8d # imm = 0x7E0
callq 0xe8680
orl 0x60(%rsp), %eax
movl %eax, 0x60(%rsp)
movl 0x60(%rsp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xeb964
jmp 0xeb9ed
movl 0x60(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xeb9c3
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
andl $0x7, %edx
movq 0x40(%rsp), %rcx
callq 0xe6ae0
cmpl $0x0, %eax
jne 0xeb9c3
cmpl $0x0, 0x58(%rsp)
jne 0xeb9c3
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x38(%rsp)
jmp 0xeb9e8
movq 0x88(%rsp), %rdi
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
callq 0xe6d10
movl 0x60(%rsp), %ecx
andl $0x10, %ecx
orl %ecx, %eax
movl %eax, 0x60(%rsp)
jmp 0xeb9ed
jmp 0xeb87e
jmp 0xeb9ef
movq 0x8(%rsp), %rdi
callq 0xe93d0
movl 0x60(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
|
bf_mul_pow_radix:
sub rsp, 98h
mov [rsp+98h+var_10], rdi
mov [rsp+98h+var_18], rsi
mov [rsp+98h+var_20], rdx
mov [rsp+98h+var_28], rcx
mov [rsp+98h+var_30], r8
mov [rsp+98h+var_34], r9d
lea rax, [rsp+98h+var_88]
mov [rsp+98h+var_90], rax
mov rax, [rsp+98h+var_18]
cmp qword ptr [rax+18h], 0
jnz short loc_EB735
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
call bf_set
mov [rsp+98h+var_4], eax
jmp loc_EBA04
loc_EB735:
cmp [rsp+98h+var_28], 0
jnz short loc_EB784
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
call bf_set
mov [rsp+98h+var_38], eax
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
call bf_round
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
mov eax, [rsp+98h+var_38]
mov [rsp+98h+var_4], eax
jmp loc_EBA04
loc_EB784:
jmp short $+2
loc_EB786:
mov rax, [rsp+98h+var_28]
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_3C], 0
cmp [rsp+98h+var_48], 0
jge short loc_EB7B4
xor eax, eax
sub rax, [rsp+98h+var_48]
mov [rsp+98h+var_48], rax
mov [rsp+98h+var_3C], 1
loc_EB7B4:
mov rax, [rsp+98h+var_10]
mov rdi, [rax]
mov rsi, [rsp+98h+var_90]
call bf_init
mov rax, 3FFFFFFFFFFFFFFFh
cmp [rsp+98h+var_30], rax
jnz loc_EB875
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_48]
mov rcx, 3FFFFFFFFFFFFFFFh
xor r8d, r8d
call bf_pow_ui_ui
mov [rsp+98h+var_38], eax
cmp [rsp+98h+var_3C], 0
jz short loc_EB841
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rax, [rsp+98h+var_18]
mov rcx, [rax+18h]
shl rcx, 6
xor r8d, r8d
call bf_div
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
jmp short loc_EB870
loc_EB841:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, 3FFFFFFFFFFFFFFFh
xor r8d, r8d
call bf_mul
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
loc_EB870:
jmp loc_EB9EF
loc_EB875:
mov [rsp+98h+var_60], 10h
loc_EB87E:
mov rax, [rsp+98h+var_30]
add rax, [rsp+98h+var_60]
mov [rsp+98h+var_58], rax
mov rdi, [rsp+98h+var_48]
call ceil_log2
shl eax, 1
add eax, 1
cdqe
mov [rsp+98h+var_50], rax
mov rdi, [rsp+98h+var_90]
mov rsi, [rsp+98h+var_20]
mov rdx, [rsp+98h+var_48]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_pow_ui_ui
mov [rsp+98h+var_38], eax
mov rdi, [rsp+98h+var_90]
call bf_is_finite_0
cmp eax, 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rsp+98h+var_40], eax
cmp [rsp+98h+var_3C], 0
jz short loc_EB921
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_div
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
jmp short loc_EB953
loc_EB921:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_18]
mov rdx, [rsp+98h+var_90]
mov rcx, [rsp+98h+var_58]
add rcx, [rsp+98h+var_50]
mov r8d, 7E0h
call bf_mul
or eax, [rsp+98h+var_38]
mov [rsp+98h+var_38], eax
loc_EB953:
mov eax, [rsp+98h+var_38]
and eax, 20h
cmp eax, 0
jz short loc_EB964
jmp loc_EB9ED
loc_EB964:
mov eax, [rsp+98h+var_38]
and eax, 10h
cmp eax, 0
jz short loc_EB9C3
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
and edx, 7
mov rcx, [rsp+98h+var_58]
call bf_can_round
cmp eax, 0
jnz short loc_EB9C3
cmp [rsp+98h+var_40], 0
jnz short loc_EB9C3
mov rax, [rsp+98h+var_60]
mov [rsp+98h+var_98], rax
mov rax, [rsp+98h+var_60]
mov ecx, 2
cqo
idiv rcx
mov rcx, rax
mov rax, [rsp+98h+var_98]
add rax, rcx
mov [rsp+98h+var_60], rax
jmp short loc_EB9E8
loc_EB9C3:
mov rdi, [rsp+98h+var_10]
mov rsi, [rsp+98h+var_30]
mov edx, [rsp+98h+var_34]
call bf_round
mov ecx, [rsp+98h+var_38]
and ecx, 10h
or eax, ecx
mov [rsp+98h+var_38], eax
jmp short loc_EB9ED
loc_EB9E8:
jmp loc_EB87E
loc_EB9ED:
jmp short $+2
loc_EB9EF:
mov rdi, [rsp+98h+var_90]
call bf_delete_0
mov eax, [rsp+98h+var_38]
mov [rsp+98h+var_4], eax
loc_EBA04:
mov eax, [rsp+98h+var_4]
add rsp, 98h
retn
|
long long bf_mul_pow_radix(long long *a1, long long *a2, long long a3, long long a4, long long a5, unsigned int a6)
{
long long *v6; // rsi
int v7; // eax
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
int v12; // eax
int v13; // eax
long long v15[5]; // [rsp+10h] [rbp-88h] BYREF
long long i; // [rsp+38h] [rbp-60h]
long long v17; // [rsp+40h] [rbp-58h]
long long v18; // [rsp+48h] [rbp-50h]
long long v19; // [rsp+50h] [rbp-48h]
BOOL v20; // [rsp+58h] [rbp-40h]
int v21; // [rsp+5Ch] [rbp-3Ch]
unsigned int v22; // [rsp+60h] [rbp-38h]
unsigned int v23; // [rsp+64h] [rbp-34h]
long long *v24; // [rsp+68h] [rbp-30h]
long long v25; // [rsp+70h] [rbp-28h]
long long v26; // [rsp+78h] [rbp-20h]
long long *v27; // [rsp+80h] [rbp-18h]
long long *v28; // [rsp+88h] [rbp-10h]
v28 = a1;
v27 = a2;
v26 = a3;
v25 = a4;
v24 = (long long *)a5;
v23 = a6;
if ( a2[3] )
{
if ( v25 )
{
v19 = v25;
v21 = 0;
if ( v25 < 0 )
{
v19 = -v19;
v21 = 1;
}
bf_init(*v28, (long long)v15);
if ( v24 == (long long *)0x3FFFFFFFFFFFFFFFLL )
{
v22 = bf_pow_ui_ui(v15, v26, v19, 0x3FFFFFFFFFFFFFFFLL, 0LL);
v6 = v27;
if ( v21 )
v7 = bf_div(v28, v27, v15, v27[3] << 6, 0);
else
v7 = bf_mul(v28, (long long)v27, (long long)v15, 0x3FFFFFFFFFFFFFFFLL, 0);
v22 |= v7;
}
else
{
for ( i = 16LL; ; i += i / 2 )
{
v17 = (long long)v24 + i;
v18 = (int)(2 * ceil_log2(v19) + 1);
v22 = bf_pow_ui_ui(v15, v26, v19, v18 + v17, 2016LL);
v20 = !bf_is_finite_0((long long)v15);
v6 = v27;
v12 = v21
? bf_div(v28, v27, v15, v18 + v17, 0x7E0u)
: bf_mul(v28, (long long)v27, (long long)v15, v18 + v17, 0x7E0u);
v22 |= v12;
if ( (v22 & 0x20) != 0 )
break;
if ( (v22 & 0x10) == 0 || bf_can_round(v28, (long long)v24, v23 & 7, v17) || v20 )
{
v6 = v24;
v13 = bf_round(v28, (long long)v24, v23);
v9 = v22 & 0x10;
v22 = v9 | v13;
break;
}
}
}
bf_delete_0(v15, (long long)v6, v8, v9, v10, v11);
return v22;
}
else
{
v22 = bf_set((long long)v28, (long long)v27);
return (unsigned int)(v22 | bf_round(v28, (long long)v24, v23));
}
}
else
{
return (unsigned int)bf_set((long long)v28, (long long)v27);
}
}
|
bf_mul_pow_radix:
SUB RSP,0x98
MOV qword ptr [RSP + 0x88],RDI
MOV qword ptr [RSP + 0x80],RSI
MOV qword ptr [RSP + 0x78],RDX
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x68],R8
MOV dword ptr [RSP + 0x64],R9D
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RAX,qword ptr [RSP + 0x80]
CMP qword ptr [RAX + 0x18],0x0
JNZ 0x001eb735
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001e62c0
MOV dword ptr [RSP + 0x94],EAX
JMP 0x001eba04
LAB_001eb735:
CMP qword ptr [RSP + 0x70],0x0
JNZ 0x001eb784
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
CALL 0x001e62c0
MOV dword ptr [RSP + 0x60],EAX
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
CALL 0x001e6d10
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
MOV EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x94],EAX
JMP 0x001eba04
LAB_001eb784:
JMP 0x001eb786
LAB_001eb786:
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x5c],0x0
CMP qword ptr [RSP + 0x50],0x0
JGE 0x001eb7b4
XOR EAX,EAX
SUB RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x50],RAX
MOV dword ptr [RSP + 0x5c],0x1
LAB_001eb7b4:
MOV RAX,qword ptr [RSP + 0x88]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001e5f70
MOV RAX,0x3fffffffffffffff
CMP qword ptr [RSP + 0x68],RAX
JNZ 0x001eb875
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,0x3fffffffffffffff
XOR R8D,R8D
CALL 0x001eba20
MOV dword ptr [RSP + 0x60],EAX
CMP dword ptr [RSP + 0x5c],0x0
JZ 0x001eb841
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x80]
MOV RCX,qword ptr [RAX + 0x18]
SHL RCX,0x6
XOR R8D,R8D
CALL 0x001ea3d0
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001eb870
LAB_001eb841:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,0x3fffffffffffffff
XOR R8D,R8D
CALL 0x001e8680
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
LAB_001eb870:
JMP 0x001eb9ef
LAB_001eb875:
MOV qword ptr [RSP + 0x38],0x10
LAB_001eb87e:
MOV RAX,qword ptr [RSP + 0x68]
ADD RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x001ebad0
SHL EAX,0x1
ADD EAX,0x1
CDQE
MOV qword ptr [RSP + 0x48],RAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x78]
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001eba20
MOV dword ptr [RSP + 0x60],EAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001eaf60
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x58],EAX
CMP dword ptr [RSP + 0x5c],0x0
JZ 0x001eb921
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001ea3d0
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001eb953
LAB_001eb921:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x40]
ADD RCX,qword ptr [RSP + 0x48]
MOV R8D,0x7e0
CALL 0x001e8680
OR EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x60],EAX
LAB_001eb953:
MOV EAX,dword ptr [RSP + 0x60]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001eb964
JMP 0x001eb9ed
LAB_001eb964:
MOV EAX,dword ptr [RSP + 0x60]
AND EAX,0x10
CMP EAX,0x0
JZ 0x001eb9c3
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
AND EDX,0x7
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x001e6ae0
CMP EAX,0x0
JNZ 0x001eb9c3
CMP dword ptr [RSP + 0x58],0x0
JNZ 0x001eb9c3
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV ECX,0x2
CQO
IDIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RSP]
ADD RAX,RCX
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001eb9e8
LAB_001eb9c3:
MOV RDI,qword ptr [RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,dword ptr [RSP + 0x64]
CALL 0x001e6d10
MOV ECX,dword ptr [RSP + 0x60]
AND ECX,0x10
OR EAX,ECX
MOV dword ptr [RSP + 0x60],EAX
JMP 0x001eb9ed
LAB_001eb9e8:
JMP 0x001eb87e
LAB_001eb9ed:
JMP 0x001eb9ef
LAB_001eb9ef:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001e93d0
MOV EAX,dword ptr [RSP + 0x60]
MOV dword ptr [RSP + 0x94],EAX
LAB_001eba04:
MOV EAX,dword ptr [RSP + 0x94]
ADD RSP,0x98
RET
|
uint bf_mul_pow_radix(int8 *param_1,long param_2,int8 param_3,long param_4,long param_5,
uint param_6)
{
uint uVar1;
int iVar2;
int1 local_88 [40];
long local_60;
long local_58;
long local_50;
long local_48;
uint local_40;
uint local_3c;
uint local_38;
uint local_34;
long local_30;
long local_28;
int8 local_20;
long local_18;
int8 *local_10;
uint local_4;
local_34 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (*(long *)(param_2 + 0x18) == 0) {
local_4 = bf_set(param_1,param_2);
}
else if (param_4 == 0) {
local_38 = bf_set(param_1,param_2);
local_4 = bf_round(local_10,local_30,local_34);
local_4 = local_4 | local_38;
}
else {
local_48 = param_4;
if (param_4 < 0) {
local_48 = -param_4;
}
local_3c = (uint)(param_4 < 0);
bf_init(*param_1,local_88);
if (local_30 == 0x3fffffffffffffff) {
local_38 = bf_pow_ui_ui(local_88,local_20,local_48,0x3fffffffffffffff,0);
if (local_3c == 0) {
uVar1 = bf_mul(local_10,local_18,local_88,0x3fffffffffffffff,0);
local_38 = uVar1 | local_38;
}
else {
uVar1 = bf_div(local_10,local_18,local_88,*(long *)(local_18 + 0x18) << 6,0);
local_38 = uVar1 | local_38;
}
}
else {
local_60 = 0x10;
while( true ) {
local_58 = local_30 + local_60;
iVar2 = ceil_log2(local_48);
local_50 = (long)(iVar2 * 2 + 1);
local_38 = bf_pow_ui_ui(local_88,local_20,local_48,local_58 + local_50,0x7e0);
iVar2 = bf_is_finite(local_88);
local_40 = (uint)((iVar2 != 0 ^ 0xffU) & 1);
if (local_3c == 0) {
uVar1 = bf_mul(local_10,local_18,local_88,local_58 + local_50,0x7e0);
local_38 = uVar1 | local_38;
}
else {
uVar1 = bf_div(local_10,local_18,local_88,local_58 + local_50,0x7e0);
local_38 = uVar1 | local_38;
}
if ((local_38 & 0x20) != 0) goto LAB_001eb9ef;
if ((((local_38 & 0x10) == 0) ||
(iVar2 = bf_can_round(local_10,local_30,local_34 & 7,local_58), iVar2 != 0)) ||
(local_40 != 0)) break;
local_60 = local_60 + local_60 / 2;
}
uVar1 = bf_round(local_10,local_30,local_34);
local_38 = uVar1 | local_38 & 0x10;
}
LAB_001eb9ef:
bf_delete(local_88);
local_4 = local_38;
}
return local_4;
}
|
|
60,054
|
mi_pack_get_block_info
|
eloqsql/storage/myisam/mi_packrec.c
|
uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info, uchar **rec_buff_p,
File file, my_off_t filepos)
{
uchar *header=info->header;
uint head_length, UNINIT_VAR(ref_length);
if (file >= 0)
{
ref_length=myisam->s->pack.ref_length;
/*
We can't use mysql_file_pread() here because mi_read_rnd_pack_record
assumes position is ok
*/
mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, header, ref_length, MYF(MY_NABP)))
return BLOCK_FATAL_ERROR;
DBUG_DUMP("header",(uchar*) header,ref_length);
}
head_length= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
head_length+= read_pack_length((uint) myisam->s->pack.version,
header + head_length, &info->blob_len);
/*
Ensure that the record buffer is big enough for the compressed
record plus all expanded blobs. [We do not have an extra buffer
for the resulting blobs. Sigh.]
*/
if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
rec_buff_p)))
return BLOCK_FATAL_ERROR; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p + info->rec_len;
bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
myisam->blob_length=info->blob_len;
}
info->filepos=filepos+head_length;
if (file > 0)
{
info->offset=MY_MIN(info->rec_len, ref_length - head_length);
memcpy(*rec_buff_p, header + head_length, info->offset);
}
return 0;
}
|
O3
|
c
|
mi_pack_get_block_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
testl %r8d, %r8d
movq %r9, -0x48(%rbp)
js 0x8884f
movq %r9, %r15
movq %rcx, -0x30(%rbp)
movq (%r14), %rax
movl 0x240(%rax), %r13d
leaq 0x30b290(%rip), %rax # 0x393a58
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x889b1
movl %r12d, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xab33c
leaq 0x30b259(%rip), %rax # 0x393a58
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %r13, -0x38(%rbp)
jne 0x889c4
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xaad5c
movq %rax, %r13
movl $0x20, %r15d
testq %r13, %r13
movq -0x30(%rbp), %rcx
jne 0x8899f
jmp 0x88853
movq %rax, -0x38(%rbp)
movzbl (%rbx), %esi
cmpq $0xfd, %rsi
ja 0x8886b
movl $0x1, %r15d
movq -0x38(%rbp), %rdi
jmp 0x888ae
cmpl $0xfe, %esi
movq -0x38(%rbp), %rdi
jne 0x88883
movzwl 0x1(%rbx), %esi
movl $0x3, %r15d
jmp 0x888ae
movq (%r14), %rax
cmpb $0x1, 0x244(%rax)
jne 0x888a5
movzwl 0x1(%rbx), %eax
movzbl 0x3(%rbx), %esi
shll $0x10, %esi
orq %rax, %rsi
movl $0x4, %r15d
jmp 0x888ae
movl 0x1(%rbx), %esi
movl $0x5, %r15d
movq %rsi, 0x18(%rbx)
movq (%r14), %rdx
cmpl $0x0, 0x188(%rdx)
je 0x88964
movl %r15d, %edi
movzbl (%rbx,%rdi), %eax
cmpq $0xfd, %rax
ja 0x888da
movl $0x1, -0x30(%rbp)
jmp 0x8891c
cmpl $0xfe, %eax
jne 0x888ef
movzwl 0x1(%rbx,%rdi), %eax
movl $0x3, -0x30(%rbp)
jmp 0x8891c
cmpb $0x1, 0x244(%rdx)
jne 0x88911
movzwl 0x1(%rbx,%rdi), %edx
movzbl 0x3(%rbx,%rdi), %eax
shll $0x10, %eax
orq %rdx, %rax
movl $0x4, -0x30(%rbp)
jmp 0x8891c
movl 0x1(%rbx,%rdi), %eax
movl $0x5, -0x30(%rbp)
movq %rax, 0x30(%rbx)
addq %rax, %rsi
movq %r14, %rdi
movq %rcx, %rdx
movq %rcx, %r13
callq 0x86af5
testq %rax, %rax
je 0x88999
movq (%r13), %rax
addq 0x18(%rbx), %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x18(%rcx)
addq 0x30(%rbx), %rax
addl -0x30(%rbp), %r15d
movq %rax, 0x20(%rcx)
movq 0x30(%rbx), %rax
movq %rax, 0x1b8(%r14)
movq %r13, %rcx
movq -0x38(%rbp), %rdi
movl %r15d, %eax
movq -0x48(%rbp), %rdx
addq %rax, %rdx
movq %rdx, 0x38(%rbx)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x8899f
movq 0x18(%rbx), %rdx
subl %eax, %edi
cmpq %rdi, %rdx
cmovael %edi, %edx
movl %edx, 0x54(%rbx)
movq (%rcx), %rdi
addq %rax, %rbx
movq %rbx, %rsi
callq 0x2a0a0
jmp 0x8899f
movl $0x20, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x2f6b4
jmp 0x887f8
movq %rax, %r15
leaq 0x30b08a(%rip), %rax # 0x393a58
movq (%rax), %rax
leaq 0x5ef0b(%rip), %rdx # 0xe78e3
movq %r15, %rdi
movq %r13, %rsi
movl $0x566, %ecx # imm = 0x566
callq *0x210(%rax)
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xaad5c
movq %r13, %rcx
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
cmoveq %rcx, %rsi
leaq 0x30b046(%rip), %rax # 0x393a58
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x8883a
|
_mi_pack_get_block_info:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov rbx, rdx
mov [rbp+var_40], rsi
mov r14, rdi
test r8d, r8d
mov [rbp+var_48], r9
js loc_8884F
mov r15, r9
mov [rbp+var_30], rcx
mov rax, [r14]
mov r13d, [rax+240h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_889B1
mov edi, r12d
mov rsi, r15
xor edx, edx
xor ecx, ecx
call my_seek
loc_887F8:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_38], r13
jnz loc_889C4
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov r13, rax
loc_8883A:
mov r15d, 20h ; ' '
test r13, r13
mov rcx, [rbp+var_30]
jnz loc_8899F
jmp short loc_88853
loc_8884F:
mov [rbp+var_38], rax
loc_88853:
movzx esi, byte ptr [rbx]
cmp rsi, 0FDh
ja short loc_8886B
mov r15d, 1
mov rdi, [rbp+var_38]
jmp short loc_888AE
loc_8886B:
cmp esi, 0FEh
mov rdi, [rbp+var_38]
jnz short loc_88883
movzx esi, word ptr [rbx+1]
mov r15d, 3
jmp short loc_888AE
loc_88883:
mov rax, [r14]
cmp byte ptr [rax+244h], 1
jnz short loc_888A5
movzx eax, word ptr [rbx+1]
movzx esi, byte ptr [rbx+3]
shl esi, 10h
or rsi, rax
mov r15d, 4
jmp short loc_888AE
loc_888A5:
mov esi, [rbx+1]
mov r15d, 5
loc_888AE:
mov [rbx+18h], rsi
mov rdx, [r14]
cmp dword ptr [rdx+188h], 0
jz loc_88964
mov edi, r15d
movzx eax, byte ptr [rbx+rdi]
cmp rax, 0FDh
ja short loc_888DA
mov dword ptr [rbp+var_30], 1
jmp short loc_8891C
loc_888DA:
cmp eax, 0FEh
jnz short loc_888EF
movzx eax, word ptr [rbx+rdi+1]
mov dword ptr [rbp+var_30], 3
jmp short loc_8891C
loc_888EF:
cmp byte ptr [rdx+244h], 1
jnz short loc_88911
movzx edx, word ptr [rbx+rdi+1]
movzx eax, byte ptr [rbx+rdi+3]
shl eax, 10h
or rax, rdx
mov dword ptr [rbp+var_30], 4
jmp short loc_8891C
loc_88911:
mov eax, [rbx+rdi+1]
mov dword ptr [rbp+var_30], 5
loc_8891C:
mov [rbx+30h], rax
add rsi, rax
mov rdi, r14
mov rdx, rcx
mov r13, rcx
call mi_alloc_rec_buff
test rax, rax
jz short loc_88999
mov rax, [r13+0]
add rax, [rbx+18h]
mov rcx, [rbp+var_40]
mov [rcx+18h], rax
add rax, [rbx+30h]
add r15d, dword ptr [rbp+var_30]
mov [rcx+20h], rax
mov rax, [rbx+30h]
mov [r14+1B8h], rax
mov rcx, r13
mov rdi, [rbp+var_38]
loc_88964:
mov eax, r15d
mov rdx, [rbp+var_48]
add rdx, rax
mov [rbx+38h], rdx
xor r15d, r15d
test r12d, r12d
jle short loc_8899F
mov rdx, [rbx+18h]
sub edi, eax
cmp rdx, rdi
cmovnb edx, edi
mov [rbx+54h], edx
mov rdi, [rcx]
add rbx, rax
mov rsi, rbx
call _memcpy
jmp short loc_8899F
loc_88999:
mov r15d, 20h ; ' '
loc_8899F:
mov eax, r15d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_889B1:
mov rdi, rax
mov esi, r12d
mov rdx, r15
call _mi_pack_get_block_info_cold_1
jmp loc_887F8
loc_889C4:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_19; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r13
mov ecx, 566h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov rcx, r13
mov r13, rax
xor esi, esi
test rax, rax
cmovz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_8883A
|
long long mi_pack_get_block_info(
long long *a1,
long long a2,
unsigned __int8 *a3,
_QWORD *a4,
unsigned int a5,
long long a6)
{
long long v6; // rax
long long v11; // r13
long long v12; // rax
long long v13; // rax
long long v14; // r13
unsigned int v15; // r15d
unsigned long long v16; // rsi
unsigned int v17; // r15d
int v18; // edi
unsigned long long v19; // rax
_QWORD *v20; // r13
long long v21; // rax
long long v22; // rcx
long long v23; // rax
unsigned long long v24; // rdx
unsigned long long v25; // rdi
long long v27; // r15
long long v28; // rax
long long v29; // rcx
long long v30; // rsi
_BYTE v31[72]; // [rsp+0h] [rbp-90h] BYREF
long long v32; // [rsp+48h] [rbp-48h]
long long v33; // [rsp+50h] [rbp-40h]
long long v34; // [rsp+58h] [rbp-38h]
_QWORD *v35; // [rsp+60h] [rbp-30h]
v33 = a2;
v32 = a6;
if ( (a5 & 0x80000000) != 0 )
{
v34 = v6;
}
else
{
v35 = a4;
v11 = *(unsigned int *)(*a1 + 576);
v12 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, a5, 8LL);
if ( v12 )
mi_pack_get_block_info_cold_1(v12, a5, a6);
else
my_seek(a5, a6, 0LL, 0LL);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, a5, 6LL);
v34 = v11;
if ( v13 )
{
v27 = v13;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v13,
v11,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
1382LL);
v28 = my_read(a5, a3, v11, 4LL);
v29 = v11;
v14 = v28;
v30 = 0LL;
if ( !v28 )
v30 = v29;
((void ( *)(long long, long long))PSI_server[67])(v27, v30);
}
else
{
v14 = my_read(a5, a3, v11, 4LL);
}
v15 = 32;
a4 = v35;
if ( v14 )
return v15;
}
v16 = *a3;
if ( v16 > 0xFD )
{
v18 = v34;
if ( (_DWORD)v16 == 254 )
{
v16 = *(unsigned __int16 *)(a3 + 1);
v17 = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v16 = *(unsigned __int16 *)(a3 + 1) | (unsigned long long)(a3[3] << 16);
v17 = 4;
}
else
{
v16 = *(unsigned int *)(a3 + 1);
v17 = 5;
}
}
else
{
v17 = 1;
v18 = v34;
}
*((_QWORD *)a3 + 3) = v16;
if ( *(_DWORD *)(*a1 + 392) )
{
v19 = a3[v17];
if ( v19 > 0xFD )
{
if ( (_DWORD)v19 == 254 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1];
LODWORD(v35) = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1] | (unsigned long long)(a3[v17 + 3] << 16);
LODWORD(v35) = 4;
}
else
{
v19 = *(unsigned int *)&a3[v17 + 1];
LODWORD(v35) = 5;
}
}
else
{
LODWORD(v35) = 1;
}
*((_QWORD *)a3 + 6) = v19;
v20 = a4;
if ( !mi_alloc_rec_buff(a1, v19 + v16, a4) )
return 32;
v21 = *((_QWORD *)a3 + 3) + *v20;
v22 = v33;
*(_QWORD *)(v33 + 24) = v21;
v17 += (unsigned int)v35;
*(_QWORD *)(v22 + 32) = *((_QWORD *)a3 + 6) + v21;
a1[55] = *((_QWORD *)a3 + 6);
a4 = v20;
v18 = v34;
}
v23 = v17;
*((_QWORD *)a3 + 7) = v17 + v32;
v15 = 0;
if ( (int)a5 > 0 )
{
v24 = *((_QWORD *)a3 + 3);
v25 = (unsigned int)(v18 - v23);
if ( v24 >= v25 )
v24 = (unsigned int)v25;
*((_DWORD *)a3 + 21) = v24;
memcpy(*a4, &a3[v23], v24);
}
return v15;
}
|
_mi_pack_get_block_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV RBX,RDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
TEST R8D,R8D
MOV qword ptr [RBP + -0x48],R9
JS 0x0018884f
MOV R15,R9
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [R14]
MOV R13D,dword ptr [RAX + 0x240]
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001889b1
MOV EDI,R12D
MOV RSI,R15
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001ab33c
LAB_001887f8:
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x38],R13
JNZ 0x001889c4
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001aad5c
MOV R13,RAX
LAB_0018883a:
MOV R15D,0x20
TEST R13,R13
MOV RCX,qword ptr [RBP + -0x30]
JNZ 0x0018899f
JMP 0x00188853
LAB_0018884f:
MOV qword ptr [RBP + -0x38],RAX
LAB_00188853:
MOVZX ESI,byte ptr [RBX]
CMP RSI,0xfd
JA 0x0018886b
MOV R15D,0x1
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x001888ae
LAB_0018886b:
CMP ESI,0xfe
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x00188883
MOVZX ESI,word ptr [RBX + 0x1]
MOV R15D,0x3
JMP 0x001888ae
LAB_00188883:
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x001888a5
MOVZX EAX,word ptr [RBX + 0x1]
MOVZX ESI,byte ptr [RBX + 0x3]
SHL ESI,0x10
OR RSI,RAX
MOV R15D,0x4
JMP 0x001888ae
LAB_001888a5:
MOV ESI,dword ptr [RBX + 0x1]
MOV R15D,0x5
LAB_001888ae:
MOV qword ptr [RBX + 0x18],RSI
MOV RDX,qword ptr [R14]
CMP dword ptr [RDX + 0x188],0x0
JZ 0x00188964
MOV EDI,R15D
MOVZX EAX,byte ptr [RBX + RDI*0x1]
CMP RAX,0xfd
JA 0x001888da
MOV dword ptr [RBP + -0x30],0x1
JMP 0x0018891c
LAB_001888da:
CMP EAX,0xfe
JNZ 0x001888ef
MOVZX EAX,word ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x3
JMP 0x0018891c
LAB_001888ef:
CMP byte ptr [RDX + 0x244],0x1
JNZ 0x00188911
MOVZX EDX,word ptr [RBX + RDI*0x1 + 0x1]
MOVZX EAX,byte ptr [RBX + RDI*0x1 + 0x3]
SHL EAX,0x10
OR RAX,RDX
MOV dword ptr [RBP + -0x30],0x4
JMP 0x0018891c
LAB_00188911:
MOV EAX,dword ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x5
LAB_0018891c:
MOV qword ptr [RBX + 0x30],RAX
ADD RSI,RAX
MOV RDI,R14
MOV RDX,RCX
MOV R13,RCX
CALL 0x00186af5
TEST RAX,RAX
JZ 0x00188999
MOV RAX,qword ptr [R13]
ADD RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX + 0x18],RAX
ADD RAX,qword ptr [RBX + 0x30]
ADD R15D,dword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x20],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x1b8],RAX
MOV RCX,R13
MOV RDI,qword ptr [RBP + -0x38]
LAB_00188964:
MOV EAX,R15D
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV qword ptr [RBX + 0x38],RDX
XOR R15D,R15D
TEST R12D,R12D
JLE 0x0018899f
MOV RDX,qword ptr [RBX + 0x18]
SUB EDI,EAX
CMP RDX,RDI
CMOVNC EDX,EDI
MOV dword ptr [RBX + 0x54],EDX
MOV RDI,qword ptr [RCX]
ADD RBX,RAX
MOV RSI,RBX
CALL 0x0012a0a0
JMP 0x0018899f
LAB_00188999:
MOV R15D,0x20
LAB_0018899f:
MOV EAX,R15D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001889b1:
MOV RDI,RAX
MOV ESI,R12D
MOV RDX,R15
CALL 0x0012f6b4
JMP 0x001887f8
LAB_001889c4:
MOV R15,RAX
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1e78e3]
MOV RDI,R15
MOV RSI,R13
MOV ECX,0x566
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001aad5c
MOV RCX,R13
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RCX
LEA RAX,[0x493a58]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x0018883a
|
int8
_mi_pack_get_block_info
(long *param_1,long param_2,byte *param_3,long *param_4,int param_5,long param_6)
{
ulong in_RAX;
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 local_98 [72];
long local_50;
long local_48;
ulong local_40;
long *local_38;
local_50 = param_6;
local_48 = param_2;
local_40 = in_RAX;
if (-1 < param_5) {
uVar4 = (ulong)*(uint *)(*param_1 + 0x240);
local_38 = param_4;
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,8);
if (lVar1 == 0) {
my_seek(param_5,param_6,0,0);
}
else {
_mi_pack_get_block_info_cold_1(lVar1,param_5,param_6);
}
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,6);
local_40 = uVar4;
if (lVar1 == 0) {
lVar2 = my_read(param_5,param_3,uVar4,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,uVar4,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
0x566);
lVar2 = my_read(param_5,param_3,uVar4,4);
uVar6 = 0;
if (lVar2 == 0) {
uVar6 = uVar4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar6);
}
param_4 = local_38;
if (lVar2 != 0) {
return 0x20;
}
}
uVar4 = (ulong)*param_3;
if (uVar4 < 0xfe) {
uVar6 = 1;
}
else if (*param_3 == 0xfe) {
uVar4 = (ulong)*(ushort *)(param_3 + 1);
uVar6 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar4 = (ulong)*(uint3 *)(param_3 + 1);
uVar6 = 4;
}
else {
uVar4 = (ulong)*(uint *)(param_3 + 1);
uVar6 = 5;
}
iVar5 = (int)local_40;
*(ulong *)(param_3 + 0x18) = uVar4;
if (*(int *)(*param_1 + 0x188) != 0) {
uVar3 = (ulong)param_3[uVar6];
if (uVar3 < 0xfe) {
local_38 = (long *)CONCAT44(local_38._4_4_,1);
}
else if (param_3[uVar6] == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,3);
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)CONCAT12(param_3[uVar6 + 3],*(int2 *)(param_3 + uVar6 + 1));
local_38 = (long *)CONCAT44(local_38._4_4_,4);
}
else {
uVar3 = (ulong)*(uint *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,5);
}
*(ulong *)(param_3 + 0x30) = uVar3;
lVar1 = mi_alloc_rec_buff(param_1,uVar4 + uVar3,param_4);
if (lVar1 == 0) {
return 0x20;
}
lVar1 = *param_4;
lVar2 = *(long *)(param_3 + 0x18);
*(long *)(local_48 + 0x18) = lVar1 + lVar2;
uVar6 = (ulong)(uint)((int)uVar6 + (int)local_38);
*(long *)(local_48 + 0x20) = lVar1 + lVar2 + *(long *)(param_3 + 0x30);
param_1[0x37] = *(long *)(param_3 + 0x30);
iVar5 = (int)local_40;
}
*(ulong *)(param_3 + 0x38) = local_50 + uVar6;
if (0 < param_5) {
uVar3 = (ulong)(uint)(iVar5 - (int)uVar6);
uVar4 = *(ulong *)(param_3 + 0x18) & 0xffffffff;
if (uVar3 <= *(ulong *)(param_3 + 0x18)) {
uVar4 = uVar3;
}
*(int *)(param_3 + 0x54) = (int)uVar4;
memcpy((void *)*param_4,param_3 + uVar6,uVar4);
}
return 0;
}
|
|
60,055
|
LefDefParser::defiAssertion::Init()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiAssertion.cpp
|
void defiAssertion::Init() {
netName_ = (char*)malloc(32);
netNameLength_ = 32;
numItems_ = 0;
clear();
numItemsAllocated_ = 16;
items_ = (int**)malloc(sizeof(char*)*16);
itemTypes_ = (char*)malloc(16);
}
|
O3
|
cpp
|
LefDefParser::defiAssertion::Init():
pushq %rbx
movq %rdi, %rbx
movl $0x20, %edi
callq 0x6270
movq %rax, 0x10(%rbx)
movl $0x20, 0x18(%rbx)
movl $0x0, 0x40(%rbx)
movq %rbx, %rdi
callq 0x2745a
movl $0x10, 0x44(%rbx)
movl $0x80, %edi
callq 0x6270
movq %rax, 0x50(%rbx)
movl $0x10, %edi
callq 0x6270
movq %rax, 0x48(%rbx)
popq %rbx
retq
nop
|
_ZN12LefDefParser13defiAssertion4InitEv:
push rbx
mov rbx, rdi
mov edi, 20h ; ' '
call _malloc
mov [rbx+10h], rax
mov dword ptr [rbx+18h], 20h ; ' '
mov dword ptr [rbx+40h], 0
mov rdi, rbx; this
call _ZN12LefDefParser13defiAssertion5clearEv; LefDefParser::defiAssertion::clear(void)
mov dword ptr [rbx+44h], 10h
mov edi, 80h
call _malloc
mov [rbx+50h], rax
mov edi, 10h
call _malloc
mov [rbx+48h], rax
pop rbx
retn
|
long long LefDefParser::defiAssertion::Init(LefDefParser::defiAssertion *this)
{
long long result; // rax
*((_QWORD *)this + 2) = malloc(32LL);
*((_DWORD *)this + 6) = 32;
*((_DWORD *)this + 16) = 0;
LefDefParser::defiAssertion::clear(this);
*((_DWORD *)this + 17) = 16;
*((_QWORD *)this + 10) = malloc(128LL);
result = malloc(16LL);
*((_QWORD *)this + 9) = result;
return result;
}
|
Init:
PUSH RBX
MOV RBX,RDI
MOV EDI,0x20
CALL 0x00106270
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x18],0x20
MOV dword ptr [RBX + 0x40],0x0
MOV RDI,RBX
CALL 0x0012745a
MOV dword ptr [RBX + 0x44],0x10
MOV EDI,0x80
CALL 0x00106270
MOV qword ptr [RBX + 0x50],RAX
MOV EDI,0x10
CALL 0x00106270
MOV qword ptr [RBX + 0x48],RAX
POP RBX
RET
|
/* LefDefParser::defiAssertion::Init() */
void __thiscall LefDefParser::defiAssertion::Init(defiAssertion *this)
{
void *pvVar1;
pvVar1 = malloc(0x20);
*(void **)(this + 0x10) = pvVar1;
*(int4 *)(this + 0x18) = 0x20;
*(int4 *)(this + 0x40) = 0;
clear(this);
*(int4 *)(this + 0x44) = 0x10;
pvVar1 = malloc(0x80);
*(void **)(this + 0x50) = pvVar1;
pvVar1 = malloc(0x10);
*(void **)(this + 0x48) = pvVar1;
return;
}
|
|
60,056
|
my_end
|
eloqsql/mysys/my_init.c
|
void my_end(int infoflag)
{
/*
this code is suboptimal to workaround a bug in
Sun CC: Sun C++ 5.6 2004/06/02 for x86, and should not be
optimized until this compiler is not in use anymore
*/
FILE *info_file= DBUG_FILE;
my_bool print_info= (info_file != stderr);
if (!my_init_done)
return;
/*
We do not use DBUG_ENTER here, as after cleanup DBUG is no longer
operational, so we cannot use DBUG_RETURN.
*/
DBUG_PRINT("info",("Shutting down: infoflag: %d print_info: %d",
infoflag, print_info));
if (!info_file)
{
info_file= stderr;
print_info= 0;
}
if ((infoflag & MY_CHECK_ERROR) || print_info)
{ /* Test if some file is left open */
char ebuff[512];
uint i, open_files, open_streams;
for (open_streams= open_files= i= 0 ; i < my_file_limit ; i++)
{
if (my_file_info[i].type == UNOPEN)
continue;
if (my_file_info[i].type == STREAM_BY_FOPEN ||
my_file_info[i].type == STREAM_BY_FDOPEN)
open_streams++;
else
open_files++;
#ifdef EXTRA_DEBUG
fprintf(stderr, EE(EE_FILE_NOT_CLOSED), my_file_info[i].name, i);
fputc('\n', stderr);
#endif
}
if (open_files || open_streams)
{
my_snprintf(ebuff, sizeof(ebuff), EE(EE_OPEN_WARNING),
open_files, open_streams);
my_message_stderr(EE_OPEN_WARNING, ebuff, ME_BELL);
DBUG_PRINT("error", ("%s", ebuff));
}
#ifdef CHECK_UNLIKELY
end_my_likely(info_file);
#endif
}
free_charsets();
my_error_unregister_all();
my_once_free();
if ((infoflag & MY_GIVE_INFO) || print_info)
{
#ifdef HAVE_GETRUSAGE
struct rusage rus;
#ifdef HAVE_valgrind
/* Purify assumes that rus is uninitialized after getrusage call */
bzero((char*) &rus, sizeof(rus));
#endif
if (!getrusage(RUSAGE_SELF, &rus))
fprintf(info_file,"\n\
User time %.2f, System time %.2f\n\
Maximum resident set size %ld, Integral resident set size %ld\n\
Non-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\n\
Blocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\n\
Voluntary context switches %ld, Involuntary context switches %ld\n",
(rus.ru_utime.tv_sec * SCALE_SEC +
rus.ru_utime.tv_usec / SCALE_USEC) / 100.0,
(rus.ru_stime.tv_sec * SCALE_SEC +
rus.ru_stime.tv_usec / SCALE_USEC) / 100.0,
rus.ru_maxrss, rus.ru_idrss,
rus.ru_minflt, rus.ru_majflt,
rus.ru_nswap, rus.ru_inblock, rus.ru_oublock,
rus.ru_msgsnd, rus.ru_msgrcv, rus.ru_nsignals,
rus.ru_nvcsw, rus.ru_nivcsw);
#endif
#if defined(_MSC_VER)
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ERROR, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ERROR, _CRTDBG_FILE_STDERR );
_CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
_CrtCheckMemory();
#endif
}
my_thread_end();
my_thread_global_end();
if (!(infoflag & MY_DONT_FREE_DBUG))
DBUG_END(); /* Must be done as late as possible */
my_mutex_end();
#if defined(SAFE_MUTEX)
/*
Check on destroying of mutexes. A few may be left that will get cleaned
up by C++ destructors
*/
safe_mutex_end((infoflag & (MY_GIVE_INFO | MY_CHECK_ERROR)) ? stderr :
(FILE *) 0);
#endif /* defined(SAFE_MUTEX) */
#ifdef _WIN32
WSACleanup();
#endif
/* At very last, delete mysys key, it is used everywhere including DBUG */
pthread_key_delete(THR_KEY_mysys);
my_init_done= my_thr_key_mysys_exists= 0;
}
|
O3
|
c
|
my_end:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq 0xb68efb(%rip), %r12 # 0xc09830
cmpb $0x0, (%r12)
je 0xa0b0b
movl %edi, %r14d
movq 0x2e565e(%rip), %rax # 0x385fa8
movq (%rax), %rbx
testb $0x1, %r14b
je 0xa09e0
leaq 0x2e71b2(%rip), %rax # 0x387b10
movl (%rax), %eax
testq %rax, %rax
je 0xa099e
leaq 0x2e71ac(%rip), %rcx # 0x387b18
movq (%rcx), %rdx
shlq $0x4, %rax
xorl %esi, %esi
xorl %r8d, %r8d
xorl %ecx, %ecx
movl 0x8(%rdx,%rsi), %edi
leal -0x3(%rdi), %r9d
cmpl $0x2, %r9d
jae 0xa098d
incl %r8d
jmp 0xa0993
testl %edi, %edi
je 0xa0993
incl %ecx
addq $0x10, %rsi
cmpq %rsi, %rax
jne 0xa097a
jmp 0xa09a3
xorl %ecx, %ecx
xorl %r8d, %r8d
movl %ecx, %eax
orl %r8d, %eax
je 0xa09e0
leaq 0x2e766f(%rip), %rax # 0x388020
movq 0x90(%rax), %rdx
leaq -0x230(%rbp), %r15
movl $0x200, %esi # imm = 0x200
movq %r15, %rdi
xorl %eax, %eax
callq 0xd81ce
movl $0x4, %edx
movl $0x13, %edi
movq %r15, %rsi
callq 0xa1544
callq 0x93914
callq 0x9f7aa
callq 0xa17e0
testb $0x2, %r14b
je 0xa0adf
leaq -0x230(%rbp), %rsi
xorl %edi, %edi
callq 0x298a0
testl %eax, %eax
jne 0xa0adf
imulq $0x64, -0x230(%rbp), %rsi
movabsq $0x346dc5d63886594b, %rcx # imm = 0x346DC5D63886594B
movq %rcx, %rax
imulq -0x228(%rbp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xb, %rdx
addq %rax, %rdx
addq %rsi, %rdx
cvtsi2sd %rdx, %xmm0
movsd 0x41c8f(%rip), %xmm2 # 0xe26d8
divsd %xmm2, %xmm0
imulq $0x64, -0x220(%rbp), %rsi
movq %rcx, %rax
imulq -0x218(%rbp)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xb, %rdx
addq %rax, %rdx
addq %rsi, %rdx
cvtsi2sd %rdx, %xmm1
divsd %xmm2, %xmm1
movq -0x210(%rbp), %rcx
movq -0x200(%rbp), %r8
movq -0x1f0(%rbp), %r9
movups -0x1e8(%rbp), %xmm2
movups -0x1d8(%rbp), %xmm3
movups -0x1c8(%rbp), %xmm4
movups -0x1b8(%rbp), %xmm5
movq -0x1a8(%rbp), %rax
movq %rax, 0x40(%rsp)
movups %xmm5, 0x30(%rsp)
movups %xmm4, 0x20(%rsp)
movups %xmm3, 0x10(%rsp)
movups %xmm2, (%rsp)
leaq 0x3cefb(%rip), %rdx # 0xdd9cb
movq %rbx, %rdi
movl $0x1, %esi
movb $0x2, %al
callq 0x291e0
callq 0xa3344
callq 0xa31db
callq 0xa5744
leaq 0xb69a3f(%rip), %rax # 0xc0a534
movl (%rax), %edi
callq 0x29720
leaq 0xb69769(%rip), %rax # 0xc0a26c
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, (%r12)
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0xa0b2a
addq $0x260, %rsp # imm = 0x260
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
|
my_end:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_28], rax
lea r12, my_init_done
cmp byte ptr [r12], 0
jz loc_A0B0B
mov r14d, edi
mov rax, cs:stderr_ptr
mov rbx, [rax]
test r14b, 1
jz loc_A09E0
lea rax, my_file_limit
mov eax, [rax]
test rax, rax
jz short loc_A099E
lea rcx, my_file_info
mov rdx, [rcx]
shl rax, 4
xor esi, esi
xor r8d, r8d
xor ecx, ecx
loc_A097A:
mov edi, [rdx+rsi+8]
lea r9d, [rdi-3]
cmp r9d, 2
jnb short loc_A098D
inc r8d
jmp short loc_A0993
loc_A098D:
test edi, edi
jz short loc_A0993
inc ecx
loc_A0993:
add rsi, 10h
cmp rax, rsi
jnz short loc_A097A
jmp short loc_A09A3
loc_A099E:
xor ecx, ecx
xor r8d, r8d
loc_A09A3:
mov eax, ecx
or eax, r8d
jz short loc_A09E0
lea rax, globerrs
mov rdx, [rax+90h]
lea r15, [rbp+var_230]
mov esi, 200h
mov rdi, r15
xor eax, eax
call my_snprintf
mov edx, 4
mov edi, 13h
mov rsi, r15
call my_message_stderr
loc_A09E0:
call free_charsets
call my_error_unregister_all
call my_once_free
test r14b, 2
jz loc_A0ADF
lea rsi, [rbp+var_230]
xor edi, edi
call _getrusage
test eax, eax
jnz loc_A0ADF
imul rsi, [rbp+var_230], 64h ; 'd'
mov rcx, 346DC5D63886594Bh
mov rax, rcx
imul [rbp+var_228]
mov rax, rdx
shr rax, 3Fh
sar rdx, 0Bh
add rdx, rax
add rdx, rsi
cvtsi2sd xmm0, rdx
movsd xmm2, cs:qword_E26D8
divsd xmm0, xmm2
imul rsi, [rbp+var_220], 64h ; 'd'
mov rax, rcx
imul [rbp+var_218]
mov rax, rdx
shr rax, 3Fh
sar rdx, 0Bh
add rdx, rax
add rdx, rsi
cvtsi2sd xmm1, rdx
divsd xmm1, xmm2
mov rcx, [rbp+var_210]
mov r8, [rbp+var_200]
mov r9, [rbp+var_1F0]
movups xmm2, [rbp+var_1E8]
movups xmm3, [rbp+var_1D8]
movups xmm4, [rbp+var_1C8]
movups xmm5, [rbp+var_1B8]
mov rax, [rbp+var_1A8]
mov [rsp+280h+var_240], rax
movups [rsp+280h+var_250], xmm5
movups [rsp+280h+var_260], xmm4
movups [rsp+280h+var_270], xmm3
movups [rsp+280h+var_280], xmm2
lea rdx, aUserTime2fSyst; "\nUser time %.2f, System time %.2f\nMax"...
mov rdi, rbx
mov esi, 1
mov al, 2
call ___fprintf_chk
loc_A0ADF:
call my_thread_end
call my_thread_global_end
call my_mutex_end
lea rax, THR_KEY_mysys
mov edi, [rax]
call _pthread_key_delete
lea rax, my_thr_key_mysys_exists
xor ecx, ecx
mov [rax], cl
mov [r12], cl
loc_A0B0B:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_A0B2A
add rsp, 260h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A0B2A:
call ___stack_chk_fail
|
unsigned long long my_end(char a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
long long v7; // rbx
long long v8; // rsi
int v9; // r8d
int v10; // ecx
int v11; // edi
long long v13; // [rsp+50h] [rbp-230h] BYREF
long long v14; // [rsp+58h] [rbp-228h]
long long v15; // [rsp+60h] [rbp-220h]
long long v16; // [rsp+68h] [rbp-218h]
long long v17; // [rsp+70h] [rbp-210h]
long long v18; // [rsp+80h] [rbp-200h]
long long v19; // [rsp+90h] [rbp-1F0h]
long long v20; // [rsp+98h] [rbp-1E8h]
long long v21; // [rsp+A0h] [rbp-1E0h]
long long v22; // [rsp+A8h] [rbp-1D8h]
long long v23; // [rsp+B0h] [rbp-1D0h]
long long v24; // [rsp+B8h] [rbp-1C8h]
long long v25; // [rsp+C0h] [rbp-1C0h]
long long v26; // [rsp+C8h] [rbp-1B8h]
long long v27; // [rsp+D0h] [rbp-1B0h]
long long v28; // [rsp+D8h] [rbp-1A8h]
unsigned long long v29; // [rsp+258h] [rbp-28h]
v29 = __readfsqword(0x28u);
if ( my_init_done )
{
v7 = stderr;
if ( (a1 & 1) != 0 )
{
if ( my_file_limit[0] )
{
v8 = 0LL;
v9 = 0;
v10 = 0;
do
{
v11 = *(_DWORD *)((char *)my_file_info + v8 + 8);
a6 = v11 - 3;
if ( (unsigned int)(v11 - 3) >= 2 )
{
if ( v11 )
++v10;
}
else
{
++v9;
}
v8 += 16LL;
}
while ( 16LL * my_file_limit[0] != v8 );
}
else
{
v10 = 0;
v9 = 0;
}
if ( v9 | v10 )
{
my_snprintf((unsigned int)&v13, 512, (unsigned int)globerrs[18], v10, v9, a6);
my_message_stderr(19LL, &v13, 4LL);
}
}
free_charsets();
my_error_unregister_all();
my_once_free();
if ( (a1 & 2) != 0 && !(unsigned int)getrusage(0LL, &v13) )
__fprintf_chk(
v7,
1LL,
"\n"
"User time %.2f, System time %.2f\n"
"Maximum resident set size %ld, Integral resident set size %ld\n"
"Non-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\n"
"Blocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\n"
"Voluntary context switches %ld, Involuntary context switches %ld\n",
(double)(100 * (int)v13 + (int)v14 / 10000) / 100.0,
(double)(int)(100 * v15 + v16 / 10000) / 100.0,
v17,
v18,
v19,
v20,
v21,
v22,
v23,
v24,
v25,
v26,
v27,
v28);
my_thread_end();
my_thread_global_end();
my_mutex_end();
pthread_key_delete(THR_KEY_mysys);
my_thr_key_mysys_exists = 0;
my_init_done = 0;
}
return __readfsqword(0x28u);
}
|
my_end:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA R12,[0xd09830]
CMP byte ptr [R12],0x0
JZ 0x001a0b0b
MOV R14D,EDI
MOV RAX,qword ptr [0x00485fa8]
MOV RBX,qword ptr [RAX]
TEST R14B,0x1
JZ 0x001a09e0
LEA RAX,[0x487b10]
MOV EAX,dword ptr [RAX]
TEST RAX,RAX
JZ 0x001a099e
LEA RCX,[0x487b18]
MOV RDX,qword ptr [RCX]
SHL RAX,0x4
XOR ESI,ESI
XOR R8D,R8D
XOR ECX,ECX
LAB_001a097a:
MOV EDI,dword ptr [RDX + RSI*0x1 + 0x8]
LEA R9D,[RDI + -0x3]
CMP R9D,0x2
JNC 0x001a098d
INC R8D
JMP 0x001a0993
LAB_001a098d:
TEST EDI,EDI
JZ 0x001a0993
INC ECX
LAB_001a0993:
ADD RSI,0x10
CMP RAX,RSI
JNZ 0x001a097a
JMP 0x001a09a3
LAB_001a099e:
XOR ECX,ECX
XOR R8D,R8D
LAB_001a09a3:
MOV EAX,ECX
OR EAX,R8D
JZ 0x001a09e0
LEA RAX,[0x488020]
MOV RDX,qword ptr [RAX + 0x90]
LEA R15,[RBP + -0x230]
MOV ESI,0x200
MOV RDI,R15
XOR EAX,EAX
CALL 0x001d81ce
MOV EDX,0x4
MOV EDI,0x13
MOV RSI,R15
CALL 0x001a1544
LAB_001a09e0:
CALL 0x00193914
CALL 0x0019f7aa
CALL 0x001a17e0
TEST R14B,0x2
JZ 0x001a0adf
LEA RSI,[RBP + -0x230]
XOR EDI,EDI
CALL 0x001298a0
TEST EAX,EAX
JNZ 0x001a0adf
IMUL RSI,qword ptr [RBP + -0x230],0x64
MOV RCX,0x346dc5d63886594b
MOV RAX,RCX
IMUL qword ptr [RBP + -0x228]
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0xb
ADD RDX,RAX
ADD RDX,RSI
CVTSI2SD XMM0,RDX
MOVSD XMM2,qword ptr [0x001e26d8]
DIVSD XMM0,XMM2
IMUL RSI,qword ptr [RBP + -0x220],0x64
MOV RAX,RCX
IMUL qword ptr [RBP + -0x218]
MOV RAX,RDX
SHR RAX,0x3f
SAR RDX,0xb
ADD RDX,RAX
ADD RDX,RSI
CVTSI2SD XMM1,RDX
DIVSD XMM1,XMM2
MOV RCX,qword ptr [RBP + -0x210]
MOV R8,qword ptr [RBP + -0x200]
MOV R9,qword ptr [RBP + -0x1f0]
MOVUPS XMM2,xmmword ptr [RBP + -0x1e8]
MOVUPS XMM3,xmmword ptr [RBP + -0x1d8]
MOVUPS XMM4,xmmword ptr [RBP + -0x1c8]
MOVUPS XMM5,xmmword ptr [RBP + -0x1b8]
MOV RAX,qword ptr [RBP + -0x1a8]
MOV qword ptr [RSP + 0x40],RAX
MOVUPS xmmword ptr [RSP + 0x30],XMM5
MOVUPS xmmword ptr [RSP + 0x20],XMM4
MOVUPS xmmword ptr [RSP + 0x10],XMM3
MOVUPS xmmword ptr [RSP],XMM2
LEA RDX,[0x1dd9cb]
MOV RDI,RBX
MOV ESI,0x1
MOV AL,0x2
CALL 0x001291e0
LAB_001a0adf:
CALL 0x001a3344
CALL 0x001a31db
CALL 0x001a5744
LEA RAX,[0xd0a534]
MOV EDI,dword ptr [RAX]
CALL 0x00129720
LEA RAX,[0xd0a26c]
XOR ECX,ECX
MOV byte ptr [RAX],CL
MOV byte ptr [R12],CL
LAB_001a0b0b:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001a0b2a
ADD RSP,0x260
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a0b2a:
CALL 0x00129250
|
void my_end(ulong param_1)
{
int8 uVar1;
int iVar2;
long lVar3;
int iVar4;
long in_FS_OFFSET;
rusage local_238 [3];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (my_init_done != '\0') {
uVar1 = *(int8 *)PTR_stderr_00485fa8;
if ((param_1 & 1) != 0) {
if ((ulong)my_file_limit == 0) {
iVar2 = 0;
iVar4 = 0;
}
else {
lVar3 = 0;
iVar4 = 0;
iVar2 = 0;
do {
if (*(int *)(my_file_info + lVar3 + 8) - 3U < 2) {
iVar4 = iVar4 + 1;
}
else if (*(int *)(my_file_info + lVar3 + 8) != 0) {
iVar2 = iVar2 + 1;
}
lVar3 = lVar3 + 0x10;
} while ((ulong)my_file_limit << 4 != lVar3);
}
if (iVar2 != 0 || iVar4 != 0) {
my_snprintf(local_238,0x200,globerrs._144_8_);
my_message_stderr(0x13,local_238,4);
}
}
free_charsets();
my_error_unregister_all();
my_once_free();
if (((param_1 & 2) != 0) && (iVar2 = getrusage(RUSAGE_SELF,local_238), iVar2 == 0)) {
__fprintf_chk((double)(local_238[0].ru_utime.tv_usec / 10000 +
local_238[0].ru_utime.tv_sec * 100) / DAT_001e26d8,
(double)(local_238[0].ru_stime.tv_usec / 10000 +
local_238[0].ru_stime.tv_sec * 100) / DAT_001e26d8,uVar1,1,
"\nUser time %.2f, System time %.2f\nMaximum resident set size %ld, Integral resident set size %ld\nNon-physical pagefaults %ld, Physical pagefaults %ld, Swaps %ld\nBlocks in %ld out %ld, Messages in %ld out %ld, Signals %ld\nVoluntary context switches %ld, Involuntary context switches %ld\n"
,local_238[0].ru_maxrss,local_238[0].ru_idrss,local_238[0].ru_minflt,
(int4)local_238[0].ru_majflt,(int4)local_238[0].ru_nswap,
(int4)local_238[0].ru_inblock,(int4)local_238[0].ru_oublock,
(int4)local_238[0].ru_msgsnd,(int4)local_238[0].ru_msgrcv,
(int4)local_238[0].ru_nsignals,(int4)local_238[0].ru_nvcsw,
local_238[0].ru_nivcsw);
}
my_thread_end();
my_thread_global_end();
my_mutex_end();
pthread_key_delete(THR_KEY_mysys);
my_thr_key_mysys_exists = 0;
my_init_done = '\0';
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_30) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return;
}
|
|
60,057
|
glfwGetVulkanResultString
|
untodesu[P]riteg/build_O3/_deps/glfw-src/src/vulkan.c
|
const char* _glfwGetVulkanResultString(VkResult result)
{
switch (result)
{
case VK_SUCCESS:
return "Success";
case VK_NOT_READY:
return "A fence or query has not yet completed";
case VK_TIMEOUT:
return "A wait operation has not completed in the specified time";
case VK_EVENT_SET:
return "An event is signaled";
case VK_EVENT_RESET:
return "An event is unsignaled";
case VK_INCOMPLETE:
return "A return array was too small for the result";
case VK_ERROR_OUT_OF_HOST_MEMORY:
return "A host memory allocation has failed";
case VK_ERROR_OUT_OF_DEVICE_MEMORY:
return "A device memory allocation has failed";
case VK_ERROR_INITIALIZATION_FAILED:
return "Initialization of an object could not be completed for implementation-specific reasons";
case VK_ERROR_DEVICE_LOST:
return "The logical or physical device has been lost";
case VK_ERROR_MEMORY_MAP_FAILED:
return "Mapping of a memory object has failed";
case VK_ERROR_LAYER_NOT_PRESENT:
return "A requested layer is not present or could not be loaded";
case VK_ERROR_EXTENSION_NOT_PRESENT:
return "A requested extension is not supported";
case VK_ERROR_FEATURE_NOT_PRESENT:
return "A requested feature is not supported";
case VK_ERROR_INCOMPATIBLE_DRIVER:
return "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
case VK_ERROR_TOO_MANY_OBJECTS:
return "Too many objects of the type have already been created";
case VK_ERROR_FORMAT_NOT_SUPPORTED:
return "A requested format is not supported on this device";
case VK_ERROR_SURFACE_LOST_KHR:
return "A surface is no longer available";
case VK_SUBOPTIMAL_KHR:
return "A swapchain no longer matches the surface properties exactly, but can still be used";
case VK_ERROR_OUT_OF_DATE_KHR:
return "A surface has changed in such a way that it is no longer compatible with the swapchain";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
return "The display used by a swapchain does not use the same presentable image layout";
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
case VK_ERROR_VALIDATION_FAILED_EXT:
return "A validation layer found an error";
default:
return "ERROR: UNKNOWN VULKAN ERROR";
}
}
|
O3
|
c
|
glfwGetVulkanResultString:
cmpl $0xc46535ff, %edi # imm = 0xC46535FF
jle 0x1c828
leal 0xb(%rdi), %eax
cmpl $0x10, %eax
ja 0x1c860
leaq 0x670b5(%rip), %rcx # 0x838cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x674ee(%rip), %rax # 0x83d15
retq
cmpl $0xc4653213, %edi # imm = 0xC4653213
jg 0x1c848
cmpl $0xc4650b07, %edi # imm = 0xC4650B07
je 0x1c878
cmpl $0xc4652a47, %edi # imm = 0xC4652A47
jne 0x1c888
leaq 0x675cd(%rip), %rax # 0x83e14
retq
cmpl $0xc4653214, %edi # imm = 0xC4653214
je 0x1c880
cmpl $0xc46535ff, %edi # imm = 0xC46535FF
jne 0x1c888
leaq 0x67604(%rip), %rax # 0x83e63
retq
cmpl $0xc4653600, %edi # imm = 0xC4653600
je 0x1c8b8
cmpl $0x3b9acdeb, %edi # imm = 0x3B9ACDEB
jne 0x1c888
leaq 0x674f2(%rip), %rax # 0x83d69
retq
leaq 0x67641(%rip), %rax # 0x83ec0
retq
leaq 0x67536(%rip), %rax # 0x83dbd
retq
leaq 0x67653(%rip), %rax # 0x83ee2
retq
leaq 0x67247(%rip), %rax # 0x83ade
retq
leaq 0x67213(%rip), %rax # 0x83ab2
retq
leaq 0x671a3(%rip), %rax # 0x83a4a
retq
leaq 0x67387(%rip), %rax # 0x83c36
retq
leaq 0x6719b(%rip), %rax # 0x83a52
retq
leaq 0x67489(%rip), %rax # 0x83d48
retq
leaq 0x67267(%rip), %rax # 0x83b2e
retq
leaq 0x673b3(%rip), %rax # 0x83c82
retq
leaq 0x671f0(%rip), %rax # 0x83ac7
retq
leaq 0x6737e(%rip), %rax # 0x83c5d
retq
leaq 0x672c4(%rip), %rax # 0x83bab
retq
leaq 0x673ef(%rip), %rax # 0x83cde
retq
leaq 0x67307(%rip), %rax # 0x83bfe
retq
leaq 0x6717a(%rip), %rax # 0x83a79
retq
leaq 0x672d1(%rip), %rax # 0x83bd8
retq
leaq 0x671fb(%rip), %rax # 0x83b0a
retq
leaq 0x6723d(%rip), %rax # 0x83b54
retq
|
_glfwGetVulkanResultString:
cmp edi, 0C46535FFh
jle short loc_1C828
lea eax, [rdi+0Bh]; switch 17 cases
cmp eax, 10h
ja short def_1C81E; jumptable 000000000001C81E default case
lea rcx, jpt_1C81E
movsxd rax, ds:(jpt_1C81E - 838CCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1C820:
lea rax, aARequestedForm; jumptable 000000000001C81E case -11
retn
loc_1C828:
cmp edi, 0C4653213h
jg short loc_1C848
cmp edi, 0C4650B07h
jz short loc_1C878
cmp edi, 0C4652A47h
jnz short loc_1C888
lea rax, aTheDisplayUsed; "The display used by a swapchain does no"...
retn
loc_1C848:
cmp edi, 0C4653214h
jz short loc_1C880
cmp edi, 0C46535FFh
jnz short loc_1C888
lea rax, aTheRequestedWi; "The requested window is already connect"...
retn
def_1C81E:
cmp edi, 0C4653600h; jumptable 000000000001C81E default case
jz short loc_1C8B8
cmp edi, 3B9ACDEBh
jnz short loc_1C888
lea rax, aASwapchainNoLo; "A swapchain no longer matches the surfa"...
retn
loc_1C878:
lea rax, aAValidationLay; "A validation layer found an error"
retn
loc_1C880:
lea rax, aASurfaceHasCha; "A surface has changed in such a way tha"...
retn
loc_1C888:
lea rax, aErrorUnknownVu; "ERROR: UNKNOWN VULKAN ERROR"
retn
loc_1C890:
lea rax, aAReturnArrayWa; jumptable 000000000001C81E case 5
retn
loc_1C898:
lea rax, aAnEventIsSigna; jumptable 000000000001C81E case 3
retn
loc_1C8A0:
lea rax, aSuccess; jumptable 000000000001C81E case 0
retn
loc_1C8A8:
lea rax, aARequestedExte; jumptable 000000000001C81E case -7
retn
loc_1C8B0:
lea rax, aAFenceOrQueryH; jumptable 000000000001C81E case 1
retn
loc_1C8B8:
lea rax, aASurfaceIsNoLo; "A surface is no longer available"
retn
loc_1C8C0:
lea rax, aADeviceMemoryA; jumptable 000000000001C81E case -2
retn
loc_1C8C8:
lea rax, aTheRequestedVe; jumptable 000000000001C81E case -9
retn
loc_1C8D0:
lea rax, aAnEventIsUnsig; jumptable 000000000001C81E case 4
retn
loc_1C8D8:
lea rax, aARequestedFeat; jumptable 000000000001C81E case -8
retn
loc_1C8E0:
lea rax, aTheLogicalOrPh; jumptable 000000000001C81E case -4
retn
loc_1C8E8:
lea rax, aTooManyObjects; jumptable 000000000001C81E case -10
retn
loc_1C8F0:
lea rax, aARequestedLaye; jumptable 000000000001C81E case -6
retn
loc_1C8F8:
lea rax, aAWaitOperation; jumptable 000000000001C81E case 2
retn
loc_1C900:
lea rax, aMappingOfAMemo; jumptable 000000000001C81E case -5
retn
loc_1C908:
lea rax, aAHostMemoryAll; jumptable 000000000001C81E case -1
retn
loc_1C910:
lea rax, aInitialization; jumptable 000000000001C81E case -3
retn
|
const char * glfwGetVulkanResultString(int a1)
{
const char *result; // rax
if ( a1 <= -1000000001 )
{
if ( a1 > -1000001005 )
{
if ( a1 == -1000001004 )
return "A surface has changed in such a way that it is no longer compatible with the swapchain";
if ( a1 == -1000000001 )
return "The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API";
}
else
{
if ( a1 == -1000011001 )
return "A validation layer found an error";
if ( a1 == -1000003001 )
return "The display used by a swapchain does not use the same presentable image layout";
}
return "ERROR: UNKNOWN VULKAN ERROR";
}
else
{
switch ( a1 )
{
case -11:
result = "A requested format is not supported on this device";
break;
case -10:
result = "Too many objects of the type have already been created";
break;
case -9:
result = "The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
break;
case -8:
result = "A requested feature is not supported";
break;
case -7:
result = "A requested extension is not supported";
break;
case -6:
result = "A requested layer is not present or could not be loaded";
break;
case -5:
result = "Mapping of a memory object has failed";
break;
case -4:
result = "The logical or physical device has been lost";
break;
case -3:
result = "Initialization of an object could not be completed for implementation-specific reasons";
break;
case -2:
result = "A device memory allocation has failed";
break;
case -1:
result = "A host memory allocation has failed";
break;
case 0:
result = "Success";
break;
case 1:
result = "A fence or query has not yet completed";
break;
case 2:
result = "A wait operation has not completed in the specified time";
break;
case 3:
result = "An event is signaled";
break;
case 4:
result = "An event is unsignaled";
break;
case 5:
result = "A return array was too small for the result";
break;
default:
if ( a1 == -1000000000 )
{
result = "A surface is no longer available";
}
else
{
if ( a1 != 1000001003 )
return "ERROR: UNKNOWN VULKAN ERROR";
result = "A swapchain no longer matches the surface properties exactly, but can still be used";
}
break;
}
}
return result;
}
|
_glfwGetVulkanResultString:
CMP EDI,0xc46535ff
JLE 0x0011c828
LEA EAX,[RDI + 0xb]
CMP EAX,0x10
JA 0x0011c860
LEA RCX,[0x1838cc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_fffffff5:
LEA RAX,[0x183d15]
RET
LAB_0011c828:
CMP EDI,0xc4653213
JG 0x0011c848
CMP EDI,0xc4650b07
JZ 0x0011c878
CMP EDI,0xc4652a47
JNZ 0x0011c888
LEA RAX,[0x183e14]
RET
LAB_0011c848:
CMP EDI,0xc4653214
JZ 0x0011c880
CMP EDI,0xc46535ff
JNZ 0x0011c888
LEA RAX,[0x183e63]
RET
default:
CMP EDI,0xc4653600
JZ 0x0011c8b8
CMP EDI,0x3b9acdeb
JNZ 0x0011c888
LEA RAX,[0x183d69]
RET
LAB_0011c878:
LEA RAX,[0x183ec0]
RET
LAB_0011c880:
LEA RAX,[0x183dbd]
RET
LAB_0011c888:
LEA RAX,[0x183ee2]
RET
caseD_5:
LEA RAX,[0x183ade]
RET
caseD_3:
LEA RAX,[0x183ab2]
RET
caseD_0:
LEA RAX,[0x183a4a]
RET
caseD_fffffff9:
LEA RAX,[0x183c36]
RET
caseD_1:
LEA RAX,[0x183a52]
RET
LAB_0011c8b8:
LEA RAX,[0x183d48]
RET
caseD_fffffffe:
LEA RAX,[0x183b2e]
RET
caseD_fffffff7:
LEA RAX,[0x183c82]
RET
caseD_4:
LEA RAX,[0x183ac7]
RET
caseD_fffffff8:
LEA RAX,[0x183c5d]
RET
caseD_fffffffc:
LEA RAX,[0x183bab]
RET
caseD_fffffff6:
LEA RAX,[0x183cde]
RET
caseD_fffffffa:
LEA RAX,[0x183bfe]
RET
caseD_2:
LEA RAX,[0x183a79]
RET
caseD_fffffffb:
LEA RAX,[0x183bd8]
RET
caseD_ffffffff:
LEA RAX,[0x183b0a]
RET
caseD_fffffffd:
LEA RAX,[0x183b54]
RET
|
char * _glfwGetVulkanResultString(int param_1)
{
if (param_1 < -1000000000) {
if (param_1 < -0x3b9acdec) {
if (param_1 == -0x3b9af4f9) {
return "A validation layer found an error";
}
if (param_1 == -0x3b9ad5b9) {
return "The display used by a swapchain does not use the same presentable image layout";
}
}
else {
if (param_1 == -0x3b9acdec) {
return
"A surface has changed in such a way that it is no longer compatible with the swapchain";
}
if (param_1 == -0x3b9aca01) {
return
"The requested window is already connected to a VkSurfaceKHR, or to some other non-Vulkan API"
;
}
}
}
else {
switch(param_1) {
case 0:
return "Success";
case 1:
return "A fence or query has not yet completed";
case 2:
return "A wait operation has not completed in the specified time";
case 3:
return "An event is signaled";
case 4:
return "An event is unsignaled";
case 5:
return "A return array was too small for the result";
case -0xb:
return "A requested format is not supported on this device";
case -10:
return "Too many objects of the type have already been created";
case -9:
return
"The requested version of Vulkan is not supported by the driver or is otherwise incompatible";
case -8:
return "A requested feature is not supported";
case -7:
return "A requested extension is not supported";
case -6:
return "A requested layer is not present or could not be loaded";
case -5:
return "Mapping of a memory object has failed";
case -4:
return "The logical or physical device has been lost";
case -3:
return
"Initialization of an object could not be completed for implementation-specific reasons";
case -2:
return "A device memory allocation has failed";
case -1:
return "A host memory allocation has failed";
}
if (param_1 == -1000000000) {
return "A surface is no longer available";
}
if (param_1 == 0x3b9acdeb) {
return "A swapchain no longer matches the surface properties exactly, but can still be used";
}
}
return "ERROR: UNKNOWN VULKAN ERROR";
}
|
|
60,058
|
rlLoadShaderCode
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h
|
unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode)
{
unsigned int id = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
unsigned int vertexShaderId = 0;
unsigned int fragmentShaderId = 0;
// Compile vertex shader (if provided)
// NOTE: If not vertex shader is provided, use default one
if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER);
else vertexShaderId = RLGL.State.defaultVShaderId;
// Compile fragment shader (if provided)
// NOTE: If not vertex shader is provided, use default one
if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER);
else fragmentShaderId = RLGL.State.defaultFShaderId;
// In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id
if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId;
else if ((vertexShaderId > 0) && (fragmentShaderId > 0))
{
// One of or both shader are new, we need to compile a new shader program
id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId);
// We can detach and delete vertex/fragment shaders (if not default ones)
// NOTE: We detach shader before deletion to make sure memory is freed
if (vertexShaderId != RLGL.State.defaultVShaderId)
{
// WARNING: Shader program linkage could fail and returned id is 0
if (id > 0) glDetachShader(id, vertexShaderId);
glDeleteShader(vertexShaderId);
}
if (fragmentShaderId != RLGL.State.defaultFShaderId)
{
// WARNING: Shader program linkage could fail and returned id is 0
if (id > 0) glDetachShader(id, fragmentShaderId);
glDeleteShader(fragmentShaderId);
}
// In case shader program loading failed, we assign default shader
if (id == 0)
{
// In case shader loading fails, we return the default shader
TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader");
id = RLGL.State.defaultShaderId;
}
/*
else
{
// Get available shader uniforms
// NOTE: This information is useful for debug...
int uniformCount = -1;
glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);
for (int i = 0; i < uniformCount; i++)
{
int namelen = -1;
int num = -1;
char name[256] = { 0 }; // Assume no variable names longer than 256
GLenum type = GL_ZERO;
// Get the name of the uniforms
glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
name[namelen] = 0;
TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
}
}
*/
}
#endif
return id;
}
|
O2
|
c
|
rlLoadShaderCode:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x553d9
movl $0x8b31, %esi # imm = 0x8B31
callq 0x5549b
movl %eax, %ebx
jmp 0x553df
movl 0xd2685(%rip), %ebx # 0x127a64
testq %r14, %r14
je 0x553fb
movq %r14, %rdi
movl $0x8b30, %esi # imm = 0x8B30
callq 0x5549b
movl %eax, %ebp
movl 0xd266f(%rip), %eax # 0x127a68
jmp 0x55403
movl 0xd2667(%rip), %eax # 0x127a68
movl %eax, %ebp
cmpl 0xd265b(%rip), %ebx # 0x127a64
jne 0x55418
cmpl %eax, %ebp
jne 0x55418
movl 0xd2656(%rip), %r14d # 0x127a6c
jmp 0x5547d
testl %ebx, %ebx
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
xorl %r14d, %r14d
cmpb $0x1, %cl
jne 0x5547d
movl %ebx, %edi
movl %ebp, %esi
callq 0x555ef
movl %eax, %r14d
cmpl 0xd2626(%rip), %ebx # 0x127a64
je 0x55458
testl %r14d, %r14d
je 0x55450
movl %r14d, %edi
movl %ebx, %esi
callq *0xd02f8(%rip) # 0x125748
movl %ebx, %edi
callq *0xd0288(%rip) # 0x1256e0
cmpl 0xd260a(%rip), %ebp # 0x127a68
je 0x55478
testl %r14d, %r14d
je 0x55470
movl %r14d, %edi
movl %ebp, %esi
callq *0xd02d8(%rip) # 0x125748
movl %ebp, %edi
callq *0xd0268(%rip) # 0x1256e0
testl %r14d, %r14d
je 0x55485
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7011c(%rip), %rsi # 0xc55a8
pushq $0x4
popq %rdi
xorl %eax, %eax
callq 0xa128b
jmp 0x5540f
|
rlLoadShaderCode:
push rbp
push r14
push rbx
mov r14, rsi
test rdi, rdi
jz short loc_553D9
mov esi, 8B31h
call rlCompileShader
mov ebx, eax
jmp short loc_553DF
loc_553D9:
mov ebx, cs:dword_127A64
loc_553DF:
test r14, r14
jz short loc_553FB
mov rdi, r14
mov esi, 8B30h
call rlCompileShader
mov ebp, eax
mov eax, cs:dword_127A68
jmp short loc_55403
loc_553FB:
mov eax, cs:dword_127A68
mov ebp, eax
loc_55403:
cmp ebx, cs:dword_127A64
jnz short loc_55418
cmp ebp, eax
jnz short loc_55418
loc_5540F:
mov r14d, cs:dword_127A6C
jmp short loc_5547D
loc_55418:
test ebx, ebx
setnz al
test ebp, ebp
setnz cl
and cl, al
xor r14d, r14d
cmp cl, 1
jnz short loc_5547D
mov edi, ebx
mov esi, ebp
call rlLoadShaderProgram
mov r14d, eax
cmp ebx, cs:dword_127A64
jz short loc_55458
test r14d, r14d
jz short loc_55450
mov edi, r14d
mov esi, ebx
call cs:glad_glDetachShader
loc_55450:
mov edi, ebx
call cs:glad_glDeleteShader
loc_55458:
cmp ebp, cs:dword_127A68
jz short loc_55478
test r14d, r14d
jz short loc_55470
mov edi, r14d
mov esi, ebp
call cs:glad_glDetachShader
loc_55470:
mov edi, ebp
call cs:glad_glDeleteShader
loc_55478:
test r14d, r14d
jz short loc_55485
loc_5547D:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_55485:
lea rsi, aShaderFailedTo; "SHADER: Failed to load custom shader co"...
push 4
pop rdi
xor eax, eax
call TraceLog
jmp loc_5540F
|
long long rlLoadShaderCode(long long a1, long long a2)
{
unsigned int v2; // ebx
unsigned int v3; // ebp
int v4; // eax
unsigned int v5; // r14d
unsigned int ShaderProgram; // eax
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
if ( a1 )
v2 = rlCompileShader(a1, 35633LL);
else
v2 = dword_127A64;
if ( a2 )
{
v3 = rlCompileShader(a2, 35632LL);
v4 = dword_127A68;
}
else
{
v4 = dword_127A68;
v3 = dword_127A68;
}
if ( v2 == dword_127A64 && v3 == v4 )
return (unsigned int)dword_127A6C;
v5 = 0;
if ( v2 != 0 && v3 != 0 )
{
ShaderProgram = rlLoadShaderProgram(v2, v3);
v5 = ShaderProgram;
if ( v2 != dword_127A64 )
{
if ( ShaderProgram )
glad_glDetachShader(ShaderProgram, v2);
glad_glDeleteShader(v2);
}
if ( v3 != dword_127A68 )
{
if ( v5 )
glad_glDetachShader(v5, v3);
glad_glDeleteShader(v3);
}
if ( !v5 )
{
TraceLog(4, (unsigned int)"SHADER: Failed to load custom shader code, using default shader", v7, v8, v9, v10);
return (unsigned int)dword_127A6C;
}
}
return v5;
}
|
rlLoadShaderCode:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RSI
TEST RDI,RDI
JZ 0x001553d9
MOV ESI,0x8b31
CALL 0x0015549b
MOV EBX,EAX
JMP 0x001553df
LAB_001553d9:
MOV EBX,dword ptr [0x00227a64]
LAB_001553df:
TEST R14,R14
JZ 0x001553fb
MOV RDI,R14
MOV ESI,0x8b30
CALL 0x0015549b
MOV EBP,EAX
MOV EAX,dword ptr [0x00227a68]
JMP 0x00155403
LAB_001553fb:
MOV EAX,dword ptr [0x00227a68]
MOV EBP,EAX
LAB_00155403:
CMP EBX,dword ptr [0x00227a64]
JNZ 0x00155418
CMP EBP,EAX
JNZ 0x00155418
LAB_0015540f:
MOV R14D,dword ptr [0x00227a6c]
JMP 0x0015547d
LAB_00155418:
TEST EBX,EBX
SETNZ AL
TEST EBP,EBP
SETNZ CL
AND CL,AL
XOR R14D,R14D
CMP CL,0x1
JNZ 0x0015547d
MOV EDI,EBX
MOV ESI,EBP
CALL 0x001555ef
MOV R14D,EAX
CMP EBX,dword ptr [0x00227a64]
JZ 0x00155458
TEST R14D,R14D
JZ 0x00155450
MOV EDI,R14D
MOV ESI,EBX
CALL qword ptr [0x00225748]
LAB_00155450:
MOV EDI,EBX
CALL qword ptr [0x002256e0]
LAB_00155458:
CMP EBP,dword ptr [0x00227a68]
JZ 0x00155478
TEST R14D,R14D
JZ 0x00155470
MOV EDI,R14D
MOV ESI,EBP
CALL qword ptr [0x00225748]
LAB_00155470:
MOV EDI,EBP
CALL qword ptr [0x002256e0]
LAB_00155478:
TEST R14D,R14D
JZ 0x00155485
LAB_0015547d:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_00155485:
LEA RSI,[0x1c55a8]
PUSH 0x4
POP RDI
XOR EAX,EAX
CALL 0x001a128b
JMP 0x0015540f
|
int rlLoadShaderCode(long param_1,long param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar1 = DAT_00227a64;
if (param_1 != 0) {
iVar1 = rlCompileShader(param_1,0x8b31);
}
iVar2 = DAT_00227a68;
if (param_2 != 0) {
iVar2 = rlCompileShader(param_2,0x8b30);
}
if (((iVar1 != DAT_00227a64) || (iVar3 = DAT_00227a6c, iVar2 != DAT_00227a68)) &&
(iVar3 = 0, iVar2 != 0 && iVar1 != 0)) {
iVar3 = rlLoadShaderProgram(iVar1,iVar2);
if (iVar1 != DAT_00227a64) {
if (iVar3 != 0) {
(*glad_glDetachShader)(iVar3,iVar1);
}
(*glad_glDeleteShader)(iVar1);
}
if (iVar2 != DAT_00227a68) {
if (iVar3 != 0) {
(*glad_glDetachShader)(iVar3,iVar2);
}
(*glad_glDeleteShader)(iVar2);
}
if (iVar3 == 0) {
TraceLog(4,"SHADER: Failed to load custom shader code, using default shader");
iVar3 = DAT_00227a6c;
}
}
return iVar3;
}
|
|
60,059
|
rlLoadShaderCode
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rlgl.h
|
unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode)
{
unsigned int id = 0;
#if defined(GRAPHICS_API_OPENGL_33) || defined(GRAPHICS_API_OPENGL_ES2)
unsigned int vertexShaderId = 0;
unsigned int fragmentShaderId = 0;
// Compile vertex shader (if provided)
// NOTE: If not vertex shader is provided, use default one
if (vsCode != NULL) vertexShaderId = rlCompileShader(vsCode, GL_VERTEX_SHADER);
else vertexShaderId = RLGL.State.defaultVShaderId;
// Compile fragment shader (if provided)
// NOTE: If not vertex shader is provided, use default one
if (fsCode != NULL) fragmentShaderId = rlCompileShader(fsCode, GL_FRAGMENT_SHADER);
else fragmentShaderId = RLGL.State.defaultFShaderId;
// In case vertex and fragment shader are the default ones, no need to recompile, we can just assign the default shader program id
if ((vertexShaderId == RLGL.State.defaultVShaderId) && (fragmentShaderId == RLGL.State.defaultFShaderId)) id = RLGL.State.defaultShaderId;
else if ((vertexShaderId > 0) && (fragmentShaderId > 0))
{
// One of or both shader are new, we need to compile a new shader program
id = rlLoadShaderProgram(vertexShaderId, fragmentShaderId);
// We can detach and delete vertex/fragment shaders (if not default ones)
// NOTE: We detach shader before deletion to make sure memory is freed
if (vertexShaderId != RLGL.State.defaultVShaderId)
{
// WARNING: Shader program linkage could fail and returned id is 0
if (id > 0) glDetachShader(id, vertexShaderId);
glDeleteShader(vertexShaderId);
}
if (fragmentShaderId != RLGL.State.defaultFShaderId)
{
// WARNING: Shader program linkage could fail and returned id is 0
if (id > 0) glDetachShader(id, fragmentShaderId);
glDeleteShader(fragmentShaderId);
}
// In case shader program loading failed, we assign default shader
if (id == 0)
{
// In case shader loading fails, we return the default shader
TRACELOG(RL_LOG_WARNING, "SHADER: Failed to load custom shader code, using default shader");
id = RLGL.State.defaultShaderId;
}
/*
else
{
// Get available shader uniforms
// NOTE: This information is useful for debug...
int uniformCount = -1;
glGetProgramiv(id, GL_ACTIVE_UNIFORMS, &uniformCount);
for (int i = 0; i < uniformCount; i++)
{
int namelen = -1;
int num = -1;
char name[256] = { 0 }; // Assume no variable names longer than 256
GLenum type = GL_ZERO;
// Get the name of the uniforms
glGetActiveUniform(id, i, sizeof(name) - 1, &namelen, &num, &type, name);
name[namelen] = 0;
TRACELOGD("SHADER: [ID %i] Active uniform (%s) set at location: %i", id, name, glGetUniformLocation(id, name));
}
}
*/
}
#endif
return id;
}
|
O3
|
c
|
rlLoadShaderCode:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x652f4
movl $0x8b31, %esi # imm = 0x8B31
callq 0x653b8
movl %eax, %ebx
jmp 0x652fa
movl 0xd674a(%rip), %ebx # 0x13ba44
testq %r14, %r14
je 0x65316
movq %r14, %rdi
movl $0x8b30, %esi # imm = 0x8B30
callq 0x653b8
movl %eax, %ebp
movl 0xd6734(%rip), %eax # 0x13ba48
jmp 0x6531e
movl 0xd672c(%rip), %eax # 0x13ba48
movl %eax, %ebp
cmpl 0xd6720(%rip), %ebx # 0x13ba44
jne 0x65333
cmpl %eax, %ebp
jne 0x65333
movl 0xd671b(%rip), %r14d # 0x13ba4c
jmp 0x65398
testl %ebx, %ebx
setne %al
testl %ebp, %ebp
setne %cl
andb %al, %cl
xorl %r14d, %r14d
cmpb $0x1, %cl
jne 0x65398
movl %ebx, %edi
movl %ebp, %esi
callq 0x65522
movl %eax, %r14d
cmpl 0xd66eb(%rip), %ebx # 0x13ba44
je 0x65373
testl %r14d, %r14d
je 0x6536b
movl %r14d, %edi
movl %ebx, %esi
callq *0xd43bd(%rip) # 0x139728
movl %ebx, %edi
callq *0xd434d(%rip) # 0x1396c0
cmpl 0xd66cf(%rip), %ebp # 0x13ba48
je 0x65393
testl %r14d, %r14d
je 0x6538b
movl %r14d, %edi
movl %ebp, %esi
callq *0xd439d(%rip) # 0x139728
movl %ebp, %edi
callq *0xd432d(%rip) # 0x1396c0
testl %r14d, %r14d
je 0x653a0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7a079(%rip), %rsi # 0xdf420
movl $0x4, %edi
xorl %eax, %eax
callq 0xb9db7
jmp 0x6532a
|
rlLoadShaderCode:
push rbp
push r14
push rbx
mov r14, rsi
test rdi, rdi
jz short loc_652F4
mov esi, 8B31h
call rlCompileShader
mov ebx, eax
jmp short loc_652FA
loc_652F4:
mov ebx, cs:dword_13BA44
loc_652FA:
test r14, r14
jz short loc_65316
mov rdi, r14
mov esi, 8B30h
call rlCompileShader
mov ebp, eax
mov eax, cs:dword_13BA48
jmp short loc_6531E
loc_65316:
mov eax, cs:dword_13BA48
mov ebp, eax
loc_6531E:
cmp ebx, cs:dword_13BA44
jnz short loc_65333
cmp ebp, eax
jnz short loc_65333
loc_6532A:
mov r14d, cs:dword_13BA4C
jmp short loc_65398
loc_65333:
test ebx, ebx
setnz al
test ebp, ebp
setnz cl
and cl, al
xor r14d, r14d
cmp cl, 1
jnz short loc_65398
mov edi, ebx
mov esi, ebp
call rlLoadShaderProgram
mov r14d, eax
cmp ebx, cs:dword_13BA44
jz short loc_65373
test r14d, r14d
jz short loc_6536B
mov edi, r14d
mov esi, ebx
call cs:glad_glDetachShader
loc_6536B:
mov edi, ebx
call cs:glad_glDeleteShader
loc_65373:
cmp ebp, cs:dword_13BA48
jz short loc_65393
test r14d, r14d
jz short loc_6538B
mov edi, r14d
mov esi, ebp
call cs:glad_glDetachShader
loc_6538B:
mov edi, ebp
call cs:glad_glDeleteShader
loc_65393:
test r14d, r14d
jz short loc_653A0
loc_65398:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_653A0:
lea rsi, aShaderFailedTo; "SHADER: Failed to load custom shader co"...
mov edi, 4
xor eax, eax
call TraceLog
jmp loc_6532A
|
long long rlLoadShaderCode(long long a1, long long a2)
{
unsigned int v2; // ebx
unsigned int v3; // ebp
int v4; // eax
unsigned int v5; // r14d
unsigned int ShaderProgram; // eax
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
if ( a1 )
v2 = rlCompileShader(a1, 35633LL);
else
v2 = dword_13BA44;
if ( a2 )
{
v3 = rlCompileShader(a2, 35632LL);
v4 = dword_13BA48;
}
else
{
v4 = dword_13BA48;
v3 = dword_13BA48;
}
if ( v2 == dword_13BA44 && v3 == v4 )
return (unsigned int)dword_13BA4C;
v5 = 0;
if ( v2 != 0 && v3 != 0 )
{
ShaderProgram = rlLoadShaderProgram(v2, v3);
v5 = ShaderProgram;
if ( v2 != dword_13BA44 )
{
if ( ShaderProgram )
glad_glDetachShader(ShaderProgram, v2);
glad_glDeleteShader(v2);
}
if ( v3 != dword_13BA48 )
{
if ( v5 )
glad_glDetachShader(v5, v3);
glad_glDeleteShader(v3);
}
if ( !v5 )
{
TraceLog(4, (unsigned int)"SHADER: Failed to load custom shader code, using default shader", v7, v8, v9, v10);
return (unsigned int)dword_13BA4C;
}
}
return v5;
}
|
rlLoadShaderCode:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RSI
TEST RDI,RDI
JZ 0x001652f4
MOV ESI,0x8b31
CALL 0x001653b8
MOV EBX,EAX
JMP 0x001652fa
LAB_001652f4:
MOV EBX,dword ptr [0x0023ba44]
LAB_001652fa:
TEST R14,R14
JZ 0x00165316
MOV RDI,R14
MOV ESI,0x8b30
CALL 0x001653b8
MOV EBP,EAX
MOV EAX,dword ptr [0x0023ba48]
JMP 0x0016531e
LAB_00165316:
MOV EAX,dword ptr [0x0023ba48]
MOV EBP,EAX
LAB_0016531e:
CMP EBX,dword ptr [0x0023ba44]
JNZ 0x00165333
CMP EBP,EAX
JNZ 0x00165333
LAB_0016532a:
MOV R14D,dword ptr [0x0023ba4c]
JMP 0x00165398
LAB_00165333:
TEST EBX,EBX
SETNZ AL
TEST EBP,EBP
SETNZ CL
AND CL,AL
XOR R14D,R14D
CMP CL,0x1
JNZ 0x00165398
MOV EDI,EBX
MOV ESI,EBP
CALL 0x00165522
MOV R14D,EAX
CMP EBX,dword ptr [0x0023ba44]
JZ 0x00165373
TEST R14D,R14D
JZ 0x0016536b
MOV EDI,R14D
MOV ESI,EBX
CALL qword ptr [0x00239728]
LAB_0016536b:
MOV EDI,EBX
CALL qword ptr [0x002396c0]
LAB_00165373:
CMP EBP,dword ptr [0x0023ba48]
JZ 0x00165393
TEST R14D,R14D
JZ 0x0016538b
MOV EDI,R14D
MOV ESI,EBP
CALL qword ptr [0x00239728]
LAB_0016538b:
MOV EDI,EBP
CALL qword ptr [0x002396c0]
LAB_00165393:
TEST R14D,R14D
JZ 0x001653a0
LAB_00165398:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_001653a0:
LEA RSI,[0x1df420]
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001b9db7
JMP 0x0016532a
|
int rlLoadShaderCode(long param_1,long param_2)
{
int iVar1;
int iVar2;
int iVar3;
iVar1 = DAT_0023ba44;
if (param_1 != 0) {
iVar1 = rlCompileShader(param_1,0x8b31);
}
iVar2 = DAT_0023ba48;
if (param_2 != 0) {
iVar2 = rlCompileShader(param_2,0x8b30);
}
if (((iVar1 != DAT_0023ba44) || (iVar3 = DAT_0023ba4c, iVar2 != DAT_0023ba48)) &&
(iVar3 = 0, iVar2 != 0 && iVar1 != 0)) {
iVar3 = rlLoadShaderProgram(iVar1,iVar2);
if (iVar1 != DAT_0023ba44) {
if (iVar3 != 0) {
(*glad_glDetachShader)(iVar3,iVar1);
}
(*glad_glDeleteShader)(iVar1);
}
if (iVar2 != DAT_0023ba48) {
if (iVar3 != 0) {
(*glad_glDetachShader)(iVar3,iVar2);
}
(*glad_glDeleteShader)(iVar2);
}
if (iVar3 == 0) {
TraceLog(4,"SHADER: Failed to load custom shader code, using default shader");
iVar3 = DAT_0023ba4c;
}
}
return iVar3;
}
|
|
60,060
|
string_format[abi:cxx11](char const*, ...)
|
monkey531[P]llama/common/common.cpp
|
std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
}
|
O0
|
cpp
|
string_format[abi:cxx11](char const*, ...):
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x30(%rsp)
movq %rdi, %r10
movq %r10, 0x38(%rsp)
testb %al, %al
je 0x66b55
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %r9, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x170(%rsp)
movq %rsi, 0x168(%rsp)
leaq 0x150(%rsp), %rax
leaq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x180(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0x130(%rsp), %rax
leaq 0x150(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x168(%rsp), %rdx
leaq 0x150(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x56288
movl %eax, 0x12c(%rsp)
cmpl $0x0, 0x12c(%rsp)
jl 0x66bfb
cmpl $0x7fffffff, 0x12c(%rsp) # imm = 0x7FFFFFFF
jl 0x66c1c
leaq 0x15dab3(%rip), %rdi # 0x1c46b5
movl $0x1b2, %esi # imm = 0x1B2
leaq 0x15bcdd(%rip), %rdx # 0x1c28eb
leaq 0x15daec(%rip), %rcx # 0x1c4701
movb $0x0, %al
callq 0x55cd0
movl 0x12c(%rsp), %eax
incl %eax
cltq
movq %rax, 0x20(%rsp)
leaq 0x10f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x55e80
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x110(%rsp), %rdi
callq 0x62040
jmp 0x66c57
leaq 0x10f(%rsp), %rdi
callq 0x56270
leaq 0x110(%rsp), %rdi
callq 0x620c0
movq %rax, %rdi
movl 0x12c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq 0x168(%rsp), %rdx
leaq 0x130(%rsp), %rcx
callq 0x56288
movl %eax, 0xf8(%rsp)
movl 0xf8(%rsp), %eax
cmpl 0x12c(%rsp), %eax
je 0x66d0f
leaq 0x15da01(%rip), %rdi # 0x1c46b5
leaq 0x15bc30(%rip), %rdx # 0x1c28eb
leaq 0x15da5b(%rip), %rcx # 0x1c471d
xorl %eax, %eax
movl $0x1b5, %esi # imm = 0x1B5
callq 0x55cd0
jmp 0x66cd0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x10f(%rsp), %rdi
callq 0x56270
jmp 0x66db0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x66da3
leaq 0x110(%rsp), %rdi
callq 0x620c0
movq %rax, 0x8(%rsp)
movslq 0x12c(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xf7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x55e80
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x56160
jmp 0x66d5b
leaq 0xf7(%rsp), %rdi
callq 0x56270
leaq 0x110(%rsp), %rdi
callq 0x620e0
movq 0x38(%rsp), %rax
addq $0x178, %rsp # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xf7(%rsp), %rdi
callq 0x56270
leaq 0x110(%rsp), %rdi
callq 0x620e0
movq 0x100(%rsp), %rdi
callq 0x55a10
nopl (%rax)
|
_Z13string_formatB5cxx11PKcz:
sub rsp, 178h
mov [rsp+178h+var_148], rdi
mov r10, rdi
mov [rsp+178h+var_140], r10
test al, al
jz short loc_66B55
movaps [rsp+178h+var_108], xmm0
movaps [rsp+178h+var_F8], xmm1
movaps [rsp+178h+var_E8], xmm2
movaps [rsp+178h+var_D8], xmm3
movaps [rsp+178h+var_C8], xmm4
movaps [rsp+178h+var_B8], xmm5
movaps [rsp+178h+var_A8], xmm6
movaps [rsp+178h+var_98], xmm7
loc_66B55:
mov [rsp+178h+var_110], r9
mov [rsp+178h+var_118], r8
mov [rsp+178h+var_120], rcx
mov [rsp+178h+var_128], rdx
mov [rsp+178h+var_8], rdi
mov [rsp+178h+var_10], rsi
lea rax, [rsp+178h+var_28]
lea rcx, [rsp+178h+var_138]
mov [rax+10h], rcx
lea rcx, [rsp+178h+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
lea rax, [rsp+178h+var_48]
lea rcx, [rsp+178h+var_28]
mov rdx, [rcx+10h]
mov [rax+10h], rdx
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rax], xmm0
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_28]
xor eax, eax
mov esi, eax
mov rdi, rsi
call vsnprintf
mov [rsp+178h+var_4C], eax
cmp [rsp+178h+var_4C], 0
jl short loc_66BFB
cmp [rsp+178h+var_4C], 7FFFFFFFh
jl short loc_66C1C
loc_66BFB:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1B2h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov al, 0
call _ggml_abort
loc_66C1C:
mov eax, [rsp+178h+var_4C]
inc eax
cdqe
mov [rsp+178h+var_158], rax
lea rdi, [rsp+178h+var_69]
mov [rsp+178h+var_150], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+178h+var_158]
mov rdx, [rsp+178h+var_150]
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
jmp short $+2
loc_66C57:
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov rdi, rax
mov eax, [rsp+178h+var_4C]
add eax, 1
movsxd rsi, eax
mov rdx, [rsp+178h+var_10]
lea rcx, [rsp+178h+var_48]
call vsnprintf
mov [rsp+178h+var_80], eax
mov eax, [rsp+178h+var_80]
cmp eax, [rsp+178h+var_4C]
jz short loc_66D0F
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
xor eax, eax
mov esi, 1B5h
call _ggml_abort
jmp short $+2
loc_66CD0:
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_66DB0
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
jmp loc_66DA3
loc_66D0F:
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEE4dataEv; std::vector<char>::data(void)
mov [rsp+178h+var_170], rax
movsxd rax, [rsp+178h+var_4C]
mov [rsp+178h+var_168], rax
lea rdi, [rsp+178h+var_81]
mov [rsp+178h+var_160], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdi, [rsp+178h+var_148]
mov rsi, [rsp+178h+var_170]
mov rdx, [rsp+178h+var_168]
mov rcx, [rsp+178h+var_160]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcmRKS3_; std::string::basic_string(char const*,ulong,std::allocator<char> const&)
jmp short $+2
loc_66D5B:
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
mov rax, [rsp+178h+var_140]
add rsp, 178h
retn
mov rcx, rax
mov eax, edx
mov [rsp+178h+var_78], rcx
mov [rsp+178h+var_7C], eax
lea rdi, [rsp+178h+var_81]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_66DA3:
lea rdi, [rsp+178h+var_68]
call _ZNSt6vectorIcSaIcEED2Ev; std::vector<char>::~vector()
loc_66DB0:
mov rdi, [rsp+178h+var_78]
call __Unwind_Resume
|
long long string_format[abi:cxx11](
long long a1,
long long a2,
long long 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 a15)
{
long long v15; // rax
int v16; // edx
long long v18; // [rsp+8h] [rbp-170h]
long long v19; // [rsp+10h] [rbp-168h]
long long v20; // [rsp+20h] [rbp-158h]
_BYTE v21[16]; // [rsp+40h] [rbp-138h] BYREF
long long v22; // [rsp+50h] [rbp-128h]
long long v23; // [rsp+58h] [rbp-120h]
long long v24; // [rsp+60h] [rbp-118h]
long long v25; // [rsp+68h] [rbp-110h]
__m128 v26; // [rsp+70h] [rbp-108h]
__m128 v27; // [rsp+80h] [rbp-F8h]
__m128 v28; // [rsp+90h] [rbp-E8h]
__m128 v29; // [rsp+A0h] [rbp-D8h]
__m128 v30; // [rsp+B0h] [rbp-C8h]
__m128 v31; // [rsp+C0h] [rbp-B8h]
__m128 v32; // [rsp+D0h] [rbp-A8h]
__m128 v33; // [rsp+E0h] [rbp-98h]
char v34; // [rsp+F7h] [rbp-81h] BYREF
int v35; // [rsp+F8h] [rbp-80h]
int v36; // [rsp+FCh] [rbp-7Ch]
long long v37; // [rsp+100h] [rbp-78h]
char v38; // [rsp+10Fh] [rbp-69h] BYREF
long long v39[3]; // [rsp+110h] [rbp-68h] BYREF
unsigned int v40; // [rsp+12Ch] [rbp-4Ch]
__int128 v41; // [rsp+130h] [rbp-48h] BYREF
_BYTE *v42; // [rsp+140h] [rbp-38h]
__int128 v43; // [rsp+150h] [rbp-28h] BYREF
_BYTE *v44; // [rsp+160h] [rbp-18h]
long long v45; // [rsp+168h] [rbp-10h]
long long v46; // [rsp+170h] [rbp-8h]
v26 = a7;
v27 = a8;
v28 = a9;
v29 = a10;
v30 = a11;
v31 = a12;
v32 = a13;
v33 = a14;
v25 = a6;
v24 = a5;
v23 = a4;
v22 = a3;
v46 = a1;
v45 = a2;
v44 = v21;
*((_QWORD *)&v43 + 1) = &a15;
*(_QWORD *)&v43 = 0x3000000010LL;
v42 = v21;
v41 = v43;
v40 = vsnprintf(0LL, 0LL, a2, &v43);
if ( v40 > 0x7FFFFFFE )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
v20 = (int)(v40 + 1);
std::allocator<char>::allocator();
std::vector<char>::vector((long long)v39, v20, (long long)&v38);
std::allocator<char>::~allocator(&v38);
v15 = std::vector<char>::data(v39);
v35 = vsnprintf(v15, (int)(v40 + 1), v45, &v41);
if ( v35 != v40 )
{
v37 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
v36 = v16;
std::allocator<char>::~allocator(&v38);
_Unwind_Resume(v37);
}
v18 = std::vector<char>::data(v39);
v19 = (int)v40;
std::allocator<char>::allocator();
std::string::basic_string(a1, v18, v19, &v34);
std::allocator<char>::~allocator(&v34);
std::vector<char>::~vector(v39);
return a1;
}
|
string_format[abi:cxx11]:
SUB RSP,0x178
MOV qword ptr [RSP + 0x30],RDI
MOV R10,RDI
MOV qword ptr [RSP + 0x38],R10
TEST AL,AL
JZ 0x00166b55
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOVAPS xmmword ptr [RSP + 0x80],XMM1
MOVAPS xmmword ptr [RSP + 0x90],XMM2
MOVAPS xmmword ptr [RSP + 0xa0],XMM3
MOVAPS xmmword ptr [RSP + 0xb0],XMM4
MOVAPS xmmword ptr [RSP + 0xc0],XMM5
MOVAPS xmmword ptr [RSP + 0xd0],XMM6
MOVAPS xmmword ptr [RSP + 0xe0],XMM7
LAB_00166b55:
MOV qword ptr [RSP + 0x68],R9
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x58],RCX
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x170],RDI
MOV qword ptr [RSP + 0x168],RSI
LEA RAX,[RSP + 0x150]
LEA RCX,[RSP + 0x40]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RSP + 0x180]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LEA RAX,[RSP + 0x130]
LEA RCX,[RSP + 0x150]
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RAX],XMM0
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x150]
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00156288
MOV dword ptr [RSP + 0x12c],EAX
CMP dword ptr [RSP + 0x12c],0x0
JL 0x00166bfb
CMP dword ptr [RSP + 0x12c],0x7fffffff
JL 0x00166c1c
LAB_00166bfb:
LEA RDI,[0x2c46b5]
MOV ESI,0x1b2
LEA RDX,[0x2c28eb]
LEA RCX,[0x2c4701]
MOV AL,0x0
CALL 0x00155cd0
LAB_00166c1c:
MOV EAX,dword ptr [RSP + 0x12c]
INC EAX
CDQE
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x10f]
MOV qword ptr [RSP + 0x28],RDI
CALL 0x00155e80
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
LAB_00166c48:
LEA RDI,[RSP + 0x110]
CALL 0x00162040
JMP 0x00166c57
LAB_00166c57:
LEA RDI,[RSP + 0x10f]
CALL 0x00156270
LEA RDI,[RSP + 0x110]
CALL 0x001620c0
MOV RDI,RAX
MOV EAX,dword ptr [RSP + 0x12c]
ADD EAX,0x1
MOVSXD RSI,EAX
MOV RDX,qword ptr [RSP + 0x168]
LEA RCX,[RSP + 0x130]
CALL 0x00156288
MOV dword ptr [RSP + 0xf8],EAX
MOV EAX,dword ptr [RSP + 0xf8]
CMP EAX,dword ptr [RSP + 0x12c]
JZ 0x00166d0f
LAB_00166cad:
LEA RDI,[0x2c46b5]
LEA RDX,[0x2c28eb]
LEA RCX,[0x2c471d]
XOR EAX,EAX
MOV ESI,0x1b5
CALL 0x00155cd0
JMP 0x00166cd0
LAB_00166cd0:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x100],RCX
MOV dword ptr [RSP + 0xfc],EAX
LEA RDI,[RSP + 0x10f]
CALL 0x00156270
JMP 0x00166db0
LAB_00166d0f:
LEA RDI,[RSP + 0x110]
CALL 0x001620c0
MOV qword ptr [RSP + 0x8],RAX
MOVSXD RAX,dword ptr [RSP + 0x12c]
MOV qword ptr [RSP + 0x10],RAX
LEA RDI,[RSP + 0xf7]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00155e80
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
LAB_00166d54:
CALL 0x00156160
LAB_00166d59:
JMP 0x00166d5b
LAB_00166d5b:
LEA RDI,[RSP + 0xf7]
CALL 0x00156270
LEA RDI,[RSP + 0x110]
CALL 0x001620e0
MOV RAX,qword ptr [RSP + 0x38]
ADD RSP,0x178
RET
LAB_00166db0:
MOV RDI,qword ptr [RSP + 0x100]
CALL 0x00155a10
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
int iVar1;
char *pcVar2;
ulong uVar3;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int4 in_XMM0_Da;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
int1 auVar4 [12];
int1 local_138 [16];
int8 local_128;
int8 local_120;
int8 local_118;
int8 local_110;
int4 local_108;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
allocator local_81;
int local_80;
int4 local_7c;
int8 local_78;
allocator local_69;
vector<char,std::allocator<char>> local_68 [28];
int local_4c;
int8 local_48;
int1 *puStack_40;
int1 *local_38;
int4 local_28;
int4 uStack_24;
int1 *puStack_20;
int1 *local_18;
char *local_10;
char *local_8;
if (in_AL != '\0') {
local_108 = in_XMM0_Da;
local_f8 = in_XMM1_Qa;
local_e8 = in_XMM2_Qa;
local_d8 = in_XMM3_Qa;
local_c8 = in_XMM4_Qa;
local_b8 = in_XMM5_Qa;
local_a8 = in_XMM6_Qa;
local_98 = in_XMM7_Qa;
}
local_38 = local_138;
puStack_40 = &stack0x00000008;
uStack_24 = 0x30;
local_28 = 0x10;
local_48 = 0x3000000010;
local_128 = in_RDX;
local_120 = in_RCX;
local_118 = in_R8;
local_110 = in_R9;
puStack_20 = puStack_40;
local_18 = local_38;
local_10 = in_RSI;
local_8 = param_1;
local_4c = vsnprintf((char *)0x0,0,in_RSI,&local_28);
if ((local_4c < 0) || (0x7ffffffe < local_4c)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
iVar1 = local_4c + 1;
std::allocator<char>::allocator();
/* try { // try from 00166c48 to 00166c54 has its CatchHandler @ 00166cd0 */
std::vector<char,std::allocator<char>>::vector(local_68,(long)iVar1,&local_69);
std::allocator<char>::~allocator((allocator<char> *)&local_69);
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
local_80 = vsnprintf(pcVar2,(long)(local_4c + 1),local_10,&local_48);
if (local_80 != local_4c) {
/* try { // try from 00166cad to 00166ccd has its CatchHandler @ 00166cf6 */
auVar4 = ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp"
,0x1b5,"GGML_ASSERT(%s) failed","size2 == size");
local_7c = auVar4._8_4_;
local_78 = auVar4._0_8_;
/* catch() { ... } // from try @ 00166c48 with catch @ 00166cd0 */
std::allocator<char>::~allocator((allocator<char> *)&local_69);
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_78);
}
pcVar2 = (char *)std::vector<char,std::allocator<char>>::data(local_68);
uVar3 = (ulong)local_4c;
std::allocator<char>::allocator();
/* try { // try from 00166d54 to 00166d58 has its CatchHandler @ 00166d82 */
std::__cxx11::string::string((string *)param_1,pcVar2,uVar3,&local_81);
std::allocator<char>::~allocator((allocator<char> *)&local_81);
std::vector<char,std::allocator<char>>::~vector(local_68);
return param_1;
}
|
|
60,061
|
string_format[abi:cxx11](char const*, ...)
|
monkey531[P]llama/common/common.cpp
|
std::string string_format(const char * fmt, ...) {
va_list ap;
va_list ap2;
va_start(ap, fmt);
va_copy(ap2, ap);
int size = vsnprintf(NULL, 0, fmt, ap);
GGML_ASSERT(size >= 0 && size < INT_MAX); // NOLINT
std::vector<char> buf(size + 1);
int size2 = vsnprintf(buf.data(), size + 1, fmt, ap2);
GGML_ASSERT(size2 == size);
va_end(ap2);
va_end(ap);
return std::string(buf.data(), size);
}
|
O3
|
cpp
|
string_format[abi:cxx11](char const*, ...):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x22f06
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x140(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
movq %rsi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x28(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1aef8
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jae 0x22fcb
movl %eax, %r15d
leal 0x1(%r15), %r12d
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x219e0
movq (%r13), %rdi
leaq 0x20(%rsp), %rcx
movq %r12, %rsi
movq %r14, %rdx
callq 0x1aef8
cmpl %r15d, %eax
jne 0x22fec
movq 0x8(%rsp), %rsi
movl %r15d, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x20d82
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x22fb7
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a740
movq %rbx, %rax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x8aca3(%rip), %rdi # 0xadc75
leaq 0x89973(%rip), %rdx # 0xac94c
leaq 0x8ace1(%rip), %rcx # 0xadcc1
movl $0x1b2, %esi # imm = 0x1B2
xorl %eax, %eax
callq 0x1ac70
leaq 0x8ac82(%rip), %rdi # 0xadc75
leaq 0x89952(%rip), %rdx # 0xac94c
leaq 0x8acdc(%rip), %rcx # 0xadcdd
movl $0x1b5, %esi # imm = 0x1B5
xorl %eax, %eax
callq 0x1ac70
jmp 0x2300f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23029
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a740
movq %rbx, %rdi
callq 0x1ad30
|
_Z13string_formatB5cxx11PKcz:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+138h+var_D8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_22F06
movaps [rsp+138h+var_A8], xmm0
movaps [rsp+138h+var_98], xmm1
movaps [rsp+138h+var_88], xmm2
movaps [rsp+138h+var_78], xmm3
movaps [rsp+138h+var_68], xmm4
movaps [rsp+138h+var_58], xmm5
movaps [rsp+138h+var_48], xmm6
movaps [rsp+138h+var_38], xmm7
loc_22F06:
mov rax, 3000000010h
lea rcx, [rsp+138h+var_F8]
mov [rcx], rax
lea rax, [rsp+138h+arg_0]
mov [rcx+8], rax
mov [rcx+10h], rsi
mov [rsp+138h+var_108], rsi
mov rax, [rcx]
mov [rsp+138h+var_118], rax
mov rax, [rcx+8]
mov [rsp+138h+var_110], rax
xor edi, edi
xor esi, esi
mov rdx, r14
call vsnprintf
cmp eax, 7FFFFFFFh
jnb short loc_22FCB
mov r15d, eax
lea r12d, [r15+1]
lea r13, [rsp+138h+var_130]
lea rdx, [rsp+138h+var_131]
mov rdi, r13
mov rsi, r12
call _ZNSt6vectorIcSaIcEEC2EmRKS0_; std::vector<char>::vector(ulong,std::allocator<char> const&)
mov rdi, [r13+0]
lea rcx, [rsp+138h+var_118]
mov rsi, r12
mov rdx, r14
call vsnprintf
cmp eax, r15d
jnz short loc_22FEC
mov rsi, [rsp+138h+var_130]
mov edx, r15d
lea rax, [rbx+10h]
mov [rbx], rax
add rdx, rsi
mov rdi, rbx
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, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_22FB7
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_22FB7:
mov rax, rbx
add rsp, 110h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_22FCB:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize0SizeIntMa; "size >= 0 && size < INT_MAX"
mov esi, 1B2h
xor eax, eax
call _ggml_abort
loc_22FEC:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSize2Size; "size2 == size"
mov esi, 1B5h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_2300F:
mov rbx, rax
mov rdi, [rsp+138h+var_130]; void *
test rdi, rdi
jz short loc_23029
mov rsi, [rsp+138h+var_120]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23029:
mov rdi, rbx
call __Unwind_Resume
|
_QWORD * string_format[abi:cxx11](
_QWORD *a1,
long long a2,
long long 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 a15)
{
unsigned int v15; // eax
unsigned int v16; // r15d
long long v17; // r12
_BYTE *v18; // rsi
long long v20; // rbx
void *v21; // [rsp+8h] [rbp-130h] BYREF
long long v22; // [rsp+18h] [rbp-120h]
_QWORD v23[4]; // [rsp+20h] [rbp-118h] BYREF
_QWORD v24[4]; // [rsp+40h] [rbp-F8h] BYREF
_BYTE v25[16]; // [rsp+60h] [rbp-D8h] BYREF
long long v26; // [rsp+70h] [rbp-C8h]
long long v27; // [rsp+78h] [rbp-C0h]
long long v28; // [rsp+80h] [rbp-B8h]
long long v29; // [rsp+88h] [rbp-B0h]
__m128 v30; // [rsp+90h] [rbp-A8h]
__m128 v31; // [rsp+A0h] [rbp-98h]
__m128 v32; // [rsp+B0h] [rbp-88h]
__m128 v33; // [rsp+C0h] [rbp-78h]
__m128 v34; // [rsp+D0h] [rbp-68h]
__m128 v35; // [rsp+E0h] [rbp-58h]
__m128 v36; // [rsp+F0h] [rbp-48h]
__m128 v37; // [rsp+100h] [rbp-38h]
v30 = a7;
v31 = a8;
v32 = a9;
v33 = a10;
v34 = a11;
v35 = a12;
v36 = a13;
v37 = a14;
v26 = a3;
v27 = a4;
v28 = a5;
v29 = a6;
v24[0] = 0x3000000010LL;
v24[1] = &a15;
v24[2] = v25;
v23[2] = v25;
v23[0] = 0x3000000010LL;
v23[1] = &a15;
v15 = vsnprintf(0LL, 0LL, a2, v24);
if ( v15 >= 0x7FFFFFFF )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
434LL,
"GGML_ASSERT(%s) failed",
"size >= 0 && size < INT_MAX");
LABEL_7:
v20 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
437LL,
"GGML_ASSERT(%s) failed",
"size2 == size");
if ( v21 )
operator delete(v21, v22 - (_QWORD)v21);
_Unwind_Resume(v20);
}
v16 = v15;
v17 = v15 + 1;
std::vector<char>::vector((long long)&v21, v17);
if ( (unsigned int)vsnprintf(v21, v17, a2, v23) != v16 )
goto LABEL_7;
v18 = v21;
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v18, (long long)&v18[v16]);
if ( v21 )
operator delete(v21, v22 - (_QWORD)v21);
return a1;
}
|
string_format[abi:cxx11]:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x60]
MOV qword ptr [RSI + 0x10],RDX
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00122f06
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVAPS xmmword ptr [RSP + 0xa0],XMM1
MOVAPS xmmword ptr [RSP + 0xb0],XMM2
MOVAPS xmmword ptr [RSP + 0xc0],XMM3
MOVAPS xmmword ptr [RSP + 0xd0],XMM4
MOVAPS xmmword ptr [RSP + 0xe0],XMM5
MOVAPS xmmword ptr [RSP + 0xf0],XMM6
MOVAPS xmmword ptr [RSP + 0x100],XMM7
LAB_00122f06:
MOV RAX,0x3000000010
LEA RCX,[RSP + 0x40]
MOV qword ptr [RCX],RAX
LEA RAX,[RSP + 0x140]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RSI
MOV qword ptr [RSP + 0x30],RSI
MOV RAX,qword ptr [RCX]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x28],RAX
XOR EDI,EDI
XOR ESI,ESI
MOV RDX,R14
CALL 0x0011aef8
CMP EAX,0x7fffffff
JNC 0x00122fcb
MOV R15D,EAX
LEA R12D,[R15 + 0x1]
LEA R13,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R13
MOV RSI,R12
CALL 0x001219e0
MOV RDI,qword ptr [R13]
LEA RCX,[RSP + 0x20]
MOV RSI,R12
MOV RDX,R14
CALL 0x0011aef8
CMP EAX,R15D
JNZ 0x00122fec
MOV RSI,qword ptr [RSP + 0x8]
MOV EDX,R15D
LEA RAX,[RBX + 0x10]
MOV qword ptr [RBX],RAX
ADD RDX,RSI
LAB_00122f98:
MOV RDI,RBX
CALL 0x00120d82
LAB_00122fa0:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00122fb7
MOV RSI,qword ptr [RSP + 0x18]
SUB RSI,RDI
CALL 0x0011a740
LAB_00122fb7:
MOV RAX,RBX
ADD RSP,0x110
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00122fcb:
LEA RDI,[0x1adc75]
LEA RDX,[0x1ac94c]
LEA RCX,[0x1adcc1]
MOV ESI,0x1b2
XOR EAX,EAX
CALL 0x0011ac70
LAB_00122fec:
LEA RDI,[0x1adc75]
LEA RDX,[0x1ac94c]
LEA RCX,[0x1adcdd]
MOV ESI,0x1b5
XOR EAX,EAX
CALL 0x0011ac70
|
/* string_format[abi:cxx11](char const*, ...) */
char * string_format_abi_cxx11_(char *param_1,...)
{
char in_AL;
uint uVar1;
uint uVar2;
int8 in_RCX;
int8 in_RDX;
char *in_RSI;
int8 in_R8;
int8 in_R9;
int8 in_XMM0_Qa;
int8 in_XMM1_Qa;
int8 in_XMM2_Qa;
int8 in_XMM3_Qa;
int8 in_XMM4_Qa;
int8 in_XMM5_Qa;
int8 in_XMM6_Qa;
int8 in_XMM7_Qa;
char *local_130 [2];
long local_120;
int8 local_118;
int1 *local_110;
int1 *local_108;
int8 local_f8;
int1 *local_f0;
int1 *local_e8;
int1 local_d8 [16];
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_b0;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
local_108 = local_d8;
if (in_AL != '\0') {
local_a8 = in_XMM0_Qa;
local_98 = in_XMM1_Qa;
local_88 = in_XMM2_Qa;
local_78 = in_XMM3_Qa;
local_68 = in_XMM4_Qa;
local_58 = in_XMM5_Qa;
local_48 = in_XMM6_Qa;
local_38 = in_XMM7_Qa;
}
local_f8 = 0x3000000010;
local_110 = &stack0x00000008;
local_118 = 0x3000000010;
local_f0 = local_110;
local_e8 = local_108;
local_c8 = in_RDX;
local_c0 = in_RCX;
local_b8 = in_R8;
local_b0 = in_R9;
uVar1 = vsnprintf((char *)0x0,0,in_RSI,&local_f8);
if (uVar1 < 0x7fffffff) {
std::vector<char,std::allocator<char>>::vector((ulong)local_130,(allocator *)(ulong)(uVar1 + 1))
;
uVar2 = vsnprintf(local_130[0],(size_t)(ulong)(uVar1 + 1),in_RSI,&local_118);
if (uVar2 == uVar1) {
*(char **)param_1 = param_1 + 0x10;
/* try { // try from 00122f98 to 00122f9f has its CatchHandler @ 0012300d */
std::__cxx11::string::_M_construct<char_const*>(param_1,local_130[0],local_130[0] + uVar1);
if (local_130[0] != (char *)0x0) {
operator_delete(local_130[0],local_120 - (long)local_130[0]);
}
return param_1;
}
/* try { // try from 00122fec to 0012300c has its CatchHandler @ 0012300f */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b5,
"GGML_ASSERT(%s) failed","size2 == size");
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x1b2,
"GGML_ASSERT(%s) failed","size >= 0 && size < INT_MAX");
}
|
|
60,062
|
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O0
|
c
|
remainingElementsCount_add:
subq $0x68, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
xorl %ecx, %ecx
callq 0x37750
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x9bcec
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x9bd7b
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x2c(%rsp), %rsi
callq 0x3f280
cmpl $0x0, %eax
je 0x9bd14
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x9bd7b
movl 0x44(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %edi
callq 0x39fb0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
xorl %ecx, %ecx
callq 0x39640
cmpl $0x0, %eax
jge 0x9bd6a
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0x9bd7b
cmpl $0x0, 0x2c(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
|
remainingElementsCount_add:
sub rsp, 68h
mov [rsp+68h+var_18], rsi
mov [rsp+68h+var_10], rdx
mov [rsp+68h+var_20], rdi
mov [rsp+68h+var_24], ecx
mov rdi, [rsp+68h+var_20]
mov rsi, [rsp+68h+var_18]
mov rdx, [rsp+68h+var_10]
xor ecx, ecx
call JS_GetPropertyUint32
mov [rsp+68h+var_50], rax
mov [rsp+68h+var_48], rdx
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_38], rax
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_30], rax
mov rdi, [rsp+68h+var_38]
mov rsi, [rsp+68h+var_30]
call JS_IsException_1
cmp eax, 0
jz short loc_9BCEC
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp loc_9BD7B
loc_9BCEC:
mov rdi, [rsp+68h+var_20]
mov rdx, [rsp+68h+var_38]
mov rcx, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_3C]
call JS_ToInt32Free
cmp eax, 0
jz short loc_9BD14
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_9BD7B
loc_9BD14:
mov eax, [rsp+68h+var_24]
add eax, [rsp+68h+var_3C]
mov [rsp+68h+var_3C], eax
mov rax, [rsp+68h+var_20]
mov [rsp+68h+var_68], rax
mov edi, [rsp+68h+var_3C]
call js_int32
mov rdi, [rsp+68h+var_68]
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_58], rdx
mov rsi, [rsp+68h+var_18]
mov rdx, [rsp+68h+var_10]
mov r8, [rsp+68h+var_60]
mov r9, [rsp+68h+var_58]
xor ecx, ecx
call JS_SetPropertyUint32
cmp eax, 0
jge short loc_9BD6A
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_9BD7B
loc_9BD6A:
cmp [rsp+68h+var_3C], 0
setz al
and al, 1
movzx eax, al
mov [rsp+68h+var_4], eax
loc_9BD7B:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
|
long long remainingElementsCount_add(long long a1, long long a2, long long a3, int a4)
{
long long v4; // rdx
long long v5; // rdx
int v7; // [rsp+0h] [rbp-68h]
long long v8; // [rsp+8h] [rbp-60h]
int v9; // [rsp+2Ch] [rbp-3Ch] BYREF
long long PropertyUint32; // [rsp+30h] [rbp-38h]
long long v11; // [rsp+38h] [rbp-30h]
int v12; // [rsp+44h] [rbp-24h]
long long v13; // [rsp+48h] [rbp-20h]
long long v14; // [rsp+50h] [rbp-18h]
long long v15; // [rsp+58h] [rbp-10h]
v14 = a2;
v15 = a3;
v13 = a1;
v12 = a4;
PropertyUint32 = JS_GetPropertyUint32(a1, a2, a3, 0);
v11 = v4;
if ( JS_IsException_1(PropertyUint32, v4) )
{
return (unsigned int)-1;
}
else if ( (unsigned int)JS_ToInt32Free(v13, &v9, PropertyUint32, v11) )
{
return (unsigned int)-1;
}
else
{
v9 += v12;
v7 = v13;
v8 = js_int32(v9);
if ( (int)JS_SetPropertyUint32(v7, v14, v15, 0, v8, v5) >= 0 )
return v9 == 0;
else
return (unsigned int)-1;
}
}
|
remainingElementsCount_add:
SUB RSP,0x68
MOV qword ptr [RSP + 0x50],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x48],RDI
MOV dword ptr [RSP + 0x44],ECX
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
XOR ECX,ECX
CALL 0x00137750
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x38],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0019bcec
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0019bd7b
LAB_0019bcec:
MOV RDI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
LEA RSI,[RSP + 0x2c]
CALL 0x0013f280
CMP EAX,0x0
JZ 0x0019bd14
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0019bd7b
LAB_0019bd14:
MOV EAX,dword ptr [RSP + 0x44]
ADD EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x2c],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP],RAX
MOV EDI,dword ptr [RSP + 0x2c]
CALL 0x00139fb0
MOV RDI,qword ptr [RSP]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x8]
MOV R9,qword ptr [RSP + 0x10]
XOR ECX,ECX
CALL 0x00139640
CMP EAX,0x0
JGE 0x0019bd6a
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x0019bd7b
LAB_0019bd6a:
CMP dword ptr [RSP + 0x2c],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x64],EAX
LAB_0019bd7b:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
RET
|
uint remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int8 uVar1;
int iVar2;
int1 auVar3 [16];
int local_3c;
int1 local_38 [16];
int local_24;
int8 local_20;
int8 local_18;
int8 local_10;
uint local_4;
local_24 = param_4;
local_20 = param_1;
local_18 = param_2;
local_10 = param_3;
local_38 = JS_GetPropertyUint32(param_1,param_2,param_3,0);
iVar2 = JS_IsException(local_38._0_8_,local_38._8_8_);
if (iVar2 == 0) {
iVar2 = JS_ToInt32Free(local_20,&local_3c,local_38._0_8_,local_38._8_8_);
uVar1 = local_20;
if (iVar2 == 0) {
local_3c = local_24 + local_3c;
auVar3 = js_int32(local_3c);
iVar2 = JS_SetPropertyUint32(uVar1,local_18,local_10,0,auVar3._0_8_,auVar3._8_8_);
if (iVar2 < 0) {
local_4 = 0xffffffff;
}
else {
local_4 = (uint)(local_3c == 0);
}
}
else {
local_4 = 0xffffffff;
}
}
else {
local_4 = 0xffffffff;
}
return local_4;
}
|
|
60,063
|
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O2
|
c
|
remainingElementsCount_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x21d28
movq %rdx, %rcx
pushq $-0x1
popq %rbp
cmpl $0x6, %ecx
je 0x4c802
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x25190
testl %eax, %eax
jne 0x4c802
addl 0xc(%rsp), %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x22893
testl %eax, %eax
js 0x4c802
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
remainingElementsCount_add:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, ecx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xor ecx, ecx
call JS_GetPropertyInt64
mov rcx, rdx
push 0FFFFFFFFFFFFFFFFh
pop rbp
cmp ecx, 6
jz short loc_4C802
lea rsi, [rsp+38h+var_2C]
mov rdi, r12
mov rdx, rax
call JS_ToInt32Free
test eax, eax
jnz short loc_4C802
add ebx, [rsp+38h+var_2C]
mov rdi, r12
mov rsi, r15
mov rdx, r14
xor ecx, ecx
mov r8, rbx
xor r9d, r9d
call JS_SetPropertyUint32
test eax, eax
js short loc_4C802
xor ebp, ebp
test ebx, ebx
setz bpl
loc_4C802:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long remainingElementsCount_add(long long a1, long long a2, int a3, int a4)
{
unsigned long long PropertyInt64; // rax
long long v7; // rdx
unsigned int v8; // ebp
long long v9; // rbx
_DWORD v11[11]; // [rsp+Ch] [rbp-2Ch] BYREF
PropertyInt64 = JS_GetPropertyInt64(a1, a2, a3, 0LL);
v8 = -1;
if ( (_DWORD)v7 != 6 && !(unsigned int)JS_ToInt32Free(a1, v11, PropertyInt64, v7) )
{
v9 = (unsigned int)(v11[0] + a4);
if ( (int)JS_SetPropertyUint32(a1, a2, a3, 0, v9, 0LL) >= 0 )
return (_DWORD)v9 == 0;
}
return v8;
}
|
remainingElementsCount_add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,ECX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XOR ECX,ECX
CALL 0x00121d28
MOV RCX,RDX
PUSH -0x1
POP RBP
CMP ECX,0x6
JZ 0x0014c802
LEA RSI,[RSP + 0xc]
MOV RDI,R12
MOV RDX,RAX
CALL 0x00125190
TEST EAX,EAX
JNZ 0x0014c802
ADD EBX,dword ptr [RSP + 0xc]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
MOV R8,RBX
XOR R9D,R9D
CALL 0x00122893
TEST EAX,EAX
JS 0x0014c802
XOR EBP,EBP
TEST EBX,EBX
SETZ BPL
LAB_0014c802:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
uint remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int iVar1;
uint uVar2;
int1 auVar3 [12];
int local_2c;
auVar3 = JS_GetPropertyInt64();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
iVar1 = JS_ToInt32Free(param_1,&local_2c,auVar3._0_8_);
if (iVar1 == 0) {
iVar1 = JS_SetPropertyUint32(param_1,param_2,param_3,0,param_4 + local_2c,0);
if (-1 < iVar1) {
uVar2 = (uint)(param_4 + local_2c == 0);
}
}
}
return uVar2;
}
|
|
60,064
|
remainingElementsCount_add
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int remainingElementsCount_add(JSContext *ctx,
JSValue resolve_element_env,
int addend)
{
JSValue val;
int remainingElementsCount;
val = JS_GetPropertyUint32(ctx, resolve_element_env, 0);
if (JS_IsException(val))
return -1;
if (JS_ToInt32Free(ctx, &remainingElementsCount, val))
return -1;
remainingElementsCount += addend;
if (JS_SetPropertyUint32(ctx, resolve_element_env, 0,
js_int32(remainingElementsCount)) < 0)
return -1;
return (remainingElementsCount == 0);
}
|
O3
|
c
|
remainingElementsCount_add:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ecx, %ecx
callq 0x28814
movq %rdx, %rcx
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpl $0x6, %ecx
je 0x5bd40
leaq 0xc(%rsp), %rsi
movq %r12, %rdi
movq %rax, %rdx
callq 0x2c050
testl %eax, %eax
jne 0x5bd40
addl 0xc(%rsp), %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
pushq $0x4000 # imm = 0x4000
pushq $0x0
callq 0x293bb
addq $0x10, %rsp
testl %eax, %eax
js 0x5bd40
xorl %ebp, %ebp
testl %ebx, %ebx
sete %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
remainingElementsCount_add:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, ecx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xor ecx, ecx
call JS_GetPropertyInt64
mov rcx, rdx
mov ebp, 0FFFFFFFFh
cmp ecx, 6
jz short loc_5BD40
lea rsi, [rsp+38h+var_2C]
mov rdi, r12
mov rdx, rax
call JS_ToInt32Free
test eax, eax
jnz short loc_5BD40
add ebx, [rsp+38h+var_2C]
mov rdi, r12
mov rsi, r15
mov rdx, r14
xor ecx, ecx
xor r8d, r8d
mov r9, rbx
push 4000h
push 0
call JS_SetPropertyValue
add rsp, 10h
test eax, eax
js short loc_5BD40
xor ebp, ebp
test ebx, ebx
setz bpl
loc_5BD40:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long remainingElementsCount_add(
long long a1,
long long a2,
unsigned long long a3,
int a4,
double a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
unsigned long long PropertyInt64; // rax
long long v15; // rdx
unsigned int v16; // ebp
double v17; // xmm4_8
double v18; // xmm5_8
long long v19; // rbx
int v21[11]; // [rsp+Ch] [rbp-2Ch] BYREF
PropertyInt64 = JS_GetPropertyInt64(a1, a2, a3, 0LL);
v16 = -1;
if ( (_DWORD)v15 != 6 && !(unsigned int)JS_ToInt32Free(a1, v21, PropertyInt64, v15) )
{
v19 = (unsigned int)(v21[0] + a4);
if ( (int)JS_SetPropertyValue(a1, a2, a3, 0LL, 0LL, v19, a5, a6, a7, a8, v17, v18, a11, a12, 0LL, 0x4000u) >= 0 )
return (_DWORD)v19 == 0;
}
return v16;
}
|
remainingElementsCount_add:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,ECX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XOR ECX,ECX
CALL 0x00128814
MOV RCX,RDX
MOV EBP,0xffffffff
CMP ECX,0x6
JZ 0x0015bd40
LEA RSI,[RSP + 0xc]
MOV RDI,R12
MOV RDX,RAX
CALL 0x0012c050
TEST EAX,EAX
JNZ 0x0015bd40
ADD EBX,dword ptr [RSP + 0xc]
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
XOR ECX,ECX
XOR R8D,R8D
MOV R9,RBX
PUSH 0x4000
PUSH 0x0
CALL 0x001293bb
ADD RSP,0x10
TEST EAX,EAX
JS 0x0015bd40
XOR EBP,EBP
TEST EBX,EBX
SETZ BPL
LAB_0015bd40:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong remainingElementsCount_add
(int8 param_1,int8 param_2,int8 param_3,int param_4)
{
int iVar1;
ulong uVar2;
int1 auVar3 [12];
int local_2c;
auVar3 = JS_GetPropertyInt64();
uVar2 = 0xffffffff;
if (auVar3._8_4_ != 6) {
iVar1 = JS_ToInt32Free(param_1,&local_2c,auVar3._0_8_);
if (iVar1 == 0) {
iVar1 = JS_SetPropertyValue(param_1,param_2,param_3,0,0,param_4 + local_2c,0,0x4000);
if (-1 < iVar1) {
uVar2 = (ulong)(param_4 + local_2c == 0);
}
}
}
return uVar2;
}
|
|
60,065
|
my_strntol_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static long
my_strntol_mb2_or_mb4(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative= 0;
int overflow;
int cnv;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
register unsigned int cutlim;
register uint32 cutoff;
register uint32 res;
register const uchar *s= (const uchar*) nptr;
register const uchar *e= (const uchar*) nptr+l;
const uchar *save;
*err= 0;
do
{
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
switch (wc)
{
case ' ' : break;
case '\t': break;
case '-' : negative= !negative; break;
case '+' : break;
default : goto bs;
}
}
else /* No more characters or bad multibyte sequence */
{
if (endptr != NULL )
*endptr= (char*) s;
err[0]= (cnv==MY_CS_ILSEQ) ? EILSEQ : EDOM;
return 0;
}
s+= cnv;
} while (1);
bs:
overflow= 0;
res= 0;
save= s;
cutoff= ((uint32)~0L) / (uint32) base;
cutlim= (uint) (((uint32)~0L) % (uint32) base);
do {
if ((cnv= mb_wc(cs, &wc, s, e)) > 0)
{
s+= cnv;
if (wc >= '0' && wc <= '9')
wc-= '0';
else if (wc >= 'A' && wc <= 'Z')
wc= wc - 'A' + 10;
else if (wc >= 'a' && wc <= 'z')
wc= wc - 'a' + 10;
else
break;
if ((int)wc >= base)
break;
if (res > cutoff || (res == cutoff && wc > cutlim))
overflow= 1;
else
{
res*= (uint32) base;
res+= wc;
}
}
else if (cnv == MY_CS_ILSEQ)
{
if (endptr !=NULL )
*endptr = (char*) s;
err[0]= EILSEQ;
return 0;
}
else
{
/* No more characters */
break;
}
} while(1);
if (endptr != NULL)
*endptr = (char *) s;
if (s == save)
{
err[0]= EDOM;
return 0L;
}
if (negative)
{
if (res > (uint32) INT_MIN32)
overflow= 1;
}
else if (res > INT_MAX32)
overflow= 1;
if (overflow)
{
err[0]= ERANGE;
return negative ? INT_MIN32 : INT_MAX32;
}
return (negative ? -((long) res) : (long) res);
}
|
O0
|
c
|
my_strntol_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x679e1
movq -0x50(%rbp), %rax
addq $-0x9, %rax
movq %rax, -0x88(%rbp)
subq $0x24, %rax
ja 0x679dd
movq -0x88(%rbp), %rax
leaq 0x1575b5(%rip), %rcx # 0x1bef70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x679df
jmp 0x679df
cmpl $0x0, -0x3c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x3c(%rbp)
jmp 0x679df
jmp 0x679df
jmp 0x67a38
jmp 0x67a19
cmpq $0x0, -0x30(%rbp)
je 0x679f3
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %edx
movl $0x21, %ecx
movl $0x54, %eax
cmpl $0x0, %edx
cmovel %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x67c41
movl -0x44(%rbp), %ecx
movq -0x70(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0x6797a
jmp 0x67a36
jmp 0x67a38
movl $0x0, -0x40(%rbp)
movl $0x0, -0x64(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %eax, -0x60(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
xorl %edx, %edx
divl -0x24(%rbp)
movl %edx, -0x5c(%rbp)
movq -0x58(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x50(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
jle 0x67b49
movl -0x44(%rbp), %ecx
movq -0x70(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
cmpq $0x30, -0x50(%rbp)
jb 0x67ab7
cmpq $0x39, -0x50(%rbp)
ja 0x67ab7
movq -0x50(%rbp), %rax
subq $0x30, %rax
movq %rax, -0x50(%rbp)
jmp 0x67b00
cmpq $0x41, -0x50(%rbp)
jb 0x67ad7
cmpq $0x5a, -0x50(%rbp)
ja 0x67ad7
movq -0x50(%rbp), %rax
subq $0x41, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x67afe
cmpq $0x61, -0x50(%rbp)
jb 0x67af7
cmpq $0x7a, -0x50(%rbp)
ja 0x67af7
movq -0x50(%rbp), %rax
subq $0x61, %rax
addq $0xa, %rax
movq %rax, -0x50(%rbp)
jmp 0x67afc
jmp 0x67b88
jmp 0x67afe
jmp 0x67b00
movq -0x50(%rbp), %rax
cmpl -0x24(%rbp), %eax
jl 0x67b0b
jmp 0x67b88
movl -0x64(%rbp), %eax
cmpl -0x60(%rbp), %eax
ja 0x67b27
movl -0x64(%rbp), %eax
cmpl -0x60(%rbp), %eax
jne 0x67b30
movq -0x50(%rbp), %rax
movl -0x5c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x67b30
movl $0x1, -0x40(%rbp)
jmp 0x67b47
movl -0x24(%rbp), %eax
imull -0x64(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x50(%rbp), %rcx
movl -0x64(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x64(%rbp)
jmp 0x67b7a
cmpl $0x0, -0x44(%rbp)
jne 0x67b78
cmpq $0x0, -0x30(%rbp)
je 0x67b61
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movl $0x54, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x67c41
jmp 0x67b88
jmp 0x67b7c
movb $0x1, %al
testb $0x1, %al
jne 0x67a68
jmp 0x67b88
cmpq $0x0, -0x30(%rbp)
je 0x67b9a
movq -0x70(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rax
cmpq -0x80(%rbp), %rax
jne 0x67bbb
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x67c41
cmpl $0x0, -0x3c(%rbp)
je 0x67bd3
cmpl $0x80000000, -0x64(%rbp) # imm = 0x80000000
jbe 0x67bd1
movl $0x1, -0x40(%rbp)
jmp 0x67be7
movl -0x64(%rbp), %eax
cmpq $0x7fffffff, %rax # imm = 0x7FFFFFFF
jle 0x67be5
movl $0x1, -0x40(%rbp)
jmp 0x67be7
cmpl $0x0, -0x40(%rbp)
je 0x67c13
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movl -0x3c(%rbp), %edx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq $-0x80000000, %rcx # imm = 0x80000000
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x67c41
cmpl $0x0, -0x3c(%rbp)
je 0x67c2c
movl -0x64(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x90(%rbp)
jmp 0x67c36
movl -0x64(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop
|
my_strntol_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov [rbp+var_3C], 0
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov [rbp+var_70], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_78], rax
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
loc_6797A:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_70]
mov rcx, [rbp+var_78]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle short loc_679E1
mov rax, [rbp+var_50]
add rax, 0FFFFFFFFFFFFFFF7h; switch 37 cases
mov [rbp+var_88], rax
sub rax, 24h
ja short def_679C2; jumptable 00000000000679C2 default case, cases 10-31,33-42,44
mov rax, [rbp+var_88]
lea rcx, jpt_679C2
movsxd rax, ds:(jpt_679C2 - 1BEF70h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_679C4:
jmp short loc_679DF; jumptable 00000000000679C2 case 32
loc_679C6:
jmp short loc_679DF; jumptable 00000000000679C2 case 9
loc_679C8:
cmp [rbp+var_3C], 0; jumptable 00000000000679C2 case 45
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rbp+var_3C], eax
jmp short loc_679DF
loc_679DB:
jmp short loc_679DF; jumptable 00000000000679C2 case 43
def_679C2:
jmp short loc_67A38; jumptable 00000000000679C2 default case, cases 10-31,33-42,44
loc_679DF:
jmp short loc_67A19
loc_679E1:
cmp [rbp+var_30], 0
jz short loc_679F3
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_679F3:
mov edx, [rbp+var_44]
mov ecx, 21h ; '!'
mov eax, 54h ; 'T'
cmp edx, 0
cmovz ecx, eax
mov rax, [rbp+var_38]
mov [rax], ecx
mov [rbp+var_8], 0
jmp loc_67C41
loc_67A19:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_70]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_70], rax
mov al, 1
test al, 1
jnz loc_6797A
jmp short $+2
loc_67A36:
jmp short $+2
loc_67A38:
mov [rbp+var_40], 0
mov [rbp+var_64], 0
mov rax, [rbp+var_70]
mov [rbp+var_80], rax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_60], eax
mov eax, 0FFFFFFFFh
xor edx, edx
div [rbp+var_24]
mov [rbp+var_5C], edx
loc_67A68:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_70]
mov rcx, [rbp+var_78]
lea rsi, [rbp+var_50]
call rax
mov [rbp+var_44], eax
cmp eax, 0
jle loc_67B49
mov ecx, [rbp+var_44]
mov rax, [rbp+var_70]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_70], rax
cmp [rbp+var_50], 30h ; '0'
jb short loc_67AB7
cmp [rbp+var_50], 39h ; '9'
ja short loc_67AB7
mov rax, [rbp+var_50]
sub rax, 30h ; '0'
mov [rbp+var_50], rax
jmp short loc_67B00
loc_67AB7:
cmp [rbp+var_50], 41h ; 'A'
jb short loc_67AD7
cmp [rbp+var_50], 5Ah ; 'Z'
ja short loc_67AD7
mov rax, [rbp+var_50]
sub rax, 41h ; 'A'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_67AFE
loc_67AD7:
cmp [rbp+var_50], 61h ; 'a'
jb short loc_67AF7
cmp [rbp+var_50], 7Ah ; 'z'
ja short loc_67AF7
mov rax, [rbp+var_50]
sub rax, 61h ; 'a'
add rax, 0Ah
mov [rbp+var_50], rax
jmp short loc_67AFC
loc_67AF7:
jmp loc_67B88
loc_67AFC:
jmp short $+2
loc_67AFE:
jmp short $+2
loc_67B00:
mov rax, [rbp+var_50]
cmp eax, [rbp+var_24]
jl short loc_67B0B
jmp short loc_67B88
loc_67B0B:
mov eax, [rbp+var_64]
cmp eax, [rbp+var_60]
ja short loc_67B27
mov eax, [rbp+var_64]
cmp eax, [rbp+var_60]
jnz short loc_67B30
mov rax, [rbp+var_50]
mov ecx, [rbp+var_5C]
cmp rax, rcx
jbe short loc_67B30
loc_67B27:
mov [rbp+var_40], 1
jmp short loc_67B47
loc_67B30:
mov eax, [rbp+var_24]
imul eax, [rbp+var_64]
mov [rbp+var_64], eax
mov rcx, [rbp+var_50]
mov eax, [rbp+var_64]
add rax, rcx
mov [rbp+var_64], eax
loc_67B47:
jmp short loc_67B7A
loc_67B49:
cmp [rbp+var_44], 0
jnz short loc_67B78
cmp [rbp+var_30], 0
jz short loc_67B61
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_67B61:
mov rax, [rbp+var_38]
mov dword ptr [rax], 54h ; 'T'
mov [rbp+var_8], 0
jmp loc_67C41
loc_67B78:
jmp short loc_67B88
loc_67B7A:
jmp short $+2
loc_67B7C:
mov al, 1
test al, 1
jnz loc_67A68
jmp short $+2
loc_67B88:
cmp [rbp+var_30], 0
jz short loc_67B9A
mov rcx, [rbp+var_70]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_67B9A:
mov rax, [rbp+var_70]
cmp rax, [rbp+var_80]
jnz short loc_67BBB
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
mov [rbp+var_8], 0
jmp loc_67C41
loc_67BBB:
cmp [rbp+var_3C], 0
jz short loc_67BD3
cmp [rbp+var_64], 80000000h
jbe short loc_67BD1
mov [rbp+var_40], 1
loc_67BD1:
jmp short loc_67BE7
loc_67BD3:
mov eax, [rbp+var_64]
cmp rax, 7FFFFFFFh
jle short loc_67BE5
mov [rbp+var_40], 1
loc_67BE5:
jmp short $+2
loc_67BE7:
cmp [rbp+var_40], 0
jz short loc_67C13
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov edx, [rbp+var_3C]
mov eax, 7FFFFFFFh
mov rcx, 0FFFFFFFF80000000h
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_8], rax
jmp short loc_67C41
loc_67C13:
cmp [rbp+var_3C], 0
jz short loc_67C2C
mov eax, [rbp+var_64]
mov ecx, eax
xor eax, eax
sub rax, rcx
mov [rbp+var_90], rax
jmp short loc_67C36
loc_67C2C:
mov eax, [rbp+var_64]
mov [rbp+var_90], rax
loc_67C36:
mov rax, [rbp+var_90]
mov [rbp+var_8], rax
loc_67C41:
mov rax, [rbp+var_8]
add rsp, 90h
pop rbp
retn
|
long long my_strntol_mb2_or_mb4(long long a1, long long a2, long long a3, unsigned int a4, _QWORD *a5, int *a6)
{
int v6; // ecx
long long v7; // rax
long long v10; // [rsp+10h] [rbp-80h]
long long v11; // [rsp+18h] [rbp-78h]
long long v12; // [rsp+20h] [rbp-70h]
unsigned int v13; // [rsp+2Ch] [rbp-64h]
unsigned int v14; // [rsp+30h] [rbp-60h]
unsigned int v15; // [rsp+34h] [rbp-5Ch]
long long ( *v16)(long long, unsigned long long *, long long, long long); // [rsp+38h] [rbp-58h]
unsigned long long v17; // [rsp+40h] [rbp-50h] BYREF
int v18; // [rsp+4Ch] [rbp-44h]
int v19; // [rsp+50h] [rbp-40h]
BOOL v20; // [rsp+54h] [rbp-3Ch]
int *v21; // [rsp+58h] [rbp-38h]
_QWORD *v22; // [rsp+60h] [rbp-30h]
unsigned int v23; // [rsp+6Ch] [rbp-24h]
long long v24; // [rsp+70h] [rbp-20h]
long long v25; // [rsp+78h] [rbp-18h]
long long v26; // [rsp+80h] [rbp-10h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v22 = a5;
v21 = a6;
v20 = 0;
v16 = *(long long ( **)(long long, unsigned long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
v12 = a2;
v11 = a3 + a2;
*a6 = 0;
while ( 2 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
{
if ( v22 )
*v22 = v12;
v6 = 33;
if ( !v18 )
v6 = 84;
*v21 = v6;
return 0LL;
}
else
{
switch ( v17 )
{
case 9uLL:
case 0x20uLL:
case 0x2BuLL:
goto LABEL_10;
case 0x2DuLL:
v20 = !v20;
LABEL_10:
v12 += v18;
continue;
default:
v19 = 0;
v13 = 0;
v10 = v12;
v14 = 0xFFFFFFFF / v23;
v15 = 0xFFFFFFFF % v23;
break;
}
while ( 1 )
{
v18 = v16(v26, &v17, v12, v11);
if ( v18 <= 0 )
break;
v12 += v18;
if ( v17 < 0x30 || v17 > 0x39 )
{
if ( v17 < 0x41 || v17 > 0x5A )
{
if ( v17 < 0x61 || v17 > 0x7A )
goto LABEL_33;
v17 = v17 - 97 + 10;
}
else
{
v17 = v17 - 65 + 10;
}
}
else
{
v17 -= 48LL;
}
if ( (int)v17 >= (int)v23 )
goto LABEL_33;
if ( v13 > v14 || v13 == v14 && v17 > v15 )
v19 = 1;
else
v13 = v17 + v13 * v23;
}
if ( v18 )
{
LABEL_33:
if ( v22 )
*v22 = v12;
if ( v12 == v10 )
{
*v21 = 33;
return 0LL;
}
else
{
if ( v20 )
{
if ( v13 > 0x80000000 )
v19 = 1;
}
else if ( v13 > 0x7FFFFFFFuLL )
{
v19 = 1;
}
if ( v19 )
{
*v21 = 34;
v7 = 0x7FFFFFFFLL;
if ( v20 )
return 0xFFFFFFFF80000000LL;
return v7;
}
else if ( v20 )
{
return -(long long)v13;
}
else
{
return v13;
}
}
}
if ( v22 )
*v22 = v12;
*v21 = 84;
return 0LL;
}
}
}
|
my_strntol_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
LAB_0016797a:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x001679e1
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,-0x9
MOV qword ptr [RBP + -0x88],RAX
SUB RAX,0x24
JA 0x001679dd
MOV RAX,qword ptr [RBP + -0x88]
LEA RCX,[0x2bef70]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_20:
JMP 0x001679df
caseD_9:
JMP 0x001679df
caseD_2d:
CMP dword ptr [RBP + -0x3c],0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001679df
caseD_2b:
JMP 0x001679df
caseD_a:
JMP 0x00167a38
LAB_001679df:
JMP 0x00167a19
LAB_001679e1:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001679f3
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_001679f3:
MOV EDX,dword ptr [RBP + -0x44]
MOV ECX,0x21
MOV EAX,0x54
CMP EDX,0x0
CMOVZ ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],ECX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00167c41
LAB_00167a19:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x70]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
MOV AL,0x1
TEST AL,0x1
JNZ 0x0016797a
JMP 0x00167a36
LAB_00167a36:
JMP 0x00167a38
LAB_00167a38:
MOV dword ptr [RBP + -0x40],0x0
MOV dword ptr [RBP + -0x64],0x0
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x60],EAX
MOV EAX,0xffffffff
XOR EDX,EDX
DIV dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x5c],EDX
LAB_00167a68:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x50]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
JLE 0x00167b49
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x70]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x50],0x30
JC 0x00167ab7
CMP qword ptr [RBP + -0x50],0x39
JA 0x00167ab7
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x30
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00167b00
LAB_00167ab7:
CMP qword ptr [RBP + -0x50],0x41
JC 0x00167ad7
CMP qword ptr [RBP + -0x50],0x5a
JA 0x00167ad7
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x41
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00167afe
LAB_00167ad7:
CMP qword ptr [RBP + -0x50],0x61
JC 0x00167af7
CMP qword ptr [RBP + -0x50],0x7a
JA 0x00167af7
MOV RAX,qword ptr [RBP + -0x50]
SUB RAX,0x61
ADD RAX,0xa
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00167afc
LAB_00167af7:
JMP 0x00167b88
LAB_00167afc:
JMP 0x00167afe
LAB_00167afe:
JMP 0x00167b00
LAB_00167b00:
MOV RAX,qword ptr [RBP + -0x50]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x00167b0b
JMP 0x00167b88
LAB_00167b0b:
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x60]
JA 0x00167b27
MOV EAX,dword ptr [RBP + -0x64]
CMP EAX,dword ptr [RBP + -0x60]
JNZ 0x00167b30
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x5c]
CMP RAX,RCX
JBE 0x00167b30
LAB_00167b27:
MOV dword ptr [RBP + -0x40],0x1
JMP 0x00167b47
LAB_00167b30:
MOV EAX,dword ptr [RBP + -0x24]
IMUL EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x64],EAX
MOV RCX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RBP + -0x64]
ADD RAX,RCX
MOV dword ptr [RBP + -0x64],EAX
LAB_00167b47:
JMP 0x00167b7a
LAB_00167b49:
CMP dword ptr [RBP + -0x44],0x0
JNZ 0x00167b78
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00167b61
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00167b61:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x54
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00167c41
LAB_00167b78:
JMP 0x00167b88
LAB_00167b7a:
JMP 0x00167b7c
LAB_00167b7c:
MOV AL,0x1
TEST AL,0x1
JNZ 0x00167a68
JMP 0x00167b88
LAB_00167b88:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00167b9a
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_00167b9a:
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RBP + -0x80]
JNZ 0x00167bbb
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00167c41
LAB_00167bbb:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00167bd3
CMP dword ptr [RBP + -0x64],0x80000000
JBE 0x00167bd1
MOV dword ptr [RBP + -0x40],0x1
LAB_00167bd1:
JMP 0x00167be7
LAB_00167bd3:
MOV EAX,dword ptr [RBP + -0x64]
CMP RAX,0x7fffffff
JLE 0x00167be5
MOV dword ptr [RBP + -0x40],0x1
LAB_00167be5:
JMP 0x00167be7
LAB_00167be7:
CMP dword ptr [RBP + -0x40],0x0
JZ 0x00167c13
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV EDX,dword ptr [RBP + -0x3c]
MOV EAX,0x7fffffff
MOV RCX,-0x80000000
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00167c41
LAB_00167c13:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x00167c2c
MOV EAX,dword ptr [RBP + -0x64]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00167c36
LAB_00167c2c:
MOV EAX,dword ptr [RBP + -0x64]
MOV qword ptr [RBP + -0x90],RAX
LAB_00167c36:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x8],RAX
LAB_00167c41:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x90
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00167a34) */
/* WARNING: Removing unreachable block (ram,0x00167b86) */
ulong my_strntol_mb2_or_mb4
(long param_1,long param_2,long param_3,uint param_4,long *param_5,
int4 *param_6)
{
code *pcVar1;
ulong uVar2;
long lVar3;
uint uVar4;
int4 uVar5;
ulong local_98;
long local_78;
uint local_6c;
ulong local_58;
int local_4c;
int local_48;
uint local_44;
int4 *local_40;
long *local_38;
uint local_2c;
long local_28;
long local_20;
long local_18;
ulong local_10;
local_44 = 0;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_6 = 0;
local_78 = param_2;
local_40 = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
do {
lVar3 = local_78;
local_4c = (*pcVar1)(local_18,&local_58,local_78,param_2 + param_3);
if (local_4c < 1) {
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
uVar5 = 0x21;
if (local_4c == 0) {
uVar5 = 0x54;
}
*local_40 = uVar5;
return 0;
}
switch(local_58) {
case 9:
break;
default:
local_48 = 0;
local_6c = 0;
uVar4 = (uint)(0xffffffff / (ulong)local_2c);
uVar2 = (ulong)local_2c;
goto LAB_00167a68;
case 0x20:
break;
case 0x2b:
break;
case 0x2d:
local_44 = (uint)((local_44 != 0 ^ 0xffU) & 1);
}
local_78 = local_78 + local_4c;
} while( true );
LAB_00167a68:
local_4c = (*pcVar1)(local_18,&local_58,local_78,param_2 + param_3);
if (local_4c < 1) {
if (local_4c == 0) {
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
*local_40 = 0x54;
local_10 = 0;
}
else {
LAB_00167b88:
if (local_38 != (long *)0x0) {
*local_38 = local_78;
}
if (local_78 == lVar3) {
*local_40 = 0x21;
local_10 = 0;
}
else {
if (local_44 == 0) {
if (0x7fffffff < local_6c) {
local_48 = 1;
}
}
else if (0x80000000 < local_6c) {
local_48 = 1;
}
if (local_48 == 0) {
if (local_44 == 0) {
local_98 = (ulong)local_6c;
}
else {
local_98 = -(ulong)local_6c;
}
local_10 = local_98;
}
else {
*local_40 = 0x22;
local_10 = 0x7fffffff;
if (local_44 != 0) {
local_10 = 0xffffffff80000000;
}
}
}
}
return local_10;
}
local_78 = local_78 + local_4c;
if ((local_58 < 0x30) || (0x39 < local_58)) {
if ((local_58 < 0x41) || (0x5a < local_58)) {
if ((local_58 < 0x61) || (0x7a < local_58)) goto LAB_00167b88;
local_58 = local_58 - 0x57;
}
else {
local_58 = local_58 - 0x37;
}
}
else {
local_58 = local_58 - 0x30;
}
if ((int)local_2c <= (int)local_58) goto LAB_00167b88;
if ((uVar4 < local_6c) || ((local_6c == uVar4 && (0xffffffffU % uVar2 < local_58)))) {
local_48 = 1;
}
else {
local_6c = local_2c * local_6c + (int)local_58;
}
goto LAB_00167a68;
}
|
|
60,066
|
read_user_name
|
eloqsql/libmariadb/libmariadb/mariadb_lib.c
|
void read_user_name(char *name)
{
if (geteuid() == 0)
strcpy(name,"root"); /* allow use of surun */
else
{
#ifdef HAVE_GETPWUID
struct passwd *skr;
const char *str;
if ((skr=getpwuid(geteuid())) != NULL)
{
str=skr->pw_name;
} else if ((str=getlogin()) == NULL)
{
if (!(str=getenv("USER")) && !(str=getenv("LOGNAME")) &&
!(str=getenv("LOGIN")))
str="UNKNOWN_USER";
}
ma_strmake(name,str,USERNAME_LENGTH);
#elif defined(HAVE_CUSERID)
(void) cuserid(name);
#else
ma_strmake(name,"UNKNOWN_USER", USERNAME_LENGTH);
#endif
}
return;
}
|
O0
|
c
|
read_user_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x13280
cmpl $0x0, %eax
jne 0x17cab
movq -0x8(%rbp), %rdi
leaq 0x347bb(%rip), %rsi # 0x4c45c
callq 0x133c0
jmp 0x17d40
callq 0x13280
movl %eax, %edi
callq 0x134e0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x17cce
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x17d2e
callq 0x13430
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17d2c
leaq 0x34d31(%rip), %rdi # 0x4ca15
callq 0x13540
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17d2a
leaq 0x34d05(%rip), %rdi # 0x4c9ff
callq 0x13540
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17d2a
leaq 0x34cf7(%rip), %rdi # 0x4ca07
callq 0x13540
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x17d2a
leaq 0x34ce7(%rip), %rax # 0x4ca0d
movq %rax, -0x18(%rbp)
jmp 0x17d2c
jmp 0x17d2e
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x32b00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
read_user_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
call _geteuid
cmp eax, 0
jnz short loc_17CAB
mov rdi, [rbp+var_8]
lea rsi, aRoot; "root"
call _strcpy
jmp loc_17D40
loc_17CAB:
call _geteuid
mov edi, eax
call _getpwuid
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_17CCE
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_17D2E
loc_17CCE:
call _getlogin
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_17D2C
lea rdi, aUnknownUser+8; "USER"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_17D2A
lea rdi, aLogname; "LOGNAME"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_17D2A
lea rdi, aLogin; "LOGIN"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_17D2A
lea rax, aUnknownUser; "UNKNOWN_USER"
mov [rbp+var_18], rax
loc_17D2A:
jmp short $+2
loc_17D2C:
jmp short $+2
loc_17D2E:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov edx, 200h
call ma_strmake
loc_17D40:
add rsp, 20h
pop rbp
retn
|
long long read_user_name(long long a1)
{
unsigned int v2; // eax
const char *v3; // [rsp+8h] [rbp-18h]
_QWORD *v4; // [rsp+10h] [rbp-10h]
if ( !(unsigned int)geteuid() )
return strcpy(a1, "root");
v2 = geteuid();
v4 = (_QWORD *)getpwuid(v2);
if ( v4 )
return ma_strmake(a1, *v4, 512LL);
v3 = (const char *)getlogin();
if ( !v3 )
{
v3 = (const char *)getenv("USER");
if ( !v3 )
{
v3 = (const char *)getenv("LOGNAME");
if ( !v3 )
{
v3 = (const char *)getenv("LOGIN");
if ( !v3 )
v3 = "UNKNOWN_USER";
}
}
}
return ma_strmake(a1, v3, 512LL);
}
|
read_user_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
CALL 0x00113280
CMP EAX,0x0
JNZ 0x00117cab
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x14c45c]
CALL 0x001133c0
JMP 0x00117d40
LAB_00117cab:
CALL 0x00113280
MOV EDI,EAX
CALL 0x001134e0
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00117cce
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00117d2e
LAB_00117cce:
CALL 0x00113430
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00117d2c
LEA RDI,[0x14ca15]
CALL 0x00113540
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00117d2a
LEA RDI,[0x14c9ff]
CALL 0x00113540
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00117d2a
LEA RDI,[0x14ca07]
CALL 0x00113540
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00117d2a
LEA RAX,[0x14ca0d]
MOV qword ptr [RBP + -0x18],RAX
LAB_00117d2a:
JMP 0x00117d2c
LAB_00117d2c:
JMP 0x00117d2e
LAB_00117d2e:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x200
CALL 0x00132b00
LAB_00117d40:
ADD RSP,0x20
POP RBP
RET
|
void read_user_name(char *param_1)
{
__uid_t _Var1;
passwd *ppVar2;
char *local_20;
_Var1 = geteuid();
if (_Var1 == 0) {
strcpy(param_1,"root");
}
else {
_Var1 = geteuid();
ppVar2 = getpwuid(_Var1);
if (ppVar2 == (passwd *)0x0) {
local_20 = getlogin();
if ((((local_20 == (char *)0x0) && (local_20 = getenv("USER"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGNAME"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGIN"), local_20 == (char *)0x0)) {
local_20 = "UNKNOWN_USER";
}
}
else {
local_20 = ppVar2->pw_name;
}
ma_strmake(param_1,local_20,0x200);
}
return;
}
|
|
60,067
|
js_thisBigIntValue
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_thisBigIntValue(JSContext *ctx, JSValue this_val)
{
if (JS_IsBigInt(ctx, this_val))
return js_dup(this_val);
if (JS_VALUE_GET_TAG(this_val) == JS_TAG_OBJECT) {
JSObject *p = JS_VALUE_GET_OBJ(this_val);
if (p->class_id == JS_CLASS_BIG_INT) {
if (JS_IsBigInt(ctx, p->u.object_data))
return js_dup(p->u.object_data);
}
}
return JS_ThrowTypeError(ctx, "not a BigInt");
}
|
O1
|
c
|
js_thisBigIntValue:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
cmpl $-0x1, %edx
je 0x6f93e
cmpl $-0x9, %edx
jne 0x6f963
movq %rsi, %rbx
incl (%rsi)
jmp 0x6f978
movq 0x8(%rsp), %rcx
movb $0x1, %al
cmpw $0x22, 0x6(%rcx)
jne 0x6f95f
movq 0x38(%rcx), %rdx
cmpl $-0x9, %edx
jne 0x6f95f
movq 0x30(%rcx), %rbx
incl (%rbx)
xorl %eax, %eax
jmp 0x6f95f
testb %al, %al
je 0x6f978
leaq 0x31e9e(%rip), %rsi # 0xa1808
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22567
movl $0x6, %edx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
js_thisBigIntValue:
push rbx
sub rsp, 10h
mov [rsp+18h+var_10], rsi
cmp edx, 0FFFFFFFFh
jz short loc_6F93E
cmp edx, 0FFFFFFF7h
jnz short loc_6F963
mov rbx, rsi
inc dword ptr [rsi]
jmp short loc_6F978
loc_6F93E:
mov rcx, [rsp+18h+var_10]
mov al, 1
cmp word ptr [rcx+6], 22h ; '"'
jnz short loc_6F95F
mov rdx, [rcx+38h]
cmp edx, 0FFFFFFF7h
jnz short loc_6F95F
mov rbx, [rcx+30h]
inc dword ptr [rbx]
xor eax, eax
jmp short $+2
loc_6F95F:
test al, al
jz short loc_6F978
loc_6F963:
lea rsi, aNotABigint; "not a BigInt"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_6F978:
mov rax, rbx
add rsp, 10h
pop rbx
retn
|
_DWORD * js_thisBigIntValue(
long long a1,
long long a2,
long long 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)
{
_DWORD *v14; // rbx
char v15; // al
char v17; // [rsp+0h] [rbp-18h]
if ( (_DWORD)a3 != -1 )
{
if ( (_DWORD)a3 == -9 )
{
v14 = (_DWORD *)a2;
++*(_DWORD *)a2;
return v14;
}
LABEL_8:
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a BigInt", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v17);
return v14;
}
a4 = a2;
v15 = 1;
if ( *(_WORD *)(a2 + 6) == 34 )
{
a3 = *(_QWORD *)(a2 + 56);
if ( (_DWORD)a3 == -9 )
{
v14 = *(_DWORD **)(a2 + 48);
++*v14;
v15 = 0;
}
}
if ( v15 )
goto LABEL_8;
return v14;
}
|
js_thisBigIntValue:
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x1
JZ 0x0016f93e
CMP EDX,-0x9
JNZ 0x0016f963
MOV RBX,RSI
INC dword ptr [RSI]
JMP 0x0016f978
LAB_0016f93e:
MOV RCX,qword ptr [RSP + 0x8]
MOV AL,0x1
CMP word ptr [RCX + 0x6],0x22
JNZ 0x0016f95f
MOV RDX,qword ptr [RCX + 0x38]
CMP EDX,-0x9
JNZ 0x0016f95f
MOV RBX,qword ptr [RCX + 0x30]
INC dword ptr [RBX]
XOR EAX,EAX
JMP 0x0016f95f
LAB_0016f95f:
TEST AL,AL
JZ 0x0016f978
LAB_0016f963:
LEA RSI,[0x1a1808]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00122567
MOV EDX,0x6
LAB_0016f978:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
int1 [16] js_thisBigIntValue(int8 param_1,int *param_2,int8 param_3)
{
bool bVar1;
int *unaff_RBX;
int1 auVar2 [16];
if ((int)param_3 == -1) {
bVar1 = true;
if ((*(short *)((long)param_2 + 6) == 0x22) &&
(param_3 = *(int8 *)(param_2 + 0xe), (int)param_3 == -9)) {
unaff_RBX = *(int **)(param_2 + 0xc);
*unaff_RBX = *unaff_RBX + 1;
bVar1 = false;
}
if (!bVar1) goto LAB_0016f978;
}
else if ((int)param_3 == -9) {
*param_2 = *param_2 + 1;
unaff_RBX = param_2;
goto LAB_0016f978;
}
unaff_RBX = (int *)0x0;
JS_ThrowTypeError(param_1,"not a BigInt");
param_3 = 6;
LAB_0016f978:
auVar2._8_8_ = param_3;
auVar2._0_8_ = unaff_RBX;
return auVar2;
}
|
|
60,068
|
my_coll_parser_scan_reset_before
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_reset_before(MY_COLL_RULE_PARSER *p)
{
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before primary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 1]")))
{
p->rule.before_level= 1;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before secondary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 2]")))
{
p->rule.before_level= 2;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before tertiary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 3]")))
{
p->rule.before_level= 3;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before quaternary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 4]")))
{
p->rule.before_level= 4;
}
else
{
p->rule.before_level= 0;
return 0; /* Don't scan thr next character */
}
return my_coll_parser_scan(p);
}
|
O0
|
c
|
my_coll_parser_scan_reset_before:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f160
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2cdbd(%rip), %rsi # 0x7ca71
movl $0x10, %edx
callq 0x4f8e0
cmpl $0x0, %eax
je 0x4fcdd
movq -0x18(%rbp), %rdi
leaq 0x2cdb4(%rip), %rsi # 0x7ca82
movl $0xa, %edx
callq 0x4f8e0
cmpl $0x0, %eax
jne 0x4fcf1
movq -0x10(%rbp), %rax
movq $0x1, 0xe0(%rax)
jmp 0x4fde1
movq -0x18(%rbp), %rdi
leaq 0x2cd91(%rip), %rsi # 0x7ca8d
movl $0x12, %edx
callq 0x4f8e0
cmpl $0x0, %eax
je 0x4fd25
movq -0x18(%rbp), %rdi
leaq 0x2cd8a(%rip), %rsi # 0x7caa0
movl $0xa, %edx
callq 0x4f8e0
cmpl $0x0, %eax
jne 0x4fd39
movq -0x10(%rbp), %rax
movq $0x2, 0xe0(%rax)
jmp 0x4fddf
movq -0x18(%rbp), %rdi
leaq 0x2cd67(%rip), %rsi # 0x7caab
movl $0x11, %edx
callq 0x4f8e0
cmpl $0x0, %eax
je 0x4fd6d
movq -0x18(%rbp), %rdi
leaq 0x2cd5f(%rip), %rsi # 0x7cabd
movl $0xa, %edx
callq 0x4f8e0
cmpl $0x0, %eax
jne 0x4fd7e
movq -0x10(%rbp), %rax
movq $0x3, 0xe0(%rax)
jmp 0x4fddd
movq -0x18(%rbp), %rdi
leaq 0x2cd3f(%rip), %rsi # 0x7cac8
movl $0x13, %edx
callq 0x4f8e0
cmpl $0x0, %eax
je 0x4fdb2
movq -0x18(%rbp), %rdi
leaq 0x2cd39(%rip), %rsi # 0x7cadc
movl $0xa, %edx
callq 0x4f8e0
cmpl $0x0, %eax
jne 0x4fdc3
movq -0x10(%rbp), %rax
movq $0x4, 0xe0(%rax)
jmp 0x4fddb
movq -0x10(%rbp), %rax
movq $0x0, 0xe0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4fded
jmp 0x4fddd
jmp 0x4fddf
jmp 0x4fde1
movq -0x10(%rbp), %rdi
callq 0x4f940
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_parser_scan_reset_before:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
lea rsi, aBeforePrimary; "[before primary]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jz short loc_4FCDD
mov rdi, [rbp+var_18]
lea rsi, aBefore1; "[before 1]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_4FCF1
loc_4FCDD:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 1
jmp loc_4FDE1
loc_4FCF1:
mov rdi, [rbp+var_18]
lea rsi, aBeforeSecondar; "[before secondary]"
mov edx, 12h
call lex_cmp
cmp eax, 0
jz short loc_4FD25
mov rdi, [rbp+var_18]
lea rsi, aBefore2; "[before 2]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_4FD39
loc_4FD25:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 2
jmp loc_4FDDF
loc_4FD39:
mov rdi, [rbp+var_18]
lea rsi, aBeforeTertiary; "[before tertiary]"
mov edx, 11h
call lex_cmp
cmp eax, 0
jz short loc_4FD6D
mov rdi, [rbp+var_18]
lea rsi, aBefore3; "[before 3]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_4FD7E
loc_4FD6D:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 3
jmp short loc_4FDDD
loc_4FD7E:
mov rdi, [rbp+var_18]
lea rsi, aBeforeQuaterna; "[before quaternary]"
mov edx, 13h
call lex_cmp
cmp eax, 0
jz short loc_4FDB2
mov rdi, [rbp+var_18]
lea rsi, aBefore4; "[before 4]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_4FDC3
loc_4FDB2:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 4
jmp short loc_4FDDB
loc_4FDC3:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 0
mov [rbp+var_4], 0
jmp short loc_4FDED
loc_4FDDB:
jmp short $+2
loc_4FDDD:
jmp short $+2
loc_4FDDF:
jmp short $+2
loc_4FDE1:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_4FDED:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_coll_parser_scan_reset_before(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
v2 = my_coll_parser_curr(a1);
if ( !(unsigned int)lex_cmp(v2, (long long)"[before primary]", 0x10uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 1]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 1LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before secondary]", 0x12uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 2]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 2LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before tertiary]", 0x11uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 3]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 3LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before quaternary]", 0x13uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 4]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 4LL;
return (unsigned int)my_coll_parser_scan(a1);
}
*(_QWORD *)(a1 + 224) = 0LL;
return 0;
}
|
my_coll_parser_scan_reset_before:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f160
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17ca71]
MOV EDX,0x10
CALL 0x0014f8e0
CMP EAX,0x0
JZ 0x0014fcdd
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17ca82]
MOV EDX,0xa
CALL 0x0014f8e0
CMP EAX,0x0
JNZ 0x0014fcf1
LAB_0014fcdd:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x1
JMP 0x0014fde1
LAB_0014fcf1:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17ca8d]
MOV EDX,0x12
CALL 0x0014f8e0
CMP EAX,0x0
JZ 0x0014fd25
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17caa0]
MOV EDX,0xa
CALL 0x0014f8e0
CMP EAX,0x0
JNZ 0x0014fd39
LAB_0014fd25:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x2
JMP 0x0014fddf
LAB_0014fd39:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17caab]
MOV EDX,0x11
CALL 0x0014f8e0
CMP EAX,0x0
JZ 0x0014fd6d
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17cabd]
MOV EDX,0xa
CALL 0x0014f8e0
CMP EAX,0x0
JNZ 0x0014fd7e
LAB_0014fd6d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x3
JMP 0x0014fddd
LAB_0014fd7e:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17cac8]
MOV EDX,0x13
CALL 0x0014f8e0
CMP EAX,0x0
JZ 0x0014fdb2
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x17cadc]
MOV EDX,0xa
CALL 0x0014f8e0
CMP EAX,0x0
JNZ 0x0014fdc3
LAB_0014fdb2:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x4
JMP 0x0014fddb
LAB_0014fdc3:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014fded
LAB_0014fddb:
JMP 0x0014fddd
LAB_0014fddd:
JMP 0x0014fddf
LAB_0014fddf:
JMP 0x0014fde1
LAB_0014fde1:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f940
MOV dword ptr [RBP + -0x4],EAX
LAB_0014fded:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_parser_scan_reset_before(long param_1)
{
int iVar1;
int4 uVar2;
int8 uVar3;
uVar3 = my_coll_parser_curr(param_1);
iVar1 = lex_cmp(uVar3,"[before primary]",0x10);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 1]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 1;
}
else {
iVar1 = lex_cmp(uVar3,"[before secondary]",0x12);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 2]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 2;
}
else {
iVar1 = lex_cmp(uVar3,"[before tertiary]",0x11);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 3]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 3;
}
else {
iVar1 = lex_cmp(uVar3,"[before quaternary]",0x13);
if ((iVar1 != 0) && (iVar1 = lex_cmp(uVar3,"[before 4]",10), iVar1 != 0)) {
*(int8 *)(param_1 + 0xe0) = 0;
return 0;
}
*(int8 *)(param_1 + 0xe0) = 4;
}
}
}
uVar2 = my_coll_parser_scan(param_1);
return uVar2;
}
|
|
60,069
|
nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int)
|
ng-log[P]ng-log/src/signalhandler.cc
|
void AppendUint64(uint64 number, unsigned radix) {
unsigned i = 0;
while (cursor_ + i < end_) {
const uint64 tmp = number % radix;
number /= radix;
cursor_[i] = static_cast<char>(tmp < 10 ? '0' + tmp : 'a' + tmp - 10);
++i;
if (number == 0) {
break;
}
}
// Reverse the bytes written.
std::reverse(cursor_, cursor_ + i);
cursor_ += i;
}
|
O0
|
cpp
|
nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rax
movl -0x18(%rbp), %edx
addq %rdx, %rax
cmpq 0x10(%rcx), %rax
jae 0x4d568
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0xa, -0x20(%rbp)
jae 0x4d52d
movq -0x20(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x30(%rbp)
jmp 0x4d53d
movq -0x20(%rbp), %rax
addq $0x61, %rax
subq $0xa, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movb %cl, %dl
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4d563
jmp 0x4d568
jmp 0x4d4e2
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rax), %rsi
movl -0x18(%rbp), %eax
addq %rax, %rsi
callq 0x4d8f0
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %edx
movq 0x8(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
_ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
mov [rbp+var_18], 0
loc_4D4E2:
mov rcx, [rbp+var_28]
mov rax, [rcx+8]
mov edx, [rbp+var_18]
add rax, rdx
cmp rax, [rcx+10h]
jnb short loc_4D568
mov rax, [rbp+var_10]
mov ecx, [rbp+var_14]
xor edx, edx
div rcx
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov ecx, eax
mov rax, [rbp+var_10]
xor edx, edx
div rcx
mov [rbp+var_10], rax
cmp [rbp+var_20], 0Ah
jnb short loc_4D52D
mov rax, [rbp+var_20]
add rax, 30h ; '0'
mov [rbp+var_30], rax
jmp short loc_4D53D
loc_4D52D:
mov rax, [rbp+var_20]
add rax, 61h ; 'a'
sub rax, 0Ah
mov [rbp+var_30], rax
loc_4D53D:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov dl, cl
mov rax, [rax+8]
mov ecx, [rbp+var_18]
mov [rax+rcx], dl
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
cmp [rbp+var_10], 0
jnz short loc_4D563
jmp short loc_4D568
loc_4D563:
jmp loc_4D4E2
loc_4D568:
mov rax, [rbp+var_28]
mov rdi, [rax+8]
mov rsi, [rax+8]
mov eax, [rbp+var_18]
add rsi, rax
call _ZSt7reverseIPcEvT_S1_; std::reverse<char *>(char *,char *)
mov rax, [rbp+var_28]
mov edx, [rbp+var_18]
mov rcx, [rax+8]
mov edx, edx
add rcx, rdx
mov [rax+8], rcx
add rsp, 30h
pop rbp
retn
|
nglog::_anonymous_namespace_::MinimalFormatter * nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
nglog::_anonymous_namespace_::MinimalFormatter *this,
unsigned long long a2,
unsigned int a3)
{
nglog::_anonymous_namespace_::MinimalFormatter *result; // rax
char v4; // [rsp+0h] [rbp-30h]
unsigned long long v5; // [rsp+10h] [rbp-20h]
unsigned int v6; // [rsp+18h] [rbp-18h]
v6 = 0;
do
{
if ( (unsigned long long)v6 + *((_QWORD *)this + 1) >= *((_QWORD *)this + 2) )
break;
v5 = a2 % a3;
a2 /= a3;
v4 = v5 >= 0xA ? v5 + 87 : (unsigned __int8)v5 + 48;
*(_BYTE *)(*((_QWORD *)this + 1) + v6++) = v4;
}
while ( a2 );
std::reverse<char *>(*((_QWORD *)this + 1), v6 + *((_QWORD *)this + 1));
result = this;
*((_QWORD *)this + 1) += v6;
return result;
}
|
AppendUint64:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
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 qword ptr [RBP + -0x28],RAX
MOV dword ptr [RBP + -0x18],0x0
LAB_0014d4e2:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RCX + 0x8]
MOV EDX,dword ptr [RBP + -0x18]
ADD RAX,RDX
CMP RAX,qword ptr [RCX + 0x10]
JNC 0x0014d568
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x20],0xa
JNC 0x0014d52d
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x30
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0014d53d
LAB_0014d52d:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x61
SUB RAX,0xa
MOV qword ptr [RBP + -0x30],RAX
LAB_0014d53d:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV DL,CL
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],DL
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0014d563
JMP 0x0014d568
LAB_0014d563:
JMP 0x0014d4e2
LAB_0014d568:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
MOV EAX,dword ptr [RBP + -0x18]
ADD RSI,RAX
CALL 0x0014d8f0
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x8]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
ADD RSP,0x30
POP RBP
RET
|
/* nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int) */
void __thiscall
nglog::(anonymous_namespace)::MinimalFormatter::AppendUint64
(MinimalFormatter *this,ulong param_1,uint param_2)
{
ulong uVar1;
char local_38;
uint local_20;
ulong local_18;
local_20 = 0;
local_18 = param_1;
do {
if (*(ulong *)(this + 0x10) <= *(long *)(this + 8) + (ulong)local_20) break;
uVar1 = local_18 % (ulong)param_2;
local_18 = local_18 / param_2;
local_38 = (char)uVar1;
if (uVar1 < 10) {
local_38 = local_38 + '0';
}
else {
local_38 = local_38 + 'W';
}
*(char *)(*(long *)(this + 8) + (ulong)local_20) = local_38;
local_20 = local_20 + 1;
} while (local_18 != 0);
std::reverse<char*>(*(char **)(this + 8),(char *)(*(long *)(this + 8) + (ulong)local_20));
*(ulong *)(this + 8) = *(long *)(this + 8) + (ulong)local_20;
return;
}
|
|
60,070
|
nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int)
|
ng-log[P]ng-log/src/signalhandler.cc
|
void AppendUint64(uint64 number, unsigned radix) {
unsigned i = 0;
while (cursor_ + i < end_) {
const uint64 tmp = number % radix;
number /= radix;
cursor_[i] = static_cast<char>(tmp < 10 ? '0' + tmp : 'a' + tmp - 10);
++i;
if (number == 0) {
break;
}
}
// Reverse the bytes written.
std::reverse(cursor_, cursor_ + i);
cursor_ += i;
}
|
O1
|
cpp
|
nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int):
movl %edx, %r8d
xorl %ecx, %ecx
movl %ecx, %r9d
addq 0x8(%rdi), %r9
cmpq 0x10(%rdi), %r9
jae 0x212d2
movq %rsi, %rax
xorl %edx, %edx
divq %r8
leal 0x57(%rdx), %r10d
movl %edx, %r11d
orb $0x30, %r11b
cmpq $0xa, %rdx
movzbl %r11b, %edx
movzbl %r10b, %r10d
cmovbl %edx, %r10d
movb %r10b, (%r9)
incl %ecx
cmpq %r8, %rsi
movq %rax, %rsi
jae 0x21295
movq 0x8(%rdi), %rdx
movl %ecx, %eax
testl %ecx, %ecx
setne %sil
leaq (%rdx,%rax), %rcx
decq %rcx
cmpq %rdx, %rcx
seta %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x21315
incq %rdx
movb -0x1(%rdx), %sil
movb (%rcx), %r8b
movb %r8b, -0x1(%rdx)
movb %sil, (%rcx)
decq %rcx
leaq 0x1(%rdx), %rsi
cmpq %rcx, %rdx
movq %rsi, %rdx
jb 0x212f8
addq %rax, 0x8(%rdi)
retq
|
_ZN5nglog12_GLOBAL__N_116MinimalFormatter12AppendUint64Emj:
mov r8d, edx
xor ecx, ecx
loc_21295:
mov r9d, ecx
add r9, [rdi+8]
cmp r9, [rdi+10h]
jnb short loc_212D2
mov rax, rsi
xor edx, edx
div r8
lea r10d, [rdx+57h]
mov r11d, edx
or r11b, 30h
cmp rdx, 0Ah
movzx edx, r11b
movzx r10d, r10b
cmovb r10d, edx
mov [r9], r10b
inc ecx
cmp rsi, r8
mov rsi, rax
jnb short loc_21295
loc_212D2:
mov rdx, [rdi+8]
mov eax, ecx
test ecx, ecx
setnz sil
lea rcx, [rdx+rax]
dec rcx
cmp rcx, rdx
setnbe r8b
and r8b, sil
cmp r8b, 1
jnz short loc_21315
inc rdx
loc_212F8:
mov sil, [rdx-1]
mov r8b, [rcx]
mov [rdx-1], r8b
mov [rcx], sil
dec rcx
lea rsi, [rdx+1]
cmp rdx, rcx
mov rdx, rsi
jb short loc_212F8
loc_21315:
add [rdi+8], rax
retn
|
long long nglog::`anonymous namespace'::MinimalFormatter::AppendUint64(
nglog::_anonymous_namespace_::MinimalFormatter *this,
unsigned long long a2,
unsigned int a3)
{
unsigned int v3; // ecx
_BYTE *v4; // r9
char v5; // r10
bool v6; // cf
unsigned long long v7; // rdx
long long result; // rax
bool v9; // si
_BYTE *v10; // rcx
unsigned long long v11; // rdx
char v12; // si
v3 = 0;
do
{
v4 = (_BYTE *)(*((_QWORD *)this + 1) + v3);
if ( (unsigned long long)v4 >= *((_QWORD *)this + 2) )
break;
v5 = a2 % a3 + 87;
if ( a2 % a3 < 0xA )
v5 = (a2 % a3) | 0x30;
*v4 = v5;
++v3;
v6 = a2 < a3;
a2 /= a3;
}
while ( !v6 );
v7 = *((_QWORD *)this + 1);
result = v3;
v9 = v3 != 0;
v10 = (_BYTE *)(v7 + v3 - 1);
if ( v9 && (unsigned long long)v10 > v7 )
{
v11 = v7 + 1;
do
{
v12 = *(_BYTE *)(v11 - 1);
*(_BYTE *)(v11 - 1) = *v10;
*v10-- = v12;
v6 = v11++ < (unsigned long long)v10;
}
while ( v6 );
}
*((_QWORD *)this + 1) += result;
return result;
}
|
AppendUint64:
MOV R8D,EDX
XOR ECX,ECX
LAB_00121295:
MOV R9D,ECX
ADD R9,qword ptr [RDI + 0x8]
CMP R9,qword ptr [RDI + 0x10]
JNC 0x001212d2
MOV RAX,RSI
XOR EDX,EDX
DIV R8
LEA R10D,[RDX + 0x57]
MOV R11D,EDX
OR R11B,0x30
CMP RDX,0xa
MOVZX EDX,R11B
MOVZX R10D,R10B
CMOVC R10D,EDX
MOV byte ptr [R9],R10B
INC ECX
CMP RSI,R8
MOV RSI,RAX
JNC 0x00121295
LAB_001212d2:
MOV RDX,qword ptr [RDI + 0x8]
MOV EAX,ECX
TEST ECX,ECX
SETNZ SIL
LEA RCX,[RDX + RAX*0x1]
DEC RCX
CMP RCX,RDX
SETA R8B
AND R8B,SIL
CMP R8B,0x1
JNZ 0x00121315
INC RDX
LAB_001212f8:
MOV SIL,byte ptr [RDX + -0x1]
MOV R8B,byte ptr [RCX]
MOV byte ptr [RDX + -0x1],R8B
MOV byte ptr [RCX],SIL
DEC RCX
LEA RSI,[RDX + 0x1]
CMP RDX,RCX
MOV RDX,RSI
JC 0x001212f8
LAB_00121315:
ADD qword ptr [RDI + 0x8],RAX
RET
|
/* nglog::(anonymous namespace)::MinimalFormatter::AppendUint64(unsigned long, unsigned int) */
void __thiscall
nglog::(anonymous_namespace)::MinimalFormatter::AppendUint64
(MinimalFormatter *this,ulong param_1,uint param_2)
{
int1 uVar1;
int1 *puVar2;
int1 auVar3 [16];
int1 auVar4 [16];
byte bVar5;
uint uVar6;
int1 *puVar7;
int1 *puVar8;
ulong uVar9;
byte bVar10;
bool bVar11;
uVar9 = CONCAT44(0,param_2);
uVar6 = 0;
do {
if (*(byte **)(this + 0x10) <= (byte *)((ulong)uVar6 + *(long *)(this + 8))) break;
auVar3._8_8_ = 0;
auVar3._0_8_ = uVar9;
auVar4._8_8_ = 0;
auVar4._0_8_ = param_1;
bVar5 = SUB161(auVar4 % auVar3,0);
bVar10 = bVar5 + 0x57;
if (SUB168(auVar4 % auVar3,0) < 10) {
bVar10 = bVar5 | 0x30;
}
*(byte *)((ulong)uVar6 + *(long *)(this + 8)) = bVar10;
uVar6 = uVar6 + 1;
bVar11 = uVar9 <= param_1;
param_1 = param_1 / uVar9;
} while (bVar11);
puVar2 = *(int1 **)(this + 8);
puVar7 = puVar2 + ((ulong)uVar6 - 1);
if (puVar2 < puVar7 && uVar6 != 0) {
do {
puVar8 = puVar2 + 1;
uVar1 = *puVar2;
*puVar2 = *puVar7;
*puVar7 = uVar1;
puVar7 = puVar7 + -1;
puVar2 = puVar8;
} while (puVar8 < puVar7);
}
*(ulong *)(this + 8) = *(long *)(this + 8) + (ulong)uVar6;
return;
}
|
|
60,071
|
decltype(fp0.reserve(std::declval<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::size_type>()), fp.get<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json_array_impl<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>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, 0>(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> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, nlohmann::json_abi_v3_11_3::detail::priority_tag<1u>)
|
msxemulator/build_O3/_deps/picotool-src/lib/nlohmann_json/single_include/nlohmann/json.hpp
|
auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
-> decltype(
arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
j.template get<typename ConstructibleArrayType::value_type>(),
void())
{
using std::end;
ConstructibleArrayType ret;
ret.reserve(j.size());
std::transform(j.begin(), j.end(),
std::inserter(ret, end(ret)), [](const BasicJsonType & i)
{
// get<BasicJsonType>() returns *this, this won't call a from_json
// method when value_type is BasicJsonType
return i.template get<typename ConstructibleArrayType::value_type>();
});
arr = std::move(ret);
}
|
O3
|
cpp
|
decltype(fp0.reserve(std::declval<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::size_type>()), fp.get<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::value_type>(), (void)()) nlohmann::json_abi_v3_11_3::detail::from_json_array_impl<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>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, 0>(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> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, nlohmann::json_abi_v3_11_3::detail::priority_tag<1u>):
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movzbl (%rdi), %esi
testl %esi, %esi
je 0x6ffb7
cmpl $0x1, %esi
je 0x6ffa8
cmpl $0x2, %esi
jne 0x6ffb2
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
subq (%rax), %rsi
sarq $0x4, %rsi
jmp 0x6ffb7
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
jmp 0x6ffb7
movl $0x1, %esi
leaq 0x20(%rsp), %rdi
callq 0x700de
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %r14, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq %rax, 0x58(%rsp)
movzbl (%r14), %ecx
testl %ecx, %ecx
je 0x70042
cmpl $0x2, %ecx
je 0x70019
cmpl $0x1, %ecx
jne 0x7004d
movq 0x8(%r14), %rcx
movq 0x18(%rcx), %rdx
movq %rdx, 0x48(%rsp)
movq %r14, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
addq $0x8, %rcx
movq %rcx, 0x8(%rsp)
jmp 0x70068
movq 0x8(%r14), %rcx
movq (%rcx), %rdx
movq %rdx, 0x50(%rsp)
movq %r14, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x10(%rsp)
jmp 0x70068
movq $0x1, 0x58(%rsp)
jmp 0x70056
movq $0x0, 0x58(%rsp)
movq %r14, (%rsp)
movups %xmm0, 0x8(%rsp)
movq $0x1, 0x18(%rsp)
leaq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rcx
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x701c5
movq 0x10(%rbx), %rax
leaq 0x20(%rsp), %r14
movaps (%r14), %xmm0
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rbx)
movups (%rbx), %xmm1
movups %xmm0, (%rbx)
leaq 0x60(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
callq 0x1d254
movq %r14, %rdi
callq 0x1d254
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1d254
movq %rbx, %rdi
callq 0xf7d0
|
_ZN8nlohmann16json_abi_v3_11_36detail20from_json_array_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISB_SaISB_EETnNSt9enable_ifIXsr3std13is_assignableIRT0_SJ_EE5valueEiE4typeELi0EEEDTcmcmcldtfp0_7reserveclsr3stdE7declvalINSJ_9size_typeEEEEcldtfp_3getINSJ_10value_typeEEEcvv_EERKT_SK_NS1_12priority_tagILj1EEE:
push r14
push rbx
sub rsp, 78h
mov rbx, rsi
mov r14, rdi
xorps xmm0, xmm0
movaps xmmword ptr [rsp+88h+var_68], xmm0
mov [rsp+88h+var_58], 0
movzx esi, byte ptr [rdi]
test esi, esi
jz short loc_6FFB7
cmp esi, 1
jz short loc_6FFA8
cmp esi, 2
jnz short loc_6FFB2
mov rax, [r14+8]
mov rsi, [rax+8]
sub rsi, [rax]
sar rsi, 4
jmp short loc_6FFB7
loc_6FFA8:
mov rax, [r14+8]
mov rsi, [rax+28h]
jmp short loc_6FFB7
loc_6FFB2:
mov esi, 1
loc_6FFB7:
lea rdi, [rsp+88h+var_68]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE7reserveEm; std::vector<std::string>::reserve(ulong)
mov rax, 8000000000000000h
mov qword ptr [rsp+88h+var_48], r14
xorps xmm0, xmm0
movups [rsp+88h+var_40], xmm0
mov [rsp+88h+var_30], rax
movzx ecx, byte ptr [r14]
test ecx, ecx
jz short loc_70042
cmp ecx, 2
jz short loc_70019
cmp ecx, 1
jnz short loc_7004D
mov rcx, [r14+8]
mov rdx, [rcx+18h]
mov qword ptr [rsp+88h+var_40], rdx
mov [rsp+88h+var_88], r14
mov qword ptr [rsp+88h+var_80+8], 0
mov [rsp+88h+var_70], rax
add rcx, 8
mov qword ptr [rsp+88h+var_80], rcx
jmp short loc_70068
loc_70019:
mov rcx, [r14+8]
mov rdx, [rcx]
mov qword ptr [rsp+88h+var_40+8], rdx
mov [rsp+88h+var_88], r14
mov qword ptr [rsp+88h+var_80], 0
mov [rsp+88h+var_70], rax
mov rax, [rcx+8]
mov qword ptr [rsp+88h+var_80+8], rax
jmp short loc_70068
loc_70042:
mov [rsp+88h+var_30], 1
jmp short loc_70056
loc_7004D:
mov [rsp+88h+var_30], 0
loc_70056:
mov [rsp+88h+var_88], r14; void *
movups xmmword ptr [rsp+88h+var_80], xmm0; int
mov [rsp+88h+var_70], 1
loc_70068:
lea rdx, [rsp+88h+var_68]; int
mov rcx, [rdx+8]; int
lea rdi, [rsp+88h+var_48]; int
mov rsi, rsp; int
call _ZSt9transformIN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEESt15insert_iteratorIS6_ISC_SaISC_EEEZNS2_20from_json_array_implISG_SL_TnNSt9enable_ifIXsr3std13is_assignableIRT0_SP_EE5valueEiE4typeELi0EEEDTcmcmcldtfL0p0_7reserveclsr3stdE7declvalINSP_9size_typeEEEEcldtfL0p_3getINSP_10value_typeEEEcvv_EERKT_SQ_NS2_12priority_tagILj1EEEEUlRSH_E_ESP_SW_SW_SP_T1_
mov rax, [rbx+10h]
lea r14, [rsp+88h+var_68]
movaps xmm0, xmmword ptr [r14]
mov rcx, [r14+10h]
mov [rbx+10h], rcx
movups xmm1, xmmword ptr [rbx]
movups xmmword ptr [rbx], xmm0
lea rdi, [rsp+88h+var_28]; void *
movaps xmmword ptr [rdi], xmm1
mov [rdi+10h], rax
xorps xmm0, xmm0
movaps xmmword ptr [r14], xmm0
mov qword ptr [r14+10h], 0
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
add rsp, 78h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, rbx
call __Unwind_Resume
|
void ZN8nlohmann16json_abi_v3_11_36detail20from_json_array_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISB_SaISB_EETnNSt9enable_ifIXsr3std13is_assignableIRT0_SJ_EE5valueEiE4typeELi0EEEDTcmcmcldtfp0_7reserveclsr3stdE7declvalINSJ_9size_typeEEEEcldtfp_3getINSJ_10value_typeEEEcvv_EERKT_SK_NS1_12priority_tagILj1EEE(
_BYTE *a1,
__int128 *a2)
{
int v2; // r8d
int v3; // r9d
int v4; // ecx
long long v5; // rcx
_QWORD *v6; // rcx
long long v7; // rax
__int128 v8; // xmm0
__int128 v9; // xmm1
void *v10; // [rsp+0h] [rbp-88h] BYREF
int v11[4]; // [rsp+8h] [rbp-80h]
long long v12; // [rsp+18h] [rbp-70h]
int v13[4]; // [rsp+20h] [rbp-68h] BYREF
long long v14; // [rsp+30h] [rbp-58h]
int v15[2]; // [rsp+40h] [rbp-48h] BYREF
__int128 v16; // [rsp+48h] [rbp-40h]
long long v17; // [rsp+58h] [rbp-30h]
__int128 v18; // [rsp+60h] [rbp-28h] BYREF
long long v19; // [rsp+70h] [rbp-18h]
*(_OWORD *)v13 = 0LL;
v14 = 0LL;
std::vector<std::string>::reserve(v13);
*(_QWORD *)v15 = a1;
v16 = 0LL;
v17 = 0x8000000000000000LL;
v4 = (unsigned __int8)*a1;
if ( !*a1 )
{
v17 = 1LL;
LABEL_8:
v10 = a1;
*(_OWORD *)v11 = 0LL;
v12 = 1LL;
goto LABEL_9;
}
if ( v4 == 2 )
{
v6 = (_QWORD *)*((_QWORD *)a1 + 1);
*((_QWORD *)&v16 + 1) = *v6;
v10 = a1;
*(_QWORD *)v11 = 0LL;
v12 = 0x8000000000000000LL;
*(_QWORD *)&v11[2] = v6[1];
goto LABEL_9;
}
if ( v4 != 1 )
{
v17 = 0LL;
goto LABEL_8;
}
v5 = *((_QWORD *)a1 + 1);
*(_QWORD *)&v16 = *(_QWORD *)(v5 + 24);
v10 = a1;
*(_QWORD *)&v11[2] = 0LL;
v12 = 0x8000000000000000LL;
*(_QWORD *)v11 = v5 + 8;
LABEL_9:
ZSt9transformIN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEESt15insert_iteratorIS6_ISC_SaISC_EEEZNS2_20from_json_array_implISG_SL_TnNSt9enable_ifIXsr3std13is_assignableIRT0_SP_EE5valueEiE4typeELi0EEEDTcmcmcldtfL0p0_7reserveclsr3stdE7declvalINSP_9size_typeEEEEcldtfL0p_3getINSP_10value_typeEEEcvv_EERKT_SQ_NS2_12priority_tagILj1EEEEUlRSH_E_ESP_SW_SW_SP_T1_(
(int)v15,
(int)&v10,
(int)v13,
v13[2],
v2,
v3,
v10,
v11[0],
*(long long *)&v11[2]);
v7 = *((_QWORD *)a2 + 2);
v8 = *(_OWORD *)v13;
*((_QWORD *)a2 + 2) = v14;
v9 = *a2;
*a2 = v8;
v18 = v9;
v19 = v7;
*(_OWORD *)v13 = 0LL;
v14 = 0LL;
std::vector<std::string>::~vector(&v18);
std::vector<std::string>::~vector(v13);
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20from_json_array_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISB_SaISB_EETnNSt9enable_ifIXsr3std13is_assignableIRT0_SJ_EE5valueEiE4typeELi0EEEDTcmcmcldtfp0_7reserveclsr3stdE7declvalINSJ_9size_typeEEEEcldtfp_3getINSJ_10value_typeEEEcvv_EERKT_SK_NS1_12priority_tagILj1EEE:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV RBX,RSI
MOV R14,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
MOVZX ESI,byte ptr [RDI]
TEST ESI,ESI
JZ 0x0016ffb7
CMP ESI,0x1
JZ 0x0016ffa8
CMP ESI,0x2
JNZ 0x0016ffb2
MOV RAX,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [RAX + 0x8]
SUB RSI,qword ptr [RAX]
SAR RSI,0x4
JMP 0x0016ffb7
LAB_0016ffa8:
MOV RAX,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [RAX + 0x28]
JMP 0x0016ffb7
LAB_0016ffb2:
MOV ESI,0x1
LAB_0016ffb7:
LEA RDI,[RSP + 0x20]
CALL 0x001700de
MOV RAX,-0x8000000000000000
MOV qword ptr [RSP + 0x40],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x48],XMM0
MOV qword ptr [RSP + 0x58],RAX
MOVZX ECX,byte ptr [R14]
TEST ECX,ECX
JZ 0x00170042
CMP ECX,0x2
JZ 0x00170019
CMP ECX,0x1
JNZ 0x0017004d
MOV RCX,qword ptr [R14 + 0x8]
MOV RDX,qword ptr [RCX + 0x18]
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP],R14
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],RAX
ADD RCX,0x8
MOV qword ptr [RSP + 0x8],RCX
JMP 0x00170068
LAB_00170019:
MOV RCX,qword ptr [R14 + 0x8]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP],R14
MOV qword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RCX + 0x8]
MOV qword ptr [RSP + 0x10],RAX
JMP 0x00170068
LAB_00170042:
MOV qword ptr [RSP + 0x58],0x1
JMP 0x00170056
LAB_0017004d:
MOV qword ptr [RSP + 0x58],0x0
LAB_00170056:
MOV qword ptr [RSP],R14
MOVUPS xmmword ptr [RSP + 0x8],XMM0
MOV qword ptr [RSP + 0x18],0x1
LAB_00170068:
LEA RDX,[RSP + 0x20]
MOV RCX,qword ptr [RDX + 0x8]
LEA RDI,[RSP + 0x40]
MOV RSI,RSP
CALL 0x001701c5
LAB_0017007e:
MOV RAX,qword ptr [RBX + 0x10]
LEA R14,[RSP + 0x20]
MOVAPS XMM0,xmmword ptr [R14]
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RCX
MOVUPS XMM1,xmmword ptr [RBX]
MOVUPS xmmword ptr [RBX],XMM0
LEA RDI,[RSP + 0x60]
MOVAPS xmmword ptr [RDI],XMM1
MOV qword ptr [RDI + 0x10],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [R14],XMM0
MOV qword ptr [R14 + 0x10],0x0
CALL 0x0011d254
MOV RDI,R14
CALL 0x0011d254
ADD RSP,0x78
POP RBX
POP R14
RET
|
void _ZN8nlohmann16json_abi_v3_11_36detail20from_json_array_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEES5_ISB_SaISB_EETnNSt9enable_ifIXsr3std13is_assignableIRT0_SJ_EE5valueEiE4typeELi0EEEDTcmcmcldtfp0_7reserveclsr3stdE7declvalINSJ_9size_typeEEEEcldtfp_3getINSJ_10value_typeEEEcvv_EERKT_SK_NS1_12priority_tagILj1EEE
(byte *param_1,int8 *param_2)
{
byte bVar1;
ulong uVar2;
byte *local_88;
long local_80;
int8 uStack_78;
int8 local_70;
int8 local_68;
int8 uStack_60;
int8 local_58;
byte *local_48;
int8 local_40;
int8 uStack_38;
int8 local_30;
int8 local_28;
int8 uStack_20;
int8 local_18;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
bVar1 = *param_1;
uVar2 = (ulong)bVar1;
if (bVar1 != 0) {
if (bVar1 == 1) {
uVar2 = *(ulong *)(*(long *)(param_1 + 8) + 0x28);
}
else if (bVar1 == 2) {
uVar2 = (*(long **)(param_1 + 8))[1] - **(long **)(param_1 + 8) >> 4;
}
else {
uVar2 = 1;
}
}
/* try { // try from 0016ffb7 to 0017007d has its CatchHandler @ 001700c9 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::reserve
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68,uVar2);
local_40 = 0;
uStack_38 = 0;
local_30 = 0x8000000000000000;
bVar1 = *param_1;
if (bVar1 == 0) {
local_30 = 1;
}
else {
if (bVar1 == 2) {
uStack_38 = **(int8 **)(param_1 + 8);
local_80 = 0;
local_70 = 0x8000000000000000;
uStack_78 = (*(int8 **)(param_1 + 8))[1];
goto LAB_00170068;
}
if (bVar1 == 1) {
local_40 = *(int8 *)(*(long *)(param_1 + 8) + 0x18);
uStack_78 = 0;
local_70 = 0x8000000000000000;
local_80 = *(long *)(param_1 + 8) + 8;
goto LAB_00170068;
}
local_30 = 0;
}
local_80 = 0;
uStack_78 = 0;
local_70 = 1;
LAB_00170068:
local_88 = param_1;
local_48 = param_1;
_ZSt9transformIN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEESt15insert_iteratorIS6_ISC_SaISC_EEEZNS2_20from_json_array_implISG_SL_TnNSt9enable_ifIXsr3std13is_assignableIRT0_SP_EE5valueEiE4typeELi0EEEDTcmcmcldtfL0p0_7reserveclsr3stdE7declvalINSP_9size_typeEEEEcldtfL0p_3getINSP_10value_typeEEEcvv_EERKT_SQ_NS2_12priority_tagILj1EEEEUlRSH_E_ESP_SW_SW_SP_T1_
(&local_48,&local_88,&local_68,uStack_60);
local_18 = param_2[2];
param_2[2] = local_58;
local_28 = *param_2;
uStack_20 = param_2[1];
*param_2 = local_68;
param_2[1] = uStack_60;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_28);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)&local_68);
return;
}
|
|
60,072
|
ggml_compute_fp32_to_bf16
|
monkey531[P]llama/ggml/src/./ggml-impl.h
|
static inline ggml_bf16_t ggml_compute_fp32_to_bf16(float s) {
ggml_bf16_t h;
union {
float f;
uint32_t i;
} u;
u.f = s;
if ((u.i & 0x7fffffff) > 0x7f800000) { /* nan */
h.bits = (u.i >> 16) | 64; /* force to quiet */
return h;
}
h.bits = (u.i + (0x7fff + ((u.i >> 16) & 1))) >> 16;
return h;
}
|
O0
|
c
|
ggml_compute_fp32_to_bf16:
vmovss %xmm0, -0x8(%rsp)
vmovss -0x8(%rsp), %xmm0
vmovss %xmm0, -0xc(%rsp)
movl -0xc(%rsp), %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x7f800000, %eax # imm = 0x7F800000
jbe 0xe2d3
movl -0xc(%rsp), %eax
shrl $0x10, %eax
orl $0x40, %eax
movw %ax, -0x2(%rsp)
jmp 0xe2f1
movl -0xc(%rsp), %eax
movl -0xc(%rsp), %ecx
shrl $0x10, %ecx
andl $0x1, %ecx
addl $0x7fff, %ecx # imm = 0x7FFF
addl %ecx, %eax
shrl $0x10, %eax
movw %ax, -0x2(%rsp)
movw -0x2(%rsp), %ax
retq
nopw (%rax,%rax)
|
ggml_compute_fp32_to_bf16:
vmovss [rsp+var_8], xmm0
vmovss xmm0, [rsp+var_8]
vmovss [rsp+var_C], xmm0
mov eax, [rsp+var_C]
and eax, 7FFFFFFFh
cmp eax, 7F800000h
jbe short loc_E2D3
mov eax, [rsp+var_C]
shr eax, 10h
or eax, 40h
mov [rsp+var_2], ax
jmp short loc_E2F1
loc_E2D3:
mov eax, [rsp+var_C]
mov ecx, [rsp+var_C]
shr ecx, 10h
and ecx, 1
add ecx, 7FFFh
add eax, ecx
shr eax, 10h
mov [rsp+var_2], ax
loc_E2F1:
mov ax, [rsp+var_2]
retn
|
__int16 ggml_compute_fp32_to_bf16(__m128 _XMM0)
{
unsigned int v3; // [rsp+0h] [rbp-Ch] BYREF
__asm
{
vmovss [rsp+var_8], xmm0
vmovss xmm0, [rsp+var_8]
vmovss [rsp+var_C], xmm0
}
if ( (v3 & 0x7FFFFFFF) <= 0x7F800000 )
return ((HIWORD(v3) & 1) + 0x7FFF + v3) >> 16;
else
return HIWORD(v3) | 0x40;
}
|
ggml_compute_fp32_to_bf16:
VMOVSS dword ptr [RSP + -0x8],XMM0
VMOVSS XMM0,dword ptr [RSP + -0x8]
VMOVSS dword ptr [RSP + -0xc],XMM0
MOV EAX,dword ptr [RSP + -0xc]
AND EAX,0x7fffffff
CMP EAX,0x7f800000
JBE 0x0010e2d3
MOV EAX,dword ptr [RSP + -0xc]
SHR EAX,0x10
OR EAX,0x40
MOV word ptr [RSP + -0x2],AX
JMP 0x0010e2f1
LAB_0010e2d3:
MOV EAX,dword ptr [RSP + -0xc]
MOV ECX,dword ptr [RSP + -0xc]
SHR ECX,0x10
AND ECX,0x1
ADD ECX,0x7fff
ADD EAX,ECX
SHR EAX,0x10
MOV word ptr [RSP + -0x2],AX
LAB_0010e2f1:
MOV AX,word ptr [RSP + -0x2]
RET
|
ushort ggml_compute_fp32_to_bf16(uint param_1)
{
int2 local_2;
if ((param_1 & 0x7fffffff) < 0x7f800001) {
local_2 = (ushort)(param_1 + (param_1 >> 0x10 & 1) + 0x7fff >> 0x10);
}
else {
local_2 = (ushort)(param_1 >> 0x10) | 0x40;
}
return local_2;
}
|
|
60,073
|
my_uca_scanner_next_implicit
|
eloqsql/strings/ctype-uca.c
|
static inline int
my_uca_scanner_next_implicit(my_uca_scanner *scanner)
{
switch (scanner->level->levelno) {
case 0: return my_uca_scanner_next_implicit_primary(scanner);/* Primary level*/
case 1: scanner->wbeg= nochar; return 0x0020; /* Secondary level */
case 2: scanner->wbeg= nochar; return 0x0002; /* Tertiary level */
default: scanner->wbeg= nochar; break;
}
DBUG_ASSERT(0);
return 0;
}
|
O0
|
c
|
my_uca_scanner_next_implicit:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x57304
jmp 0x572f0
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x57312
jmp 0x572fa
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x57329
jmp 0x57340
movq -0x10(%rbp), %rdi
callq 0x57650
movl %eax, -0x4(%rbp)
jmp 0x57359
movq -0x10(%rbp), %rax
leaq 0x1601b3(%rip), %rcx # 0x1b74d0
movq %rcx, (%rax)
movl $0x20, -0x4(%rbp)
jmp 0x57359
movq -0x10(%rbp), %rax
leaq 0x16019c(%rip), %rcx # 0x1b74d0
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x57359
movq -0x10(%rbp), %rax
leaq 0x160185(%rip), %rcx # 0x1b74d0
movq %rcx, (%rax)
jmp 0x57350
jmp 0x57352
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_scanner_next_implicit:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+18h]
mov eax, [rax+30h]
mov [rbp+var_14], eax
test eax, eax
jz short loc_57304
jmp short $+2
loc_572F0:
mov eax, [rbp+var_14]
sub eax, 1
jz short loc_57312
jmp short $+2
loc_572FA:
mov eax, [rbp+var_14]
sub eax, 2
jz short loc_57329
jmp short loc_57340
loc_57304:
mov rdi, [rbp+var_10]
call my_uca_scanner_next_implicit_primary
mov [rbp+var_4], eax
jmp short loc_57359
loc_57312:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
mov [rbp+var_4], 20h ; ' '
jmp short loc_57359
loc_57329:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
mov [rbp+var_4], 2
jmp short loc_57359
loc_57340:
mov rax, [rbp+var_10]
lea rcx, nochar
mov [rax], rcx
jmp short $+2
loc_57350:
jmp short $+2
loc_57352:
mov [rbp+var_4], 0
loc_57359:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_uca_scanner_next_implicit(_QWORD *a1)
{
int v2; // [rsp+Ch] [rbp-14h]
v2 = *(_DWORD *)(a1[3] + 48LL);
if ( v2 )
{
if ( v2 == 1 )
{
*a1 = &nochar;
return 32;
}
else
{
*a1 = &nochar;
if ( v2 == 2 )
return 2;
else
return 0;
}
}
else
{
return (unsigned int)my_uca_scanner_next_implicit_primary(a1);
}
}
|
my_uca_scanner_next_implicit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RBP + -0x14],EAX
TEST EAX,EAX
JZ 0x00157304
JMP 0x001572f0
LAB_001572f0:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
JZ 0x00157312
JMP 0x001572fa
LAB_001572fa:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x2
JZ 0x00157329
JMP 0x00157340
LAB_00157304:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00157650
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00157359
LAB_00157312:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2b74d0]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x20
JMP 0x00157359
LAB_00157329:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2b74d0]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x00157359
LAB_00157340:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x2b74d0]
MOV qword ptr [RAX],RCX
JMP 0x00157350
LAB_00157350:
JMP 0x00157352
LAB_00157352:
MOV dword ptr [RBP + -0x4],0x0
LAB_00157359:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_uca_scanner_next_implicit(int8 *param_1)
{
int iVar1;
int4 local_c;
iVar1 = *(int *)(param_1[3] + 0x30);
if (iVar1 == 0) {
local_c = my_uca_scanner_next_implicit_primary(param_1);
}
else if (iVar1 == 1) {
*param_1 = &nochar;
local_c = 0x20;
}
else if (iVar1 == 2) {
*param_1 = &nochar;
local_c = 2;
}
else {
*param_1 = &nochar;
local_c = 0;
}
return local_c;
}
|
|
60,074
|
dummy_fallback_auth_client
|
eloqsql/libmariadb/plugins/auth/my_auth.c
|
static int dummy_fallback_auth_client(MYSQL_PLUGIN_VIO *vio, MYSQL *mysql __attribute__((unused)))
{
char last_error[MYSQL_ERRMSG_SIZE];
unsigned int i, last_errno= ((MCPVIO_EXT *)vio)->mysql->net.last_errno;
if (last_errno)
{
strncpy(last_error, ((MCPVIO_EXT *)vio)->mysql->net.last_error,
sizeof(last_error) - 1);
last_error[sizeof(last_error) - 1]= 0;
}
/* safety-wise we only do 10 round-trips */
for (i=0; i < 10; i++)
{
uchar *pkt;
if (vio->read_packet(vio, &pkt) < 0)
break;
if (vio->write_packet(vio, 0, 0))
break;
}
if (last_errno)
{
MYSQL *mysql= ((MCPVIO_EXT *)vio)->mysql;
strncpy(mysql->net.last_error, last_error,
sizeof(mysql->net.last_error) - 1);
mysql->net.last_error[sizeof(mysql->net.last_error) - 1]= 0;
}
return CR_ERROR;
}
|
O0
|
c
|
dummy_fallback_auth_client:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp # imm = 0x240
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x218(%rbp)
movq %rsi, -0x220(%rbp)
movq -0x218(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x90(%rax), %eax
movl %eax, -0x228(%rbp)
cmpl $0x0, -0x228(%rbp)
je 0x59f2d
leaq -0x210(%rbp), %rdi
movq -0x218(%rbp), %rax
movq 0x18(%rax), %rsi
addq $0x97, %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14220
movb $0x0, -0x11(%rbp)
movl $0x0, -0x224(%rbp)
cmpl $0xa, -0x224(%rbp)
jae 0x59f95
movq -0x218(%rbp), %rax
movq (%rax), %rax
movq -0x218(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jge 0x59f61
jmp 0x59f95
movq -0x218(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x218(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
xorl %edx, %edx
callq *%rax
cmpl $0x0, %eax
je 0x59f82
jmp 0x59f95
jmp 0x59f84
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x59f37
cmpl $0x0, -0x228(%rbp)
je 0x59fdd
movq -0x218(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
addq $0x97, %rdi
leaq -0x210(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14220
movq -0x238(%rbp), %rax
movb $0x0, 0x296(%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x59ffa
xorl %eax, %eax
addq $0x240, %rsp # imm = 0x240
popq %rbp
retq
callq 0x144c0
nop
|
dummy_fallback_auth_client:
push rbp
mov rbp, rsp
sub rsp, 240h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], rdi
mov [rbp+var_220], rsi
mov rax, [rbp+var_218]
mov rax, [rax+18h]
mov eax, [rax+90h]
mov [rbp+var_228], eax
cmp [rbp+var_228], 0
jz short loc_59F2D
lea rdi, [rbp+var_210]
mov rax, [rbp+var_218]
mov rsi, [rax+18h]
add rsi, 97h
mov edx, 1FFh
call _strncpy
mov [rbp+var_11], 0
loc_59F2D:
mov [rbp+var_224], 0
loc_59F37:
cmp [rbp+var_224], 0Ah
jnb short loc_59F95
mov rax, [rbp+var_218]
mov rax, [rax]
mov rdi, [rbp+var_218]
lea rsi, [rbp+var_230]
call rax
cmp eax, 0
jge short loc_59F61
jmp short loc_59F95
loc_59F61:
mov rax, [rbp+var_218]
mov rax, [rax+8]
mov rdi, [rbp+var_218]
xor ecx, ecx
mov esi, ecx
xor edx, edx
call rax
cmp eax, 0
jz short loc_59F82
jmp short loc_59F95
loc_59F82:
jmp short $+2
loc_59F84:
mov eax, [rbp+var_224]
add eax, 1
mov [rbp+var_224], eax
jmp short loc_59F37
loc_59F95:
cmp [rbp+var_228], 0
jz short loc_59FDD
mov rax, [rbp+var_218]
mov rax, [rax+18h]
mov [rbp+var_238], rax
mov rdi, [rbp+var_238]
add rdi, 97h
lea rsi, [rbp+var_210]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_238]
mov byte ptr [rax+296h], 0
loc_59FDD:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_59FFA
xor eax, eax
add rsp, 240h
pop rbp
retn
loc_59FFA:
call ___stack_chk_fail
|
long long dummy_fallback_auth_client(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-238h]
_BYTE v4[8]; // [rsp+10h] [rbp-230h] BYREF
int v5; // [rsp+18h] [rbp-228h]
unsigned int i; // [rsp+1Ch] [rbp-224h]
long long v7; // [rsp+20h] [rbp-220h]
long long v8; // [rsp+28h] [rbp-218h]
_BYTE v9[520]; // [rsp+30h] [rbp-210h] BYREF
unsigned long long v10; // [rsp+238h] [rbp-8h]
v10 = __readfsqword(0x28u);
v8 = a1;
v7 = a2;
v5 = *(_DWORD *)(*(_QWORD *)(a1 + 24) + 144LL);
if ( v5 )
{
strncpy(v9, *(_QWORD *)(v8 + 24) + 151LL, 511LL);
v9[511] = 0;
}
for ( i = 0;
i < 0xA
&& (*(int ( **)(long long, _BYTE *))v8)(v8, v4) >= 0
&& !(*(unsigned int ( **)(long long, _QWORD, _QWORD))(v8 + 8))(v8, 0LL, 0LL);
++i )
{
;
}
if ( v5 )
{
v3 = *(_QWORD *)(v8 + 24);
strncpy(v3 + 151, v9, 511LL);
*(_BYTE *)(v3 + 662) = 0;
}
return 0LL;
}
|
dummy_fallback_auth_client:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x240
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x218],RDI
MOV qword ptr [RBP + -0x220],RSI
MOV RAX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RAX + 0x18]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x228],EAX
CMP dword ptr [RBP + -0x228],0x0
JZ 0x00159f2d
LEA RDI,[RBP + -0x210]
MOV RAX,qword ptr [RBP + -0x218]
MOV RSI,qword ptr [RAX + 0x18]
ADD RSI,0x97
MOV EDX,0x1ff
CALL 0x00114220
MOV byte ptr [RBP + -0x11],0x0
LAB_00159f2d:
MOV dword ptr [RBP + -0x224],0x0
LAB_00159f37:
CMP dword ptr [RBP + -0x224],0xa
JNC 0x00159f95
MOV RAX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x218]
LEA RSI,[RBP + -0x230]
CALL RAX
CMP EAX,0x0
JGE 0x00159f61
JMP 0x00159f95
LAB_00159f61:
MOV RAX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x218]
XOR ECX,ECX
MOV ESI,ECX
XOR EDX,EDX
CALL RAX
CMP EAX,0x0
JZ 0x00159f82
JMP 0x00159f95
LAB_00159f82:
JMP 0x00159f84
LAB_00159f84:
MOV EAX,dword ptr [RBP + -0x224]
ADD EAX,0x1
MOV dword ptr [RBP + -0x224],EAX
JMP 0x00159f37
LAB_00159f95:
CMP dword ptr [RBP + -0x228],0x0
JZ 0x00159fdd
MOV RAX,qword ptr [RBP + -0x218]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x238],RAX
MOV RDI,qword ptr [RBP + -0x238]
ADD RDI,0x97
LEA RSI,[RBP + -0x210]
MOV EDX,0x1ff
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x238]
MOV byte ptr [RAX + 0x296],0x0
LAB_00159fdd:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00159ffa
XOR EAX,EAX
ADD RSP,0x240
POP RBP
RET
LAB_00159ffa:
CALL 0x001144c0
|
int8 dummy_fallback_auth_client(int8 *param_1,int8 param_2)
{
long lVar1;
int iVar2;
long in_FS_OFFSET;
int1 local_238 [8];
int local_230;
uint local_22c;
int8 local_228;
int8 *local_220;
char local_218 [511];
int1 local_19;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_230 = *(int *)(param_1[3] + 0x90);
local_228 = param_2;
local_220 = param_1;
if (local_230 != 0) {
strncpy(local_218,(char *)(param_1[3] + 0x97),0x1ff);
local_19 = 0;
}
local_22c = 0;
while (((local_22c < 10 && (iVar2 = (*(code *)*local_220)(local_220,local_238), -1 < iVar2)) &&
(iVar2 = (*(code *)local_220[1])(local_220,0,0), iVar2 == 0))) {
local_22c = local_22c + 1;
}
if (local_230 != 0) {
lVar1 = local_220[3];
strncpy((char *)(lVar1 + 0x97),local_218,0x1ff);
*(int1 *)(lVar1 + 0x296) = 0;
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return 0;
}
|
|
60,075
|
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);
}
|
O0
|
c
|
mysql_stmt_attr_get:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x283b8
jmp 0x2833b
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x283ca
jmp 0x28349
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x283db
jmp 0x28357
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0x283ef
jmp 0x28367
movl -0x24(%rbp), %eax
subl $0xc9, %eax
je 0x28401
jmp 0x28377
movl -0x24(%rbp), %eax
subl $0xca, %eax
je 0x28413
jmp 0x28387
movl -0x24(%rbp), %eax
subl $0xcb, %eax
je 0x283a6
jmp 0x28393
movl -0x24(%rbp), %eax
subl $0xcc, %eax
je 0x28427
jmp 0x2843b
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movb 0x313(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movl 0x378(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movl 0x368(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movq 0x370(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28441
movq -0x10(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28441
movb $0x1, -0x1(%rbp)
jmp 0x28445
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_attr_get:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
test eax, eax
jz short loc_283B8
jmp short $+2
loc_2833B:
mov eax, [rbp+var_24]
sub eax, 1
jz loc_283CA
jmp short $+2
loc_28349:
mov eax, [rbp+var_24]
sub eax, 2
jz loc_283DB
jmp short $+2
loc_28357:
mov eax, [rbp+var_24]
sub eax, 0C8h
jz loc_283EF
jmp short $+2
loc_28367:
mov eax, [rbp+var_24]
sub eax, 0C9h
jz loc_28401
jmp short $+2
loc_28377:
mov eax, [rbp+var_24]
sub eax, 0CAh
jz loc_28413
jmp short $+2
loc_28387:
mov eax, [rbp+var_24]
sub eax, 0CBh
jz short loc_283A6
jmp short $+2
loc_28393:
mov eax, [rbp+var_24]
sub eax, 0CCh
jz loc_28427
jmp loc_2843B
loc_283A6:
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp loc_28441
loc_283B8:
mov rax, [rbp+var_10]
mov cl, [rax+313h]
mov rax, [rbp+var_20]
mov [rax], cl
jmp short loc_28441
loc_283CA:
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28441
loc_283DB:
mov rax, [rbp+var_10]
mov rcx, [rax+318h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28441
loc_283EF:
mov rax, [rbp+var_10]
mov ecx, [rax+378h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_28441
loc_28401:
mov rax, [rbp+var_10]
mov ecx, [rax+368h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_28441
loc_28413:
mov rax, [rbp+var_10]
mov rcx, [rax+370h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28441
loc_28427:
mov rax, [rbp+var_10]
mov rcx, [rax+380h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28441
loc_2843B:
mov [rbp+var_1], 1
jmp short loc_28445
loc_28441:
mov [rbp+var_1], 0
loc_28445:
mov al, [rbp+var_1]
pop rbp
retn
|
char mysql_stmt_attr_get(long long a1, int a2, _BYTE *a3)
{
switch ( a2 )
{
case 0:
*a3 = *(_BYTE *)(a1 + 787);
return 0;
case 1:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 72);
return 0;
case 2:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 792);
return 0;
case 200:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 888);
return 0;
case 201:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 872);
return 0;
case 202:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 880);
return 0;
case 203:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 80);
return 0;
case 204:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 896);
return 0;
}
return 1;
}
|
mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
TEST EAX,EAX
JZ 0x001283b8
JMP 0x0012833b
LAB_0012833b:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
JZ 0x001283ca
JMP 0x00128349
LAB_00128349:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x001283db
JMP 0x00128357
LAB_00128357:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
JZ 0x001283ef
JMP 0x00128367
LAB_00128367:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc9
JZ 0x00128401
JMP 0x00128377
LAB_00128377:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xca
JZ 0x00128413
JMP 0x00128387
LAB_00128387:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcb
JZ 0x001283a6
JMP 0x00128393
LAB_00128393:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcc
JZ 0x00128427
JMP 0x0012843b
LAB_001283a6:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128441
LAB_001283b8:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x313]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
JMP 0x00128441
LAB_001283ca:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128441
LAB_001283db:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x318]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128441
LAB_001283ef:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128441
LAB_00128401:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x368]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128441
LAB_00128413:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x370]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128441
LAB_00128427:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128441
LAB_0012843b:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00128445
LAB_00128441:
MOV byte ptr [RBP + -0x1],0x0
LAB_00128445:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
if (param_2 == 0) {
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
}
else if (param_2 == 1) {
*param_3 = *(int8 *)(param_1 + 0x48);
}
else if (param_2 == 2) {
*param_3 = *(int8 *)(param_1 + 0x318);
}
else if (param_2 == 200) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x378);
}
else if (param_2 == 0xc9) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x368);
}
else if (param_2 == 0xca) {
*param_3 = *(int8 *)(param_1 + 0x370);
}
else if (param_2 == 0xcb) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x50);
}
else {
if (param_2 != 0xcc) {
return 1;
}
*param_3 = *(int8 *)(param_1 + 0x380);
}
return 0;
}
|
|
60,076
|
reset_events_waits_history_long()
|
eloqsql/storage/perfschema/pfs_events_waits.cc
|
void reset_events_waits_history_long(void)
{
PFS_atomic::store_u32(&events_waits_history_long_index.m_u32, 0);
events_waits_history_long_full= false;
PFS_events_waits *wait= events_waits_history_long_array;
PFS_events_waits *wait_last= wait + events_waits_history_long_size;
for ( ; wait < wait_last; wait++)
wait->m_wait_class= NO_WAIT_CLASS;
}
|
O0
|
cpp
|
reset_events_waits_history_long():
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3b8c41(%rip), %rdi # 0x411040
xorl %esi, %esi
callq 0x32120
movb $0x0, 0x3b8bf3(%rip) # 0x411000
movq 0x3b8c6c(%rip), %rax # 0x411080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
imulq $0xb0, 0x3b8a59(%rip), %rcx # 0x410e80
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x58453
movq -0x8(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x8(%rbp)
jmp 0x5842e
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
_Z31reset_events_waits_history_longv:
push rbp
mov rbp, rsp
sub rsp, 10h
lea rdi, events_waits_history_long_index; this
xor esi, esi; unsigned int *
call _ZN10PFS_atomic9store_u32EPjj; PFS_atomic::store_u32(uint *,uint)
mov cs:events_waits_history_long_full, 0
mov rax, cs:events_waits_history_long_array
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
imul rcx, cs:events_waits_history_long_size, 0B0h
add rax, rcx
mov [rbp+var_10], rax
loc_5842E:
mov rax, [rbp+var_8]
cmp rax, [rbp+var_10]
jnb short loc_58453
mov rax, [rbp+var_8]
mov dword ptr [rax+58h], 0
mov rax, [rbp+var_8]
add rax, 0B0h
mov [rbp+var_8], rax
jmp short loc_5842E
loc_58453:
add rsp, 10h
pop rbp
retn
|
char *reset_events_waits_history_long(void)
{
char *result; // rax
char *v1; // [rsp+0h] [rbp-10h]
char *v2; // [rsp+8h] [rbp-8h]
PFS_atomic::store_u32((PFS_atomic *)&events_waits_history_long_index, 0LL);
events_waits_history_long_full = 0;
v2 = (char *)events_waits_history_long_array;
v1 = (char *)events_waits_history_long_array + 176 * events_waits_history_long_size;
while ( 1 )
{
result = v2;
if ( v2 >= v1 )
break;
*((_DWORD *)v2 + 22) = 0;
v2 += 176;
}
return result;
}
|
reset_events_waits_history_long:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
LEA RDI,[0x511040]
XOR ESI,ESI
CALL 0x00132120
MOV byte ptr [0x00511000],0x0
MOV RAX,qword ptr [0x00511080]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
IMUL RCX,qword ptr [0x00510e80],0xb0
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
LAB_0015842e:
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00158453
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x58],0x0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0xb0
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0015842e
LAB_00158453:
ADD RSP,0x10
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* reset_events_waits_history_long() */
void reset_events_waits_history_long(void)
{
ulong uVar1;
ulong local_10;
PFS_atomic::store_u32((uint *)events_waits_history_long_index,0);
events_waits_history_long_full = 0;
uVar1 = events_waits_history_long_array + events_waits_history_long_size * 0xb0;
for (local_10 = events_waits_history_long_array; local_10 < uVar1; local_10 = local_10 + 0xb0) {
*(int4 *)(local_10 + 0x58) = 0;
}
return;
}
|
|
60,077
|
mysql_stmt_fetch_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_fetch_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_fetch,
(parms->stmt),
parms->stmt->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_stmt_fetch_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x38(%rdi), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rbx
callq 0x2086f
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_fetch_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+38h]
mov rax, [rax+480h]
mov rbx, [rax+28h]
call mysql_stmt_fetch
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_fetch_start_internal(long long *a1)
{
long long v1; // rdi
_DWORD *v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(v1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_fetch(v1);
v2[2] = result;
*v2 = 0;
return result;
}
|
mysql_stmt_fetch_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0012086f
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_fetch_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_fetch();
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
60,078
|
sp_get_geometry_mbr
|
eloqsql/storage/maria/ma_sp_key.c
|
static int sp_get_geometry_mbr(uchar *(*wkb), uchar *end, uint n_dims,
double *mbr, int top)
{
int res;
uchar byte_order;
uint wkb_type;
byte_order = *(*wkb);
++(*wkb);
wkb_type = uint4korr((*wkb));
(*wkb) += 4;
switch ((enum wkbType) wkb_type)
{
case wkbPoint:
res = sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbLineString:
res = sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbPolygon:
res = sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr);
break;
case wkbMultiPoint:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_point_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiLineString:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_linestring_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbMultiPolygon:
{
uint n_items;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
byte_order = *(*wkb);
++(*wkb);
(*wkb) += 4;
if (sp_get_polygon_mbr(wkb, end, n_dims, byte_order, mbr))
return -1;
}
res = 0;
break;
}
case wkbGeometryCollection:
{
uint n_items;
if (!top)
return -1;
n_items = uint4korr((*wkb));
(*wkb) += 4;
for (; n_items > 0; --n_items)
{
if (sp_get_geometry_mbr(wkb, end, n_dims, mbr, 0))
return -1;
}
res = 0;
break;
}
default:
res = -1;
}
return res;
}
|
O0
|
c
|
sp_get_geometry_mbr:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
incq %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0x38(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0x6, %eax
ja 0x87b37
movq -0x50(%rbp), %rax
leaq 0xddd43(%rip), %rcx # 0x165600
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87b50
movl %eax, -0x30(%rbp)
jmp 0x87b3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87b90
movl %eax, -0x30(%rbp)
jmp 0x87b3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87c20
movl %eax, -0x30(%rbp)
jmp 0x87b3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x3c(%rbp)
jbe 0x879ac
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87b50
cmpl $0x0, %eax
je 0x8799f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x87b44
jmp 0x879a1
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x87946
movl $0x0, -0x30(%rbp)
jmp 0x87b3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x40(%rbp)
jbe 0x87a38
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87b90
cmpl $0x0, %eax
je 0x87a2b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x87b44
jmp 0x87a2d
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x879d2
movl $0x0, -0x30(%rbp)
jmp 0x87b3e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x44(%rbp)
jbe 0x87ac4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movb -0x31(%rbp), %al
movq -0x28(%rbp), %r8
movzbl %al, %ecx
callq 0x87c20
cmpl $0x0, %eax
je 0x87ab7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x87b44
jmp 0x87ab9
movl -0x44(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x87a5e
movl $0x0, -0x30(%rbp)
jmp 0x87b3e
cmpl $0x0, -0x2c(%rbp)
jne 0x87adc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x87b44
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
cmpl $0x0, -0x48(%rbp)
jbe 0x87b2e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
xorl %r8d, %r8d
callq 0x87850
cmpl $0x0, %eax
je 0x87b21
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x87b44
jmp 0x87b23
movl -0x48(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x87af6
movl $0x0, -0x30(%rbp)
jmp 0x87b3e
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
|
sp_get_geometry_mbr:
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
mov [rbp+var_2C], r8d
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
inc rcx
mov [rax], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_38], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov eax, [rbp+var_38]
dec eax; switch 7 cases
mov ecx, eax
mov [rbp+var_50], rcx
sub eax, 6
ja def_878C4; jumptable 00000000000878C4 default case
mov rax, [rbp+var_50]
lea rcx, jpt_878C4
movsxd rax, ds:(jpt_878C4 - 165600h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_878C6:
mov rdi, [rbp+var_10]; jumptable 00000000000878C4 case 1
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_point_mbr
mov [rbp+var_30], eax
jmp loc_87B3E
loc_878E8:
mov rdi, [rbp+var_10]; jumptable 00000000000878C4 case 2
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_linestring_mbr
mov [rbp+var_30], eax
jmp loc_87B3E
loc_8790A:
mov rdi, [rbp+var_10]; jumptable 00000000000878C4 case 3
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_polygon_mbr
mov [rbp+var_30], eax
jmp loc_87B3E
loc_8792C:
mov rax, [rbp+var_10]; jumptable 00000000000878C4 case 4
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_3C], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_87946:
cmp [rbp+var_3C], 0
jbe short loc_879AC
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_point_mbr
cmp eax, 0
jz short loc_8799F
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_87B44
loc_8799F:
jmp short $+2
loc_879A1:
mov eax, [rbp+var_3C]
add eax, 0FFFFFFFFh
mov [rbp+var_3C], eax
jmp short loc_87946
loc_879AC:
mov [rbp+var_30], 0
jmp loc_87B3E
loc_879B8:
mov rax, [rbp+var_10]; jumptable 00000000000878C4 case 5
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_40], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_879D2:
cmp [rbp+var_40], 0
jbe short loc_87A38
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_linestring_mbr
cmp eax, 0
jz short loc_87A2B
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_87B44
loc_87A2B:
jmp short $+2
loc_87A2D:
mov eax, [rbp+var_40]
add eax, 0FFFFFFFFh
mov [rbp+var_40], eax
jmp short loc_879D2
loc_87A38:
mov [rbp+var_30], 0
jmp loc_87B3E
loc_87A44:
mov rax, [rbp+var_10]; jumptable 00000000000878C4 case 6
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_44], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_87A5E:
cmp [rbp+var_44], 0
jbe short loc_87AC4
mov rax, [rbp+var_10]
mov rax, [rax]
mov al, [rax]
mov [rbp+var_31], al
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov al, [rbp+var_31]
mov r8, [rbp+var_28]
movzx ecx, al
call sp_get_polygon_mbr
cmp eax, 0
jz short loc_87AB7
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_87B44
loc_87AB7:
jmp short $+2
loc_87AB9:
mov eax, [rbp+var_44]
add eax, 0FFFFFFFFh
mov [rbp+var_44], eax
jmp short loc_87A5E
loc_87AC4:
mov [rbp+var_30], 0
jmp short loc_87B3E
loc_87ACD:
cmp [rbp+var_2C], 0; jumptable 00000000000878C4 case 7
jnz short loc_87ADC
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_87B44
loc_87ADC:
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_48], eax
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
loc_87AF6:
cmp [rbp+var_48], 0
jbe short loc_87B2E
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
xor r8d, r8d
call sp_get_geometry_mbr
cmp eax, 0
jz short loc_87B21
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_87B44
loc_87B21:
jmp short $+2
loc_87B23:
mov eax, [rbp+var_48]
add eax, 0FFFFFFFFh
mov [rbp+var_48], eax
jmp short loc_87AF6
loc_87B2E:
mov [rbp+var_30], 0
jmp short loc_87B3E
def_878C4:
mov [rbp+var_30], 0FFFFFFFFh; jumptable 00000000000878C4 default case
loc_87B3E:
mov eax, [rbp+var_30]
mov [rbp+var_4], eax
loc_87B44:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long sp_get_geometry_mbr(unsigned __int8 **a1, long long a2, unsigned int a3, long long a4, int a5)
{
int v6; // [rsp+8h] [rbp-48h]
int v7; // [rsp+Ch] [rbp-44h]
int v8; // [rsp+10h] [rbp-40h]
int v9; // [rsp+14h] [rbp-3Ch]
int v10; // [rsp+18h] [rbp-38h]
unsigned __int8 v11; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v12; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v13; // [rsp+1Fh] [rbp-31h]
unsigned __int8 v14; // [rsp+1Fh] [rbp-31h]
v11 = *(*a1)++;
v10 = *(_DWORD *)*a1;
*a1 += 4;
switch ( v10 )
{
case 1:
return (unsigned int)sp_get_point_mbr(a1, a2, a3, v11, a4);
case 2:
return (unsigned int)sp_get_linestring_mbr(a1, a2, a3, v11, a4);
case 3:
return (unsigned int)sp_get_polygon_mbr(a1, a2, a3, v11, a4);
case 4:
v9 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v9 )
return 0;
v12 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_point_mbr(a1, a2, a3, v12, a4) )
{
--v9;
continue;
}
return (unsigned int)-1;
}
case 5:
v8 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v8 )
return 0;
v13 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_linestring_mbr(a1, a2, a3, v13, a4) )
{
--v8;
continue;
}
return (unsigned int)-1;
}
case 6:
v7 = *(_DWORD *)*a1;
*a1 += 4;
while ( 2 )
{
if ( !v7 )
return 0;
v14 = *(*a1)++;
*a1 += 4;
if ( !(unsigned int)sp_get_polygon_mbr(a1, a2, a3, v14, a4) )
{
--v7;
continue;
}
break;
}
return (unsigned int)-1;
case 7:
if ( !a5 )
return (unsigned int)-1;
v6 = *(_DWORD *)*a1;
*a1 += 4;
break;
default:
return (unsigned int)-1;
}
while ( v6 )
{
if ( (unsigned int)sp_get_geometry_mbr(a1, a2, a3, a4, 0LL) )
return (unsigned int)-1;
--v6;
}
return 0;
}
|
sp_get_geometry_mbr:
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
MOV dword ptr [RBP + -0x2c],R8D
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
INC RCX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x38]
DEC EAX
MOV ECX,EAX
MOV qword ptr [RBP + -0x50],RCX
SUB EAX,0x6
JA 0x00187b37
MOV RAX,qword ptr [RBP + -0x50]
LEA RCX,[0x265600]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187b50
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00187b3e
caseD_2:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187b90
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00187b3e
caseD_3:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187c20
MOV dword ptr [RBP + -0x30],EAX
JMP 0x00187b3e
caseD_4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_00187946:
CMP dword ptr [RBP + -0x3c],0x0
JBE 0x001879ac
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187b50
CMP EAX,0x0
JZ 0x0018799f
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00187b44
LAB_0018799f:
JMP 0x001879a1
LAB_001879a1:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00187946
LAB_001879ac:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00187b3e
caseD_5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_001879d2:
CMP dword ptr [RBP + -0x40],0x0
JBE 0x00187a38
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187b90
CMP EAX,0x0
JZ 0x00187a2b
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00187b44
LAB_00187a2b:
JMP 0x00187a2d
LAB_00187a2d:
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x40],EAX
JMP 0x001879d2
LAB_00187a38:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00187b3e
caseD_6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_00187a5e:
CMP dword ptr [RBP + -0x44],0x0
JBE 0x00187ac4
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV AL,byte ptr [RBP + -0x31]
MOV R8,qword ptr [RBP + -0x28]
MOVZX ECX,AL
CALL 0x00187c20
CMP EAX,0x0
JZ 0x00187ab7
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00187b44
LAB_00187ab7:
JMP 0x00187ab9
LAB_00187ab9:
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x00187a5e
LAB_00187ac4:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00187b3e
caseD_7:
CMP dword ptr [RBP + -0x2c],0x0
JNZ 0x00187adc
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00187b44
LAB_00187adc:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x48],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
LAB_00187af6:
CMP dword ptr [RBP + -0x48],0x0
JBE 0x00187b2e
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
XOR R8D,R8D
CALL 0x00187850
CMP EAX,0x0
JZ 0x00187b21
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00187b44
LAB_00187b21:
JMP 0x00187b23
LAB_00187b23:
MOV EAX,dword ptr [RBP + -0x48]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x48],EAX
JMP 0x00187af6
LAB_00187b2e:
MOV dword ptr [RBP + -0x30],0x0
JMP 0x00187b3e
default:
MOV dword ptr [RBP + -0x30],0xffffffff
LAB_00187b3e:
MOV EAX,dword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x4],EAX
LAB_00187b44:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
sp_get_geometry_mbr(long *param_1,int8 param_2,int4 param_3,int8 param_4,
int param_5)
{
int1 uVar1;
int4 uVar2;
int iVar3;
int local_50;
int local_4c;
int local_48;
int local_44;
int4 local_38;
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
uVar2 = *(int4 *)*param_1;
*param_1 = *param_1 + 4;
switch(uVar2) {
case 1:
local_38 = sp_get_point_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 2:
local_38 = sp_get_linestring_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 3:
local_38 = sp_get_polygon_mbr(param_1,param_2,param_3,uVar1,param_4);
break;
case 4:
local_44 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_44 != 0; local_44 = local_44 + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_point_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 5:
local_48 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_48 != 0; local_48 = local_48 + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_linestring_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 6:
local_4c = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_4c != 0; local_4c = local_4c + -1) {
uVar1 = *(int1 *)*param_1;
*param_1 = *param_1 + 1;
*param_1 = *param_1 + 4;
iVar3 = sp_get_polygon_mbr(param_1,param_2,param_3,uVar1,param_4);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
case 7:
if (param_5 == 0) {
return 0xffffffff;
}
local_50 = *(int *)*param_1;
*param_1 = *param_1 + 4;
for (; local_50 != 0; local_50 = local_50 + -1) {
iVar3 = sp_get_geometry_mbr(param_1,param_2,param_3,param_4,0);
if (iVar3 != 0) {
return 0xffffffff;
}
}
local_38 = 0;
break;
default:
local_38 = 0xffffffff;
}
return local_38;
}
|
|
60,079
|
minja::Value::at(minja::Value const&)
|
monkey531[P]llama/common/minja.hpp
|
Value& at(const Value & index) {
if (!index.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
if (is_array()) return array_->at(index.get<int>());
if (is_object()) return object_->at(index.primitive_);
throw std::runtime_error("Value is not an array or object: " + dump());
}
|
O3
|
cpp
|
minja::Value::at(minja::Value const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
jne 0x672f1
cmpq $0x0, 0x20(%rsi)
jne 0x672f1
cmpq $0x0, 0x30(%rsi)
jne 0x672f1
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x672d7
movq %rsi, %rdi
callq 0x648b0
movslq %eax, %rsi
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x6734e
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x6735c
addq $0x40, %rsi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x68810
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x50cd0
leaq 0x55359(%rip), %rsi # 0xbc670
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x4320d
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x19c80
xorl %ebp, %ebp
movq 0x89cb3(%rip), %rsi # 0xf0ff0
movq 0x89c2c(%rip), %rdx # 0xf0f70
movq %rbx, %rdi
callq 0x19d60
jmp 0x673b7
leaq 0x51444(%rip), %rdi # 0xb8799
xorl %eax, %eax
callq 0x19ba0
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x50cd0
leaq 0x5543a(%rip), %rsi # 0xbc7bc
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x4320d
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x19c80
xorl %ebp, %ebp
movq 0x89c48(%rip), %rsi # 0xf0ff0
movq 0x89bc1(%rip), %rdx # 0xf0f70
movq %rbx, %rdi
callq 0x19d60
jmp 0x673bd
jmp 0x673fd
jmp 0x6741d
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x673db
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x197f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x673f6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x197f0
testb %bpl, %bpl
jne 0x67420
jmp 0x67428
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67420
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x197f0
jmp 0x67420
movq %rax, %r14
movq %rbx, %rdi
callq 0x195a0
movq %r14, %rdi
callq 0x19dc0
|
_ZN5minja5Value2atERKS0_:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rsi+10h], 0
jnz short loc_672F1
cmp qword ptr [rsi+20h], 0
jnz short loc_672F1
cmp qword ptr [rsi+30h], 0
jnz short loc_672F1
mov rbx, [r14+10h]
test rbx, rbx
jz short loc_672D7
mov rdi, rsi
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
movsxd rsi, eax
mov rax, [rbx]
mov rcx, [rbx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe loc_6734E
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_672D7:
mov rdi, [r14+20h]
test rdi, rdi
jz short loc_6735C
add rsi, 40h ; '@'
add rsp, 40h
pop rbx
pop r14
pop rbp
jmp _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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::allocator<std::pair<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,minja::Value>>>::at(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&)
loc_672F1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
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:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_673B7
loc_6734E:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_6735C:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
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:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_673B7:
jmp short loc_673BD
jmp short loc_673FD
jmp short loc_6741D
loc_673BD:
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_673DB
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_673DB:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_673F6
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_673F6:
test bpl, bpl
jnz short loc_67420
jmp short loc_67428
loc_673FD:
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_67420
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_67420
loc_6741D:
mov r14, rax
loc_67420:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_67428:
mov rdi, r14
call __Unwind_Resume
|
unsigned long long minja::Value::at(minja::Value *this, const minja::Value *a2)
{
_QWORD *v3; // rbx
unsigned long long v4; // rsi
unsigned long long v5; // rdx
long long v7; // rdi
void *exception; // rbx
void *v9; // rbx
_BYTE v10[16]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+20h] [rbp-38h] BYREF
if ( *((_QWORD *)a2 + 2) || *((_QWORD *)a2 + 4) || *((_QWORD *)a2 + 6) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Unashable type: ", (long long)v10);
std::runtime_error::runtime_error(exception, v11);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3 = (_QWORD *)*((_QWORD *)this + 2);
if ( v3 )
{
v4 = (int)minja::Value::get<int>(a2);
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= v4 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", v4, v5);
return 80 * v4 + *v3;
}
else
{
v7 = *((_QWORD *)this + 4);
if ( !v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v9, v11);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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::allocator<std::pair<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,minja::Value>>>::at(
v7,
(char *)a2 + 64);
}
}
|
at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001672f1
CMP qword ptr [RSI + 0x20],0x0
JNZ 0x001672f1
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001672f1
MOV RBX,qword ptr [R14 + 0x10]
TEST RBX,RBX
JZ 0x001672d7
MOV RDI,RSI
CALL 0x001648b0
MOVSXD RSI,EAX
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x0016734e
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_001672d7:
MOV RDI,qword ptr [R14 + 0x20]
TEST RDI,RDI
JZ 0x0016735c
ADD RSI,0x40
ADD RSP,0x40
POP RBX
POP R14
POP RBP
JMP 0x00168810
LAB_001672f1:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_001672fe:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00150cd0
LAB_00167310:
LEA RSI,[0x1bc670]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0014320d
MOV BPL,0x1
LAB_00167327:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00119c80
XOR EBP,EBP
MOV RSI,qword ptr [0x001f0ff0]
MOV RDX,qword ptr [0x001f0f70]
MOV RDI,RBX
CALL 0x00119d60
LAB_0016734e:
LEA RDI,[0x1b8799]
XOR EAX,EAX
CALL 0x00119ba0
LAB_0016735c:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_00167369:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x00150cd0
LAB_0016737b:
LEA RSI,[0x1bc7bc]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0014320d
MOV BPL,0x1
LAB_00167392:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00119c80
XOR EBP,EBP
MOV RSI,qword ptr [0x001f0ff0]
MOV RDX,qword ptr [0x001f0f70]
MOV RDI,RBX
CALL 0x00119d60
|
/* minja::Value::at(minja::Value const&) */
long __thiscall minja::Value::at(Value *this,Value *param_1)
{
long *plVar1;
int iVar2;
long lVar3;
runtime_error *prVar4;
ulong uVar5;
ulong uVar6;
int1 auStack_58 [32];
string local_38 [32];
if (((*(long *)(param_1 + 0x10) != 0) || (*(long *)(param_1 + 0x20) != 0)) ||
(*(long *)(param_1 + 0x30) != 0)) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001672fe to 0016730f has its CatchHandler @ 0016741d */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 00167310 to 00167323 has its CatchHandler @ 001673fd */
std::operator+((char *)local_38,(string *)"Unashable type: ");
/* try { // try from 00167327 to 0016734b has its CatchHandler @ 001673bd */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001f0ff0,PTR__runtime_error_001f0f70);
}
plVar1 = *(long **)(this + 0x10);
if (plVar1 == (long *)0x0) {
if (*(ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
**)(this + 0x20) !=
(ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
*)0x0) {
lVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
::at(*(ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
**)(this + 0x20),(basic_json *)(param_1 + 0x40));
return lVar3;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00167369 to 0016737a has its CatchHandler @ 001673bb */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 0016737b to 0016738e has its CatchHandler @ 001673b9 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 00167392 to 001673b6 has its CatchHandler @ 001673b7 */
std::runtime_error::runtime_error(prVar4,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001f0ff0,PTR__runtime_error_001f0f70);
}
iVar2 = get<int>(param_1);
uVar6 = (ulong)iVar2;
uVar5 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar6 <= uVar5 && uVar5 - uVar6 != 0) {
return *plVar1 + uVar6 * 0x50;
}
/* WARNING: Subroutine does not return */
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
}
|
|
60,080
|
list_free
|
eloqsql/libmariadb/libmariadb/ma_list.c
|
void list_free(LIST *root, unsigned int free_data)
{
LIST *next;
while (root)
{
next=root->next;
if (free_data)
free(root->data);
free(root);
root=next;
}
}
|
O0
|
c
|
list_free:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x27a08
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x279f5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13520
movq -0x8(%rbp), %rdi
callq 0x13520
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x279cf
addq $0x20, %rsp
popq %rbp
retq
nop
|
list_free:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
loc_279CF:
cmp [rbp+var_8], 0
jz short loc_27A08
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
cmp [rbp+var_C], 0
jz short loc_279F5
mov rax, [rbp+var_8]
mov rdi, [rax+10h]
call _free
loc_279F5:
mov rdi, [rbp+var_8]
call _free
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
jmp short loc_279CF
loc_27A08:
add rsp, 20h
pop rbp
retn
|
long long list_free(long long a1, int a2)
{
long long result; // rax
long long v3; // [rsp+8h] [rbp-18h]
while ( a1 )
{
v3 = *(_QWORD *)(a1 + 8);
if ( a2 )
free(*(_QWORD *)(a1 + 16));
free(a1);
result = v3;
a1 = v3;
}
return result;
}
|
list_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
LAB_001279cf:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x00127a08
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
CMP dword ptr [RBP + -0xc],0x0
JZ 0x001279f5
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00113520
LAB_001279f5:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00113520
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001279cf
LAB_00127a08:
ADD RSP,0x20
POP RBP
RET
|
void list_free(void *param_1,int param_2)
{
void *pvVar1;
int8 local_10;
local_10 = param_1;
while (local_10 != (void *)0x0) {
pvVar1 = *(void **)((long)local_10 + 8);
if (param_2 != 0) {
free(*(void **)((long)local_10 + 0x10));
}
free(local_10);
local_10 = pvVar1;
}
return;
}
|
|
60,081
|
nlohmann::json_abi_v3_11_3::ordered_map<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>, minja::Value, std::less<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::allocator<std::pair<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> const, minja::Value>>>::count(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> const&) const
|
monkey531[P]llama/common/json.hpp
|
size_type count(const key_type& key) const
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return 1;
}
}
return 0;
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<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>, minja::Value, std::less<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::allocator<std::pair<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> const, minja::Value>>>::count(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> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq %rcx, %r15
movq 0x8(%r14), %r12
cmpq %r12, %rcx
je 0x6a5a8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x48cc8
leaq 0x60(%r15), %rcx
testb %al, %al
je 0x6a589
xorl %eax, %eax
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZNK8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE5countERSJ_:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
mov rcx, [rdi]
loc_6A589:
mov r15, rcx
mov r12, [r14+8]
cmp rcx, r12
jz short loc_6A5A8
mov rdi, r15
mov rsi, rbx
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&)
lea rcx, [r15+60h]
test al, al
jz short loc_6A589
loc_6A5A8:
xor eax, eax
cmp r15, r12
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
_BOOL8 nlohmann::json_abi_v3_11_3::ordered_map<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>,minja::Value,std::less<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::allocator<std::pair<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,minja::Value>>>::count(
unsigned __int8 **a1,
unsigned __int8 *a2,
__m128d a3)
{
unsigned __int8 *v3; // rcx
unsigned __int8 *v4; // r15
unsigned __int8 *v5; // r12
char v6; // al
v3 = *a1;
do
{
v4 = v3;
v5 = a1[1];
if ( v3 == v5 )
break;
v6 = nlohmann::json_abi_v3_11_3::operator==(v3, a2, a3);
v3 = v4 + 96;
}
while ( !v6 );
return v4 != v5;
}
|
count:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RCX,qword ptr [RDI]
LAB_0016a589:
MOV R15,RCX
MOV R12,qword ptr [R14 + 0x8]
CMP RCX,R12
JZ 0x0016a5a8
MOV RDI,R15
MOV RSI,RBX
CALL 0x00148cc8
LEA RCX,[R15 + 0x60]
TEST AL,AL
JZ 0x0016a589
LAB_0016a5a8:
XOR EAX,EAX
CMP R15,R12
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<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>, minja::Value,
std::less<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<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, minja::Value> >
>::count(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&) const */
bool __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
::count(ordered_map<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>,minja::Value,std::less<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<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,minja::Value>>>
*this,basic_json *param_1)
{
basic_json *pbVar1;
basic_json *pbVar2;
char cVar3;
basic_json *pbVar4;
pbVar2 = *(basic_json **)this;
do {
pbVar4 = pbVar2;
pbVar1 = *(basic_json **)(this + 8);
if (pbVar4 == pbVar1) break;
cVar3 = operator==(pbVar4,param_1);
pbVar2 = pbVar4 + 0x60;
} while (cVar3 == '\0');
return pbVar4 != pbVar1;
}
|
|
60,082
|
emit_push_const
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int emit_push_const(JSParseState *s, JSValue val,
BOOL as_atom)
{
int idx;
if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING && as_atom) {
JSAtom atom;
/* warning: JS_NewAtomStr frees the string value */
JS_DupValue(s->ctx, val);
atom = JS_NewAtomStr(s->ctx, JS_VALUE_GET_STRING(val));
if (atom != JS_ATOM_NULL && !__JS_AtomIsTaggedInt(atom)) {
emit_op(s, OP_push_atom_value);
emit_u32(s, atom);
return 0;
}
}
idx = cpool_add(s, JS_DupValue(s->ctx, val));
if (idx < 0)
return -1;
emit_op(s, OP_push_const);
emit_u32(s, idx);
return 0;
}
|
O1
|
c
|
emit_push_const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
cmpl $-0x7, %r14d
setne %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x68560
incl (%r15)
movq (%rbx), %rdi
movq 0x10(%rsp), %rsi
callq 0x20038
testl %eax, %eax
jle 0x68560
movl %eax, %ebp
movq 0x90(%rbx), %rax
movl $0x138, %r14d # imm = 0x138
leaq (%rax,%r14), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0x4, %esi
jmp 0x685a8
movq %r15, 0x8(%rsp)
cmpl $-0x9, %r14d
jb 0x68572
movq 0x8(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6513b
testl %eax, %eax
js 0x685cc
movl %eax, %ebp
movq 0x90(%rbx), %rax
movl $0x138, %r14d # imm = 0x138
leaq (%rax,%r14), %rdi
movl 0x140(%rax), %ecx
movl %ecx, 0x168(%rax)
movl $0x2, %esi
callq 0x1b4d0
addq 0x90(%rbx), %r14
leaq 0x8(%rsp), %rsi
movl %ebp, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x1b422
xorl %eax, %eax
jmp 0x685d1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
emit_push_const:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov [rsp+38h+var_28], rsi
cmp r14d, 0FFFFFFF9h
setnz al
test ecx, ecx
setz cl
or cl, al
jnz short loc_68560
inc dword ptr [r15]
mov rdi, [rbx]
mov rsi, [rsp+38h+var_28]
call JS_NewAtomStr
test eax, eax
jle short loc_68560
mov ebp, eax
mov rax, [rbx+90h]
mov r14d, 138h
lea rdi, [rax+r14]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 4
jmp short loc_685A8
loc_68560:
mov [rsp+38h+var_30], r15
cmp r14d, 0FFFFFFF7h
jb short loc_68572
mov rax, [rsp+38h+var_30]
inc dword ptr [rax]
loc_68572:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call cpool_add
test eax, eax
js short loc_685CC
mov ebp, eax
mov rax, [rbx+90h]
mov r14d, 138h
lea rdi, [rax+r14]
mov ecx, [rax+140h]
mov [rax+168h], ecx
mov esi, 2
loc_685A8:
call dbuf_putc
add r14, [rbx+90h]
lea rsi, [rsp+38h+var_30]
mov [rsi], ebp
mov edx, 4
mov rdi, r14
call dbuf_put
xor eax, eax
jmp short loc_685D1
loc_685CC:
mov eax, 0FFFFFFFFh
loc_685D1:
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long emit_push_const(long long *a1, _DWORD *a2, long long a3, int a4)
{
int v6; // eax
int v7; // ebp
long long v8; // rax
_QWORD *v9; // rdi
char v10; // si
int v11; // eax
long long v12; // rax
_QWORD *v13; // r14
_DWORD *v15; // [rsp+8h] [rbp-30h] BYREF
_DWORD *v16; // [rsp+10h] [rbp-28h]
v16 = a2;
if ( (_DWORD)a3 == -7 && a4 != 0 )
{
++*a2;
v6 = JS_NewAtomStr(*a1, (long long)v16);
if ( v6 > 0 )
{
v7 = v6;
v8 = a1[18];
v9 = (_QWORD *)(v8 + 312);
*(_DWORD *)(v8 + 360) = *(_DWORD *)(v8 + 320);
v10 = 4;
LABEL_8:
dbuf_putc(v9, v10);
v13 = (_QWORD *)(a1[18] + 312);
LODWORD(v15) = v7;
dbuf_put(v13, (long long)&v15, 4LL);
return 0LL;
}
}
v15 = a2;
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*v15;
v11 = cpool_add(a1, (long long)a2, a3);
if ( v11 >= 0 )
{
v7 = v11;
v12 = a1[18];
v9 = (_QWORD *)(v12 + 312);
*(_DWORD *)(v12 + 360) = *(_DWORD *)(v12 + 320);
v10 = 2;
goto LABEL_8;
}
return 0xFFFFFFFFLL;
}
|
emit_push_const:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV qword ptr [RSP + 0x10],RSI
CMP R14D,-0x7
SETNZ AL
TEST ECX,ECX
SETZ CL
OR CL,AL
JNZ 0x00168560
INC dword ptr [R15]
MOV RDI,qword ptr [RBX]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00120038
TEST EAX,EAX
JLE 0x00168560
MOV EBP,EAX
MOV RAX,qword ptr [RBX + 0x90]
MOV R14D,0x138
LEA RDI,[RAX + R14*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0x4
JMP 0x001685a8
LAB_00168560:
MOV qword ptr [RSP + 0x8],R15
CMP R14D,-0x9
JC 0x00168572
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_00168572:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0016513b
TEST EAX,EAX
JS 0x001685cc
MOV EBP,EAX
MOV RAX,qword ptr [RBX + 0x90]
MOV R14D,0x138
LEA RDI,[RAX + R14*0x1]
MOV ECX,dword ptr [RAX + 0x140]
MOV dword ptr [RAX + 0x168],ECX
MOV ESI,0x2
LAB_001685a8:
CALL 0x0011b4d0
ADD R14,qword ptr [RBX + 0x90]
LEA RSI,[RSP + 0x8]
MOV dword ptr [RSI],EBP
MOV EDX,0x4
MOV RDI,R14
CALL 0x0011b422
XOR EAX,EAX
JMP 0x001685d1
LAB_001685cc:
MOV EAX,0xffffffff
LAB_001685d1:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 emit_push_const(int8 *param_1,int *param_2,int8 param_3,int param_4)
{
long lVar1;
int iVar2;
int8 uVar3;
int *local_30;
int *local_28;
local_28 = param_2;
if (param_4 != 0 && (uint)param_3 == 0xfffffff9) {
*param_2 = *param_2 + 1;
iVar2 = JS_NewAtomStr(*param_1,param_2);
if (0 < iVar2) {
lVar1 = param_1[0x12];
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
uVar3 = 4;
goto LAB_001685a8;
}
}
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
local_30 = param_2;
iVar2 = cpool_add(param_1,param_2,param_3);
if (iVar2 < 0) {
return 0xffffffff;
}
lVar1 = param_1[0x12];
*(int4 *)(lVar1 + 0x168) = *(int4 *)(lVar1 + 0x140);
uVar3 = 2;
LAB_001685a8:
dbuf_putc(lVar1 + 0x138,uVar3);
local_30 = (int *)CONCAT44(local_30._4_4_,iVar2);
dbuf_put(param_1[0x12] + 0x138,&local_30,4);
return 0;
}
|
|
60,083
|
emit_push_const
|
bluesky950520[P]quickjs/quickjs.c
|
static __exception int emit_push_const(JSParseState *s, JSValue val,
BOOL as_atom)
{
int idx;
if (JS_VALUE_GET_TAG(val) == JS_TAG_STRING && as_atom) {
JSAtom atom;
/* warning: JS_NewAtomStr frees the string value */
JS_DupValue(s->ctx, val);
atom = JS_NewAtomStr(s->ctx, JS_VALUE_GET_STRING(val));
if (atom != JS_ATOM_NULL && !__JS_AtomIsTaggedInt(atom)) {
emit_op(s, OP_push_atom_value);
emit_u32(s, atom);
return 0;
}
}
idx = cpool_add(s, JS_DupValue(s->ctx, val));
if (idx < 0)
return -1;
emit_op(s, OP_push_const);
emit_u32(s, idx);
return 0;
}
|
O2
|
c
|
emit_push_const:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x7, %r14d
setne %al
testl %ecx, %ecx
sete %cl
orb %al, %cl
jne 0x588ac
incl (%r15)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1a40c
testl %eax, %eax
jle 0x588ac
movl %eax, %ebp
movb $0x4, %al
jmp 0x588cb
cmpl $-0x9, %r14d
jb 0x588b5
incl (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x56369
testl %eax, %eax
js 0x588e4
movl %eax, %ebp
movb $0x2, %al
movzbl %al, %esi
movq %rbx, %rdi
callq 0x4fa1b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x563de
xorl %eax, %eax
jmp 0x588e7
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
emit_push_const:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
cmp r14d, 0FFFFFFF9h
setnz al
test ecx, ecx
setz cl
or cl, al
jnz short loc_588AC
inc dword ptr [r15]
mov rdi, [rbx]
mov rsi, r15
call JS_NewAtomStr
test eax, eax
jle short loc_588AC
mov ebp, eax
mov al, 4
jmp short loc_588CB
loc_588AC:
cmp r14d, 0FFFFFFF7h
jb short loc_588B5
inc dword ptr [r15]
loc_588B5:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call cpool_add
test eax, eax
js short loc_588E4
mov ebp, eax
mov al, 2
loc_588CB:
movzx esi, al
mov rdi, rbx
call emit_op
mov rdi, rbx
mov esi, ebp
call emit_u32
xor eax, eax
jmp short loc_588E7
loc_588E4:
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_588E7:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long emit_push_const(long long *a1, _DWORD *a2, long long a3, int a4)
{
int v5; // eax
unsigned int v6; // ebp
char v7; // al
int v8; // eax
if ( (_DWORD)a3 == -7 && a4 != 0 )
{
++*a2;
v5 = JS_NewAtomStr(*a1, (long long)a2);
if ( v5 > 0 )
{
v6 = v5;
v7 = 4;
LABEL_8:
emit_op((long long)a1, v7);
emit_u32((long long)a1, v6);
return 0LL;
}
}
if ( (unsigned int)a3 >= 0xFFFFFFF7 )
++*a2;
v8 = cpool_add(a1, (long long)a2, a3);
if ( v8 >= 0 )
{
v6 = v8;
v7 = 2;
goto LABEL_8;
}
return -1LL;
}
|
emit_push_const:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CMP R14D,-0x7
SETNZ AL
TEST ECX,ECX
SETZ CL
OR CL,AL
JNZ 0x001588ac
INC dword ptr [R15]
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x0011a40c
TEST EAX,EAX
JLE 0x001588ac
MOV EBP,EAX
MOV AL,0x4
JMP 0x001588cb
LAB_001588ac:
CMP R14D,-0x9
JC 0x001588b5
INC dword ptr [R15]
LAB_001588b5:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00156369
TEST EAX,EAX
JS 0x001588e4
MOV EBP,EAX
MOV AL,0x2
LAB_001588cb:
MOVZX ESI,AL
MOV RDI,RBX
CALL 0x0014fa1b
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001563de
XOR EAX,EAX
JMP 0x001588e7
LAB_001588e4:
PUSH -0x1
POP RAX
LAB_001588e7:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 emit_push_const(int8 *param_1,int *param_2,int8 param_3,int param_4)
{
int1 uVar1;
int iVar2;
if (param_4 != 0 && (uint)param_3 == 0xfffffff9) {
*param_2 = *param_2 + 1;
iVar2 = JS_NewAtomStr(*param_1,param_2);
if (0 < iVar2) {
uVar1 = 4;
goto LAB_001588cb;
}
}
if (0xfffffff6 < (uint)param_3) {
*param_2 = *param_2 + 1;
}
iVar2 = cpool_add(param_1,param_2,param_3);
if (iVar2 < 0) {
return 0xffffffffffffffff;
}
uVar1 = 2;
LAB_001588cb:
emit_op(param_1,uVar1);
emit_u32(param_1,iVar2);
return 0;
}
|
|
60,084
|
Balloc
|
eloqsql/libmariadb/libmariadb/ma_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;
}
|
O0
|
c
|
Balloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xf, -0x4(%rbp)
jg 0x4f7df
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0x4f7df
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x4f864
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq $0x18, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x4f843
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x4f850
movslq -0x20(%rbp), %rdi
callq 0x145c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
Balloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
cmp [rbp+var_4], 0Fh
jg short loc_4F7DF
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
cmp qword ptr [rax+rcx*8+18h], 0
jz short loc_4F7DF
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov rax, [rax+rcx*8+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov [rax+rcx*8+18h], rdx
jmp loc_4F864
loc_4F7DF:
mov ecx, [rbp+var_4]
mov eax, 1
shl eax, cl
mov [rbp+var_1C], eax
movsxd rax, [rbp+var_1C]
shl rax, 2
add rax, 18h
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_20]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_4F843
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_4F850
loc_4F843:
movsxd rdi, [rbp+var_20]
call _malloc
mov [rbp+var_18], rax
loc_4F850:
mov ecx, [rbp+var_4]
mov rax, [rbp+var_18]
mov [rax+8], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov [rax+0Ch], ecx
loc_4F864:
mov rax, [rbp+var_18]
mov dword ptr [rax+14h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+10h], 0
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
|
long long Balloc(int a1, long long a2)
{
signed int v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
if ( a1 <= 15 && *(_QWORD *)(a2 + 8LL * a1 + 24) )
{
v4 = *(_QWORD *)(a2 + 8LL * a1 + 24);
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)v4;
}
else
{
v3 = (4 * (1 << a1) + 31) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
{
v4 = malloc(v3);
}
else
{
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
}
*(_DWORD *)(v4 + 8) = a1;
*(_DWORD *)(v4 + 12) = 1 << a1;
}
*(_DWORD *)(v4 + 20) = 0;
*(_DWORD *)(v4 + 16) = 0;
*(_QWORD *)v4 = v4 + 24;
return v4;
}
|
Balloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
CMP dword ptr [RBP + -0x4],0xf
JG 0x0014f7df
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
CMP qword ptr [RAX + RCX*0x8 + 0x18],0x0
JZ 0x0014f7df
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
JMP 0x0014f864
LAB_0014f7df:
MOV ECX,dword ptr [RBP + -0x4]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x1c],EAX
MOVSXD RAX,dword ptr [RBP + -0x1c]
SHL RAX,0x2
ADD RAX,0x18
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x0014f843
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x0014f850
LAB_0014f843:
MOVSXD RDI,dword ptr [RBP + -0x20]
CALL 0x001145c0
MOV qword ptr [RBP + -0x18],RAX
LAB_0014f850:
MOV ECX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xc],ECX
LAB_0014f864:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int8 * Balloc(int param_1,long param_2)
{
int iVar1;
uint uVar2;
int8 *local_20;
if ((param_1 < 0x10) && (*(long *)(param_2 + 0x18 + (long)param_1 * 8) != 0)) {
local_20 = *(int8 **)(param_2 + 0x18 + (long)param_1 * 8);
*(int8 *)(param_2 + 0x18 + (long)param_1 * 8) = *local_20;
}
else {
iVar1 = 1 << ((byte)param_1 & 0x1f);
uVar2 = iVar1 * 4 + 0x1fU & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar2)) {
local_20 = (int8 *)malloc((long)(int)uVar2);
}
else {
local_20 = *(int8 **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar2;
}
*(int *)(local_20 + 1) = param_1;
*(int *)((long)local_20 + 0xc) = iVar1;
}
*(int4 *)((long)local_20 + 0x14) = 0;
*(int4 *)(local_20 + 2) = 0;
*local_20 = local_20 + 3;
return local_20;
}
|
|
60,085
|
ha_find_null
|
eloqsql/mysys/my_compare.c
|
HA_KEYSEG *ha_find_null(HA_KEYSEG *keyseg, const uchar *a)
{
for (; (enum ha_base_keytype) keyseg->type != HA_KEYTYPE_END; keyseg++)
{
const uchar *end;
if (keyseg->null_bit)
{
if (!*a++)
return keyseg;
}
end= a+ keyseg->length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_TEXT:
case HA_KEYTYPE_BINARY:
case HA_KEYTYPE_BIT:
if (keyseg->flag & HA_SPACE_PACK)
{
int a_length;
get_key_length(a_length, a);
a += a_length;
break;
}
else
a= end;
break;
case HA_KEYTYPE_VARTEXT1:
case HA_KEYTYPE_VARTEXT2:
case HA_KEYTYPE_VARBINARY1:
case HA_KEYTYPE_VARBINARY2:
{
int a_length;
get_key_length(a_length, a);
a+= a_length;
break;
}
case HA_KEYTYPE_NUM:
if (keyseg->flag & HA_SPACE_PACK)
{
int alength= *a++;
end= a+alength;
}
a= end;
break;
case HA_KEYTYPE_INT8:
case HA_KEYTYPE_SHORT_INT:
case HA_KEYTYPE_USHORT_INT:
case HA_KEYTYPE_LONG_INT:
case HA_KEYTYPE_ULONG_INT:
case HA_KEYTYPE_INT24:
case HA_KEYTYPE_UINT24:
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
case HA_KEYTYPE_ULONGLONG:
#endif
case HA_KEYTYPE_FLOAT:
case HA_KEYTYPE_DOUBLE:
a= end;
break;
case HA_KEYTYPE_END: /* purecov: inspected */
/* keep compiler happy */
DBUG_ASSERT(0);
break;
}
}
return keyseg;
}
|
O3
|
c
|
ha_find_null:
movq %rdi, %rax
movb 0x18(%rdi), %dl
testb %dl, %dl
je 0x9f317
pushq %rbp
movq %rsp, %rbp
leaq 0x42b62(%rip), %rcx # 0xe1dfc
cmpb $0x0, 0x19(%rax)
je 0x9f2a8
cmpb $0x0, (%rsi)
je 0x9f316
incq %rsi
movzbl %dl, %edx
decl %edx
cmpl $0x12, %edx
ja 0x9f2f1
movzwl 0x14(%rax), %edi
addq %rsi, %rdi
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
testb $0x1, 0x12(%rax)
je 0x9f2f4
movzbl (%rsi), %edx
cmpq $0xff, %rdx
je 0x9f2db
movl $0x1, %edi
jmp 0x9f2eb
movzwl 0x1(%rsi), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movl $0x3, %edi
addq %rdi, %rsi
addq %rdx, %rsi
movq %rsi, %rdi
movb 0x38(%rax), %dl
addq $0x20, %rax
movq %rdi, %rsi
testb %dl, %dl
jne 0x9f29a
jmp 0x9f316
testb $0x1, 0x12(%rax)
je 0x9f2f4
movzbl (%rsi), %edx
leaq (%rsi,%rdx), %rdi
incq %rdi
jmp 0x9f2f4
popq %rbp
retq
|
ha_find_null:
mov rax, rdi
mov dl, [rdi+18h]
test dl, dl
jz locret_9F317
push rbp
mov rbp, rsp
lea rcx, jpt_9F2C0
loc_9F29A:
cmp byte ptr [rax+19h], 0
jz short loc_9F2A8
cmp byte ptr [rsi], 0
jz short loc_9F316
inc rsi
loc_9F2A8:
movzx edx, dl
dec edx; switch 19 cases
cmp edx, 12h
ja short def_9F2C0; jumptable 000000000009F2C0 default case
movzx edi, word ptr [rax+14h]
add rdi, rsi
movsxd rdx, ds:(jpt_9F2C0 - 0E1DFCh)[rcx+rdx*4]
add rdx, rcx
jmp rdx; switch jump
loc_9F2C2:
test byte ptr [rax+12h], 1; jumptable 000000000009F2C0 cases 1,2,19
jz short loc_9F2F4; jumptable 000000000009F2C0 cases 3-6,8-14
loc_9F2C8:
movzx edx, byte ptr [rsi]; jumptable 000000000009F2C0 cases 15-18
cmp rdx, 0FFh
jz short loc_9F2DB
mov edi, 1
jmp short loc_9F2EB
loc_9F2DB:
movzx edx, word ptr [rsi+1]
rol dx, 8
movzx edx, dx
mov edi, 3
loc_9F2EB:
add rsi, rdi
add rsi, rdx
def_9F2C0:
mov rdi, rsi; jumptable 000000000009F2C0 default case
loc_9F2F4:
mov dl, [rax+38h]; jumptable 000000000009F2C0 cases 3-6,8-14
add rax, 20h ; ' '
mov rsi, rdi
test dl, dl
jnz short loc_9F29A
jmp short loc_9F316
loc_9F304:
test byte ptr [rax+12h], 1; jumptable 000000000009F2C0 case 7
jz short loc_9F2F4; jumptable 000000000009F2C0 cases 3-6,8-14
movzx edx, byte ptr [rsi]
lea rdi, [rsi+rdx]
inc rdi
jmp short loc_9F2F4; jumptable 000000000009F2C0 cases 3-6,8-14
loc_9F316:
pop rbp
locret_9F317:
retn
|
long long ha_find_null(long long a1, unsigned __int8 *a2)
{
long long result; // rax
char i; // dl
long long v4; // rdi
long long v5; // rdx
long long v6; // rdi
result = a1;
for ( i = *(_BYTE *)(a1 + 24); i; a2 = (unsigned __int8 *)v4 )
{
if ( *(_BYTE *)(result + 25) )
{
if ( !*a2 )
return result;
++a2;
}
v4 = (long long)&a2[*(unsigned __int16 *)(result + 20)];
switch ( i )
{
case 1:
case 2:
case 19:
if ( (*(_BYTE *)(result + 18) & 1) != 0 )
goto LABEL_7;
break;
case 3:
case 4:
case 5:
case 6:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
break;
case 7:
if ( (*(_BYTE *)(result + 18) & 1) != 0 )
v4 = (long long)&a2[*a2 + 1];
break;
case 15:
case 16:
case 17:
case 18:
LABEL_7:
v5 = *a2;
if ( v5 == 255 )
{
v5 = (unsigned __int16)__ROL2__(*(_WORD *)(a2 + 1), 8);
v6 = 3LL;
}
else
{
v6 = 1LL;
}
a2 += v5 + v6;
goto LABEL_11;
default:
LABEL_11:
v4 = (long long)a2;
break;
}
i = *(_BYTE *)(result + 56);
result += 32LL;
}
return result;
}
|
ha_find_null:
MOV RAX,RDI
MOV DL,byte ptr [RDI + 0x18]
TEST DL,DL
JZ 0x0019f317
PUSH RBP
MOV RBP,RSP
LEA RCX,[0x1e1dfc]
LAB_0019f29a:
CMP byte ptr [RAX + 0x19],0x0
JZ 0x0019f2a8
CMP byte ptr [RSI],0x0
JZ 0x0019f316
INC RSI
LAB_0019f2a8:
MOVZX EDX,DL
DEC EDX
CMP EDX,0x12
JA 0x0019f2f1
MOVZX EDI,word ptr [RAX + 0x14]
ADD RDI,RSI
MOVSXD RDX,dword ptr [RCX + RDX*0x4]
ADD RDX,RCX
switchD:
JMP RDX
caseD_1:
TEST byte ptr [RAX + 0x12],0x1
JZ 0x0019f2f4
caseD_f:
MOVZX EDX,byte ptr [RSI]
CMP RDX,0xff
JZ 0x0019f2db
MOV EDI,0x1
JMP 0x0019f2eb
LAB_0019f2db:
MOVZX EDX,word ptr [RSI + 0x1]
ROL DX,0x8
MOVZX EDX,DX
MOV EDI,0x3
LAB_0019f2eb:
ADD RSI,RDI
ADD RSI,RDX
LAB_0019f2f1:
MOV RDI,RSI
caseD_3:
MOV DL,byte ptr [RAX + 0x38]
ADD RAX,0x20
MOV RSI,RDI
TEST DL,DL
JNZ 0x0019f29a
JMP 0x0019f316
caseD_7:
TEST byte ptr [RAX + 0x12],0x1
JZ 0x0019f2f4
MOVZX EDX,byte ptr [RSI]
LEA RDI,[RSI + RDX*0x1]
INC RDI
JMP 0x0019f2f4
LAB_0019f316:
POP RBP
LAB_0019f317:
RET
|
void ha_find_null(long param_1,byte *param_2)
{
byte bVar1;
ulong uVar2;
byte *pbVar3;
long lVar4;
bVar1 = *(byte *)(param_1 + 0x18);
do {
if (bVar1 == 0) {
return;
}
if (*(char *)(param_1 + 0x19) != '\0') {
if (*param_2 == 0) {
return;
}
param_2 = param_2 + 1;
}
pbVar3 = param_2;
if (bVar1 - 1 < 0x13) {
pbVar3 = param_2 + *(ushort *)(param_1 + 0x14);
switch((uint)bVar1) {
case 1:
case 2:
case 0x13:
if ((*(byte *)(param_1 + 0x12) & 1) != 0) goto switchD_0019f2c0_caseD_f;
break;
case 7:
if ((*(byte *)(param_1 + 0x12) & 1) != 0) {
pbVar3 = param_2 + (ulong)*param_2 + 1;
}
break;
case 0xf:
case 0x10:
case 0x11:
case 0x12:
switchD_0019f2c0_caseD_f:
uVar2 = (ulong)*param_2;
if (uVar2 == 0xff) {
uVar2 = (ulong)(ushort)(*(ushort *)(param_2 + 1) << 8 | *(ushort *)(param_2 + 1) >> 8);
lVar4 = 3;
}
else {
lVar4 = 1;
}
pbVar3 = param_2 + uVar2 + lVar4;
}
}
bVar1 = *(byte *)(param_1 + 0x38);
param_1 = param_1 + 0x20;
param_2 = pbVar3;
} while( true );
}
|
|
60,086
|
rtree_overlapping_area
|
eloqsql/storage/myisam/rt_mbr.c
|
double rtree_overlapping_area(HA_KEYSEG *keyseg, uchar* a, uchar* b,
uint key_length)
{
double res = 1;
for (; (int) key_length > 0 ; keyseg += 2)
{
uint32 keyseg_length;
switch ((enum ha_base_keytype) keyseg->type) {
case HA_KEYTYPE_INT8:
RT_OVL_AREA_KORR(int8, mi_sint1korr, 1);
break;
case HA_KEYTYPE_BINARY:
RT_OVL_AREA_KORR(uint8, mi_uint1korr, 1);
break;
case HA_KEYTYPE_SHORT_INT:
RT_OVL_AREA_KORR(int16, mi_sint2korr, 2);
break;
case HA_KEYTYPE_USHORT_INT:
RT_OVL_AREA_KORR(uint16, mi_uint2korr, 2);
break;
case HA_KEYTYPE_INT24:
RT_OVL_AREA_KORR(int32, mi_sint3korr, 3);
break;
case HA_KEYTYPE_UINT24:
RT_OVL_AREA_KORR(uint32, mi_uint3korr, 3);
break;
case HA_KEYTYPE_LONG_INT:
RT_OVL_AREA_KORR(int32, mi_sint4korr, 4);
break;
case HA_KEYTYPE_ULONG_INT:
RT_OVL_AREA_KORR(uint32, mi_uint4korr, 4);
break;
#ifdef HAVE_LONG_LONG
case HA_KEYTYPE_LONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
case HA_KEYTYPE_ULONGLONG:
RT_OVL_AREA_KORR(longlong, mi_sint8korr, 8);
break;
#endif
case HA_KEYTYPE_FLOAT:
RT_OVL_AREA_GET(float, mi_float4get, 4);
break;
case HA_KEYTYPE_DOUBLE:
RT_OVL_AREA_GET(double, mi_float8get, 8);
break;
case HA_KEYTYPE_END:
return res;
default:
return -1;
}
keyseg_length= keyseg->length * 2;
key_length-= keyseg_length;
a+= keyseg_length;
b+= keyseg_length;
}
return res;
}
|
O3
|
c
|
rtree_overlapping_area:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
testl %ecx, %ecx
jle 0x8cc26
addq $0x18, %rdi
movsd 0x546a1(%rip), %xmm0 # 0xe0ea8
movsd 0x546b1(%rip), %xmm1 # 0xe0ec0
leaq 0x5525a(%rip), %rax # 0xe1a70
movzbl (%rdi), %r8d
cmpq $0xe, %r8
ja 0x8cc3b
movslq (%rax,%r8,4), %r8
addq %rax, %r8
jmpq *%r8
movq (%rsi), %r9
movq 0x8(%rsi), %r10
bswapq %r9
movq (%rdx), %r11
movq 0x8(%rdx), %r8
bswapq %r11
bswapq %r10
bswapq %r8
cmpq %r11, %r9
cmovgq %r9, %r11
cmpq %r8, %r10
cmovlq %r10, %r8
subq %r11, %r8
jg 0x8ca1f
jmp 0x8cc30
movzbl (%rsi), %r11d
movl %r11d, %r8d
shll $0x10, %r8d
movzbl 0x1(%rsi), %r9d
shll $0x8, %r9d
movzbl 0x2(%rsi), %r10d
testb %r11b, %r11b
js 0x8cb47
orl %r10d, %r8d
orl %r9d, %r8d
jmp 0x8cb54
movzwl 0x1(%rsi), %r8d
movzwl 0x4(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzbl (%rsi), %r8d
shll $0x10, %r8d
orl %r10d, %r8d
movzwl 0x1(%rdx), %r10d
movzwl 0x4(%rdx), %r11d
rolw $0x8, %r10w
movzwl %r10w, %r10d
movzbl (%rdx), %ebx
shll $0x10, %ebx
orl %r10d, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
movzbl 0x3(%rsi), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
rolw $0x8, %r11w
movzwl %r11w, %r11d
movzbl 0x3(%rdx), %r9d
shll $0x10, %r9d
orl %r11d, %r9d
cmpl %ebx, %r8d
cmoval %r8d, %ebx
cmpl %r9d, %r10d
cmovbl %r10d, %r9d
subl %ebx, %r9d
jbe 0x8cc30
xorps %xmm2, %xmm2
cvtsi2sd %r9, %xmm2
jmp 0x8cc05
movq (%rsi), %r8
movq 0x8(%rsi), %r9
bswapq %r8
movq %r8, %xmm3
movq (%rdx), %r8
bswapq %r8
movq 0x8(%rdx), %r10
movq %r8, %xmm2
bswapq %r9
maxsd %xmm2, %xmm3
movq %r9, %xmm2
bswapq %r10
movq %r10, %xmm4
minsd %xmm4, %xmm2
ucomisd %xmm2, %xmm3
jae 0x8cc30
subsd %xmm3, %xmm2
jmp 0x8cc05
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmovgl %r9d, %r11d
cmpl %r8d, %r10d
cmovll %r10d, %r8d
subl %r11d, %r8d
jg 0x8c9e1
jmp 0x8cc30
movzwl (%rsi), %r8d
movzwl 0x2(%rsi), %r9d
rolw $0x8, %r8w
movzwl %r8w, %r10d
movzwl (%rdx), %r8d
rolw $0x8, %r8w
movzwl 0x2(%rdx), %r11d
movzwl %r8w, %ebx
rolw $0x8, %r9w
movzwl %r9w, %r9d
rolw $0x8, %r11w
movzwl %r11w, %r8d
cmpl %ebx, %r10d
cmoval %r10d, %ebx
cmpl %r8d, %r9d
cmovbl %r9d, %r8d
subl %ebx, %r8d
jbe 0x8cc30
xorps %xmm2, %xmm2
cvtsi2sd %r8d, %xmm2
jmp 0x8cc05
movl (%rsi), %r9d
movl 0x4(%rsi), %r10d
bswapl %r9d
movl (%rdx), %r11d
movl 0x4(%rdx), %r8d
bswapl %r11d
bswapl %r10d
bswapl %r8d
cmpl %r11d, %r9d
cmoval %r9d, %r11d
cmpl %r8d, %r10d
cmovbl %r10d, %r8d
subl %r11d, %r8d
jbe 0x8cc30
xorps %xmm2, %xmm2
cvtsi2sd %r8, %xmm2
jmp 0x8cc05
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r9), %r10d
leal 0x1(%r8), %r11d
cmpb %r8b, %r9b
cmovgl %r9d, %r8d
movzbl %r10b, %r10d
movzbl %r11b, %r9d
cmpb %r9b, %r10b
cmovll %r10d, %r9d
cmpb %r9b, %r8b
jge 0x8cc30
movsbl %r9b, %r9d
movsbl %r8b, %r8d
jmp 0x8cae8
movzwl (%rsi), %r10d
movzwl 0x2(%rsi), %r11d
rolw $0x8, %r10w
movzwl (%rdx), %r8d
movzwl 0x2(%rdx), %r9d
rolw $0x8, %r8w
rolw $0x8, %r11w
rolw $0x8, %r9w
cmpw %r8w, %r10w
cmovgl %r10d, %r8d
cmpw %r9w, %r11w
cmovll %r11d, %r9d
cmpw %r9w, %r8w
jge 0x8cc30
movswl %r9w, %r9d
movswl %r8w, %r8d
jmp 0x8cae8
movzbl (%rsi), %r9d
movzbl (%rdx), %r8d
leal 0x1(%r8), %r10d
cmpb %r8b, %r9b
cmoval %r9d, %r8d
incl %r9d
movzbl %r9b, %r11d
movzbl %r10b, %r9d
cmpb %r9b, %r11b
cmovbl %r11d, %r9d
cmpb %r9b, %r8b
jae 0x8cc30
movzbl %r9b, %r9d
movzbl %r8b, %r8d
subl %r8d, %r9d
xorps %xmm2, %xmm2
cvtsi2sd %r9d, %xmm2
jmp 0x8cc05
movl (%rsi), %r8d
movl 0x4(%rsi), %r9d
bswapl %r8d
movd %r8d, %xmm2
movl (%rdx), %r8d
movl 0x4(%rdx), %r10d
bswapl %r8d
movd %r8d, %xmm3
maxss %xmm3, %xmm2
bswapl %r9d
movd %r9d, %xmm3
bswapl %r10d
movd %r10d, %xmm4
minss %xmm4, %xmm3
ucomiss %xmm3, %xmm2
jae 0x8cc30
subss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
jmp 0x8cc05
orl %r10d, %r9d
addl %r9d, %r8d
addl $0xff000000, %r8d # imm = 0xFF000000
movzbl (%rdx), %ebx
movl %ebx, %r9d
shll $0x10, %r9d
movzbl 0x1(%rdx), %r10d
shll $0x8, %r10d
movzbl 0x2(%rdx), %r11d
testb %bl, %bl
js 0x8cb78
orl %r11d, %r9d
orl %r10d, %r9d
jmp 0x8cb85
orl %r11d, %r10d
addl %r10d, %r9d
addl $0xff000000, %r9d # imm = 0xFF000000
movzbl 0x3(%rsi), %r14d
movl %r14d, %r10d
shll $0x10, %r10d
movzbl 0x4(%rsi), %r11d
shll $0x8, %r11d
movzbl 0x5(%rsi), %ebx
testb %r14b, %r14b
js 0x8cbab
orl %ebx, %r10d
orl %r11d, %r10d
jmp 0x8cbb8
orl %ebx, %r11d
addl %r11d, %r10d
addl $0xff000000, %r10d # imm = 0xFF000000
movzbl 0x3(%rdx), %r15d
movl %r15d, %r11d
shll $0x10, %r11d
movzbl 0x4(%rdx), %ebx
shll $0x8, %ebx
movzbl 0x5(%rdx), %r14d
testb %r15b, %r15b
js 0x8cbdd
orl %r14d, %r11d
orl %ebx, %r11d
jmp 0x8cbea
orl %r14d, %ebx
addl %ebx, %r11d
addl $0xff000000, %r11d # imm = 0xFF000000
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
cmpl %r11d, %r10d
cmovll %r10d, %r11d
subl %r9d, %r11d
jle 0x8cc30
xorps %xmm2, %xmm2
cvtsi2sd %r11d, %xmm2
mulsd %xmm2, %xmm0
movzwl -0x4(%rdi), %r8d
addl %r8d, %r8d
addq %r8, %rsi
addq %r8, %rdx
addq $0x40, %rdi
subl %r8d, %ecx
jg 0x8c816
jmp 0x8cc34
movsd 0x5427a(%rip), %xmm0 # 0xe0ea8
jmp 0x8cc34
xorpd %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movapd %xmm1, %xmm0
jmp 0x8cc34
|
rtree_overlapping_area:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
test ecx, ecx
jle loc_8CC26
add rdi, 18h
movsd xmm0, cs:qword_E0EA8
movsd xmm1, cs:qword_E0EC0
lea rax, jpt_8C82B
loc_8C816:
movzx r8d, byte ptr [rdi]
cmp r8, 0Eh; switch 15 cases
ja def_8C82B; jumptable 000000000008C82B default case, cases 1,7
movsxd r8, ds:(jpt_8C82B - 0E1A70h)[rax+r8*4]
add r8, rax
jmp r8; switch jump
loc_8C82E:
mov r9, [rsi]; jumptable 000000000008C82B cases 10,11
mov r10, [rsi+8]
bswap r9
mov r11, [rdx]
mov r8, [rdx+8]
bswap r11
bswap r10
bswap r8
cmp r9, r11
cmovg r11, r9
cmp r10, r8
cmovl r8, r10
sub r8, r11
jg loc_8CA1F
jmp loc_8CC30
loc_8C864:
movzx r11d, byte ptr [rsi]; jumptable 000000000008C82B case 12
mov r8d, r11d
shl r8d, 10h
movzx r9d, byte ptr [rsi+1]
shl r9d, 8
movzx r10d, byte ptr [rsi+2]
test r11b, r11b
js loc_8CB47
or r8d, r10d
or r8d, r9d
jmp loc_8CB54
loc_8C891:
movzx r8d, word ptr [rsi+1]; jumptable 000000000008C82B case 13
movzx r9d, word ptr [rsi+4]
rol r8w, 8
movzx r10d, r8w
movzx r8d, byte ptr [rsi]
shl r8d, 10h
or r8d, r10d
movzx r10d, word ptr [rdx+1]
movzx r11d, word ptr [rdx+4]
rol r10w, 8
movzx r10d, r10w
movzx ebx, byte ptr [rdx]
shl ebx, 10h
or ebx, r10d
rol r9w, 8
movzx r9d, r9w
movzx r10d, byte ptr [rsi+3]
shl r10d, 10h
or r10d, r9d
rol r11w, 8
movzx r11d, r11w
movzx r9d, byte ptr [rdx+3]
shl r9d, 10h
or r9d, r11d
cmp r8d, ebx
cmova ebx, r8d
cmp r10d, r9d
cmovb r9d, r10d
sub r9d, ebx
jbe loc_8CC30
xorps xmm2, xmm2
cvtsi2sd xmm2, r9
jmp loc_8CC05
loc_8C919:
mov r8, [rsi]; jumptable 000000000008C82B case 6
mov r9, [rsi+8]
bswap r8
movq xmm3, r8
mov r8, [rdx]
bswap r8
mov r10, [rdx+8]
movq xmm2, r8
bswap r9
maxsd xmm3, xmm2
movq xmm2, r9
bswap r10
movq xmm4, r10
minsd xmm2, xmm4
ucomisd xmm3, xmm2
jnb loc_8CC30
subsd xmm2, xmm3
jmp loc_8CC05
loc_8C962:
mov r9d, [rsi]; jumptable 000000000008C82B case 4
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmovg r11d, r9d
cmp r10d, r8d
cmovl r8d, r10d
sub r8d, r11d
jg short loc_8C9E1
jmp loc_8CC30
loc_8C994:
movzx r8d, word ptr [rsi]; jumptable 000000000008C82B case 8
movzx r9d, word ptr [rsi+2]
rol r8w, 8
movzx r10d, r8w
movzx r8d, word ptr [rdx]
rol r8w, 8
movzx r11d, word ptr [rdx+2]
movzx ebx, r8w
rol r9w, 8
movzx r9d, r9w
rol r11w, 8
movzx r8d, r11w
cmp r10d, ebx
cmova ebx, r10d
cmp r9d, r8d
cmovb r8d, r9d
sub r8d, ebx
jbe loc_8CC30
loc_8C9E1:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8d
jmp loc_8CC05
loc_8C9EE:
mov r9d, [rsi]; jumptable 000000000008C82B case 9
mov r10d, [rsi+4]
bswap r9d
mov r11d, [rdx]
mov r8d, [rdx+4]
bswap r11d
bswap r10d
bswap r8d
cmp r9d, r11d
cmova r11d, r9d
cmp r10d, r8d
cmovb r8d, r10d
sub r8d, r11d
jbe loc_8CC30
loc_8CA1F:
xorps xmm2, xmm2
cvtsi2sd xmm2, r8
jmp loc_8CC05
loc_8CA2C:
movzx r9d, byte ptr [rsi]; jumptable 000000000008C82B case 14
movzx r8d, byte ptr [rdx]
lea r10d, [r9+1]
lea r11d, [r8+1]
cmp r9b, r8b
cmovg r8d, r9d
movzx r10d, r10b
movzx r9d, r11b
cmp r10b, r9b
cmovl r9d, r10d
cmp r8b, r9b
jge loc_8CC30
movsx r9d, r9b
movsx r8d, r8b
jmp loc_8CAE8
loc_8CA68:
movzx r10d, word ptr [rsi]; jumptable 000000000008C82B case 3
movzx r11d, word ptr [rsi+2]
rol r10w, 8
movzx r8d, word ptr [rdx]
movzx r9d, word ptr [rdx+2]
rol r8w, 8
rol r11w, 8
rol r9w, 8
cmp r10w, r8w
cmovg r8d, r10d
cmp r11w, r9w
cmovl r9d, r11d
cmp r8w, r9w
jge loc_8CC30
movsx r9d, r9w
movsx r8d, r8w
jmp short loc_8CAE8
loc_8CAB2:
movzx r9d, byte ptr [rsi]; jumptable 000000000008C82B case 2
movzx r8d, byte ptr [rdx]
lea r10d, [r8+1]
cmp r9b, r8b
cmova r8d, r9d
inc r9d
movzx r11d, r9b
movzx r9d, r10b
cmp r11b, r9b
cmovb r9d, r11d
cmp r8b, r9b
jnb loc_8CC30
movzx r9d, r9b
movzx r8d, r8b
loc_8CAE8:
sub r9d, r8d
xorps xmm2, xmm2
cvtsi2sd xmm2, r9d
jmp loc_8CC05
loc_8CAF8:
mov r8d, [rsi]; jumptable 000000000008C82B case 5
mov r9d, [rsi+4]
bswap r8d
movd xmm2, r8d
mov r8d, [rdx]
mov r10d, [rdx+4]
bswap r8d
movd xmm3, r8d
maxss xmm2, xmm3
bswap r9d
movd xmm3, r9d
bswap r10d
movd xmm4, r10d
minss xmm3, xmm4
ucomiss xmm2, xmm3
jnb loc_8CC30
subss xmm3, xmm2
xorps xmm2, xmm2
cvtss2sd xmm2, xmm3
jmp loc_8CC05
loc_8CB47:
or r9d, r10d
add r8d, r9d
add r8d, 0FF000000h
loc_8CB54:
movzx ebx, byte ptr [rdx]
mov r9d, ebx
shl r9d, 10h
movzx r10d, byte ptr [rdx+1]
shl r10d, 8
movzx r11d, byte ptr [rdx+2]
test bl, bl
js short loc_8CB78
or r9d, r11d
or r9d, r10d
jmp short loc_8CB85
loc_8CB78:
or r10d, r11d
add r9d, r10d
add r9d, 0FF000000h
loc_8CB85:
movzx r14d, byte ptr [rsi+3]
mov r10d, r14d
shl r10d, 10h
movzx r11d, byte ptr [rsi+4]
shl r11d, 8
movzx ebx, byte ptr [rsi+5]
test r14b, r14b
js short loc_8CBAB
or r10d, ebx
or r10d, r11d
jmp short loc_8CBB8
loc_8CBAB:
or r11d, ebx
add r10d, r11d
add r10d, 0FF000000h
loc_8CBB8:
movzx r15d, byte ptr [rdx+3]
mov r11d, r15d
shl r11d, 10h
movzx ebx, byte ptr [rdx+4]
shl ebx, 8
movzx r14d, byte ptr [rdx+5]
test r15b, r15b
js short loc_8CBDD
or r11d, r14d
or r11d, ebx
jmp short loc_8CBEA
loc_8CBDD:
or ebx, r14d
add r11d, ebx
add r11d, 0FF000000h
loc_8CBEA:
cmp r8d, r9d
cmovg r9d, r8d
cmp r10d, r11d
cmovl r11d, r10d
sub r11d, r9d
jle short loc_8CC30
xorps xmm2, xmm2
cvtsi2sd xmm2, r11d
loc_8CC05:
mulsd xmm0, xmm2
movzx r8d, word ptr [rdi-4]
add r8d, r8d
add rsi, r8
add rdx, r8
add rdi, 40h ; '@'
sub ecx, r8d
jg loc_8C816
jmp short loc_8CC34; jumptable 000000000008C82B case 0
loc_8CC26:
movsd xmm0, cs:qword_E0EA8
jmp short loc_8CC34; jumptable 000000000008C82B case 0
loc_8CC30:
xorpd xmm0, xmm0
loc_8CC34:
pop rbx; jumptable 000000000008C82B case 0
pop r14
pop r15
pop rbp
retn
def_8C82B:
movapd xmm0, xmm1; jumptable 000000000008C82B default case, cases 1,7
jmp short loc_8CC34; jumptable 000000000008C82B case 0
|
double rtree_overlapping_area(long long a1, _WORD *a2, _WORD *a3, int a4)
{
_BYTE *v4; // rdi
double result; // xmm0_8
signed long long v6; // r9
signed long long v7; // r11
signed long long v8; // r10
signed long long v9; // r8
bool v10; // cc
int v11; // r8d
int v12; // r8d
int v13; // r9d
int v14; // r10d
int v15; // r8d
unsigned int v16; // r8d
unsigned int v17; // ebx
unsigned int v18; // r10d
unsigned int v19; // r9d
int v20; // r9d
double v21; // xmm2_8
double v22; // xmm3_8
double v23; // xmm2_8
signed __int32 v24; // r9d
signed __int32 v25; // r11d
signed __int32 v26; // r10d
signed __int32 v27; // r8d
int v28; // r8d
unsigned int v29; // r10d
unsigned int v30; // ebx
unsigned int v31; // r9d
unsigned int v32; // r8d
unsigned __int32 v33; // r9d
unsigned __int32 v34; // r11d
unsigned __int32 v35; // r10d
unsigned __int32 v36; // r8d
int v37; // r8d
int v38; // r9d
__int16 v39; // r10
__int16 v40; // r11
float v41; // xmm2_4
float v42; // xmm3_4
int v43; // r9d
int v44; // r10d
int v45; // r11d
int v46; // r9d
int v47; // r10d
int v48; // r11d
int v49; // ebx
int v50; // r10d
int v51; // r11d
int v52; // ebx
int v53; // r14d
int v54; // r11d
int v55; // r11d
long long v56; // r8
if ( a4 <= 0 )
return 1.0;
v4 = (_BYTE *)(a1 + 24);
result = 1.0;
while ( 2 )
{
switch ( *v4 )
{
case 0:
return result;
case 2:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (unsigned __int8)(*(_BYTE *)a2 + 1) < (unsigned __int8)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (unsigned __int8)v37 >= (unsigned __int8)v38 )
return 0.0;
v38 = (unsigned __int8)v38;
v37 = (unsigned __int8)v37;
goto LABEL_56;
case 3:
v39 = __ROL2__(*a2, 8);
LOWORD(v37) = __ROL2__(*a3, 8);
v40 = __ROL2__(a2[1], 8);
LOWORD(v38) = __ROL2__(a3[1], 8);
if ( v39 > (__int16)v37 )
LOWORD(v37) = v39;
if ( v40 < (__int16)v38 )
LOWORD(v38) = v40;
if ( (__int16)v37 >= (__int16)v38 )
return 0.0;
v38 = (__int16)v38;
v37 = (__int16)v37;
goto LABEL_56;
case 4:
v24 = _byteswap_ulong(*(_DWORD *)a2);
v25 = _byteswap_ulong(*(_DWORD *)a3);
v26 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v27 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v24 > v25 )
v25 = v24;
if ( v26 < v27 )
v27 = v26;
v10 = v27 <= v25;
v28 = v27 - v25;
if ( v10 )
return 0.0;
goto LABEL_31;
case 5:
v41 = fmaxf(COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a2)), COERCE_FLOAT(_byteswap_ulong(*(_DWORD *)a3)));
v42 = fminf(
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a2 + 1))),
COERCE_FLOAT(_byteswap_ulong(*((_DWORD *)a3 + 1))));
if ( v41 >= v42 )
return 0.0;
v21 = (float)(v42 - v41);
goto LABEL_75;
case 6:
v22 = fmax(COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a2)), COERCE_DOUBLE(_byteswap_uint64(*(_QWORD *)a3)));
v23 = fmin(
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a2 + 1))),
COERCE_DOUBLE(_byteswap_uint64(*((_QWORD *)a3 + 1))));
if ( v22 >= v23 )
return 0.0;
v21 = v23 - v22;
goto LABEL_75;
case 8:
v29 = (unsigned __int16)__ROL2__(*a2, 8);
v30 = (unsigned __int16)__ROL2__(*a3, 8);
v31 = (unsigned __int16)__ROL2__(a2[1], 8);
v32 = (unsigned __int16)__ROL2__(a3[1], 8);
if ( v29 > v30 )
v30 = v29;
if ( v31 < v32 )
v32 = v31;
v10 = v32 <= v30;
v28 = v32 - v30;
if ( v10 )
return 0.0;
LABEL_31:
v21 = (double)v28;
goto LABEL_75;
case 9:
v33 = _byteswap_ulong(*(_DWORD *)a2);
v34 = _byteswap_ulong(*(_DWORD *)a3);
v35 = _byteswap_ulong(*((_DWORD *)a2 + 1));
v36 = _byteswap_ulong(*((_DWORD *)a3 + 1));
if ( v33 > v34 )
v34 = v33;
if ( v35 < v36 )
v36 = v35;
v10 = v36 <= v34;
v11 = v36 - v34;
if ( !v10 )
goto LABEL_37;
return 0.0;
case 0xA:
case 0xB:
v6 = _byteswap_uint64(*(_QWORD *)a2);
v7 = _byteswap_uint64(*(_QWORD *)a3);
v8 = _byteswap_uint64(*((_QWORD *)a2 + 1));
v9 = _byteswap_uint64(*((_QWORD *)a3 + 1));
if ( v6 > v7 )
v7 = v6;
if ( v8 < v9 )
v9 = v8;
v10 = v9 <= v7;
v11 = v9 - v7;
if ( v10 )
return 0.0;
LABEL_37:
v21 = (double)v11;
goto LABEL_75;
case 0xC:
v12 = *(unsigned __int8 *)a2 << 16;
v13 = *((unsigned __int8 *)a2 + 1) << 8;
v14 = *((unsigned __int8 *)a2 + 2);
if ( *(char *)a2 < 0 )
v15 = (v14 | v13) + v12 - 0x1000000;
else
v15 = v13 | v14 | v12;
v43 = *(unsigned __int8 *)a3 << 16;
v44 = *((unsigned __int8 *)a3 + 1) << 8;
v45 = *((unsigned __int8 *)a3 + 2);
if ( *(char *)a3 < 0 )
v46 = (v45 | v44) + v43 - 0x1000000;
else
v46 = v44 | v45 | v43;
v47 = *((unsigned __int8 *)a2 + 3) << 16;
v48 = *((unsigned __int8 *)a2 + 4) << 8;
v49 = *((unsigned __int8 *)a2 + 5);
if ( *((char *)a2 + 3) < 0 )
v50 = (v49 | v48) + v47 - 0x1000000;
else
v50 = v48 | v49 | v47;
v51 = *((unsigned __int8 *)a3 + 3) << 16;
v52 = *((unsigned __int8 *)a3 + 4) << 8;
v53 = *((unsigned __int8 *)a3 + 5);
if ( *((char *)a3 + 3) < 0 )
v54 = (v53 | v52) + v51 - 0x1000000;
else
v54 = v52 | v53 | v51;
if ( v15 > v46 )
v46 = v15;
if ( v50 < v54 )
v54 = v50;
v10 = v54 <= v46;
v55 = v54 - v46;
if ( v10 )
return 0.0;
v21 = (double)v55;
goto LABEL_75;
case 0xD:
v16 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a2 + 1), 8) | (*(unsigned __int8 *)a2 << 16);
v17 = (unsigned __int16)__ROL2__(*(_WORD *)((char *)a3 + 1), 8) | (*(unsigned __int8 *)a3 << 16);
v18 = (unsigned __int16)__ROL2__(a2[2], 8) | (*((unsigned __int8 *)a2 + 3) << 16);
v19 = (unsigned __int16)__ROL2__(a3[2], 8) | (*((unsigned __int8 *)a3 + 3) << 16);
if ( v16 > v17 )
v17 = v16;
if ( v18 < v19 )
v19 = v18;
v10 = v19 <= v17;
v20 = v19 - v17;
if ( v10 )
return 0.0;
v21 = (double)v20;
goto LABEL_75;
case 0xE:
LOBYTE(v37) = *(_BYTE *)a3;
if ( *(_BYTE *)a2 > *(_BYTE *)a3 )
LOBYTE(v37) = *(_BYTE *)a2;
LOBYTE(v38) = *(_BYTE *)a3 + 1;
if ( (char)(*(_BYTE *)a2 + 1) < (char)v38 )
LOBYTE(v38) = *(_BYTE *)a2 + 1;
if ( (char)v37 < (char)v38 )
{
v38 = (char)v38;
v37 = (char)v37;
LABEL_56:
v21 = (double)(v38 - v37);
LABEL_75:
result = result * v21;
v56 = 2 * (unsigned int)*((unsigned __int16 *)v4 - 2);
a2 = (_WORD *)((char *)a2 + v56);
a3 = (_WORD *)((char *)a3 + v56);
v4 += 64;
v10 = a4 <= (int)v56;
a4 -= v56;
if ( v10 )
return result;
continue;
}
return 0.0;
default:
return -1.0;
}
}
}
|
rtree_overlapping_area:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
TEST ECX,ECX
JLE 0x0018cc26
ADD RDI,0x18
MOVSD XMM0,qword ptr [0x001e0ea8]
MOVSD XMM1,qword ptr [0x001e0ec0]
LEA RAX,[0x1e1a70]
LAB_0018c816:
MOVZX R8D,byte ptr [RDI]
CMP R8,0xe
JA 0x0018cc3b
MOVSXD R8,dword ptr [RAX + R8*0x4]
ADD R8,RAX
switchD:
JMP R8
caseD_a:
MOV R9,qword ptr [RSI]
MOV R10,qword ptr [RSI + 0x8]
BSWAP R9
MOV R11,qword ptr [RDX]
MOV R8,qword ptr [RDX + 0x8]
BSWAP R11
BSWAP R10
BSWAP R8
CMP R9,R11
CMOVG R11,R9
CMP R10,R8
CMOVL R8,R10
SUB R8,R11
JG 0x0018ca1f
JMP 0x0018cc30
caseD_c:
MOVZX R11D,byte ptr [RSI]
MOV R8D,R11D
SHL R8D,0x10
MOVZX R9D,byte ptr [RSI + 0x1]
SHL R9D,0x8
MOVZX R10D,byte ptr [RSI + 0x2]
TEST R11B,R11B
JS 0x0018cb47
OR R8D,R10D
OR R8D,R9D
JMP 0x0018cb54
caseD_d:
MOVZX R8D,word ptr [RSI + 0x1]
MOVZX R9D,word ptr [RSI + 0x4]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,byte ptr [RSI]
SHL R8D,0x10
OR R8D,R10D
MOVZX R10D,word ptr [RDX + 0x1]
MOVZX R11D,word ptr [RDX + 0x4]
ROL R10W,0x8
MOVZX R10D,R10W
MOVZX EBX,byte ptr [RDX]
SHL EBX,0x10
OR EBX,R10D
ROL R9W,0x8
MOVZX R9D,R9W
MOVZX R10D,byte ptr [RSI + 0x3]
SHL R10D,0x10
OR R10D,R9D
ROL R11W,0x8
MOVZX R11D,R11W
MOVZX R9D,byte ptr [RDX + 0x3]
SHL R9D,0x10
OR R9D,R11D
CMP R8D,EBX
CMOVA EBX,R8D
CMP R10D,R9D
CMOVC R9D,R10D
SUB R9D,EBX
JBE 0x0018cc30
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9
JMP 0x0018cc05
caseD_6:
MOV R8,qword ptr [RSI]
MOV R9,qword ptr [RSI + 0x8]
BSWAP R8
MOVQ XMM3,R8
MOV R8,qword ptr [RDX]
BSWAP R8
MOV R10,qword ptr [RDX + 0x8]
MOVQ XMM2,R8
BSWAP R9
MAXSD XMM3,XMM2
MOVQ XMM2,R9
BSWAP R10
MOVQ XMM4,R10
MINSD XMM2,XMM4
UCOMISD XMM3,XMM2
JNC 0x0018cc30
SUBSD XMM2,XMM3
JMP 0x0018cc05
caseD_4:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVG R11D,R9D
CMP R10D,R8D
CMOVL R8D,R10D
SUB R8D,R11D
JG 0x0018c9e1
JMP 0x0018cc30
caseD_8:
MOVZX R8D,word ptr [RSI]
MOVZX R9D,word ptr [RSI + 0x2]
ROL R8W,0x8
MOVZX R10D,R8W
MOVZX R8D,word ptr [RDX]
ROL R8W,0x8
MOVZX R11D,word ptr [RDX + 0x2]
MOVZX EBX,R8W
ROL R9W,0x8
MOVZX R9D,R9W
ROL R11W,0x8
MOVZX R8D,R11W
CMP R10D,EBX
CMOVA EBX,R10D
CMP R9D,R8D
CMOVC R8D,R9D
SUB R8D,EBX
JBE 0x0018cc30
LAB_0018c9e1:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8D
JMP 0x0018cc05
caseD_9:
MOV R9D,dword ptr [RSI]
MOV R10D,dword ptr [RSI + 0x4]
BSWAP R9D
MOV R11D,dword ptr [RDX]
MOV R8D,dword ptr [RDX + 0x4]
BSWAP R11D
BSWAP R10D
BSWAP R8D
CMP R9D,R11D
CMOVA R11D,R9D
CMP R10D,R8D
CMOVC R8D,R10D
SUB R8D,R11D
JBE 0x0018cc30
LAB_0018ca1f:
XORPS XMM2,XMM2
CVTSI2SD XMM2,R8
JMP 0x0018cc05
caseD_e:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R9 + 0x1]
LEA R11D,[R8 + 0x1]
CMP R9B,R8B
CMOVG R8D,R9D
MOVZX R10D,R10B
MOVZX R9D,R11B
CMP R10B,R9B
CMOVL R9D,R10D
CMP R8B,R9B
JGE 0x0018cc30
MOVSX R9D,R9B
MOVSX R8D,R8B
JMP 0x0018cae8
caseD_3:
MOVZX R10D,word ptr [RSI]
MOVZX R11D,word ptr [RSI + 0x2]
ROL R10W,0x8
MOVZX R8D,word ptr [RDX]
MOVZX R9D,word ptr [RDX + 0x2]
ROL R8W,0x8
ROL R11W,0x8
ROL R9W,0x8
CMP R10W,R8W
CMOVG R8D,R10D
CMP R11W,R9W
CMOVL R9D,R11D
CMP R8W,R9W
JGE 0x0018cc30
MOVSX R9D,R9W
MOVSX R8D,R8W
JMP 0x0018cae8
caseD_2:
MOVZX R9D,byte ptr [RSI]
MOVZX R8D,byte ptr [RDX]
LEA R10D,[R8 + 0x1]
CMP R9B,R8B
CMOVA R8D,R9D
INC R9D
MOVZX R11D,R9B
MOVZX R9D,R10B
CMP R11B,R9B
CMOVC R9D,R11D
CMP R8B,R9B
JNC 0x0018cc30
MOVZX R9D,R9B
MOVZX R8D,R8B
LAB_0018cae8:
SUB R9D,R8D
XORPS XMM2,XMM2
CVTSI2SD XMM2,R9D
JMP 0x0018cc05
caseD_5:
MOV R8D,dword ptr [RSI]
MOV R9D,dword ptr [RSI + 0x4]
BSWAP R8D
MOVD XMM2,R8D
MOV R8D,dword ptr [RDX]
MOV R10D,dword ptr [RDX + 0x4]
BSWAP R8D
MOVD XMM3,R8D
MAXSS XMM2,XMM3
BSWAP R9D
MOVD XMM3,R9D
BSWAP R10D
MOVD XMM4,R10D
MINSS XMM3,XMM4
UCOMISS XMM2,XMM3
JNC 0x0018cc30
SUBSS XMM3,XMM2
XORPS XMM2,XMM2
CVTSS2SD XMM2,XMM3
JMP 0x0018cc05
LAB_0018cb47:
OR R9D,R10D
ADD R8D,R9D
ADD R8D,0xff000000
LAB_0018cb54:
MOVZX EBX,byte ptr [RDX]
MOV R9D,EBX
SHL R9D,0x10
MOVZX R10D,byte ptr [RDX + 0x1]
SHL R10D,0x8
MOVZX R11D,byte ptr [RDX + 0x2]
TEST BL,BL
JS 0x0018cb78
OR R9D,R11D
OR R9D,R10D
JMP 0x0018cb85
LAB_0018cb78:
OR R10D,R11D
ADD R9D,R10D
ADD R9D,0xff000000
LAB_0018cb85:
MOVZX R14D,byte ptr [RSI + 0x3]
MOV R10D,R14D
SHL R10D,0x10
MOVZX R11D,byte ptr [RSI + 0x4]
SHL R11D,0x8
MOVZX EBX,byte ptr [RSI + 0x5]
TEST R14B,R14B
JS 0x0018cbab
OR R10D,EBX
OR R10D,R11D
JMP 0x0018cbb8
LAB_0018cbab:
OR R11D,EBX
ADD R10D,R11D
ADD R10D,0xff000000
LAB_0018cbb8:
MOVZX R15D,byte ptr [RDX + 0x3]
MOV R11D,R15D
SHL R11D,0x10
MOVZX EBX,byte ptr [RDX + 0x4]
SHL EBX,0x8
MOVZX R14D,byte ptr [RDX + 0x5]
TEST R15B,R15B
JS 0x0018cbdd
OR R11D,R14D
OR R11D,EBX
JMP 0x0018cbea
LAB_0018cbdd:
OR EBX,R14D
ADD R11D,EBX
ADD R11D,0xff000000
LAB_0018cbea:
CMP R8D,R9D
CMOVG R9D,R8D
CMP R10D,R11D
CMOVL R11D,R10D
SUB R11D,R9D
JLE 0x0018cc30
XORPS XMM2,XMM2
CVTSI2SD XMM2,R11D
LAB_0018cc05:
MULSD XMM0,XMM2
MOVZX R8D,word ptr [RDI + -0x4]
ADD R8D,R8D
ADD RSI,R8
ADD RDX,R8
ADD RDI,0x40
SUB ECX,R8D
JG 0x0018c816
JMP 0x0018cc34
LAB_0018cc26:
MOVSD XMM0,qword ptr [0x001e0ea8]
JMP 0x0018cc34
LAB_0018cc30:
XORPD XMM0,XMM0
caseD_0:
POP RBX
POP R14
POP R15
POP RBP
RET
caseD_1:
MOVAPD XMM0,XMM1
JMP 0x0018cc34
|
double rtree_overlapping_area(long param_1,ulong *param_2,ulong *param_3,int param_4)
{
ushort *puVar1;
byte bVar2;
byte bVar3;
ulong uVar4;
int1 *puVar5;
byte bVar6;
ushort uVar7;
uint uVar8;
int iVar9;
uint uVar10;
float fVar11;
float fVar12;
ulong uVar13;
double dVar14;
double dVar15;
char cVar16;
byte bVar17;
ushort uVar18;
uint uVar19;
ulong uVar20;
ushort uVar21;
uint uVar22;
uint uVar23;
float fVar24;
ulong uVar25;
ushort uVar26;
ulong uVar27;
bool bVar28;
double dVar29;
double dVar30;
dVar29 = DAT_001e0ea8;
if (param_4 < 1) {
switchD_0018c82b_caseD_0:
return dVar29;
}
puVar5 = (int1 *)(param_1 + 0x18);
do {
switch(*puVar5) {
case 0:
goto switchD_0018c82b_caseD_0;
default:
return DAT_001e0ec0;
case 2:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if (bVar3 < bVar2) {
bVar6 = bVar2;
}
bVar17 = bVar3 + 1;
if ((byte)(bVar2 + 1) < (byte)(bVar3 + 1)) {
bVar17 = bVar2 + 1;
}
if (bVar17 <= bVar6) {
return 0.0;
}
uVar19 = (uint)bVar17;
uVar10 = (uint)bVar6;
goto LAB_0018cae8;
case 3:
uVar21 = (ushort)*param_2 << 8 | (ushort)*param_2 >> 8;
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar26 = *(ushort *)((long)param_2 + 2) << 8 | *(ushort *)((long)param_2 + 2) >> 8;
uVar18 = *(ushort *)((long)param_3 + 2) << 8 | *(ushort *)((long)param_3 + 2) >> 8;
if ((short)uVar7 < (short)uVar21) {
uVar7 = uVar21;
}
if ((short)uVar26 < (short)uVar18) {
uVar18 = uVar26;
}
if ((short)uVar18 <= (short)uVar7) {
return 0.0;
}
uVar19 = (uint)(short)uVar18;
uVar10 = (uint)(short)uVar7;
goto LAB_0018cae8;
case 4:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if ((int)uVar10 < (int)uVar22) {
uVar10 = uVar22;
}
if ((int)uVar23 < (int)uVar19) {
uVar19 = uVar23;
}
iVar9 = uVar19 - uVar10;
if (iVar9 == 0 || (int)uVar19 < (int)uVar10) {
return 0.0;
}
goto LAB_0018c9e1;
case 5:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
fVar11 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
fVar12 = (float)(uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 |
uVar10 << 0x18);
if (fVar11 <= fVar12) {
fVar11 = fVar12;
}
fVar12 = (float)(uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 |
uVar19 << 0x18);
fVar24 = (float)(uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 |
uVar8 << 0x18);
if (fVar24 <= fVar12) {
fVar12 = fVar24;
}
if (fVar12 <= fVar11) {
return 0.0;
}
dVar30 = (double)(fVar12 - fVar11);
break;
case 6:
uVar13 = *param_2;
uVar25 = param_2[1];
dVar14 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = *param_3;
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
uVar13 = param_3[1];
dVar30 = (double)(uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 |
(uVar25 & 0xff00) << 0x28 | uVar25 << 0x38);
if (dVar14 <= dVar15) {
dVar14 = dVar15;
}
dVar15 = (double)(uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 |
(uVar13 & 0xff00) << 0x28 | uVar13 << 0x38);
if (dVar15 <= dVar30) {
dVar30 = dVar15;
}
if (dVar30 <= dVar14) {
return 0.0;
}
dVar30 = dVar30 - dVar14;
break;
case 8:
uVar7 = (ushort)*param_3 << 8 | (ushort)*param_3 >> 8;
uVar19 = (uint)(ushort)((ushort)*param_2 << 8 | (ushort)*param_2 >> 8);
uVar10 = (uint)uVar7;
if (uVar7 < uVar19) {
uVar10 = uVar19;
}
uVar8 = (uint)(ushort)(*(ushort *)((long)param_2 + 2) << 8 |
*(ushort *)((long)param_2 + 2) >> 8);
uVar19 = (uint)(ushort)(*(ushort *)((long)param_3 + 2) << 8 |
*(ushort *)((long)param_3 + 2) >> 8);
if (uVar8 < uVar19) {
uVar19 = uVar8;
}
iVar9 = uVar19 - uVar10;
if (uVar19 < uVar10 || iVar9 == 0) {
return 0.0;
}
LAB_0018c9e1:
dVar30 = (double)iVar9;
break;
case 9:
uVar10 = (uint)*param_2;
uVar19 = *(uint *)((long)param_2 + 4);
uVar22 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar10 = (uint)*param_3;
uVar8 = *(uint *)((long)param_3 + 4);
uVar10 = uVar10 >> 0x18 | (uVar10 & 0xff0000) >> 8 | (uVar10 & 0xff00) << 8 | uVar10 << 0x18;
uVar23 = uVar19 >> 0x18 | (uVar19 & 0xff0000) >> 8 | (uVar19 & 0xff00) << 8 | uVar19 << 0x18;
uVar19 = uVar8 >> 0x18 | (uVar8 & 0xff0000) >> 8 | (uVar8 & 0xff00) << 8 | uVar8 << 0x18;
if (uVar10 < uVar22) {
uVar10 = uVar22;
}
if (uVar23 < uVar19) {
uVar19 = uVar23;
}
uVar25 = (ulong)(uVar19 - uVar10);
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
goto LAB_0018ca1f;
case 10:
case 0xb:
uVar13 = *param_2;
uVar25 = param_2[1];
uVar20 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar13 = *param_3;
uVar4 = param_3[1];
uVar27 = uVar13 >> 0x38 | (uVar13 & 0xff000000000000) >> 0x28 |
(uVar13 & 0xff0000000000) >> 0x18 | (uVar13 & 0xff00000000) >> 8 |
(uVar13 & 0xff000000) << 8 | (uVar13 & 0xff0000) << 0x18 | (uVar13 & 0xff00) << 0x28
| uVar13 << 0x38;
uVar25 = uVar25 >> 0x38 | (uVar25 & 0xff000000000000) >> 0x28 |
(uVar25 & 0xff0000000000) >> 0x18 | (uVar25 & 0xff00000000) >> 8 |
(uVar25 & 0xff000000) << 8 | (uVar25 & 0xff0000) << 0x18 | (uVar25 & 0xff00) << 0x28
| uVar25 << 0x38;
uVar13 = uVar4 >> 0x38 | (uVar4 & 0xff000000000000) >> 0x28 | (uVar4 & 0xff0000000000) >> 0x18
| (uVar4 & 0xff00000000) >> 8 | (uVar4 & 0xff000000) << 8 |
(uVar4 & 0xff0000) << 0x18 | (uVar4 & 0xff00) << 0x28 | uVar4 << 0x38;
if ((long)uVar27 < (long)uVar20) {
uVar27 = uVar20;
}
if ((long)uVar25 < (long)uVar13) {
uVar13 = uVar25;
}
uVar25 = uVar13 - uVar27;
if (uVar25 == 0 || (long)uVar13 < (long)uVar27) {
return 0.0;
}
LAB_0018ca1f:
dVar30 = (double)(long)uVar25;
break;
case 0xc:
uVar10 = (uint)(byte)*param_2 * 0x10000;
if ((char)(byte)*param_2 < '\0') {
uVar10 = (uVar10 + CONCAT11(*(byte *)((long)param_2 + 1),*(byte *)((long)param_2 + 2))) -
0x1000000;
}
else {
uVar10 = uVar10 | *(byte *)((long)param_2 + 2) | (uint)*(byte *)((long)param_2 + 1) << 8;
}
uVar19 = (uint)(byte)*param_3 * 0x10000;
if ((char)(byte)*param_3 < '\0') {
uVar19 = (uVar19 + CONCAT11(*(byte *)((long)param_3 + 1),*(byte *)((long)param_3 + 2))) -
0x1000000;
}
else {
uVar19 = uVar19 | *(byte *)((long)param_3 + 2) | (uint)*(byte *)((long)param_3 + 1) << 8;
}
uVar8 = (uint)*(byte *)((long)param_2 + 3) * 0x10000;
if ((char)*(byte *)((long)param_2 + 3) < '\0') {
uVar8 = (uVar8 + CONCAT11(*(byte *)((long)param_2 + 4),*(byte *)((long)param_2 + 5))) -
0x1000000;
}
else {
uVar8 = uVar8 | *(byte *)((long)param_2 + 5) | (uint)*(byte *)((long)param_2 + 4) << 8;
}
uVar22 = (uint)*(byte *)((long)param_3 + 3) * 0x10000;
if ((char)*(byte *)((long)param_3 + 3) < '\0') {
uVar22 = (uVar22 + CONCAT11(*(byte *)((long)param_3 + 4),*(byte *)((long)param_3 + 5))) -
0x1000000;
}
else {
uVar22 = uVar22 | *(byte *)((long)param_3 + 5) | (uint)*(byte *)((long)param_3 + 4) << 8;
}
if ((int)uVar19 < (int)uVar10) {
uVar19 = uVar10;
}
if ((int)uVar8 < (int)uVar22) {
uVar22 = uVar8;
}
if (uVar22 - uVar19 == 0 || (int)uVar22 < (int)uVar19) {
return 0.0;
}
dVar30 = (double)(int)(uVar22 - uVar19);
break;
case 0xd:
uVar8 = (uint)CONCAT12((byte)*param_2,
*(ushort *)((long)param_2 + 1) << 8 |
*(ushort *)((long)param_2 + 1) >> 8);
uVar10 = (uint)CONCAT12((byte)*param_3,
*(ushort *)((long)param_3 + 1) << 8 |
*(ushort *)((long)param_3 + 1) >> 8);
uVar22 = (uint)CONCAT12(*(byte *)((long)param_2 + 3),
*(ushort *)((long)param_2 + 4) << 8 |
*(ushort *)((long)param_2 + 4) >> 8);
uVar19 = (uint)CONCAT12(*(byte *)((long)param_3 + 3),
*(ushort *)((long)param_3 + 4) << 8 |
*(ushort *)((long)param_3 + 4) >> 8);
if (uVar10 < uVar8) {
uVar10 = uVar8;
}
if (uVar22 < uVar19) {
uVar19 = uVar22;
}
if (uVar19 < uVar10 || uVar19 - uVar10 == 0) {
return 0.0;
}
dVar30 = (double)(uVar19 - uVar10);
break;
case 0xe:
bVar2 = (byte)*param_2;
bVar3 = (byte)*param_3;
bVar6 = bVar3;
if ((char)bVar3 < (char)bVar2) {
bVar6 = bVar2;
}
cVar16 = bVar3 + 1;
if ((char)(bVar2 + 1) < (char)(bVar3 + 1)) {
cVar16 = bVar2 + 1;
}
if (cVar16 <= (char)bVar6) {
return 0.0;
}
uVar19 = (uint)cVar16;
uVar10 = (uint)(char)bVar6;
LAB_0018cae8:
dVar30 = (double)(int)(uVar19 - uVar10);
}
dVar29 = dVar29 * dVar30;
puVar1 = (ushort *)(puVar5 + -4);
uVar10 = (uint)*puVar1 * 2;
param_2 = (ulong *)((long)param_2 + (ulong)uVar10);
param_3 = (ulong *)((long)param_3 + (ulong)uVar10);
puVar5 = puVar5 + 0x40;
bVar28 = SBORROW4(param_4,uVar10);
param_4 = param_4 + (uint)*puVar1 * -2;
if (param_4 == 0 || bVar28 != param_4 < 0) {
return dVar29;
}
} while( true );
}
|
|
60,087
|
google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/bytestream.cc
|
void CheckedArrayByteSink::Append(const char* bytes, size_t n) {
size_t available = capacity_ - size_;
if (n > available) {
n = available;
overflowed_ = true;
}
if (n > 0 && bytes != (outbuf_ + size_)) {
// Catch cases where the pointer returned by GetAppendBuffer() was modified.
GOOGLE_DCHECK(!(outbuf_ <= bytes && bytes < (outbuf_ + capacity_)))
<< "Append() bytes[] overlaps with outbuf_[]";
memcpy(outbuf_ + size_, bytes, n);
}
size_ += n;
}
|
O0
|
cpp
|
google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long):
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rcx), %rax
subq 0x18(%rcx), %rax
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x78(%rsp), %rax
jbe 0x23bade
movq 0x20(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movb $0x1, 0x20(%rax)
cmpq $0x0, 0x80(%rsp)
jbe 0x23bc14
movq 0x20(%rsp), %rdx
movq 0x88(%rsp), %rax
movq 0x8(%rdx), %rcx
addq 0x18(%rdx), %rcx
cmpq %rcx, %rax
je 0x23bc14
jmp 0x23bb0d
xorl %eax, %eax
testb $0x1, %al
jne 0x23bb18
jmp 0x23bbf2
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x88(%rsp), %rcx
movb $0x0, 0x3f(%rsp)
cmpq %rcx, %rax
ja 0x23bb4d
movq 0x20(%rsp), %rdx
movq 0x88(%rsp), %rax
movq 0x8(%rdx), %rcx
addq 0x10(%rdx), %rcx
cmpq %rcx, %rax
jb 0x23bb4f
jmp 0x23bbb7
leaq 0x1aff02(%rip), %rdx # 0x3eba58
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x50, %ecx
callq 0x19a670
movq 0x10(%rsp), %rdi
movb $0x1, 0x3f(%rsp)
leaq 0x1affc6(%rip), %rsi # 0x3ebb46
callq 0x199f30
movq %rax, 0x18(%rsp)
jmp 0x23bb8c
movq 0x18(%rsp), %rdi
leaq 0x1afff3(%rip), %rsi # 0x3ebb8b
callq 0x199f30
movq %rax, 0x8(%rsp)
jmp 0x23bba4
movq 0x8(%rsp), %rsi
leaq 0x2b(%rsp), %rdi
callq 0x19a0e0
jmp 0x23bbb5
jmp 0x23bbb7
testb $0x1, 0x3f(%rsp)
jne 0x23bbc0
jmp 0x23bbca
leaq 0x40(%rsp), %rdi
callq 0x19a6b0
jmp 0x23bb0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x23bbe6
jmp 0x23bbf0
leaq 0x40(%rsp), %rdi
callq 0x19a6b0
jmp 0x23bc31
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
addq 0x18(%rax), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0x8b800
movq 0x20(%rsp), %rax
movq 0x80(%rsp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x90db0
nopl (%rax,%rax)
|
_ZN6google8protobuf7strings20CheckedArrayByteSink6AppendEPKcm:
sub rsp, 98h
mov [rsp+98h+var_8], rdi
mov [rsp+98h+var_10], rsi
mov [rsp+98h+var_18], rdx
mov rcx, [rsp+98h+var_8]
mov [rsp+98h+var_78], rcx
mov rax, [rcx+10h]
sub rax, [rcx+18h]
mov [rsp+98h+var_20], rax
mov rax, [rsp+98h+var_18]
cmp rax, [rsp+98h+var_20]
jbe short loc_23BADE
mov rax, [rsp+98h+var_78]
mov rcx, [rsp+98h+var_20]
mov [rsp+98h+var_18], rcx
mov byte ptr [rax+20h], 1
loc_23BADE:
cmp [rsp+98h+var_18], 0
jbe loc_23BC14
mov rdx, [rsp+98h+var_78]
mov rax, [rsp+98h+var_10]
mov rcx, [rdx+8]
add rcx, [rdx+18h]
cmp rax, rcx
jz loc_23BC14
jmp short $+2
loc_23BB0D:
xor eax, eax
test al, 1
jnz short loc_23BB18
jmp loc_23BBF2
loc_23BB18:
mov rax, [rsp+98h+var_78]
mov rax, [rax+8]
mov rcx, [rsp+98h+var_10]
mov [rsp+98h+var_59], 0
cmp rax, rcx
ja short loc_23BB4D
mov rdx, [rsp+98h+var_78]
mov rax, [rsp+98h+var_10]
mov rcx, [rdx+8]
add rcx, [rdx+10h]
cmp rax, rcx
jb short loc_23BB4F
loc_23BB4D:
jmp short loc_23BBB7
loc_23BB4F:
lea rdx, aWorkspaceLlm4b_51; "/workspace/llm4binary/github2025/aimrt_"...
lea rdi, [rsp+98h+var_58]
mov [rsp+98h+var_88], rdi
mov esi, 3
mov ecx, 50h ; 'P'
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
mov rdi, [rsp+98h+var_88]
mov [rsp+98h+var_59], 1
lea rsi, aCheckFailedOut_1; "CHECK failed: !(outbuf_ <= bytes && byt"...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_80], rax
jmp short $+2
loc_23BB8C:
mov rdi, [rsp+98h+var_80]
lea rsi, aAppendBytesOve; "Append() bytes[] overlaps with outbuf_["...
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
mov [rsp+98h+var_90], rax
jmp short $+2
loc_23BBA4:
mov rsi, [rsp+98h+var_90]
lea rdi, [rsp+98h+var_6D]
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
jmp short $+2
loc_23BBB5:
jmp short $+2
loc_23BBB7:
test [rsp+98h+var_59], 1
jnz short loc_23BBC0
jmp short loc_23BBCA
loc_23BBC0:
lea rdi, [rsp+98h+var_58]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_23BBCA:
jmp loc_23BB0D
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
test [rsp+arg_37], 1
jnz short loc_23BBE6
jmp short loc_23BBF0
loc_23BBE6:
lea rdi, [rsp+arg_38]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_23BBF0:
jmp short loc_23BC31
loc_23BBF2:
mov rax, [rsp+98h+var_78]
mov rdi, [rax+8]
add rdi, [rax+18h]
mov rsi, [rsp+98h+var_10]
mov rdx, [rsp+98h+var_18]
call _memcpy
loc_23BC14:
mov rax, [rsp+98h+var_78]
mov rcx, [rsp+98h+var_18]
add rcx, [rax+18h]
mov [rax+18h], rcx
add rsp, 98h
retn
loc_23BC31:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
|
google::protobuf::strings::CheckedArrayByteSink * google::protobuf::strings::CheckedArrayByteSink::Append(
google::protobuf::strings::CheckedArrayByteSink *this,
const char *a2,
unsigned long long a3)
{
google::protobuf::strings::CheckedArrayByteSink *result; // rax
unsigned long long v4; // [rsp+80h] [rbp-18h]
v4 = a3;
if ( a3 > *((_QWORD *)this + 2) - *((_QWORD *)this + 3) )
{
v4 = *((_QWORD *)this + 2) - *((_QWORD *)this + 3);
*((_BYTE *)this + 32) = 1;
}
if ( v4 && a2 != (const char *)(*((_QWORD *)this + 3) + *((_QWORD *)this + 1)) )
memcpy(*((_QWORD *)this + 3) + *((_QWORD *)this + 1), a2, v4);
result = this;
*((_QWORD *)this + 3) += v4;
return result;
}
| |||
60,088
|
google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/bytestream.cc
|
void CheckedArrayByteSink::Append(const char* bytes, size_t n) {
size_t available = capacity_ - size_;
if (n > available) {
n = available;
overflowed_ = true;
}
if (n > 0 && bytes != (outbuf_ + size_)) {
// Catch cases where the pointer returned by GetAppendBuffer() was modified.
GOOGLE_DCHECK(!(outbuf_ <= bytes && bytes < (outbuf_ + capacity_)))
<< "Append() bytes[] overlaps with outbuf_[]";
memcpy(outbuf_ + size_, bytes, n);
}
size_ += n;
}
|
O3
|
cpp
|
google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long):
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rax
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0xbc827
movb $0x1, 0x20(%rbx)
movq %rcx, %r14
testq %r14, %r14
je 0xbc844
movq 0x8(%rbx), %rdi
addq %rax, %rdi
cmpq %rsi, %rdi
je 0xbc844
movq %r14, %rdx
callq 0x2ceb0
movq 0x18(%rbx), %rax
addq %r14, %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN6google8protobuf7strings20CheckedArrayByteSink6AppendEPKcm:
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rdi
mov rcx, [rdi+10h]
mov rax, [rdi+18h]
sub rcx, rax
cmp rcx, rdx
jnb short loc_BC827
mov byte ptr [rbx+20h], 1
mov r14, rcx
loc_BC827:
test r14, r14
jz short loc_BC844
mov rdi, [rbx+8]
add rdi, rax
cmp rdi, rsi
jz short loc_BC844
mov rdx, r14
call _memcpy
mov rax, [rbx+18h]
loc_BC844:
add rax, r14
mov [rbx+18h], rax
add rsp, 8
pop rbx
pop r14
retn
|
long long google::protobuf::strings::CheckedArrayByteSink::Append(
google::protobuf::strings::CheckedArrayByteSink *this,
const char *a2,
unsigned long long a3)
{
unsigned long long v3; // r14
long long v5; // rax
unsigned long long v6; // rcx
const char *v7; // rdi
long long result; // rax
v3 = a3;
v5 = *((_QWORD *)this + 3);
v6 = *((_QWORD *)this + 2) - v5;
if ( v6 < a3 )
{
*((_BYTE *)this + 32) = 1;
v3 = v6;
}
if ( v3 )
{
v7 = (const char *)(v5 + *((_QWORD *)this + 1));
if ( v7 != a2 )
{
memcpy(v7);
v5 = *((_QWORD *)this + 3);
}
}
result = v3 + v5;
*((_QWORD *)this + 3) = result;
return result;
}
|
Append:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI + 0x18]
SUB RCX,RAX
CMP RCX,RDX
JNC 0x001bc827
MOV byte ptr [RBX + 0x20],0x1
MOV R14,RCX
LAB_001bc827:
TEST R14,R14
JZ 0x001bc844
MOV RDI,qword ptr [RBX + 0x8]
ADD RDI,RAX
CMP RDI,RSI
JZ 0x001bc844
MOV RDX,R14
CALL 0x0012ceb0
MOV RAX,qword ptr [RBX + 0x18]
LAB_001bc844:
ADD RAX,R14
MOV qword ptr [RBX + 0x18],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* google::protobuf::strings::CheckedArrayByteSink::Append(char const*, unsigned long) */
void __thiscall
google::protobuf::strings::CheckedArrayByteSink::Append
(CheckedArrayByteSink *this,char *param_1,ulong param_2)
{
long lVar1;
lVar1 = *(long *)(this + 0x18);
if ((ulong)(*(long *)(this + 0x10) - lVar1) < param_2) {
this[0x20] = (CheckedArrayByteSink)0x1;
param_2 = *(long *)(this + 0x10) - lVar1;
}
if ((param_2 != 0) && ((char *)(*(long *)(this + 8) + lVar1) != param_1)) {
memcpy((char *)(*(long *)(this + 8) + lVar1),param_1,param_2);
lVar1 = *(long *)(this + 0x18);
}
*(ulong *)(this + 0x18) = lVar1 + param_2;
return;
}
|
|
60,089
|
glfwPlatformGetWindowOpacity
|
untodesu[P]riteg/build_O3/_deps/glfw-src/src/x11_window.c
|
float _glfwPlatformGetWindowOpacity(_GLFWwindow* window)
{
float opacity = 1.f;
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.NET_WM_CM_Sx))
{
CARD32* value = NULL;
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_WM_WINDOW_OPACITY,
XA_CARDINAL,
(unsigned char**) &value))
{
opacity = (float) (*value / (double) 0xffffffffu);
}
if (value)
XFree(value);
}
return opacity;
}
|
O3
|
c
|
glfwPlatformGetWindowOpacity:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x84881(%rip), %r15 # 0xa8638
movq 0x1fec0(%r15), %rdi
movq 0x20488(%r15), %rsi
callq 0xcfd0
testq %rax, %rax
je 0x23e44
leaq 0x10(%rsp), %r14
movq $0x0, (%r14)
movq 0x348(%rbx), %rsi
movq 0x20480(%r15), %rdx
movq 0x1fec0(%r15), %rdi
leaq 0x18(%rsp), %rax
leaq 0x20(%rsp), %rbx
leaq 0xc(%rsp), %r10
leaq 0x28(%rsp), %r11
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %r14
pushq %rax
pushq %rbx
pushq %r10
pushq %r11
pushq $0x6
callq 0xc200
addq $0x30, %rsp
cmpq $0x0, (%rbx)
movq (%r14), %rdi
je 0x23e4e
movl (%rdi), %eax
cvtsi2sd %rax, %xmm0
divsd 0x61c32(%rip), %xmm0 # 0x85a70
cvtsd2ss %xmm0, %xmm0
jmp 0x23e5b
movss 0x42d88(%rip), %xmm0 # 0x66bd4
jmp 0x23e6c
movss 0x42d7e(%rip), %xmm0 # 0x66bd4
testq %rdi, %rdi
je 0x23e6c
movss %xmm0, 0x8(%rsp)
callq 0xcac0
movss 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
_glfwPlatformGetWindowOpacity:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
lea r15, _glfw
mov rdi, [r15+1FEC0h]
mov rsi, [r15+20488h]
call _XGetSelectionOwner
test rax, rax
jz short loc_23E44
lea r14, [rsp+48h+var_38]
mov qword ptr [r14], 0
mov rsi, [rbx+348h]
mov rdx, [r15+20480h]
mov rdi, [r15+1FEC0h]
lea rax, [rsp+48h+var_30]
lea rbx, [rsp+48h+var_28]
lea r10, [rsp+48h+var_3C]
lea r11, [rsp+48h+var_20]
mov r8, 7FFFFFFFFFFFFFFFh
xor ecx, ecx
xor r9d, r9d
push r14
push rax
push rbx
push r10
push r11
push 6
call _XGetWindowProperty
add rsp, 30h
cmp qword ptr [rbx], 0
mov rdi, [r14]
jz short loc_23E4E
mov eax, [rdi]
cvtsi2sd xmm0, rax
divsd xmm0, cs:qword_85A70
cvtsd2ss xmm0, xmm0
jmp short loc_23E5B
loc_23E44:
movss xmm0, cs:dword_66BD4
jmp short loc_23E6C
loc_23E4E:
movss xmm0, cs:dword_66BD4
test rdi, rdi
jz short loc_23E6C
loc_23E5B:
movss [rsp+48h+var_40], xmm0
call _XFree
movss xmm0, [rsp+48h+var_40]
loc_23E6C:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
|
float glfwPlatformGetWindowOpacity(long long a1)
{
float result; // xmm0_4
_BYTE v2[4]; // [rsp+Ch] [rbp-3Ch] BYREF
int *v3; // [rsp+10h] [rbp-38h] BYREF
_BYTE v4[8]; // [rsp+18h] [rbp-30h] BYREF
long long v5; // [rsp+20h] [rbp-28h] BYREF
_BYTE v6[32]; // [rsp+28h] [rbp-20h] BYREF
if ( !XGetSelectionOwner(*(_QWORD *)&glfw[32688], *(_QWORD *)&glfw[33058]) )
return 1.0;
v3 = 0LL;
XGetWindowProperty(
*(_QWORD *)&glfw[32688],
*(_QWORD *)(a1 + 840),
*(_QWORD *)&glfw[33056],
0LL,
0x7FFFFFFFFFFFFFFFLL,
0LL,
6LL,
v6,
v2,
&v5,
v4,
&v3);
if ( v5 )
{
result = (double)*v3 / 4294967295.0;
}
else
{
result = 1.0;
if ( !v3 )
return result;
}
XFree(v3);
return result;
}
|
_glfwPlatformGetWindowOpacity:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA R15,[0x1a8638]
MOV RDI,qword ptr [R15 + 0x1fec0]
MOV RSI,qword ptr [R15 + 0x20488]
CALL 0x0010cfd0
TEST RAX,RAX
JZ 0x00123e44
LEA R14,[RSP + 0x10]
MOV qword ptr [R14],0x0
MOV RSI,qword ptr [RBX + 0x348]
MOV RDX,qword ptr [R15 + 0x20480]
MOV RDI,qword ptr [R15 + 0x1fec0]
LEA RAX,[RSP + 0x18]
LEA RBX,[RSP + 0x20]
LEA R10,[RSP + 0xc]
LEA R11,[RSP + 0x28]
MOV R8,0x7fffffffffffffff
XOR ECX,ECX
XOR R9D,R9D
PUSH R14
PUSH RAX
PUSH RBX
PUSH R10
PUSH R11
PUSH 0x6
CALL 0x0010c200
ADD RSP,0x30
CMP qword ptr [RBX],0x0
MOV RDI,qword ptr [R14]
JZ 0x00123e4e
MOV EAX,dword ptr [RDI]
CVTSI2SD XMM0,RAX
DIVSD XMM0,qword ptr [0x00185a70]
CVTSD2SS XMM0,XMM0
JMP 0x00123e5b
LAB_00123e44:
MOVSS XMM0,dword ptr [0x00166bd4]
JMP 0x00123e6c
LAB_00123e4e:
MOVSS XMM0,dword ptr [0x00166bd4]
TEST RDI,RDI
JZ 0x00123e6c
LAB_00123e5b:
MOVSS dword ptr [RSP + 0x8],XMM0
CALL 0x0010cac0
MOVSS XMM0,dword ptr [RSP + 0x8]
LAB_00123e6c:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
float _glfwPlatformGetWindowOpacity(long param_1)
{
long lVar1;
float fVar2;
int1 local_3c [4];
uint *local_38;
int1 local_30 [8];
long local_28;
int1 local_20 [8];
lVar1 = XGetSelectionOwner(DAT_001c84f8,DAT_001c8ac0);
fVar2 = _DAT_00166bd4;
if (lVar1 != 0) {
local_38 = (uint *)0x0;
XGetWindowProperty(DAT_001c84f8,*(int8 *)(param_1 + 0x348),DAT_001c8ab8,0,
0x7fffffffffffffff,0,6,local_20,local_3c,&local_28,local_30,&local_38);
if (local_28 == 0) {
fVar2 = _DAT_00166bd4;
if (local_38 == (uint *)0x0) {
return _DAT_00166bd4;
}
}
else {
fVar2 = (float)((double)*local_38 / _DAT_00185a70);
}
XFree();
}
return fVar2;
}
|
|
60,090
|
uf_prespace
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_prespace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
bfill((uchar*) to,spaces,' ');
if (to+spaces != end)
decode_bytes(rec,bit_buff,to+spaces,end);
}
|
O0
|
c
|
uf_prespace:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbec2b
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x20bb4d(%rip), %rcx # 0x2ca770
andl (%rcx,%rdx,4), %eax
movl %eax, -0x28(%rbp)
jmp 0xbec3e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xbbe20
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
jbe 0xbec60
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
jmp 0xbec9e
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x2a2c0
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
cmpq -0x20(%rbp), %rax
je 0xbec9e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
addq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0xbdd80
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
uf_prespace_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BEC2B
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_28], eax
jmp short loc_BEC3E
loc_BEC2B:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_28], eax
loc_BEC3E:
mov ecx, [rbp+var_28]
mov [rbp+var_24], ecx
mov rax, [rbp+var_18]
mov ecx, ecx
add rax, rcx
cmp rax, [rbp+var_20]
jbe short loc_BEC60
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
jmp short loc_BEC9E
loc_BEC60:
mov rdi, [rbp+var_18]
mov eax, [rbp+var_24]
mov edx, eax
mov esi, 20h ; ' '
call _memset
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
add rax, rcx
cmp rax, [rbp+var_20]
jz short loc_BEC9E
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov eax, [rbp+var_24]
add rdx, rax
mov rcx, [rbp+var_20]
call decode_bytes_0
loc_BEC9E:
add rsp, 30h
pop rbp
retn
|
long long uf_prespace_0(long long a1, unsigned int *a2, long long a3, _BYTE *a4)
{
unsigned int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int bits_0; // [rsp+8h] [rbp-28h]
if ( a2[1] < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0(a2, *(_DWORD *)(a1 + 28));
}
else
{
v4 = *a2;
v5 = a2[1] - *(_DWORD *)(a1 + 28);
a2[1] = v5;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v4 >> v5);
}
if ( (unsigned long long)bits_0 + a3 <= (unsigned long long)a4 )
{
memset(a3, 32LL, bits_0);
result = bits_0 + a3;
if ( (_BYTE *)result != a4 )
return decode_bytes_0(a1, (long long)a2, (_BYTE *)(bits_0 + a3), a4);
}
else
{
result = (long long)a2;
a2[10] = 1;
}
return result;
}
|
uf_prespace:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
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 RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bec2b
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3ca770]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x001bec3e
LAB_001bec2b:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001bbe20
MOV dword ptr [RBP + -0x28],EAX
LAB_001bec3e:
MOV ECX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,ECX
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001bec60
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
JMP 0x001bec9e
LAB_001bec60:
MOV RDI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
MOV EDX,EAX
MOV ESI,0x20
CALL 0x0012a2c0
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x20]
JZ 0x001bec9e
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x24]
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x001bdd80
LAB_001bec9e:
ADD RSP,0x30
POP RBP
RET
|
void uf_prespace(long param_1,uint *param_2,void *param_3,ulong param_4)
{
uint uVar1;
uint local_30;
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_30 = fill_and_get_bits(param_2,*(int4 *)(param_1 + 0x1c));
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_30 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
if (param_4 < (long)param_3 + (ulong)local_30) {
param_2[10] = 1;
}
else {
memset(param_3,0x20,(ulong)local_30);
if ((long)param_3 + (ulong)local_30 != param_4) {
decode_bytes(param_1,param_2,(long)param_3 + (ulong)local_30,param_4);
}
}
return;
}
|
|
60,091
|
LefDefParser::lefiViaRule::propType(int) const
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiViaRule.cpp
|
char
lefiViaRule::propType(int i) const
{
char msg[160];
if (i < 0 || i >= numProps_) {
sprintf(msg, "ERROR (LEFPARS-1431): The index number %d given for the VIARULE PROPERTY is invalid.\nValid index is from 0 to %d", i, numProps_);
lefiError(0, 1431, msg);
return 0;
}
return types_[i];
}
|
O0
|
cpp
|
LefDefParser::lefiViaRule::propType(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x30c31
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x1d8(%rcx), %eax
jl 0x30c71
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x1d8(%rax), %ecx
leaq 0x49102(%rip), %rsi # 0x79d51
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x597, %esi # imm = 0x597
callq 0x3f4e0
movb $0x0, 0xc7(%rsp)
jmp 0x30c8f
movq 0x8(%rsp), %rax
movq 0x1f8(%rax), %rax
movslq 0xb4(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0xc7(%rsp)
movb 0xc7(%rsp), %al
addq $0xc8, %rsp
retq
nop
|
_ZNK12LefDefParser11lefiViaRule8propTypeEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_30C31
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+1D8h]
jl short loc_30C71
loc_30C31:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+1D8h]
lea rsi, aErrorLefpars14_11; "ERROR (LEFPARS-1431): The index number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 597h; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
mov [rsp+0C8h+var_1], 0
jmp short loc_30C8F
loc_30C71:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+1F8h]
movsxd rcx, [rsp+0C8h+var_14]
mov al, [rax+rcx]
mov [rsp+0C8h+var_1], al
loc_30C8F:
mov al, [rsp+0C8h+var_1]
add rsp, 0C8h
retn
|
char LefDefParser::lefiViaRule::propType(LefDefParser::lefiViaRule *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiViaRule *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 118) )
return *(_BYTE *)(*((_QWORD *)this + 63) + v5);
sprintf(
v4,
"ERROR (LEFPARS-1431): The index number %d given for the VIARULE PROPERTY is invalid.\nValid index is from 0 to %d",
v5,
*((_DWORD *)this + 118));
LefDefParser::lefiError(0LL, 1431, (int)v4, v2);
return 0;
}
|
propType:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x00130c31
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x1d8]
JL 0x00130c71
LAB_00130c31:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x1d8]
LEA RSI,[0x179d51]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x597
CALL 0x0013f4e0
MOV byte ptr [RSP + 0xc7],0x0
JMP 0x00130c8f
LAB_00130c71:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x1f8]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RSP + 0xc7],AL
LAB_00130c8f:
MOV AL,byte ptr [RSP + 0xc7]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiViaRule::propType(int) const */
int8 __thiscall LefDefParser::lefiViaRule::propType(lefiViaRule *this,int param_1)
{
int7 extraout_var;
int7 uVar1;
char local_b8 [164];
int local_14;
lefiViaRule *local_10;
int1 local_1;
if ((param_1 < 0) || (*(int *)(this + 0x1d8) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1431): The index number %d given for the VIARULE PROPERTY is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x1d8));
lefiError(0,0x597,local_b8);
local_1 = 0;
uVar1 = extraout_var;
}
else {
local_1 = *(int1 *)(*(long *)(this + 0x1f8) + (long)param_1);
uVar1 = (int7)((ulong)*(long *)(this + 0x1f8) >> 8);
}
return CONCAT71(uVar1,local_1);
}
|
|
60,092
|
coro::shared_mutex<coro::thread_pool>::unlock_shared()
|
AlayaLite/build_O3/_deps/libcoro-src/include/coro/shared_mutex.hpp
|
auto unlock_shared() -> void
{
std::unique_lock lk{m_mutex};
--m_shared_users;
// Only wake waiters from shared state if all shared users have completed.
if (m_shared_users == 0)
{
if (m_head_waiter != nullptr)
{
wake_waiters(lk);
}
else
{
m_state = state::unlocked;
}
}
}
|
O3
|
cpp
|
coro::shared_mutex<coro::thread_pool>::unlock_shared():
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x2e99c
movb $0x1, 0x8(%r14)
decq 0x40(%rbx)
jne 0x340bf
cmpq $0x0, 0x50(%rbx)
je 0x340b8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x340e6
jmp 0x340bf
movl $0x0, 0x38(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2e986
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2e986
movq %rbx, %rdi
callq 0x17740
|
_ZN4coro12shared_mutexINS_11thread_poolEE13unlock_sharedEv:
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
lea rax, [rdi+10h]
lea r14, [rsp+28h+var_20]
mov [r14], rax
mov byte ptr [r14+8], 0
mov rdi, r14
call _ZNSt11unique_lockISt5mutexE4lockEv; std::unique_lock<std::mutex>::lock(void)
mov byte ptr [r14+8], 1
dec qword ptr [rbx+40h]
jnz short loc_340BF
cmp qword ptr [rbx+50h], 0
jz short loc_340B8
lea rsi, [rsp+28h+var_20]
mov rdi, rbx
call _ZN4coro12shared_mutexINS_11thread_poolEE12wake_waitersERSt11unique_lockISt5mutexE; coro::shared_mutex<coro::thread_pool>::wake_waiters(std::unique_lock<std::mutex> &)
jmp short loc_340BF
loc_340B8:
mov dword ptr [rbx+38h], 0
loc_340BF:
lea rdi, [rsp+28h+var_20]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov rdi, rbx
call __Unwind_Resume
|
long long coro::shared_mutex<coro::thread_pool>::unlock_shared(long long a1)
{
long long result; // rax
long long v3; // [rsp+8h] [rbp-20h] BYREF
char v4; // [rsp+10h] [rbp-18h]
v3 = a1 + 16;
v4 = 0;
result = std::unique_lock<std::mutex>::lock(&v3);
v4 = 1;
if ( (*(_QWORD *)(a1 + 64))-- == 1LL )
{
if ( *(_QWORD *)(a1 + 80) )
result = coro::shared_mutex<coro::thread_pool>::wake_waiters(a1, &v3);
else
*(_DWORD *)(a1 + 56) = 0;
}
std::unique_lock<std::mutex>::~unique_lock((long long)&v3);
return result;
}
|
unlock_shared:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
LEA R14,[RSP + 0x8]
MOV qword ptr [R14],RAX
MOV byte ptr [R14 + 0x8],0x0
MOV RDI,R14
CALL 0x0012e99c
MOV byte ptr [R14 + 0x8],0x1
DEC qword ptr [RBX + 0x40]
JNZ 0x001340bf
CMP qword ptr [RBX + 0x50],0x0
JZ 0x001340b8
LAB_001340a9:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001340e6
LAB_001340b6:
JMP 0x001340bf
LAB_001340b8:
MOV dword ptr [RBX + 0x38],0x0
LAB_001340bf:
LEA RDI,[RSP + 0x8]
CALL 0x0012e986
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* coro::shared_mutex<coro::thread_pool>::unlock_shared() */
void __thiscall
coro::shared_mutex<coro::thread_pool>::unlock_shared(shared_mutex<coro::thread_pool> *this)
{
shared_mutex<coro::thread_pool> *psVar1;
shared_mutex<coro::thread_pool> *local_20;
int1 local_18;
local_20 = this + 0x10;
local_18 = 0;
std::unique_lock<std::mutex>::lock((unique_lock<std::mutex> *)&local_20);
local_18 = 1;
psVar1 = this + 0x40;
*(long *)psVar1 = *(long *)psVar1 + -1;
if (*(long *)psVar1 == 0) {
if (*(long *)(this + 0x50) == 0) {
*(int4 *)(this + 0x38) = 0;
}
else {
/* try { // try from 001340a9 to 001340b5 has its CatchHandler @ 001340d1 */
wake_waiters(this,(unique_lock *)&local_20);
}
}
std::unique_lock<std::mutex>::~unique_lock((unique_lock<std::mutex> *)&local_20);
return;
}
|
|
60,093
|
create_last_word_mask
|
eloqsql/mysys/my_bitmap.c
|
void create_last_word_mask(MY_BITMAP *map)
{
unsigned char const mask= invers_last_byte_mask(map->n_bits);
/*
The first bytes are to be set to zero since they represent real bits
in the bitvector. The last bytes are set to 0xFF since they represent
bytes not used by the bitvector. Finally the last byte contains bits
as set by the mask above.
*/
unsigned char *ptr= (unsigned char*)&map->last_word_mask;
map->last_word_ptr= map->bitmap + no_words_in_map(map)-1;
switch (no_bytes_in_map(map) & 3) {
case 1:
map->last_word_mask= ~0U;
ptr[0]= mask;
return;
case 2:
map->last_word_mask= ~0U;
ptr[0]= 0;
ptr[1]= mask;
return;
case 3:
map->last_word_mask= 0U;
ptr[2]= mask;
ptr[3]= 0xFFU;
return;
case 0:
map->last_word_mask= 0U;
ptr[3]= mask;
return;
}
}
|
O3
|
c
|
create_last_word_mask:
pushq %rbp
movq %rsp, %rbp
movl 0x1c(%rdi), %eax
leal 0x7(%rax), %ecx
movq (%rdi), %rdx
addl $0x1f, %eax
shrl $0x5, %eax
leaq (%rdx,%rax,4), %rax
addq $-0x4, %rax
movq %rax, 0x8(%rdi)
movl %ecx, %eax
shrl $0x3, %eax
andl $0x3, %eax
leaq 0x44656(%rip), %rdx # 0xe1edc
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl $0x0, 0x18(%rdi)
addq $0x1b, %rdi
jmp 0x9d8c0
movl $0xffffff00, 0x18(%rdi) # imm = 0xFFFFFF00
addq $0x19, %rdi
jmp 0x9d8c0
movl $0xff000000, 0x18(%rdi) # imm = 0xFF000000
addq $0x1a, %rdi
jmp 0x9d8c0
addq $0x18, %rdi
movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF
andb $0x7, %cl
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
shll %cl, %eax
movb %al, (%rdi)
popq %rbp
retq
|
create_last_word_mask:
push rbp
mov rbp, rsp
mov eax, [rdi+1Ch]
lea ecx, [rax+7]
mov rdx, [rdi]
add eax, 1Fh
shr eax, 5
lea rax, [rdx+rax*4]
add rax, 0FFFFFFFFFFFFFFFCh
mov [rdi+8], rax
mov eax, ecx
shr eax, 3
and eax, 3
lea rdx, jpt_9D88D
movsxd rax, ds:(jpt_9D88D - 0E1EDCh)[rdx+rax*4]; switch 4 cases
add rax, rdx
jmp rax; switch jump
loc_9D88F:
mov dword ptr [rdi+18h], 0; jumptable 000000000009D88D case 0
add rdi, 1Bh
jmp short loc_9D8C0
loc_9D89C:
mov dword ptr [rdi+18h], 0FFFFFF00h; jumptable 000000000009D88D case 2
add rdi, 19h
jmp short loc_9D8C0
loc_9D8A9:
mov dword ptr [rdi+18h], 0FF000000h; jumptable 000000000009D88D case 3
add rdi, 1Ah
jmp short loc_9D8C0
loc_9D8B6:
add rdi, 18h; jumptable 000000000009D88D case 1
mov dword ptr [rdi], 0FFFFFFFFh
loc_9D8C0:
and cl, 7
mov eax, 0FFFFFFFEh
shl eax, cl
mov [rdi], al
pop rbp
retn
|
long long create_last_word_mask(long long a1)
{
int v1; // eax
_DWORD *v2; // rdi
long long result; // rax
v1 = *(_DWORD *)(a1 + 28);
*(_QWORD *)(a1 + 8) = *(_QWORD *)a1 + 4LL * ((unsigned int)(v1 + 31) >> 5) - 4;
switch ( ((unsigned int)(v1 + 7) >> 3) & 3 )
{
case 0u:
*(_DWORD *)(a1 + 24) = 0;
v2 = (_DWORD *)(a1 + 27);
break;
case 1u:
v2 = (_DWORD *)(a1 + 24);
*v2 = -1;
break;
case 2u:
*(_DWORD *)(a1 + 24) = -256;
v2 = (_DWORD *)(a1 + 25);
break;
case 3u:
*(_DWORD *)(a1 + 24) = -16777216;
v2 = (_DWORD *)(a1 + 26);
break;
}
result = (unsigned int)(-2 << ((v1 + 7) & 7));
*(_BYTE *)v2 = result;
return result;
}
|
create_last_word_mask:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RDI + 0x1c]
LEA ECX,[RAX + 0x7]
MOV RDX,qword ptr [RDI]
ADD EAX,0x1f
SHR EAX,0x5
LEA RAX,[RDX + RAX*0x4]
ADD RAX,-0x4
MOV qword ptr [RDI + 0x8],RAX
MOV EAX,ECX
SHR EAX,0x3
AND EAX,0x3
LEA RDX,[0x1e1edc]
MOVSXD RAX,dword ptr [RDX + RAX*0x4]
ADD RAX,RDX
switchD:
JMP RAX
caseD_0:
MOV dword ptr [RDI + 0x18],0x0
ADD RDI,0x1b
JMP 0x0019d8c0
caseD_2:
MOV dword ptr [RDI + 0x18],0xffffff00
ADD RDI,0x19
JMP 0x0019d8c0
caseD_3:
MOV dword ptr [RDI + 0x18],0xff000000
ADD RDI,0x1a
JMP 0x0019d8c0
caseD_1:
ADD RDI,0x18
MOV dword ptr [RDI],0xffffffff
LAB_0019d8c0:
AND CL,0x7
MOV EAX,0xfffffffe
SHL EAX,CL
MOV byte ptr [RDI],AL
POP RBP
RET
|
void create_last_word_mask(long *param_1)
{
uint uVar1;
uVar1 = *(int *)((long)param_1 + 0x1c) + 7;
param_1[1] = *param_1 + (ulong)(*(int *)((long)param_1 + 0x1c) + 0x1fU >> 5) * 4 + -4;
switch(uVar1 >> 3 & 3) {
case 0:
*(int4 *)(param_1 + 3) = 0;
param_1 = (long *)((long)param_1 + 0x1b);
break;
case 1:
param_1 = param_1 + 3;
*(int4 *)param_1 = 0xffffffff;
break;
case 2:
*(int4 *)(param_1 + 3) = 0xffffff00;
param_1 = (long *)((long)param_1 + 0x19);
break;
case 3:
*(int4 *)(param_1 + 3) = 0xff000000;
param_1 = (long *)((long)param_1 + 0x1a);
}
*(char *)param_1 = (char)(-2 << ((byte)uVar1 & 7));
return;
}
|
|
60,094
|
mysql_store_result_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_store_result_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_store_result,
(parms->mysql),
parms->mysql,
MYSQL_RES *,
r_ptr)
}
|
O3
|
c
|
mysql_store_result_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1b3f5
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_store_result_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_store_result
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_store_result_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
long long result; // rax
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_store_result(v1);
*(_QWORD *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
|
mysql_store_result_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011b3f5
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_store_result_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_store_result();
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
|
|
60,095
|
common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&)
|
monkey531[P]llama/common/common.cpp
|
void common_set_adapter_lora(struct llama_context * ctx, std::vector<common_adapter_lora_info> & lora) {
llama_clear_adapter_lora(ctx);
for (auto & la : lora) {
if (la.scale != 0.0f) {
llama_set_adapter_lora(ctx, la.ptr, la.scale);
}
}
}
|
O2
|
cpp
|
common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x239c0
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x55e6a
movss 0x20(%r15), %xmm0
ucomiss 0x5bad4(%rip), %xmm0 # 0xb1928
jne 0x55e58
jnp 0x55e64
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x239a0
addq $0x30, %r15
jmp 0x55e42
popq %rbx
popq %r14
popq %r15
retq
|
_Z23common_set_adapter_loraP13llama_contextRSt6vectorI24common_adapter_lora_infoSaIS2_EE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
call _llama_clear_adapter_lora
mov r15, [r14]
mov r14, [r14+8]
loc_55E42:
cmp r15, r14
jz short loc_55E6A
movss xmm0, dword ptr [r15+20h]
ucomiss xmm0, cs:dword_B1928
jnz short loc_55E58
jnp short loc_55E64
loc_55E58:
mov rsi, [r15+28h]
mov rdi, rbx
call _llama_set_adapter_lora
loc_55E64:
add r15, 30h ; '0'
jmp short loc_55E42
loc_55E6A:
pop rbx
pop r14
pop r15
retn
|
long long common_set_adapter_lora(long long a1, long long *a2)
{
long long result; // rax
long long v3; // r15
long long v4; // r14
result = llama_clear_adapter_lora();
v3 = *a2;
v4 = a2[1];
while ( v3 != v4 )
{
if ( *(float *)(v3 + 32) != 0.0 )
result = llama_set_adapter_lora(a1, *(_QWORD *)(v3 + 40));
v3 += 48LL;
}
return result;
}
|
common_set_adapter_lora:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CALL 0x001239c0
MOV R15,qword ptr [R14]
MOV R14,qword ptr [R14 + 0x8]
LAB_00155e42:
CMP R15,R14
JZ 0x00155e6a
MOVSS XMM0,dword ptr [R15 + 0x20]
UCOMISS XMM0,dword ptr [0x001b1928]
JNZ 0x00155e58
JNP 0x00155e64
LAB_00155e58:
MOV RSI,qword ptr [R15 + 0x28]
MOV RDI,RBX
CALL 0x001239a0
LAB_00155e64:
ADD R15,0x30
JMP 0x00155e42
LAB_00155e6a:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info,
std::allocator<common_adapter_lora_info> >&) */
void common_set_adapter_lora(llama_context *param_1,vector *param_2)
{
long lVar1;
long lVar2;
llama_clear_adapter_lora();
lVar1 = *(long *)(param_2 + 8);
for (lVar2 = *(long *)param_2; lVar2 != lVar1; lVar2 = lVar2 + 0x30) {
if ((*(float *)(lVar2 + 0x20) != _DAT_001b1928) ||
(NAN(*(float *)(lVar2 + 0x20)) || NAN(_DAT_001b1928))) {
llama_set_adapter_lora(param_1,*(int8 *)(lVar2 + 0x28));
}
}
return;
}
|
|
60,096
|
insert_dynamic
|
eloqsql/mysys/array.c
|
my_bool insert_dynamic(DYNAMIC_ARRAY *array, const void * element)
{
void *buffer;
if (array->elements == array->max_element)
{ /* Call only when necessary */
if (!(buffer=alloc_dynamic(array)))
return TRUE;
}
else
{
buffer=array->buffer+(array->elements * array->size_of_element);
array->elements++;
}
memcpy(buffer,element,(size_t) array->size_of_element);
return FALSE;
}
|
O3
|
c
|
insert_dynamic:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jne 0x32c91
movq %r14, %rdi
callq 0x32cb8
testq %rax, %rax
je 0x32cb4
movq %rax, %rdi
movl 0x14(%r14), %eax
jmp 0x32ca3
movl 0x14(%r14), %eax
movl %eax, %edi
imull %ecx, %edi
addq (%r14), %rdi
incl %ecx
movl %ecx, 0x8(%r14)
movl %eax, %edx
movq %rbx, %rsi
callq 0x24290
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb $0x1, %al
jmp 0x32caf
|
insert_dynamic:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov ecx, [rdi+8]
cmp ecx, [rdi+0Ch]
jnz short loc_32C91
mov rdi, r14
call alloc_dynamic
test rax, rax
jz short loc_32CB4
mov rdi, rax
mov eax, [r14+14h]
jmp short loc_32CA3
loc_32C91:
mov eax, [r14+14h]
mov edi, eax
imul edi, ecx
add rdi, [r14]
inc ecx
mov [r14+8], ecx
loc_32CA3:
mov edx, eax
mov rsi, rbx
call _memcpy
xor eax, eax
loc_32CAF:
pop rbx
pop r14
pop rbp
retn
loc_32CB4:
mov al, 1
jmp short loc_32CAF
|
long long insert_dynamic(long long a1, long long a2)
{
int v3; // ecx
long long v4; // rax
long long v5; // rdi
v3 = *(_DWORD *)(a1 + 8);
if ( v3 != *(_DWORD *)(a1 + 12) )
{
v5 = *(_QWORD *)a1 + (unsigned int)(v3 * *(_DWORD *)(a1 + 20));
*(_DWORD *)(a1 + 8) = v3 + 1;
goto LABEL_5;
}
v4 = alloc_dynamic(a1);
if ( v4 )
{
v5 = v4;
LABEL_5:
memcpy(v5, a2);
return 0LL;
}
return 1LL;
}
|
insert_dynamic:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ECX,dword ptr [RDI + 0x8]
CMP ECX,dword ptr [RDI + 0xc]
JNZ 0x00132c91
MOV RDI,R14
CALL 0x00132cb8
TEST RAX,RAX
JZ 0x00132cb4
MOV RDI,RAX
MOV EAX,dword ptr [R14 + 0x14]
JMP 0x00132ca3
LAB_00132c91:
MOV EAX,dword ptr [R14 + 0x14]
MOV EDI,EAX
IMUL EDI,ECX
ADD RDI,qword ptr [R14]
INC ECX
MOV dword ptr [R14 + 0x8],ECX
LAB_00132ca3:
MOV EDX,EAX
MOV RSI,RBX
CALL 0x00124290
XOR EAX,EAX
LAB_00132caf:
POP RBX
POP R14
POP RBP
RET
LAB_00132cb4:
MOV AL,0x1
JMP 0x00132caf
|
int8 insert_dynamic(long *param_1,void *param_2)
{
int iVar1;
uint uVar2;
void *__dest;
iVar1 = (int)param_1[1];
if (iVar1 == *(int *)((long)param_1 + 0xc)) {
__dest = (void *)alloc_dynamic(param_1);
if (__dest == (void *)0x0) {
return 1;
}
uVar2 = *(uint *)((long)param_1 + 0x14);
}
else {
uVar2 = *(uint *)((long)param_1 + 0x14);
__dest = (void *)((ulong)(uVar2 * iVar1) + *param_1);
*(int *)(param_1 + 1) = iVar1 + 1;
}
memcpy(__dest,param_2,(ulong)uVar2);
return 0;
}
|
|
60,097
|
LefDefParser::defiFPC::Init()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiFPC.cpp
|
void defiFPC::Init() {
name_ = 0;
nameLength_ = 0;
namesAllocated_ = 0;
namesUsed_ = 0;
names_ = 0;
rowOrComp_ = 0;
clear();
}
|
O0
|
cpp
|
LefDefParser::defiFPC::Init():
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movq $0x0, (%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x28(%rdi)
callq 0x33640
popq %rax
retq
nopl (%rax)
|
_ZN12LefDefParser7defiFPC4InitEv:
push rax
mov [rsp+8+var_8], rdi
mov rdi, [rsp+8+var_8]; this
mov qword ptr [rdi], 0
mov dword ptr [rdi+8], 0
mov dword ptr [rdi+20h], 0
mov dword ptr [rdi+24h], 0
mov qword ptr [rdi+30h], 0
mov qword ptr [rdi+28h], 0
call _ZN12LefDefParser7defiFPC5clearEv; LefDefParser::defiFPC::clear(void)
pop rax
retn
|
LefDefParser::defiFPC * LefDefParser::defiFPC::Init(LefDefParser::defiFPC *this)
{
*(_QWORD *)this = 0LL;
*((_DWORD *)this + 2) = 0;
*((_DWORD *)this + 8) = 0;
*((_DWORD *)this + 9) = 0;
*((_QWORD *)this + 6) = 0LL;
*((_QWORD *)this + 5) = 0LL;
LefDefParser::defiFPC::clear(this);
return this;
}
|
Init:
PUSH RAX
MOV qword ptr [RSP],RDI
MOV RDI,qword ptr [RSP]
MOV qword ptr [RDI],0x0
MOV dword ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0x20],0x0
MOV dword ptr [RDI + 0x24],0x0
MOV qword ptr [RDI + 0x30],0x0
MOV qword ptr [RDI + 0x28],0x0
CALL 0x00133640
POP RAX
RET
|
/* LefDefParser::defiFPC::Init() */
defiFPC * __thiscall LefDefParser::defiFPC::Init(defiFPC *this)
{
*(int8 *)this = 0;
*(int4 *)(this + 8) = 0;
*(int4 *)(this + 0x20) = 0;
*(int4 *)(this + 0x24) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x28) = 0;
clear(this);
return this;
}
|
|
60,098
|
init_re_comp(regex_t*, char const*)
|
eloqsql/client/mysqltest.cc
|
void init_re_comp(regex_t *re, const char* str)
{
int err= regcomp(re, str, (REG_EXTENDED | REG_ICASE | REG_NOSUB | REG_DOTALL));
if (err)
{
char erbuf[100];
size_t len= regerror(err, re, erbuf, sizeof(erbuf));
die("error %s, %d/%d `%s'\n",
re_eprint(err), (int)len, (int)sizeof(erbuf), erbuf);
}
}
|
O0
|
cpp
|
init_re_comp(regex_t*, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x78(%rbp)
movq %rsi, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl $0x31, %edx
callq 0xcb050
movl %eax, -0x84(%rbp)
cmpl $0x0, -0x84(%rbp)
je 0x7111e
movl -0x84(%rbp), %edi
movq -0x78(%rbp), %rsi
leaq -0x70(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movl $0x64, %ecx
callq 0xcaf60
movq %rax, -0x90(%rbp)
movl -0x84(%rbp), %edi
callq 0x71020
movq %rax, -0xa0(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x94(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x71139
movq -0xa8(%rbp), %r8
movl -0x94(%rbp), %edx
movq -0xa0(%rbp), %rsi
leaq 0xdc88e(%rip), %rdi # 0x14d9a0
movl $0x64, %ecx
movb $0x0, %al
callq 0x62b40
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x71139
addq $0xb0, %rsp
popq %rbp
retq
callq 0x60310
nop
|
_Z12init_re_compP7regex_tPKc:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rdi, [rbp+var_78]
mov rsi, [rbp+var_80]
mov edx, 31h ; '1'
call pcre2_regcomp
mov [rbp+var_84], eax
cmp [rbp+var_84], 0
jz short loc_7111E
mov edi, [rbp+var_84]
mov rsi, [rbp+var_78]
lea rdx, [rbp+var_70]
mov [rbp+var_A8], rdx
mov ecx, 64h ; 'd'
call pcre2_regerror
mov [rbp+var_90], rax
mov edi, [rbp+var_84]; int
call _Z9re_eprinti; re_eprint(int)
mov [rbp+var_A0], rax
mov eax, dword ptr [rbp+var_90]
mov [rbp+var_94], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_71139
mov r8, [rbp+var_A8]
mov edx, [rbp+var_94]
mov rsi, [rbp+var_A0]
lea rdi, aErrorSDDS; "error %s, %d/%d `%s'\n"
mov ecx, 64h ; 'd'
mov al, 0
call _ZL3diePKcz; die(char const*,...)
loc_7111E:
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_71139
add rsp, 0B0h
pop rbp
retn
loc_71139:
call ___stack_chk_fail
|
unsigned long long init_re_comp(long long a1, long long a2)
{
const char *v3; // [rsp+10h] [rbp-A0h]
int v4; // [rsp+20h] [rbp-90h]
unsigned int v5; // [rsp+2Ch] [rbp-84h]
char v6[104]; // [rsp+40h] [rbp-70h] BYREF
unsigned long long v7; // [rsp+A8h] [rbp-8h]
v7 = __readfsqword(0x28u);
v5 = pcre2_regcomp(a1, a2, 49LL);
if ( v5 )
{
v4 = pcre2_regerror(v5, a1, v6, 100LL);
v3 = (const char *)re_eprint(v5);
die("error %s, %d/%d `%s'\n", v3, v4, 100, v6);
}
return __readfsqword(0x28u);
}
|
init_re_comp:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RDI,qword ptr [RBP + -0x78]
MOV RSI,qword ptr [RBP + -0x80]
MOV EDX,0x31
CALL 0x001cb050
MOV dword ptr [RBP + -0x84],EAX
CMP dword ptr [RBP + -0x84],0x0
JZ 0x0017111e
MOV EDI,dword ptr [RBP + -0x84]
MOV RSI,qword ptr [RBP + -0x78]
LEA RDX,[RBP + -0x70]
MOV qword ptr [RBP + -0xa8],RDX
MOV ECX,0x64
CALL 0x001caf60
MOV qword ptr [RBP + -0x90],RAX
MOV EDI,dword ptr [RBP + -0x84]
CALL 0x00171020
MOV qword ptr [RBP + -0xa0],RAX
MOV EAX,dword ptr [RBP + -0x90]
MOV dword ptr [RBP + -0x94],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00171139
MOV R8,qword ptr [RBP + -0xa8]
MOV EDX,dword ptr [RBP + -0x94]
MOV RSI,qword ptr [RBP + -0xa0]
LEA RDI,[0x24d9a0]
MOV ECX,0x64
MOV AL,0x0
CALL 0x00162b40
LAB_0017111e:
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00171139
ADD RSP,0xb0
POP RBP
RET
LAB_00171139:
CALL 0x00160310
|
/* init_re_comp(regex_t*, char const*) */
void init_re_comp(regex_t *param_1,char *param_2)
{
int iVar1;
ulong uVar2;
int8 uVar3;
long in_FS_OFFSET;
int1 local_78 [104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
iVar1 = pcre2_regcomp(param_1,param_2,0x31);
if (iVar1 != 0) {
uVar2 = pcre2_regerror(iVar1,param_1,local_78,100);
uVar3 = re_eprint(iVar1);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) goto LAB_00171139;
die("error %s, %d/%d `%s\'\n",uVar3,uVar2 & 0xffffffff,100,local_78);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return;
}
LAB_00171139:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
60,099
|
allocate_dynamic
|
eloqsql/mysys/array.c
|
my_bool allocate_dynamic(DYNAMIC_ARRAY *array, uint max_elements)
{
DBUG_ENTER("allocate_dynamic");
if (max_elements >= array->max_element)
{
uint size;
uchar *new_ptr;
size= (max_elements + array->alloc_increment)/array->alloc_increment;
size*= array->alloc_increment;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this senerio, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (uchar *) my_malloc(array->m_psi_key, size *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr= (uchar*) my_realloc(array->m_psi_key,
array->buffer,size *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(TRUE);
array->buffer= new_ptr;
array->max_element= size;
}
DBUG_RETURN(FALSE);
}
|
O0
|
c
|
allocate_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x3be55
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x10(%rcx)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x3bdfe
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0x36e60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3bdc3
jmp 0x3bdba
movb $0x0, -0x1(%rbp)
jmp 0x3be5b
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x25260
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x3be40
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0x37030
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3be3e
jmp 0x3be38
movb $0x1, -0x1(%rbp)
jmp 0x3be5b
jmp 0x3be40
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x3be57
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
allocate_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jb loc_3BE55
mov eax, [rbp+var_14]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
xor edx, edx
div dword ptr [rcx+10h]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov eax, [rax+10h]
imul eax, [rbp+var_18]
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz short loc_3BDFE
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_3BDC3
jmp short $+2
loc_3BDBA:
mov [rbp+var_1], 0
jmp loc_3BE5B
loc_3BDC3:
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_3BE40
loc_3BDFE:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov eax, [rbp+var_18]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_3BE3E
jmp short $+2
loc_3BE38:
mov [rbp+var_1], 1
jmp short loc_3BE5B
loc_3BE3E:
jmp short $+2
loc_3BE40:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax+0Ch], ecx
loc_3BE55:
jmp short $+2
loc_3BE57:
mov [rbp+var_1], 0
loc_3BE5B:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char allocate_dynamic(long long *a1, unsigned int a2)
{
long long v3; // [rsp+0h] [rbp-20h]
unsigned int v4; // [rsp+8h] [rbp-18h]
if ( a2 < *((_DWORD *)a1 + 3) )
return 0;
v4 = (*((_DWORD *)a1 + 4) + a2) / *((_DWORD *)a1 + 4) * *((_DWORD *)a1 + 4);
if ( (a1[4] & 0x100) == 0 )
{
v3 = my_realloc(*((_DWORD *)a1 + 6), *a1, *((_DWORD *)a1 + 5) * v4, *((_BYTE *)a1 + 32) | 0x50u);
if ( !v3 )
return 1;
goto LABEL_8;
}
v3 = my_malloc(*((_DWORD *)a1 + 6), *((_DWORD *)a1 + 5) * v4, *((_DWORD *)a1 + 8) | 0x10u);
if ( v3 )
{
memcpy(v3, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * *((_DWORD *)a1 + 2)));
a1[4] &= 0xFFFFFEFFuLL;
LABEL_8:
*a1 = v3;
*((_DWORD *)a1 + 3) = v4;
return 0;
}
return 0;
}
|
allocate_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JC 0x0013be55
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV dword ptr [RCX + 0x10]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
IMUL EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x0013bdfe
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x00136e60
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0013bdc3
JMP 0x0013bdba
LAB_0013bdba:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0013be5b
LAB_0013bdc3:
MOV RDI,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x00125260
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x0013be40
LAB_0013bdfe:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x00137030
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x0013be3e
JMP 0x0013be38
LAB_0013be38:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013be5b
LAB_0013be3e:
JMP 0x0013be40
LAB_0013be40:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xc],ECX
LAB_0013be55:
JMP 0x0013be57
LAB_0013be57:
MOV byte ptr [RBP + -0x1],0x0
LAB_0013be5b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 allocate_dynamic(int8 *param_1,uint param_2)
{
int iVar1;
void *local_28;
if (*(uint *)((long)param_1 + 0xc) <= param_2) {
iVar1 = *(int *)(param_1 + 2) * ((param_2 + *(int *)(param_1 + 2)) / *(uint *)(param_1 + 2));
if ((param_1[4] & 0x100) == 0) {
local_28 = (void *)my_realloc(*(int4 *)(param_1 + 3),*param_1,
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_28 == (void *)0x0) {
return 1;
}
}
else {
local_28 = (void *)my_malloc(*(int4 *)(param_1 + 3),
iVar1 * *(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_28 == (void *)0x0) {
return 0;
}
memcpy(local_28,(void *)*param_1,
(ulong)(uint)(*(int *)(param_1 + 1) * *(int *)((long)param_1 + 0x14)));
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = local_28;
*(int *)((long)param_1 + 0xc) = iVar1;
}
return 0;
}
|
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.