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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
17,700
|
js_promise_resolve
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_promise_resolve(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue result_promise, resolving_funcs[2], ret;
BOOL is_reject = magic;
if (!JS_IsObject(this_val))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (!is_reject && JS_GetOpaque(argv[0], JS_CLASS_PROMISE)) {
JSValue ctor;
BOOL is_same;
ctor = JS_GetProperty(ctx, argv[0], JS_ATOM_constructor);
if (JS_IsException(ctor))
return ctor;
is_same = js_same_value(ctx, ctor, this_val);
JS_FreeValue(ctx, ctor);
if (is_same)
return js_dup(argv[0]);
}
result_promise = js_new_promise_capability(ctx, resolving_funcs, this_val);
if (JS_IsException(result_promise))
return result_promise;
ret = JS_Call(ctx, resolving_funcs[is_reject], JS_UNDEFINED, 1, argv);
JS_FreeValue(ctx, resolving_funcs[0]);
JS_FreeValue(ctx, resolving_funcs[1]);
if (JS_IsException(ret)) {
JS_FreeValue(ctx, result_promise);
return ret;
}
JS_FreeValue(ctx, ret);
return result_promise;
}
|
O0
|
c
|
js_promise_resolve:
subq $0xf8, %rsp
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rdi, 0xd0(%rsp)
movl %ecx, 0xcc(%rsp)
movq %r8, 0xc0(%rsp)
movl %r9d, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
movl %eax, 0x6c(%rsp)
movq 0xd8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0x29cb0
cmpl $0x0, %eax
jne 0x918ad
movq 0xd0(%rsp), %rdi
callq 0x2e2e0
movq %rax, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
jmp 0x91b7a
cmpl $0x0, 0x6c(%rsp)
jne 0x919c1
movq 0xc0(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
movl $0x31, %edx
callq 0x37090
cmpq $0x0, %rax
je 0x919c1
movq 0xd0(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movl $0x3d, %ecx
callq 0x28ac0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x9194d
movq 0x58(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0x91b7a
movq 0xd0(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0xd8(%rsp), %rcx
movq 0xe0(%rsp), %r8
callq 0x34850
movl %eax, 0x54(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x229d0
cmpl $0x0, 0x54(%rsp)
je 0x919bf
movq 0xc0(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x20410
movq %rax, 0xe8(%rsp)
movq %rdx, 0xf0(%rsp)
jmp 0x91b7a
jmp 0x919c1
movq 0xd0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0xe0(%rsp), %rcx
callq 0x52500
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x91a49
movq 0xa8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0x91b7a
movq 0xd0(%rsp), %rdi
movslq 0x6c(%rsp), %rax
leaq 0x80(%rsp), %rcx
shlq $0x4, %rax
addq %rax, %rcx
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0xc0(%rsp), %rax
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x38d90
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0xd0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x229d0
movq 0xd0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x229d0
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x22a00
cmpl $0x0, %eax
je 0x91b43
movq 0xd0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
callq 0x229d0
movq 0x70(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0xf0(%rsp)
jmp 0x91b7a
movq 0xd0(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x229d0
movq 0xa8(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xe8(%rsp), %rax
movq 0xf0(%rsp), %rdx
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_promise_resolve:
sub rsp, 0F8h
mov [rsp+0F8h+var_20], rsi
mov [rsp+0F8h+var_18], rdx
mov [rsp+0F8h+var_28], rdi
mov [rsp+0F8h+var_2C], ecx
mov [rsp+0F8h+var_38], r8
mov [rsp+0F8h+var_3C], r9d
mov eax, [rsp+0F8h+var_3C]
mov [rsp+0F8h+var_8C], eax
mov rdi, [rsp+0F8h+var_20]
mov rsi, [rsp+0F8h+var_18]
call JS_IsObject
cmp eax, 0
jnz short loc_918AD
mov rdi, [rsp+0F8h+var_28]
call JS_ThrowTypeErrorNotAnObject
mov [rsp+0F8h+var_10], rax
mov [rsp+0F8h+var_8], rdx
jmp loc_91B7A
loc_918AD:
cmp [rsp+0F8h+var_8C], 0
jnz loc_919C1
mov rax, [rsp+0F8h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
mov edx, 31h ; '1'
call JS_GetOpaque
cmp rax, 0
jz loc_919C1
mov rdi, [rsp+0F8h+var_28]
mov rax, [rsp+0F8h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
mov ecx, 3Dh ; '='
call JS_GetProperty
mov [rsp+0F8h+var_B8], rax
mov [rsp+0F8h+var_B0], rdx
mov rax, [rsp+0F8h+var_B8]
mov [rsp+0F8h+var_A0], rax
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_98], rax
mov rdi, [rsp+0F8h+var_A0]
mov rsi, [rsp+0F8h+var_98]
call JS_IsException_1
cmp eax, 0
jz short loc_9194D
mov rax, [rsp+0F8h+var_A0]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_8], rax
jmp loc_91B7A
loc_9194D:
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_A0]
mov rdx, [rsp+0F8h+var_98]
mov rcx, [rsp+0F8h+var_20]
mov r8, [rsp+0F8h+var_18]
call js_same_value
mov [rsp+0F8h+var_A4], eax
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_A0]
mov rdx, [rsp+0F8h+var_98]
call JS_FreeValue
cmp [rsp+0F8h+var_A4], 0
jz short loc_919BF
mov rax, [rsp+0F8h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov [rsp+0F8h+var_10], rax
mov [rsp+0F8h+var_8], rdx
jmp loc_91B7A
loc_919BF:
jmp short $+2
loc_919C1:
mov rdi, [rsp+0F8h+var_28]
lea rsi, [rsp+0F8h+var_78]
mov rdx, [rsp+0F8h+var_20]
mov rcx, [rsp+0F8h+var_18]
call js_new_promise_capability
mov [rsp+0F8h+var_C8], rax
mov [rsp+0F8h+var_C0], rdx
mov rax, [rsp+0F8h+var_C8]
mov [rsp+0F8h+var_50], rax
mov rax, [rsp+0F8h+var_C0]
mov [rsp+0F8h+var_48], rax
mov rdi, [rsp+0F8h+var_50]
mov rsi, [rsp+0F8h+var_48]
call JS_IsException_1
cmp eax, 0
jz short loc_91A49
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_48]
mov [rsp+0F8h+var_8], rax
jmp loc_91B7A
loc_91A49:
mov rdi, [rsp+0F8h+var_28]
movsxd rax, [rsp+0F8h+var_8C]
lea rcx, [rsp+0F8h+var_78]
shl rax, 4
add rcx, rax
mov dword ptr [rsp+0F8h+var_E8], 0
mov [rsp+0F8h+var_E0], 3
mov rax, [rsp+0F8h+var_38]
mov rsi, [rcx]
mov rdx, [rcx+8]
mov rcx, [rsp+0F8h+var_E8]
mov r8, [rsp+0F8h+var_E0]
mov r9d, 1
mov [rsp+0F8h+var_F8], rax
call JS_Call
mov [rsp+0F8h+var_D8], rax
mov [rsp+0F8h+var_D0], rdx
mov rax, [rsp+0F8h+var_D8]
mov [rsp+0F8h+var_88], rax
mov rax, [rsp+0F8h+var_D0]
mov [rsp+0F8h+var_80], rax
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_78]
mov rdx, [rsp+0F8h+var_70]
call JS_FreeValue
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_68]
mov rdx, [rsp+0F8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0F8h+var_88]
mov rsi, [rsp+0F8h+var_80]
call JS_IsException_1
cmp eax, 0
jz short loc_91B43
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_50]
mov rdx, [rsp+0F8h+var_48]
call JS_FreeValue
mov rax, [rsp+0F8h+var_88]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_8], rax
jmp short loc_91B7A
loc_91B43:
mov rdi, [rsp+0F8h+var_28]
mov rsi, [rsp+0F8h+var_88]
mov rdx, [rsp+0F8h+var_80]
call JS_FreeValue
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_10], rax
mov rax, [rsp+0F8h+var_48]
mov [rsp+0F8h+var_8], rax
loc_91B7A:
mov rax, [rsp+0F8h+var_10]
mov rdx, [rsp+0F8h+var_8]
add rsp, 0F8h
retn
|
long long js_promise_resolve(
long long a1,
_DWORD *a2,
unsigned long long a3,
int a4,
long long *a5,
int a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
double a11,
double a12,
__m128 a13,
__m128 a14)
{
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
long long v22; // rdx
long long v23; // rdx
long long v24; // rdx
long long v25; // rdx
long long v26; // rdx
long long v28; // [rsp+20h] [rbp-D8h]
_DWORD *Property; // [rsp+40h] [rbp-B8h]
int v30; // [rsp+54h] [rbp-A4h]
long long v31; // [rsp+60h] [rbp-98h]
long long v33; // [rsp+78h] [rbp-80h]
long long v34[5]; // [rsp+80h] [rbp-78h] BYREF
long long v35; // [rsp+A8h] [rbp-50h]
long long v36; // [rsp+B0h] [rbp-48h]
int v37; // [rsp+BCh] [rbp-3Ch]
long long *v38; // [rsp+C0h] [rbp-38h]
int v39; // [rsp+CCh] [rbp-2Ch]
long long v40; // [rsp+D0h] [rbp-28h]
_DWORD *v41; // [rsp+D8h] [rbp-20h]
unsigned long long v42; // [rsp+E0h] [rbp-18h]
long long v43; // [rsp+E8h] [rbp-10h]
long long v44; // [rsp+F0h] [rbp-8h]
v41 = a2;
v42 = a3;
v40 = a1;
v39 = a4;
v38 = a5;
v37 = a6;
if ( JS_IsObject((long long)a2, a3) )
{
if ( !a6 && JS_GetOpaque(*v38, v38[1], 49) )
{
Property = (_DWORD *)JS_GetProperty(v40, *v38, v38[1], 61);
v31 = v23;
if ( JS_IsException_1((long long)Property, v23) )
{
v43 = (long long)Property;
v44 = v31;
return v43;
}
v30 = js_same_value(v40, Property, v31, v41, v42);
JS_FreeValue(v40, (long long)Property, v31);
if ( v30 )
{
v43 = (long long)js_dup((_DWORD *)*v38, v38[1]);
v44 = v24;
return v43;
}
}
v35 = js_new_promise_capability(
v40,
(long long)v34,
(long long)v41,
v42,
a7,
a8,
a9,
a10,
*(double *)v20.m128_u64,
*(double *)v21.m128_u64,
a13,
a14);
v36 = v25;
if ( JS_IsException_1(v35, v25) )
{
v43 = v35;
v44 = v36;
}
else
{
v28 = JS_Call(v40, v34[2 * a6], v34[2 * a6 + 1], 0, 3, 1, (long long)v38);
v33 = v26;
JS_FreeValue(v40, v34[0], v34[1]);
JS_FreeValue(v40, v34[2], v34[3]);
if ( JS_IsException_1(v28, v33) )
{
JS_FreeValue(v40, v35, v36);
v43 = v28;
v44 = v33;
}
else
{
JS_FreeValue(v40, v28, v33);
v43 = v35;
v44 = v36;
}
}
}
else
{
v43 = JS_ThrowTypeErrorNotAnObject(v40, a7, a8, a9, a10, v20, v21, a13, a14, a3, v16, v17, v18, v19);
v44 = v22;
}
return v43;
}
|
js_promise_resolve:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xd8],RSI
MOV qword ptr [RSP + 0xe0],RDX
MOV qword ptr [RSP + 0xd0],RDI
MOV dword ptr [RSP + 0xcc],ECX
MOV qword ptr [RSP + 0xc0],R8
MOV dword ptr [RSP + 0xbc],R9D
MOV EAX,dword ptr [RSP + 0xbc]
MOV dword ptr [RSP + 0x6c],EAX
MOV RDI,qword ptr [RSP + 0xd8]
MOV RSI,qword ptr [RSP + 0xe0]
CALL 0x00129cb0
CMP EAX,0x0
JNZ 0x001918ad
MOV RDI,qword ptr [RSP + 0xd0]
CALL 0x0012e2e0
MOV qword ptr [RSP + 0xe8],RAX
MOV qword ptr [RSP + 0xf0],RDX
JMP 0x00191b7a
LAB_001918ad:
CMP dword ptr [RSP + 0x6c],0x0
JNZ 0x001919c1
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
MOV EDX,0x31
CALL 0x00137090
CMP RAX,0x0
JZ 0x001919c1
MOV RDI,qword ptr [RSP + 0xd0]
MOV RAX,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV ECX,0x3d
CALL 0x00128ac0
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x60],RAX
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x60]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x0019194d
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x00191b7a
LAB_0019194d:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0xd8]
MOV R8,qword ptr [RSP + 0xe0]
CALL 0x00134850
MOV dword ptr [RSP + 0x54],EAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
CALL 0x001229d0
CMP dword ptr [RSP + 0x54],0x0
JZ 0x001919bf
MOV RAX,qword ptr [RSP + 0xc0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00120410
MOV qword ptr [RSP + 0xe8],RAX
MOV qword ptr [RSP + 0xf0],RDX
JMP 0x00191b7a
LAB_001919bf:
JMP 0x001919c1
LAB_001919c1:
MOV RDI,qword ptr [RSP + 0xd0]
LEA RSI,[RSP + 0x80]
MOV RDX,qword ptr [RSP + 0xd8]
MOV RCX,qword ptr [RSP + 0xe0]
CALL 0x00152500
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xb0],RAX
MOV RDI,qword ptr [RSP + 0xa8]
MOV RSI,qword ptr [RSP + 0xb0]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00191a49
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x00191b7a
LAB_00191a49:
MOV RDI,qword ptr [RSP + 0xd0]
MOVSXD RAX,dword ptr [RSP + 0x6c]
LEA RCX,[RSP + 0x80]
SHL RAX,0x4
ADD RCX,RAX
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RAX,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RCX]
MOV RDX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RSP + 0x10]
MOV R8,qword ptr [RSP + 0x18]
MOV R9D,0x1
MOV qword ptr [RSP],RAX
CALL 0x00138d90
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x70],RAX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x001229d0
MOV RDI,qword ptr [RSP + 0x70]
MOV RSI,qword ptr [RSP + 0x78]
CALL 0x00122a00
CMP EAX,0x0
JZ 0x00191b43
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0xa8]
MOV RDX,qword ptr [RSP + 0xb0]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0xf0],RAX
JMP 0x00191b7a
LAB_00191b43:
MOV RDI,qword ptr [RSP + 0xd0]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x78]
CALL 0x001229d0
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0xe8],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0xf0],RAX
LAB_00191b7a:
MOV RAX,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xf0]
ADD RSP,0xf8
RET
|
int1 [16]
js_promise_resolve(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5,int param_6)
{
int iVar1;
long lVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
uint uStack_e4;
int8 local_78 [5];
int1 local_50 [16];
int local_3c;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
local_3c = param_6;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar1 = JS_IsObject(param_2,param_3);
if (iVar1 == 0) {
auVar5 = JS_ThrowTypeErrorNotAnObject(local_28);
return auVar5;
}
if ((param_6 == 0) && (lVar2 = JS_GetOpaque(*local_38,local_38[1],0x31), lVar2 != 0)) {
auVar5 = JS_GetProperty(local_28,*local_38,local_38[1],0x3d);
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
iVar1 = JS_IsException(uVar3,uVar4);
if (iVar1 != 0) {
return auVar5;
}
iVar1 = js_same_value(local_28,uVar3,uVar4,local_20,local_18);
JS_FreeValue(local_28,uVar3,uVar4);
if (iVar1 != 0) {
auVar5 = js_dup(*local_38,local_38[1]);
return auVar5;
}
}
local_50 = js_new_promise_capability(local_28,local_78,local_20,local_18);
iVar1 = JS_IsException(local_50._0_8_,local_50._8_8_);
if (iVar1 == 0) {
auVar5 = JS_Call(local_28,local_78[(long)param_6 * 2],local_78[(long)param_6 * 2 + 1],
(ulong)uStack_e4 << 0x20,3,1,local_38);
JS_FreeValue(local_28,local_78[0],local_78[1]);
JS_FreeValue(local_28,local_78[2],local_78[3]);
iVar1 = JS_IsException(auVar5._0_8_,auVar5._8_8_);
if (iVar1 == 0) {
JS_FreeValue(local_28,auVar5._0_8_,auVar5._8_8_);
}
else {
JS_FreeValue(local_28,local_50._0_8_,local_50._8_8_);
local_50 = auVar5;
}
}
return local_50;
}
|
|
17,701
|
ha_blackhole::rnd_next(unsigned char*)
|
eloqsql/storage/blackhole/ha_blackhole.cc
|
int ha_blackhole::rnd_next(uchar *buf)
{
int rc;
DBUG_ENTER("ha_blackhole::rnd_next");
THD *thd= ha_thd();
if (is_row_based_replication(thd))
rc= 0;
else
rc= HA_ERR_END_OF_FILE;
DBUG_RETURN(rc);
}
|
O0
|
cpp
|
ha_blackhole::rnd_next(unsigned char*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x72b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79d0
testb $0x1, %al
jne 0x7acc
jmp 0x7ad5
movl $0x0, -0x14(%rbp)
jmp 0x7adc
movl $0x89, -0x14(%rbp)
jmp 0x7ade
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_ZN12ha_blackhole8rnd_nextEPh:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; this
call __ZNK7handler6ha_thdEv; handler::ha_thd(void)
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
call _ZL24is_row_based_replicationP3THD; is_row_based_replication(THD *)
test al, 1
jnz short loc_7ACC
jmp short loc_7AD5
loc_7ACC:
mov [rbp+var_14], 0
jmp short loc_7ADC
loc_7AD5:
mov [rbp+var_14], 89h
loc_7ADC:
jmp short $+2
loc_7ADE:
mov eax, [rbp+var_14]
add rsp, 20h
pop rbp
retn
|
long long ha_blackhole::rnd_next(ha_blackhole *this, unsigned __int8 *a2)
{
long long v3; // [rsp+0h] [rbp-20h]
v3 = handler::ha_thd(this);
if ( is_row_based_replication(v3) )
return 0;
else
return 137;
}
|
rnd_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001072b0
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001079d0
TEST AL,0x1
JNZ 0x00107acc
JMP 0x00107ad5
LAB_00107acc:
MOV dword ptr [RBP + -0x14],0x0
JMP 0x00107adc
LAB_00107ad5:
MOV dword ptr [RBP + -0x14],0x89
LAB_00107adc:
JMP 0x00107ade
LAB_00107ade:
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x20
POP RBP
RET
|
/* ha_blackhole::rnd_next(unsigned char*) */
int4 ha_blackhole::rnd_next(uchar *param_1)
{
THD *pTVar1;
ulong uVar2;
int4 local_1c;
pTVar1 = (THD *)handler::ha_thd();
uVar2 = is_row_based_replication(pTVar1);
if ((uVar2 & 1) == 0) {
local_1c = 0x89;
}
else {
local_1c = 0;
}
return local_1c;
}
|
|
17,702
|
my_mb_wc_gbk
|
eloqsql/strings/ctype-gbk.c
|
static int
my_mb_wc_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
hi=s[0];
if (hi<0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gbk_uni_onechar( (hi<<8) + s[1])))
return -2;
return 2;
}
|
O3
|
c
|
my_mb_wc_gbk:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x386b1
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x38635
movq %rdi, (%rsi)
movl $0x1, %eax
jmp 0x386b1
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x386b1
movzbl %dil, %ecx
xorl %eax, %eax
cmpl $0x80, %ecx
je 0x386b1
cmpl $0xff, %ecx
je 0x386b1
movzbl 0x1(%rdx), %edx
leal -0x7f(%rdx), %edi
cmpb $-0x3f, %dil
setb %dil
cmpb $-0x1, %dl
setge %r8b
testb %dil, %r8b
jne 0x386b1
shll $0x8, %ecx
leal (%rcx,%rdx), %eax
addl $0xffff7ec0, %eax # imm = 0xFFFF7EC0
cmpl $0x7d10, %eax # imm = 0x7D10
jae 0x386a5
movl %eax, %eax
leaq 0x1457c1(%rip), %rcx # 0x17de50
movzwl (%rcx,%rax,2), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x386b1
jmp 0x386ac
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
|
my_mb_wc_gbk:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb loc_386B1
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_38635
mov [rsi], rdi
mov eax, 1
jmp short loc_386B1
loc_38635:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_386B1
movzx ecx, dil
xor eax, eax
cmp ecx, 80h
jz short loc_386B1
cmp ecx, 0FFh
jz short loc_386B1
movzx edx, byte ptr [rdx+1]
lea edi, [rdx-7Fh]
cmp dil, 0C1h
setb dil
cmp dl, 0FFh
setnl r8b
test r8b, dil
jnz short loc_386B1
shl ecx, 8
lea eax, [rcx+rdx]
add eax, 0FFFF7EC0h
cmp eax, 7D10h
jnb short loc_386A5
mov eax, eax
lea rcx, tab_gbk_uni0
movzx eax, word ptr [rcx+rax*2]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_386B1
jmp short loc_386AC
loc_386A5:
mov qword ptr [rsi], 0
loc_386AC:
mov eax, 0FFFFFFFEh
loc_386B1:
pop rbp
retn
|
long long my_mb_wc_gbk(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // edx
unsigned int v7; // eax
long long v8; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)v5 != 128 && (unsigned __int8)v5 != 255 )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 - 127) >= 0xC1u || (char)v6 < -1 )
{
v7 = ((unsigned __int8)v5 << 8) + v6 - 33088;
if ( v7 >= 0x7D10 )
{
*a2 = 0LL;
}
else
{
v8 = tab_gbk_uni0[v7];
*a2 = v8;
result = 2LL;
if ( (_WORD)v8 )
return result;
}
return 4294967294LL;
}
}
}
}
return result;
}
|
my_mb_wc_gbk:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001386b1
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x00138635
MOV qword ptr [RSI],RDI
MOV EAX,0x1
JMP 0x001386b1
LAB_00138635:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001386b1
MOVZX ECX,DIL
XOR EAX,EAX
CMP ECX,0x80
JZ 0x001386b1
CMP ECX,0xff
JZ 0x001386b1
MOVZX EDX,byte ptr [RDX + 0x1]
LEA EDI,[RDX + -0x7f]
CMP DIL,0xc1
SETC DIL
CMP DL,0xff
SETGE R8B
TEST R8B,DIL
JNZ 0x001386b1
SHL ECX,0x8
LEA EAX,[RCX + RDX*0x1]
ADD EAX,0xffff7ec0
CMP EAX,0x7d10
JNC 0x001386a5
MOV EAX,EAX
LEA RCX,[0x27de50]
MOVZX EAX,word ptr [RCX + RAX*0x2]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x001386b1
JMP 0x001386ac
LAB_001386a5:
MOV qword ptr [RSI],0x0
LAB_001386ac:
MOV EAX,0xfffffffe
LAB_001386b1:
POP RBP
RET
|
int8 my_mb_wc_gbk(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
uint uVar4;
int8 uVar5;
uVar5 = 0xffffff9b;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((long)(char)bVar1 < 0) {
uVar5 = 0xffffff9a;
if ((((param_3 + 2 <= param_4) && (uVar5 = 0, bVar1 != 0x80)) && (bVar1 != 0xff)) &&
(bVar2 = param_3[1], (char)bVar2 < -1 || 0xc0 < (byte)(bVar2 + 0x81))) {
uVar4 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0x8140;
if (uVar4 < 0x7d10) {
uVar3 = *(ushort *)(&tab_gbk_uni0 + (ulong)uVar4 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 != 0) {
return 2;
}
}
else {
*param_2 = 0;
}
uVar5 = 0xfffffffe;
}
}
else {
*param_2 = (long)(char)bVar1;
uVar5 = 1;
}
}
return uVar5;
}
|
|
17,703
|
slide_hash
|
3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/deflate.c
|
local void slide_hash(s)
deflate_state *s;
{
unsigned n, m;
Posf *p;
uInt wsize = s->w_size;
n = s->hash_size;
p = &s->head[n];
do {
m = *--p;
*p = (Pos)(m >= wsize ? m - wsize : NIL);
} while (--n);
n = wsize;
#ifndef FASTEST
p = &s->prev[n];
do {
m = *--p;
*p = (Pos)(m >= wsize ? m - wsize : NIL);
/* If n is not on any hash chain, prev[n] is garbage but
* its value will never be used.
*/
} while (--n);
#endif
}
|
O3
|
c
|
slide_hash:
movl 0x50(%rdi), %eax
movl 0x84(%rdi), %ecx
movq 0x78(%rdi), %rdx
leaq (%rdx,%rcx,2), %rdx
addq $-0x2, %rdx
xorl %esi, %esi
movzwl (%rdx), %r8d
subl %eax, %r8d
cmovbl %esi, %r8d
movw %r8w, (%rdx)
addq $-0x2, %rdx
decl %ecx
jne 0x5581
movq 0x70(%rdi), %rcx
leaq (%rcx,%rax,2), %rcx
addq $-0x2, %rcx
xorl %edx, %edx
movl %eax, %esi
movzwl (%rcx), %edi
subl %eax, %edi
cmovbl %edx, %edi
movw %di, (%rcx)
addq $-0x2, %rcx
decl %esi
jne 0x55a8
retq
|
slide_hash:
mov eax, [rdi+50h]
mov ecx, [rdi+84h]
mov rdx, [rdi+78h]
lea rdx, [rdx+rcx*2]
add rdx, 0FFFFFFFFFFFFFFFEh
xor esi, esi
loc_5581:
movzx r8d, word ptr [rdx]
sub r8d, eax
cmovb r8d, esi
mov [rdx], r8w
add rdx, 0FFFFFFFFFFFFFFFEh
dec ecx
jnz short loc_5581
mov rcx, [rdi+70h]
lea rcx, [rcx+rax*2]
add rcx, 0FFFFFFFFFFFFFFFEh
xor edx, edx
mov esi, eax
loc_55A8:
movzx edi, word ptr [rcx]
sub edi, eax
cmovb edi, edx
mov [rcx], di
add rcx, 0FFFFFFFFFFFFFFFEh
dec esi
jnz short loc_55A8
retn
|
long long slide_hash(long long a1)
{
long long result; // rax
long long v2; // rcx
_WORD *v3; // rdx
unsigned int v4; // r8d
bool v5; // cf
__int16 v6; // r8
_WORD *v7; // rcx
int v8; // esi
unsigned int v9; // edi
__int16 v10; // di
result = *(unsigned int *)(a1 + 80);
v2 = *(unsigned int *)(a1 + 132);
v3 = (_WORD *)(*(_QWORD *)(a1 + 120) + 2 * v2 - 2);
do
{
v4 = (unsigned __int16)*v3;
v5 = v4 < (unsigned int)result;
v6 = v4 - result;
if ( v5 )
v6 = 0;
*v3-- = v6;
LODWORD(v2) = v2 - 1;
}
while ( (_DWORD)v2 );
v7 = (_WORD *)(*(_QWORD *)(a1 + 112) + 2 * result - 2);
v8 = result;
do
{
v9 = (unsigned __int16)*v7;
v5 = v9 < (unsigned int)result;
v10 = v9 - result;
if ( v5 )
v10 = 0;
*v7-- = v10;
--v8;
}
while ( v8 );
return result;
}
|
slide_hash:
MOV EAX,dword ptr [RDI + 0x50]
MOV ECX,dword ptr [RDI + 0x84]
MOV RDX,qword ptr [RDI + 0x78]
LEA RDX,[RDX + RCX*0x2]
ADD RDX,-0x2
XOR ESI,ESI
LAB_00105581:
MOVZX R8D,word ptr [RDX]
SUB R8D,EAX
CMOVC R8D,ESI
MOV word ptr [RDX],R8W
ADD RDX,-0x2
DEC ECX
JNZ 0x00105581
MOV RCX,qword ptr [RDI + 0x70]
LEA RCX,[RCX + RAX*0x2]
ADD RCX,-0x2
XOR EDX,EDX
MOV ESI,EAX
LAB_001055a8:
MOVZX EDI,word ptr [RCX]
SUB EDI,EAX
CMOVC EDI,EDX
MOV word ptr [RCX],DI
ADD RCX,-0x2
DEC ESI
JNZ 0x001055a8
RET
|
void slide_hash(long param_1)
{
uint uVar1;
uint uVar2;
ulong uVar3;
ushort *puVar4;
ushort uVar5;
uVar1 = *(uint *)(param_1 + 0x50);
uVar3 = (ulong)*(uint *)(param_1 + 0x84);
puVar4 = (ushort *)(*(long *)(param_1 + 0x78) + uVar3 * 2);
do {
puVar4 = puVar4 + -1;
uVar5 = *puVar4 - (short)uVar1;
if (*puVar4 < uVar1) {
uVar5 = 0;
}
*puVar4 = uVar5;
uVar2 = (int)uVar3 - 1;
uVar3 = (ulong)uVar2;
} while (uVar2 != 0);
puVar4 = (ushort *)(*(long *)(param_1 + 0x70) + (ulong)uVar1 * 2);
uVar2 = uVar1;
do {
puVar4 = puVar4 + -1;
uVar5 = *puVar4 - (short)uVar1;
if (*puVar4 < uVar1) {
uVar5 = 0;
}
*puVar4 = uVar5;
uVar2 = uVar2 - 1;
} while (uVar2 != 0);
return;
}
|
|
17,704
|
delete_finrec_weakref
|
bluesky950520[P]quickjs/quickjs.c
|
static void delete_finrec_weakref(JSRuntime *rt, JSFinRecEntry *fre)
{
JSWeakRefRecord **pwr, *wr;
pwr = get_first_weak_ref(fre->target);
for(;;) {
wr = *pwr;
assert(wr != NULL);
if (wr->kind == JS_WEAK_REF_KIND_FINALIZATION_REGISTRY_ENTRY && wr->u.fin_rec_entry == fre)
break;
pwr = &wr->next_weak_ref;
}
*pwr = wr->next_weak_ref;
js_free_rt(rt, wr);
}
|
O1
|
c
|
delete_finrec_weakref:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x20(%rsi), %xmm0
movl 0x28(%rsi), %eax
movsd %xmm0, (%rsp)
cmpl $-0x8, %eax
je 0x84368
cmpl $-0x1, %eax
jne 0x843bc
movq (%rsp), %rax
addq $0x28, %rax
jmp 0x84379
movq (%rsp), %rax
addq $0x10, %rax
jmp 0x84379
addq $0x8, %r14
movq %r14, %rax
movq (%rax), %r14
cmpl $0x2, (%r14)
jne 0x84372
cmpq %rsi, 0x10(%r14)
jne 0x84372
movq 0x8(%r14), %rcx
movq %rcx, (%rax)
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x10(%rbx), %rcx
movq 0x30(%rbx), %rdx
subq %rax, %rdx
addq $-0x8, %rdx
movq %rdx, 0x30(%rbx)
movq 0x40(%rbx), %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
callq 0xe090
|
delete_finrec_weakref:
push r14
push rbx
push rax
mov rbx, rdi
movsd xmm0, qword ptr [rsi+20h]
mov eax, [rsi+28h]
movsd [rsp+18h+var_18], xmm0
cmp eax, 0FFFFFFF8h
jz short loc_84368
cmp eax, 0FFFFFFFFh
jnz short loc_843BC
mov rax, [rsp+18h+var_18]
add rax, 28h ; '('
jmp short loc_84379
loc_84368:
mov rax, [rsp+18h+var_18]
add rax, 10h
jmp short loc_84379
loc_84372:
add r14, 8
mov rax, r14
loc_84379:
mov r14, [rax]
cmp dword ptr [r14], 2
jnz short loc_84372
cmp [r14+10h], rsi
jnz short loc_84372
mov rcx, [r14+8]
mov [rax], rcx
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+10h]
mov rdx, [rbx+30h]
sub rdx, rax
add rdx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rdx
mov rdi, [rbx+40h]
mov rsi, r14
add rsp, 8
pop rbx
pop r14
jmp rcx
loc_843BC:
call _abort
|
long long delete_finrec_weakref(long long a1, long long a2)
{
int v2; // eax
_QWORD *v3; // rax
_DWORD *v4; // r14
long long v5; // rax
long long ( *v6)(_QWORD, _DWORD *); // rcx
long long v8; // [rsp+0h] [rbp-18h]
v2 = *(_DWORD *)(a2 + 40);
v8 = *(_QWORD *)(a2 + 32);
if ( v2 == -8 )
{
v3 = (_QWORD *)(v8 + 16);
}
else
{
if ( v2 != -1 )
abort((const char *)a1);
v3 = (_QWORD *)(v8 + 40);
}
while ( 1 )
{
v4 = (_DWORD *)*v3;
if ( *(_DWORD *)*v3 == 2 && *((_QWORD *)v4 + 2) == a2 )
break;
v3 = v4 + 2;
}
*v3 = *((_QWORD *)v4 + 1);
--*(_QWORD *)(a1 + 40);
v5 = (*(long long ( **)(_DWORD *))(a1 + 32))(v4);
v6 = *(long long ( **)(_QWORD, _DWORD *))(a1 + 16);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v5 - 8;
return v6(*(_QWORD *)(a1 + 64), v4);
}
|
delete_finrec_weakref:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOVSD XMM0,qword ptr [RSI + 0x20]
MOV EAX,dword ptr [RSI + 0x28]
MOVSD qword ptr [RSP],XMM0
CMP EAX,-0x8
JZ 0x00184368
CMP EAX,-0x1
JNZ 0x001843bc
MOV RAX,qword ptr [RSP]
ADD RAX,0x28
JMP 0x00184379
LAB_00184368:
MOV RAX,qword ptr [RSP]
ADD RAX,0x10
JMP 0x00184379
LAB_00184372:
ADD R14,0x8
MOV RAX,R14
LAB_00184379:
MOV R14,qword ptr [RAX]
CMP dword ptr [R14],0x2
JNZ 0x00184372
CMP qword ptr [R14 + 0x10],RSI
JNZ 0x00184372
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [RAX],RCX
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x10]
MOV RDX,qword ptr [RBX + 0x30]
SUB RDX,RAX
ADD RDX,-0x8
MOV qword ptr [RBX + 0x30],RDX
MOV RDI,qword ptr [RBX + 0x40]
MOV RSI,R14
ADD RSP,0x8
POP RBX
POP R14
JMP RCX
LAB_001843bc:
CALL 0x0010e090
|
void delete_finrec_weakref(long param_1,long param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
if (*(int *)(param_2 + 0x28) == -8) {
piVar2 = (int *)(*(long *)(param_2 + 0x20) + 0x10);
}
else {
if (*(int *)(param_2 + 0x28) != -1) {
/* WARNING: Subroutine does not return */
abort();
}
piVar2 = (int *)(*(long *)(param_2 + 0x20) + 0x28);
}
while ((piVar1 = *(int **)piVar2, *piVar1 != 2 || (*(long *)(piVar1 + 4) != param_2))) {
piVar2 = piVar1 + 2;
}
*(int8 *)piVar2 = *(int8 *)(piVar1 + 2);
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(piVar1);
lVar3 = (*(long *)(param_1 + 0x30) - lVar3) + -8;
*(long *)(param_1 + 0x30) = lVar3;
/* WARNING: Could not recover jumptable at 0x001843ba. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x10))
(*(int8 *)(param_1 + 0x40),piVar1,lVar3,*(code **)(param_1 + 0x10));
return;
}
|
|
17,705
|
find_export_entry
|
bluesky950520[P]quickjs/quickjs.c
|
static JSExportEntry *find_export_entry(JSContext *ctx, const JSModuleDef *m,
JSAtom export_name)
{
JSExportEntry *me;
int i;
for(i = 0; i < m->export_entries_count; i++) {
me = &m->export_entries[i];
if (me->export_name == export_name)
return me;
}
return NULL;
}
|
O2
|
c
|
find_export_entry:
movl 0x30(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
shlq $0x5, %rcx
pushq $-0x20
popq %rdx
leaq 0x20(%rdx), %r8
cmpq %r8, %rcx
je 0x2913c
movq 0x28(%rdi), %r9
cmpl %esi, 0x38(%r9,%rdx)
movq %r8, %rdx
jne 0x2911f
addq %r8, %r9
movq %r9, %rax
retq
|
find_export_entry:
mov ecx, [rdi+30h]
xor eax, eax
test ecx, ecx
cmovle ecx, eax
shl rcx, 5
push 0FFFFFFFFFFFFFFE0h
pop rdx
loc_2911F:
lea r8, [rdx+20h]
cmp rcx, r8
jz short locret_2913C
mov r9, [rdi+28h]
cmp [r9+rdx+38h], esi
mov rdx, r8
jnz short loc_2911F
add r9, r8
mov rax, r9
locret_2913C:
retn
|
long long find_export_entry(long long a1, int a2)
{
long long v2; // rcx
long long result; // rax
long long v4; // rcx
long long i; // rdx
long long v6; // r8
long long v7; // r9
v2 = *(unsigned int *)(a1 + 48);
result = 0LL;
if ( (int)v2 <= 0 )
v2 = 0LL;
v4 = 32 * v2;
for ( i = -32LL; ; i += 32LL )
{
v6 = i + 32;
if ( v4 == i + 32 )
break;
v7 = *(_QWORD *)(a1 + 40);
if ( *(_DWORD *)(v7 + i + 56) == a2 )
return v6 + v7;
}
return result;
}
|
find_export_entry:
MOV ECX,dword ptr [RDI + 0x30]
XOR EAX,EAX
TEST ECX,ECX
CMOVLE ECX,EAX
SHL RCX,0x5
PUSH -0x20
POP RDX
LAB_0012911f:
LEA R8,[RDX + 0x20]
CMP RCX,R8
JZ 0x0012913c
MOV R9,qword ptr [RDI + 0x28]
CMP dword ptr [R9 + RDX*0x1 + 0x38],ESI
MOV RDX,R8
JNZ 0x0012911f
ADD R9,R8
MOV RAX,R9
LAB_0012913c:
RET
|
long find_export_entry(long param_1,int param_2)
{
long lVar1;
int *piVar2;
ulong uVar3;
long lVar4;
uVar3 = (ulong)*(uint *)(param_1 + 0x30);
if ((int)*(uint *)(param_1 + 0x30) < 1) {
uVar3 = 0;
}
lVar4 = -0x20;
do {
lVar1 = lVar4 + 0x20;
if (uVar3 * 0x20 == lVar1) {
return 0;
}
piVar2 = (int *)(*(long *)(param_1 + 0x28) + 0x38 + lVar4);
lVar4 = lVar1;
} while (*piVar2 != param_2);
return *(long *)(param_1 + 0x28) + lVar1;
}
|
|
17,706
|
JS_PreventExtensions
|
bluesky950520[P]quickjs/quickjs.c
|
int JS_PreventExtensions(JSContext *ctx, JSValue obj)
{
JSObject *p;
if (unlikely(JS_VALUE_GET_TAG(obj) != JS_TAG_OBJECT))
return FALSE;
p = JS_VALUE_GET_OBJ(obj);
if (unlikely(p->class_id == JS_CLASS_PROXY))
return js_proxy_preventExtensions(ctx, obj);
p->extensible = FALSE;
return TRUE;
}
|
O2
|
c
|
JS_PreventExtensions:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rcx
cmpl $-0x1, %ecx
jne 0x21b5a
movq %rsi, %rdx
cmpw $0x30, 0x6(%rsi)
je 0x21abf
andb $-0x2, 0x5(%rdx)
pushq $0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
leaq 0x8(%rsp), %rsi
pushq $0x63
popq %r8
callq 0x398b1
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x21ab2
movq %rax, %r15
movq 0x10(%rsp), %rdx
cmpl $0x3, %edx
jne 0x21af8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x21a8b
movl %eax, %ebx
jmp 0x21ab2
movq 0x8(%rsp), %rsi
movq 0x10(%r15), %rcx
movq 0x18(%r15), %r8
movq %r15, (%rsp)
pushq $0x1
popq %r9
movq %r14, %rdi
callq 0x2093e
cmpl $0x6, %edx
je 0x21ab2
movq %r14, %rdi
movq %rax, %rsi
callq 0x209aa
testl %eax, %eax
je 0x21b5a
movl %eax, %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x219ba
testl %eax, %eax
js 0x21ab2
je 0x21b61
leaq 0x6853a(%rip), %rsi # 0x8a085
movq %r14, %rdi
xorl %eax, %eax
callq 0x201fd
jmp 0x21ab2
xorl %ebx, %ebx
jmp 0x21ab2
movl %ebp, %ebx
jmp 0x21ab2
|
JS_PreventExtensions:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov rcx, rdx
cmp ecx, 0FFFFFFFFh
jnz loc_21B5A
mov rdx, rsi
cmp word ptr [rsi+6], 30h ; '0'
jz short loc_21ABF
and byte ptr [rdx+5], 0FEh
push 1
pop rbx
loc_21AB2:
mov eax, ebx
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_21ABF:
mov r14, rdi
lea rsi, [rsp+38h+var_30]
push 63h ; 'c'
pop r8
call get_proxy_method
push 0FFFFFFFFFFFFFFFFh
pop rbx
test rax, rax
jz short loc_21AB2
mov r15, rax
mov rdx, [rsp+38h+var_28]
cmp edx, 3
jnz short loc_21AF8
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, r14
call JS_PreventExtensions
mov ebx, eax
jmp short loc_21AB2
loc_21AF8:
mov rsi, [rsp+38h+var_30]
mov rcx, [r15+10h]
mov r8, [r15+18h]
mov [rsp+38h+var_38], r15
push 1
pop r9
mov rdi, r14
call JS_CallFree
cmp edx, 6
jz short loc_21AB2
mov rdi, r14
mov rsi, rax
call JS_ToBoolFree
test eax, eax
jz short loc_21B5A
mov ebp, eax
mov rsi, [r15]
mov rdx, [r15+8]
mov rdi, r14
call JS_IsExtensible
test eax, eax
js loc_21AB2
jz short loc_21B61
lea rsi, aProxyInconsist_1; "proxy: inconsistent preventExtensions"
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
jmp loc_21AB2
loc_21B5A:
xor ebx, ebx
jmp loc_21AB2
loc_21B61:
mov ebx, ebp
jmp loc_21AB2
|
long long JS_PreventExtensions(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
unsigned int v11; // ebx
long long *proxy_method; // rax
long long *v14; // r15
long long v15; // rax
long long v16; // rdx
unsigned int v17; // eax
double v18; // xmm4_8
double v19; // xmm5_8
unsigned int v20; // ebp
int IsExtensible; // eax
long long v22; // rdx
long long v23; // rcx
long long v24; // r8
long long v25; // r9
__m128 v26; // xmm4
__m128 v27; // xmm5
char v28; // [rsp+0h] [rbp-38h]
long long v29; // [rsp+8h] [rbp-30h] BYREF
long long v30; // [rsp+10h] [rbp-28h]
if ( (_DWORD)a3 != -1 )
return 0;
if ( *(_WORD *)(a2 + 6) != 48 )
{
*(_BYTE *)(a2 + 5) &= ~1u;
return 1;
}
proxy_method = (long long *)get_proxy_method(a1, &v29, a2, a3, 99LL);
v11 = -1;
if ( !proxy_method )
return v11;
v14 = proxy_method;
if ( (_DWORD)v30 == 3 )
return (unsigned int)JS_PreventExtensions(a1, *proxy_method, proxy_method[1]);
v15 = JS_CallFree(a1, v29, v30, proxy_method[2], proxy_method[3], 1, (long long)proxy_method);
if ( (_DWORD)v16 == 6 )
return v11;
v17 = JS_ToBoolFree(a1, v15, v16);
if ( !v17 )
return 0;
v20 = v17;
IsExtensible = JS_IsExtensible(a1, *v14, v14[1], a4, a5, a6, a7, v18, v19, a10, a11);
if ( IsExtensible >= 0 )
{
if ( IsExtensible )
JS_ThrowTypeError(
a1,
(long long)"proxy: inconsistent preventExtensions",
v22,
v23,
v24,
v25,
a4,
a5,
a6,
a7,
v26,
v27,
a10,
a11,
v28);
else
return v20;
}
return v11;
}
|
JS_PreventExtensions:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RCX,RDX
CMP ECX,-0x1
JNZ 0x00121b5a
MOV RDX,RSI
CMP word ptr [RSI + 0x6],0x30
JZ 0x00121abf
AND byte ptr [RDX + 0x5],0xfe
PUSH 0x1
POP RBX
LAB_00121ab2:
MOV EAX,EBX
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00121abf:
MOV R14,RDI
LEA RSI,[RSP + 0x8]
PUSH 0x63
POP R8
CALL 0x001398b1
PUSH -0x1
POP RBX
TEST RAX,RAX
JZ 0x00121ab2
MOV R15,RAX
MOV RDX,qword ptr [RSP + 0x10]
CMP EDX,0x3
JNZ 0x00121af8
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV RDI,R14
CALL 0x00121a8b
MOV EBX,EAX
JMP 0x00121ab2
LAB_00121af8:
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [R15 + 0x10]
MOV R8,qword ptr [R15 + 0x18]
MOV qword ptr [RSP],R15
PUSH 0x1
POP R9
MOV RDI,R14
CALL 0x0012093e
CMP EDX,0x6
JZ 0x00121ab2
MOV RDI,R14
MOV RSI,RAX
CALL 0x001209aa
TEST EAX,EAX
JZ 0x00121b5a
MOV EBP,EAX
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
MOV RDI,R14
CALL 0x001219ba
TEST EAX,EAX
JS 0x00121ab2
JZ 0x00121b61
LEA RSI,[0x18a085]
MOV RDI,R14
XOR EAX,EAX
CALL 0x001201fd
JMP 0x00121ab2
LAB_00121b5a:
XOR EBX,EBX
JMP 0x00121ab2
LAB_00121b61:
MOV EBX,EBP
JMP 0x00121ab2
|
int JS_PreventExtensions(int8 param_1,long param_2,int8 param_3)
{
int iVar1;
int iVar2;
int8 *puVar3;
int1 auVar4 [12];
int8 local_30;
int8 local_28;
if ((int)param_3 == -1) {
if (*(short *)(param_2 + 6) != 0x30) {
*(byte *)(param_2 + 5) = *(byte *)(param_2 + 5) & 0xfe;
return 1;
}
puVar3 = (int8 *)get_proxy_method(param_1,&local_30,param_2,param_3,99);
if (puVar3 == (int8 *)0x0) {
return -1;
}
if ((int)local_28 == 3) {
iVar1 = JS_PreventExtensions(param_1,*puVar3,puVar3[1]);
return iVar1;
}
auVar4 = JS_CallFree(param_1,local_30,local_28,puVar3[2],puVar3[3],1,puVar3);
if (auVar4._8_4_ == 6) {
return -1;
}
iVar1 = JS_ToBoolFree(param_1,auVar4._0_8_);
if (iVar1 != 0) {
iVar2 = JS_IsExtensible(param_1,*puVar3,puVar3[1]);
if (iVar2 < 0) {
return -1;
}
if (iVar2 == 0) {
return iVar1;
}
JS_ThrowTypeError(param_1,"proxy: inconsistent preventExtensions");
return -1;
}
}
return 0;
}
|
|
17,707
|
Feature::place(glm::vec<3, long, (glm::qualifier)0> const&, glm::vec<3, int, (glm::qualifier)0> const&, VoxelStorage&) const
|
untodesu[P]voxelius/game/shared/feature.cc
|
void Feature::place(const voxel_pos &vpos, const chunk_pos &cpos, VoxelStorage &voxels) const
{
for(const auto [rpos, voxel, overwrite] : (*this)) {
auto it_vpos = vpos + rpos;
auto it_cpos = coord::to_chunk(it_vpos);
if(it_cpos == cpos) {
auto it_lpos = coord::to_local(it_vpos);
auto it_index = coord::to_index(it_lpos);
if(voxels[it_index] && !overwrite) {
// There is something in the way
// and the called intentionally requested
// we do not force feature to overwrite voxels
continue;
}
voxels[it_index] = voxel;
}
}
}
|
O2
|
cpp
|
Feature::place(glm::vec<3, long, (glm::qualifier)0> const&, glm::vec<3, int, (glm::qualifier)0> const&, VoxelStorage&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
cmpq %rbp, %r13
je 0x3a9a4
movb (%r13), %r12b
movzwl 0x2(%r13), %ebx
movq 0x18(%r13), %rax
movdqu 0x8(%r13), %xmm0
movdqu (%r15), %xmm1
paddq %xmm0, %xmm1
addq 0x10(%r15), %rax
movdqa %xmm1, 0x10(%rsp)
movq %rax, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x25e6d
cmpl %eax, (%r14)
jne 0x3a99b
shrq $0x20, %rax
cmpl %eax, 0x4(%r14)
jne 0x3a99b
cmpl 0x8(%r14), %edx
jne 0x3a99b
leaq 0x10(%rsp), %rdi
callq 0x25e8e
movq %rax, %rcx
shrq $0x20, %rcx
movswl %ax, %edx
sarl $0x10, %eax
shll $0x8, %eax
addl %edx, %eax
movswl %cx, %ecx
shll $0x4, %ecx
addl %eax, %ecx
movq 0x8(%rsp), %rax
cmpw $0x0, (%rax,%rcx,2)
je 0x3a992
testb $0x1, %r12b
je 0x3a99b
movq 0x8(%rsp), %rax
movw %bx, (%rax,%rcx,2)
addq $0x20, %r13
jmp 0x3a909
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZNK7Feature5placeERKN3glm3vecILi3ElLNS0_9qualifierE0EEERKNS1_ILi3EiLS2_0EEER12VoxelStorage:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rsp+58h+var_50], rcx
mov r14, rdx
mov r15, rsi
mov r13, [rdi+8]
mov rbp, [rdi+10h]
loc_3A909:
cmp r13, rbp
jz loc_3A9A4
mov r12b, [r13+0]
movzx ebx, word ptr [r13+2]
mov rax, [r13+18h]
movdqu xmm0, xmmword ptr [r13+8]
movdqu xmm1, xmmword ptr [r15]
paddq xmm1, xmm0
add rax, [r15+10h]
movdqa [rsp+58h+var_48], xmm1
mov [rsp+58h+var_38], rax
lea rdi, [rsp+58h+var_48]
call _ZN5coord8to_chunkERKN3glm3vecILi3ElLNS0_9qualifierE0EEE; coord::to_chunk(glm::vec<3,long,(glm::qualifier)0> const&)
cmp [r14], eax
jnz short loc_3A99B
shr rax, 20h
cmp [r14+4], eax
jnz short loc_3A99B
cmp edx, [r14+8]
jnz short loc_3A99B
lea rdi, [rsp+58h+var_48]
call _ZN5coord8to_localERKN3glm3vecILi3ElLNS0_9qualifierE0EEE; coord::to_local(glm::vec<3,long,(glm::qualifier)0> const&)
mov rcx, rax
shr rcx, 20h
movsx edx, ax
sar eax, 10h
shl eax, 8
add eax, edx
movsx ecx, cx
shl ecx, 4
add ecx, eax
mov rax, [rsp+58h+var_50]
cmp word ptr [rax+rcx*2], 0
jz short loc_3A992
test r12b, 1
jz short loc_3A99B
loc_3A992:
mov rax, [rsp+58h+var_50]
mov [rax+rcx*2], bx
loc_3A99B:
add r13, 20h ; ' '
jmp loc_3A909
loc_3A9A4:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void Feature::place(long long a1, const __m128i *a2, long long a3, long long a4)
{
char *v5; // r13
char *v6; // rbp
char v7; // r12
__int16 v8; // bx
long long v9; // rax
unsigned long long v10; // rax
unsigned int v11; // edx
unsigned long long v12; // rax
long long v13; // rcx
__m128i v15; // [rsp+10h] [rbp-48h] BYREF
long long v16; // [rsp+20h] [rbp-38h]
v5 = *(char **)(a1 + 8);
v6 = *(char **)(a1 + 16);
while ( v5 != v6 )
{
v7 = *v5;
v8 = *((_WORD *)v5 + 1);
v9 = a2[1].m128i_i64[0] + *((_QWORD *)v5 + 3);
v15 = _mm_add_epi64(_mm_loadu_si128(a2), _mm_loadu_si128((const __m128i *)(v5 + 8)));
v16 = v9;
v10 = coord::to_chunk(&v15);
if ( *(_DWORD *)a3 == (_DWORD)v10 && __PAIR64__(v11, HIDWORD(v10)) == *(_QWORD *)(a3 + 4) )
{
v12 = coord::to_local((long long)&v15);
v13 = (unsigned int)((__int16)v12 + ((int)v12 >> 16 << 8) + 16 * SWORD2(v12));
if ( !*(_WORD *)(a4 + 2 * v13) || (v7 & 1) != 0 )
*(_WORD *)(a4 + 2 * v13) = v8;
}
v5 += 32;
}
}
|
place:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RSP + 0x8],RCX
MOV R14,RDX
MOV R15,RSI
MOV R13,qword ptr [RDI + 0x8]
MOV RBP,qword ptr [RDI + 0x10]
LAB_0013a909:
CMP R13,RBP
JZ 0x0013a9a4
MOV R12B,byte ptr [R13]
MOVZX EBX,word ptr [R13 + 0x2]
MOV RAX,qword ptr [R13 + 0x18]
MOVDQU XMM0,xmmword ptr [R13 + 0x8]
MOVDQU XMM1,xmmword ptr [R15]
PADDQ XMM1,XMM0
ADD RAX,qword ptr [R15 + 0x10]
MOVDQA xmmword ptr [RSP + 0x10],XMM1
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x10]
CALL 0x00125e6d
CMP dword ptr [R14],EAX
JNZ 0x0013a99b
SHR RAX,0x20
CMP dword ptr [R14 + 0x4],EAX
JNZ 0x0013a99b
CMP EDX,dword ptr [R14 + 0x8]
JNZ 0x0013a99b
LEA RDI,[RSP + 0x10]
CALL 0x00125e8e
MOV RCX,RAX
SHR RCX,0x20
MOVSX EDX,AX
SAR EAX,0x10
SHL EAX,0x8
ADD EAX,EDX
MOVSX ECX,CX
SHL ECX,0x4
ADD ECX,EAX
MOV RAX,qword ptr [RSP + 0x8]
CMP word ptr [RAX + RCX*0x2],0x0
JZ 0x0013a992
TEST R12B,0x1
JZ 0x0013a99b
LAB_0013a992:
MOV RAX,qword ptr [RSP + 0x8]
MOV word ptr [RAX + RCX*0x2],BX
LAB_0013a99b:
ADD R13,0x20
JMP 0x0013a909
LAB_0013a9a4:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Feature::place(glm::vec<3, long, (glm::qualifier)0> const&, glm::vec<3, int, (glm::qualifier)0>
const&, VoxelStorage&) const */
void __thiscall Feature::place(Feature *this,vec *param_1,vec *param_2,VoxelStorage *param_3)
{
byte bVar1;
int2 uVar2;
byte *pbVar3;
int8 uVar4;
ulong uVar5;
byte *pbVar6;
int1 auVar7 [12];
long local_48;
long lStack_40;
long local_38;
pbVar3 = *(byte **)(this + 0x10);
for (pbVar6 = *(byte **)(this + 8); pbVar6 != pbVar3; pbVar6 = pbVar6 + 0x20) {
bVar1 = *pbVar6;
uVar2 = *(int2 *)(pbVar6 + 2);
local_48 = *(long *)param_1 + *(long *)(pbVar6 + 8);
lStack_40 = *(long *)(param_1 + 8) + *(long *)(pbVar6 + 0x10);
local_38 = *(long *)(pbVar6 + 0x18) + *(long *)(param_1 + 0x10);
auVar7 = coord::to_chunk((vec *)&local_48);
if (((*(int *)param_2 == auVar7._0_4_) && (*(int *)(param_2 + 4) == auVar7._4_4_)) &&
(auVar7._8_4_ == *(int *)(param_2 + 8))) {
uVar4 = coord::to_local((vec *)&local_48);
uVar5 = (ulong)(uint)((short)((ulong)uVar4 >> 0x20) * 0x10 +
((int)uVar4 >> 0x10) * 0x100 + (int)(short)uVar4);
if ((*(short *)(param_3 + uVar5 * 2) == 0) || ((bVar1 & 1) != 0)) {
*(int2 *)(param_3 + uVar5 * 2) = uVar2;
}
}
}
return;
}
|
|
17,708
|
ma_pvio_has_data
|
eloqsql/libmariadb/libmariadb/ma_pvio.c
|
my_bool ma_pvio_has_data(MARIADB_PVIO *pvio, ssize_t *data_len)
{
/* check if we still have unread data in cache */
if (pvio && pvio->cache)
if (pvio->cache_pos > pvio->cache)
return test(pvio->cache_pos - pvio->cache);
if (pvio && pvio->methods->has_data)
return pvio->methods->has_data(pvio, data_len);
return 1;
}
|
O0
|
c
|
ma_pvio_has_data:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4addc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4addc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x4adda
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
subq %rax, %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, -0x1(%rbp)
jmp 0x4ae11
jmp 0x4addc
cmpq $0x0, -0x10(%rbp)
je 0x4ae0d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x4ae0d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movb %al, -0x1(%rbp)
jmp 0x4ae11
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
ma_pvio_has_data:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp [rbp+var_10], 0
jz short loc_4ADDC
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_4ADDC
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jbe short loc_4ADDA
mov rax, [rbp+var_10]
mov rdx, [rax+10h]
mov rax, [rbp+var_10]
mov rax, [rax+8]
sub rdx, rax
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov [rbp+var_1], al
jmp short loc_4AE11
loc_4ADDA:
jmp short $+2
loc_4ADDC:
cmp [rbp+var_10], 0
jz short loc_4AE0D
mov rax, [rbp+var_10]
mov rax, [rax+48h]
cmp qword ptr [rax+78h], 0
jz short loc_4AE0D
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov rax, [rax+78h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rax
mov [rbp+var_1], al
jmp short loc_4AE11
loc_4AE0D:
mov [rbp+var_1], 1
loc_4AE11:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
|
char ma_pvio_has_data(_QWORD *a1, long long a2)
{
if ( a1 && a1[1] && a1[2] > a1[1] )
return a1[2] != a1[1];
if ( a1 && *(_QWORD *)(a1[9] + 120LL) )
return (*(long long ( **)(_QWORD *, long long))(a1[9] + 120LL))(a1, a2);
return 1;
}
|
ma_pvio_has_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0014addc
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x0014addc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x8]
JBE 0x0014adda
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
SUB RDX,RAX
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV byte ptr [RBP + -0x1],AL
JMP 0x0014ae11
LAB_0014adda:
JMP 0x0014addc
LAB_0014addc:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x0014ae0d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x78],0x0
JZ 0x0014ae0d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX + 0x78]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL RAX
MOV byte ptr [RBP + -0x1],AL
JMP 0x0014ae11
LAB_0014ae0d:
MOV byte ptr [RBP + -0x1],0x1
LAB_0014ae11:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 ma_pvio_has_data(long param_1,int8 param_2)
{
int1 local_9;
if (((param_1 == 0) || (*(long *)(param_1 + 8) == 0)) ||
(*(ulong *)(param_1 + 0x10) <= *(ulong *)(param_1 + 8))) {
if ((param_1 == 0) || (*(long *)(*(long *)(param_1 + 0x48) + 0x78) == 0)) {
local_9 = 1;
}
else {
local_9 = (**(code **)(*(long *)(param_1 + 0x48) + 0x78))(param_1,param_2);
}
}
else {
local_9 = *(long *)(param_1 + 0x10) != *(long *)(param_1 + 8);
}
return local_9;
}
|
|
17,709
|
MyCTX_gcm::finish(unsigned char*, unsigned int*)
|
eloqsql/mysys_ssl/my_crypt.cc
|
int finish(uchar *dst, uint *dlen)
{
int fin;
if (!EVP_CipherFinal_ex(ctx, dst, &fin))
return MY_AES_BAD_DATA;
DBUG_ASSERT(fin == 0);
if (EVP_CIPHER_CTX_encrypting(ctx))
{
if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, MY_AES_BLOCK_SIZE, dst))
return MY_AES_OPENSSL_ERROR;
*dlen= MY_AES_BLOCK_SIZE;
}
else
*dlen= 0;
return MY_AES_OK;
}
|
O3
|
cpp
|
MyCTX_gcm::finish(unsigned char*, unsigned int*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0xc8(%rdi), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x29290
testl %eax, %eax
je 0xd93a6
movq 0xc8(%r12), %rdi
callq 0x29870
xorl %r15d, %r15d
movl $0x0, %r13d
testl %eax, %eax
je 0xd93a1
movq 0xc8(%r12), %rdi
movl $0x10, %r13d
movl $0x10, %esi
movl $0x10, %edx
movq %r14, %rcx
callq 0x292d0
testl %eax, %eax
je 0xd93ae
movl %r13d, (%rbx)
jmp 0xd93b4
movl $0xffffff9c, %r15d # imm = 0xFFFFFF9C
jmp 0xd93b4
movl $0xffffff9b, %r15d # imm = 0xFFFFFF9B
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN9MyCTX_gcm6finishEPhPj:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rsi
mov r12, rdi
mov rdi, [rdi+0C8h]
lea rdx, [rbp+var_2C]
call _EVP_CipherFinal_ex
test eax, eax
jz short loc_D93A6
mov rdi, [r12+0C8h]
call _EVP_CIPHER_CTX_is_encrypting
xor r15d, r15d
mov r13d, 0
test eax, eax
jz short loc_D93A1
mov rdi, [r12+0C8h]
mov r13d, 10h
mov esi, 10h
mov edx, 10h
mov rcx, r14
call _EVP_CIPHER_CTX_ctrl
test eax, eax
jz short loc_D93AE
loc_D93A1:
mov [rbx], r13d
jmp short loc_D93B4
loc_D93A6:
mov r15d, 0FFFFFF9Ch
jmp short loc_D93B4
loc_D93AE:
mov r15d, 0FFFFFF9Bh
loc_D93B4:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long MyCTX_gcm::finish(MyCTX_gcm *this, unsigned __int8 *a2, unsigned int *a3)
{
long long v3; // rax
unsigned int v5; // r15d
unsigned int v6; // r13d
_DWORD v8[11]; // [rsp+0h] [rbp-2Ch] BYREF
v8[0] = HIDWORD(v3);
if ( (unsigned int)EVP_CipherFinal_ex(*((_QWORD *)this + 25), a2, v8) )
{
v5 = 0;
v6 = 0;
if ( (unsigned int)EVP_CIPHER_CTX_is_encrypting(*((_QWORD *)this + 25))
&& (v6 = 16, !(unsigned int)EVP_CIPHER_CTX_ctrl(*((_QWORD *)this + 25), 16LL, 16LL, a2)) )
{
return (unsigned int)-101;
}
else
{
*a3 = v6;
}
}
else
{
return (unsigned int)-100;
}
return v5;
}
|
finish:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RSI
MOV R12,RDI
MOV RDI,qword ptr [RDI + 0xc8]
LEA RDX,[RBP + -0x2c]
CALL 0x00129290
TEST EAX,EAX
JZ 0x001d93a6
MOV RDI,qword ptr [R12 + 0xc8]
CALL 0x00129870
XOR R15D,R15D
MOV R13D,0x0
TEST EAX,EAX
JZ 0x001d93a1
MOV RDI,qword ptr [R12 + 0xc8]
MOV R13D,0x10
MOV ESI,0x10
MOV EDX,0x10
MOV RCX,R14
CALL 0x001292d0
TEST EAX,EAX
JZ 0x001d93ae
LAB_001d93a1:
MOV dword ptr [RBX],R13D
JMP 0x001d93b4
LAB_001d93a6:
MOV R15D,0xffffff9c
JMP 0x001d93b4
LAB_001d93ae:
MOV R15D,0xffffff9b
LAB_001d93b4:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* MyCTX_gcm::finish(unsigned char*, unsigned int*) */
int8 __thiscall MyCTX_gcm::finish(MyCTX_gcm *this,uchar *param_1,uint *param_2)
{
int iVar1;
uint uVar2;
int8 uVar3;
int local_34;
iVar1 = EVP_CipherFinal_ex(*(EVP_CIPHER_CTX **)(this + 200),param_1,&local_34);
if (iVar1 == 0) {
uVar3 = 0xffffff9c;
}
else {
iVar1 = EVP_CIPHER_CTX_is_encrypting(*(int8 *)(this + 200));
uVar3 = 0;
uVar2 = 0;
if (iVar1 != 0) {
uVar2 = 0x10;
iVar1 = EVP_CIPHER_CTX_ctrl(*(EVP_CIPHER_CTX **)(this + 200),0x10,0x10,param_1);
if (iVar1 == 0) {
return 0xffffff9b;
}
}
*param_2 = uVar2;
}
return uVar3;
}
|
|
17,710
|
ma_send
|
eloqsql/libmariadb/plugins/pvio/pvio_socket.c
|
static ssize_t ma_send(my_socket socket, const uchar *buffer, size_t length, int flags)
{
ssize_t r;
#if !defined(MSG_NOSIGNAL) && !defined(SO_NOSIGPIPE) && !defined(_WIN32)
struct sigaction act, oldact;
act.sa_handler= SIG_IGN;
sigaction(SIGPIPE, &act, &oldact);
#endif
do {
r = send(socket, (const char *)buffer, IF_WIN((int)length,length), flags);
}
while (r == -1 && IS_SOCKET_EINTR(socket_errno));
#if !defined(MSG_NOSIGNAL) && !defined(SO_NOSIGPIPE) && !defined(_WIN32)
sigaction(SIGPIPE, &oldact, NULL);
#endif
return r;
}
|
O0
|
c
|
ma_send:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x131e0
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x28(%rbp)
movb %al, -0x29(%rbp)
jne 0x42537
callq 0x13050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x42506
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
ma_send:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
loc_42506:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_1C]
call _send
mov [rbp+var_28], rax
xor eax, eax
cmp [rbp+var_28], 0FFFFFFFFFFFFFFFFh
mov [rbp+var_29], al
jnz short loc_42537
call ___errno_location
cmp dword ptr [rax], 4
setz al
mov [rbp+var_29], al
loc_42537:
mov al, [rbp+var_29]
test al, 1
jnz short loc_42506
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
|
long long ma_send(unsigned int a1, long long a2, long long a3, unsigned int a4)
{
bool v5; // [rsp+7h] [rbp-29h]
long long v6; // [rsp+8h] [rbp-28h]
do
{
v6 = send(a1, a2, a3, a4);
v5 = 0;
if ( v6 == -1 )
v5 = *(_DWORD *)__errno_location(a1) == 4;
}
while ( v5 );
return v6;
}
|
ma_send:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
LAB_00142506:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CALL 0x001131e0
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
CMP qword ptr [RBP + -0x28],-0x1
MOV byte ptr [RBP + -0x29],AL
JNZ 0x00142537
CALL 0x00113050
CMP dword ptr [RAX],0x4
SETZ AL
MOV byte ptr [RBP + -0x29],AL
LAB_00142537:
MOV AL,byte ptr [RBP + -0x29]
TEST AL,0x1
JNZ 0x00142506
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
ssize_t ma_send(int param_1,void *param_2,size_t param_3,int param_4)
{
ssize_t sVar1;
int *piVar2;
bool bVar3;
do {
sVar1 = send(param_1,param_2,param_3,param_4);
bVar3 = false;
if (sVar1 == -1) {
piVar2 = __errno_location();
bVar3 = *piVar2 == 4;
}
} while (bVar3);
return sVar1;
}
|
|
17,711
|
main
|
tsotchke[P]eshkol/tests/unit/test_vector.c
|
int main(void) {
printf("Running vector and matrix tests...\n");
// Test SIMD detection
test_simd_detection();
// Test vector operations
test_vector_create();
test_vector_set();
test_vector_add();
test_vector_sub();
test_vector_mul_scalar();
test_vector_dot();
test_vector_cross();
test_vector_magnitude();
test_vector_normalize();
// Test matrix operations
test_matrix_create();
test_matrix_set();
test_matrix_add();
test_matrix_sub();
test_matrix_mul();
test_matrix_mul_scalar();
test_matrix_transpose();
test_matrix_determinant();
test_matrix_inverse();
test_matrix_mul_vector();
test_matrix_identity();
printf("All vector and matrix tests passed!\n");
return 0;
}
|
O0
|
c
|
main:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x8e9a(%rip), %rdi # 0xa0c0
movb $0x0, %al
callq 0x1080
callq 0x12b0
callq 0x1320
callq 0x15c0
callq 0x18f0
callq 0x1b40
callq 0x1d90
callq 0x1f60
callq 0x2120
callq 0x2360
callq 0x24b0
callq 0x2700
callq 0x28a0
callq 0x2a80
callq 0x2d20
callq 0x2fc0
callq 0x3280
callq 0x34a0
callq 0x3710
callq 0x3930
callq 0x3ce0
callq 0x3f50
leaq 0x8e47(%rip), %rdi # 0xa0e4
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
|
main:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], 0
lea rdi, aRunningVectorA; "Running vector and matrix tests...\n"
mov al, 0
call _printf
call test_simd_detection
call test_vector_create
call test_vector_set
call test_vector_add
call test_vector_sub
call test_vector_mul_scalar
call test_vector_dot
call test_vector_cross
call test_vector_magnitude
call test_vector_normalize
call test_matrix_create
call test_matrix_set
call test_matrix_add
call test_matrix_sub
call test_matrix_mul
call test_matrix_mul_scalar
call test_matrix_transpose
call test_matrix_determinant
call test_matrix_inverse
call test_matrix_mul_vector
call test_matrix_identity
lea rdi, aAllVectorAndMa; "All vector and matrix tests passed!\n"
mov al, 0
call _printf
xor eax, eax
add rsp, 10h
pop rbp
retn
|
int main(int argc, const char **argv, const char **envp)
{
long long v3; // rdx
printf("Running vector and matrix tests...\n", argv, envp);
test_simd_detection();
test_vector_create();
test_vector_set();
test_vector_add();
test_vector_sub();
test_vector_mul_scalar();
test_vector_dot();
test_vector_cross();
test_vector_magnitude();
test_vector_normalize();
test_matrix_create();
test_matrix_set();
test_matrix_add();
test_matrix_sub();
test_matrix_mul();
test_matrix_mul_scalar();
test_matrix_transpose();
test_matrix_determinant();
test_matrix_inverse();
test_matrix_mul_vector();
test_matrix_identity();
printf("All vector and matrix tests passed!\n", argv, v3);
return 0;
}
|
main:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],0x0
LEA RDI,[0x10a0c0]
MOV AL,0x0
CALL 0x00101080
CALL 0x001012b0
CALL 0x00101320
CALL 0x001015c0
CALL 0x001018f0
CALL 0x00101b40
CALL 0x00101d90
CALL 0x00101f60
CALL 0x00102120
CALL 0x00102360
CALL 0x001024b0
CALL 0x00102700
CALL 0x001028a0
CALL 0x00102a80
CALL 0x00102d20
CALL 0x00102fc0
CALL 0x00103280
CALL 0x001034a0
CALL 0x00103710
CALL 0x00103930
CALL 0x00103ce0
CALL 0x00103f50
LEA RDI,[0x10a0e4]
MOV AL,0x0
CALL 0x00101080
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 main(void)
{
printf("Running vector and matrix tests...\n");
test_simd_detection();
test_vector_create();
test_vector_set();
test_vector_add();
test_vector_sub();
test_vector_mul_scalar();
test_vector_dot();
test_vector_cross();
test_vector_magnitude();
test_vector_normalize();
test_matrix_create();
test_matrix_set();
test_matrix_add();
test_matrix_sub();
test_matrix_mul();
test_matrix_mul_scalar();
test_matrix_transpose();
test_matrix_determinant();
test_matrix_inverse();
test_matrix_mul_vector();
test_matrix_identity();
printf("All vector and matrix tests passed!\n");
return 0;
}
|
|
17,712
|
ma_ft_segiterator_init
|
eloqsql/storage/maria/ma_ft_update.c
|
void _ma_ft_segiterator_init(MARIA_HA *info, uint keynr, const uchar *record,
FT_SEG_ITERATOR *ftsi)
{
DBUG_ENTER("_ma_ft_segiterator_init");
ftsi->num=info->s->keyinfo[keynr].keysegs;
ftsi->seg=info->s->keyinfo[keynr].seg;
ftsi->rec=record;
ftsi->pos= 0; /* Avoid warnings from gcc */
ftsi->len= 0; /* Avoid warnings from gcc */
DBUG_VOID_RETURN;
}
|
O3
|
c
|
ma_ft_segiterator_init:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq 0x570(%rax), %rax
movl %esi, %esi
imulq $0x118, %rsi, %rsi # imm = 0x118
movzwl 0xa0(%rax,%rsi), %eax
movl %eax, (%rcx)
movq (%rdi), %rax
movq 0x570(%rax), %rax
movq 0xc0(%rax,%rsi), %rax
movq %rax, 0x8(%rcx)
movq %rdx, 0x10(%rcx)
movq $0x0, 0x18(%rcx)
movl $0x0, 0x4(%rcx)
popq %rbp
retq
|
_ma_ft_segiterator_init:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov rax, [rax+570h]
mov esi, esi
imul rsi, 118h
movzx eax, word ptr [rax+rsi+0A0h]
mov [rcx], eax
mov rax, [rdi]
mov rax, [rax+570h]
mov rax, [rax+rsi+0C0h]
mov [rcx+8], rax
mov [rcx+10h], rdx
mov qword ptr [rcx+18h], 0
mov dword ptr [rcx+4], 0
pop rbp
retn
|
long long ma_ft_segiterator_init(long long a1, unsigned int a2, long long a3, long long a4)
{
long long v4; // rsi
long long result; // rax
v4 = 280LL * a2;
*(_DWORD *)a4 = *(unsigned __int16 *)(*(_QWORD *)(*(_QWORD *)a1 + 1392LL) + v4 + 160);
result = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 1392LL) + v4 + 192);
*(_QWORD *)(a4 + 8) = result;
*(_QWORD *)(a4 + 16) = a3;
*(_QWORD *)(a4 + 24) = 0LL;
*(_DWORD *)(a4 + 4) = 0;
return result;
}
|
_ma_ft_segiterator_init:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV ESI,ESI
IMUL RSI,RSI,0x118
MOVZX EAX,word ptr [RAX + RSI*0x1 + 0xa0]
MOV dword ptr [RCX],EAX
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x570]
MOV RAX,qword ptr [RAX + RSI*0x1 + 0xc0]
MOV qword ptr [RCX + 0x8],RAX
MOV qword ptr [RCX + 0x10],RDX
MOV qword ptr [RCX + 0x18],0x0
MOV dword ptr [RCX + 0x4],0x0
POP RBP
RET
|
void _ma_ft_segiterator_init(long *param_1,uint param_2,int8 param_3,uint *param_4)
{
*param_4 = (uint)*(ushort *)(*(long *)(*param_1 + 0x570) + 0xa0 + (ulong)param_2 * 0x118);
*(int8 *)(param_4 + 2) =
*(int8 *)(*(long *)(*param_1 + 0x570) + 0xc0 + (ulong)param_2 * 0x118);
*(int8 *)(param_4 + 4) = param_3;
param_4[6] = 0;
param_4[7] = 0;
param_4[1] = 0;
return;
}
|
|
17,713
|
gguf_writer::write(gguf_kv const&) const
|
monkey531[P]llama/ggml/src/gguf.cpp
|
void write(const struct gguf_kv & kv) const {
const uint64_t ne = kv.get_ne();
write(kv.get_key());
if (kv.is_array) {
write(GGUF_TYPE_ARRAY);
write(kv.get_type());
write(ne);
} else {
write(kv.get_type());
}
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: {
write(kv.data);
} break;
case GGUF_TYPE_BOOL: {
for (size_t i = 0; i < ne; ++i) {
write(kv.get_val<bool>(i));
}
} break;
case GGUF_TYPE_STRING: {
for (size_t i = 0; i < ne; ++i) {
write(kv.get_val<std::string>(i));
}
} break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
}
|
O0
|
cpp
|
gguf_writer::write(gguf_kv const&) const:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x415d0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x43410
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x47c40
movq 0x38(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x96018
movq 0x10(%rsp), %rdi
movl $0x9, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x42240
movq 0x38(%rsp), %rdi
callq 0x465c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x42240
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x41520
jmp 0x9602f
movq 0x38(%rsp), %rdi
callq 0x465c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x42240
movq 0x38(%rsp), %rdi
callq 0x465c0
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0xc, %rax
ja 0x960ff
movq 0x8(%rsp), %rax
leaq 0x2d6ea(%rip), %rcx # 0xc3740
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x28, %rsi
callq 0x456c0
jmp 0x96119
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x960b8
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x43d30
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x405c0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x96080
jmp 0x96119
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x960fb
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x446a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x47c40
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x960c3
jmp 0x96119
jmp 0x960ff
leaq 0x2d90b(%rip), %rdi # 0xc3a11
movl $0x4c4, %esi # imm = 0x4C4
leaq 0x2dead(%rip), %rdx # 0xc3fbf
movb $0x0, %al
callq 0x46770
addq $0x48, %rsp
retq
nop
|
_ZNK11gguf_writer5writeERK7gguf_kv:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rax, [rsp+48h+var_8]
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_10]; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
mov [rsp+48h+var_18], rax
mov rdi, [rsp+48h+var_10]
call __ZNK7gguf_kv7get_keyB5cxx11Ev; gguf_kv::get_key(void)
mov rdi, [rsp+48h+var_38]
mov rsi, rax
call __ZNK11gguf_writer5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; gguf_writer::write(std::string const&)
mov rax, [rsp+48h+var_10]
test byte ptr [rax+20h], 1
jz short loc_96018
mov rdi, [rsp+48h+var_38]
mov [rsp+48h+var_1C], 9
lea rsi, [rsp+48h+var_1C]
call __ZNK11gguf_writer5writeERK9gguf_type; gguf_writer::write(gguf_type const&)
mov rdi, [rsp+48h+var_10]; this
call __ZNK7gguf_kv8get_typeEv; gguf_kv::get_type(void)
mov rdi, [rsp+48h+var_38]
mov rsi, rax
call __ZNK11gguf_writer5writeERK9gguf_type; gguf_writer::write(gguf_type const&)
mov rdi, [rsp+48h+var_38]
lea rsi, [rsp+48h+var_18]
call __ZNK11gguf_writer5writeImEEvRKT_; gguf_writer::write<ulong>(ulong const&)
jmp short loc_9602F
loc_96018:
mov rdi, [rsp+48h+var_10]; this
call __ZNK7gguf_kv8get_typeEv; gguf_kv::get_type(void)
mov rdi, [rsp+48h+var_38]
mov rsi, rax
call __ZNK11gguf_writer5writeERK9gguf_type; gguf_writer::write(gguf_type const&)
loc_9602F:
mov rdi, [rsp+48h+var_10]; this
call __ZNK7gguf_kv8get_typeEv; gguf_kv::get_type(void)
mov eax, [rax]
mov [rsp+48h+var_40], rax
sub rax, 0Ch; switch 13 cases
ja def_9605D; jumptable 000000000009605D default case
mov rax, [rsp+48h+var_40]
lea rcx, jpt_9605D
movsxd rax, ds:(jpt_9605D - 0C3740h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_9605F:
mov rdi, [rsp+48h+var_38]; jumptable 000000000009605D cases 0-6,10-12
mov rsi, [rsp+48h+var_10]
add rsi, 28h ; '('
call __ZNK11gguf_writer5writeERKSt6vectorIaSaIaEE; gguf_writer::write(std::vector<signed char> const&)
jmp loc_96119
loc_96077:
mov [rsp+48h+var_28], 0; jumptable 000000000009605D case 7
loc_96080:
mov rax, [rsp+48h+var_28]
cmp rax, [rsp+48h+var_18]
jnb short loc_960B8
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_28]
call __ZNK7gguf_kv7get_valIbEERKT_m; gguf_kv::get_val<bool>(ulong)
mov rdi, [rsp+48h+var_38]; this
mov rsi, rax; bool *
call __ZNK11gguf_writer5writeERKb; gguf_writer::write(bool const&)
mov rax, [rsp+48h+var_28]
add rax, 1
mov [rsp+48h+var_28], rax
jmp short loc_96080
loc_960B8:
jmp short loc_96119
loc_960BA:
mov [rsp+48h+var_30], 0; jumptable 000000000009605D case 8
loc_960C3:
mov rax, [rsp+48h+var_30]
cmp rax, [rsp+48h+var_18]
jnb short loc_960FB
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_30]
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rdi, [rsp+48h+var_38]
mov rsi, rax
call __ZNK11gguf_writer5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; gguf_writer::write(std::string const&)
mov rax, [rsp+48h+var_30]
add rax, 1
mov [rsp+48h+var_30], rax
jmp short loc_960C3
loc_960FB:
jmp short loc_96119
loc_960FD:
jmp short $+2; jumptable 000000000009605D case 9
def_9605D:
lea rdi, aWorkspaceLlm4b_5; jumptable 000000000009605D default case
mov esi, 4C4h
lea rdx, aInvalidType; "invalid type"
mov al, 0
call _ggml_abort
loc_96119:
add rsp, 48h
retn
|
unsigned long long gguf_writer::write(gguf_writer *this, const gguf_kv *a2)
{
long long v2; // rax
long long type; // rax
long long v4; // rax
unsigned long long result; // rax
const bool *v6; // rax
long long v7; // rax
unsigned long long j; // [rsp+18h] [rbp-30h]
unsigned long long i; // [rsp+20h] [rbp-28h]
int v10; // [rsp+2Ch] [rbp-1Ch] BYREF
unsigned long long ne; // [rsp+30h] [rbp-18h] BYREF
gguf_kv *v12; // [rsp+38h] [rbp-10h]
gguf_writer *v13; // [rsp+40h] [rbp-8h]
v13 = this;
v12 = a2;
ne = gguf_kv::get_ne(a2);
v2 = gguf_kv::get_key[abi:cxx11](a2);
gguf_writer::write(this, v2);
if ( (*((_BYTE *)a2 + 32) & 1) != 0 )
{
v10 = 9;
gguf_writer::write(this, &v10);
type = gguf_kv::get_type(v12);
gguf_writer::write(this, type);
gguf_writer::write<unsigned long>(this, &ne);
}
else
{
v4 = gguf_kv::get_type(v12);
gguf_writer::write(this, v4);
}
switch ( *(_DWORD *)gguf_kv::get_type(v12) )
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 0xA:
case 0xB:
case 0xC:
result = gguf_writer::write(this, (char *)v12 + 40);
break;
case 7:
for ( i = 0LL; ; ++i )
{
result = i;
if ( i >= ne )
break;
v6 = (const bool *)gguf_kv::get_val<bool>(v12, i);
gguf_writer::write(this, v6);
}
break;
case 8:
for ( j = 0LL; ; ++j )
{
result = j;
if ( j >= ne )
break;
v7 = gguf_kv::get_val<std::string>(v12, j);
gguf_writer::write(this, v7);
}
break;
default:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
1220,
(long long)"invalid type");
}
return result;
}
|
write:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001415d0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x00143410
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00147c40
MOV RAX,qword ptr [RSP + 0x38]
TEST byte ptr [RAX + 0x20],0x1
JZ 0x00196018
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x2c],0x9
LEA RSI,[RSP + 0x2c]
CALL 0x00142240
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001465c0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00142240
MOV RDI,qword ptr [RSP + 0x10]
LEA RSI,[RSP + 0x30]
CALL 0x00141520
JMP 0x0019602f
LAB_00196018:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001465c0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00142240
LAB_0019602f:
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001465c0
MOV EAX,dword ptr [RAX]
MOV qword ptr [RSP + 0x8],RAX
SUB RAX,0xc
JA 0x001960ff
MOV RAX,qword ptr [RSP + 0x8]
LEA RCX,[0x1c3740]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x38]
ADD RSI,0x28
CALL 0x001456c0
JMP 0x00196119
caseD_7:
MOV qword ptr [RSP + 0x20],0x0
LAB_00196080:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x30]
JNC 0x001960b8
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00143d30
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x001405c0
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x1
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00196080
LAB_001960b8:
JMP 0x00196119
caseD_8:
MOV qword ptr [RSP + 0x18],0x0
LAB_001960c3:
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x30]
JNC 0x001960fb
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001446a0
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,RAX
CALL 0x00147c40
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001960c3
LAB_001960fb:
JMP 0x00196119
caseD_9:
JMP 0x001960ff
default:
LEA RDI,[0x1c3a11]
MOV ESI,0x4c4
LEA RDX,[0x1c3fbf]
MOV AL,0x0
CALL 0x00146770
LAB_00196119:
ADD RSP,0x48
RET
|
/* gguf_writer::write(gguf_kv const&) const */
void __thiscall gguf_writer::write(gguf_writer *this,gguf_kv *param_1)
{
string *psVar1;
gguf_type *pgVar2;
int4 *puVar3;
bool *pbVar4;
ulong local_30;
ulong local_28;
int4 local_1c;
ulong local_18;
gguf_kv *local_10;
gguf_writer *local_8;
local_10 = param_1;
local_8 = this;
local_18 = gguf_kv::get_ne(param_1);
psVar1 = (string *)gguf_kv::get_key_abi_cxx11_(local_10);
write(this,psVar1);
if (((byte)local_10[0x20] & 1) == 0) {
pgVar2 = (gguf_type *)gguf_kv::get_type(local_10);
write(this,pgVar2);
}
else {
local_1c = 9;
write(this,(gguf_type *)&local_1c);
pgVar2 = (gguf_type *)gguf_kv::get_type(local_10);
write(this,pgVar2);
write<unsigned_long>(this,&local_18);
}
puVar3 = (int4 *)gguf_kv::get_type(local_10);
switch(*puVar3) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 10:
case 0xb:
case 0xc:
write(this,(vector *)(local_10 + 0x28));
break;
case 7:
for (local_28 = 0; local_28 < local_18; local_28 = local_28 + 1) {
pbVar4 = gguf_kv::get_val<bool>(local_10,local_28);
write(this,pbVar4);
}
break;
case 8:
for (local_30 = 0; local_30 < local_18; local_30 = local_30 + 1) {
psVar1 = gguf_kv::get_val<std::__cxx11::string>(local_10,local_30);
write(this,psVar1);
}
break;
case 9:
default:
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x4c4,
"invalid type");
}
return;
}
|
|
17,714
|
gguf_writer::write(gguf_kv const&) const
|
monkey531[P]llama/ggml/src/gguf.cpp
|
void write(const struct gguf_kv & kv) const {
const uint64_t ne = kv.get_ne();
write(kv.get_key());
if (kv.is_array) {
write(GGUF_TYPE_ARRAY);
write(kv.get_type());
write(ne);
} else {
write(kv.get_type());
}
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: {
write(kv.data);
} break;
case GGUF_TYPE_BOOL: {
for (size_t i = 0; i < ne; ++i) {
write(kv.get_val<bool>(i));
}
} break;
case GGUF_TYPE_STRING: {
for (size_t i = 0; i < ne; ++i) {
write(kv.get_val<std::string>(i));
}
} break;
case GGUF_TYPE_ARRAY:
default: GGML_ABORT("invalid type");
}
}
|
O3
|
cpp
|
gguf_writer::write(gguf_kv const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x16620
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x181f0
cmpb $0x1, 0x20(%rbx)
jne 0x4116c
leaq 0xc(%rsp), %r15
movl $0x9, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x16390
movl 0x24(%rbx), %eax
movl %eax, (%r15)
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x16390
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x165d0
jmp 0x4117e
movl 0x24(%rbx), %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x16390
movl 0x24(%rbx), %eax
cmpl $0xc, %eax
ja 0x41223
movl $0x1c7f, %ecx # imm = 0x1C7F
btl %eax, %ecx
jae 0x411b4
movq (%r14), %rdi
movq 0x8(%rdi), %rsi
movq 0x28(%rbx), %rdx
movq 0x30(%rbx), %rcx
callq 0x17190
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x7, %eax
je 0x411eb
cmpl $0x8, %eax
jne 0x41223
cmpq $0x0, 0x10(%rsp)
je 0x411a8
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17310
movq %r14, %rdi
movq %rax, %rsi
callq 0x181f0
incq %r15
cmpq 0x10(%rsp), %r15
jb 0x411c9
jmp 0x411a8
cmpq $0x0, 0x10(%rsp)
je 0x411a8
xorl %r15d, %r15d
leaq 0xc(%rsp), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x17060
movb (%rax), %al
movb %al, 0xc(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x169d0
incq %r15
cmpq 0x10(%rsp), %r15
jb 0x411fb
jmp 0x411a8
leaq 0x18aab(%rip), %rdi # 0x59cd5
leaq 0x19052(%rip), %rdx # 0x5a283
movl $0x4c4, %esi # imm = 0x4C4
xorl %eax, %eax
callq 0x17c60
nop
|
_ZNK11gguf_writer5writeERK7gguf_kv:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rdi, rsi; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
mov [rsp+38h+var_28], rax
mov rdi, r14
mov rsi, rbx
call __ZNK11gguf_writer5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; gguf_writer::write(std::string const&)
cmp byte ptr [rbx+20h], 1
jnz short loc_4116C
lea r15, [rsp+38h+var_2C]
mov dword ptr [r15], 9
mov rdi, r14
mov rsi, r15
call __ZNK11gguf_writer5writeIiEEvRKT_; gguf_writer::write<int>(int const&)
mov eax, [rbx+24h]
mov [r15], eax
lea rsi, [rsp+38h+var_2C]
mov rdi, r14
call __ZNK11gguf_writer5writeIiEEvRKT_; gguf_writer::write<int>(int const&)
lea rsi, [rsp+38h+var_28]
mov rdi, r14
call __ZNK11gguf_writer5writeImEEvRKT_; gguf_writer::write<ulong>(ulong const&)
jmp short loc_4117E
loc_4116C:
mov eax, [rbx+24h]
lea rsi, [rsp+38h+var_2C]
mov [rsi], eax
mov rdi, r14
call __ZNK11gguf_writer5writeIiEEvRKT_; gguf_writer::write<int>(int const&)
loc_4117E:
mov eax, [rbx+24h]
cmp eax, 0Ch
ja loc_41223
mov ecx, 1C7Fh
bt ecx, eax
jnb short loc_411B4
mov rdi, [r14]
mov rsi, [rdi+8]
mov rdx, [rbx+28h]
mov rcx, [rbx+30h]
call __ZNSt6vectorIaSaIaEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPKaS1_EEEEvNS4_IPaS1_EET_SA_St20forward_iterator_tag; std::vector<signed char>::_M_range_insert<__gnu_cxx::__normal_iterator<signed char const*,std::vector<signed char>>>(__gnu_cxx::__normal_iterator<signed char *,std::vector<signed char>>,__gnu_cxx::__normal_iterator<signed char const*,std::vector<signed char>>,__gnu_cxx::__normal_iterator<signed char const*,std::vector<signed char>>,std::forward_iterator_tag)
loc_411A8:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
loc_411B4:
cmp eax, 7
jz short loc_411EB
cmp eax, 8
jnz short loc_41223
cmp [rsp+38h+var_28], 0
jz short loc_411A8
xor r15d, r15d
loc_411C9:
mov rdi, rbx
mov rsi, r15
call __ZNK7gguf_kv7get_valINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERKT_m; gguf_kv::get_val<std::string>(ulong)
mov rdi, r14
mov rsi, rax
call __ZNK11gguf_writer5writeERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; gguf_writer::write(std::string const&)
inc r15
cmp r15, [rsp+38h+var_28]
jb short loc_411C9
jmp short loc_411A8
loc_411EB:
cmp [rsp+38h+var_28], 0
jz short loc_411A8
xor r15d, r15d
lea r12, [rsp+38h+var_2C]
loc_411FB:
mov rdi, rbx
mov rsi, r15
call __ZNK7gguf_kv7get_valIbEERKT_m; gguf_kv::get_val<bool>(ulong)
mov al, [rax]
mov [rsp+38h+var_2C], al
mov rdi, r14
mov rsi, r12
call __ZNK11gguf_writer5writeIaEEvRKT_; gguf_writer::write<signed char>(signed char const&)
inc r15
cmp r15, [rsp+38h+var_28]
jb short loc_411FB
jmp short loc_411A8
loc_41223:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aInvalidType; "invalid type"
mov esi, 4C4h
xor eax, eax
call _ggml_abort
|
long long gguf_writer::write(gguf_writer *this, const gguf_kv *a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
long long result; // rax
unsigned long long v6; // r15
long long v7; // rax
unsigned long long v8; // r15
int v9; // [rsp+Ch] [rbp-2Ch] BYREF
unsigned long long v10[5]; // [rsp+10h] [rbp-28h] BYREF
v10[0] = gguf_kv::get_ne(a2);
gguf_writer::write(this, a2);
if ( *((_BYTE *)a2 + 32) == 1 )
{
v9 = 9;
gguf_writer::write<int>(this);
v9 = *((_DWORD *)a2 + 9);
gguf_writer::write<int>(this);
gguf_writer::write<unsigned long>(this, v10);
}
else
{
v9 = *((_DWORD *)a2 + 9);
gguf_writer::write<int>(this);
}
result = *((unsigned int *)a2 + 9);
if ( (unsigned int)result > 0xC )
goto LABEL_18;
v2 = 7295;
if ( _bittest(&v2, result) )
return std::vector<signed char>::_M_range_insert<__gnu_cxx::__normal_iterator<signed char const*,std::vector<signed char>>>(
*(_QWORD *)this,
*(_QWORD *)(*(_QWORD *)this + 8LL),
*((_QWORD *)a2 + 5),
*((_QWORD *)a2 + 6));
if ( (_DWORD)result != 7 )
{
if ( (_DWORD)result == 8 )
{
if ( v10[0] )
{
v6 = 0LL;
do
{
v7 = gguf_kv::get_val<std::string>(a2, v6);
result = gguf_writer::write(this, v7);
++v6;
}
while ( v6 < v10[0] );
}
return result;
}
LABEL_18:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",
1220,
(unsigned int)"invalid type",
v2,
v3,
v4);
}
if ( v10[0] )
{
v8 = 0LL;
do
{
LOBYTE(v9) = *(_BYTE *)gguf_kv::get_val<bool>(a2, v8);
result = gguf_writer::write<signed char>(this, &v9);
++v8;
}
while ( v8 < v10[0] );
}
return result;
}
|
write:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x00116620
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x001181f0
CMP byte ptr [RBX + 0x20],0x1
JNZ 0x0014116c
LEA R15,[RSP + 0xc]
MOV dword ptr [R15],0x9
MOV RDI,R14
MOV RSI,R15
CALL 0x00116390
MOV EAX,dword ptr [RBX + 0x24]
MOV dword ptr [R15],EAX
LEA RSI,[RSP + 0xc]
MOV RDI,R14
CALL 0x00116390
LEA RSI,[RSP + 0x10]
MOV RDI,R14
CALL 0x001165d0
JMP 0x0014117e
LAB_0014116c:
MOV EAX,dword ptr [RBX + 0x24]
LEA RSI,[RSP + 0xc]
MOV dword ptr [RSI],EAX
MOV RDI,R14
CALL 0x00116390
LAB_0014117e:
MOV EAX,dword ptr [RBX + 0x24]
CMP EAX,0xc
JA 0x00141223
MOV ECX,0x1c7f
BT ECX,EAX
JNC 0x001411b4
MOV RDI,qword ptr [R14]
MOV RSI,qword ptr [RDI + 0x8]
MOV RDX,qword ptr [RBX + 0x28]
MOV RCX,qword ptr [RBX + 0x30]
CALL 0x00117190
LAB_001411a8:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001411b4:
CMP EAX,0x7
JZ 0x001411eb
CMP EAX,0x8
JNZ 0x00141223
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001411a8
XOR R15D,R15D
LAB_001411c9:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00117310
MOV RDI,R14
MOV RSI,RAX
CALL 0x001181f0
INC R15
CMP R15,qword ptr [RSP + 0x10]
JC 0x001411c9
JMP 0x001411a8
LAB_001411eb:
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001411a8
XOR R15D,R15D
LEA R12,[RSP + 0xc]
LAB_001411fb:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00117060
MOV AL,byte ptr [RAX]
MOV byte ptr [RSP + 0xc],AL
MOV RDI,R14
MOV RSI,R12
CALL 0x001169d0
INC R15
CMP R15,qword ptr [RSP + 0x10]
JC 0x001411fb
JMP 0x001411a8
LAB_00141223:
LEA RDI,[0x159cd5]
LEA RDX,[0x15a283]
MOV ESI,0x4c4
XOR EAX,EAX
CALL 0x00117c60
|
/* gguf_writer::write(gguf_kv const&) const */
void __thiscall gguf_writer::write(gguf_writer *this,gguf_kv *param_1)
{
uint uVar1;
string *psVar2;
bool *pbVar3;
ulong uVar4;
int local_2c;
ulong local_28;
local_28 = gguf_kv::get_ne(param_1);
write(this,(string *)param_1);
if (param_1[0x20] == (gguf_kv)0x1) {
local_2c = 9;
write<int>(this,&local_2c);
local_2c = *(int *)(param_1 + 0x24);
write<int>(this,&local_2c);
write<unsigned_long>(this,&local_28);
}
else {
local_2c = *(int *)(param_1 + 0x24);
write<int>(this,&local_2c);
}
uVar1 = *(uint *)(param_1 + 0x24);
if (0xc < uVar1) {
LAB_00141223:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/gguf.cpp",0x4c4,
"invalid type");
}
if ((0x1c7fU >> (uVar1 & 0x1f) & 1) == 0) {
if (uVar1 == 7) {
if (local_28 != 0) {
uVar4 = 0;
do {
pbVar3 = gguf_kv::get_val<bool>(param_1,uVar4);
local_2c = CONCAT31(local_2c._1_3_,*pbVar3);
write<signed_char>(this,(signed *)&local_2c);
uVar4 = uVar4 + 1;
} while (uVar4 < local_28);
}
}
else {
if (uVar1 != 8) goto LAB_00141223;
if (local_28 != 0) {
uVar4 = 0;
do {
psVar2 = gguf_kv::get_val<std::__cxx11::string>(param_1,uVar4);
write(this,psVar2);
uVar4 = uVar4 + 1;
} while (uVar4 < local_28);
}
}
}
else {
std::vector<signed_char,std::allocator<signed_char>>::
_M_range_insert<__gnu_cxx::__normal_iterator<signed_char_const*,std::vector<signed_char,std::allocator<signed_char>>>>
(*(long *)this,*(int8 *)(*(long *)this + 8),*(int8 *)(param_1 + 0x28),
*(int8 *)(param_1 + 0x30));
}
return;
}
|
|
17,715
|
lre_canonicalize
|
bluesky950520[P]quickjs/libunicode.c
|
int lre_canonicalize(uint32_t c, BOOL is_unicode)
{
if (c < 128) {
/* fast case */
if (is_unicode) {
if (c >= 'A' && c <= 'Z') {
c = c - 'A' + 'a';
}
} else {
if (c >= 'a' && c <= 'z') {
c = c - 'a' + 'A';
}
}
} else {
uint32_t v, code, len;
int idx, idx_min, idx_max;
idx_min = 0;
idx_max = countof(case_conv_table1) - 1;
while (idx_min <= idx_max) {
idx = (unsigned)(idx_max + idx_min) / 2;
v = case_conv_table1[idx];
code = v >> (32 - 17);
len = (v >> (32 - 17 - 7)) & 0x7f;
if (c < code) {
idx_max = idx - 1;
} else if (c >= code + len) {
idx_min = idx + 1;
} else {
return lre_case_folding_entry(c, idx, v, is_unicode);
}
}
}
return c;
}
|
O1
|
c
|
lre_canonicalize:
movl %esi, %ecx
cmpl $0x80, %edi
jae 0x9840f
testl %ecx, %ecx
je 0x9845a
leal -0x41(%rdi), %eax
movl %edi, %ecx
orl $0x20, %ecx
jmp 0x98460
xorl %r9d, %r9d
movl $0x179, %r8d # imm = 0x179
leaq 0xb421(%rip), %rax # 0xa3840
leal (%r8,%r9), %esi
shrl %esi
movl (%rax,%rsi,4), %edx
movl %edx, %r10d
shrl $0xf, %r10d
cmpl %edi, %r10d
jbe 0x9843b
decl %esi
movl %esi, %r8d
jmp 0x98453
movl %edx, %r9d
shrl $0x8, %r9d
andl $0x7f, %r9d
addl %r10d, %r9d
cmpl %edi, %r9d
ja 0x9846b
incl %esi
movl %esi, %r9d
cmpl %r8d, %r9d
jle 0x9841f
jmp 0x98468
leal -0x61(%rdi), %eax
leal -0x20(%rdi), %ecx
cmpl $0x1a, %eax
cmovael %edi, %ecx
movl %ecx, %edi
movl %edi, %eax
retq
jmp 0x9846d
|
lre_canonicalize:
mov ecx, esi
cmp edi, 80h
jnb short loc_9840F
test ecx, ecx
jz short loc_9845A
lea eax, [rdi-41h]
mov ecx, edi
or ecx, 20h
jmp short loc_98460
loc_9840F:
xor r9d, r9d
mov r8d, 179h
lea rax, case_conv_table1
loc_9841F:
lea esi, [r8+r9]
shr esi, 1
mov edx, [rax+rsi*4]
mov r10d, edx
shr r10d, 0Fh
cmp r10d, edi
jbe short loc_9843B
dec esi
mov r8d, esi
jmp short loc_98453
loc_9843B:
mov r9d, edx
shr r9d, 8
and r9d, 7Fh
add r9d, r10d
cmp r9d, edi
ja short loc_9846B
inc esi
mov r9d, esi
loc_98453:
cmp r9d, r8d
jle short loc_9841F
jmp short loc_98468
loc_9845A:
lea eax, [rdi-61h]
lea ecx, [rdi-20h]
loc_98460:
cmp eax, 1Ah
cmovnb ecx, edi
mov edi, ecx
loc_98468:
mov eax, edi
retn
loc_9846B:
jmp short $+2
|
long long lre_canonicalize(long long a1, unsigned int a2)
{
long long v2; // rcx
unsigned int v3; // eax
int v4; // ecx
int v5; // r9d
int v6; // r8d
long long v7; // rsi
long long v8; // rdx
unsigned int v9; // r10d
v2 = a2;
if ( (unsigned int)a1 >= 0x80 )
{
v5 = 0;
v6 = 377;
while ( 1 )
{
v7 = (unsigned int)(v6 + v5) >> 1;
v8 = (unsigned int)case_conv_table1[v7];
v9 = case_conv_table1[v7] >> 15;
if ( v9 <= (unsigned int)a1 )
{
if ( v9 + (((unsigned int)v8 >> 8) & 0x7F) > (unsigned int)a1 )
return lre_case_folding_entry(a1, v7, v8, v2);
v5 = v7 + 1;
}
else
{
v6 = v7 - 1;
}
if ( v5 > v6 )
return (unsigned int)a1;
}
}
if ( a2 )
{
v3 = a1 - 65;
v4 = a1 | 0x20;
}
else
{
v3 = a1 - 97;
v4 = a1 - 32;
}
if ( v3 >= 0x1A )
v4 = a1;
LODWORD(a1) = v4;
return (unsigned int)a1;
}
|
lre_canonicalize:
MOV ECX,ESI
CMP EDI,0x80
JNC 0x0019840f
TEST ECX,ECX
JZ 0x0019845a
LEA EAX,[RDI + -0x41]
MOV ECX,EDI
OR ECX,0x20
JMP 0x00198460
LAB_0019840f:
XOR R9D,R9D
MOV R8D,0x179
LEA RAX,[0x1a3840]
LAB_0019841f:
LEA ESI,[R8 + R9*0x1]
SHR ESI,0x1
MOV EDX,dword ptr [RAX + RSI*0x4]
MOV R10D,EDX
SHR R10D,0xf
CMP R10D,EDI
JBE 0x0019843b
DEC ESI
MOV R8D,ESI
JMP 0x00198453
LAB_0019843b:
MOV R9D,EDX
SHR R9D,0x8
AND R9D,0x7f
ADD R9D,R10D
CMP R9D,EDI
JA 0x0019846b
INC ESI
MOV R9D,ESI
LAB_00198453:
CMP R9D,R8D
JLE 0x0019841f
JMP 0x00198468
LAB_0019845a:
LEA EAX,[RDI + -0x61]
LEA ECX,[RDI + -0x20]
LAB_00198460:
CMP EAX,0x1a
CMOVNC ECX,EDI
MOV EDI,ECX
LAB_00198468:
MOV EAX,EDI
RET
LAB_0019846b:
JMP 0x0019846d
|
ulong lre_canonicalize(uint param_1,int param_2)
{
uint uVar1;
ulong uVar2;
uint uVar3;
int iVar4;
int iVar5;
if (param_1 < 0x80) {
if (param_2 == 0) {
uVar1 = param_1 - 0x61;
uVar3 = param_1 - 0x20;
}
else {
uVar1 = param_1 - 0x41;
uVar3 = param_1 | 0x20;
}
if (0x19 < uVar1) {
uVar3 = param_1;
}
}
else {
iVar5 = 0;
iVar4 = 0x179;
do {
uVar3 = (uint)(iVar4 + iVar5) >> 1;
uVar1 = (uint)(&case_conv_table1)[uVar3] >> 0xf;
if (param_1 < uVar1) {
iVar4 = uVar3 - 1;
}
else {
if (param_1 < ((uint)(&case_conv_table1)[uVar3] >> 8 & 0x7f) + uVar1) {
uVar2 = lre_case_folding_entry();
return uVar2;
}
iVar5 = uVar3 + 1;
}
uVar3 = param_1;
} while (iVar5 <= iVar4);
}
return (ulong)uVar3;
}
|
|
17,716
|
fill_uchar
|
eloqsql/strings/ctype.c
|
static int fill_uchar(uchar *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uchar) strtoul(b,NULL,16);
}
return 0;
}
|
O0
|
c
|
fill_uchar:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x150af6
jmp 0x150a22
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x150a4e
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x13617(%rip), %rdi # 0x164056
callq 0x2a400
cmpq $0x0, %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x150a57
jmp 0x150a67
jmp 0x150a59
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x150a22
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x42(%rbp)
jae 0x150a9d
movq -0x30(%rbp), %rax
movsbl (%rax), %esi
leaq 0x135ca(%rip), %rdi # 0x164056
callq 0x2a400
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x150aa6
jmp 0x150ab6
jmp 0x150aa8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x150a6f
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x150ac8
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jbe 0x150aca
jmp 0x150af6
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x10, %edx
callq 0x2a0a0
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x150a12
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
|
fill_uchar:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
loc_150A12:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_40]
jnb loc_150AF6
jmp short $+2
loc_150A22:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_41], al
jnb short loc_150A4E
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_164056; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
mov [rbp+var_41], al
loc_150A4E:
mov al, [rbp+var_41]
test al, 1
jnz short loc_150A57
jmp short loc_150A67
loc_150A57:
jmp short $+2
loc_150A59:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_150A22
loc_150A67:
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
loc_150A6F:
mov rcx, [rbp+var_30]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_42], al
jnb short loc_150A9D
mov rax, [rbp+var_30]
movsx esi, byte ptr [rax]
lea rdi, asc_164056; " \t\r\n"
call _strchr
cmp rax, 0
setnz al
xor al, 0FFh
mov [rbp+var_42], al
loc_150A9D:
mov al, [rbp+var_42]
test al, 1
jnz short loc_150AA6
jmp short loc_150AB6
loc_150AA6:
jmp short $+2
loc_150AA8:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_150A6F
loc_150AB6:
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_150AC8
mov eax, [rbp+var_24]
cmp eax, [rbp+var_C]
jbe short loc_150ACA
loc_150AC8:
jmp short loc_150AF6
loc_150ACA:
mov rdi, [rbp+var_38]
xor eax, eax
mov esi, eax
mov edx, 10h
call ___isoc23_strtoul
mov dl, al
mov rax, [rbp+var_8]
mov ecx, [rbp+var_24]
mov [rax+rcx], dl
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp loc_150A12
loc_150AF6:
xor eax, eax
add rsp, 50h
pop rbp
retn
|
long long fill_uchar(long long a1, unsigned int a2, char *a3, long long a4)
{
char v5; // [rsp+Eh] [rbp-42h]
bool v6; // [rsp+Fh] [rbp-41h]
unsigned long long v7; // [rsp+10h] [rbp-40h]
char *v8; // [rsp+18h] [rbp-38h]
char *v9; // [rsp+20h] [rbp-30h]
unsigned int v10; // [rsp+2Ch] [rbp-24h]
v10 = 0;
v7 = (unsigned long long)&a3[a4];
v9 = a3;
while ( (unsigned long long)v9 < v7 )
{
while ( 1 )
{
v6 = 0;
if ( (unsigned long long)v9 < v7 )
v6 = strchr(" \t\r\n", (unsigned int)*v9) != 0;
if ( !v6 )
break;
++v9;
}
v8 = v9;
while ( 1 )
{
v5 = 0;
if ( (unsigned long long)v9 < v7 )
v5 = ~(strchr(" \t\r\n", (unsigned int)*v9) != 0);
if ( (v5 & 1) == 0 )
break;
++v9;
}
if ( v9 == v8 || v10 > a2 )
break;
*(_BYTE *)(a1 + v10++) = __isoc23_strtoul(v8, 0LL, 16LL);
}
return 0LL;
}
| |||
17,717
|
fill_uchar
|
eloqsql/strings/ctype.c
|
static int fill_uchar(uchar *a,uint size,const char *str, size_t len)
{
uint i= 0;
const char *s, *b, *e=str+len;
for (s=str ; s < e ; i++)
{
for ( ; (s < e) && strchr(" \t\r\n",s[0]); s++) ;
b=s;
for ( ; (s < e) && !strchr(" \t\r\n",s[0]); s++) ;
if (s == b || i > size)
break;
a[i]= (uchar) strtoul(b,NULL,16);
}
return 0;
}
|
O3
|
c
|
fill_uchar:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x38(%rbp)
testq %rcx, %rcx
jle 0xdabc8
movq %rcx, %rbx
movq %rdx, %r12
addq %rdx, %rbx
movl %esi, %eax
movq %rax, -0x30(%rbp)
xorl %r14d, %r14d
leaq 0xe586(%rip), %r15 # 0xe90db
movq %r12, %r13
movsbl (%r13), %esi
movl $0x5, %edx
movq %r15, %rdi
callq 0x2a370
testq %rax, %rax
je 0xdab77
incq %r13
cmpq %rbx, %r13
jb 0xdab58
cmpq %rbx, %r13
jae 0xdabc8
movq %r13, %r12
movsbl (%r12), %esi
movl $0x5, %edx
movq %r15, %rdi
callq 0x2a370
testq %rax, %rax
jne 0xdab9e
incq %r12
cmpq %rbx, %r12
jb 0xdab7f
cmpq %r13, %r12
je 0xdabc8
cmpq -0x30(%rbp), %r14
ja 0xdabc8
movq %r13, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2a090
movq -0x38(%rbp), %rcx
movb %al, (%rcx,%r14)
incq %r14
cmpq %rbx, %r12
jb 0xdab55
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
fill_uchar:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], rdi
test rcx, rcx
jle loc_DABC8
mov rbx, rcx
mov r12, rdx
add rbx, rdx
mov eax, esi
mov [rbp+var_30], rax
xor r14d, r14d
lea r15, asc_E90DB; " \t\r\n"
loc_DAB55:
mov r13, r12
loc_DAB58:
movsx esi, byte ptr [r13+0]
mov edx, 5
mov rdi, r15
call _memchr
test rax, rax
jz short loc_DAB77
inc r13
cmp r13, rbx
jb short loc_DAB58
loc_DAB77:
cmp r13, rbx
jnb short loc_DABC8
mov r12, r13
loc_DAB7F:
movsx esi, byte ptr [r12]
mov edx, 5
mov rdi, r15
call _memchr
test rax, rax
jnz short loc_DAB9E
inc r12
cmp r12, rbx
jb short loc_DAB7F
loc_DAB9E:
cmp r12, r13
jz short loc_DABC8
cmp r14, [rbp+var_30]
ja short loc_DABC8
mov rdi, r13
xor esi, esi
mov edx, 10h
call ___isoc23_strtoul
mov rcx, [rbp+var_38]
mov [rcx+r14], al
inc r14
cmp r12, rbx
jb short loc_DAB55
loc_DABC8:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
void fill_uchar(long long a1, unsigned int a2, char *a3, long long a4)
{
char *v4; // r12
unsigned long long v5; // rbx
unsigned long long v6; // r14
char *v7; // r13
if ( a4 > 0 )
{
v4 = a3;
v5 = (unsigned long long)&a3[a4];
v6 = 0LL;
do
{
v7 = v4;
do
{
if ( !memchr(" \t\r\n", (unsigned int)*v7, 5LL) )
break;
++v7;
}
while ( (unsigned long long)v7 < v5 );
if ( (unsigned long long)v7 >= v5 )
break;
v4 = v7;
do
{
if ( memchr(" \t\r\n", (unsigned int)*v4, 5LL) )
break;
++v4;
}
while ( (unsigned long long)v4 < v5 );
if ( v4 == v7 )
break;
if ( v6 > a2 )
break;
*(_BYTE *)(a1 + v6++) = __isoc23_strtoul(v7, 0LL, 16LL);
}
while ( (unsigned long long)v4 < v5 );
}
}
|
fill_uchar:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],RDI
TEST RCX,RCX
JLE 0x001dabc8
MOV RBX,RCX
MOV R12,RDX
ADD RBX,RDX
MOV EAX,ESI
MOV qword ptr [RBP + -0x30],RAX
XOR R14D,R14D
LEA R15,[0x1e90db]
LAB_001dab55:
MOV R13,R12
LAB_001dab58:
MOVSX ESI,byte ptr [R13]
MOV EDX,0x5
MOV RDI,R15
CALL 0x0012a370
TEST RAX,RAX
JZ 0x001dab77
INC R13
CMP R13,RBX
JC 0x001dab58
LAB_001dab77:
CMP R13,RBX
JNC 0x001dabc8
MOV R12,R13
LAB_001dab7f:
MOVSX ESI,byte ptr [R12]
MOV EDX,0x5
MOV RDI,R15
CALL 0x0012a370
TEST RAX,RAX
JNZ 0x001dab9e
INC R12
CMP R12,RBX
JC 0x001dab7f
LAB_001dab9e:
CMP R12,R13
JZ 0x001dabc8
CMP R14,qword ptr [RBP + -0x30]
JA 0x001dabc8
MOV RDI,R13
XOR ESI,ESI
MOV EDX,0x10
CALL 0x0012a090
MOV RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RCX + R14*0x1],AL
INC R14
CMP R12,RBX
JC 0x001dab55
LAB_001dabc8:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void fill_uchar(long param_1,ulong param_2,char *param_3,long param_4)
{
int1 uVar1;
void *pvVar2;
char *pcVar3;
char *pcVar4;
ulong uVar5;
if (param_4 < 1) {
return;
}
pcVar3 = param_3 + param_4;
uVar5 = 0;
LAB_001dab58:
do {
pvVar2 = memchr(&DAT_001e90db,(int)*param_3,5);
pcVar4 = param_3;
if (pvVar2 != (void *)0x0) {
param_3 = param_3 + 1;
pcVar4 = param_3;
if (param_3 < pcVar3) goto LAB_001dab58;
}
param_3 = pcVar4;
if (pcVar3 <= pcVar4) {
return;
}
do {
pvVar2 = memchr(&DAT_001e90db,(int)*param_3,5);
if (pvVar2 != (void *)0x0) break;
param_3 = param_3 + 1;
} while (param_3 < pcVar3);
if (param_3 == pcVar4) {
return;
}
if ((param_2 & 0xffffffff) < uVar5) {
return;
}
uVar1 = __isoc23_strtoul(pcVar4,0,0x10);
*(int1 *)(param_1 + uVar5) = uVar1;
uVar5 = uVar5 + 1;
if (pcVar3 <= param_3) {
return;
}
} while( true );
}
|
|
17,718
|
test_distinct
|
eloqsql/tests/mysql_client_test.c
|
static void test_distinct()
{
MYSQL_STMT *stmt;
int rc, i;
const char *query=
"SELECT 2+count(distinct b), group_concat(a) FROM t1 group by a";
myheader("test_distinct");
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
myquery(rc);
rc= mysql_query(mysql, "CREATE TABLE t1 (a int , b int);");
myquery(rc);
rc= mysql_query(mysql,
"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), \
(1, 10), (2, 20), (3, 30), (4, 40), (5, 50);");
myquery(rc);
for (i= 0; i < 3; i++)
{
stmt= mysql_simple_prepare(mysql, query);
check_stmt(stmt);
rc= mysql_stmt_execute(stmt);
check_execute(stmt, rc);
rc= my_process_stmt_result(stmt);
DIE_UNLESS(rc == 5);
mysql_stmt_close(stmt);
}
rc= mysql_query(mysql, "DROP TABLE t1");
myquery(rc);
}
|
O3
|
c
|
test_distinct:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x3bf4b2(%rip) # 0x41a4c1
jg 0x5b08a
movq 0x344fa8(%rip), %rbx # 0x39ffc0
movq (%rbx), %rdi
leaq 0x844a2(%rip), %rdx # 0xdf4c4
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
movl 0x3bf6d5(%rip), %ecx # 0x41a70c
leal 0x1(%rcx), %eax
movl %eax, 0x3bf6cc(%rip) # 0x41a70c
movl 0x3bf6c1(%rip), %r8d # 0x41a708
movl 0x3bf49e(%rip), %r9d # 0x41a4ec
leaq 0x84cae(%rip), %rax # 0xdfd03
movq %rax, (%rsp)
leaq 0x8576c(%rip), %rdx # 0xe07cc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
leaq 0x84486(%rip), %rdx # 0xdf4fc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
callq 0x394b0
movq 0x3bf437(%rip), %rdi # 0x41a4c8
leaq 0x85746(%rip), %rsi # 0xe07de
callq 0x3b116
testl %eax, %eax
jne 0x5b1a2
movq 0x3bf41c(%rip), %rdi # 0x41a4c8
leaq 0x8e404(%rip), %rsi # 0xe94b7
callq 0x3b116
testl %eax, %eax
jne 0x5b1c1
movq 0x3bf401(%rip), %rdi # 0x41a4c8
leaq 0x8e4cc(%rip), %rsi # 0xe959a
callq 0x3b116
testl %eax, %eax
jne 0x5b1e0
movl $0x3, %r15d
leaq 0x8e473(%rip), %rbx # 0xe955b
movq 0x3bf3d9(%rip), %rdi # 0x41a4c8
movq %rbx, %rsi
callq 0x3ba15
testq %rax, %rax
je 0x5b14b
movq %rax, %r14
movq %rax, %rdi
callq 0x3b510
testl %eax, %eax
jne 0x5b182
movq %r14, %rdi
callq 0x3bc81
cmpl $0x5, %eax
jne 0x5b16a
movq %r14, %rdi
callq 0x3b639
decl %r15d
jne 0x5b0e8
movq 0x3bf39c(%rip), %rdi # 0x41a4c8
leaq 0x856da(%rip), %rsi # 0xe080d
callq 0x3b116
testl %eax, %eax
jne 0x5b1ff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x3ba57
leaq 0x83c53(%rip), %rdi # 0xdedac
leaq 0x839aa(%rip), %rdx # 0xdeb0a
movl $0x24dd, %esi # imm = 0x24DD
callq 0x3bb30
leaq 0x83c3b(%rip), %rdi # 0xdedac
leaq 0x8e3c0(%rip), %rdx # 0xe9538
movl $0x24e1, %esi # imm = 0x24E1
callq 0x3bb30
movq %r14, %rdi
callq 0x3bbbe
leaq 0x83c1b(%rip), %rdi # 0xdedac
leaq 0x8f7cf(%rip), %rdx # 0xea967
movl $0x24df, %esi # imm = 0x24DF
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x83bfc(%rip), %rdi # 0xdedac
leaq 0x99f08(%rip), %rdx # 0xf50bf
movl $0x24d0, %esi # imm = 0x24D0
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x83bdd(%rip), %rdi # 0xdedac
leaq 0x99ee9(%rip), %rdx # 0xf50bf
movl $0x24d3, %esi # imm = 0x24D3
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x83bbe(%rip), %rdi # 0xdedac
leaq 0x99eca(%rip), %rdx # 0xf50bf
movl $0x24d8, %esi # imm = 0x24D8
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x83b9f(%rip), %rdi # 0xdedac
leaq 0x99eab(%rip), %rdx # 0xf50bf
movl $0x24e6, %esi # imm = 0x24E6
callq 0x3bb30
|
test_distinct:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp cs:opt_silent, 1
jg short loc_5B08A
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_DF4C4; "\n\n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
mov ecx, cs:test_count
lea eax, [rcx+1]
mov cs:test_count, eax
mov r8d, cs:iter_count
mov r9d, cs:opt_count
lea rax, aTestDistinct; "test_distinct"
mov [rsp+20h+var_20], rax
lea rdx, aUOfUUS; "%u of (%u/%u): %s"
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
lea rdx, asc_DF4FC; " \n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_5B08A:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi; "DROP TABLE IF EXISTS t1"
call wrap_mysql_query
test eax, eax
jnz loc_5B1A2
mov rdi, cs:mysql
lea rsi, aCreateTableT1A_5; "CREATE TABLE t1 (a int , b int);"
call wrap_mysql_query
test eax, eax
jnz loc_5B1C1
mov rdi, cs:mysql
lea rsi, aInsertIntoT1Va_7; "insert into t1 values (1, 1), (2, 2), ("...
call wrap_mysql_query
test eax, eax
jnz loc_5B1E0
mov r15d, 3
lea rbx, aSelect2CountDi; "SELECT 2+count(distinct b), group_conca"...
loc_5B0E8:
mov rdi, cs:mysql
mov rsi, rbx
call mysql_simple_prepare
test rax, rax
jz short loc_5B14B
mov r14, rax
mov rdi, rax
call wrap_mysql_stmt_execute
test eax, eax
jnz short loc_5B182
mov rdi, r14
call my_process_stmt_result
cmp eax, 5
jnz short loc_5B16A
mov rdi, r14
call wrap_mysql_stmt_close
dec r15d
jnz short loc_5B0E8
mov rdi, cs:mysql
lea rsi, aDropTableT1; "DROP TABLE t1"
call wrap_mysql_query
test eax, eax
jnz loc_5B1FF
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_5B14B:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aStmt0; "stmt != 0"
mov esi, 24DDh
call die
loc_5B16A:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aRc5; "rc == 5"
mov esi, 24E1h
call die
loc_5B182:
mov rdi, r14
call print_st_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
mov esi, 24DFh
call die
loc_5B1A2:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 24D0h
call die
loc_5B1C1:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 24D3h
call die
loc_5B1E0:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 24D8h
call die
loc_5B1FF:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 24E6h
call die
|
long long test_distinct()
{
int v0; // ecx
int v1; // r15d
long long v2; // rax
long long v3; // r14
long long result; // rax
if ( opt_silent <= 1 )
{
__fprintf_chk(stdout, 1LL, "\n\n#####################################\n");
v0 = test_count++;
__fprintf_chk(stdout, 1LL, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_distinct");
__fprintf_chk(stdout, 1LL, " \n#####################################\n");
fflush(stdout);
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP TABLE IF EXISTS t1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9424, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"CREATE TABLE t1 (a int , b int);") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9427, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (1, 10), (2, 20), (3, 30),"
" (4, 40), (5, 50);") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9432, "r == 0");
}
v1 = 3;
do
{
v2 = mysql_simple_prepare(mysql, (long long)"SELECT 2+count(distinct b), group_concat(a) FROM t1 group by a");
if ( !v2 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9437, "stmt != 0");
}
v3 = v2;
if ( (unsigned int)wrap_mysql_stmt_execute(v2) )
{
print_st_error(v3);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9439, "rc == 0");
}
if ( (unsigned int)my_process_stmt_result(v3) != 5 )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9441, "rc == 5");
wrap_mysql_stmt_close(v3);
--v1;
}
while ( v1 );
result = wrap_mysql_query(mysql, (long long)"DROP TABLE t1");
if ( (_DWORD)result )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 9446, "r == 0");
}
return result;
}
|
test_distinct:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP byte ptr [0x0051a4c1],0x1
JG 0x0015b08a
MOV RBX,qword ptr [0x0049ffc0]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4c4]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
MOV ECX,dword ptr [0x0051a70c]
LEA EAX,[RCX + 0x1]
MOV dword ptr [0x0051a70c],EAX
MOV R8D,dword ptr [0x0051a708]
MOV R9D,dword ptr [0x0051a4ec]
LEA RAX,[0x1dfd03]
MOV qword ptr [RSP],RAX
LEA RDX,[0x1e07cc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4fc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
CALL 0x001394b0
LAB_0015b08a:
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e07de]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015b1a2
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e94b7]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015b1c1
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e959a]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015b1e0
MOV R15D,0x3
LEA RBX,[0x1e955b]
LAB_0015b0e8:
MOV RDI,qword ptr [0x0051a4c8]
MOV RSI,RBX
CALL 0x0013ba15
TEST RAX,RAX
JZ 0x0015b14b
MOV R14,RAX
MOV RDI,RAX
CALL 0x0013b510
TEST EAX,EAX
JNZ 0x0015b182
MOV RDI,R14
CALL 0x0013bc81
CMP EAX,0x5
JNZ 0x0015b16a
MOV RDI,R14
CALL 0x0013b639
DEC R15D
JNZ 0x0015b0e8
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e080d]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x0015b1ff
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0015b14b:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1deb0a]
MOV ESI,0x24dd
CALL 0x0013bb30
LAB_0015b16a:
LEA RDI,[0x1dedac]
LEA RDX,[0x1e9538]
MOV ESI,0x24e1
CALL 0x0013bb30
LAB_0015b182:
MOV RDI,R14
CALL 0x0013bbbe
LEA RDI,[0x1dedac]
LEA RDX,[0x1ea967]
MOV ESI,0x24df
CALL 0x0013bb30
LAB_0015b1a2:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x24d0
CALL 0x0013bb30
LAB_0015b1c1:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x24d3
CALL 0x0013bb30
LAB_0015b1e0:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x24d8
CALL 0x0013bb30
LAB_0015b1ff:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x24e6
CALL 0x0013bb30
|
void test_distinct(void)
{
int *puVar1;
int iVar2;
int iVar3;
long lVar4;
puVar1 = PTR_stdout_0049ffc0;
if (opt_silent < '\x02') {
__fprintf_chk(*(int8 *)PTR_stdout_0049ffc0,1,"\n\n#####################################\n"
);
iVar2 = test_count;
test_count = test_count + 1;
__fprintf_chk(*(int8 *)puVar1,1,"%u of (%u/%u): %s",iVar2,iter_count,opt_count,
"test_distinct");
__fprintf_chk(*(int8 *)puVar1,1," \n#####################################\n");
fflush(*(FILE **)puVar1);
}
iVar2 = wrap_mysql_query(mysql,"DROP TABLE IF EXISTS t1");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24d0,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,"CREATE TABLE t1 (a int , b int);");
if (iVar2 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24d3,"r == 0");
}
iVar2 = wrap_mysql_query(mysql,
"insert into t1 values (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (1, 10), (2, 20), (3, 30), (4, 40), (5, 50);"
);
if (iVar2 == 0) {
iVar2 = 3;
do {
lVar4 = mysql_simple_prepare
(mysql,"SELECT 2+count(distinct b), group_concat(a) FROM t1 group by a");
if (lVar4 == 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24dd,"stmt != 0")
;
}
iVar3 = wrap_mysql_stmt_execute(lVar4);
if (iVar3 != 0) {
print_st_error(lVar4);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24df,"rc == 0");
}
iVar3 = my_process_stmt_result(lVar4);
if (iVar3 != 5) {
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24e1,"rc == 5");
}
wrap_mysql_stmt_close(lVar4);
iVar2 = iVar2 + -1;
} while (iVar2 != 0);
iVar2 = wrap_mysql_query(mysql,"DROP TABLE t1");
if (iVar2 == 0) {
return;
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24e6,"r == 0");
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x24d8,"r == 0");
}
|
|
17,719
|
nglog::DoRawLog(char**, unsigned long*, char const*, ...)
|
ng-log[P]ng-log/src/raw_logging.cc
|
static bool DoRawLog(char** buf, size_t* size, const char* format, ...) {
va_list ap;
va_start(ap, format);
int n = std::vsnprintf(*buf, *size, format, ap);
va_end(ap);
if (n < 0 || static_cast<size_t>(n) > *size) return false;
*size -= static_cast<size_t>(n);
*buf += n;
return true;
}
|
O3
|
cpp
|
nglog::DoRawLog(char**, unsigned long*, char const*, ...):
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x29a5b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax # imm = 0x3000000018
movq %rax, (%rcx)
movq (%rdi), %rdi
movq (%r14), %rsi
callq 0x11550
testl %eax, %eax
js 0x29a9a
movl %eax, %eax
movq (%r14), %rcx
subq %rax, %rcx
jb 0x29a9a
movq %rcx, (%r14)
addq %rax, (%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
|
_ZN5nglogL8DoRawLogEPPcPmPKcz:
push r14
push rbx
sub rsp, 0D8h
mov r14, rsi
mov rbx, rdi
lea rsi, [rsp+0E8h+var_C8]
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_29A5B
movaps [rsp+0E8h+var_98], xmm0
movaps [rsp+0E8h+var_88], xmm1
movaps [rsp+0E8h+var_78], xmm2
movaps [rsp+0E8h+var_68], xmm3
movaps [rsp+0E8h+var_58], xmm4
movaps [rsp+0E8h+var_48], xmm5
movaps [rsp+0E8h+var_38], xmm6
movaps [rsp+0E8h+var_28], xmm7
loc_29A5B:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0E8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000018h
mov [rcx], rax
mov rdi, [rdi]
mov rsi, [r14]
call _vsnprintf
test eax, eax
js short loc_29A9A
mov eax, eax
mov rcx, [r14]
sub rcx, rax
jb short loc_29A9A
mov [r14], rcx
add [rbx], rax
loc_29A9A:
add rsp, 0D8h
pop rbx
pop r14
retn
|
long long nglog::DoRawLog(
nglog *this,
char **a2,
unsigned long long *a3,
const char *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 result; // rax
_QWORD v16[4]; // [rsp+0h] [rbp-E8h] BYREF
char v17; // [rsp+20h] [rbp-C8h] BYREF
const char *v18; // [rsp+38h] [rbp-B0h]
long long v19; // [rsp+40h] [rbp-A8h]
long long v20; // [rsp+48h] [rbp-A0h]
__m128 v21; // [rsp+50h] [rbp-98h]
__m128 v22; // [rsp+60h] [rbp-88h]
__m128 v23; // [rsp+70h] [rbp-78h]
__m128 v24; // [rsp+80h] [rbp-68h]
__m128 v25; // [rsp+90h] [rbp-58h]
__m128 v26; // [rsp+A0h] [rbp-48h]
__m128 v27; // [rsp+B0h] [rbp-38h]
__m128 v28; // [rsp+C0h] [rbp-28h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v18 = a4;
v19 = a5;
v20 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000018LL;
result = vsnprintf(*(_QWORD *)this, *a2, a3, v16);
if ( (int)result >= 0 )
{
result = (unsigned int)result;
if ( (unsigned long long)*a2 >= (unsigned int)result )
{
*a2 -= (unsigned int)result;
*(_QWORD *)this += (unsigned int)result;
}
}
return result;
}
|
DoRawLog:
PUSH R14
PUSH RBX
SUB RSP,0xd8
MOV R14,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x18],RCX
MOV qword ptr [RSI + 0x20],R8
MOV qword ptr [RSI + 0x28],R9
TEST AL,AL
JZ 0x00129a5b
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_00129a5b:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xf0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000018
MOV qword ptr [RCX],RAX
MOV RDI,qword ptr [RDI]
MOV RSI,qword ptr [R14]
CALL 0x00111550
TEST EAX,EAX
JS 0x00129a9a
MOV EAX,EAX
MOV RCX,qword ptr [R14]
SUB RCX,RAX
JC 0x00129a9a
MOV qword ptr [R14],RCX
ADD qword ptr [RBX],RAX
LAB_00129a9a:
ADD RSP,0xd8
POP RBX
POP R14
RET
|
/* nglog::DoRawLog(char**, unsigned long*, char const*, ...) */
void nglog::DoRawLog(char **param_1,ulong *param_2,char *param_3,...)
{
char in_AL;
uint uVar1;
ulong uVar2;
int8 in_RCX;
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;
int8 local_e8;
int1 *local_e0;
int1 *local_d8;
int1 local_c8 [24];
int8 local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int8 local_38;
int8 local_28;
local_d8 = local_c8;
if (in_AL != '\0') {
local_98 = in_XMM0_Qa;
local_88 = in_XMM1_Qa;
local_78 = in_XMM2_Qa;
local_68 = in_XMM3_Qa;
local_58 = in_XMM4_Qa;
local_48 = in_XMM5_Qa;
local_38 = in_XMM6_Qa;
local_28 = in_XMM7_Qa;
}
local_e0 = &stack0x00000008;
local_e8 = 0x3000000018;
local_b0 = in_RCX;
local_a8 = in_R8;
local_a0 = in_R9;
uVar1 = vsnprintf(*param_1,*param_2,param_3,&local_e8);
if (-1 < (int)uVar1) {
uVar2 = (ulong)uVar1;
if (uVar2 <= *param_2) {
*param_2 = *param_2 - uVar2;
*param_1 = *param_1 + uVar2;
}
}
return;
}
|
|
17,720
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [5], 0>(char const (&) [5])
|
monkey531[P]llama/common/json.hpp
|
size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
}
|
O2
|
cpp
|
unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [5], 0>(char const (&) [5]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x73a27
movq %rbx, %rdi
movq %r15, %rsi
callq 0x26bd3
testb %al, %al
jne 0x739fa
addq $0x30, %rbx
jmp 0x739dc
movq %rbx, %r15
leaq 0x30(%r15), %r12
cmpq 0x8(%r14), %r12
je 0x73a1f
movq %r15, %rdi
callq 0x36286
movq %r15, %rdi
movq %r12, %rsi
callq 0x36ee6
movq %r12, %r15
jmp 0x739fd
movq %r14, %rdi
callq 0x736b0
xorl %eax, %eax
cmpq %r13, %rbx
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_739DC:
mov r13, [r14+8]
cmp rbx, r13
jz short loc_73A27
mov rdi, rbx
mov rsi, r15
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_739FA
add rbx, 30h ; '0'
jmp short loc_739DC
loc_739FA:
mov r15, rbx
loc_739FD:
lea r12, [r15+30h]
cmp r12, [r14+8]
jz short loc_73A1F
mov rdi, r15; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, r15
mov rsi, r12
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
mov r15, r12
jmp short loc_739FD
loc_73A1F:
mov rdi, r14
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
loc_73A27:
xor eax, eax
cmp rbx, r13
setnz al
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
_BOOL8 ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long *a1)
{
long long i; // rbx
long long v2; // r13
char *j; // r15
for ( i = *a1; ; i += 48LL )
{
v2 = a1[1];
if ( i == v2 )
break;
if ( std::operator==<char>(i) )
{
for ( j = (char *)i; j + 48 != (char *)a1[1]; j += 48 )
{
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(j);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
(long long)j,
(long long)(j + 48));
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back((long long)a1);
return i != v2;
}
}
return i != v2;
}
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_001739dc:
MOV R13,qword ptr [R14 + 0x8]
CMP RBX,R13
JZ 0x00173a27
MOV RDI,RBX
MOV RSI,R15
CALL 0x00126bd3
TEST AL,AL
JNZ 0x001739fa
ADD RBX,0x30
JMP 0x001739dc
LAB_001739fa:
MOV R15,RBX
LAB_001739fd:
LEA R12,[R15 + 0x30]
CMP R12,qword ptr [R14 + 0x8]
JZ 0x00173a1f
MOV RDI,R15
CALL 0x00136286
MOV RDI,R15
MOV RSI,R12
CALL 0x00136ee6
MOV R15,R12
JMP 0x001739fd
LAB_00173a1f:
MOV RDI,R14
CALL 0x001736b0
LAB_00173a27:
XOR EAX,EAX
CMP RBX,R13
SETNZ AL
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
bool _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
pair *ppVar1;
string *psVar2;
bool bVar3;
string *psVar4;
pair *this;
for (psVar4 = *(string **)param_1; psVar2 = *(string **)(param_1 + 8), psVar4 != psVar2;
psVar4 = psVar4 + 0x30) {
bVar3 = std::operator==(psVar4,param_2);
this = (pair *)psVar4;
if (bVar3) goto LAB_001739fd;
}
LAB_00173a27:
return psVar4 != psVar2;
LAB_001739fd:
while (ppVar1 = (pair *)((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this + 0x30), ppVar1 != *(pair **)(param_1 + 8)) {
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this);
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this,ppVar1);
this = ppVar1;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::pop_back(param_1);
goto LAB_00173a27;
}
|
|
17,721
|
psi_rwlock_wrlock
|
eloqsql/mysys/my_thr_init.c
|
ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_wrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
}
|
O0
|
c
|
psi_rwlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1a836e(%rip), %rax # 0x1e1bb8
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39fe0
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x398a3
leaq 0x1a8328(%rip), %rax # 0x1e1bb8
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
psi_rwlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_398A3
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_398A3:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
|
long long psi_rwlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = (*((long long ( **)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server + 54))(
v6,
*(_QWORD *)(a1 + 144),
1LL,
a2,
a3);
v4 = my_rw_wrlock(v9);
if ( v5 )
(*((void ( **)(long long, _QWORD))PSI_server + 55))(v5, v4);
return v4;
}
|
psi_rwlock_wrlock:
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
LEA RAX,[0x2e1bb8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00139fe0
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001398a3
LEA RAX,[0x2e1bb8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001398a3:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),1,param_2,param_3);
uVar1 = my_rw_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
|
|
17,722
|
end_partitioned_key_cache
|
eloqsql/mysys/mf_keycache.c
|
static
void end_partitioned_key_cache(PARTITIONED_KEY_CACHE_CB *keycache,
my_bool cleanup)
{
uint i;
uint partitions= keycache->partitions;
DBUG_ENTER("partitioned_end_key_cache");
DBUG_PRINT("enter", ("key_cache: %p", keycache));
for (i= 0; i < partitions; i++)
{
end_simple_key_cache(keycache->partition_array[i], cleanup);
}
if (cleanup)
{
for (i= 0; i < partitions; i++)
my_free(keycache->partition_array[i]);
my_free(keycache->partition_array);
keycache->key_cache_inited= 0;
}
DBUG_VOID_RETURN;
}
|
O0
|
c
|
end_partitioned_key_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xeddbe
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xeddf0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movsbl -0x9(%rbp), %esi
callq 0xec380
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xeddc5
cmpb $0x0, -0x9(%rbp)
je 0xede38
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xede24
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0xfcc60
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xeddfd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xfcc60
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0xede3a
jmp 0xede3c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
end_partitioned_key_cache:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rax, [rbp+var_8]
mov eax, [rax+1Ch]
mov [rbp+var_14], eax
jmp short $+2
loc_EDDBE:
mov [rbp+var_10], 0
loc_EDDC5:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jnb short loc_EDDF0
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_10]
mov rdi, [rax+rcx*8]
movsx esi, [rbp+var_9]
call end_simple_key_cache
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_EDDC5
loc_EDDF0:
cmp [rbp+var_9], 0
jz short loc_EDE38
mov [rbp+var_10], 0
loc_EDDFD:
mov eax, [rbp+var_10]
cmp eax, [rbp+var_14]
jnb short loc_EDE24
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov ecx, [rbp+var_10]
mov rdi, [rax+rcx*8]
call my_free
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_EDDFD
loc_EDE24:
mov rax, [rbp+var_8]
mov rdi, [rax+8]
call my_free
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
loc_EDE38:
jmp short $+2
loc_EDE3A:
jmp short $+2
loc_EDE3C:
add rsp, 20h
pop rbp
retn
|
long long end_partitioned_key_cache(long long a1, char a2)
{
long long result; // rax
unsigned int v3; // [rsp+Ch] [rbp-14h]
unsigned int i; // [rsp+10h] [rbp-10h]
unsigned int j; // [rsp+10h] [rbp-10h]
v3 = *(_DWORD *)(a1 + 28);
for ( i = 0; ; ++i )
{
result = i;
if ( i >= v3 )
break;
end_simple_key_cache(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * i), a2);
}
if ( a2 )
{
for ( j = 0; j < v3; ++j )
my_free(*(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL * j));
my_free(*(_QWORD *)(a1 + 8));
result = a1;
*(_BYTE *)a1 = 0;
}
return result;
}
|
end_partitioned_key_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x1c]
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001eddbe
LAB_001eddbe:
MOV dword ptr [RBP + -0x10],0x0
LAB_001eddc5:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x001eddf0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + RCX*0x8]
MOVSX ESI,byte ptr [RBP + -0x9]
CALL 0x001ec380
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001eddc5
LAB_001eddf0:
CMP byte ptr [RBP + -0x9],0x0
JZ 0x001ede38
MOV dword ptr [RBP + -0x10],0x0
LAB_001eddfd:
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x14]
JNC 0x001ede24
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + RCX*0x8]
CALL 0x001fcc60
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x001eddfd
LAB_001ede24:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001fcc60
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
LAB_001ede38:
JMP 0x001ede3a
LAB_001ede3a:
JMP 0x001ede3c
LAB_001ede3c:
ADD RSP,0x20
POP RBP
RET
|
void end_partitioned_key_cache(int1 *param_1,char param_2)
{
uint uVar1;
uint local_18;
uVar1 = *(uint *)(param_1 + 0x1c);
for (local_18 = 0; local_18 < uVar1; local_18 = local_18 + 1) {
end_simple_key_cache(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_18 * 8),(int)param_2)
;
}
if (param_2 != '\0') {
for (local_18 = 0; local_18 < uVar1; local_18 = local_18 + 1) {
my_free(*(int8 *)(*(long *)(param_1 + 8) + (ulong)local_18 * 8));
}
my_free(*(int8 *)(param_1 + 8));
*param_1 = 0;
}
return;
}
|
|
17,723
|
reciprocal_fr
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/recip.c
|
static void reciprocal_fr(vec256 out, const vec256 inp)
{
static const vec256 rx2 = { /* left-aligned value of the modulus */
TO_LIMB_T(0xfffffffe00000002), TO_LIMB_T(0xa77b4805fffcb7fd),
TO_LIMB_T(0x6673b0101343b00a), TO_LIMB_T(0xe7db4ea6533afa90),
};
vec512 temp;
ct_inverse_mod_256(temp, inp, BLS12_381_r, rx2);
redc_mont_256(out, temp, BLS12_381_r, r0);
mul_mont_sparse_256(out, out, BLS12_381_rRR, BLS12_381_r, r0);
}
|
O3
|
c
|
reciprocal_fr:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x2a29d(%rip), %r14 # 0x8ca40
leaq 0x2c116(%rip), %rcx # 0x8e8c0
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x76c20
movabsq $-0x100000001, %r12 # imm = 0xFFFFFFFEFFFFFFFF
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x76500
leaq 0x2a775(%rip), %rdx # 0x8cf50
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rcx
movq %r12, %r8
callq 0x76040
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
reciprocal_fr:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov rbx, rdi
lea r14, BLS12_381_r
lea rcx, reciprocal_fr_rx2
lea r15, [rbp+var_60]
mov rdi, r15
mov rdx, r14
call ct_inverse_mod_256
mov r12, 0FFFFFFFEFFFFFFFFh
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov rcx, r12
call redc_mont_256
lea rdx, BLS12_381_rRR
mov rdi, rbx
mov rsi, rbx
mov rcx, r14
mov r8, r12
call mul_mont_sparse_256
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long reciprocal_fr(long long a1, long long a2)
{
_BYTE v3[96]; // [rsp+0h] [rbp-60h] BYREF
ct_inverse_mod_256(v3, a2, &BLS12_381_r, &reciprocal_fr_rx2);
redc_mont_256(a1, v3, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
return mul_mont_sparse_256(a1, a1, &BLS12_381_rRR, &BLS12_381_r, 0xFFFFFFFEFFFFFFFFLL);
}
|
reciprocal_fr:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
LEA R14,[0x18ca40]
LEA RCX,[0x18e8c0]
LEA R15,[RBP + -0x60]
MOV RDI,R15
MOV RDX,R14
CALL 0x00176c20
MOV R12,-0x100000001
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
CALL 0x00176500
LEA RDX,[0x18cf50]
MOV RDI,RBX
MOV RSI,RBX
MOV RCX,R14
MOV R8,R12
CALL 0x00176040
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void reciprocal_fr(int8 param_1,int8 param_2)
{
int1 local_68 [64];
ct_inverse_mod_256(local_68,param_2,BLS12_381_r,reciprocal_fr_rx2);
redc_mont_256(param_1,local_68,BLS12_381_r,0xfffffffeffffffff);
mul_mont_sparse_256(param_1,param_1,BLS12_381_rRR,BLS12_381_r,0xfffffffeffffffff);
return;
}
|
|
17,724
|
my_casedn_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
}
|
O0
|
c
|
my_casedn_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x43512
jmp 0x43514
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x4354b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x43514
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_casedn_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_38], rax
jmp short $+2
loc_43512:
jmp short $+2
loc_43514:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jz short loc_4354B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_43514
loc_4354B:
mov rax, [rbp+var_18]
pop rbp
retn
|
long long my_casedn_8bit(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4)
{
_BYTE *v4; // rax
long long v6; // [rsp+0h] [rbp-38h]
unsigned __int8 *v8; // [rsp+28h] [rbp-10h]
v8 = a2;
v6 = *(_QWORD *)(a1 + 72);
while ( v8 != &a2[a3] )
{
v4 = a4++;
*v4 = *(_BYTE *)(v6 + *v8++);
}
return a3;
}
|
my_casedn_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00143512
LAB_00143512:
JMP 0x00143514
LAB_00143514:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x0014354b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00143514
LAB_0014354b:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long my_casedn_8bit(long param_1,byte *param_2,long param_3,int1 *param_4)
{
long lVar1;
int1 *local_28;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_28 = param_4;
for (local_18 = param_2; local_18 != param_2 + param_3; local_18 = local_18 + 1) {
*local_28 = *(int1 *)(lVar1 + (ulong)*local_18);
local_28 = local_28 + 1;
}
return param_3;
}
|
|
17,725
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++()
|
monkey531[P]llama/common/json.hpp
|
iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
}
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::operator++():
movq (%rdi), %rax
testq %rax, %rax
je 0x61a47
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x61a38
cmpl $0x1, %eax
jne 0x61a3f
addq $0x30, 0x8(%rdi)
jmp 0x61a43
addq $0x10, 0x10(%rdi)
jmp 0x61a43
incq 0x18(%rdi)
movq %rdi, %rax
retq
pushq %rax
leaq 0x8d884(%rip), %rdi # 0xef2d3
leaq 0x879c6(%rip), %rdx # 0xe941c
leaq 0x92a37(%rip), %rcx # 0xf4494
movl $0x33c0, %esi # imm = 0x33C0
xorl %eax, %eax
callq 0x1c130
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
mov rax, [rdi]
test rax, rax
jz short loc_61A47
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_61A38
cmp eax, 1
jnz short loc_61A3F
add qword ptr [rdi+8], 30h ; '0'
jmp short loc_61A43
loc_61A38:
add qword ptr [rdi+10h], 10h
jmp short loc_61A43
loc_61A3F:
inc qword ptr [rdi+18h]
loc_61A43:
mov rax, rdi
retn
loc_61A47:
push rax
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aAnchorMObjectN+7; "m_object != nullptr"
mov esi, 33C0h
xor eax, eax
call _ggml_abort
nop
|
long long nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( *a1 )
{
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] += 48;
}
else
{
++a1[3];
}
return (long long)a1;
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
13248LL,
"GGML_ASSERT(%s) failed",
"m_object != nullptr");
return 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>::data::~data("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp");
}
}
|
operator++:
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x00161a47
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x00161a38
CMP EAX,0x1
JNZ 0x00161a3f
ADD qword ptr [RDI + 0x8],0x30
JMP 0x00161a43
LAB_00161a38:
ADD qword ptr [RDI + 0x10],0x10
JMP 0x00161a43
LAB_00161a3f:
INC qword ptr [RDI + 0x18]
LAB_00161a43:
MOV RAX,RDI
RET
LAB_00161a47:
PUSH RAX
LEA RDI,[0x1ef2d3]
LEA RDX,[0x1e941c]
LEA RCX,[0x1f4494]
MOV ESI,0x33c0
XOR EAX,EAX
CALL 0x0011c130
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
char cVar1;
int8 in_R8;
int8 in_R9;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
*(long *)(this + 8) = *(long *)(this + 8) + 0x30;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x33c0,
"GGML_ASSERT(%s) failed","m_object != nullptr",in_R8,in_R9,0);
}
|
|
17,726
|
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>>>>>::get_codepoint()
|
monkey531[P]llama/common/json.hpp
|
int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
|
O0
|
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>>>>>::get_codepoint():
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x75, 0x14(%rax)
je 0xa2cca
leaq 0x1674c0(%rip), %rdi # 0x20a170
movl $0x1d79, %esi # imm = 0x1D79
leaq 0x1674fe(%rip), %rdx # 0x20a1ba
leaq 0x1681f7(%rip), %rcx # 0x20aeba
movb $0x0, %al
callq 0x59e90
movl $0x0, 0x54(%rsp)
movl $0xc, 0x30(%rsp)
movl $0x8, 0x34(%rsp)
movl $0x4, 0x38(%rsp)
movl $0x0, 0x3c(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x4, 0x48(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa30b0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa30c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xa2e08
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
callq 0xa1e40
movq 0x8(%rsp), %rax
cmpl $0x30, 0x14(%rax)
jl 0xa2d83
movq 0x8(%rsp), %rax
cmpl $0x39, 0x14(%rax)
jg 0xa2d83
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x30, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa2df3
movq 0x8(%rsp), %rax
cmpl $0x41, 0x14(%rax)
jl 0xa2db4
movq 0x8(%rsp), %rax
cmpl $0x46, 0x14(%rax)
jg 0xa2db4
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x37, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa2df1
movq 0x8(%rsp), %rax
cmpl $0x61, 0x14(%rax)
jl 0xa2de5
movq 0x8(%rsp), %rax
cmpl $0x66, 0x14(%rax)
jg 0xa2de5
movq 0x8(%rsp), %rax
movl 0x14(%rax), %eax
subl $0x57, %eax
movl 0x14(%rsp), %ecx
shll %cl, %eax
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0xa2def
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
jmp 0xa2e43
jmp 0xa2df1
jmp 0xa2df3
jmp 0xa2df5
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0xa2d2d
xorl %eax, %eax
cmpl 0x54(%rsp), %eax
jg 0xa2e1a
cmpl $0xffff, 0x54(%rsp) # imm = 0xFFFF
jle 0xa2e3b
leaq 0x16734f(%rip), %rdi # 0x20a170
movl $0x1d93, %esi # imm = 0x1D93
leaq 0x16738d(%rip), %rdx # 0x20a1ba
leaq 0x168095(%rip), %rcx # 0x20aec9
movb $0x0, %al
callq 0x59e90
movl 0x54(%rsp), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
sub rsp, 68h
mov [rsp+68h+var_10], rdi
mov rax, [rsp+68h+var_10]
mov [rsp+68h+var_60], rax
cmp dword ptr [rax+14h], 75h ; 'u'
jz short loc_A2CCA
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1D79h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov al, 0
call _ggml_abort
loc_A2CCA:
mov [rsp+68h+var_14], 0
mov [rsp+68h+var_38], 0Ch
mov [rsp+68h+var_34], 8
mov [rsp+68h+var_30], 4
mov [rsp+68h+var_2C], 0
lea rax, [rsp+68h+var_38]
mov [rsp+68h+var_28], rax
mov [rsp+68h+var_20], 4
lea rax, [rsp+68h+var_28]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_40]
call _ZNKSt16initializer_listIjE5beginEv; std::initializer_list<uint>::begin(void)
mov [rsp+68h+var_48], rax
mov rdi, [rsp+68h+var_40]
call _ZNKSt16initializer_listIjE3endEv; std::initializer_list<uint>::end(void)
mov [rsp+68h+var_50], rax
loc_A2D2D:
mov rax, [rsp+68h+var_48]
cmp rax, [rsp+68h+var_50]
jz loc_A2E08
mov rdi, [rsp+68h+var_60]
mov rax, [rsp+68h+var_48]
mov eax, [rax]
mov [rsp+68h+var_54], eax
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)
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 30h ; '0'
jl short loc_A2D83
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 39h ; '9'
jg short loc_A2D83
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 30h ; '0'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A2DF3
loc_A2D83:
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 41h ; 'A'
jl short loc_A2DB4
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 46h ; 'F'
jg short loc_A2DB4
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 37h ; '7'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A2DF1
loc_A2DB4:
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 61h ; 'a'
jl short loc_A2DE5
mov rax, [rsp+68h+var_60]
cmp dword ptr [rax+14h], 66h ; 'f'
jg short loc_A2DE5
mov rax, [rsp+68h+var_60]
mov eax, [rax+14h]
sub eax, 57h ; 'W'
mov ecx, [rsp+68h+var_54]
shl eax, cl
add eax, [rsp+68h+var_14]
mov [rsp+68h+var_14], eax
jmp short loc_A2DEF
loc_A2DE5:
mov [rsp+68h+var_4], 0FFFFFFFFh
jmp short loc_A2E43
loc_A2DEF:
jmp short $+2
loc_A2DF1:
jmp short $+2
loc_A2DF3:
jmp short $+2
loc_A2DF5:
mov rax, [rsp+68h+var_48]
add rax, 4
mov [rsp+68h+var_48], rax
jmp loc_A2D2D
loc_A2E08:
xor eax, eax
cmp eax, [rsp+68h+var_14]
jg short loc_A2E1A
cmp [rsp+68h+var_14], 0FFFFh
jle short loc_A2E3B
loc_A2E1A:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1D93h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x0000Codepoin; "0x0000 <= codepoint && codepoint <= 0xF"...
mov al, 0
call _ggml_abort
loc_A2E3B:
mov eax, [rsp+68h+var_14]
mov [rsp+68h+var_4], eax
loc_A2E43:
mov eax, [rsp+68h+var_4]
add rsp, 68h
retn
|
long long 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_codepoint(
long long a1)
{
int v2; // [rsp+14h] [rbp-54h]
long long v3; // [rsp+18h] [rbp-50h]
int *v4; // [rsp+20h] [rbp-48h]
_DWORD v5[4]; // [rsp+30h] [rbp-38h] BYREF
_QWORD v6[2]; // [rsp+40h] [rbp-28h] BYREF
unsigned int v7; // [rsp+54h] [rbp-14h]
long long v8; // [rsp+58h] [rbp-10h]
v8 = a1;
if ( *(_DWORD *)(a1 + 20) != 117 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
v7 = 0;
v5[0] = 12;
v5[1] = 8;
v5[2] = 4;
v5[3] = 0;
v6[0] = v5;
v6[1] = 4LL;
v4 = (int *)std::initializer_list<unsigned int>::begin(v6);
v3 = std::initializer_list<unsigned int>::end(v6);
while ( v4 != (int *)v3 )
{
v2 = *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);
if ( *(int *)(a1 + 20) < 48 || *(int *)(a1 + 20) > 57 )
{
if ( *(int *)(a1 + 20) < 65 || *(int *)(a1 + 20) > 70 )
{
if ( *(int *)(a1 + 20) < 97 || *(int *)(a1 + 20) > 102 )
return (unsigned int)-1;
v7 += (*(_DWORD *)(a1 + 20) - 87) << v2;
}
else
{
v7 += (*(_DWORD *)(a1 + 20) - 55) << v2;
}
}
else
{
v7 += (*(_DWORD *)(a1 + 20) - 48) << v2;
}
++v4;
}
if ( v7 >= 0x10000 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7571LL,
"GGML_ASSERT(%s) failed",
"0x0000 <= codepoint && codepoint <= 0xFFFF");
return v7;
}
|
get_codepoint:
SUB RSP,0x68
MOV qword ptr [RSP + 0x58],RDI
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RAX + 0x14],0x75
JZ 0x001a2cca
LEA RDI,[0x30a170]
MOV ESI,0x1d79
LEA RDX,[0x30a1ba]
LEA RCX,[0x30aeba]
MOV AL,0x0
CALL 0x00159e90
LAB_001a2cca:
MOV dword ptr [RSP + 0x54],0x0
MOV dword ptr [RSP + 0x30],0xc
MOV dword ptr [RSP + 0x34],0x8
MOV dword ptr [RSP + 0x38],0x4
MOV dword ptr [RSP + 0x3c],0x0
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],0x4
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a30b0
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001a30c0
MOV qword ptr [RSP + 0x18],RAX
LAB_001a2d2d:
MOV RAX,qword ptr [RSP + 0x20]
CMP RAX,qword ptr [RSP + 0x18]
JZ 0x001a2e08
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x14],EAX
CALL 0x001a1e40
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x30
JL 0x001a2d83
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x39
JG 0x001a2d83
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x30
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a2df3
LAB_001a2d83:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x41
JL 0x001a2db4
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x46
JG 0x001a2db4
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x37
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a2df1
LAB_001a2db4:
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x61
JL 0x001a2de5
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x14],0x66
JG 0x001a2de5
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x57
MOV ECX,dword ptr [RSP + 0x14]
SHL EAX,CL
ADD EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x54],EAX
JMP 0x001a2def
LAB_001a2de5:
MOV dword ptr [RSP + 0x64],0xffffffff
JMP 0x001a2e43
LAB_001a2def:
JMP 0x001a2df1
LAB_001a2df1:
JMP 0x001a2df3
LAB_001a2df3:
JMP 0x001a2df5
LAB_001a2df5:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,0x4
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001a2d2d
LAB_001a2e08:
XOR EAX,EAX
CMP EAX,dword ptr [RSP + 0x54]
JG 0x001a2e1a
CMP dword ptr [RSP + 0x54],0xffff
JLE 0x001a2e3b
LAB_001a2e1a:
LEA RDI,[0x30a170]
MOV ESI,0x1d93
LEA RDX,[0x30a1ba]
LEA RCX,[0x30aec9]
MOV AL,0x0
CALL 0x00159e90
LAB_001a2e3b:
MOV EAX,dword ptr [RSP + 0x54]
MOV dword ptr [RSP + 0x64],EAX
LAB_001a2e43:
MOV EAX,dword ptr [RSP + 0x64]
ADD RSP,0x68
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 > > >::get_codepoint() */
int __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>>>
::get_codepoint(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)
{
int4 uVar1;
int iVar2;
int4 *puVar3;
byte bVar4;
int4 *local_48;
int4 local_38;
int4 local_34;
int4 local_30;
int4 local_2c;
int4 *local_28;
int8 local_20;
int local_14;
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>>>
*local_10;
local_10 = this;
if (*(int *)(this + 0x14) != 0x75) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1d79,
"GGML_ASSERT(%s) failed","current == \'u\'");
}
local_14 = 0;
local_38 = 0xc;
local_34 = 8;
local_30 = 4;
local_2c = 0;
local_28 = &local_38;
local_20 = 4;
local_48 = (int4 *)
std::initializer_list<unsigned_int>::begin((initializer_list<unsigned_int> *)&local_28)
;
puVar3 = (int4 *)
std::initializer_list<unsigned_int>::end((initializer_list<unsigned_int> *)&local_28);
do {
if (local_48 == puVar3) {
if ((local_14 < 0) || (0xffff < local_14)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1d93,"GGML_ASSERT(%s) failed","0x0000 <= codepoint && codepoint <= 0xFFFF");
}
return local_14;
}
uVar1 = *local_48;
get(this);
bVar4 = (byte)uVar1;
if ((*(int *)(this + 0x14) < 0x30) || (0x39 < *(int *)(this + 0x14))) {
if ((*(int *)(this + 0x14) < 0x41) || (0x46 < *(int *)(this + 0x14))) {
if ((*(int *)(this + 0x14) < 0x61) || (0x66 < *(int *)(this + 0x14))) {
return -1;
}
iVar2 = *(int *)(this + 0x14) + -0x57 << (bVar4 & 0x1f);
}
else {
iVar2 = *(int *)(this + 0x14) + -0x37 << (bVar4 & 0x1f);
}
}
else {
iVar2 = *(int *)(this + 0x14) + -0x30 << (bVar4 & 0x1f);
}
local_14 = iVar2 + local_14;
local_48 = local_48 + 1;
} while( true );
}
|
|
17,727
|
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>>>>>::get_codepoint()
|
monkey531[P]llama/common/json.hpp
|
int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
|
O1
|
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>>>>>::get_codepoint():
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x581fc
leaq 0x14(%rdi), %rsi
leaq 0xc(%rsp), %rbx
movq %rbx, %rdx
callq 0x1b32a
movl (%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x949d6(%rip), %rdi # 0xecbd9
leaq 0x94a19(%rip), %rdx # 0xecc23
leaq 0x956f7(%rip), %rcx # 0xed908
movl $0x1d79, %esi # imm = 0x1D79
xorl %eax, %eax
callq 0x1ae30
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
push rbx
sub rsp, 10h
cmp dword ptr [rdi+14h], 75h ; 'u'
jnz short loc_581FC
lea rsi, [rdi+14h]
lea rbx, [rsp+18h+var_C]
mov rdx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv_cold_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,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_codepoint(void) [clone]
mov eax, [rbx]
add rsp, 10h
pop rbx
retn
loc_581FC:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov esi, 1D79h
xor eax, eax
call _ggml_abort
nop
|
long long 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_codepoint(
__m128i *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
unsigned int v14[3]; // [rsp+Ch] [rbp-Ch] BYREF
if ( a1[1].m128i_i32[1] == 117 )
{
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_codepoint(
a1,
&a1[1].m128i_i32[1],
v14);
return v14[0];
}
else
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
return 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>>>::next_byte_in_range(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
v10,
v11,
v12,
v13,
a7,
a8,
a9);
}
}
|
get_codepoint:
PUSH RBX
SUB RSP,0x10
CMP dword ptr [RDI + 0x14],0x75
JNZ 0x001581fc
LEA RSI,[RDI + 0x14]
LEA RBX,[RSP + 0xc]
MOV RDX,RBX
CALL 0x0011b32a
MOV EAX,dword ptr [RBX]
ADD RSP,0x10
POP RBX
RET
LAB_001581fc:
LEA RDI,[0x1ecbd9]
LEA RDX,[0x1ecc23]
LEA RCX,[0x1ed908]
MOV ESI,0x1d79
XOR EAX,EAX
CALL 0x0011ae30
|
/* 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 > > >::get_codepoint() */
int4 __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>>>
::get_codepoint(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)
{
int4 local_c;
if (*(int *)(this + 0x14) == 0x75) {
get_codepoint();
return local_c;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1d79,
"GGML_ASSERT(%s) failed","current == \'u\'");
}
|
|
17,728
|
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>>>>>::get_codepoint()
|
monkey531[P]llama/common/json.hpp
|
int get_codepoint()
{
// this function only makes sense after reading `\u`
JSON_ASSERT(current == 'u');
int codepoint = 0;
const auto factors = { 12u, 8u, 4u, 0u };
for (const auto factor : factors)
{
get();
if (current >= '0' && current <= '9')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
}
else if (current >= 'A' && current <= 'F')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
}
else if (current >= 'a' && current <= 'f')
{
codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
}
else
{
return -1;
}
}
JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
return codepoint;
}
|
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>>>>>::get_codepoint():
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x14(%rdi)
jne 0x3e0f9
movq %rdi, %rbx
movaps 0x6b2a4(%rip), %xmm0 # 0xa9330
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
pushq $-0x1
popq %r12
xorl %ebp, %ebp
cmpq $0x10, %r15
je 0x3e0dd
movl (%rsp,%r15), %r14d
movq %rbx, %rdi
callq 0x3ddf2
movl 0x14(%rbx), %eax
leal -0x30(%rax), %edx
cmpl $0xa, %edx
jb 0x3e0d0
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3e0c3
addl $-0x37, %eax
jmp 0x3e0ce
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x3e0f4
addl $-0x57, %eax
movl %eax, %edx
movl %r14d, %ecx
shll %cl, %edx
addl %edx, %ebp
addq $0x4, %r15
jmp 0x3e099
cmpl $0x10000, %ebp # imm = 0x10000
jae 0x3e115
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %ebp
jmp 0x3e0e5
leaq 0x70adc(%rip), %rdi # 0xaebdc
leaq 0x70b1f(%rip), %rdx # 0xaec26
leaq 0x7180c(%rip), %rcx # 0xaf91a
movl $0x1d79, %esi # imm = 0x1D79
jmp 0x3e12f
leaq 0x70ac0(%rip), %rdi # 0xaebdc
leaq 0x70b03(%rip), %rdx # 0xaec26
leaq 0x717ff(%rip), %rcx # 0xaf929
movl $0x1d93, %esi # imm = 0x1D93
xorl %eax, %eax
callq 0x23e40
|
_ZN8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE13get_codepointEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
cmp dword ptr [rdi+14h], 75h ; 'u'
jnz short loc_3E0F9
mov rbx, rdi
movaps xmm0, cs:xmmword_A9330
movaps [rsp+38h+var_38], xmm0
xor r15d, r15d
push 0FFFFFFFFFFFFFFFFh
pop r12
xor ebp, ebp
loc_3E099:
cmp r15, 10h
jz short loc_3E0DD
mov r14d, dword ptr [rsp+r15+38h+var_38]
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)
mov eax, [rbx+14h]
lea edx, [rax-30h]
cmp edx, 0Ah
jb short loc_3E0D0
lea ecx, [rax-41h]
cmp ecx, 5
ja short loc_3E0C3
add eax, 0FFFFFFC9h
jmp short loc_3E0CE
loc_3E0C3:
lea ecx, [rax-61h]
cmp ecx, 5
ja short loc_3E0F4
add eax, 0FFFFFFA9h
loc_3E0CE:
mov edx, eax
loc_3E0D0:
mov ecx, r14d
shl edx, cl
add ebp, edx
add r15, 4
jmp short loc_3E099
loc_3E0DD:
cmp ebp, 10000h
jnb short loc_3E115
loc_3E0E5:
mov eax, ebp
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_3E0F4:
mov ebp, r12d
jmp short loc_3E0E5
loc_3E0F9:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurrentU; "current == 'u'"
mov esi, 1D79h
jmp short loc_3E12F
loc_3E115:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, a0x0000Codepoin; "0x0000 <= codepoint && codepoint <= 0xF"...
mov esi, 1D93h
loc_3E12F:
xor eax, eax
call _ggml_abort
|
long long 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_codepoint(
__m128i *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
long long a9)
{
long long v9; // r15
unsigned int v10; // ebp
int v11; // r14d
__int32 v12; // eax
__int32 v13; // edx
__int32 v14; // eax
long long v16; // rsi
long long v17; // rdx
long long v18; // rcx
long long v19; // r8
long long v20; // r9
_OWORD v21[3]; // [rsp+0h] [rbp-38h]
if ( a1[1].m128i_i32[1] == 117 )
{
v21[0] = xmmword_A9330;
v9 = 0LL;
v10 = 0;
while ( v9 != 16 )
{
v11 = *(_DWORD *)((char *)v21 + v9);
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);
v12 = a1[1].m128i_i32[1];
v13 = v12 - 48;
if ( (unsigned int)(v12 - 48) >= 0xA )
{
if ( (unsigned int)(v12 - 65) > 5 )
{
if ( (unsigned int)(v12 - 97) > 5 )
return (unsigned int)-1;
v14 = v12 - 87;
}
else
{
v14 = v12 - 55;
}
v13 = v14;
}
v10 += v13 << v11;
v9 += 4LL;
}
if ( v10 < 0x10000 )
return v10;
v16 = 7571LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7571LL,
"GGML_ASSERT(%s) failed",
"0x0000 <= codepoint && codepoint <= 0xFFFF");
}
else
{
v16 = 7545LL;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7545LL,
"GGML_ASSERT(%s) failed",
"current == 'u'");
}
return 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>>>::next_byte_in_range(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
v17,
v18,
v19,
v20,
a7,
a8,
a9);
}
|
get_codepoint:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
CMP dword ptr [RDI + 0x14],0x75
JNZ 0x0013e0f9
MOV RBX,RDI
MOVAPS XMM0,xmmword ptr [0x001a9330]
MOVAPS xmmword ptr [RSP],XMM0
XOR R15D,R15D
PUSH -0x1
POP R12
XOR EBP,EBP
LAB_0013e099:
CMP R15,0x10
JZ 0x0013e0dd
MOV R14D,dword ptr [RSP + R15*0x1]
MOV RDI,RBX
CALL 0x0013ddf2
MOV EAX,dword ptr [RBX + 0x14]
LEA EDX,[RAX + -0x30]
CMP EDX,0xa
JC 0x0013e0d0
LEA ECX,[RAX + -0x41]
CMP ECX,0x5
JA 0x0013e0c3
ADD EAX,-0x37
JMP 0x0013e0ce
LAB_0013e0c3:
LEA ECX,[RAX + -0x61]
CMP ECX,0x5
JA 0x0013e0f4
ADD EAX,-0x57
LAB_0013e0ce:
MOV EDX,EAX
LAB_0013e0d0:
MOV ECX,R14D
SHL EDX,CL
ADD EBP,EDX
ADD R15,0x4
JMP 0x0013e099
LAB_0013e0dd:
CMP EBP,0x10000
JNC 0x0013e115
LAB_0013e0e5:
MOV EAX,EBP
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0013e0f4:
MOV EBP,R12D
JMP 0x0013e0e5
LAB_0013e0f9:
LEA RDI,[0x1aebdc]
LEA RDX,[0x1aec26]
LEA RCX,[0x1af91a]
MOV ESI,0x1d79
JMP 0x0013e12f
LAB_0013e115:
LEA RDI,[0x1aebdc]
LEA RDX,[0x1aec26]
LEA RCX,[0x1af929]
MOV ESI,0x1d93
LAB_0013e12f:
XOR EAX,EAX
CALL 0x00123e40
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* 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 > > >::get_codepoint() */
uint __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>>>
::get_codepoint(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)
{
int4 uVar1;
int iVar2;
uint uVar3;
char *pcVar4;
uint uVar5;
int8 uVar6;
long lVar7;
int8 local_38;
int8 uStack_30;
if (*(int *)(this + 0x14) == 0x75) {
local_38 = _DAT_001a9330;
uStack_30 = _UNK_001a9338;
uVar5 = 0;
for (lVar7 = 0; lVar7 != 0x10; lVar7 = lVar7 + 4) {
uVar1 = *(int4 *)((long)&local_38 + lVar7);
get(this);
iVar2 = *(int *)(this + 0x14);
uVar3 = iVar2 - 0x30;
if (9 < uVar3) {
if (iVar2 - 0x41U < 6) {
uVar3 = iVar2 - 0x37;
}
else {
if (5 < iVar2 - 0x61U) {
return 0xffffffff;
}
uVar3 = iVar2 - 0x57;
}
}
uVar5 = uVar5 + (uVar3 << ((byte)uVar1 & 0x1f));
}
if (uVar5 < 0x10000) {
return uVar5;
}
pcVar4 = "0x0000 <= codepoint && codepoint <= 0xFFFF";
uVar6 = 0x1d93;
}
else {
pcVar4 = "current == \'u\'";
uVar6 = 0x1d79;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
|
|
17,729
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
virtual ~StencilTableReal() {}
|
O1
|
c
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal():
pushq %rbx
movq %rdi, %rbx
movq 0x6c1b3(%rip), %rax # 0xdde90
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0x71cf9
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x71d0e
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x71d23
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2d0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x71d39
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x3a2d0
popq %rbx
retq
nop
pushq %rbx
movq %rdi, %rbx
callq 0x38340
movl $0x70, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x3a2d0
nop
|
_ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdED1Ev:
push rbx
mov rbx, rdi
mov rax, cs:_ZTVN10OpenSubdiv6v3_6_03Far16StencilTableRealIdEE_ptr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+58h]; void *
test rdi, rdi
jz short loc_71CF9
mov rsi, [rbx+68h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71CF9:
mov rdi, [rbx+40h]; void *
test rdi, rdi
jz short loc_71D0E
mov rsi, [rbx+50h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71D0E:
mov rdi, [rbx+28h]; void *
test rdi, rdi
jz short loc_71D23
mov rsi, [rbx+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_71D23:
mov rdi, [rbx+10h]; void *
test rdi, rdi
jz short loc_71D39
mov rsi, [rbx+20h]
sub rsi, rdi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_71D39:
pop rbx
retn
|
void OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal(_QWORD *a1)
{
void *v2; // rdi
void *v3; // rdi
void *v4; // rdi
void *v5; // rdi
*a1 = &`vtable for'OpenSubdiv::v3_6_0::Far::StencilTableReal<double> + 2;
v2 = (void *)a1[11];
if ( v2 )
operator delete(v2, a1[13] - (_QWORD)v2);
v3 = (void *)a1[8];
if ( v3 )
operator delete(v3, a1[10] - (_QWORD)v3);
v4 = (void *)a1[5];
if ( v4 )
operator delete(v4, a1[7] - (_QWORD)v4);
v5 = (void *)a1[2];
if ( v5 )
operator delete(v5, a1[4] - (_QWORD)v5);
}
|
~StencilTableReal:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [0x001dde90]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x58]
TEST RDI,RDI
JZ 0x00171cf9
MOV RSI,qword ptr [RBX + 0x68]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_00171cf9:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x00171d0e
MOV RSI,qword ptr [RBX + 0x50]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_00171d0e:
MOV RDI,qword ptr [RBX + 0x28]
TEST RDI,RDI
JZ 0x00171d23
MOV RSI,qword ptr [RBX + 0x38]
SUB RSI,RDI
CALL 0x0013a2d0
LAB_00171d23:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00171d39
MOV RSI,qword ptr [RBX + 0x20]
SUB RSI,RDI
POP RBX
JMP 0x0013a2d0
LAB_00171d39:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal() */
void __thiscall
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal(StencilTableReal<double> *this)
{
void *pvVar1;
*(int **)this = PTR_vtable_001dde90 + 0x10;
pvVar1 = *(void **)(this + 0x58);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x68) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x40);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x50) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x28);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x38) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x10);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x20) - (long)pvVar1);
return;
}
return;
}
|
|
17,730
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal()
|
NVIDIA-RTX[P]OSD-Lite/opensubdiv/far/../far/stencilTable.h
|
virtual ~StencilTableReal() {}
|
O3
|
c
|
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal():
pushq %rbx
movq %rdi, %rbx
movq 0x6ebcb(%rip), %rax # 0xe1e98
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x58(%rdi), %rdi
testq %rdi, %rdi
je 0x732e9
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x732fe
movq 0x50(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x73313
movq 0x38(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x73329
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x3a2b0
popq %rbx
retq
nop
pushq %rbx
movq %rdi, %rbx
callq 0x38340
movl $0x70, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x3a2b0
nop
|
_ZN10OpenSubdiv6v3_6_03Far16StencilTableRealIdED1Ev:
push rbx
mov rbx, rdi
mov rax, cs:_ZTVN10OpenSubdiv6v3_6_03Far16StencilTableRealIdEE_ptr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+58h]; void *
test rdi, rdi
jz short loc_732E9
mov rsi, [rbx+68h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_732E9:
mov rdi, [rbx+40h]; void *
test rdi, rdi
jz short loc_732FE
mov rsi, [rbx+50h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_732FE:
mov rdi, [rbx+28h]; void *
test rdi, rdi
jz short loc_73313
mov rsi, [rbx+38h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_73313:
mov rdi, [rbx+10h]; void *
test rdi, rdi
jz short loc_73329
mov rsi, [rbx+20h]
sub rsi, rdi; unsigned __int64
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_73329:
pop rbx
retn
|
void OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal(_QWORD *a1)
{
void *v2; // rdi
void *v3; // rdi
void *v4; // rdi
void *v5; // rdi
*a1 = &`vtable for'OpenSubdiv::v3_6_0::Far::StencilTableReal<double> + 2;
v2 = (void *)a1[11];
if ( v2 )
operator delete(v2, a1[13] - (_QWORD)v2);
v3 = (void *)a1[8];
if ( v3 )
operator delete(v3, a1[10] - (_QWORD)v3);
v4 = (void *)a1[5];
if ( v4 )
operator delete(v4, a1[7] - (_QWORD)v4);
v5 = (void *)a1[2];
if ( v5 )
operator delete(v5, a1[4] - (_QWORD)v5);
}
|
~StencilTableReal:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [0x001e1e98]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x58]
TEST RDI,RDI
JZ 0x001732e9
MOV RSI,qword ptr [RBX + 0x68]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001732e9:
MOV RDI,qword ptr [RBX + 0x40]
TEST RDI,RDI
JZ 0x001732fe
MOV RSI,qword ptr [RBX + 0x50]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001732fe:
MOV RDI,qword ptr [RBX + 0x28]
TEST RDI,RDI
JZ 0x00173313
MOV RSI,qword ptr [RBX + 0x38]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00173313:
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00173329
MOV RSI,qword ptr [RBX + 0x20]
SUB RSI,RDI
POP RBX
JMP 0x0013a2b0
LAB_00173329:
POP RBX
RET
|
/* OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal() */
void __thiscall
OpenSubdiv::v3_6_0::Far::StencilTableReal<double>::~StencilTableReal(StencilTableReal<double> *this)
{
void *pvVar1;
*(int **)this = PTR_vtable_001e1e98 + 0x10;
pvVar1 = *(void **)(this + 0x58);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x68) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x40);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x50) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x28);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x38) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x10);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x20) - (long)pvVar1);
return;
}
return;
}
|
|
17,731
|
bfdec_rem
|
bluesky950520[P]quickjs/libbf.c
|
int bfdec_rem(bfdec_t *r, const bfdec_t *a, const bfdec_t *b, limb_t prec,
bf_flags_t flags, int rnd_mode)
{
bfdec_t q_s, *q = &q_s;
int ret;
bfdec_init(r->ctx, q);
ret = bfdec_divrem(q, r, a, b, prec, flags, rnd_mode);
bfdec_delete(q);
return ret;
}
|
O3
|
c
|
bfdec_rem:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %r8d, %eax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rsi
movq (%rdi), %rdi
leaq 0x10(%rsp), %r14
movq %rdi, (%r14)
movl $0x0, 0x8(%r14)
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
movq %rdi, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movl %r9d, (%rsp)
movq %r14, %rdi
movl %eax, %r9d
callq 0x914f5
movl %eax, %ebx
movq (%r14), %rax
movq 0x20(%r14), %rsi
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x91a9f
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
bfdec_rem:
push r14
push rbx
sub rsp, 38h
mov eax, r8d
mov r8, rcx
mov rcx, rdx
mov rdx, rsi
mov rsi, rdi
mov rdi, [rdi]
lea r14, [rsp+48h+var_38]
mov [r14], rdi
mov dword ptr [r14+8], 0
mov rdi, 8000000000000000h
mov [r14+10h], rdi
xorps xmm0, xmm0
movups xmmword ptr [r14+18h], xmm0
mov [rsp+48h+var_48], r9d
mov rdi, r14
mov r9d, eax
call bfdec_divrem
mov ebx, eax
mov rax, [r14]
mov rsi, [r14+20h]
test rax, rax
setz cl
test rsi, rsi
setz dl
or dl, cl
jnz short loc_91A9F
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
loc_91A9F:
mov eax, ebx
add rsp, 38h
pop rbx
pop r14
retn
|
long long bfdec_rem(__int128 *a1, long long a2, long long a3, long long a4, unsigned int a5, int a6)
{
unsigned int v6; // ebx
__int128 v8; // [rsp+10h] [rbp-38h] BYREF
unsigned long long v9; // [rsp+20h] [rbp-28h]
__int128 v10; // [rsp+28h] [rbp-20h]
*(_QWORD *)&v8 = *(_QWORD *)a1;
DWORD2(v8) = 0;
v9 = 0x8000000000000000LL;
v10 = 0LL;
v6 = bfdec_divrem(&v8, a1, a2, a3, a4, a5, a6);
if ( (_QWORD)v8 != 0LL && *((_QWORD *)&v10 + 1) != 0LL )
(*(void ( **)(_QWORD, _QWORD, _QWORD))(v8 + 8))(*(_QWORD *)v8, *((_QWORD *)&v10 + 1), 0LL);
return v6;
}
|
bfdec_rem:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV EAX,R8D
MOV R8,RCX
MOV RCX,RDX
MOV RDX,RSI
MOV RSI,RDI
MOV RDI,qword ptr [RDI]
LEA R14,[RSP + 0x10]
MOV qword ptr [R14],RDI
MOV dword ptr [R14 + 0x8],0x0
MOV RDI,-0x8000000000000000
MOV qword ptr [R14 + 0x10],RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x18],XMM0
MOV dword ptr [RSP],R9D
MOV RDI,R14
MOV R9D,EAX
CALL 0x001914f5
MOV EBX,EAX
MOV RAX,qword ptr [R14]
MOV RSI,qword ptr [R14 + 0x20]
TEST RAX,RAX
SETZ CL
TEST RSI,RSI
SETZ DL
OR DL,CL
JNZ 0x00191a9f
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_00191a9f:
MOV EAX,EBX
ADD RSP,0x38
POP RBX
POP R14
RET
|
int4
bfdec_rem(int8 *param_1,int8 param_2,int8 param_3,int8 param_4,
int4 param_5,int4 param_6)
{
int4 uVar1;
int8 *local_38;
int4 local_30;
int8 local_28;
int8 local_20;
long lStack_18;
local_38 = (int8 *)*param_1;
local_30 = 0;
local_28 = 0x8000000000000000;
local_20 = 0;
lStack_18 = 0;
uVar1 = bfdec_divrem(&local_38,param_1,param_2,param_3,param_4,param_5,param_6);
if (lStack_18 != 0 && local_38 != (int8 *)0x0) {
(*(code *)local_38[1])(*local_38,lStack_18,0);
}
return uVar1;
}
|
|
17,732
|
make_type
|
eloqsql/mysys/typelib.c
|
void make_type(register char * to, register uint nr,
register TYPELIB *typelib)
{
DBUG_ENTER("make_type");
if (!nr)
to[0]=0;
else
(void) strmov(to,get_type(typelib,nr-1));
DBUG_VOID_RETURN;
}
|
O3
|
c
|
make_type:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
je 0xabdb7
decl %esi
leaq 0x378f6(%rip), %rax # 0xe3691
cmpl %esi, (%rdx)
jbe 0xabdae
movq 0x10(%rdx), %rcx
testq %rcx, %rcx
je 0xabdae
movl %esi, %eax
movq (%rcx,%rax,8), %rax
movq %rax, %rsi
popq %rbp
jmp 0x2a370
movb $0x0, (%rdi)
popq %rbp
retq
|
make_type:
push rbp
mov rbp, rsp
test esi, esi
jz short loc_ABDB7
dec esi
lea rax, asc_E3691; "?"
cmp [rdx], esi
jbe short loc_ABDAE
mov rcx, [rdx+10h]
test rcx, rcx
jz short loc_ABDAE
mov eax, esi
mov rax, [rcx+rax*8]
loc_ABDAE:
mov rsi, rax
pop rbp
jmp _strcpy
loc_ABDB7:
mov byte ptr [rdi], 0
pop rbp
retn
|
void make_type(_BYTE *a1, int a2, long long a3)
{
unsigned int v3; // esi
const char *v4; // rax
long long v5; // rcx
if ( a2 )
{
v3 = a2 - 1;
v4 = "?";
if ( *(_DWORD *)a3 > v3 )
{
v5 = *(_QWORD *)(a3 + 16);
if ( v5 )
v4 = *(const char **)(v5 + 8LL * v3);
}
strcpy(a1, v4);
}
else
{
*a1 = 0;
}
}
|
make_type:
PUSH RBP
MOV RBP,RSP
TEST ESI,ESI
JZ 0x001abdb7
DEC ESI
LEA RAX,[0x1e3691]
CMP dword ptr [RDX],ESI
JBE 0x001abdae
MOV RCX,qword ptr [RDX + 0x10]
TEST RCX,RCX
JZ 0x001abdae
MOV EAX,ESI
MOV RAX,qword ptr [RCX + RAX*0x8]
LAB_001abdae:
MOV RSI,RAX
POP RBP
JMP 0x0012a370
LAB_001abdb7:
MOV byte ptr [RDI],0x0
POP RBP
RET
|
void make_type(char *param_1,int param_2,uint *param_3)
{
char *__src;
if (param_2 != 0) {
__src = "?";
if ((param_2 - 1U < *param_3) && (*(long *)(param_3 + 4) != 0)) {
__src = *(char **)(*(long *)(param_3 + 4) + (ulong)(param_2 - 1U) * 8);
}
strcpy(param_1,__src);
return;
}
*param_1 = '\0';
return;
}
|
|
17,733
|
js_array_join
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_join(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int toLocaleString)
{
JSValue obj, sep = JS_UNDEFINED, el;
StringBuffer b_s, *b = &b_s;
JSString *p = NULL;
int64_t i, n;
int c;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &n, obj))
goto exception;
c = ','; /* default separator */
if (!toLocaleString && argc > 0 && !JS_IsUndefined(argv[0])) {
sep = JS_ToString(ctx, argv[0]);
if (JS_IsException(sep))
goto exception;
p = JS_VALUE_GET_STRING(sep);
if (p->len == 1 && !p->is_wide_char)
c = p->u.str8[0];
else
c = -1;
}
string_buffer_init(ctx, b, 0);
for(i = 0; i < n; i++) {
if (i > 0) {
if (c >= 0) {
string_buffer_putc8(b, c);
} else {
string_buffer_concat(b, p, 0, p->len);
}
}
el = JS_GetPropertyUint32(ctx, obj, i);
if (JS_IsException(el))
goto fail;
if (!JS_IsNull(el) && !JS_IsUndefined(el)) {
if (toLocaleString) {
el = JS_ToLocaleStringFree(ctx, el);
}
if (string_buffer_concat_value_free(b, el))
goto fail;
}
}
JS_FreeValue(ctx, sep);
JS_FreeValue(ctx, obj);
return string_buffer_end(b);
fail:
string_buffer_free(b);
JS_FreeValue(ctx, sep);
exception:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_array_join:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
callq 0x26ddd
movq %rax, %r15
movq %rdx, %r14
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r14, %rcx
callq 0x22adc
testl %eax, %eax
je 0x76084
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
movl $0x6, %edx
xorl %eax, %eax
jmp 0x761a8
movl %r13d, 0x1c(%rsp)
testl %r13d, %r13d
setne %al
testl %ebp, %ebp
setle %cl
movl $0x2c, %r13d
orb %al, %cl
jne 0x760ac
movq 0x8(%r12), %rdx
cmpl $0x3, %edx
jne 0x761b7
movl $0x3, %eax
movq %rax, (%rsp)
movq $0x0, 0x10(%rsp)
movq %rbx, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x20b73
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x7622a
movq 0x40(%rsp), %r12
testq %r12, %r12
jle 0x7617d
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x76129
testl %r13d, %r13d
js 0x7610e
leaq 0x20(%rsp), %rdi
movl %r13d, %esi
callq 0x4b861
jmp 0x76129
movq 0x10(%rsp), %rsi
movl 0x4(%rsi), %ecx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl %eax, %ecx
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x420b9
movl %ebp, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x241b4
leal -0x2(%rdx), %ecx
cmpl $0x2, %ecx
jb 0x76171
cmpl $0x6, %edx
je 0x761fb
cmpl $0x0, 0x1c(%rsp)
je 0x7615c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x781d2
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x4b8b6
testl %eax, %eax
jne 0x761fb
incq %rbp
cmpq %rbp, %r12
jne 0x760f5
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq (%rsp), %rdx
callq 0x1d8c6
movq 0x18(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1d8c6
leaq 0x20(%rsp), %rdi
callq 0x33444
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rsi
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x27add
movq %rax, 0x8(%rsp)
cmpl $0x6, %edx
je 0x76069
movq 0x8(%rsp), %rax
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
cmpl $0x1, 0x4(%rax)
movq %rdx, (%rsp)
movq %rax, 0x10(%rsp)
jne 0x760be
movzbl 0x18(%rax), %r13d
jmp 0x760be
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1cb99
movq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rbx), %rdi
movq (%rsp), %rdx
callq 0x1d8c6
jmp 0x76069
movl $0x0, 0x34(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0x760e5
|
js_array_join:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13d, r9d
mov r12, r8
mov ebp, ecx
mov rbx, rdi
mov [rsp+78h+var_70], 0
call JS_ToObject
mov r15, rax
mov r14, rdx
lea rsi, [rsp+78h+var_38]
mov rdi, rbx
mov rdx, rax
mov rcx, r14
call js_get_length64
test eax, eax
jz short loc_76084
loc_76069:
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
mov edx, 6
xor eax, eax
jmp loc_761A8
loc_76084:
mov [rsp+78h+var_5C], r13d
test r13d, r13d
setnz al
test ebp, ebp
setle cl
mov r13d, 2Ch ; ','
or cl, al
jnz short loc_760AC
mov rdx, [r12+8]
cmp edx, 3
jnz loc_761B7
loc_760AC:
mov eax, 3
mov [rsp+78h+var_78], rax
mov [rsp+78h+var_68], 0
loc_760BE:
mov [rsp+78h+var_58], rbx
xorps xmm0, xmm0
movups [rsp+78h+var_48], xmm0
mov rdi, rbx
xor esi, esi
xor edx, edx
call js_alloc_string
mov [rsp+78h+var_50], rax
test rax, rax
jz loc_7622A
loc_760E5:
mov r12, [rsp+78h+var_38]
test r12, r12
jle loc_7617D
xor ebp, ebp
loc_760F5:
test rbp, rbp
jz short loc_76129
test r13d, r13d
js short loc_7610E
lea rdi, [rsp+78h+var_58]
mov esi, r13d
call string_buffer_putc8
jmp short loc_76129
loc_7610E:
mov rsi, [rsp+78h+var_68]
mov ecx, [rsi+4]
mov eax, 7FFFFFFFh
and ecx, eax
lea rdi, [rsp+78h+var_58]
xor edx, edx
call string_buffer_concat
loc_76129:
mov ecx, ebp
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetPropertyInt64
lea ecx, [rdx-2]
cmp ecx, 2
jb short loc_76171
cmp edx, 6
jz loc_761FB
cmp [rsp+78h+var_5C], 0
jz short loc_7615C
mov rdi, rbx
mov rsi, rax
call JS_ToLocaleStringFree
loc_7615C:
lea rdi, [rsp+78h+var_58]
mov rsi, rax
call string_buffer_concat_value_free
test eax, eax
jnz loc_761FB
loc_76171:
inc rbp
cmp r12, rbp
jnz loc_760F5
loc_7617D:
mov rsi, [rsp+78h+var_70]
mov rdi, [rbx+18h]
mov rdx, [rsp+78h+var_78]
call JS_FreeValueRT
mov rdi, [rbx+18h]
mov rsi, r15
mov rdx, r14
call JS_FreeValueRT
lea rdi, [rsp+78h+var_58]
call string_buffer_end
loc_761A8:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_761B7:
mov rsi, [r12]
mov rdi, rbx
xor ecx, ecx
call JS_ToStringInternal
mov [rsp+78h+var_70], rax
cmp edx, 6
jz loc_76069
mov rax, [rsp+78h+var_70]
mov r13d, 0FFFFFFFFh
cmp dword ptr [rax+4], 1
mov [rsp+78h+var_78], rdx
mov [rsp+78h+var_68], rax
jnz loc_760BE
movzx r13d, byte ptr [rax+18h]
jmp loc_760BE
loc_761FB:
mov rdi, [rsp+78h+var_58]
mov rsi, [rsp+78h+var_50]
call js_free
mov [rsp+78h+var_50], 0
mov rsi, [rsp+78h+var_70]
mov rdi, [rbx+18h]
mov rdx, [rsp+78h+var_78]
call JS_FreeValueRT
jmp loc_76069
loc_7622A:
mov dword ptr [rsp+78h+var_48+4], 0
mov dword ptr [rsp+78h+var_48+0Ch], 0FFFFFFFFh
jmp loc_760E5
|
_DWORD * js_array_join(
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)
{
int v14; // r13d
int v16; // ebp
_DWORD *v17; // r15
long long v18; // rdx
long long v19; // r14
long long v20; // r8
long long v21; // r9
__m128 v22; // xmm4
__m128 v23; // xmm5
bool v25; // al
signed int v26; // r13d
long long v27; // rdx
long long v28; // rdx
long long v29; // rcx
long long v30; // r8
long long v31; // r9
__m128 v32; // xmm4
__m128 v33; // xmm5
long long v34; // r12
long long v35; // rbp
_DWORD *PropertyInt64; // rax
long long v37; // rdx
long long v38; // [rsp+0h] [rbp-78h]
unsigned long long v39; // [rsp+8h] [rbp-70h]
long long v40; // [rsp+10h] [rbp-68h]
int v41; // [rsp+1Ch] [rbp-5Ch]
long long v42; // [rsp+20h] [rbp-58h] BYREF
long long v43; // [rsp+28h] [rbp-50h]
__int128 v44; // [rsp+30h] [rbp-48h]
long long v45[7]; // [rsp+40h] [rbp-38h] BYREF
v14 = a6;
v16 = a4;
v39 = 0LL;
v17 = JS_ToObject(a1, a2, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
if ( (unsigned int)js_get_length64(a1, v45, (int)v17, v18) )
goto LABEL_2;
v41 = v14;
v25 = v14 != 0;
v26 = 44;
if ( v25 || v16 <= 0 || (v27 = a5[1], (_DWORD)v27 == 3) )
{
v38 = 3LL;
v40 = 0LL;
}
else
{
v39 = JS_ToStringInternal(a1, *a5, v27, 0, v20, v21, a7, a8, a9, a10, v22, v23, a13, a14);
if ( (_DWORD)v37 == 6 )
{
LABEL_2:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v17, v19);
return 0LL;
}
v26 = -1;
v38 = v37;
v40 = v39;
if ( *(_DWORD *)(v39 + 4) == 1 )
v26 = *(unsigned __int8 *)(v39 + 24);
}
v42 = a1;
v44 = 0LL;
v43 = js_alloc_string(a1, 0LL, 0);
if ( !v43 )
{
DWORD1(v44) = 0;
HIDWORD(v44) = -1;
}
v34 = v45[0];
if ( v45[0] > 0 )
{
v35 = 0LL;
while ( 1 )
{
if ( v35 )
{
if ( v26 < 0 )
string_buffer_concat((long long)&v42, v40, 0, *(_DWORD *)(v40 + 4) & 0x7FFFFFFF);
else
string_buffer_putc8((long long)&v42, v26, (__m128)0LL, a8, a9, a10, v32, v33, a13, a14, v28, v29, v30, v31);
}
PropertyInt64 = (_DWORD *)JS_GetPropertyInt64(a1, (long long)v17, v19, (unsigned int)v35);
v29 = (unsigned int)(v28 - 2);
if ( (unsigned int)v29 >= 2 )
{
if ( (_DWORD)v28 == 6 )
break;
if ( v41 )
PropertyInt64 = (_DWORD *)JS_ToLocaleStringFree(a1, PropertyInt64);
if ( (unsigned int)string_buffer_concat_value_free(
&v42,
PropertyInt64,
v28,
v29,
v30,
v31,
(__m128)0LL,
a8,
a9,
a10,
v32,
v33,
a13,
a14) )
break;
}
if ( v34 == ++v35 )
goto LABEL_20;
}
js_free(v42, v43);
v43 = 0LL;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v39, v38);
goto LABEL_2;
}
LABEL_20:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)v39, v38);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v17, v19);
return string_buffer_end((long long)&v42);
}
| |||
17,734
|
js_array_join
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_join(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int toLocaleString)
{
JSValue obj, sep = JS_UNDEFINED, el;
StringBuffer b_s, *b = &b_s;
JSString *p = NULL;
int64_t i, n;
int c;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &n, obj))
goto exception;
c = ','; /* default separator */
if (!toLocaleString && argc > 0 && !JS_IsUndefined(argv[0])) {
sep = JS_ToString(ctx, argv[0]);
if (JS_IsException(sep))
goto exception;
p = JS_VALUE_GET_STRING(sep);
if (p->len == 1 && !p->is_wide_char)
c = p->u.str8[0];
else
c = -1;
}
string_buffer_init(ctx, b, 0);
for(i = 0; i < n; i++) {
if (i > 0) {
if (c >= 0) {
string_buffer_putc8(b, c);
} else {
string_buffer_concat(b, p, 0, p->len);
}
}
el = JS_GetPropertyUint32(ctx, obj, i);
if (JS_IsException(el))
goto fail;
if (!JS_IsNull(el) && !JS_IsUndefined(el)) {
if (toLocaleString) {
el = JS_ToLocaleStringFree(ctx, el);
}
if (string_buffer_concat_value_free(b, el))
goto fail;
}
}
JS_FreeValue(ctx, sep);
JS_FreeValue(ctx, obj);
return string_buffer_end(b);
fail:
string_buffer_free(b);
JS_FreeValue(ctx, sep);
exception:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O3
|
c
|
js_array_join:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r13d
movq %r8, %rbp
movl %ecx, %r12d
movq %rdi, %r15
callq 0x27514
movq %rax, %r14
movq %rdx, %rbx
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2331b
testl %eax, %eax
je 0x788ca
movl $0x6, %r12d
cmpl $-0x9, %ebx
jb 0x788c3
movq 0x18(%r15), %rdi
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x788c3
movq %r14, %rsi
movq %rbx, %rdx
callq 0x219cc
xorl %eax, %eax
jmp 0x78a17
testl %r13d, %r13d
setne %dl
testl %r12d, %r12d
setle %cl
movl $0x3, %esi
movl $0x2c, %r12d
xorl %eax, %eax
orb %dl, %cl
jne 0x788f6
movq 0x8(%rbp), %rdx
xorl %eax, %eax
cmpl $0x3, %edx
jne 0x78a29
movq %rax, 0x8(%rsp)
movq %rsi, 0x18(%rsp)
movl %r13d, 0x14(%rsp)
movq %r15, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x212c2
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x78a9e
movq 0x40(%rsp), %r13
testq %r13, %r13
jle 0x789c4
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x78970
testl %r12d, %r12d
js 0x78955
leaq 0x20(%rsp), %rdi
movl %r12d, %esi
callq 0x4d7cc
jmp 0x78970
movq 0x8(%rsp), %rsi
movl 0x4(%rsi), %ecx
movl $0x7fffffff, %eax # imm = 0x7FFFFFFF
andl %eax, %ecx
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x43bad
movl %ebp, %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x24808
leal -0x2(%rdx), %ecx
cmpl $0x2, %ecx
jb 0x789b8
cmpl $0x6, %edx
je 0x78a53
cmpl $0x0, 0x14(%rsp)
je 0x789a3
movq %r15, %rdi
movq %rax, %rsi
callq 0x7abe7
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x4d821
testl %eax, %eax
jne 0x78a53
incq %rbp
cmpq %rbp, %r13
jne 0x7893c
movq 0x18(%r15), %rdi
movq 0x18(%rsp), %rdx
cmpl $-0x9, %edx
jb 0x789ec
movq 0x8(%rsp), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x789ec
callq 0x219cc
movq 0x18(%r15), %rdi
cmpl $-0x9, %ebx
jb 0x78a0a
movl (%r14), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x1, %eax
jg 0x78a0a
movq %r14, %rsi
movq %rbx, %rdx
callq 0x219cc
leaq 0x20(%rsp), %rdi
callq 0x342b1
movq %rdx, %r12
movq %r12, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbp), %rsi
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x28154
movq %rdx, %rsi
cmpl $0x6, %esi
je 0x7889b
cmpl $0x1, 0x4(%rax)
jne 0x78a93
movzbl 0x18(%rax), %r12d
jmp 0x788f6
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1d481
movq 0x18(%rsp), %rdx
cmpl $-0x9, %edx
movq 0x8(%rsp), %rsi
jb 0x7889b
movq 0x18(%r15), %rdi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x7889b
callq 0x219cc
jmp 0x7889b
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
jmp 0x788f6
movl $0x0, 0x34(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0x7892c
|
js_array_join:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r13d, r9d
mov rbp, r8
mov r12d, ecx
mov r15, rdi
call JS_ToObject
mov r14, rax
mov rbx, rdx
lea rsi, [rsp+78h+var_38]
mov rdi, r15
mov rdx, rax
mov rcx, rbx
call js_get_length64
test eax, eax
jz short loc_788CA
loc_7889B:
mov r12d, 6
cmp ebx, 0FFFFFFF7h
jb short loc_788C3
mov rdi, [r15+18h]
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_788C3
mov rsi, r14
mov rdx, rbx
call js_free_value_rt
loc_788C3:
xor eax, eax
jmp loc_78A17
loc_788CA:
test r13d, r13d
setnz dl
test r12d, r12d
setle cl
mov esi, 3
mov r12d, 2Ch ; ','
xor eax, eax
or cl, dl
jnz short loc_788F6
mov rdx, [rbp+8]
xor eax, eax
cmp edx, 3
jnz loc_78A29
loc_788F6:
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_60], rsi
mov [rsp+78h+var_64], r13d
mov [rsp+78h+var_58], r15
xorps xmm0, xmm0
movups [rsp+78h+var_48], xmm0
mov rdi, r15
xor esi, esi
xor edx, edx
call js_alloc_string
mov [rsp+78h+var_50], rax
test rax, rax
jz loc_78A9E
loc_7892C:
mov r13, [rsp+78h+var_38]
test r13, r13
jle loc_789C4
xor ebp, ebp
loc_7893C:
test rbp, rbp
jz short loc_78970
test r12d, r12d
js short loc_78955
lea rdi, [rsp+78h+var_58]
mov esi, r12d
call string_buffer_putc8
jmp short loc_78970
loc_78955:
mov rsi, [rsp+78h+var_70]
mov ecx, [rsi+4]
mov eax, 7FFFFFFFh
and ecx, eax
lea rdi, [rsp+78h+var_58]
xor edx, edx
call string_buffer_concat
loc_78970:
mov ecx, ebp
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_GetPropertyInt64
lea ecx, [rdx-2]
cmp ecx, 2
jb short loc_789B8
cmp edx, 6
jz loc_78A53
cmp [rsp+78h+var_64], 0
jz short loc_789A3
mov rdi, r15
mov rsi, rax
call JS_ToLocaleStringFree
loc_789A3:
lea rdi, [rsp+78h+var_58]
mov rsi, rax
call string_buffer_concat_value_free
test eax, eax
jnz loc_78A53
loc_789B8:
inc rbp
cmp r13, rbp
jnz loc_7893C
loc_789C4:
mov rdi, [r15+18h]
mov rdx, [rsp+78h+var_60]
cmp edx, 0FFFFFFF7h
jb short loc_789EC
mov rsi, [rsp+78h+var_70]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_789EC
call js_free_value_rt
mov rdi, [r15+18h]
loc_789EC:
cmp ebx, 0FFFFFFF7h
jb short loc_78A0A
mov eax, [r14]
lea ecx, [rax-1]
mov [r14], ecx
cmp eax, 1
jg short loc_78A0A
mov rsi, r14
mov rdx, rbx
call js_free_value_rt
loc_78A0A:
lea rdi, [rsp+78h+var_58]
call string_buffer_end
mov r12, rdx
loc_78A17:
mov rdx, r12
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_78A29:
mov rsi, [rbp+0]
mov rdi, r15
xor ecx, ecx
call JS_ToStringInternal
mov rsi, rdx
cmp esi, 6
jz loc_7889B
cmp dword ptr [rax+4], 1
jnz short loc_78A93
movzx r12d, byte ptr [rax+18h]
jmp loc_788F6
loc_78A53:
mov rdi, [rsp+78h+var_58]
mov rsi, [rsp+78h+var_50]
call js_free
mov rdx, [rsp+78h+var_60]
cmp edx, 0FFFFFFF7h
mov rsi, [rsp+78h+var_70]
jb loc_7889B
mov rdi, [r15+18h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg loc_7889B
call js_free_value_rt
jmp loc_7889B
loc_78A93:
mov r12d, 0FFFFFFFFh
jmp loc_788F6
loc_78A9E:
mov dword ptr [rsp+78h+var_48+4], 0
mov dword ptr [rsp+78h+var_48+0Ch], 0FFFFFFFFh
jmp loc_7892C
|
long long js_array_join(
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)
{
int v14; // r13d
int v16; // r12d
_QWORD *v18; // r14
long long v19; // rdx
long long v20; // rbx
long long v21; // r8
long long v22; // r9
__m128 v23; // xmm4
__m128 v24; // xmm5
long long v25; // rdi
int v26; // eax
bool v28; // cl
unsigned int v29; // esi
signed int v30; // r12d
unsigned long long v31; // rax
long long v32; // rdx
long long v33; // rdx
long long v34; // rcx
long long v35; // r8
long long v36; // r9
__m128 v37; // xmm4
__m128 v38; // xmm5
long long v39; // r13
long long v40; // rbp
_DWORD *PropertyInt64; // rax
long long v42; // rdi
int v43; // eax
int v44; // eax
unsigned int v45; // edx
long long v46; // rdi
int v47; // eax
long long v48; // [rsp+8h] [rbp-70h]
int v49; // [rsp+14h] [rbp-64h]
long long v50; // [rsp+20h] [rbp-58h] BYREF
long long v51; // [rsp+28h] [rbp-50h]
__int128 v52; // [rsp+30h] [rbp-48h]
long long v53[7]; // [rsp+40h] [rbp-38h] BYREF
v14 = a6;
v16 = a4;
v18 = (_QWORD *)JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v20 = v19;
if ( (unsigned int)js_get_length64(a1, v53, (int)v18, v19) )
goto LABEL_2;
v28 = v16 <= 0;
v29 = 3;
v30 = 44;
v31 = 0LL;
if ( v14 == 0 && !v28 )
{
v32 = *(_QWORD *)(a5 + 8);
v31 = 0LL;
if ( (_DWORD)v32 != 3 )
{
v31 = JS_ToStringInternal(a1, *(_DWORD **)a5, v32, 0LL, v21, v22, a7, a8, a9, a10, v23, v24, a13, a14);
v29 = v45;
if ( v45 == 6 )
{
LABEL_2:
if ( (unsigned int)v20 >= 0xFFFFFFF7 )
{
v25 = *(_QWORD *)(a1 + 24);
v26 = (*(_DWORD *)v18)--;
if ( v26 <= 1 )
js_free_value_rt(v25, v18, v20);
}
return 0LL;
}
if ( *(_DWORD *)(v31 + 4) == 1 )
v30 = *(unsigned __int8 *)(v31 + 24);
else
v30 = -1;
}
}
v48 = v31;
v49 = v14;
v50 = a1;
v52 = 0LL;
v51 = js_alloc_string(a1, 0LL, 0);
if ( !v51 )
{
DWORD1(v52) = 0;
HIDWORD(v52) = -1;
}
v39 = v53[0];
if ( v53[0] > 0 )
{
v40 = 0LL;
while ( 1 )
{
if ( v40 )
{
if ( v30 < 0 )
string_buffer_concat((long long)&v50, v48, 0, *(_DWORD *)(v48 + 4) & 0x7FFFFFFF);
else
string_buffer_putc8((long long)&v50, v30, (__m128)0LL, a8, a9, a10, v37, v38, a13, a14, v33, v34, v35, v36);
}
PropertyInt64 = (_DWORD *)JS_GetPropertyInt64(a1, (long long)v18, v20, (unsigned int)v40);
v34 = (unsigned int)(v33 - 2);
if ( (unsigned int)v34 >= 2 )
{
if ( (_DWORD)v33 == 6 )
break;
if ( v49 )
PropertyInt64 = (_DWORD *)JS_ToLocaleStringFree(a1, PropertyInt64);
if ( (unsigned int)string_buffer_concat_value_free(
(long long)&v50,
PropertyInt64,
v33,
v34,
v35,
v36,
(__m128)0LL,
a8,
a9,
a10,
v37,
v38,
a13,
a14) )
break;
}
if ( v39 == ++v40 )
goto LABEL_22;
}
js_free(v50, v51);
if ( v29 >= 0xFFFFFFF7 )
{
v46 = *(_QWORD *)(a1 + 24);
v47 = (*(_DWORD *)v48)--;
if ( v47 <= 1 )
js_free_value_rt(v46, (_QWORD *)v48, v29);
}
goto LABEL_2;
}
LABEL_22:
v42 = *(_QWORD *)(a1 + 24);
if ( v29 >= 0xFFFFFFF7 )
{
v43 = (*(_DWORD *)v48)--;
if ( v43 <= 1 )
{
js_free_value_rt(v42, (_QWORD *)v48, v29);
v42 = *(_QWORD *)(a1 + 24);
}
}
if ( (unsigned int)v20 >= 0xFFFFFFF7 )
{
v44 = (*(_DWORD *)v18)--;
if ( v44 <= 1 )
js_free_value_rt(v42, v18, v20);
}
return string_buffer_end(&v50);
}
|
js_array_join:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R13D,R9D
MOV RBP,R8
MOV R12D,ECX
MOV R15,RDI
CALL 0x00127514
MOV R14,RAX
MOV RBX,RDX
LEA RSI,[RSP + 0x40]
MOV RDI,R15
MOV RDX,RAX
MOV RCX,RBX
CALL 0x0012331b
TEST EAX,EAX
JZ 0x001788ca
LAB_0017889b:
MOV R12D,0x6
CMP EBX,-0x9
JC 0x001788c3
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x001788c3
MOV RSI,R14
MOV RDX,RBX
CALL 0x001219cc
LAB_001788c3:
XOR EAX,EAX
JMP 0x00178a17
LAB_001788ca:
TEST R13D,R13D
SETNZ DL
TEST R12D,R12D
SETLE CL
MOV ESI,0x3
MOV R12D,0x2c
XOR EAX,EAX
OR CL,DL
JNZ 0x001788f6
MOV RDX,qword ptr [RBP + 0x8]
XOR EAX,EAX
CMP EDX,0x3
JNZ 0x00178a29
LAB_001788f6:
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x18],RSI
MOV dword ptr [RSP + 0x14],R13D
MOV qword ptr [RSP + 0x20],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x30],XMM0
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001212c2
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JZ 0x00178a9e
LAB_0017892c:
MOV R13,qword ptr [RSP + 0x40]
TEST R13,R13
JLE 0x001789c4
XOR EBP,EBP
LAB_0017893c:
TEST RBP,RBP
JZ 0x00178970
TEST R12D,R12D
JS 0x00178955
LEA RDI,[RSP + 0x20]
MOV ESI,R12D
CALL 0x0014d7cc
JMP 0x00178970
LAB_00178955:
MOV RSI,qword ptr [RSP + 0x8]
MOV ECX,dword ptr [RSI + 0x4]
MOV EAX,0x7fffffff
AND ECX,EAX
LEA RDI,[RSP + 0x20]
XOR EDX,EDX
CALL 0x00143bad
LAB_00178970:
MOV ECX,EBP
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00124808
LEA ECX,[RDX + -0x2]
CMP ECX,0x2
JC 0x001789b8
CMP EDX,0x6
JZ 0x00178a53
CMP dword ptr [RSP + 0x14],0x0
JZ 0x001789a3
MOV RDI,R15
MOV RSI,RAX
CALL 0x0017abe7
LAB_001789a3:
LEA RDI,[RSP + 0x20]
MOV RSI,RAX
CALL 0x0014d821
TEST EAX,EAX
JNZ 0x00178a53
LAB_001789b8:
INC RBP
CMP R13,RBP
JNZ 0x0017893c
LAB_001789c4:
MOV RDI,qword ptr [R15 + 0x18]
MOV RDX,qword ptr [RSP + 0x18]
CMP EDX,-0x9
JC 0x001789ec
MOV RSI,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x001789ec
CALL 0x001219cc
MOV RDI,qword ptr [R15 + 0x18]
LAB_001789ec:
CMP EBX,-0x9
JC 0x00178a0a
MOV EAX,dword ptr [R14]
LEA ECX,[RAX + -0x1]
MOV dword ptr [R14],ECX
CMP EAX,0x1
JG 0x00178a0a
MOV RSI,R14
MOV RDX,RBX
CALL 0x001219cc
LAB_00178a0a:
LEA RDI,[RSP + 0x20]
CALL 0x001342b1
MOV R12,RDX
LAB_00178a17:
MOV RDX,R12
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00178a29:
MOV RSI,qword ptr [RBP]
MOV RDI,R15
XOR ECX,ECX
CALL 0x00128154
MOV RSI,RDX
CMP ESI,0x6
JZ 0x0017889b
CMP dword ptr [RAX + 0x4],0x1
JNZ 0x00178a93
MOVZX R12D,byte ptr [RAX + 0x18]
JMP 0x001788f6
LAB_00178a53:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x0011d481
MOV RDX,qword ptr [RSP + 0x18]
CMP EDX,-0x9
MOV RSI,qword ptr [RSP + 0x8]
JC 0x0017889b
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0017889b
CALL 0x001219cc
JMP 0x0017889b
LAB_00178a93:
MOV R12D,0xffffffff
JMP 0x001788f6
LAB_00178a9e:
MOV dword ptr [RSP + 0x34],0x0
MOV dword ptr [RSP + 0x3c],0xffffffff
JMP 0x0017892c
|
int1 [16]
js_array_join(long param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5,
int param_6)
{
int iVar1;
int *piVar2;
int *piVar3;
int8 uVar4;
int8 uVar5;
ulong uVar6;
uint uVar7;
int1 auVar8 [12];
int1 auVar9 [12];
int1 auVar10 [16];
long local_58;
long local_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
auVar10 = JS_ToObject();
uVar5 = auVar10._8_8_;
piVar2 = auVar10._0_8_;
iVar1 = js_get_length64(param_1,&local_38,piVar2,uVar5);
if (iVar1 == 0) {
uVar7 = 0x2c;
auVar9 = ZEXT412(3) << 0x40;
if (0 < param_4 && param_6 == 0) {
auVar9 = ZEXT412(3) << 0x40;
if ((int)param_5[1] != 3) {
auVar9 = JS_ToStringInternal(param_1,*param_5,param_5[1],0);
if (auVar9._8_4_ == 6) goto LAB_0017889b;
if (*(int *)(auVar9._0_8_ + 4) == 1) {
uVar7 = (uint)*(byte *)(auVar9._0_8_ + 0x18);
}
else {
uVar7 = 0xffffffff;
}
}
}
piVar3 = auVar9._0_8_;
local_48 = 0;
uStack_40 = 0;
local_58 = param_1;
local_50 = js_alloc_string(param_1,0,0);
if (local_50 == 0) {
local_48 = local_48 & 0xffffffff;
uStack_40 = CONCAT44(0xffffffff,(int4)uStack_40);
}
if (0 < (long)local_38) {
uVar6 = 0;
do {
if (uVar6 != 0) {
if ((int)uVar7 < 0) {
string_buffer_concat(&local_58,piVar3,0,piVar3[1] & 0x7fffffff);
}
else {
string_buffer_putc8(&local_58,uVar7);
}
}
auVar8 = JS_GetPropertyInt64(param_1,piVar2,uVar5,uVar6 & 0xffffffff);
uVar4 = auVar8._0_8_;
if (1 < auVar8._8_4_ - 2U) {
if (auVar8._8_4_ != 6) {
if (param_6 != 0) {
uVar4 = JS_ToLocaleStringFree(param_1,uVar4);
}
iVar1 = string_buffer_concat_value_free(&local_58,uVar4);
if (iVar1 == 0) goto LAB_001789b8;
}
js_free(local_58,local_50);
if (0xfffffff6 < auVar9._8_4_) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar3;
*piVar3 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
}
}
goto LAB_0017889b;
}
LAB_001789b8:
uVar6 = uVar6 + 1;
} while (local_38 != uVar6);
}
uVar4 = *(int8 *)(param_1 + 0x18);
if (0xfffffff6 < auVar9._8_4_) {
iVar1 = *piVar3;
*piVar3 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4);
uVar4 = *(int8 *)(param_1 + 0x18);
}
}
if (0xfffffff6 < auVar10._8_4_) {
iVar1 = *piVar2;
*piVar2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4,piVar2,uVar5);
}
}
auVar10 = string_buffer_end(&local_58);
}
else {
LAB_0017889b:
if (0xfffffff6 < auVar10._8_4_) {
uVar4 = *(int8 *)(param_1 + 0x18);
iVar1 = *piVar2;
*piVar2 = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(uVar4,piVar2,uVar5);
}
}
auVar10 = ZEXT816(6) << 0x40;
}
return auVar10;
}
|
|
17,735
|
mysql_stmt_prepare_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_prepare_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_prepare,
(parms->stmt, parms->query, parms->length),
parms->stmt->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_stmt_prepare_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x38(%rax), %rcx
movq 0x480(%rcx), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x23cc8
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_prepare_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+38h]
mov rcx, [rcx+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_stmt_prepare
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_prepare_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_prepare(*a1, a1[1], a1[2]);
v1[2] = result;
*v1 = 0;
return result;
}
|
mysql_stmt_prepare_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RCX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x00123cc8
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_prepare_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_prepare(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
17,736
|
quick_partition
|
davidesantangelo[P]vsort/examples/benchmark.c
|
int quick_partition(int arr[], int low, int high)
{
// Simple Lomuto partition scheme with last element as pivot
int pivot = arr[high];
int i = low - 1; // Index of smaller element
for (int j = low; j < high; j++) // Iterate up to high-1
{
// If current element is smaller than or equal to pivot
if (arr[j] <= pivot)
{
i++; // increment index of smaller element
// Swap arr[i] and arr[j]
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Swap arr[i+1] and arr[high] (pivot)
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1; // Return partitioning index
}
|
O3
|
c
|
quick_partition:
movslq %edx, %rcx
movl (%rdi,%rcx,4), %edx
cmpl %ecx, %esi
jge 0x1592
movslq %esi, %rax
decl %esi
movl (%rdi,%rax,4), %r8d
cmpl %edx, %r8d
jg 0x1585
movslq %esi, %r9
incl %esi
movl 0x4(%rdi,%r9,4), %r10d
movl %r8d, 0x4(%rdi,%r9,4)
movl %r10d, (%rdi,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x1569
movl (%rdi,%rcx,4), %edx
incl %esi
movslq %esi, %rax
movl (%rdi,%rax,4), %esi
movl %edx, (%rdi,%rax,4)
movl %esi, (%rdi,%rcx,4)
retq
|
quick_partition:
movsxd rcx, edx
mov edx, [rdi+rcx*4]
cmp esi, ecx
jge short loc_1592
movsxd rax, esi
dec esi
loc_1569:
mov r8d, [rdi+rax*4]
cmp r8d, edx
jg short loc_1585
movsxd r9, esi
inc esi
mov r10d, [rdi+r9*4+4]
mov [rdi+r9*4+4], r8d
mov [rdi+rax*4], r10d
loc_1585:
inc rax
cmp rcx, rax
jnz short loc_1569
mov edx, [rdi+rcx*4]
inc esi
loc_1592:
movsxd rax, esi
mov esi, [rdi+rax*4]
mov [rdi+rax*4], edx
mov [rdi+rcx*4], esi
retn
|
long long quick_partition(long long a1, int a2, int a3)
{
long long v3; // rcx
int v4; // edx
long long v5; // rax
int v6; // esi
int v7; // r8d
long long v8; // r9
int v9; // r10d
long long result; // rax
int v11; // esi
v3 = a3;
v4 = *(_DWORD *)(a1 + 4LL * a3);
if ( a2 < (int)v3 )
{
v5 = a2;
v6 = a2 - 1;
do
{
v7 = *(_DWORD *)(a1 + 4 * v5);
if ( v7 <= v4 )
{
v8 = v6++;
v9 = *(_DWORD *)(a1 + 4 * v8 + 4);
*(_DWORD *)(a1 + 4 * v8 + 4) = v7;
*(_DWORD *)(a1 + 4 * v5) = v9;
}
++v5;
}
while ( v3 != v5 );
v4 = *(_DWORD *)(a1 + 4 * v3);
a2 = v6 + 1;
}
result = a2;
v11 = *(_DWORD *)(a1 + 4LL * a2);
*(_DWORD *)(a1 + 4 * result) = v4;
*(_DWORD *)(a1 + 4 * v3) = v11;
return result;
}
|
quick_partition:
MOVSXD RCX,EDX
MOV EDX,dword ptr [RDI + RCX*0x4]
CMP ESI,ECX
JGE 0x00101592
MOVSXD RAX,ESI
DEC ESI
LAB_00101569:
MOV R8D,dword ptr [RDI + RAX*0x4]
CMP R8D,EDX
JG 0x00101585
MOVSXD R9,ESI
INC ESI
MOV R10D,dword ptr [RDI + R9*0x4 + 0x4]
MOV dword ptr [RDI + R9*0x4 + 0x4],R8D
MOV dword ptr [RDI + RAX*0x4],R10D
LAB_00101585:
INC RAX
CMP RCX,RAX
JNZ 0x00101569
MOV EDX,dword ptr [RDI + RCX*0x4]
INC ESI
LAB_00101592:
MOVSXD RAX,ESI
MOV ESI,dword ptr [RDI + RAX*0x4]
MOV dword ptr [RDI + RAX*0x4],EDX
MOV dword ptr [RDI + RCX*0x4],ESI
RET
|
void quick_partition(long param_1,int param_2,int param_3)
{
int iVar1;
int4 uVar2;
long lVar3;
long lVar4;
int iVar5;
long lVar6;
lVar4 = (long)param_3;
iVar5 = *(int *)(param_1 + lVar4 * 4);
if (param_2 < param_3) {
lVar3 = (long)param_2;
param_2 = param_2 + -1;
do {
iVar1 = *(int *)(param_1 + lVar3 * 4);
if (iVar1 <= iVar5) {
lVar6 = (long)param_2;
param_2 = param_2 + 1;
uVar2 = *(int4 *)(param_1 + 4 + lVar6 * 4);
*(int *)(param_1 + 4 + lVar6 * 4) = iVar1;
*(int4 *)(param_1 + lVar3 * 4) = uVar2;
}
lVar3 = lVar3 + 1;
} while (lVar4 != lVar3);
iVar5 = *(int *)(param_1 + lVar4 * 4);
param_2 = param_2 + 1;
}
uVar2 = *(int4 *)(param_1 + (long)param_2 * 4);
*(int *)(param_1 + (long)param_2 * 4) = iVar5;
*(int4 *)(param_1 + lVar4 * 4) = uVar2;
return;
}
|
|
17,737
|
blst_bendian_from_fp12
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/fp12_tower.c
|
void blst_bendian_from_fp12(unsigned char ret[48*12], const vec384fp12 a)
{
size_t i, j;
vec384 out;
for (i = 0; i < 3; i++) {
for (j = 0; j < 2; j++) {
from_fp(out, a[j][i][0]);
be_bytes_from_limbs(ret, out, sizeof(vec384)); ret += 48;
from_fp(out, a[j][i][1]);
be_bytes_from_limbs(ret, out, sizeof(vec384)); ret += 48;
}
}
}
|
O0
|
c
|
blst_bendian_from_fp12:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0xaf66a
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x20(%rbp)
jae 0xaf657
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
imulq $0x120, -0x20(%rbp), %rax # imm = 0x120
addq %rax, %rsi
imulq $0x60, -0x18(%rbp), %rax
addq %rax, %rsi
callq 0xaf670
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0xaf6b0
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
imulq $0x120, -0x20(%rbp), %rax # imm = 0x120
addq %rax, %rsi
imulq $0x60, -0x18(%rbp), %rax
addq %rax, %rsi
addq $0x30, %rsi
callq 0xaf670
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movl $0x30, %edx
callq 0xaf6b0
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xaf5bb
jmp 0xaf659
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xaf5a8
addq $0x50, %rsp
popq %rbp
retq
|
blst_bendian_from_fp12:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
loc_AF5A8:
cmp [rbp+var_18], 3
jnb loc_AF66A
mov [rbp+var_20], 0
loc_AF5BB:
cmp [rbp+var_20], 2
jnb loc_AF657
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_10]
imul rax, [rbp+var_20], 120h
add rsi, rax
imul rax, [rbp+var_18], 60h ; '`'
add rsi, rax
call from_fp
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_50]
mov edx, 30h ; '0'
call be_bytes_from_limbs
mov rax, [rbp+var_8]
add rax, 30h ; '0'
mov [rbp+var_8], rax
lea rdi, [rbp+var_50]
mov rsi, [rbp+var_10]
imul rax, [rbp+var_20], 120h
add rsi, rax
imul rax, [rbp+var_18], 60h ; '`'
add rsi, rax
add rsi, 30h ; '0'
call from_fp
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_50]
mov edx, 30h ; '0'
call be_bytes_from_limbs
mov rax, [rbp+var_8]
add rax, 30h ; '0'
mov [rbp+var_8], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_AF5BB
loc_AF657:
jmp short $+2
loc_AF659:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp loc_AF5A8
loc_AF66A:
add rsp, 50h
pop rbp
retn
|
unsigned long long blst_bendian_from_fp12(long long a1, long long a2)
{
unsigned long long result; // rax
_BYTE v3[48]; // [rsp+0h] [rbp-50h] BYREF
unsigned long long j; // [rsp+30h] [rbp-20h]
unsigned long long i; // [rsp+38h] [rbp-18h]
long long v6; // [rsp+40h] [rbp-10h]
long long v7; // [rsp+48h] [rbp-8h]
v7 = a1;
v6 = a2;
for ( i = 0LL; i < 3; ++i )
{
for ( j = 0LL; j < 2; ++j )
{
from_fp(v3, 96 * i + 288 * j + v6);
be_bytes_from_limbs(v7, v3, 48LL);
v7 += 48LL;
from_fp(v3, 96 * i + 288 * j + v6 + 48);
be_bytes_from_limbs(v7, v3, 48LL);
v7 += 48LL;
}
result = i + 1;
}
return result;
}
|
blst_bendian_from_fp12:
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],0x0
LAB_001af5a8:
CMP qword ptr [RBP + -0x18],0x3
JNC 0x001af66a
MOV qword ptr [RBP + -0x20],0x0
LAB_001af5bb:
CMP qword ptr [RBP + -0x20],0x2
JNC 0x001af657
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x10]
IMUL RAX,qword ptr [RBP + -0x20],0x120
ADD RSI,RAX
IMUL RAX,qword ptr [RBP + -0x18],0x60
ADD RSI,RAX
CALL 0x001af670
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x50]
MOV EDX,0x30
CALL 0x001af6b0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x30
MOV qword ptr [RBP + -0x8],RAX
LEA RDI,[RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x10]
IMUL RAX,qword ptr [RBP + -0x20],0x120
ADD RSI,RAX
IMUL RAX,qword ptr [RBP + -0x18],0x60
ADD RSI,RAX
ADD RSI,0x30
CALL 0x001af670
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x50]
MOV EDX,0x30
CALL 0x001af6b0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x30
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001af5bb
LAB_001af657:
JMP 0x001af659
LAB_001af659:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001af5a8
LAB_001af66a:
ADD RSP,0x50
POP RBP
RET
|
void blst_bendian_from_fp12(long param_1,long param_2)
{
int1 local_58 [48];
ulong local_28;
ulong local_20;
long local_18;
long local_10;
local_18 = param_2;
local_10 = param_1;
for (local_20 = 0; local_20 < 3; local_20 = local_20 + 1) {
for (local_28 = 0; local_28 < 2; local_28 = local_28 + 1) {
from_fp(local_58,local_18 + local_28 * 0x120 + local_20 * 0x60);
be_bytes_from_limbs(local_10,local_58,0x30);
local_10 = local_10 + 0x30;
from_fp(local_58,local_18 + local_28 * 0x120 + local_20 * 0x60 + 0x30);
be_bytes_from_limbs(local_10,local_58,0x30);
local_10 = local_10 + 0x30;
}
}
return;
}
|
|
17,738
|
mysql_real_query_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_real_query_start(int *ret, MYSQL *mysql, const char *stmt_str, unsigned long length)
{
int res;
struct mysql_async_context *b;
struct mysql_real_query_params parms;
b= mysql->options.extension->async_context;
{
WIN_SET_NONBLOCKING(mysql)
parms.mysql= mysql;
parms.stmt_str= stmt_str;
parms.length= length;
}
b->active= 1;
res= my_context_spawn(&b->async_context, mysql_real_query_start_internal, &parms);
b->active= b->suspended= 0;
if (res > 0)
{
/* Suspended. */
b->suspended= 1;
return b->events_to_wait_for;
}
if (res < 0)
{
set_mariadb_error((mysql), CR_OUT_OF_MEMORY, unknown_sqlstate);
*ret= 1;
}
else
*ret= b->ret_result.r_int;
return 0;
}
|
O3
|
c
|
mysql_real_query_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x480(%rsi), %rax
movq 0x28(%rax), %r15
leaq -0x30(%rbp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0x8c(%rip), %rsi # 0x28c21
movq %rax, %rdx
callq 0x2d668
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x28bb2
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x28c16
js 0x28bba
movl 0x8(%r15), %eax
jmp 0x28c12
movl $0x7d8, 0x90(%r14) # imm = 0x7D8
leaq 0x297(%r14), %rdi
leaq 0x1fe2d(%rip), %rax # 0x48a00
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r15d, %r15d
movb %r15b, 0x29c(%r14)
leaq 0x97(%r14), %rdi
leaq 0x1fe18(%rip), %rax # 0x48a10
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r15b, 0x296(%r14)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
mysql_real_query_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+480h]
mov r15, [rax+28h]
lea rax, [rbp+var_30]
mov [rax], rsi
mov [rax+8], rdx
mov [rax+10h], rcx
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_real_query_start_internal
mov rdx, rax
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_28BB2
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_28C16
loc_28BB2:
js short loc_28BBA
mov eax, [r15+8]
jmp short loc_28C12
loc_28BBA:
mov dword ptr [r14+90h], 7D8h
lea rdi, [r14+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r15d, r15d
mov [r14+29Ch], r15b
lea rdi, [r14+97h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov [r14+296h], r15b
mov eax, 1
loc_28C12:
mov [rbx], eax
xor eax, eax
loc_28C16:
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long mysql_real_query_start(int *a1, long long a2, long long a3, long long a4)
{
unsigned int *v4; // r15
int v5; // eax
int v7; // eax
_QWORD v8[6]; // [rsp+0h] [rbp-30h] BYREF
v4 = *(unsigned int **)(*(_QWORD *)(a2 + 1152) + 40LL);
v8[0] = a2;
v8[1] = a3;
v8[2] = a4;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_real_query_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 <= 0 )
{
if ( v5 < 0 )
{
*(_DWORD *)(a2 + 144) = 2008;
strncpy(a2 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a2 + 668) = 0;
strncpy(a2 + 151, client_errors[8], 511LL);
*(_BYTE *)(a2 + 662) = 0;
v7 = 1;
}
else
{
v7 = v4[2];
}
*a1 = v7;
return 0LL;
}
else
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
}
|
mysql_real_query_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RAX,[RBP + -0x30]
MOV qword ptr [RAX],RSI
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RAX + 0x10],RCX
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x128c21]
MOV RDX,RAX
CALL 0x0012d668
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x00128bb2
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x00128c16
LAB_00128bb2:
JS 0x00128bba
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x00128c12
LAB_00128bba:
MOV dword ptr [R14 + 0x90],0x7d8
LEA RDI,[R14 + 0x297]
LEA RAX,[0x148a00]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R15D,R15D
MOV byte ptr [R14 + 0x29c],R15B
LEA RDI,[R14 + 0x97]
LEA RAX,[0x148a10]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [R14 + 0x296],R15B
MOV EAX,0x1
LAB_00128c12:
MOV dword ptr [RBX],EAX
XOR EAX,EAX
LAB_00128c16:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4
mysql_real_query_start(int4 *param_1,long param_2,int8 param_3,int8 param_4)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
long local_38;
int8 local_30;
int8 local_28;
puVar1 = *(int4 **)(*(long *)(param_2 + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
local_38 = param_2;
local_30 = param_3;
local_28 = param_4;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_real_query_start_internal,&local_38);
*(int2 *)(puVar1 + 5) = 0;
if (iVar2 < 1) {
if (iVar2 < 0) {
*(int4 *)(param_2 + 0x90) = 0x7d8;
strncpy((char *)(param_2 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_2 + 0x29c) = 0;
strncpy((char *)(param_2 + 0x97),PTR_s_Client_run_out_of_memory_00148a50,0x1ff);
*(int1 *)(param_2 + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
*param_1 = uVar3;
uVar3 = 0;
}
else {
*(int1 *)((long)puVar1 + 0x15) = 1;
uVar3 = *puVar1;
}
return uVar3;
}
|
|
17,739
|
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, unsigned long, 0>(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&, unsigned long&)
|
monkey531[P]llama/common/json.hpp
|
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::boolean:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
}
|
O0
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, unsigned long, 0>(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&, unsigned long&):
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x112a30
movzbl %al, %ecx
movq %rcx, 0x8(%rsp)
subb $0x9, %al
ja 0x17d5b4
movq 0x8(%rsp), %rax
leaq 0x91f80(%rip), %rcx # 0x20f4b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%rsp), %rdi
callq 0x112a40
movq (%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
jmp 0x17d662
movq 0x50(%rsp), %rdi
callq 0x112a60
movq (%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
jmp 0x17d662
movq 0x50(%rsp), %rdi
callq 0x112a80
movsd (%rax), %xmm0
movsd 0x91991(%rip), %xmm2 # 0x20ef18
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
jmp 0x17d662
jmp 0x17d5b4
movb $0x1, 0x13(%rsp)
movl $0x20, %edi
callq 0x5a680
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0xb4d40
movq %rax, 0x20(%rsp)
leaq 0x9317a(%rip), %rsi # 0x210757
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x112c50
jmp 0x17d5ee
movq (%rsp), %rdi
movq 0x50(%rsp), %rcx
movl $0x12e, %esi # imm = 0x12E
leaq 0x28(%rsp), %rdx
callq 0x112aa0
jmp 0x17d608
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
leaq 0x122770(%rip), %rsi # 0x29fd88
leaq -0xc882f(%rip), %rdx # 0xb4df0
callq 0x5aae0
jmp 0x17d671
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x17d64e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5b528
testb $0x1, 0x13(%rsp)
jne 0x17d657
jmp 0x17d660
movq (%rsp), %rdi
callq 0x5af50
jmp 0x17d667
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x5aba0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
|
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
sub rsp, 58h
mov qword ptr [rsp+58h+var_8], rdi; char
mov qword ptr [rsp+58h+var_10], rsi; int
mov rdi, qword ptr [rsp+58h+var_8]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEcvNS0_6detail7value_tEEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator nlohmann::json_abi_v3_11_3::detail::value_t(void)
movzx ecx, al
mov qword ptr [rsp+58h+var_50], rcx; int
sub al, 9; switch 10 cases
ja def_17D53B; jumptable 000000000017D53B default case
mov rax, qword ptr [rsp+58h+var_50]
lea rcx, jpt_17D53B
movsxd rax, ds:(jpt_17D53B - 20F4B4h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_17D53D:
mov rdi, qword ptr [rsp+58h+var_8]; jumptable 000000000017D53B case 6
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKmTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv
mov rcx, [rax]
mov rax, qword ptr [rsp+58h+var_10]
mov [rax], rcx
jmp loc_17D662
loc_17D557:
mov rdi, qword ptr [rsp+58h+var_8]; jumptable 000000000017D53B case 5
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKlTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv
mov rcx, [rax]
mov rax, qword ptr [rsp+58h+var_10]
mov [rax], rcx
jmp loc_17D662
loc_17D571:
mov rdi, qword ptr [rsp+58h+var_8]; jumptable 000000000017D53B case 7
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKdTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv
movsd xmm0, qword ptr [rax]
movsd xmm2, cs:qword_20EF18
movaps xmm1, xmm0
subsd xmm1, xmm2
cvttsd2si rax, xmm1
cvttsd2si rcx, xmm0
mov rdx, rcx
sar rdx, 3Fh
and rax, rdx
or rcx, rax
mov rax, qword ptr [rsp+58h+var_10]
mov [rax], rcx
jmp loc_17D662
loc_17D5B2:
jmp short $+2; jumptable 000000000017D53B cases 0-4,8,9
def_17D53B:
mov [rsp+58h+var_45], 1; jumptable 000000000017D53B default case
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+58h+var_58], rax; int
mov rdi, qword ptr [rsp+58h+var_8]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; 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>::type_name(void)
mov qword ptr [rsp+58h+var_38], rax; int
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+58h+var_30]
lea rdx, [rsp+58h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
jmp short $+2
loc_17D5EE:
mov rdi, [rsp+58h+var_58]; int
mov rcx, qword ptr [rsp+58h+var_8]
mov esi, 12Eh
lea rdx, [rsp+58h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
jmp short $+2
loc_17D608:
mov rdi, [rsp+58h+var_58]; void *
mov [rsp+58h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_17D671
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
jmp short loc_17D64E
mov rcx, rax
mov eax, edx
mov [rsp+arg_10], rcx
mov [rsp+arg_C], eax
lea rdi, [rsp+arg_20]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_17D64E:
test [rsp+arg_B], 1
jnz short loc_17D657
jmp short loc_17D660
loc_17D657:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_17D660:
jmp short loc_17D667
loc_17D662:
add rsp, 58h
retn
loc_17D667:
mov rdi, [rsp+arg_10]
call __Unwind_Resume
loc_17D671:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
|
long long ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
long long a1,
long long a2)
{
long long v2; // rcx
long long result; // rax
long long v4; // rcx
double v5; // xmm0_8
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // [rsp+0h] [rbp-58h]
int v7[2]; // [rsp+20h] [rbp-38h] BYREF
_BYTE v8[32]; // [rsp+28h] [rbp-30h] BYREF
int v9[2]; // [rsp+48h] [rbp-10h]
char v10[8]; // [rsp+50h] [rbp-8h]
*(_QWORD *)v10 = a1;
*(_QWORD *)v9 = a2;
switch ( nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator nlohmann::json_abi_v3_11_3::detail::value_t(a1) )
{
case 5:
v4 = *(_QWORD *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKlTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv(*(long long *)v10);
result = *(_QWORD *)v9;
**(_QWORD **)v9 = v4;
break;
case 6:
v2 = *(_QWORD *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKmTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv(*(long long *)v10);
result = *(_QWORD *)v9;
**(_QWORD **)v9 = v2;
break;
case 7:
v5 = *(double *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE7get_ptrIPKdTnNSt9enable_ifIXaasr3std10is_pointerIT_EE5valuesr3std8is_constINSt14remove_pointerISI_E4typeEEE5valueEiE4typeELi0EEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalISI_ELi0EEEvEE12get_impl_ptrclsr3stdE7declvalISI_EEEEv(*(long long *)v10);
result = *(_QWORD *)v9;
**(_QWORD **)v9 = (unsigned int)(int)v5;
break;
default:
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
*(_QWORD *)v7 = 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>::type_name(*(_BYTE **)v10);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v8,
(long long)"type must be number, but is ",
(nlohmann::json_abi_v3_11_3::detail **)v7);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
(long long)v8,
*(long long *)v10);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
return result;
}
| |||
17,740
|
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, unsigned long, 0>(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&, unsigned long&)
|
monkey531[P]llama/common/json.hpp
|
void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
{
switch (static_cast<value_t>(j))
{
case value_t::number_unsigned:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
break;
}
case value_t::number_integer:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
break;
}
case value_t::number_float:
{
val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
break;
}
case value_t::null:
case value_t::object:
case value_t::array:
case value_t::string:
case value_t::boolean:
case value_t::binary:
case value_t::discarded:
default:
JSON_THROW(type_error::create(302, concat("type must be number, but is ", j.type_name()), &j));
}
}
|
O2
|
cpp
|
void nlohmann::json_abi_v3_11_3::detail::get_arithmetic_value<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, unsigned long, 0>(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&, unsigned long&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movzbl (%rdi), %eax
cmpl $0x5, %eax
je 0x82d2a
cmpl $0x7, %eax
je 0x82d30
cmpl $0x6, %eax
jne 0x82d61
movq 0x8(%r14), %rax
jmp 0x82d55
movsd 0x8(%r14), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2ec96(%rip), %xmm0 # 0xb19e0
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movq %rax, (%rsi)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x42dc8
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x2ffdd(%rip), %rsi # 0xb2d60
leaq 0x10(%rsp), %rdi
callq 0x62f1b
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x62e2e
xorl %ebp, %ebp
leaq 0x7819a(%rip), %rsi # 0xfaf48
leaq -0x4345d(%rip), %rdx # 0x3f958
movq %rbx, %rdi
callq 0x23ee0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241a8
testb %bpl, %bpl
jne 0x82dd4
jmp 0x82ddc
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f70
|
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov r14, rdi
movzx eax, byte ptr [rdi]
cmp eax, 5
jz short loc_82D2A
cmp eax, 7
jz short loc_82D30
cmp eax, 6
jnz short loc_82D61
loc_82D2A:
mov rax, [r14+8]
jmp short loc_82D55
loc_82D30:
movsd xmm0, qword ptr [r14+8]
cvttsd2si rcx, xmm0
mov rdx, rcx
sar rdx, 3Fh
subsd xmm0, cs:qword_B19E0
cvttsd2si rax, xmm0
and rax, rdx
or rax, rcx
loc_82D55:
mov [rsi], rax
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_82D61:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; 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>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeNumb; "type must be number, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_82DD4
jmp short loc_82DDC
mov r14, rax
loc_82DD4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_82DDC:
mov rdi, r14
call __Unwind_Resume
|
long long ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
double *a1,
_QWORD *a2)
{
int v2; // eax
long long result; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
const char *v5; // [rsp+8h] [rbp-40h] BYREF
_BYTE v6[56]; // [rsp+10h] [rbp-38h] BYREF
v2 = *(unsigned __int8 *)a1;
if ( v2 != 5 )
{
if ( v2 == 7 )
{
result = (unsigned int)(int)a1[1];
goto LABEL_6;
}
if ( v2 != 6 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v5 = 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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v6,
(long long)"type must be number, but is ",
&v5);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
result = *((_QWORD *)a1 + 1);
LABEL_6:
*a2 = result;
return result;
}
|
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
CMP EAX,0x5
JZ 0x00182d2a
CMP EAX,0x7
JZ 0x00182d30
CMP EAX,0x6
JNZ 0x00182d61
LAB_00182d2a:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x00182d55
LAB_00182d30:
MOVSD XMM0,qword ptr [R14 + 0x8]
CVTTSD2SI RCX,XMM0
MOV RDX,RCX
SAR RDX,0x3f
SUBSD XMM0,qword ptr [0x001b19e0]
CVTTSD2SI RAX,XMM0
AND RAX,RDX
OR RAX,RCX
LAB_00182d55:
MOV qword ptr [RSI],RAX
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00182d61:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x00142dc8
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00182d7c:
LEA RSI,[0x1b2d60]
LEA RDI,[RSP + 0x10]
CALL 0x00162f1b
MOV BPL,0x1
LAB_00182d90:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00162e2e
XOR EBP,EBP
LEA RSI,[0x1faf48]
LEA RDX,[0x13f958]
MOV RDI,RBX
CALL 0x00123ee0
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEmTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,ulong *param_2)
{
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>
bVar1;
int8 uVar2;
ulong uVar3;
char *local_40;
detail local_38 [32];
bVar1 = *param_1;
if (bVar1 != (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>
)0x5) {
if (bVar1 == (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>
)0x7) {
uVar3 = (ulong)*(double *)(param_1 + 8);
uVar3 = (long)(*(double *)(param_1 + 8) - _DAT_001b19e0) & (long)uVar3 >> 0x3f | uVar3;
goto LAB_00182d55;
}
if (bVar1 != (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>
)0x6) {
uVar2 = __cxa_allocate_exception(0x20);
local_40 = (char *)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>
::type_name(param_1);
/* try { // try from 00182d7c to 00182d8c has its CatchHandler @ 00182dd1 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be number, but is ",&local_40);
/* try { // try from 00182d90 to 00182dbc has its CatchHandler @ 00182dbd */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar2,0x12e,local_38,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
}
uVar3 = *(ulong *)(param_1 + 8);
LAB_00182d55:
*param_2 = uVar3;
return;
}
|
|
17,741
|
mi_copy_status
|
eloqsql/storage/myisam/mi_locking.c
|
void mi_copy_status(void* to,void *from)
{
MI_INFO *info= (MI_INFO*) to;
DBUG_ENTER("mi_copy_status");
info->state= &((MI_INFO*) from)->save_state;
DBUG_PRINT("info",("key_file: %ld data_file: %ld",
(long) info->state->key_file_length,
(long) info->state->data_file_length));
DBUG_VOID_RETURN;
}
|
O0
|
c
|
mi_copy_status:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xb2896
jmp 0xb2898
jmp 0xb289a
popq %rbp
retq
nopl (%rax)
|
mi_copy_status:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rcx, [rbp+var_10]
add rcx, 10h
mov rax, [rbp+var_18]
mov [rax+8], rcx
jmp short $+2
loc_B2896:
jmp short $+2
loc_B2898:
jmp short $+2
loc_B289A:
pop rbp
retn
|
long long mi_copy_status(long long a1, long long a2)
{
long long result; // rax
result = a1;
*(_QWORD *)(a1 + 8) = a2 + 16;
return result;
}
|
mi_copy_status:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,0x10
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001b2896
LAB_001b2896:
JMP 0x001b2898
LAB_001b2898:
JMP 0x001b289a
LAB_001b289a:
POP RBP
RET
|
void mi_copy_status(long param_1,long param_2)
{
*(long *)(param_1 + 8) = param_2 + 0x10;
return;
}
|
|
17,742
|
Vector3Normalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI Vector3 Vector3Normalize(Vector3 v)
{
Vector3 result = v;
float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length != 0.0f)
{
float ilength = 1.0f/length;
result.x *= ilength;
result.y *= ilength;
result.z *= ilength;
}
return result;
}
|
O2
|
c
|
Vector3Normalize:
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
sqrtss %xmm2, %xmm3
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm3
movss 0x6304e(%rip), %xmm2 # 0xb969c
divss %xmm3, %xmm2
movaps %xmm2, %xmm3
shufps $0x0, %xmm2, %xmm3 # xmm3 = xmm3[0,0],xmm2[0,0]
mulps %xmm0, %xmm3
jne 0x56663
jp 0x56663
movaps %xmm0, %xmm3
mulss %xmm1, %xmm2
jne 0x5666e
jp 0x5666e
movaps %xmm1, %xmm2
movaps %xmm3, %xmm0
movaps %xmm2, %xmm1
retq
|
Vector3Normalize:
movaps xmm2, xmm0
mulps xmm2, xmm0
shufps xmm2, xmm2, 55h ; 'U'
movaps xmm3, xmm0
mulss xmm3, xmm0
addss xmm3, xmm2
movaps xmm2, xmm1
mulss xmm2, xmm1
addss xmm2, xmm3
sqrtss xmm3, xmm2
xorps xmm2, xmm2
ucomiss xmm3, xmm2
movss xmm2, cs:dword_B969C
divss xmm2, xmm3
movaps xmm3, xmm2
shufps xmm3, xmm2, 0
mulps xmm3, xmm0
jnz short loc_56663
jp short loc_56663
movaps xmm3, xmm0
loc_56663:
mulss xmm2, xmm1
jnz short loc_5666E
jp short loc_5666E
movaps xmm2, xmm1
loc_5666E:
movaps xmm0, xmm3
movaps xmm1, xmm2
retn
|
__m128 Vector3Normalize(__m128 a1, float a2)
{
__m128 v2; // xmm2
float v3; // xmm3_4
bool v4; // zf
__m128 v5; // xmm2
__m128 v6; // xmm3
v2 = _mm_mul_ps(a1, a1);
v3 = fsqrt((float)(a2 * a2) + (float)((float)(a1.m128_f32[0] * a1.m128_f32[0]) + _mm_shuffle_ps(v2, v2, 85).m128_f32[0]));
v4 = v3 == 0.0;
v5 = (__m128)0x3F800000u;
v5.m128_f32[0] = 1.0 / v3;
v6 = _mm_mul_ps(_mm_shuffle_ps(v5, v5, 0), a1);
if ( v4 )
return a1;
return v6;
}
|
Vector3Normalize:
MOVAPS XMM2,XMM0
MULPS XMM2,XMM0
SHUFPS XMM2,XMM2,0x55
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
ADDSS XMM3,XMM2
MOVAPS XMM2,XMM1
MULSS XMM2,XMM1
ADDSS XMM2,XMM3
SQRTSS XMM3,XMM2
XORPS XMM2,XMM2
UCOMISS XMM3,XMM2
MOVSS XMM2,dword ptr [0x001b969c]
DIVSS XMM2,XMM3
MOVAPS XMM3,XMM2
SHUFPS XMM3,XMM2,0x0
MULPS XMM3,XMM0
JNZ 0x00156663
JP 0x00156663
MOVAPS XMM3,XMM0
LAB_00156663:
MULSS XMM2,XMM1
JNZ 0x0015666e
JP 0x0015666e
MOVAPS XMM2,XMM1
LAB_0015666e:
MOVAPS XMM0,XMM3
MOVAPS XMM1,XMM2
RET
|
int8 Vector3Normalize(int8 param_1,float param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
fVar2 = (float)((ulong)param_1 >> 0x20);
fVar1 = (float)param_1;
fVar3 = SQRT(param_2 * param_2 + fVar1 * fVar1 + fVar2 * fVar2);
fVar4 = (DAT_001b969c / fVar3) * fVar1;
fVar5 = (DAT_001b969c / fVar3) * fVar2;
if ((fVar3 == 0.0) && (!NAN(fVar3))) {
fVar4 = fVar1;
fVar5 = fVar2;
}
return CONCAT44(fVar5,fVar4);
}
|
|
17,743
|
Vector3Normalize
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI Vector3 Vector3Normalize(Vector3 v)
{
Vector3 result = v;
float length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
if (length != 0.0f)
{
float ilength = 1.0f/length;
result.x *= ilength;
result.y *= ilength;
result.z *= ilength;
}
return result;
}
|
O3
|
c
|
Vector3Normalize:
movaps %xmm0, %xmm2
mulps %xmm0, %xmm2
shufps $0x55, %xmm2, %xmm2 # xmm2 = xmm2[1,1,1,1]
movaps %xmm0, %xmm3
mulss %xmm0, %xmm3
addss %xmm2, %xmm3
movaps %xmm1, %xmm2
mulss %xmm1, %xmm2
addss %xmm3, %xmm2
xorps %xmm3, %xmm3
sqrtss %xmm2, %xmm3
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm3
movss 0x6d527(%rip), %xmm2 # 0xd3b1c
divss %xmm3, %xmm2
movaps %xmm2, %xmm3
shufps $0x0, %xmm2, %xmm3 # xmm3 = xmm3[0,0],xmm2[0,0]
mulps %xmm0, %xmm3
jne 0x6660a
jp 0x6660a
movaps %xmm0, %xmm3
mulss %xmm1, %xmm2
jne 0x66615
jp 0x66615
movaps %xmm1, %xmm2
movaps %xmm3, %xmm0
movaps %xmm2, %xmm1
retq
|
Vector3Normalize:
movaps xmm2, xmm0
mulps xmm2, xmm0
shufps xmm2, xmm2, 55h ; 'U'
movaps xmm3, xmm0
mulss xmm3, xmm0
addss xmm3, xmm2
movaps xmm2, xmm1
mulss xmm2, xmm1
addss xmm2, xmm3
xorps xmm3, xmm3
sqrtss xmm3, xmm2
xorps xmm2, xmm2
ucomiss xmm3, xmm2
movss xmm2, cs:dword_D3B1C
divss xmm2, xmm3
movaps xmm3, xmm2
shufps xmm3, xmm2, 0
mulps xmm3, xmm0
jnz short loc_6660A
jp short loc_6660A
movaps xmm3, xmm0
loc_6660A:
mulss xmm2, xmm1
jnz short loc_66615
jp short loc_66615
movaps xmm2, xmm1
loc_66615:
movaps xmm0, xmm3
movaps xmm1, xmm2
retn
|
__m128 Vector3Normalize(__m128 a1, float a2)
{
__m128 v2; // xmm2
float v3; // xmm3_4
bool v4; // zf
__m128 v5; // xmm2
__m128 v6; // xmm3
v2 = _mm_mul_ps(a1, a1);
v3 = fsqrt((float)(a2 * a2) + (float)((float)(a1.m128_f32[0] * a1.m128_f32[0]) + _mm_shuffle_ps(v2, v2, 85).m128_f32[0]));
v4 = v3 == 0.0;
v5 = (__m128)0x3F800000u;
v5.m128_f32[0] = 1.0 / v3;
v6 = _mm_mul_ps(_mm_shuffle_ps(v5, v5, 0), a1);
if ( v4 )
return a1;
return v6;
}
|
Vector3Normalize:
MOVAPS XMM2,XMM0
MULPS XMM2,XMM0
SHUFPS XMM2,XMM2,0x55
MOVAPS XMM3,XMM0
MULSS XMM3,XMM0
ADDSS XMM3,XMM2
MOVAPS XMM2,XMM1
MULSS XMM2,XMM1
ADDSS XMM2,XMM3
XORPS XMM3,XMM3
SQRTSS XMM3,XMM2
XORPS XMM2,XMM2
UCOMISS XMM3,XMM2
MOVSS XMM2,dword ptr [0x001d3b1c]
DIVSS XMM2,XMM3
MOVAPS XMM3,XMM2
SHUFPS XMM3,XMM2,0x0
MULPS XMM3,XMM0
JNZ 0x0016660a
JP 0x0016660a
MOVAPS XMM3,XMM0
LAB_0016660a:
MULSS XMM2,XMM1
JNZ 0x00166615
JP 0x00166615
MOVAPS XMM2,XMM1
LAB_00166615:
MOVAPS XMM0,XMM3
MOVAPS XMM1,XMM2
RET
|
int8 Vector3Normalize(int8 param_1,float param_2)
{
float fVar1;
float fVar2;
float fVar3;
float fVar4;
float fVar5;
fVar2 = (float)((ulong)param_1 >> 0x20);
fVar1 = (float)param_1;
fVar3 = SQRT(param_2 * param_2 + fVar1 * fVar1 + fVar2 * fVar2);
fVar4 = (DAT_001d3b1c / fVar3) * fVar1;
fVar5 = (DAT_001d3b1c / fVar3) * fVar2;
if ((fVar3 == 0.0) && (!NAN(fVar3))) {
fVar4 = fVar1;
fVar5 = fVar2;
}
return CONCAT44(fVar5,fVar4);
}
|
|
17,744
|
blst_core_verify_pk_in_g1
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/aggregate.c
|
BLST_ERROR blst_core_verify_pk_in_g1(const POINTonE1_affine *pk,
const POINTonE2_affine *signature,
int hash_or_encode,
const void *msg, size_t msg_len,
const void *DST, size_t DST_len,
const void *aug, size_t aug_len)
{
PAIRING ctx;
BLST_ERROR ret;
ctx.ctrl = AGGR_UNDEFINED | (hash_or_encode ? AGGR_HASH_OR_ENCODE : 0);
ctx.nelems = 0;
ctx.DST = DST;
ctx.DST_len = DST_len;
ret = PAIRING_Aggregate_PK_in_G1(&ctx, pk, 1, signature, 1, NULL, 0,
msg, msg_len, aug, aug_len);
if (ret != BLST_SUCCESS)
return ret;
PAIRING_Commit(&ctx);
return PAIRING_FinalVerify(&ctx, NULL) ? BLST_SUCCESS : BLST_VERIFY_FAIL;
}
|
O2
|
c
|
blst_core_verify_pk_in_g1:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xca8, %rsp # imm = 0xCA8
movq %rcx, %rax
movq %rsi, %rcx
movq %rdi, %rsi
xorl %r10d, %r10d
testl %edx, %edx
setne %r10b
shll $0x6, %r10d
leaq -0xc80(%rbp), %rdi
movl %r10d, (%rdi)
andl $0x0, 0x4(%rdi)
movups 0x18(%rbp), %xmm0
movq 0x10(%rbp), %rdx
movq %r9, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movups %xmm0, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rdx
movq %rdx, %r8
xorl %r9d, %r9d
callq 0x575bd
testl %eax, %eax
jne 0x58030
leaq -0xc80(%rbp), %rbx
movq %rbx, %rdi
callq 0x579a1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x57b54
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,4), %eax
addq $0xca8, %rsp # imm = 0xCA8
popq %rbx
popq %rbp
retq
|
blst_core_verify_pk_in_g1:
push rbp
mov rbp, rsp
push rbx
sub rsp, 0CA8h
mov rax, rcx
mov rcx, rsi
mov rsi, rdi
xor r10d, r10d
test edx, edx
setnz r10b
shl r10d, 6
lea rdi, [rbp+var_C80]
mov [rdi], r10d
and dword ptr [rdi+4], 0
movups xmm0, [rbp+arg_8]
mov rdx, [rbp+arg_0]
mov [rdi+8], r9
mov [rdi+10h], rdx
movups [rsp+0CB0h+var_C98], xmm0
mov [rsp+0CB0h+var_CA0], r8
and [rsp+0CB0h+var_CB0], 0
mov [rsp+0CB0h+var_CA8], rax
push 1
pop rdx
mov r8, rdx
xor r9d, r9d
call PAIRING_Aggregate_PK_in_G1
test eax, eax
jnz short loc_58030
lea rbx, [rbp+var_C80]
mov rdi, rbx
call PAIRING_Commit
mov rdi, rbx
xor esi, esi
call PAIRING_FinalVerify
xor ecx, ecx
test rax, rax
setz cl
lea eax, [rcx+rcx*4]
loc_58030:
add rsp, 0CA8h
pop rbx
pop rbp
retn
|
long long blst_core_verify_pk_in_g1(
long long a1,
long long a2,
int a3,
long long a4,
long long a5,
long long a6,
long long a7,
__int128 a8)
{
long long result; // rax
_QWORD v9[400]; // [rsp+30h] [rbp-C80h] BYREF
v9[0] = (unsigned __int8)(a3 != 0) << 6;
v9[1] = a6;
v9[2] = a7;
result = PAIRING_Aggregate_PK_in_G1((long long)v9, a1, 1LL, a2, 1LL, 0LL, 0LL, a4, a5, a8, *((long long *)&a8 + 1));
if ( !(_DWORD)result )
{
PAIRING_Commit((long long)v9);
return 5 * (unsigned int)(PAIRING_FinalVerify(v9, 0LL) == 0);
}
return result;
}
|
blst_core_verify_pk_in_g1:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xca8
MOV RAX,RCX
MOV RCX,RSI
MOV RSI,RDI
XOR R10D,R10D
TEST EDX,EDX
SETNZ R10B
SHL R10D,0x6
LEA RDI,[RBP + -0xc80]
MOV dword ptr [RDI],R10D
AND dword ptr [RDI + 0x4],0x0
MOVUPS XMM0,xmmword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + 0x10]
MOV qword ptr [RDI + 0x8],R9
MOV qword ptr [RDI + 0x10],RDX
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV qword ptr [RSP + 0x10],R8
AND qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
PUSH 0x1
POP RDX
MOV R8,RDX
XOR R9D,R9D
CALL 0x001575bd
TEST EAX,EAX
JNZ 0x00158030
LEA RBX,[RBP + -0xc80]
MOV RDI,RBX
CALL 0x001579a1
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00157b54
XOR ECX,ECX
TEST RAX,RAX
SETZ CL
LEA EAX,[RCX + RCX*0x4]
LAB_00158030:
ADD RSP,0xca8
POP RBX
POP RBP
RET
|
ulong blst_core_verify_pk_in_g1
(int8 param_1,int8 param_2,int param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int4 param_8,
int4 param_9)
{
ulong uVar1;
long lVar2;
int local_c88 [2];
int8 local_c80;
int8 local_c78;
local_c88[0] = (uint)(param_3 != 0) << 6;
local_c88[1] = 0;
local_c78 = param_7;
local_c80 = param_6;
uVar1 = PAIRING_Aggregate_PK_in_G1
(local_c88,param_1,1,param_2,1,0,0,param_4,param_5,param_8,param_9);
if ((int)uVar1 == 0) {
PAIRING_Commit(local_c88);
lVar2 = PAIRING_FinalVerify(local_c88,0);
uVar1 = (ulong)((uint)(lVar2 == 0) * 5);
}
return uVar1;
}
|
|
17,745
|
is_small_allocation
|
seiftnesse[P]memoryallocator/src/custom_alloc_small.c
|
int is_small_allocation(void *ptr) {
// Ensure pointer is valid and within small pool bounds
if (!ptr) return 0;
// Calculate pointer addresses for bounds checking
uintptr_t ptr_addr = (uintptr_t) ptr;
uintptr_t pool_start = (uintptr_t) small_pool;
uintptr_t pool_end = pool_start + SMALL_POOL_SIZE;
int result = (ptr_addr >= pool_start && ptr_addr < pool_end);
HEAP_LOG("Checking if %p is small allocation: %s\n", ptr, result ? "yes" : "no");
return result;
}
|
O1
|
c
|
is_small_allocation:
leaq 0x473e(%rip), %rax # 0x8140
cmpq %rax, %rdi
setae %cl
addq $0x100000, %rax # imm = 0x100000
cmpq %rax, %rdi
setb %al
andb %cl, %al
movzbl %al, %eax
retq
nop
|
is_small_allocation:
lea rax, small_pool
cmp rdi, rax
setnb cl
add rax, 100000h
cmp rdi, rax
setb al
and al, cl
movzx eax, al
retn
|
long long is_small_allocation(unsigned long long a1)
{
return (a1 >= (unsigned long long)&small_pool) & (unsigned __int8)(a1 < (unsigned long long)&small_pool + 0x100000);
}
|
is_small_allocation:
LEA RAX,[0x108140]
CMP RDI,RAX
SETNC CL
ADD RAX,0x100000
CMP RDI,RAX
SETC AL
AND AL,CL
MOVZX EAX,AL
RET
|
bool is_small_allocation(int1 *param_1)
{
return param_1 < memory && (int1 *)0x10813f < param_1;
}
|
|
17,746
|
is_small_allocation
|
seiftnesse[P]memoryallocator/src/custom_alloc_small.c
|
int is_small_allocation(void *ptr) {
// Ensure pointer is valid and within small pool bounds
if (!ptr) return 0;
// Calculate pointer addresses for bounds checking
uintptr_t ptr_addr = (uintptr_t) ptr;
uintptr_t pool_start = (uintptr_t) small_pool;
uintptr_t pool_end = pool_start + SMALL_POOL_SIZE;
int result = (ptr_addr >= pool_start && ptr_addr < pool_end);
HEAP_LOG("Checking if %p is small allocation: %s\n", ptr, result ? "yes" : "no");
return result;
}
|
O3
|
c
|
is_small_allocation:
leaq 0x4746(%rip), %rax # 0x8140
cmpq %rax, %rdi
setae %cl
addq $0x100000, %rax # imm = 0x100000
cmpq %rax, %rdi
setb %al
andb %cl, %al
movzbl %al, %eax
retq
nop
|
is_small_allocation:
lea rax, small_pool
cmp rdi, rax
setnb cl
add rax, 100000h
cmp rdi, rax
setb al
and al, cl
movzx eax, al
retn
|
long long is_small_allocation(unsigned long long a1)
{
return (a1 >= (unsigned long long)&small_pool) & (unsigned __int8)(a1 < (unsigned long long)&small_pool + 0x100000);
}
|
is_small_allocation:
LEA RAX,[0x108140]
CMP RDI,RAX
SETNC CL
ADD RAX,0x100000
CMP RDI,RAX
SETC AL
AND AL,CL
MOVZX EAX,AL
RET
|
bool is_small_allocation(int1 *param_1)
{
return param_1 < memory && (int1 *)0x10813f < param_1;
}
|
|
17,747
|
my_wc_mb_euc_kr
|
eloqsql/strings/ctype-euc_kr.c
|
static int
my_wc_mb_euc_kr(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_ksc5601_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
}
|
O0
|
c
|
my_wc_mb_euc_kr:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x6e33b
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x6e3b4
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jae 0x6e35b
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x6e3b4
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x6e6e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x6e377
movl $0x0, -0x4(%rbp)
jmp 0x6e3b4
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6e38e
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x6e3b4
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
my_wc_mb_euc_kr:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_6E33B
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_6E3B4
loc_6E33B:
mov rax, [rbp+var_18]
cmp eax, 80h
jnb short loc_6E35B
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_6E3B4
loc_6E35B:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_ksc5601_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_6E377
mov [rbp+var_4], 0
jmp short loc_6E3B4
loc_6E377:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6E38E
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_6E3B4
loc_6E38E:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_6E3B4:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long my_wc_mb_euc_kr(long long a1, unsigned int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x80 )
{
v5 = func_uni_ksc5601_onechar(a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_euc_kr:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0016e33b
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0016e3b4
LAB_0016e33b:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JNC 0x0016e35b
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0016e3b4
LAB_0016e35b:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x0016e6e0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0016e377
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0016e3b4
LAB_0016e377:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016e38e
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0016e3b4
LAB_0016e38e:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0016e3b4:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_euc_kr(int8 param_1,uint param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_ksc5601_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
17,748
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>, 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>>>>>::~json_sax_dom_callback_parser()
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
~json_sax_dom_callback_parser() = default;
|
O1
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>, 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>>>>>::~json_sax_dom_callback_parser():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movq %r14, %rdi
callq 0x11e50
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x1a76b
leaq 0x80(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rbx), %rdi
callq 0x11f20
leaq 0x20(%rbx), %rdi
callq 0x11f20
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1a799
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x119b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a7a5
jmp 0x1a7a5
movq %rax, %rdi
callq 0x15362
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, [rdi+0A8h]
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, [rbx+90h]
test rax, rax
jz short loc_1A76B
lea rdi, [rbx+80h]
mov rsi, rdi
mov edx, 3
call rax
loc_1A76B:
lea rdi, [rbx+48h]
call __ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
lea rdi, [rbx+20h]
call __ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
mov rdi, [rbx+8]; void *
test rdi, rdi
jz short loc_1A799
mov rsi, [rbx+18h]
sub rsi, rdi; unsigned __int64
add rsp, 8
pop rbx
pop r14
jmp __ZdlPvm; operator delete(void *,ulong)
loc_1A799:
add rsp, 8
pop rbx
pop r14
retn
jmp short loc_1A7A5
jmp short $+2
loc_1A7A5:
mov rdi, rax
call __clang_call_terminate
|
void nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~json_sax_dom_callback_parser(
_QWORD *a1)
{
void ( *v2)(_QWORD *, _QWORD *, long long); // rax
void *v3; // rdi
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1 + 21,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(a1 + 21);
v2 = (void ( *)(_QWORD *, _QWORD *, long long))a1[18];
if ( v2 )
v2(a1 + 16, a1 + 16, 3LL);
std::_Bvector_base<std::allocator<bool>>::_M_deallocate(a1 + 9);
std::_Bvector_base<std::allocator<bool>>::_M_deallocate(a1 + 4);
v3 = (void *)a1[1];
if ( v3 )
operator delete(v3, a1[3] - (_QWORD)v3);
}
|
~json_sax_dom_callback_parser:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[RDI + 0xa8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R14
CALL 0x00111e50
MOV RAX,qword ptr [RBX + 0x90]
TEST RAX,RAX
JZ 0x0011a76b
LEA RDI,[RBX + 0x80]
LAB_0011a761:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0011a76b:
LEA RDI,[RBX + 0x48]
LAB_0011a76f:
CALL 0x00111f20
LEA RDI,[RBX + 0x20]
LAB_0011a778:
CALL 0x00111f20
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0011a799
MOV RSI,qword ptr [RBX + 0x18]
SUB RSI,RDI
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001119b0
LAB_0011a799:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::~json_sax_dom_callback_parser() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::~json_sax_dom_callback_parser
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
void *pvVar1;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(this + 0xa8),0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(this + 0xa8));
if (*(code **)(this + 0x90) != (code *)0x0) {
/* try { // try from 0011a761 to 0011a76a has its CatchHandler @ 0011a7a1 */
(**(code **)(this + 0x90))(this + 0x80,this + 0x80,3);
}
/* try { // try from 0011a76f to 0011a773 has its CatchHandler @ 0011a7a5 */
std::_Bvector_base<std::allocator<bool>>::_M_deallocate
((_Bvector_base<std::allocator<bool>> *)(this + 0x48));
/* try { // try from 0011a778 to 0011a77c has its CatchHandler @ 0011a7a3 */
std::_Bvector_base<std::allocator<bool>>::_M_deallocate
((_Bvector_base<std::allocator<bool>> *)(this + 0x20));
pvVar1 = *(void **)(this + 8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x18) - (long)pvVar1);
return;
}
return;
}
|
|
17,749
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>, 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>>>>>::~json_sax_dom_callback_parser()
|
11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp
|
~json_sax_dom_callback_parser() = default;
|
O3
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>, 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>>>>>::~json_sax_dom_callback_parser():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x11430
movq %r14, %rdi
callq 0x11e20
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x1a437
leaq 0x80(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rbx), %rdi
callq 0x11ef0
leaq 0x20(%rbx), %rdi
callq 0x11ef0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1a465
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x119a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x1a471
jmp 0x1a471
movq %rax, %rdi
callq 0x1532e
nop
|
_ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEED2Ev:
push r14
push rbx
push rax
mov rbx, rdi
lea r14, [rdi+0A8h]
mov rdi, r14
xor esi, esi
call __ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call __ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rax, [rbx+90h]
test rax, rax
jz short loc_1A437
lea rdi, [rbx+80h]
mov rsi, rdi
mov edx, 3
call rax
loc_1A437:
lea rdi, [rbx+48h]
call __ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
lea rdi, [rbx+20h]
call __ZNSt13_Bvector_baseISaIbEE13_M_deallocateEv; std::_Bvector_base<std::allocator<bool>>::_M_deallocate(void)
mov rdi, [rbx+8]; void *
test rdi, rdi
jz short loc_1A465
mov rsi, [rbx+18h]
sub rsi, rdi; unsigned __int64
add rsp, 8
pop rbx
pop r14
jmp __ZdlPvm; operator delete(void *,ulong)
loc_1A465:
add rsp, 8
pop rbx
pop r14
retn
jmp short loc_1A471
jmp short $+2
loc_1A471:
mov rdi, rax
call __clang_call_terminate
|
void nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::~json_sax_dom_callback_parser(
_QWORD *a1)
{
void ( *v2)(_QWORD *, _QWORD *, long long); // rax
void *v3; // rdi
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1 + 21,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(a1 + 21);
v2 = (void ( *)(_QWORD *, _QWORD *, long long))a1[18];
if ( v2 )
v2(a1 + 16, a1 + 16, 3LL);
std::_Bvector_base<std::allocator<bool>>::_M_deallocate(a1 + 9);
std::_Bvector_base<std::allocator<bool>>::_M_deallocate(a1 + 4);
v3 = (void *)a1[1];
if ( v3 )
operator delete(v3, a1[3] - (_QWORD)v3);
}
|
~json_sax_dom_callback_parser:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14,[RDI + 0xa8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x00111430
MOV RDI,R14
CALL 0x00111e20
MOV RAX,qword ptr [RBX + 0x90]
TEST RAX,RAX
JZ 0x0011a437
LEA RDI,[RBX + 0x80]
LAB_0011a42d:
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0011a437:
LEA RDI,[RBX + 0x48]
LAB_0011a43b:
CALL 0x00111ef0
LEA RDI,[RBX + 0x20]
LAB_0011a444:
CALL 0x00111ef0
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x0011a465
MOV RSI,qword ptr [RBX + 0x18]
SUB RSI,RDI
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001119a0
LAB_0011a465:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::~json_sax_dom_callback_parser() */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::~json_sax_dom_callback_parser
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this)
{
void *pvVar1;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)(this + 0xa8),0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)(this + 0xa8));
if (*(code **)(this + 0x90) != (code *)0x0) {
/* try { // try from 0011a42d to 0011a436 has its CatchHandler @ 0011a46d */
(**(code **)(this + 0x90))(this + 0x80,this + 0x80,3);
}
/* try { // try from 0011a43b to 0011a43f has its CatchHandler @ 0011a471 */
std::_Bvector_base<std::allocator<bool>>::_M_deallocate
((_Bvector_base<std::allocator<bool>> *)(this + 0x48));
/* try { // try from 0011a444 to 0011a448 has its CatchHandler @ 0011a46f */
std::_Bvector_base<std::allocator<bool>>::_M_deallocate
((_Bvector_base<std::allocator<bool>> *)(this + 0x20));
pvVar1 = *(void **)(this + 8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x18) - (long)pvVar1);
return;
}
return;
}
|
|
17,750
|
line_add
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/pairing.c
|
static void line_add(vec384fp6 line, POINTonE2 *T, const POINTonE2 *R,
const POINTonE2_affine *Q)
{
vec384x Z1Z1, U2, S2, H, HH, I, J, V;
#if 1
# define r line[1]
#else
vec384x r;
#endif
/*
* https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl
* with XYZ3 being |T|, XYZ1 - |R|, XY2 - |Q|, i.e. Q is affine
*/
sqr_fp2(Z1Z1, R->Z); /* Z1Z1 = Z1^2 */
mul_fp2(U2, Q->X, Z1Z1); /* U2 = X2*Z1Z1 */
mul_fp2(S2, Q->Y, R->Z);
mul_fp2(S2, S2, Z1Z1); /* S2 = Y2*Z1*Z1Z1 */
sub_fp2(H, U2, R->X); /* H = U2-X1 */
sqr_fp2(HH, H); /* HH = H^2 */
add_fp2(I, HH, HH);
add_fp2(I, I, I); /* I = 4*HH */
mul_fp2(J, H, I); /* J = H*I */
sub_fp2(r, S2, R->Y);
add_fp2(r, r, r); /* r = 2*(S2-Y1) */
mul_fp2(V, R->X, I); /* V = X1*I */
sqr_fp2(T->X, r);
sub_fp2(T->X, T->X, J);
sub_fp2(T->X, T->X, V);
sub_fp2(T->X, T->X, V); /* X3 = r^2-J-2*V */
mul_fp2(J, J, R->Y);
sub_fp2(T->Y, V, T->X);
mul_fp2(T->Y, T->Y, r);
sub_fp2(T->Y, T->Y, J);
sub_fp2(T->Y, T->Y, J); /* Y3 = r*(V-X3)-2*Y1*J */
add_fp2(T->Z, R->Z, H);
sqr_fp2(T->Z, T->Z);
sub_fp2(T->Z, T->Z, Z1Z1);
sub_fp2(T->Z, T->Z, HH); /* Z3 = (Z1+H)^2-Z1Z1-HH */
/*
* line evaluation
*/
mul_fp2(I, r, Q->X);
mul_fp2(J, Q->Y, T->Z);
sub_fp2(I, I, J);
add_fp2(line[0], I, I); /* 2*(r*X2 - Y2*Z3) */
#ifdef r
# undef r
#else
vec_copy(line[1], r, sizeof(r));
#endif
vec_copy(line[2], T->Z, sizeof(T->Z));
}
|
O0
|
c
|
line_add:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xc0, %rsi
callq 0xb6750
leaq -0xe0(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0xb66e0
leaq -0x140(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x60, %rsi
movq -0x18(%rbp), %rdx
addq $0xc0, %rdx
callq 0xb66e0
leaq -0x140(%rbp), %rdi
leaq -0x140(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0xb66e0
leaq -0x1a0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb6520
leaq -0x200(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xb6750
leaq -0x260(%rbp), %rdi
leaq -0x200(%rbp), %rsi
leaq -0x200(%rbp), %rdx
callq 0xb64b0
leaq -0x260(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0xb64b0
leaq -0x2c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0xb66e0
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x140(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x60, %rdx
callq 0xb6520
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
movq -0x8(%rbp), %rdx
addq $0x60, %rdx
callq 0xb64b0
leaq -0x320(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0xb66e0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
callq 0xb6750
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x2c0(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x320(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x320(%rbp), %rdx
callq 0xb6520
leaq -0x2c0(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x60, %rdx
callq 0xb66e0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
leaq -0x320(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
movq -0x8(%rbp), %rdx
addq $0x60, %rdx
callq 0xb66e0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
leaq -0x2c0(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
leaq -0x2c0(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x18(%rbp), %rsi
addq $0xc0, %rsi
leaq -0x1a0(%rbp), %rdx
callq 0xb64b0
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
addq $0xc0, %rsi
callq 0xb6750
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
addq $0xc0, %rsi
leaq -0x80(%rbp), %rdx
callq 0xb6520
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
addq $0xc0, %rsi
leaq -0x200(%rbp), %rdx
callq 0xb6520
leaq -0x260(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x60, %rsi
movq -0x20(%rbp), %rdx
callq 0xb66e0
leaq -0x2c0(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x60, %rsi
movq -0x10(%rbp), %rdx
addq $0xc0, %rdx
callq 0xb66e0
leaq -0x260(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x2c0(%rbp), %rdx
callq 0xb6520
movq -0x8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0xb64b0
movq -0x8(%rbp), %rdi
addq $0xc0, %rdi
movq -0x10(%rbp), %rsi
addq $0xc0, %rsi
movl $0x60, %edx
callq 0xa8ad0
addq $0x320, %rsp # imm = 0x320
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
line_add:
push rbp
mov rbp, rsp
sub rsp, 320h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
lea rdi, [rbp+var_80]
mov rsi, [rbp+var_18]
add rsi, 0C0h
call sqr_fp2
lea rdi, [rbp+var_E0]
mov rsi, [rbp+var_20]
lea rdx, [rbp+var_80]
call mul_fp2
lea rdi, [rbp+var_140]
mov rsi, [rbp+var_20]
add rsi, 60h ; '`'
mov rdx, [rbp+var_18]
add rdx, 0C0h
call mul_fp2
lea rdi, [rbp+var_140]
lea rsi, [rbp+var_140]
lea rdx, [rbp+var_80]
call mul_fp2
lea rdi, [rbp+var_1A0]
lea rsi, [rbp+var_E0]
mov rdx, [rbp+var_18]
call _sub_fp2
lea rdi, [rbp+var_200]
lea rsi, [rbp+var_1A0]
call sqr_fp2
lea rdi, [rbp+var_260]
lea rsi, [rbp+var_200]
lea rdx, [rbp+var_200]
call add_fp2
lea rdi, [rbp+var_260]
lea rsi, [rbp+var_260]
lea rdx, [rbp+var_260]
call add_fp2
lea rdi, [rbp+var_2C0]
lea rsi, [rbp+var_1A0]
lea rdx, [rbp+var_260]
call mul_fp2
mov rdi, [rbp+var_8]
add rdi, 60h ; '`'
lea rsi, [rbp+var_140]
mov rdx, [rbp+var_18]
add rdx, 60h ; '`'
call _sub_fp2
mov rdi, [rbp+var_8]
add rdi, 60h ; '`'
mov rsi, [rbp+var_8]
add rsi, 60h ; '`'
mov rdx, [rbp+var_8]
add rdx, 60h ; '`'
call add_fp2
lea rdi, [rbp+var_320]
mov rsi, [rbp+var_18]
lea rdx, [rbp+var_260]
call mul_fp2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_8]
add rsi, 60h ; '`'
call sqr_fp2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_2C0]
call _sub_fp2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_320]
call _sub_fp2
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_320]
call _sub_fp2
lea rdi, [rbp+var_2C0]
lea rsi, [rbp+var_2C0]
mov rdx, [rbp+var_18]
add rdx, 60h ; '`'
call mul_fp2
mov rdi, [rbp+var_10]
add rdi, 60h ; '`'
lea rsi, [rbp+var_320]
mov rdx, [rbp+var_10]
call _sub_fp2
mov rdi, [rbp+var_10]
add rdi, 60h ; '`'
mov rsi, [rbp+var_10]
add rsi, 60h ; '`'
mov rdx, [rbp+var_8]
add rdx, 60h ; '`'
call mul_fp2
mov rdi, [rbp+var_10]
add rdi, 60h ; '`'
mov rsi, [rbp+var_10]
add rsi, 60h ; '`'
lea rdx, [rbp+var_2C0]
call _sub_fp2
mov rdi, [rbp+var_10]
add rdi, 60h ; '`'
mov rsi, [rbp+var_10]
add rsi, 60h ; '`'
lea rdx, [rbp+var_2C0]
call _sub_fp2
mov rdi, [rbp+var_10]
add rdi, 0C0h
mov rsi, [rbp+var_18]
add rsi, 0C0h
lea rdx, [rbp+var_1A0]
call add_fp2
mov rdi, [rbp+var_10]
add rdi, 0C0h
mov rsi, [rbp+var_10]
add rsi, 0C0h
call sqr_fp2
mov rdi, [rbp+var_10]
add rdi, 0C0h
mov rsi, [rbp+var_10]
add rsi, 0C0h
lea rdx, [rbp+var_80]
call _sub_fp2
mov rdi, [rbp+var_10]
add rdi, 0C0h
mov rsi, [rbp+var_10]
add rsi, 0C0h
lea rdx, [rbp+var_200]
call _sub_fp2
lea rdi, [rbp+var_260]
mov rsi, [rbp+var_8]
add rsi, 60h ; '`'
mov rdx, [rbp+var_20]
call mul_fp2
lea rdi, [rbp+var_2C0]
mov rsi, [rbp+var_20]
add rsi, 60h ; '`'
mov rdx, [rbp+var_10]
add rdx, 0C0h
call mul_fp2
lea rdi, [rbp+var_260]
lea rsi, [rbp+var_260]
lea rdx, [rbp+var_2C0]
call _sub_fp2
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_260]
lea rdx, [rbp+var_260]
call add_fp2
mov rdi, [rbp+var_8]
add rdi, 0C0h
mov rsi, [rbp+var_10]
add rsi, 0C0h
mov edx, 60h ; '`'
call vec_copy
add rsp, 320h
pop rbp
retn
|
unsigned long long line_add(long long a1, long long a2, long long a3, long long a4)
{
_BYTE v5[96]; // [rsp+0h] [rbp-320h] BYREF
_BYTE v6[96]; // [rsp+60h] [rbp-2C0h] BYREF
_BYTE v7[96]; // [rsp+C0h] [rbp-260h] BYREF
_BYTE v8[96]; // [rsp+120h] [rbp-200h] BYREF
_BYTE v9[96]; // [rsp+180h] [rbp-1A0h] BYREF
_BYTE v10[96]; // [rsp+1E0h] [rbp-140h] BYREF
_BYTE v11[96]; // [rsp+240h] [rbp-E0h] BYREF
_BYTE v12[96]; // [rsp+2A0h] [rbp-80h] BYREF
long long v13; // [rsp+300h] [rbp-20h]
long long v14; // [rsp+308h] [rbp-18h]
long long v15; // [rsp+310h] [rbp-10h]
long long v16; // [rsp+318h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
sqr_fp2((long long)v12, a3 + 192);
mul_fp2((long long)v11, v13, (long long)v12);
mul_fp2((long long)v10, v13 + 96, v14 + 192);
mul_fp2((long long)v10, (long long)v10, (long long)v12);
sub_fp2((long long)v9, (long long)v11, v14);
sqr_fp2((long long)v8, (long long)v9);
add_fp2((long long)v7, (long long)v8, (long long)v8);
add_fp2((long long)v7, (long long)v7, (long long)v7);
mul_fp2((long long)v6, (long long)v9, (long long)v7);
sub_fp2(v16 + 96, (long long)v10, v14 + 96);
add_fp2(v16 + 96, v16 + 96, v16 + 96);
mul_fp2((long long)v5, v14, (long long)v7);
sqr_fp2(v15, v16 + 96);
sub_fp2(v15, v15, (long long)v6);
sub_fp2(v15, v15, (long long)v5);
sub_fp2(v15, v15, (long long)v5);
mul_fp2((long long)v6, (long long)v6, v14 + 96);
sub_fp2(v15 + 96, (long long)v5, v15);
mul_fp2(v15 + 96, v15 + 96, v16 + 96);
sub_fp2(v15 + 96, v15 + 96, (long long)v6);
sub_fp2(v15 + 96, v15 + 96, (long long)v6);
add_fp2(v15 + 192, v14 + 192, (long long)v9);
sqr_fp2(v15 + 192, v15 + 192);
sub_fp2(v15 + 192, v15 + 192, (long long)v12);
sub_fp2(v15 + 192, v15 + 192, (long long)v8);
mul_fp2((long long)v7, v16 + 96, v13);
mul_fp2((long long)v6, v13 + 96, v15 + 192);
sub_fp2((long long)v7, (long long)v7, (long long)v6);
add_fp2(v16, (long long)v7, (long long)v7);
return vec_copy(v16 + 192, v15 + 192, 0x60uLL);
}
|
line_add:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x320
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
LEA RDI,[RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0xc0
CALL 0x001b6750
LEA RDI,[RBP + -0xe0]
MOV RSI,qword ptr [RBP + -0x20]
LEA RDX,[RBP + -0x80]
CALL 0x001b66e0
LEA RDI,[RBP + -0x140]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x60
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,0xc0
CALL 0x001b66e0
LEA RDI,[RBP + -0x140]
LEA RSI,[RBP + -0x140]
LEA RDX,[RBP + -0x80]
CALL 0x001b66e0
LEA RDI,[RBP + -0x1a0]
LEA RSI,[RBP + -0xe0]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001b6520
LEA RDI,[RBP + -0x200]
LEA RSI,[RBP + -0x1a0]
CALL 0x001b6750
LEA RDI,[RBP + -0x260]
LEA RSI,[RBP + -0x200]
LEA RDX,[RBP + -0x200]
CALL 0x001b64b0
LEA RDI,[RBP + -0x260]
LEA RSI,[RBP + -0x260]
LEA RDX,[RBP + -0x260]
CALL 0x001b64b0
LEA RDI,[RBP + -0x2c0]
LEA RSI,[RBP + -0x1a0]
LEA RDX,[RBP + -0x260]
CALL 0x001b66e0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x60
LEA RSI,[RBP + -0x140]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,0x60
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x60
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x60
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,0x60
CALL 0x001b64b0
LEA RDI,[RBP + -0x320]
MOV RSI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x260]
CALL 0x001b66e0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x60
CALL 0x001b6750
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x2c0]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x320]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x320]
CALL 0x001b6520
LEA RDI,[RBP + -0x2c0]
LEA RSI,[RBP + -0x2c0]
MOV RDX,qword ptr [RBP + -0x18]
ADD RDX,0x60
CALL 0x001b66e0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x60
LEA RSI,[RBP + -0x320]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x60
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x60
MOV RDX,qword ptr [RBP + -0x8]
ADD RDX,0x60
CALL 0x001b66e0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x60
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x60
LEA RDX,[RBP + -0x2c0]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x60
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x60
LEA RDX,[RBP + -0x2c0]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0xc0
LEA RDX,[RBP + -0x1a0]
CALL 0x001b64b0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0xc0
CALL 0x001b6750
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0xc0
LEA RDX,[RBP + -0x80]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0xc0
LEA RDX,[RBP + -0x200]
CALL 0x001b6520
LEA RDI,[RBP + -0x260]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x60
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001b66e0
LEA RDI,[RBP + -0x2c0]
MOV RSI,qword ptr [RBP + -0x20]
ADD RSI,0x60
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,0xc0
CALL 0x001b66e0
LEA RDI,[RBP + -0x260]
LEA RSI,[RBP + -0x260]
LEA RDX,[RBP + -0x2c0]
CALL 0x001b6520
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x260]
LEA RDX,[RBP + -0x260]
CALL 0x001b64b0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc0
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0xc0
MOV EDX,0x60
CALL 0x001a8ad0
ADD RSP,0x320
POP RBP
RET
|
void line_add(long param_1,long param_2,long param_3,long param_4)
{
int1 local_328 [96];
int1 local_2c8 [96];
int1 local_268 [96];
int1 local_208 [96];
int1 local_1a8 [96];
int1 local_148 [96];
int1 local_e8 [96];
int1 local_88 [96];
long local_28;
long local_20;
long local_18;
long local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
sqr_fp2(local_88,param_3 + 0xc0);
mul_fp2(local_e8,local_28,local_88);
mul_fp2(local_148,local_28 + 0x60,local_20 + 0xc0);
mul_fp2(local_148,local_148,local_88);
sub_fp2(local_1a8,local_e8,local_20);
sqr_fp2(local_208,local_1a8);
add_fp2(local_268,local_208,local_208);
add_fp2(local_268,local_268,local_268);
mul_fp2(local_2c8,local_1a8,local_268);
sub_fp2(local_10 + 0x60,local_148,local_20 + 0x60);
add_fp2(local_10 + 0x60,local_10 + 0x60,local_10 + 0x60);
mul_fp2(local_328,local_20,local_268);
sqr_fp2(local_18,local_10 + 0x60);
sub_fp2(local_18,local_18,local_2c8);
sub_fp2(local_18,local_18,local_328);
sub_fp2(local_18,local_18,local_328);
mul_fp2(local_2c8,local_2c8,local_20 + 0x60);
sub_fp2(local_18 + 0x60,local_328,local_18);
mul_fp2(local_18 + 0x60,local_18 + 0x60,local_10 + 0x60);
sub_fp2(local_18 + 0x60,local_18 + 0x60,local_2c8);
sub_fp2(local_18 + 0x60,local_18 + 0x60,local_2c8);
add_fp2(local_18 + 0xc0,local_20 + 0xc0,local_1a8);
sqr_fp2(local_18 + 0xc0,local_18 + 0xc0);
sub_fp2(local_18 + 0xc0,local_18 + 0xc0,local_88);
sub_fp2(local_18 + 0xc0,local_18 + 0xc0,local_208);
mul_fp2(local_268,local_10 + 0x60,local_28);
mul_fp2(local_2c8,local_28 + 0x60,local_18 + 0xc0);
sub_fp2(local_268,local_268,local_2c8);
add_fp2(local_10,local_268,local_268);
vec_copy(local_10 + 0xc0,local_18 + 0xc0,0x60);
return;
}
|
|
17,751
|
var_object_test
|
bluesky950520[P]quickjs/quickjs.c
|
static void var_object_test(JSContext *ctx, JSFunctionDef *s,
JSAtom var_name, int op, DynBuf *bc,
int *plabel_done, BOOL is_with)
{
dbuf_putc(bc, get_with_scope_opcode(op));
dbuf_put_u32(bc, JS_DupAtom(ctx, var_name));
*plabel_done = new_label_fd(s, *plabel_done);
dbuf_put_u32(bc, *plabel_done);
dbuf_putc(bc, is_with);
update_label(s, *plabel_done, 1);
s->jump_size++;
}
|
O1
|
c
|
var_object_test:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r12
movl 0x40(%rsp), %r13d
leal -0x44(%rcx), %eax
cmpl $0xb6, %ecx
movzbl %al, %eax
movl $0x73, %ecx
cmovnel %eax, %ecx
movzbl %cl, %esi
movq %r8, %rdi
callq 0x1b4d0
cmpl $0xe0, %ebp
jl 0x6ef68
movq 0x18(%r12), %rax
movq 0x68(%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
incl (%rax)
movq %rsp, %rsi
movl %ebp, (%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x1b422
movl (%r14), %esi
movq %rbx, %rdi
callq 0x6c7b9
movl %eax, (%r14)
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x1b422
movzbl %r13b, %esi
movq %r15, %rdi
callq 0x1b4d0
movslq (%r14), %rax
movq 0x170(%rbx), %rcx
leaq (%rax,%rax,2), %rax
incl (%rcx,%rax,8)
incl 0x1b0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
var_object_test:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov r15, r8
mov ebp, edx
mov rbx, rsi
mov r12, rdi
mov r13d, [rsp+38h+arg_0]
lea eax, [rcx-44h]
cmp ecx, 0B6h
movzx eax, al
mov ecx, 73h ; 's'
cmovnz ecx, eax
movzx esi, cl
mov rdi, r8
call dbuf_putc
cmp ebp, 0E0h
jl short loc_6EF68
mov rax, [r12+18h]
mov rax, [rax+68h]
mov ecx, ebp
mov rax, [rax+rcx*8]
inc dword ptr [rax]
loc_6EF68:
mov rsi, rsp
mov [rsi], ebp
mov edx, 4
mov rdi, r15
call dbuf_put
mov esi, [r14]
mov rdi, rbx
call new_label_fd
mov [r14], eax
lea rsi, [rsp+38h+var_34]
mov [rsi], eax
mov edx, 4
mov rdi, r15
call dbuf_put
movzx esi, r13b
mov rdi, r15
call dbuf_putc
movsxd rax, dword ptr [r14]
mov rcx, [rbx+170h]
lea rax, [rax+rax*2]
inc dword ptr [rcx+rax*8]
inc dword ptr [rbx+1B0h]
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long var_object_test(long long a1, long long a2, int a3, int a4, _QWORD *a5, int *a6, char a7)
{
long long v7; // rax
bool v11; // zf
char v12; // al
char v13; // cl
_DWORD *v14; // rax
int v15; // eax
long long result; // rax
_QWORD v17[7]; // [rsp-4h] [rbp-38h] BYREF
v17[0] = v7;
v11 = a4 == 182;
v12 = a4 - 68;
v13 = 115;
if ( !v11 )
v13 = v12;
dbuf_putc(a5, v13);
if ( a3 >= 224 )
{
v14 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a3);
++*v14;
}
LODWORD(v17[0]) = a3;
dbuf_put(a5, (long long)v17, 4LL);
v15 = new_label_fd(a2, *a6);
*a6 = v15;
HIDWORD(v17[0]) = v15;
dbuf_put(a5, (long long)v17 + 4, 4LL);
dbuf_putc(a5, a7);
result = 3LL * *a6;
++*(_DWORD *)(*(_QWORD *)(a2 + 368) + 24LL * *a6);
++*(_DWORD *)(a2 + 432);
return result;
}
|
var_object_test:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV R15,R8
MOV EBP,EDX
MOV RBX,RSI
MOV R12,RDI
MOV R13D,dword ptr [RSP + 0x40]
LEA EAX,[RCX + -0x44]
CMP ECX,0xb6
MOVZX EAX,AL
MOV ECX,0x73
CMOVNZ ECX,EAX
MOVZX ESI,CL
MOV RDI,R8
CALL 0x0011b4d0
CMP EBP,0xe0
JL 0x0016ef68
MOV RAX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,EBP
MOV RAX,qword ptr [RAX + RCX*0x8]
INC dword ptr [RAX]
LAB_0016ef68:
MOV RSI,RSP
MOV dword ptr [RSI],EBP
MOV EDX,0x4
MOV RDI,R15
CALL 0x0011b422
MOV ESI,dword ptr [R14]
MOV RDI,RBX
CALL 0x0016c7b9
MOV dword ptr [R14],EAX
LEA RSI,[RSP + 0x4]
MOV dword ptr [RSI],EAX
MOV EDX,0x4
MOV RDI,R15
CALL 0x0011b422
MOVZX ESI,R13B
MOV RDI,R15
CALL 0x0011b4d0
MOVSXD RAX,dword ptr [R14]
MOV RCX,qword ptr [RBX + 0x170]
LEA RAX,[RAX + RAX*0x2]
INC dword ptr [RCX + RAX*0x8]
INC dword ptr [RBX + 0x1b0]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void var_object_test(long param_1,long param_2,ulong param_3,int param_4,int8 param_5,
int *param_6,int1 param_7)
{
int *piVar1;
int iVar2;
int8 in_RAX;
uint uVar3;
int local_38;
int local_34;
local_34 = (int)((ulong)in_RAX >> 0x20);
uVar3 = 0x73;
if (param_4 != 0xb6) {
uVar3 = param_4 - 0x44U & 0xff;
}
dbuf_putc(param_5,uVar3,param_3,uVar3);
if (0xdf < (int)param_3) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (param_3 & 0xffffffff) * 8);
*piVar1 = *piVar1 + 1;
}
_local_38 = CONCAT44(local_34,(int)param_3);
dbuf_put(param_5,&local_38,4);
iVar2 = new_label_fd(param_2,*param_6);
*param_6 = iVar2;
_local_38 = CONCAT44(iVar2,local_38);
dbuf_put(param_5,&local_34,4);
dbuf_putc(param_5,param_7);
piVar1 = (int *)(*(long *)(param_2 + 0x170) + (long)*param_6 * 0x18);
*piVar1 = *piVar1 + 1;
*(int *)(param_2 + 0x1b0) = *(int *)(param_2 + 0x1b0) + 1;
return;
}
|
|
17,752
|
hi0bits
|
eloqsql/strings/dtoa.c
|
static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
}
|
O3
|
c
|
hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x10000000, %edx # imm = 0x10000000
cmovael %edx, %ecx
leal 0x4(%rax), %edx
cmovael %eax, %edx
leal (,%rcx,4), %esi
movl $0x40000000, %eax # imm = 0x40000000
cmpl %eax, %ecx
cmovael %ecx, %esi
leal 0x2(%rdx), %ecx
cmovael %edx, %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %esi
movl $0x20, %eax
cmovael %edx, %eax
testl %esi, %esi
cmovsl %ecx, %eax
popq %rbp
retq
|
hi0bits:
push rbp
mov rbp, rsp
mov eax, edi
shl eax, 10h
xor ecx, ecx
cmp edi, offset stru_10000
setb cl
cmovnb eax, edi
shl ecx, 4
mov edx, eax
shl edx, 8
cmp eax, 1000000h
cmovnb edx, eax
lea eax, [rcx+8]
cmovnb eax, ecx
mov ecx, edx
shl ecx, 4
cmp edx, 10000000h
cmovnb ecx, edx
lea edx, [rax+4]
cmovnb edx, eax
lea esi, ds:0[rcx*4]
mov eax, 40000000h
cmp ecx, eax
cmovnb esi, ecx
lea ecx, [rdx+2]
cmovnb ecx, edx
lea edx, [rcx+1]
cmp esi, eax
mov eax, 20h ; ' '
cmovnb eax, edx
test esi, esi
cmovs eax, ecx
pop rbp
retn
|
long long hi0bits(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // edx
bool v3; // cf
int v4; // eax
unsigned int v5; // ecx
bool v6; // cf
int v7; // edx
int v8; // esi
bool v9; // cf
unsigned int v10; // ecx
long long result; // rax
v1 = a1 << 16;
if ( a1 >= (unsigned int)&stru_10000 )
v1 = a1;
v2 = v1 << 8;
v3 = v1 < 0x1000000;
if ( v1 >= 0x1000000 )
v2 = v1;
v4 = 16 * (a1 < (unsigned int)&stru_10000) + 8;
if ( !v3 )
v4 = 16 * (a1 < (unsigned int)&stru_10000);
v5 = 16 * v2;
v6 = v2 < 0x10000000;
if ( v2 >= 0x10000000 )
v5 = v2;
v7 = v4 + 4;
if ( !v6 )
v7 = v4;
v8 = 4 * v5;
v9 = v5 < 0x40000000;
if ( v5 >= 0x40000000 )
v8 = v5;
v10 = v7 + 2;
if ( !v9 )
v10 = v7;
result = 32LL;
if ( (unsigned int)v8 >= 0x40000000 )
result = v10 + 1;
if ( v8 < 0 )
return v10;
return result;
}
|
hi0bits:
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
SHL EAX,0x10
XOR ECX,ECX
CMP EDI,0x10000
SETC CL
CMOVNC EAX,EDI
SHL ECX,0x4
MOV EDX,EAX
SHL EDX,0x8
CMP EAX,0x1000000
CMOVNC EDX,EAX
LEA EAX,[RCX + 0x8]
CMOVNC EAX,ECX
MOV ECX,EDX
SHL ECX,0x4
CMP EDX,0x10000000
CMOVNC ECX,EDX
LEA EDX,[RAX + 0x4]
CMOVNC EDX,EAX
LEA ESI,[RCX*0x4]
MOV EAX,0x40000000
CMP ECX,EAX
CMOVNC ESI,ECX
LEA ECX,[RDX + 0x2]
CMOVNC ECX,EDX
LEA EDX,[RCX + 0x1]
CMP ESI,EAX
MOV EAX,0x20
CMOVNC EAX,EDX
TEST ESI,ESI
CMOVS EAX,ECX
POP RBP
RET
|
int hi0bits(uint param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = param_1 << 0x10;
if (param_1 >= 0x10000) {
uVar2 = param_1;
}
iVar4 = (uint)(param_1 < 0x10000) * 0x10;
uVar1 = uVar2 << 8;
if (0xffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 8;
if (0xffffff < uVar2) {
iVar3 = iVar4;
}
uVar2 = uVar1 << 4;
if (0xfffffff < uVar1) {
uVar2 = uVar1;
}
iVar4 = iVar3 + 4;
if (0xfffffff < uVar1) {
iVar4 = iVar3;
}
uVar1 = uVar2 * 4;
if (0x3fffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 2;
if (0x3fffffff < uVar2) {
iVar3 = iVar4;
}
iVar4 = 0x20;
if (0x3fffffff < uVar1) {
iVar4 = iVar3 + 1;
}
if ((int)uVar1 < 0) {
iVar4 = iVar3;
}
return iVar4;
}
|
|
17,753
|
JS_ThrowInternalError
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_INTERNAL_ERROR, fmt, ap);
va_end(ap);
return val;
}
|
O0
|
c
|
JS_ThrowInternalError:
subq $0x108, %rsp # imm = 0x108
testb %al, %al
je 0x2d51c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x10, 0xc0(%rsp)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rdx
movl $0x6, %esi
leaq 0xc0(%rsp), %rcx
callq 0x2d140
movq %rax, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movups 0xb0(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq 0xf8(%rsp), %rdx
addq $0x108, %rsp # imm = 0x108
retq
nopl (%rax,%rax)
|
JS_ThrowInternalError:
sub rsp, 108h
test al, al
jz short loc_2D51C
movaps [rsp+108h+var_D8], xmm0
movaps [rsp+108h+var_C8], xmm1
movaps [rsp+108h+var_B8], xmm2
movaps [rsp+108h+var_A8], xmm3
movaps [rsp+108h+var_98], xmm4
movaps [rsp+108h+var_88], xmm5
movaps [rsp+108h+var_78], xmm6
movaps [rsp+108h+var_68], xmm7
loc_2D51C:
mov [rsp+108h+var_E0], r9
mov [rsp+108h+var_E8], r8
mov [rsp+108h+var_F0], rcx
mov [rsp+108h+var_F8], rdx
mov [rsp+108h+var_20], rdi
mov [rsp+108h+var_28], rsi
mov rax, rsp
mov [rsp+108h+var_38], rax
lea rax, [rsp+108h+arg_0]
mov [rsp+108h+var_40], rax
mov [rsp+108h+var_44], 30h ; '0'
mov [rsp+108h+var_48], 10h
mov rdi, [rsp+108h+var_20]
mov rdx, [rsp+108h+var_28]
mov esi, 6
lea rcx, [rsp+108h+var_48]
call JS_ThrowError
mov qword ptr [rsp+108h+var_58], rax
mov qword ptr [rsp+108h+var_58+8], rdx
movups xmm0, [rsp+108h+var_58]
movaps [rsp+108h+var_18], xmm0
mov rax, qword ptr [rsp+108h+var_18]
mov rdx, qword ptr [rsp+108h+var_18+8]
add rsp, 108h
retn
|
long long JS_ThrowInternalError(
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)
{
_QWORD v16[6]; // [rsp+0h] [rbp-108h] BYREF
__m128 v17; // [rsp+30h] [rbp-D8h]
__m128 v18; // [rsp+40h] [rbp-C8h]
__m128 v19; // [rsp+50h] [rbp-B8h]
__m128 v20; // [rsp+60h] [rbp-A8h]
__m128 v21; // [rsp+70h] [rbp-98h]
__m128 v22; // [rsp+80h] [rbp-88h]
__m128 v23; // [rsp+90h] [rbp-78h]
__m128 v24; // [rsp+A0h] [rbp-68h]
_DWORD v25[2]; // [rsp+C0h] [rbp-48h] BYREF
char *v26; // [rsp+C8h] [rbp-40h]
_QWORD *v27; // [rsp+D0h] [rbp-38h]
long long v28; // [rsp+E0h] [rbp-28h]
long long v29; // [rsp+E8h] [rbp-20h]
v17 = a7;
v18 = a8;
v19 = a9;
v20 = a10;
v21 = a11;
v22 = a12;
v23 = a13;
v24 = a14;
v16[5] = a6;
v16[4] = a5;
v16[3] = a4;
v16[2] = a3;
v29 = a1;
v28 = a2;
v27 = v16;
v26 = &a15;
v25[1] = 48;
v25[0] = 16;
return JS_ThrowError(a1, 6u, a2, (long long)v25);
}
|
JS_ThrowInternalError:
SUB RSP,0x108
TEST AL,AL
JZ 0x0012d51c
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOVAPS xmmword ptr [RSP + 0x50],XMM2
MOVAPS xmmword ptr [RSP + 0x60],XMM3
MOVAPS xmmword ptr [RSP + 0x70],XMM4
MOVAPS xmmword ptr [RSP + 0x80],XMM5
MOVAPS xmmword ptr [RSP + 0x90],XMM6
MOVAPS xmmword ptr [RSP + 0xa0],XMM7
LAB_0012d51c:
MOV qword ptr [RSP + 0x28],R9
MOV qword ptr [RSP + 0x20],R8
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0xe8],RDI
MOV qword ptr [RSP + 0xe0],RSI
MOV RAX,RSP
MOV qword ptr [RSP + 0xd0],RAX
LEA RAX,[RSP + 0x110]
MOV qword ptr [RSP + 0xc8],RAX
MOV dword ptr [RSP + 0xc4],0x30
MOV dword ptr [RSP + 0xc0],0x10
MOV RDI,qword ptr [RSP + 0xe8]
MOV RDX,qword ptr [RSP + 0xe0]
MOV ESI,0x6
LEA RCX,[RSP + 0xc0]
CALL 0x0012d140
MOV qword ptr [RSP + 0xb0],RAX
MOV qword ptr [RSP + 0xb8],RDX
MOVUPS XMM0,xmmword ptr [RSP + 0xb0]
MOVAPS xmmword ptr [RSP + 0xf0],XMM0
MOV RAX,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
ADD RSP,0x108
RET
|
int1 [16]
JS_ThrowInternalError
(int4 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 param_9,int8 param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
int1 auVar1 [16];
char in_AL;
int1 auStack_108 [16];
int8 local_f8;
int8 local_f0;
int8 local_e8;
int8 local_e0;
int4 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int4 local_48;
int4 local_44;
int1 *local_40;
int1 *local_38;
int8 local_28;
int8 local_20;
local_38 = auStack_108;
if (in_AL != '\0') {
local_d8 = param_1;
local_c8 = param_2;
local_b8 = param_3;
local_a8 = param_4;
local_98 = param_5;
local_88 = param_6;
local_78 = param_7;
local_68 = param_8;
}
local_40 = &stack0x00000008;
local_44 = 0x30;
local_48 = 0x10;
local_f8 = param_11;
local_f0 = param_12;
local_e8 = param_13;
local_e0 = param_14;
local_28 = param_10;
local_20 = param_9;
auVar1 = JS_ThrowError(param_9,6,param_10,&local_48);
return auVar1;
}
|
|
17,754
|
JS_ThrowInternalError
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_INTERNAL_ERROR, fmt, ap);
va_end(ap);
return val;
}
|
O2
|
c
|
JS_ThrowInternalError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1c7cb
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
pushq $0x6
popq %rsi
movq %r10, %rdx
callq 0x1c551
pushq $0x6
popq %rdx
xorl %eax, %eax
addq $0xd8, %rsp
retq
|
JS_ThrowInternalError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_1C7CB
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_1C7CB:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
push 6
pop rsi
mov rdx, r10
call JS_ThrowError
push 6
pop rdx
xor eax, eax
add rsp, 0D8h
retn
|
long long JS_ThrowInternalError(
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)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
JS_ThrowError(a1, 6LL, a2, (long long)v16);
return 0LL;
}
|
JS_ThrowInternalError:
SUB RSP,0xd8
MOV R10,RSI
LEA RSI,[RSP + 0x20]
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 0x0011c7cb
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_0011c7cb:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
PUSH 0x6
POP RSI
MOV RDX,R10
CALL 0x0011c551
PUSH 0x6
POP RDX
XOR EAX,EAX
ADD RSP,0xd8
RET
|
int1 [16] JS_ThrowInternalError(int8 param_1,int8 param_2)
{
JS_ThrowError(param_1,6,param_2);
return ZEXT816(6) << 0x40;
}
|
|
17,755
|
JS_ThrowInternalError
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue __attribute__((format(printf, 2, 3))) JS_ThrowInternalError(JSContext *ctx, const char *fmt, ...)
{
JSValue val;
va_list ap;
va_start(ap, fmt);
val = JS_ThrowError(ctx, JS_INTERNAL_ERROR, fmt, ap);
va_end(ap);
return val;
}
|
O3
|
c
|
JS_ThrowInternalError:
subq $0xd8, %rsp
movq %rsi, %r10
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x22f11
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rcx
movq %rsi, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000010, %rax # imm = 0x3000000010
movq %rax, (%rcx)
movl $0x6, %esi
movq %r10, %rdx
callq 0x22c89
movl $0x6, %edx
xorl %eax, %eax
addq $0xd8, %rsp
retq
|
JS_ThrowInternalError:
sub rsp, 0D8h
mov r10, rsi
lea rsi, [rsp+0D8h+var_B8]
mov [rsi+10h], rdx
mov [rsi+18h], rcx
mov [rsi+20h], r8
mov [rsi+28h], r9
test al, al
jz short loc_22F11
movaps [rsp+0D8h+var_88], xmm0
movaps [rsp+0D8h+var_78], xmm1
movaps [rsp+0D8h+var_68], xmm2
movaps [rsp+0D8h+var_58], xmm3
movaps [rsp+0D8h+var_48], xmm4
movaps [rsp+0D8h+var_38], xmm5
movaps [rsp+0D8h+var_28], xmm6
movaps [rsp+0D8h+var_18], xmm7
loc_22F11:
mov rcx, rsp
mov [rcx+10h], rsi
lea rax, [rsp+0D8h+arg_0]
mov [rcx+8], rax
mov rax, 3000000010h
mov [rcx], rax
mov esi, 6
mov rdx, r10
call JS_ThrowError
mov edx, 6
xor eax, eax
add rsp, 0D8h
retn
|
long long JS_ThrowInternalError(
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)
{
_QWORD v16[4]; // [rsp+0h] [rbp-D8h] BYREF
char v17; // [rsp+20h] [rbp-B8h] BYREF
long long v18; // [rsp+30h] [rbp-A8h]
long long v19; // [rsp+38h] [rbp-A0h]
long long v20; // [rsp+40h] [rbp-98h]
long long v21; // [rsp+48h] [rbp-90h]
__m128 v22; // [rsp+50h] [rbp-88h]
__m128 v23; // [rsp+60h] [rbp-78h]
__m128 v24; // [rsp+70h] [rbp-68h]
__m128 v25; // [rsp+80h] [rbp-58h]
__m128 v26; // [rsp+90h] [rbp-48h]
__m128 v27; // [rsp+A0h] [rbp-38h]
__m128 v28; // [rsp+B0h] [rbp-28h]
__m128 v29; // [rsp+C0h] [rbp-18h]
v22 = a7;
v23 = a8;
v24 = a9;
v25 = a10;
v26 = a11;
v27 = a12;
v28 = a13;
v29 = a14;
v18 = a3;
v19 = a4;
v20 = a5;
v21 = a6;
v16[2] = &v17;
v16[1] = &a15;
v16[0] = 0x3000000010LL;
JS_ThrowError(a1, 6LL, a2, (long long)v16);
return 0LL;
}
|
JS_ThrowInternalError:
SUB RSP,0xd8
MOV R10,RSI
LEA RSI,[RSP + 0x20]
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 0x00122f11
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVAPS xmmword ptr [RSP + 0x70],XMM2
MOVAPS xmmword ptr [RSP + 0x80],XMM3
MOVAPS xmmword ptr [RSP + 0x90],XMM4
MOVAPS xmmword ptr [RSP + 0xa0],XMM5
MOVAPS xmmword ptr [RSP + 0xb0],XMM6
MOVAPS xmmword ptr [RSP + 0xc0],XMM7
LAB_00122f11:
MOV RCX,RSP
MOV qword ptr [RCX + 0x10],RSI
LEA RAX,[RSP + 0xe0]
MOV qword ptr [RCX + 0x8],RAX
MOV RAX,0x3000000010
MOV qword ptr [RCX],RAX
MOV ESI,0x6
MOV RDX,R10
CALL 0x00122c89
MOV EDX,0x6
XOR EAX,EAX
ADD RSP,0xd8
RET
|
int1 [16] JS_ThrowInternalError(int8 param_1,int8 param_2)
{
JS_ThrowError(param_1,6,param_2);
return ZEXT816(6) << 0x40;
}
|
|
17,756
|
common_sampler_sample(common_sampler*, llama_context*, int, bool)
|
monkey531[P]llama/common/sampling.cpp
|
llama_token common_sampler_sample(struct common_sampler * gsmpl, struct llama_context * ctx, int idx, bool grammar_first) {
gsmpl->set_logits(ctx, idx);
auto & grmr = gsmpl->grmr;
auto & chain = gsmpl->chain;
auto & cur_p = gsmpl->cur_p; // initialized by set_logits
if (grammar_first) {
llama_sampler_apply(grmr, &cur_p);
}
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during sampling - check your sampling configuration");
const llama_token id = cur_p.data[cur_p.selected].id;
if (grammar_first) {
return id;
}
// check if it the sampled token fits the grammar
{
llama_token_data single_token_data = { id, 1.0f, 0.0f };
llama_token_data_array single_token_data_array = { &single_token_data, 1, -1, false };
llama_sampler_apply(grmr, &single_token_data_array);
const bool is_valid = single_token_data_array.data[0].logit != -INFINITY;
if (is_valid) {
return id;
}
}
// resampling:
// if the token is not valid, sample again, but first apply the grammar sampler and then the sampling chain
gsmpl->set_logits(ctx, idx);
llama_sampler_apply(grmr, &cur_p);
llama_sampler_apply(chain, &cur_p);
GGML_ASSERT(cur_p.selected != -1 && "no selected token during re-sampling - check your sampling configuration");
return cur_p.data[cur_p.selected].id;
}
|
O3
|
cpp
|
common_sampler_sample(common_sampler*, llama_context*, int, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xf2502
leaq 0x198(%rbx), %r14
testl %r12d, %r12d
je 0xf1419
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1e380
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x1e380
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xf14f8
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %r13d
testb %r12b, %r12b
jne 0xf14e6
leaq 0xc(%rsp), %rax
movl %r13d, (%rax)
movss 0x17c83(%rip), %xmm0 # 0x1090e0
movlps %xmm0, 0x4(%rax)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq $0x1, 0x8(%r12)
movq $-0x1, 0x10(%r12)
movb $0x0, 0x18(%r12)
movq 0x138(%rbx), %rdi
movq %r12, %rsi
callq 0x1e380
movq (%r12), %rax
movss 0x29227(%rip), %xmm0 # 0x11a6c4
ucomiss 0x4(%rax), %xmm0
jb 0xf14e6
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xf2502
movq 0x138(%rbx), %rdi
movq %r14, %rsi
callq 0x1e380
movq 0x140(%rbx), %rdi
movq %r14, %rsi
callq 0x1e380
movq 0x1a8(%rbx), %rax
cmpq $-0x1, %rax
je 0xf1514
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %r13d
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2933a(%rip), %rdi # 0x11a839
leaq 0x1956d(%rip), %rdx # 0x10aa73
leaq 0x293f6(%rip), %rcx # 0x11a903
movl $0x133, %esi # imm = 0x133
jmp 0xf152e
leaq 0x2931e(%rip), %rdi # 0x11a839
leaq 0x19551(%rip), %rdx # 0x10aa73
leaq 0x2943a(%rip), %rcx # 0x11a963
movl $0x14f, %esi # imm = 0x14F
xorl %eax, %eax
callq 0x1e500
|
_Z21common_sampler_sampleP14common_samplerP13llama_contextib:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r12d, ecx
mov ebp, edx
mov r15, rsi
mov rbx, rdi
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
lea r14, [rbx+198h]
test r12d, r12d
jz short loc_F1419
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
loc_F1419:
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_F14F8
mov rcx, [r14]
lea rax, [rax+rax*2]
mov r13d, [rcx+rax*4]
test r12b, r12b
jnz loc_F14E6
lea rax, [rsp+68h+var_5C]
mov [rax], r13d
movss xmm0, cs:dword_1090E0
movlps qword ptr [rax+4], xmm0
lea r12, [rsp+68h+var_50]
mov [r12], rax
mov qword ptr [r12+8], 1
mov qword ptr [r12+10h], 0FFFFFFFFFFFFFFFFh
mov byte ptr [r12+18h], 0
mov rdi, [rbx+138h]
mov rsi, r12
call _llama_sampler_apply
mov rax, [r12]
movss xmm0, cs:dword_11A6C4
ucomiss xmm0, dword ptr [rax+4]
jb short loc_F14E6
mov rdi, rbx
mov rsi, r15
mov edx, ebp
call _ZN14common_sampler10set_logitsEP13llama_contexti; common_sampler::set_logits(llama_context *,int)
mov rdi, [rbx+138h]
mov rsi, r14
call _llama_sampler_apply
mov rdi, [rbx+140h]
mov rsi, r14
call _llama_sampler_apply
mov rax, [rbx+1A8h]
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_F1514
mov rcx, [r14]
lea rax, [rax+rax*2]
mov r13d, [rcx+rax*4]
loc_F14E6:
mov eax, r13d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_F14F8:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N; "cur_p.selected != -1 && \"no selected t"...
mov esi, 133h
jmp short loc_F152E
loc_F1514:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCurPSelected1N_0; "cur_p.selected != -1 && \"no selected t"...
mov esi, 14Fh
loc_F152E:
xor eax, eax
call _ggml_abort
|
long long common_sampler_sample(_QWORD *a1, long long a2, unsigned int a3, int a4)
{
_QWORD *v6; // r14
long long v7; // rax
unsigned int v8; // r13d
long long v9; // rax
double v11; // xmm0_8
int v12; // [rsp+Ch] [rbp-5Ch] BYREF
double v13; // [rsp+10h] [rbp-58h] BYREF
_QWORD v14[3]; // [rsp+18h] [rbp-50h] BYREF
char v15; // [rsp+30h] [rbp-38h]
((void (*)(void))common_sampler::set_logits)();
v6 = a1 + 51;
if ( a4 )
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v7 = a1[53];
if ( v7 == -1 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
307LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\"");
}
else
{
v8 = *(_DWORD *)(*v6 + 12 * v7);
if ( (_BYTE)a4 )
return v8;
v12 = *(_DWORD *)(*v6 + 12 * v7);
_mm_storel_ps(&v13, (__m128)0x3F800000u);
v14[0] = &v12;
v14[1] = 1LL;
v14[2] = -1LL;
v15 = 0;
llama_sampler_apply(a1[39], v14);
if ( *(float *)(v14[0] + 4LL) > -INFINITY )
return v8;
common_sampler::set_logits(a1, a2, a3);
llama_sampler_apply(a1[39], a1 + 51);
llama_sampler_apply(a1[40], a1 + 51);
v9 = a1[53];
if ( v9 != -1 )
return *(unsigned int *)(*v6 + 12 * v9);
v11 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
335LL,
"GGML_ASSERT(%s) failed",
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\"");
}
return common_sampler_sample_and_accept_n(v11);
}
|
common_sampler_sample:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R12D,ECX
MOV EBP,EDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x001f2502
LEA R14,[RBX + 0x198]
TEST R12D,R12D
JZ 0x001f1419
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x0011e380
LAB_001f1419:
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x0011e380
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001f14f8
MOV RCX,qword ptr [R14]
LEA RAX,[RAX + RAX*0x2]
MOV R13D,dword ptr [RCX + RAX*0x4]
TEST R12B,R12B
JNZ 0x001f14e6
LEA RAX,[RSP + 0xc]
MOV dword ptr [RAX],R13D
MOVSS XMM0,dword ptr [0x002090e0]
MOVLPS qword ptr [RAX + 0x4],XMM0
LEA R12,[RSP + 0x18]
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],0x1
MOV qword ptr [R12 + 0x10],-0x1
MOV byte ptr [R12 + 0x18],0x0
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R12
CALL 0x0011e380
MOV RAX,qword ptr [R12]
MOVSS XMM0,dword ptr [0x0021a6c4]
UCOMISS XMM0,dword ptr [RAX + 0x4]
JC 0x001f14e6
MOV RDI,RBX
MOV RSI,R15
MOV EDX,EBP
CALL 0x001f2502
MOV RDI,qword ptr [RBX + 0x138]
MOV RSI,R14
CALL 0x0011e380
MOV RDI,qword ptr [RBX + 0x140]
MOV RSI,R14
CALL 0x0011e380
MOV RAX,qword ptr [RBX + 0x1a8]
CMP RAX,-0x1
JZ 0x001f1514
MOV RCX,qword ptr [R14]
LEA RAX,[RAX + RAX*0x2]
MOV R13D,dword ptr [RCX + RAX*0x4]
LAB_001f14e6:
MOV EAX,R13D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001f14f8:
LEA RDI,[0x21a839]
LEA RDX,[0x20aa73]
LEA RCX,[0x21a903]
MOV ESI,0x133
JMP 0x001f152e
LAB_001f1514:
LEA RDI,[0x21a839]
LEA RDX,[0x20aa73]
LEA RCX,[0x21a963]
MOV ESI,0x14f
LAB_001f152e:
XOR EAX,EAX
CALL 0x0011e500
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_sampler_sample(common_sampler*, llama_context*, int, bool) */
int4
common_sampler_sample(common_sampler *param_1,llama_context *param_2,int param_3,bool param_4)
{
common_sampler *pcVar1;
int7 in_register_00000009;
char *pcVar2;
int8 uVar3;
int4 uVar4;
int4 local_5c;
ulong local_58;
int4 *local_50;
int8 local_48;
int8 local_40;
int1 local_38;
common_sampler::set_logits(param_1,param_2,param_3);
pcVar1 = param_1 + 0x198;
if ((int)CONCAT71(in_register_00000009,param_4) != 0) {
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
}
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) != -1) {
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
if (!param_4) {
local_50 = &local_5c;
local_58 = (ulong)_DAT_002090e0;
local_48 = 1;
local_40 = 0xffffffffffffffff;
local_38 = 0;
local_5c = uVar4;
llama_sampler_apply(*(int8 *)(param_1 + 0x138),&local_50);
if ((float)local_50[1] <= DAT_0021a6c4) {
common_sampler::set_logits(param_1,param_2,param_3);
llama_sampler_apply(*(int8 *)(param_1 + 0x138),pcVar1);
llama_sampler_apply(*(int8 *)(param_1 + 0x140),pcVar1);
if (*(long *)(param_1 + 0x1a8) == -1) {
pcVar2 =
"cur_p.selected != -1 && \"no selected token during re-sampling - check your sampling configuration\""
;
uVar3 = 0x14f;
goto LAB_001f152e;
}
uVar4 = *(int4 *)(*(long *)pcVar1 + *(long *)(param_1 + 0x1a8) * 0xc);
}
}
return uVar4;
}
pcVar2 =
"cur_p.selected != -1 && \"no selected token during sampling - check your sampling configuration\""
;
uVar3 = 0x133;
LAB_001f152e:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
17,757
|
TensorStorage::reverse_ne()
|
7CodeWizard[P]stablediffusion/model.h
|
void reverse_ne() {
int64_t new_ne[4] = {1, 1, 1, 1};
for (int i = 0; i < n_dims; i++) {
new_ne[i] = ne[n_dims - 1 - i];
}
for (int i = 0; i < n_dims; i++) {
ne[i] = new_ne[i];
}
}
|
O0
|
c
|
TensorStorage::reverse_ne():
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x38(%rsp)
movq 0xc166a(%rip), %rax # 0x185460
movq %rax, -0x28(%rsp)
movq 0xc1666(%rip), %rax # 0x185468
movq %rax, -0x20(%rsp)
movq 0xc1662(%rip), %rax # 0x185470
movq %rax, -0x18(%rsp)
movq 0xc165e(%rip), %rax # 0x185478
movq %rax, -0x10(%rsp)
movl $0x0, -0x2c(%rsp)
movq -0x38(%rsp), %rcx
movl -0x2c(%rsp), %eax
cmpl 0x48(%rcx), %eax
jge 0xc3e63
movq -0x38(%rsp), %rax
movl 0x48(%rax), %ecx
subl $0x1, %ecx
subl -0x2c(%rsp), %ecx
movslq %ecx, %rcx
movq 0x28(%rax,%rcx,8), %rcx
movslq -0x2c(%rsp), %rax
movq %rcx, -0x28(%rsp,%rax,8)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0xc3e27
movl $0x0, -0x30(%rsp)
movq -0x38(%rsp), %rcx
movl -0x30(%rsp), %eax
cmpl 0x48(%rcx), %eax
jge 0xc3e9f
movq -0x38(%rsp), %rax
movslq -0x30(%rsp), %rcx
movq -0x28(%rsp,%rcx,8), %rdx
movslq -0x30(%rsp), %rcx
movq %rdx, 0x28(%rax,%rcx,8)
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0xc3e6b
retq
|
_ZN13TensorStorage10reverse_neEv:
mov [rsp+var_8], rdi
mov rax, [rsp+var_8]
mov [rsp+var_38], rax
mov rax, cs:qword_185460
mov [rsp+var_28], rax
mov rax, cs:qword_185468
mov [rsp+var_20], rax
mov rax, cs:qword_185470
mov [rsp+var_18], rax
mov rax, cs:qword_185478
mov [rsp+var_10], rax
mov [rsp+var_2C], 0
loc_C3E27:
mov rcx, [rsp+var_38]
mov eax, [rsp+var_2C]
cmp eax, [rcx+48h]
jge short loc_C3E63
mov rax, [rsp+var_38]
mov ecx, [rax+48h]
sub ecx, 1
sub ecx, [rsp+var_2C]
movsxd rcx, ecx
mov rcx, [rax+rcx*8+28h]
movsxd rax, [rsp+var_2C]
mov [rsp+rax*8+var_28], rcx
mov eax, [rsp+var_2C]
add eax, 1
mov [rsp+var_2C], eax
jmp short loc_C3E27
loc_C3E63:
mov [rsp+var_30], 0
loc_C3E6B:
mov rcx, [rsp+var_38]
mov eax, [rsp+var_30]
cmp eax, [rcx+48h]
jge short locret_C3E9F
mov rax, [rsp+var_38]
movsxd rcx, [rsp+var_30]
mov rdx, [rsp+rcx*8+var_28]
movsxd rcx, [rsp+var_30]
mov [rax+rcx*8+28h], rdx
mov eax, [rsp+var_30]
add eax, 1
mov [rsp+var_30], eax
jmp short loc_C3E6B
locret_C3E9F:
retn
|
long long TensorStorage::reverse_ne(TensorStorage *this)
{
long long result; // rax
unsigned int j; // [rsp+8h] [rbp-30h]
int i; // [rsp+Ch] [rbp-2Ch]
_QWORD v4[5]; // [rsp+10h] [rbp-28h]
v4[4] = this;
v4[0] = 1LL;
v4[1] = 1LL;
v4[2] = 1LL;
v4[3] = 1LL;
for ( i = 0; i < *((_DWORD *)this + 18); ++i )
v4[i] = *((_QWORD *)this + *((_DWORD *)this + 18) - 1 - i + 5);
for ( j = 0; ; ++j )
{
result = j;
if ( (signed int)j >= *((_DWORD *)this + 18) )
break;
*((_QWORD *)this + (int)j + 5) = v4[j];
}
return result;
}
|
reverse_ne:
MOV qword ptr [RSP + -0x8],RDI
MOV RAX,qword ptr [RSP + -0x8]
MOV qword ptr [RSP + -0x38],RAX
MOV RAX,qword ptr [0x00285460]
MOV qword ptr [RSP + -0x28],RAX
MOV RAX,qword ptr [0x00285468]
MOV qword ptr [RSP + -0x20],RAX
MOV RAX,qword ptr [0x00285470]
MOV qword ptr [RSP + -0x18],RAX
MOV RAX,qword ptr [0x00285478]
MOV qword ptr [RSP + -0x10],RAX
MOV dword ptr [RSP + -0x2c],0x0
LAB_001c3e27:
MOV RCX,qword ptr [RSP + -0x38]
MOV EAX,dword ptr [RSP + -0x2c]
CMP EAX,dword ptr [RCX + 0x48]
JGE 0x001c3e63
MOV RAX,qword ptr [RSP + -0x38]
MOV ECX,dword ptr [RAX + 0x48]
SUB ECX,0x1
SUB ECX,dword ptr [RSP + -0x2c]
MOVSXD RCX,ECX
MOV RCX,qword ptr [RAX + RCX*0x8 + 0x28]
MOVSXD RAX,dword ptr [RSP + -0x2c]
MOV qword ptr [RSP + RAX*0x8 + -0x28],RCX
MOV EAX,dword ptr [RSP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + -0x2c],EAX
JMP 0x001c3e27
LAB_001c3e63:
MOV dword ptr [RSP + -0x30],0x0
LAB_001c3e6b:
MOV RCX,qword ptr [RSP + -0x38]
MOV EAX,dword ptr [RSP + -0x30]
CMP EAX,dword ptr [RCX + 0x48]
JGE 0x001c3e9f
MOV RAX,qword ptr [RSP + -0x38]
MOVSXD RCX,dword ptr [RSP + -0x30]
MOV RDX,qword ptr [RSP + RCX*0x8 + -0x28]
MOVSXD RCX,dword ptr [RSP + -0x30]
MOV qword ptr [RAX + RCX*0x8 + 0x28],RDX
MOV EAX,dword ptr [RSP + -0x30]
ADD EAX,0x1
MOV dword ptr [RSP + -0x30],EAX
JMP 0x001c3e6b
LAB_001c3e9f:
RET
|
/* TensorStorage::reverse_ne() */
void __thiscall TensorStorage::reverse_ne(TensorStorage *this)
{
int local_30;
int local_2c;
int8 local_28 [4];
TensorStorage *local_8;
local_8 = this;
local_28[0] = DAT_00285460;
local_28[1] = DAT_00285468;
local_28[2] = DAT_00285470;
local_28[3] = DAT_00285478;
for (local_2c = 0; local_2c < *(int *)(this + 0x48); local_2c = local_2c + 1) {
local_28[local_2c] =
*(int8 *)(this + (long)((*(int *)(this + 0x48) + -1) - local_2c) * 8 + 0x28);
}
for (local_30 = 0; local_30 < *(int *)(this + 0x48); local_30 = local_30 + 1) {
*(int8 *)(this + (long)local_30 * 8 + 0x28) = local_28[local_30];
}
return;
}
|
|
17,758
|
TensorStorage::reverse_ne()
|
7CodeWizard[P]stablediffusion/model.h
|
void reverse_ne() {
int64_t new_ne[4] = {1, 1, 1, 1};
for (int i = 0; i < n_dims; i++) {
new_ne[i] = ne[n_dims - 1 - i];
}
for (int i = 0; i < n_dims; i++) {
ne[i] = new_ne[i];
}
}
|
O2
|
c
|
TensorStorage::reverse_ne():
movaps 0x548ff(%rip), %xmm0 # 0x9f310
movaps %xmm0, -0x18(%rsp)
movaps 0x548e3(%rip), %xmm0 # 0x9f300
movaps %xmm0, -0x28(%rsp)
movl 0x48(%rdi), %ecx
xorl %edx, %edx
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
decl %ecx
cmpq %rdx, %rax
je 0x4aa4a
movslq %ecx, %rcx
movq 0x28(%rdi,%rcx,8), %rsi
movq %rsi, -0x28(%rsp,%rdx,8)
incq %rdx
jmp 0x4aa31
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x4aa60
movq -0x28(%rsp,%rcx,8), %rdx
movq %rdx, 0x28(%rdi,%rcx,8)
incq %rcx
jmp 0x4aa4c
retq
nop
|
_ZN13TensorStorage10reverse_neEv:
movaps xmm0, cs:xmmword_9F310
movaps [rsp+var_18], xmm0
movaps xmm0, cs:xmmword_9F300
movaps [rsp+var_28], xmm0
mov ecx, [rdi+48h]
xor edx, edx
test ecx, ecx
mov eax, 0
cmovg eax, ecx
loc_4AA31:
dec ecx
cmp rax, rdx
jz short loc_4AA4A
movsxd rcx, ecx
mov rsi, [rdi+rcx*8+28h]
mov qword ptr [rsp+rdx*8+var_28], rsi
inc rdx
jmp short loc_4AA31
loc_4AA4A:
xor ecx, ecx
loc_4AA4C:
cmp rax, rcx
jz short locret_4AA60
mov rdx, qword ptr [rsp+rcx*8+var_28]
mov [rdi+rcx*8+28h], rdx
inc rcx
jmp short loc_4AA4C
locret_4AA60:
retn
|
long long TensorStorage::reverse_ne(TensorStorage *this)
{
int v1; // ecx
long long v2; // rdx
long long result; // rax
long long i; // rcx
_OWORD v5[2]; // [rsp+0h] [rbp-28h]
v5[1] = xmmword_9F310;
v5[0] = xmmword_9F300;
v1 = *((_DWORD *)this + 18);
v2 = 0LL;
result = 0LL;
if ( v1 > 0 )
result = (unsigned int)v1;
while ( 1 )
{
--v1;
if ( result == v2 )
break;
*((_QWORD *)v5 + v2++) = *((_QWORD *)this + v1 + 5);
}
for ( i = 0LL; result != i; ++i )
*((_QWORD *)this + i + 5) = *((_QWORD *)v5 + i);
return result;
}
|
reverse_ne:
MOVAPS XMM0,xmmword ptr [0x0019f310]
MOVAPS xmmword ptr [RSP + -0x18],XMM0
MOVAPS XMM0,xmmword ptr [0x0019f300]
MOVAPS xmmword ptr [RSP + -0x28],XMM0
MOV ECX,dword ptr [RDI + 0x48]
XOR EDX,EDX
TEST ECX,ECX
MOV EAX,0x0
CMOVG EAX,ECX
LAB_0014aa31:
DEC ECX
CMP RAX,RDX
JZ 0x0014aa4a
MOVSXD RCX,ECX
MOV RSI,qword ptr [RDI + RCX*0x8 + 0x28]
MOV qword ptr [RSP + RDX*0x8 + -0x28],RSI
INC RDX
JMP 0x0014aa31
LAB_0014aa4a:
XOR ECX,ECX
LAB_0014aa4c:
CMP RAX,RCX
JZ 0x0014aa60
MOV RDX,qword ptr [RSP + RCX*0x8 + -0x28]
MOV qword ptr [RDI + RCX*0x8 + 0x28],RDX
INC RCX
JMP 0x0014aa4c
LAB_0014aa60:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* TensorStorage::reverse_ne() */
void __thiscall TensorStorage::reverse_ne(TensorStorage *this)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
int8 local_28 [5];
local_28[2] = _DAT_0019f310;
local_28[3] = _UNK_0019f318;
local_28[0] = _DAT_0019f300;
local_28[1] = _UNK_0019f308;
uVar1 = *(uint *)(this + 0x48);
uVar3 = (ulong)uVar1;
uVar4 = 0;
uVar2 = 0;
if (0 < (int)uVar1) {
uVar2 = (ulong)uVar1;
}
for (; uVar2 != uVar4; uVar4 = uVar4 + 1) {
uVar3 = (ulong)((int)uVar3 + -1);
local_28[uVar4] = *(int8 *)(this + uVar3 * 8 + 0x28);
}
for (uVar3 = 0; uVar2 != uVar3; uVar3 = uVar3 + 1) {
*(int8 *)(this + uVar3 * 8 + 0x28) = local_28[uVar3];
}
return;
}
|
|
17,759
|
test_list_fields_default
|
eloqsql/tests/mysql_client_test.c
|
static void test_list_fields_default()
{
int rc, i;
myheader("test_list_fields_default");
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1");
myquery(rc);
rc= mysql_query(mysql,
"CREATE TABLE t1 ("
" i1 INT NOT NULL DEFAULT 0,"
" i3 BIGINT UNSIGNED NOT NULL DEFAULT 0xFFFFFFFFFFFFFFFF,"
" s1 VARCHAR(10) CHARACTER SET latin1 NOT NULL DEFAULT 's1def',"
" d1 DECIMAL(31,1) NOT NULL DEFAULT 111111111122222222223333333333.9,"
" t1 DATETIME(6) NOT NULL DEFAULT '2001-01-01 10:20:30.123456',"
" e1 ENUM('a','b') NOT NULL DEFAULT 'a'"
")");
myquery(rc);
rc= mysql_query(mysql, "DROP VIEW IF EXISTS v1");
myquery(rc);
rc= mysql_query(mysql, "CREATE VIEW v1 AS SELECT * FROM t1");
myquery(rc);
/*
Checking that mysql_list_fields() returns the same result
for a TABLE and a VIEW on the same table.
*/
for (i= 0; i < 2; i++)
{
const char *table_name= i == 0 ? "t1" : "v1";
MYSQL_RES *result= mysql_list_fields(mysql, table_name, NULL);
mytest(result);
rc= my_process_result_set(result);
DIE_UNLESS(rc == 0);
verify_prepare_field(result, 0, "i1", "i1", MYSQL_TYPE_LONG,
table_name, table_name, current_db,
11, "0");
verify_prepare_field(result, 1, "i3", "i3", MYSQL_TYPE_LONGLONG,
table_name, table_name, current_db,
20, "18446744073709551615");
verify_prepare_field(result, 2, "s1", "s1", MYSQL_TYPE_VAR_STRING,
table_name, table_name, current_db,
10, "s1def");
verify_prepare_field(result, 3, "d1", "d1", MYSQL_TYPE_NEWDECIMAL,
table_name, table_name, current_db,
33, "111111111122222222223333333333.9");
verify_prepare_field(result, 4, "t1", "t1", MYSQL_TYPE_DATETIME,
table_name, table_name, current_db,
26, "2001-01-01 10:20:30.123456");
verify_prepare_field(result, 5, "e1", "e1", MYSQL_TYPE_STRING,
table_name, table_name, current_db,
1, "a");
mysql_free_result(result);
}
myquery(mysql_query(mysql, "DROP VIEW v1"));
myquery(mysql_query(mysql, "DROP TABLE t1"));
}
|
O3
|
c
|
test_list_fields_default:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x3c340e(%rip) # 0x41a4c1
jg 0x57134
movq 0x348f04(%rip), %rbx # 0x39ffc0
movq (%rbx), %rdi
leaq 0x883fe(%rip), %rdx # 0xdf4c4
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
movl 0x3c3631(%rip), %ecx # 0x41a70c
leal 0x1(%rcx), %eax
movl %eax, 0x3c3628(%rip) # 0x41a70c
movl 0x3c361d(%rip), %r8d # 0x41a708
movl 0x3c33fa(%rip), %r9d # 0x41a4ec
subq $0x8, %rsp
leaq 0x88b3c(%rip), %r10 # 0xdfc39
leaq 0x896c8(%rip), %rdx # 0xe07cc
movl $0x1, %esi
xorl %eax, %eax
pushq %r10
callq 0x39240
addq $0x10, %rsp
movq (%rbx), %rdi
leaq 0x883dc(%rip), %rdx # 0xdf4fc
movl $0x1, %esi
xorl %eax, %eax
callq 0x39240
movq (%rbx), %rdi
callq 0x394b0
movq 0x3c338d(%rip), %rdi # 0x41a4c8
leaq 0x8969c(%rip), %rsi # 0xe07de
callq 0x3b116
testl %eax, %eax
jne 0x573c8
movq 0x3c3372(%rip), %rdi # 0x41a4c8
leaq 0x9129f(%rip), %rsi # 0xe83fc
callq 0x3b116
testl %eax, %eax
jne 0x573e7
movq 0x3c3357(%rip), %rdi # 0x41a4c8
leaq 0x913d0(%rip), %rsi # 0xe8548
callq 0x3b116
testl %eax, %eax
jne 0x57406
movq 0x3c333c(%rip), %rdi # 0x41a4c8
leaq 0x89616(%rip), %rsi # 0xe07a9
callq 0x3b116
testl %eax, %eax
jne 0x57425
movb $0x1, %r13b
leaq 0x8966e(%rip), %rbx # 0xe0818
leaq 0x34985f(%rip), %r14 # 0x3a0a10
testb $0x1, %r13b
leaq 0x9677e(%rip), %r15 # 0xed93a
cmovneq %rbx, %r15
movq 0x3c3301(%rip), %rdi # 0x41a4c8
movq %r15, %rsi
xorl %edx, %edx
callq 0x8c603
testq %rax, %rax
je 0x57391
movq %rax, %r12
movq %rax, %rdi
callq 0x3c0fe
testl %eax, %eax
jne 0x573b0
subq $0x8, %rsp
movq %r12, %rdi
xorl %esi, %esi
leaq 0x91362(%rip), %rcx # 0xe855f
movq %rcx, %rdx
movl $0x3, %r8d
movq %r15, %r9
pushq $0x2148 # imm = 0x2148
leaq 0x8ec2a(%rip), %rax # 0xe5e3f
pushq %rax
pushq $0xb
pushq %r14
pushq %r15
callq 0x4c956
addq $0x28, %rsp
movq %r12, %rdi
movl $0x1, %esi
leaq 0x9132e(%rip), %rcx # 0xe8562
movq %rcx, %rdx
movl $0x8, %r8d
movq %r15, %r9
pushq $0x214c # imm = 0x214C
leaq 0x91319(%rip), %rax # 0xe8565
pushq %rax
pushq $0x14
pushq %r14
pushq %r15
callq 0x4c956
addq $0x28, %rsp
movq %r12, %rdi
movl $0x2, %esi
leaq 0x8d96b(%rip), %rcx # 0xe4bd6
movq %rcx, %rdx
movl $0xfd, %r8d
movq %r15, %r9
pushq $0x2150 # imm = 0x2150
leaq 0x912f7(%rip), %rax # 0xe857a
pushq %rax
pushq $0xa
pushq %r14
pushq %r15
callq 0x4c956
addq $0x28, %rsp
movq %r12, %rdi
movl $0x3, %esi
leaq 0x912de(%rip), %rcx # 0xe8580
movq %rcx, %rdx
movl $0xf6, %r8d
movq %r15, %r9
pushq $0x2154 # imm = 0x2154
leaq 0x912c9(%rip), %rax # 0xe8583
pushq %rax
pushq $0x21
pushq %r14
pushq %r15
callq 0x4c956
addq $0x28, %rsp
movq %r12, %rdi
movl $0x4, %esi
movq %rbx, %rdx
movq %rbx, %rcx
movl $0xc, %r8d
movq %r15, %r9
pushq $0x2158 # imm = 0x2158
leaq 0x912b7(%rip), %rax # 0xe85a4
pushq %rax
pushq $0x1a
pushq %r14
pushq %r15
callq 0x4c956
addq $0x28, %rsp
movq %r12, %rdi
movl $0x5, %esi
leaq 0x912b3(%rip), %rcx # 0xe85bf
movq %rcx, %rdx
movl $0xfe, %r8d
movq %r15, %r9
pushq $0x215c # imm = 0x215C
leaq 0x9e2b9(%rip), %rax # 0xf55dd
pushq %rax
pushq $0x1
pushq %r14
pushq %r15
callq 0x4c956
addq $0x30, %rsp
movq %r12, %rdi
callq 0x3b00f
testb $0x1, %r13b
movl $0x0, %r13d
jne 0x571b1
movq 0x3c3175(%rip), %rdi # 0x41a4c8
leaq 0x89835(%rip), %rsi # 0xe0b8f
callq 0x3b116
testl %eax, %eax
jne 0x57444
movq 0x3c315a(%rip), %rdi # 0x41a4c8
leaq 0x89498(%rip), %rsi # 0xe080d
callq 0x3b116
testl %eax, %eax
jne 0x57463
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x3ba57
leaq 0x87a0d(%rip), %rdi # 0xdedac
leaq 0x877d6(%rip), %rdx # 0xdeb7c
movl $0x2141, %esi # imm = 0x2141
callq 0x3bb30
leaq 0x879f5(%rip), %rdi # 0xdedac
leaq 0x935a9(%rip), %rdx # 0xea967
movl $0x2144, %esi # imm = 0x2144
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x879d6(%rip), %rdi # 0xdedac
leaq 0x9dce2(%rip), %rdx # 0xf50bf
movl $0x2126, %esi # imm = 0x2126
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x879b7(%rip), %rdi # 0xdedac
leaq 0x9dcc3(%rip), %rdx # 0xf50bf
movl $0x2131, %esi # imm = 0x2131
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x87998(%rip), %rdi # 0xdedac
leaq 0x9dca4(%rip), %rdx # 0xf50bf
movl $0x2134, %esi # imm = 0x2134
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x87979(%rip), %rdi # 0xdedac
leaq 0x9dc85(%rip), %rdx # 0xf50bf
movl $0x2137, %esi # imm = 0x2137
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x8795a(%rip), %rdi # 0xdedac
leaq 0x9dc66(%rip), %rdx # 0xf50bf
movl $0x2161, %esi # imm = 0x2161
callq 0x3bb30
xorl %edi, %edi
callq 0x3ba57
leaq 0x8793b(%rip), %rdi # 0xdedac
leaq 0x9dc47(%rip), %rdx # 0xf50bf
movl $0x2162, %esi # imm = 0x2162
callq 0x3bb30
|
test_list_fields_default:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp cs:opt_silent, 1
jg short loc_57134
mov rbx, cs:stdout_ptr
mov rdi, [rbx]
lea rdx, asc_DF4C4; "\n\n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
mov ecx, cs:test_count
lea eax, [rcx+1]
mov cs:test_count, eax
mov r8d, cs:iter_count
mov r9d, cs:opt_count
sub rsp, 8
lea r10, aTestListFields_1; "test_list_fields_default"
lea rdx, aUOfUUS; "%u of (%u/%u): %s"
mov esi, 1
xor eax, eax
push r10
call ___fprintf_chk
add rsp, 10h
mov rdi, [rbx]
lea rdx, asc_DF4FC; " \n###################################"...
mov esi, 1
xor eax, eax
call ___fprintf_chk
mov rdi, [rbx]
call _fflush
loc_57134:
mov rdi, cs:mysql
lea rsi, aDropTableIfExi; "DROP TABLE IF EXISTS t1"
call wrap_mysql_query
test eax, eax
jnz loc_573C8
mov rdi, cs:mysql
lea rsi, aCreateTableT1I_2; "CREATE TABLE t1 ( i1 INT NOT NULL DEFAU"...
call wrap_mysql_query
test eax, eax
jnz loc_573E7
mov rdi, cs:mysql
lea rsi, aDropViewIfExis_0; "DROP VIEW IF EXISTS v1"
call wrap_mysql_query
test eax, eax
jnz loc_57406
mov rdi, cs:mysql
lea rsi, aCreateViewV1As; "CREATE VIEW v1 AS SELECT * FROM t1"
call wrap_mysql_query
test eax, eax
jnz loc_57425
mov r13b, 1
lea rbx, aDropTableT1+0Bh; "t1"
lea r14, current_db; "client_test_db"
loc_571B1:
test r13b, 1
lea r15, aDropTableIfExi_71+19h; "v1"
cmovnz r15, rbx
mov rdi, cs:mysql
mov rsi, r15
xor edx, edx
call mysql_list_fields
test rax, rax
jz loc_57391
mov r12, rax
mov rdi, rax
call my_process_result_set
test eax, eax
jnz loc_573B0
sub rsp, 8
mov rdi, r12
xor esi, esi
lea rcx, aI1; "i1"
mov rdx, rcx
mov r8d, 3
mov r9, r15
push 2148h
lea rax, aRc0_2+5; "0"
push rax
push 0Bh
push r14
push r15
call do_verify_prepare_field
add rsp, 28h
mov rdi, r12
mov esi, 1
lea rcx, aI3; "i3"
mov rdx, rcx
mov r8d, 8
mov r9, r15
push 214Ch
lea rax, a18446744073709; "18446744073709551615"
push rax
push 14h
push r14
push r15
call do_verify_prepare_field
add rsp, 28h
mov rdi, r12
mov esi, 2
lea rcx, aSelectIdAsIdAl+2Ch; "s1"
mov rdx, rcx
mov r8d, 0FDh
mov r9, r15
push 2150h
lea rax, aS1def; "s1def"
push rax
push 0Ah
push r14
push r15
call do_verify_prepare_field
add rsp, 28h
mov rdi, r12
mov esi, 3
lea rcx, aD1; "d1"
mov rdx, rcx
mov r8d, 0F6h
mov r9, r15
push 2154h
lea rax, a11111111112222; "111111111122222222223333333333.9"
push rax
push 21h ; '!'
push r14
push r15
call do_verify_prepare_field
add rsp, 28h
mov rdi, r12
mov esi, 4
mov rdx, rbx
mov rcx, rbx
mov r8d, 0Ch
mov r9, r15
push 2158h
lea rax, a20010101102030; "2001-01-01 10:20:30.123456"
push rax
push 1Ah
push r14
push r15
call do_verify_prepare_field
add rsp, 28h
mov rdi, r12
mov esi, 5
lea rcx, aE1; "e1"
mov rdx, rcx
mov r8d, 0FEh
mov r9, r15
push 215Ch
lea rax, aCreateProcedur_22+31h; "a"
push rax
push 1
push r14
push r15
call do_verify_prepare_field
add rsp, 30h
mov rdi, r12
call wrap_mysql_free_result
test r13b, 1
mov r13d, 0
jnz loc_571B1
mov rdi, cs:mysql
lea rsi, aDropViewV1; "DROP VIEW v1"
call wrap_mysql_query
test eax, eax
jnz loc_57444
mov rdi, cs:mysql
lea rsi, aDropTableT1; "DROP TABLE t1"
call wrap_mysql_query
test eax, eax
jnz loc_57463
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_57391:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aFalse; "FALSE"
mov esi, 2141h
call die
loc_573B0:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aRcMysqlDataTru+1Eh; "rc == 0"
mov esi, 2144h
call die
loc_573C8:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2126h
call die
loc_573E7:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2131h
call die
loc_57406:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2134h
call die
loc_57425:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2137h
call die
loc_57444:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2161h
call die
loc_57463:
xor edi, edi
call print_error
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
lea rdx, aTmIYear0+9; "r == 0"
mov esi, 2162h
call die
|
long long test_list_fields_default()
{
int v0; // ecx
char v1; // r13
const char *v2; // r15
long long v3; // rax
long long v4; // r12
bool v5; // zf
long long result; // rax
if ( opt_silent <= 1 )
{
__fprintf_chk(stdout, 1LL, "\n\n#####################################\n");
v0 = test_count++;
__fprintf_chk(stdout, 1LL, "%u of (%u/%u): %s", v0, iter_count, opt_count, "test_list_fields_default");
__fprintf_chk(stdout, 1LL, " \n#####################################\n");
fflush(stdout);
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP TABLE IF EXISTS t1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8486, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(
mysql,
(long long)"CREATE TABLE t1 ( i1 INT NOT NULL DEFAULT 0, i3 BIGINT UNSIGNED NOT NULL DEFAULT 0xFFFFF"
"FFFFFFFFFFF, s1 VARCHAR(10) CHARACTER SET latin1 NOT NULL DEFAULT 's1def', d1 DECIMAL(31"
",1) NOT NULL DEFAULT 111111111122222222223333333333.9, t1 DATETIME(6) NOT NULL DEFAULT '"
"2001-01-01 10:20:30.123456', e1 ENUM('a','b') NOT NULL DEFAULT 'a')") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8497, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP VIEW IF EXISTS v1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8500, "r == 0");
}
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"CREATE VIEW v1 AS SELECT * FROM t1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8503, "r == 0");
}
v1 = 1;
do
{
v2 = "v1";
if ( (v1 & 1) != 0 )
v2 = "t1";
v3 = mysql_list_fields(mysql, v2, 0LL);
if ( !v3 )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8513, "FALSE");
}
v4 = v3;
if ( (unsigned int)my_process_result_set(v3) )
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8516, "rc == 0");
do_verify_prepare_field(v4, 0, "i1", "i1", 3, v2, v2, current_db, 11LL, "0", 8520);
do_verify_prepare_field(v4, 1, "i3", "i3", 8, v2, v2, current_db, 20LL, "18446744073709551615", 8524);
do_verify_prepare_field(v4, 2, "s1", "s1", 253, v2, v2, current_db, 10LL, "s1def", 8528);
do_verify_prepare_field(v4, 3, "d1", "d1", 246, v2, v2, current_db, 33LL, "111111111122222222223333333333.9", 8532);
do_verify_prepare_field(v4, 4, "t1", "t1", 12, v2, v2, current_db, 26LL, "2001-01-01 10:20:30.123456", 8536);
do_verify_prepare_field(v4, 5, "e1", "e1", 254, v2, v2, current_db, 1LL, "a", 8540);
wrap_mysql_free_result(v4);
v5 = (v1 & 1) == 0;
v1 = 0;
}
while ( !v5 );
if ( (unsigned int)wrap_mysql_query(mysql, (long long)"DROP VIEW v1") )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8545, "r == 0");
}
result = wrap_mysql_query(mysql, (long long)"DROP TABLE t1");
if ( (_DWORD)result )
{
print_error(0LL);
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c", 8546, "r == 0");
}
return result;
}
|
test_list_fields_default:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP byte ptr [0x0051a4c1],0x1
JG 0x00157134
MOV RBX,qword ptr [0x0049ffc0]
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4c4]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
MOV ECX,dword ptr [0x0051a70c]
LEA EAX,[RCX + 0x1]
MOV dword ptr [0x0051a70c],EAX
MOV R8D,dword ptr [0x0051a708]
MOV R9D,dword ptr [0x0051a4ec]
SUB RSP,0x8
LEA R10,[0x1dfc39]
LEA RDX,[0x1e07cc]
MOV ESI,0x1
XOR EAX,EAX
PUSH R10
CALL 0x00139240
ADD RSP,0x10
MOV RDI,qword ptr [RBX]
LEA RDX,[0x1df4fc]
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00139240
MOV RDI,qword ptr [RBX]
CALL 0x001394b0
LAB_00157134:
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e07de]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x001573c8
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e83fc]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x001573e7
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e8548]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00157406
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e07a9]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00157425
MOV R13B,0x1
LEA RBX,[0x1e0818]
LEA R14,[0x4a0a10]
LAB_001571b1:
TEST R13B,0x1
LEA R15,[0x1ed93a]
CMOVNZ R15,RBX
MOV RDI,qword ptr [0x0051a4c8]
MOV RSI,R15
XOR EDX,EDX
CALL 0x0018c603
TEST RAX,RAX
JZ 0x00157391
MOV R12,RAX
MOV RDI,RAX
CALL 0x0013c0fe
TEST EAX,EAX
JNZ 0x001573b0
SUB RSP,0x8
MOV RDI,R12
XOR ESI,ESI
LEA RCX,[0x1e855f]
MOV RDX,RCX
MOV R8D,0x3
MOV R9,R15
PUSH 0x2148
LEA RAX,[0x1e5e3f]
PUSH RAX
PUSH 0xb
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x28
MOV RDI,R12
MOV ESI,0x1
LEA RCX,[0x1e8562]
MOV RDX,RCX
MOV R8D,0x8
MOV R9,R15
PUSH 0x214c
LEA RAX,[0x1e8565]
PUSH RAX
PUSH 0x14
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x28
MOV RDI,R12
MOV ESI,0x2
LEA RCX,[0x1e4bd6]
MOV RDX,RCX
MOV R8D,0xfd
MOV R9,R15
PUSH 0x2150
LEA RAX,[0x1e857a]
PUSH RAX
PUSH 0xa
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x28
MOV RDI,R12
MOV ESI,0x3
LEA RCX,[0x1e8580]
MOV RDX,RCX
MOV R8D,0xf6
MOV R9,R15
PUSH 0x2154
LEA RAX,[0x1e8583]
PUSH RAX
PUSH 0x21
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x28
MOV RDI,R12
MOV ESI,0x4
MOV RDX,RBX
MOV RCX,RBX
MOV R8D,0xc
MOV R9,R15
PUSH 0x2158
LEA RAX,[0x1e85a4]
PUSH RAX
PUSH 0x1a
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x28
MOV RDI,R12
MOV ESI,0x5
LEA RCX,[0x1e85bf]
MOV RDX,RCX
MOV R8D,0xfe
MOV R9,R15
PUSH 0x215c
LEA RAX,[0x1f55dd]
PUSH RAX
PUSH 0x1
PUSH R14
PUSH R15
CALL 0x0014c956
ADD RSP,0x30
MOV RDI,R12
CALL 0x0013b00f
TEST R13B,0x1
MOV R13D,0x0
JNZ 0x001571b1
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e0b8f]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00157444
MOV RDI,qword ptr [0x0051a4c8]
LEA RSI,[0x1e080d]
CALL 0x0013b116
TEST EAX,EAX
JNZ 0x00157463
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00157391:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1deb7c]
MOV ESI,0x2141
CALL 0x0013bb30
LAB_001573b0:
LEA RDI,[0x1dedac]
LEA RDX,[0x1ea967]
MOV ESI,0x2144
CALL 0x0013bb30
LAB_001573c8:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2126
CALL 0x0013bb30
LAB_001573e7:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2131
CALL 0x0013bb30
LAB_00157406:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2134
CALL 0x0013bb30
LAB_00157425:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2137
CALL 0x0013bb30
LAB_00157444:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2161
CALL 0x0013bb30
LAB_00157463:
XOR EDI,EDI
CALL 0x0013ba57
LEA RDI,[0x1dedac]
LEA RDX,[0x1f50bf]
MOV ESI,0x2162
CALL 0x0013bb30
|
void test_list_fields_default(void)
{
bool bVar1;
int *puVar2;
bool bVar3;
int iVar4;
long lVar5;
char *pcVar6;
puVar2 = PTR_stdout_0049ffc0;
if (opt_silent < '\x02') {
__fprintf_chk(*(int8 *)PTR_stdout_0049ffc0,1,"\n\n#####################################\n"
);
iVar4 = test_count;
test_count = test_count + 1;
__fprintf_chk(*(int8 *)puVar2,1,"%u of (%u/%u): %s",iVar4,iter_count,opt_count,
"test_list_fields_default");
__fprintf_chk(*(int8 *)puVar2,1," \n#####################################\n");
fflush(*(FILE **)puVar2);
}
iVar4 = wrap_mysql_query(mysql,"DROP TABLE IF EXISTS t1");
if (iVar4 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2126,"r == 0");
}
iVar4 = wrap_mysql_query(mysql,
"CREATE TABLE t1 ( i1 INT NOT NULL DEFAULT 0, i3 BIGINT UNSIGNED NOT NULL DEFAULT 0xFFFFFFFFFFFFFFFF, s1 VARCHAR(10) CHARACTER SET latin1 NOT NULL DEFAULT \'s1def\', d1 DECIMAL(31,1) NOT NULL DEFAULT 111111111122222222223333333333.9, t1 DATETIME(6) NOT NULL DEFAULT \'2001-01-01 10:20:30.123456\', e1 ENUM(\'a\',\'b\') NOT NULL DEFAULT \'a\')"
);
if (iVar4 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2131,"r == 0");
}
iVar4 = wrap_mysql_query(mysql,"DROP VIEW IF EXISTS v1");
if (iVar4 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2134,"r == 0");
}
iVar4 = wrap_mysql_query(mysql,"CREATE VIEW v1 AS SELECT * FROM t1");
if (iVar4 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2137,"r == 0");
}
bVar3 = true;
do {
bVar1 = bVar3;
pcVar6 = "v1";
if (bVar1) {
pcVar6 = "t1";
}
lVar5 = mysql_list_fields(mysql,pcVar6,0);
if (lVar5 == 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2141,"FALSE");
}
iVar4 = my_process_result_set(lVar5);
if (iVar4 != 0) {
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2144,"rc == 0");
}
do_verify_prepare_field
(lVar5,0,&DAT_001e855f,&DAT_001e855f,3,pcVar6,pcVar6,current_db,0xb,&DAT_001e5e3f,
0x2148);
do_verify_prepare_field
(lVar5,1,&DAT_001e8562,&DAT_001e8562,8,pcVar6,pcVar6,current_db,0x14,
"18446744073709551615",0x214c);
do_verify_prepare_field(lVar5,2,"s1","s1",0xfd,pcVar6,pcVar6,current_db,10,"s1def",0x2150);
do_verify_prepare_field
(lVar5,3,&DAT_001e8580,&DAT_001e8580,0xf6,pcVar6,pcVar6,current_db,0x21,
"111111111122222222223333333333.9",0x2154);
do_verify_prepare_field
(lVar5,4,"t1","t1",0xc,pcVar6,pcVar6,current_db,0x1a,"2001-01-01 10:20:30.123456",
0x2158);
do_verify_prepare_field
(lVar5,5,&DAT_001e85bf,&DAT_001e85bf,0xfe,pcVar6,pcVar6,current_db,1,"a",0x215c);
wrap_mysql_free_result(lVar5);
bVar3 = false;
} while (bVar1);
iVar4 = wrap_mysql_query(mysql,"DROP VIEW v1");
if (iVar4 != 0) {
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2161,"r == 0");
}
iVar4 = wrap_mysql_query(mysql,"DROP TABLE t1");
if (iVar4 == 0) {
return;
}
print_error(0);
/* WARNING: Subroutine does not return */
die("/workspace/llm4binary/github2025/eloqsql/tests/mysql_client_test.c",0x2162,"r == 0");
}
|
|
17,760
|
my_hash_sort_simple
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x58(%rdi), %rax
leaq (%rsi,%rdx), %rdi
cmpq $0x11, %rdx
jb 0x3d421
cmpq $0x15, %rdx
jb 0x3d40c
movq %rdi, %r10
andq $-0x4, %r10
cmpq %rsi, %r10
jbe 0x3d40c
leaq 0x3(%rsi), %r9
andq $-0x4, %r9
movq %rdi, %rdx
movb -0x1(%rdi), %r11b
cmpq %r10, %rdi
jbe 0x3d48c
leaq -0x1(%rdx), %rdi
cmpb $0x20, %r11b
je 0x3d3f0
jmp 0x3d40f
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdx
jbe 0x3d421
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
je 0x3d40f
movb 0x20(%rax), %r9b
movq %rdi, %r11
subq %rsi, %r11
movq %rdi, %rdx
movq %r11, %r10
cmpq %rsi, %rdi
jbe 0x3d448
leaq -0x1(%rdx), %rdi
movzbl -0x1(%rdx), %ebx
leaq -0x1(%r10), %r11
cmpb %r9b, (%rax,%rbx)
je 0x3d42b
movq (%rcx), %rdi
movq (%r8), %r9
testq %r10, %r10
jle 0x3d483
movl %edi, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rax,%r11), %r11d
imulq %r10, %r11
movq %rdi, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rdi
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x3d453
movq %rdi, (%rcx)
movq %r9, (%r8)
popq %rbx
popq %rbp
retq
cmpb $0x20, %r11b
setne %dil
cmpq %r10, %r9
setae %r10b
orb %dil, %r10b
jne 0x3d40f
movq %rdx, %rdi
movq %rdi, %rdx
cmpq %r9, %rdi
jbe 0x3d40f
leaq -0x4(%rdx), %rdi
cmpl $0x20202020, -0x4(%rdx) # imm = 0x20202020
je 0x3d4a7
jmp 0x3d40f
|
my_hash_sort_simple:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi+58h]
lea rdi, [rsi+rdx]
cmp rdx, 11h
jb short loc_3D421
cmp rdx, 15h
jb short loc_3D40C
mov r10, rdi
and r10, 0FFFFFFFFFFFFFFFCh
cmp r10, rsi
jbe short loc_3D40C
lea r9, [rsi+3]
and r9, 0FFFFFFFFFFFFFFFCh
loc_3D3F0:
mov rdx, rdi
mov r11b, [rdi-1]
cmp rdi, r10
jbe loc_3D48C
lea rdi, [rdx-1]
cmp r11b, 20h ; ' '
jz short loc_3D3F0
jmp short loc_3D40F
loc_3D40C:
mov rdx, rdi
loc_3D40F:
mov rdi, rdx
cmp rdx, rsi
jbe short loc_3D421
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
jz short loc_3D40F
loc_3D421:
mov r9b, [rax+20h]
mov r11, rdi
sub r11, rsi
loc_3D42B:
mov rdx, rdi
mov r10, r11
cmp rdi, rsi
jbe short loc_3D448
lea rdi, [rdx-1]
movzx ebx, byte ptr [rdx-1]
lea r11, [r10-1]
cmp [rax+rbx], r9b
jz short loc_3D42B
loc_3D448:
mov rdi, [rcx]
mov r9, [r8]
test r10, r10
jle short loc_3D483
loc_3D453:
mov r10d, edi
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rax+r11]
imul r11, r10
mov r10, rdi
shl r10, 8
add r10, r11
xor rdi, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_3D453
loc_3D483:
mov [rcx], rdi
mov [r8], r9
pop rbx
pop rbp
retn
loc_3D48C:
cmp r11b, 20h ; ' '
setnz dil
cmp r9, r10
setnb r10b
or r10b, dil
jnz loc_3D40F
mov rdi, rdx
loc_3D4A7:
mov rdx, rdi
cmp rdi, r9
jbe loc_3D40F
lea rdi, [rdx-4]
cmp dword ptr [rdx-4], 20202020h
jz short loc_3D4A7
jmp loc_3D40F
|
long long my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, long long *a5)
{
long long result; // rax
unsigned long long v6; // rdi
unsigned long long v7; // r10
unsigned long long v8; // r9
unsigned __int8 *v9; // rdx
char v10; // r11
long long v11; // r11
unsigned long long v12; // rdx
long long v13; // r10
long long v14; // rdi
long long v15; // r9
result = *(_QWORD *)(a1 + 88);
v6 = (unsigned long long)&a2[a3];
if ( a3 >= 0x11 )
{
if ( a3 < 0x15 || (v7 = v6 & 0xFFFFFFFFFFFFFFFCLL, (v6 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v9 = &a2[a3];
}
else
{
v8 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v9 = (unsigned __int8 *)v6;
v10 = *(_BYTE *)(v6 - 1);
if ( v6 <= v7 )
break;
--v6;
if ( v10 != 32 )
goto LABEL_9;
}
if ( v10 == 32 && v8 < v7 )
{
do
{
v9 = (unsigned __int8 *)v6;
if ( v6 <= v8 )
break;
v6 -= 4LL;
}
while ( *((_DWORD *)v9 - 1) == 538976288 );
}
}
do
{
LABEL_9:
v6 = (unsigned long long)v9;
if ( v9 <= a2 )
break;
--v9;
}
while ( *(_BYTE *)(v6 - 1) == 32 );
}
v11 = v6 - (_QWORD)a2;
do
{
v12 = v6;
v13 = v11;
if ( v6 <= (unsigned long long)a2 )
break;
--v6;
--v11;
}
while ( *(_BYTE *)(result + *(unsigned __int8 *)(v12 - 1)) == *(_BYTE *)(result + 32) );
v14 = *a4;
v15 = *a5;
if ( v13 > 0 )
{
do
{
v14 ^= (v15 + (v14 & 0x3F)) * *(unsigned __int8 *)(result + *a2) + (v14 << 8);
v15 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v12 );
}
*a4 = v14;
*a5 = v15;
return result;
}
|
my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x58]
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x11
JC 0x0013d421
CMP RDX,0x15
JC 0x0013d40c
MOV R10,RDI
AND R10,-0x4
CMP R10,RSI
JBE 0x0013d40c
LEA R9,[RSI + 0x3]
AND R9,-0x4
LAB_0013d3f0:
MOV RDX,RDI
MOV R11B,byte ptr [RDI + -0x1]
CMP RDI,R10
JBE 0x0013d48c
LEA RDI,[RDX + -0x1]
CMP R11B,0x20
JZ 0x0013d3f0
JMP 0x0013d40f
LAB_0013d40c:
MOV RDX,RDI
LAB_0013d40f:
MOV RDI,RDX
CMP RDX,RSI
JBE 0x0013d421
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
JZ 0x0013d40f
LAB_0013d421:
MOV R9B,byte ptr [RAX + 0x20]
MOV R11,RDI
SUB R11,RSI
LAB_0013d42b:
MOV RDX,RDI
MOV R10,R11
CMP RDI,RSI
JBE 0x0013d448
LEA RDI,[RDX + -0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
LEA R11,[R10 + -0x1]
CMP byte ptr [RAX + RBX*0x1],R9B
JZ 0x0013d42b
LAB_0013d448:
MOV RDI,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST R10,R10
JLE 0x0013d483
LAB_0013d453:
MOV R10D,EDI
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RAX + R11*0x1]
IMUL R11,R10
MOV R10,RDI
SHL R10,0x8
ADD R10,R11
XOR RDI,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0013d453
LAB_0013d483:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],R9
POP RBX
POP RBP
RET
LAB_0013d48c:
CMP R11B,0x20
SETNZ DIL
CMP R9,R10
SETNC R10B
OR R10B,DIL
JNZ 0x0013d40f
MOV RDI,RDX
LAB_0013d4a7:
MOV RDX,RDI
CMP RDI,R9
JBE 0x0013d40f
LEA RDI,[RDX + -0x4]
CMP dword ptr [RDX + -0x4],0x20202020
JZ 0x0013d4a7
JMP 0x0013d40f
|
void my_hash_sort_simple(long param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
byte *pbVar3;
ulong uVar4;
byte *pbVar5;
long lVar6;
byte *pbVar7;
long lVar8;
lVar2 = *(long *)(param_1 + 0x58);
pbVar5 = param_2 + param_3;
if (param_3 < 0x11) goto LAB_0013d421;
pbVar3 = pbVar5;
if ((0x14 < param_3) && (pbVar7 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar7))
{
do {
pbVar1 = pbVar5 + -1;
pbVar3 = pbVar5;
if (pbVar5 <= pbVar7) {
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar7 && *pbVar1 == 0x20)
goto LAB_0013d4a7;
break;
}
pbVar5 = pbVar5 + -1;
} while (*pbVar1 == 0x20);
}
goto LAB_0013d40f;
while (pbVar7 = pbVar5 + -4, pbVar5 = pbVar5 + -4, *(int *)pbVar7 == 0x20202020) {
LAB_0013d4a7:
pbVar3 = pbVar5;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_0013d40f:
do {
pbVar5 = pbVar3;
if (pbVar5 <= param_2) break;
pbVar3 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
LAB_0013d421:
lVar6 = (long)pbVar5 - (long)param_2;
do {
lVar8 = lVar6;
pbVar3 = pbVar5;
if (pbVar3 <= param_2) break;
pbVar5 = pbVar3 + -1;
lVar6 = lVar8 + -1;
} while (*(char *)(lVar2 + (ulong)pbVar3[-1]) == *(char *)(lVar2 + 0x20));
uVar4 = *param_4;
lVar6 = *param_5;
if (0 < lVar8) {
do {
uVar4 = uVar4 ^ uVar4 * 0x100 +
(ulong)*(byte *)(lVar2 + (ulong)*param_2) *
((ulong)((uint)uVar4 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar3);
}
*param_4 = uVar4;
*param_5 = lVar6;
return;
}
|
|
17,761
|
safe_lexcstrdup_root
|
eloqsql/mysys/my_alloc.c
|
LEX_CSTRING safe_lexcstrdup_root(MEM_ROOT *root, const LEX_CSTRING str)
{
LEX_CSTRING res;
if (str.length)
res.str= strmake_root(root, str.str, str.length);
else
res.str= (const char *)"";
res.length= str.length;
return res;
}
|
O0
|
c
|
safe_lexcstrdup_root:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x82052
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x81f70
movq %rax, -0x10(%rbp)
jmp 0x8205d
leaq 0x67aa7(%rip), %rax # 0xe9b00
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
safe_lexcstrdup_root:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_28], rdi
cmp [rbp+var_18], 0
jz short loc_82052
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call strmake_root
mov [rbp+var_10], rax
jmp short loc_8205D
loc_82052:
lea rax, asc_E9AFC+4; ""
mov [rbp+var_10], rax
loc_8205D:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
char * safe_lexcstrdup_root(_QWORD **a1, long long a2, long long a3)
{
if ( a3 )
return strmake_root(a1, a2, a3);
else
return "";
}
|
safe_lexcstrdup_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x28],RDI
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00182052
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00181f70
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0018205d
LAB_00182052:
LEA RAX,[0x1e9b00]
MOV qword ptr [RBP + -0x10],RAX
LAB_0018205d:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] safe_lexcstrdup_root(int8 param_1,int8 param_2,long param_3)
{
int1 auVar1 [16];
int *local_18;
if (param_3 == 0) {
local_18 = &DAT_001e9b00;
}
else {
local_18 = (int *)strmake_root(param_1,param_2,param_3);
}
auVar1._8_8_ = param_3;
auVar1._0_8_ = local_18;
return auVar1;
}
|
|
17,762
|
ggml_graph_reset
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
void ggml_graph_reset(struct ggml_cgraph * cgraph) {
GGML_ASSERT(cgraph->grads != NULL);
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
struct ggml_tensor * grad_acc = ggml_graph_get_grad_acc(cgraph, node);
if (node->op == GGML_OP_OPT_STEP_ADAMW) {
// clear momenta
ggml_set_zero(node->src[2]);
ggml_set_zero(node->src[3]);
}
// initial gradients of loss should be 1, 0 otherwise
if (grad_acc) {
if (node->flags & GGML_TENSOR_FLAG_LOSS) {
GGML_ASSERT(grad_acc->type == GGML_TYPE_F32);
GGML_ASSERT(ggml_is_scalar(grad_acc));
const float onef = 1.0f;
if (grad_acc->buffer) {
ggml_backend_tensor_set(grad_acc, &onef, 0, sizeof(float));
} else {
GGML_ASSERT(grad_acc->data);
*((float *) grad_acc->data) = onef;
}
} else {
ggml_set_zero(grad_acc);
}
}
}
}
|
O1
|
c
|
ggml_graph_reset:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x18(%rdi)
je 0x23b83
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x23b1c
xorl %r13d, %r13d
leaq 0xc(%rsp), %r14
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x18140
movq %rax, %r15
cmpl $0x52, 0x50(%r12)
jne 0x23a97
movq 0xa8(%r12), %rdi
callq 0x17f60
movq 0xb0(%r12), %rdi
callq 0x17f60
testq %r15, %r15
je 0x23b0c
testb $0x8, 0x94(%r12)
jne 0x23ab1
movq %r15, %rdi
callq 0x17f60
jmp 0x23b0c
cmpl $0x0, (%r15)
jne 0x23b4b
cmpq $0x1, 0x10(%r15)
jne 0x23b2a
cmpq $0x1, 0x18(%r15)
jne 0x23b2a
cmpq $0x1, 0x20(%r15)
jne 0x23b2a
cmpq $0x1, 0x28(%r15)
jne 0x23b2a
movl $0x3f800000, 0xc(%rsp) # imm = 0x3F800000
cmpq $0x0, 0x8(%r15)
je 0x23afa
movl $0x4, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x178e0
jmp 0x23b0c
movq 0xf8(%r15), %rax
testq %rax, %rax
je 0x23b67
movl $0x3f800000, (%rax) # imm = 0x3F800000
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x23a5f
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x28a3e(%rip), %rdi # 0x4c56f
leaq 0x28a89(%rip), %rdx # 0x4c5c1
leaq 0x29c8d(%rip), %rcx # 0x4d7cc
movl $0x1792, %esi # imm = 0x1792
xorl %eax, %eax
callq 0x18ce0
leaq 0x28a1d(%rip), %rdi # 0x4c56f
leaq 0x28a68(%rip), %rdx # 0x4c5c1
leaq 0x29c4c(%rip), %rcx # 0x4d7ac
movl $0x1791, %esi # imm = 0x1791
jmp 0x23b44
leaq 0x28a01(%rip), %rdi # 0x4c56f
leaq 0x28a4c(%rip), %rdx # 0x4c5c1
leaq 0x29c69(%rip), %rcx # 0x4d7e5
movl $0x1798, %esi # imm = 0x1798
jmp 0x23b44
leaq 0x289e5(%rip), %rdi # 0x4c56f
leaq 0x28a30(%rip), %rdx # 0x4c5c1
leaq 0x29bfe(%rip), %rcx # 0x4d796
movl $0x1782, %esi # imm = 0x1782
jmp 0x23b44
|
ggml_graph_reset:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
cmp qword ptr [rdi+18h], 0
jz loc_23B83
mov rbx, rdi
cmp dword ptr [rdi+4], 0
jle loc_23B1C
xor r13d, r13d
lea r14, [rsp+38h+var_2C]
loc_23A5F:
mov rax, [rbx+10h]
mov r12, [rax+r13*8]
mov rdi, rbx
mov rsi, r12
call _ggml_graph_get_grad_acc
mov r15, rax
cmp dword ptr [r12+50h], 52h ; 'R'
jnz short loc_23A97
mov rdi, [r12+0A8h]
call _ggml_set_zero
mov rdi, [r12+0B0h]
call _ggml_set_zero
loc_23A97:
test r15, r15
jz short loc_23B0C
test byte ptr [r12+94h], 8
jnz short loc_23AB1
mov rdi, r15
call _ggml_set_zero
jmp short loc_23B0C
loc_23AB1:
cmp dword ptr [r15], 0
jnz loc_23B4B
cmp qword ptr [r15+10h], 1
jnz short loc_23B2A
cmp qword ptr [r15+18h], 1
jnz short loc_23B2A
cmp qword ptr [r15+20h], 1
jnz short loc_23B2A
cmp qword ptr [r15+28h], 1
jnz short loc_23B2A
mov [rsp+38h+var_2C], 3F800000h
cmp qword ptr [r15+8], 0
jz short loc_23AFA
mov ecx, 4
mov rdi, r15
mov rsi, r14
xor edx, edx
call _ggml_backend_tensor_set
jmp short loc_23B0C
loc_23AFA:
mov rax, [r15+0F8h]
test rax, rax
jz short loc_23B67
mov dword ptr [rax], 3F800000h
loc_23B0C:
inc r13
movsxd rax, dword ptr [rbx+4]
cmp r13, rax
jl loc_23A5F
loc_23B1C:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_23B2A:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsScalarGr; "ggml_is_scalar(grad_acc)"
mov esi, 1792h
loc_23B44:
xor eax, eax
call _ggml_abort
loc_23B4B:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccTypeGgm; "grad_acc->type == GGML_TYPE_F32"
mov esi, 1791h
jmp short loc_23B44
loc_23B67:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccData; "grad_acc->data"
mov esi, 1798h
jmp short loc_23B44
loc_23B83:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCgraphGradsNul; "cgraph->grads != NULL"
mov esi, 1782h
jmp short loc_23B44
|
void ggml_graph_reset(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long i; // r13
long long v7; // r12
long long v8; // rdx
long long v9; // rcx
long long grad_acc; // r15
long long v11; // rdx
long long v12; // rcx
int v13; // r8d
int v14; // r9d
_DWORD *v15; // rax
const char *v16; // rcx
int v17; // esi
int v18[11]; // [rsp+Ch] [rbp-2Ch] BYREF
if ( !*(_QWORD *)(a1 + 24) )
{
v16 = "cgraph->grads != NULL";
v17 = 6018;
LABEL_21:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
v17,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v16,
a5,
a6);
}
if ( *(int *)(a1 + 4) > 0 )
{
for ( i = 0LL; i < *(int *)(a1 + 4); ++i )
{
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * i);
grad_acc = ggml_graph_get_grad_acc(a1, v7);
if ( *(_DWORD *)(v7 + 80) == 82 )
{
ggml_set_zero(*(_QWORD *)(v7 + 168), v7, v8, v9, a5, a6);
ggml_set_zero(*(_QWORD *)(v7 + 176), v7, v11, v12, v13, v14);
}
if ( grad_acc )
{
if ( (*(_BYTE *)(v7 + 148) & 8) != 0 )
{
if ( *(_DWORD *)grad_acc )
{
v16 = "grad_acc->type == GGML_TYPE_F32";
v17 = 6033;
goto LABEL_21;
}
if ( *(_QWORD *)(grad_acc + 16) != 1LL
|| *(_QWORD *)(grad_acc + 24) != 1LL
|| *(_QWORD *)(grad_acc + 32) != 1LL
|| *(_QWORD *)(grad_acc + 40) != 1LL )
{
v16 = "ggml_is_scalar(grad_acc)";
v17 = 6034;
goto LABEL_21;
}
v18[0] = 1065353216;
if ( *(_QWORD *)(grad_acc + 8) )
{
ggml_backend_tensor_set(grad_acc, v18, 0LL, 4LL);
}
else
{
v15 = *(_DWORD **)(grad_acc + 248);
if ( !v15 )
{
v16 = "grad_acc->data";
v17 = 6040;
goto LABEL_21;
}
*v15 = 1065353216;
}
}
else
{
ggml_set_zero(grad_acc, v7, v8, v9, a5, a6);
}
}
}
}
}
|
ggml_graph_reset:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
CMP qword ptr [RDI + 0x18],0x0
JZ 0x00123b83
MOV RBX,RDI
CMP dword ptr [RDI + 0x4],0x0
JLE 0x00123b1c
XOR R13D,R13D
LEA R14,[RSP + 0xc]
LAB_00123a5f:
MOV RAX,qword ptr [RBX + 0x10]
MOV R12,qword ptr [RAX + R13*0x8]
MOV RDI,RBX
MOV RSI,R12
CALL 0x00118140
MOV R15,RAX
CMP dword ptr [R12 + 0x50],0x52
JNZ 0x00123a97
MOV RDI,qword ptr [R12 + 0xa8]
CALL 0x00117f60
MOV RDI,qword ptr [R12 + 0xb0]
CALL 0x00117f60
LAB_00123a97:
TEST R15,R15
JZ 0x00123b0c
TEST byte ptr [R12 + 0x94],0x8
JNZ 0x00123ab1
MOV RDI,R15
CALL 0x00117f60
JMP 0x00123b0c
LAB_00123ab1:
CMP dword ptr [R15],0x0
JNZ 0x00123b4b
CMP qword ptr [R15 + 0x10],0x1
JNZ 0x00123b2a
CMP qword ptr [R15 + 0x18],0x1
JNZ 0x00123b2a
CMP qword ptr [R15 + 0x20],0x1
JNZ 0x00123b2a
CMP qword ptr [R15 + 0x28],0x1
JNZ 0x00123b2a
MOV dword ptr [RSP + 0xc],0x3f800000
CMP qword ptr [R15 + 0x8],0x0
JZ 0x00123afa
MOV ECX,0x4
MOV RDI,R15
MOV RSI,R14
XOR EDX,EDX
CALL 0x001178e0
JMP 0x00123b0c
LAB_00123afa:
MOV RAX,qword ptr [R15 + 0xf8]
TEST RAX,RAX
JZ 0x00123b67
MOV dword ptr [RAX],0x3f800000
LAB_00123b0c:
INC R13
MOVSXD RAX,dword ptr [RBX + 0x4]
CMP R13,RAX
JL 0x00123a5f
LAB_00123b1c:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00123b2a:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14d7cc]
MOV ESI,0x1792
LAB_00123b44:
XOR EAX,EAX
CALL 0x00118ce0
LAB_00123b4b:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14d7ac]
MOV ESI,0x1791
JMP 0x00123b44
LAB_00123b67:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14d7e5]
MOV ESI,0x1798
JMP 0x00123b44
LAB_00123b83:
LEA RDI,[0x14c56f]
LEA RDX,[0x14c5c1]
LEA RCX,[0x14d796]
MOV ESI,0x1782
JMP 0x00123b44
|
void ggml_graph_reset(long param_1)
{
long lVar1;
int *piVar2;
char *pcVar3;
int8 uVar4;
long lVar5;
int4 local_2c;
if (*(long *)(param_1 + 0x18) == 0) {
pcVar3 = "cgraph->grads != NULL";
uVar4 = 0x1782;
LAB_00123b44:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
uVar4,"GGML_ASSERT(%s) failed",pcVar3);
}
if (0 < *(int *)(param_1 + 4)) {
lVar5 = 0;
do {
lVar1 = *(long *)(*(long *)(param_1 + 0x10) + lVar5 * 8);
piVar2 = (int *)ggml_graph_get_grad_acc(param_1,lVar1);
if (*(int *)(lVar1 + 0x50) == 0x52) {
ggml_set_zero(*(int8 *)(lVar1 + 0xa8));
ggml_set_zero(*(int8 *)(lVar1 + 0xb0));
}
if (piVar2 != (int *)0x0) {
if ((*(byte *)(lVar1 + 0x94) & 8) == 0) {
ggml_set_zero(piVar2);
}
else {
if (*piVar2 != 0) {
pcVar3 = "grad_acc->type == GGML_TYPE_F32";
uVar4 = 0x1791;
goto LAB_00123b44;
}
if ((((*(long *)(piVar2 + 4) != 1) || (*(long *)(piVar2 + 6) != 1)) ||
(*(long *)(piVar2 + 8) != 1)) || (*(long *)(piVar2 + 10) != 1)) {
pcVar3 = "ggml_is_scalar(grad_acc)";
uVar4 = 0x1792;
goto LAB_00123b44;
}
local_2c = 0x3f800000;
if (*(long *)(piVar2 + 2) == 0) {
if (*(int4 **)(piVar2 + 0x3e) == (int4 *)0x0) {
pcVar3 = "grad_acc->data";
uVar4 = 0x1798;
goto LAB_00123b44;
}
**(int4 **)(piVar2 + 0x3e) = 0x3f800000;
}
else {
ggml_backend_tensor_set(piVar2,&local_2c,0,4);
}
}
}
lVar5 = lVar5 + 1;
} while (lVar5 < *(int *)(param_1 + 4));
}
return;
}
|
|
17,763
|
ggml_graph_reset
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
void ggml_graph_reset(struct ggml_cgraph * cgraph) {
GGML_ASSERT(cgraph->grads != NULL);
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
struct ggml_tensor * grad_acc = ggml_graph_get_grad_acc(cgraph, node);
if (node->op == GGML_OP_OPT_STEP_ADAMW) {
// clear momenta
ggml_set_zero(node->src[2]);
ggml_set_zero(node->src[3]);
}
// initial gradients of loss should be 1, 0 otherwise
if (grad_acc) {
if (node->flags & GGML_TENSOR_FLAG_LOSS) {
GGML_ASSERT(grad_acc->type == GGML_TYPE_F32);
GGML_ASSERT(ggml_is_scalar(grad_acc));
const float onef = 1.0f;
if (grad_acc->buffer) {
ggml_backend_tensor_set(grad_acc, &onef, 0, sizeof(float));
} else {
GGML_ASSERT(grad_acc->data);
*((float *) grad_acc->data) = onef;
}
} else {
ggml_set_zero(grad_acc);
}
}
}
}
|
O2
|
c
|
ggml_graph_reset:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x18(%rdi)
je 0x285f1
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x4(%rsp), %r14
pushq $0x4
popq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %rbp
jge 0x2858e
movq 0x10(%rbx), %rax
movq (%rax,%rbp,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1e8b0
movq %rax, %r12
cmpl $0x52, 0x50(%r13)
jne 0x28525
movq 0xa8(%r13), %rdi
callq 0x1e610
movq 0xb0(%r13), %rdi
callq 0x1e610
testq %r12, %r12
je 0x28586
testb $0x8, 0x94(%r13)
jne 0x2853e
movq %r12, %rdi
callq 0x1e610
jmp 0x28586
cmpl $0x0, (%r12)
jne 0x285b9
movq %r12, %rdi
callq 0x1fa00
testb %al, %al
je 0x2859d
movl $0x3f800000, 0x4(%rsp) # imm = 0x3F800000
cmpq $0x0, 0x8(%r12)
je 0x28573
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x1dcb0
jmp 0x28586
movq 0xf8(%r12), %rax
testq %rax, %rax
je 0x285d5
movl $0x3f800000, (%rax) # imm = 0x3F800000
incq %rbp
jmp 0x284e3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25fdf(%rip), %rdi # 0x4e583
leaq 0x2602a(%rip), %rdx # 0x4e5d5
leaq 0x2722e(%rip), %rcx # 0x4f7e0
movl $0x1792, %esi # imm = 0x1792
jmp 0x2860b
leaq 0x25fc3(%rip), %rdi # 0x4e583
leaq 0x2600e(%rip), %rdx # 0x4e5d5
leaq 0x271f2(%rip), %rcx # 0x4f7c0
movl $0x1791, %esi # imm = 0x1791
jmp 0x2860b
leaq 0x25fa7(%rip), %rdi # 0x4e583
leaq 0x25ff2(%rip), %rdx # 0x4e5d5
leaq 0x2720f(%rip), %rcx # 0x4f7f9
movl $0x1798, %esi # imm = 0x1798
jmp 0x2860b
leaq 0x25f8b(%rip), %rdi # 0x4e583
leaq 0x25fd6(%rip), %rdx # 0x4e5d5
leaq 0x271a4(%rip), %rcx # 0x4f7aa
movl $0x1782, %esi # imm = 0x1782
xorl %eax, %eax
callq 0x1f9b0
|
ggml_graph_reset:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp qword ptr [rdi+18h], 0
jz loc_285F1
mov rbx, rdi
xor ebp, ebp
lea r14, [rsp+38h+var_34]
push 4
pop r15
loc_284E3:
movsxd rax, dword ptr [rbx+4]
cmp rbp, rax
jge loc_2858E
mov rax, [rbx+10h]
mov r13, [rax+rbp*8]
mov rdi, rbx
mov rsi, r13
call _ggml_graph_get_grad_acc
mov r12, rax
cmp dword ptr [r13+50h], 52h ; 'R'
jnz short loc_28525
mov rdi, [r13+0A8h]
call _ggml_set_zero
mov rdi, [r13+0B0h]
call _ggml_set_zero
loc_28525:
test r12, r12
jz short loc_28586
test byte ptr [r13+94h], 8
jnz short loc_2853E
mov rdi, r12
call _ggml_set_zero
jmp short loc_28586
loc_2853E:
cmp dword ptr [r12], 0
jnz short loc_285B9
mov rdi, r12
call _ggml_is_scalar
test al, al
jz short loc_2859D
mov [rsp+38h+var_34], 3F800000h
cmp qword ptr [r12+8], 0
jz short loc_28573
mov rdi, r12
mov rsi, r14
xor edx, edx
mov rcx, r15
call _ggml_backend_tensor_set
jmp short loc_28586
loc_28573:
mov rax, [r12+0F8h]
test rax, rax
jz short loc_285D5
mov dword ptr [rax], 3F800000h
loc_28586:
inc rbp
jmp loc_284E3
loc_2858E:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2859D:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsScalarGr; "ggml_is_scalar(grad_acc)"
mov esi, 1792h
jmp short loc_2860B
loc_285B9:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccTypeGgm; "grad_acc->type == GGML_TYPE_F32"
mov esi, 1791h
jmp short loc_2860B
loc_285D5:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccData; "grad_acc->data"
mov esi, 1798h
jmp short loc_2860B
loc_285F1:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCgraphGradsNul; "cgraph->grads != NULL"
mov esi, 1782h
loc_2860B:
xor eax, eax
call _ggml_abort
|
long long ggml_graph_reset(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
long long v14; // rax
long long i; // rbp
long long result; // rax
long long v17; // r13
_QWORD *grad_acc; // r12
double v19; // xmm4_8
double v20; // xmm5_8
_DWORD *v21; // rax
const char *v22; // rcx
int v23; // esi
long long v24; // [rsp-4h] [rbp-38h] BYREF
v24 = v14;
if ( !*(_QWORD *)(a1 + 24) )
{
v22 = "cgraph->grads != NULL";
v23 = 6018;
LABEL_21:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
v23,
(long long)"GGML_ASSERT(%s) failed",
(long long)v22,
a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v24);
}
for ( i = 0LL; ; ++i )
{
result = *(int *)(a1 + 4);
if ( i >= result )
break;
v17 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * i);
grad_acc = (_QWORD *)ggml_graph_get_grad_acc(a1, v17);
if ( *(_DWORD *)(v17 + 80) == 82 )
{
ggml_set_zero(*(_QWORD *)(v17 + 168), a2, a3, a4, a5, *(double *)a6.m128_u64, *(double *)a7.m128_u64, a8, a9);
ggml_set_zero(*(_QWORD *)(v17 + 176), a2, a3, a4, a5, v19, v20, a8, a9);
}
if ( grad_acc )
{
if ( (*(_BYTE *)(v17 + 148) & 8) != 0 )
{
if ( *(_DWORD *)grad_acc )
{
v22 = "grad_acc->type == GGML_TYPE_F32";
v23 = 6033;
goto LABEL_21;
}
if ( !ggml_is_scalar(grad_acc) )
{
v22 = "ggml_is_scalar(grad_acc)";
v23 = 6034;
goto LABEL_21;
}
HIDWORD(v24) = 1065353216;
if ( grad_acc[1] )
{
ggml_backend_tensor_set(grad_acc, (char *)&v24 + 4, 0LL, 4LL);
}
else
{
v21 = (_DWORD *)grad_acc[31];
if ( !v21 )
{
v22 = "grad_acc->data";
v23 = 6040;
goto LABEL_21;
}
*v21 = 1065353216;
}
}
else
{
ggml_set_zero((long long)grad_acc, a2, a3, a4, a5, *(double *)a6.m128_u64, *(double *)a7.m128_u64, a8, a9);
}
}
}
return result;
}
|
ggml_graph_reset:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP qword ptr [RDI + 0x18],0x0
JZ 0x001285f1
MOV RBX,RDI
XOR EBP,EBP
LEA R14,[RSP + 0x4]
PUSH 0x4
POP R15
LAB_001284e3:
MOVSXD RAX,dword ptr [RBX + 0x4]
CMP RBP,RAX
JGE 0x0012858e
MOV RAX,qword ptr [RBX + 0x10]
MOV R13,qword ptr [RAX + RBP*0x8]
MOV RDI,RBX
MOV RSI,R13
CALL 0x0011e8b0
MOV R12,RAX
CMP dword ptr [R13 + 0x50],0x52
JNZ 0x00128525
MOV RDI,qword ptr [R13 + 0xa8]
CALL 0x0011e610
MOV RDI,qword ptr [R13 + 0xb0]
CALL 0x0011e610
LAB_00128525:
TEST R12,R12
JZ 0x00128586
TEST byte ptr [R13 + 0x94],0x8
JNZ 0x0012853e
MOV RDI,R12
CALL 0x0011e610
JMP 0x00128586
LAB_0012853e:
CMP dword ptr [R12],0x0
JNZ 0x001285b9
MOV RDI,R12
CALL 0x0011fa00
TEST AL,AL
JZ 0x0012859d
MOV dword ptr [RSP + 0x4],0x3f800000
CMP qword ptr [R12 + 0x8],0x0
JZ 0x00128573
MOV RDI,R12
MOV RSI,R14
XOR EDX,EDX
MOV RCX,R15
CALL 0x0011dcb0
JMP 0x00128586
LAB_00128573:
MOV RAX,qword ptr [R12 + 0xf8]
TEST RAX,RAX
JZ 0x001285d5
MOV dword ptr [RAX],0x3f800000
LAB_00128586:
INC RBP
JMP 0x001284e3
LAB_0012858e:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012859d:
LEA RDI,[0x14e583]
LEA RDX,[0x14e5d5]
LEA RCX,[0x14f7e0]
MOV ESI,0x1792
JMP 0x0012860b
LAB_001285b9:
LEA RDI,[0x14e583]
LEA RDX,[0x14e5d5]
LEA RCX,[0x14f7c0]
MOV ESI,0x1791
JMP 0x0012860b
LAB_001285d5:
LEA RDI,[0x14e583]
LEA RDX,[0x14e5d5]
LEA RCX,[0x14f7f9]
MOV ESI,0x1798
JMP 0x0012860b
LAB_001285f1:
LEA RDI,[0x14e583]
LEA RDX,[0x14e5d5]
LEA RCX,[0x14f7aa]
MOV ESI,0x1782
LAB_0012860b:
XOR EAX,EAX
CALL 0x0011f9b0
|
void ggml_graph_reset(long param_1)
{
long lVar1;
char cVar2;
int8 in_RAX;
int *piVar3;
char *pcVar4;
long lVar5;
int8 uVar6;
int8 uStack_38;
uStack_38 = in_RAX;
if (*(long *)(param_1 + 0x18) == 0) {
pcVar4 = "cgraph->grads != NULL";
uVar6 = 0x1782;
LAB_0012860b:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
lVar5 = 0;
do {
if (*(int *)(param_1 + 4) <= lVar5) {
return;
}
lVar1 = *(long *)(*(long *)(param_1 + 0x10) + lVar5 * 8);
piVar3 = (int *)ggml_graph_get_grad_acc(param_1,lVar1);
if (*(int *)(lVar1 + 0x50) == 0x52) {
ggml_set_zero(*(int8 *)(lVar1 + 0xa8));
ggml_set_zero(*(int8 *)(lVar1 + 0xb0));
}
if (piVar3 != (int *)0x0) {
if ((*(byte *)(lVar1 + 0x94) & 8) == 0) {
ggml_set_zero(piVar3);
}
else {
if (*piVar3 != 0) {
pcVar4 = "grad_acc->type == GGML_TYPE_F32";
uVar6 = 0x1791;
goto LAB_0012860b;
}
cVar2 = ggml_is_scalar(piVar3);
if (cVar2 == '\0') {
pcVar4 = "ggml_is_scalar(grad_acc)";
uVar6 = 0x1792;
goto LAB_0012860b;
}
uStack_38 = CONCAT44(0x3f800000,(int4)uStack_38);
if (*(long *)(piVar3 + 2) == 0) {
if (*(int4 **)(piVar3 + 0x3e) == (int4 *)0x0) {
pcVar4 = "grad_acc->data";
uVar6 = 0x1798;
goto LAB_0012860b;
}
**(int4 **)(piVar3 + 0x3e) = 0x3f800000;
}
else {
ggml_backend_tensor_set(piVar3,(long)&uStack_38 + 4,0,4);
}
}
}
lVar5 = lVar5 + 1;
} while( true );
}
|
|
17,764
|
ggml_graph_reset
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
void ggml_graph_reset(struct ggml_cgraph * cgraph) {
GGML_ASSERT(cgraph->grads != NULL);
for (int i = 0; i < cgraph->n_nodes; i++) {
struct ggml_tensor * node = cgraph->nodes[i];
struct ggml_tensor * grad_acc = ggml_graph_get_grad_acc(cgraph, node);
if (node->op == GGML_OP_OPT_STEP_ADAMW) {
// clear momenta
ggml_set_zero(node->src[2]);
ggml_set_zero(node->src[3]);
}
// initial gradients of loss should be 1, 0 otherwise
if (grad_acc) {
if (node->flags & GGML_TENSOR_FLAG_LOSS) {
GGML_ASSERT(grad_acc->type == GGML_TYPE_F32);
GGML_ASSERT(ggml_is_scalar(grad_acc));
const float onef = 1.0f;
if (grad_acc->buffer) {
ggml_backend_tensor_set(grad_acc, &onef, 0, sizeof(float));
} else {
GGML_ASSERT(grad_acc->data);
*((float *) grad_acc->data) = onef;
}
} else {
ggml_set_zero(grad_acc);
}
}
}
}
|
O3
|
c
|
ggml_graph_reset:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x18(%rdi)
je 0x2288c
movq %rdi, %rbx
cmpl $0x0, 0x4(%rdi)
jle 0x22825
xorl %r13d, %r13d
leaq 0xc(%rsp), %r14
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x17130
movq %rax, %r15
cmpl $0x52, 0x50(%r12)
jne 0x227a0
movq 0xa8(%r12), %rdi
callq 0x16f50
movq 0xb0(%r12), %rdi
callq 0x16f50
testq %r15, %r15
je 0x22815
testb $0x8, 0x94(%r12)
jne 0x227ba
movq %r15, %rdi
callq 0x16f50
jmp 0x22815
cmpl $0x0, (%r15)
jne 0x22854
cmpq $0x1, 0x10(%r15)
jne 0x22833
cmpq $0x1, 0x18(%r15)
jne 0x22833
cmpq $0x1, 0x20(%r15)
jne 0x22833
cmpq $0x1, 0x28(%r15)
jne 0x22833
movl $0x3f800000, 0xc(%rsp) # imm = 0x3F800000
cmpq $0x0, 0x8(%r15)
je 0x22803
movl $0x4, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x168e0
jmp 0x22815
movq 0xf8(%r15), %rax
testq %rax, %rax
je 0x22870
movl $0x3f800000, (%rax) # imm = 0x3F800000
incq %r13
movslq 0x4(%rbx), %rax
cmpq %rax, %r13
jl 0x22768
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x29dd9(%rip), %rdi # 0x4c613
leaq 0x29e24(%rip), %rdx # 0x4c665
leaq 0x2b028(%rip), %rcx # 0x4d870
movl $0x1792, %esi # imm = 0x1792
xorl %eax, %eax
callq 0x17cd0
leaq 0x29db8(%rip), %rdi # 0x4c613
leaq 0x29e03(%rip), %rdx # 0x4c665
leaq 0x2afe7(%rip), %rcx # 0x4d850
movl $0x1791, %esi # imm = 0x1791
jmp 0x2284d
leaq 0x29d9c(%rip), %rdi # 0x4c613
leaq 0x29de7(%rip), %rdx # 0x4c665
leaq 0x2b004(%rip), %rcx # 0x4d889
movl $0x1798, %esi # imm = 0x1798
jmp 0x2284d
leaq 0x29d80(%rip), %rdi # 0x4c613
leaq 0x29dcb(%rip), %rdx # 0x4c665
leaq 0x2af99(%rip), %rcx # 0x4d83a
movl $0x1782, %esi # imm = 0x1782
jmp 0x2284d
|
ggml_graph_reset:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
cmp qword ptr [rdi+18h], 0
jz loc_2288C
mov rbx, rdi
cmp dword ptr [rdi+4], 0
jle loc_22825
xor r13d, r13d
lea r14, [rsp+38h+var_2C]
loc_22768:
mov rax, [rbx+10h]
mov r12, [rax+r13*8]
mov rdi, rbx
mov rsi, r12
call _ggml_graph_get_grad_acc
mov r15, rax
cmp dword ptr [r12+50h], 52h ; 'R'
jnz short loc_227A0
mov rdi, [r12+0A8h]
call _ggml_set_zero
mov rdi, [r12+0B0h]
call _ggml_set_zero
loc_227A0:
test r15, r15
jz short loc_22815
test byte ptr [r12+94h], 8
jnz short loc_227BA
mov rdi, r15
call _ggml_set_zero
jmp short loc_22815
loc_227BA:
cmp dword ptr [r15], 0
jnz loc_22854
cmp qword ptr [r15+10h], 1
jnz short loc_22833
cmp qword ptr [r15+18h], 1
jnz short loc_22833
cmp qword ptr [r15+20h], 1
jnz short loc_22833
cmp qword ptr [r15+28h], 1
jnz short loc_22833
mov [rsp+38h+var_2C], 3F800000h
cmp qword ptr [r15+8], 0
jz short loc_22803
mov ecx, 4
mov rdi, r15
mov rsi, r14
xor edx, edx
call _ggml_backend_tensor_set
jmp short loc_22815
loc_22803:
mov rax, [r15+0F8h]
test rax, rax
jz short loc_22870
mov dword ptr [rax], 3F800000h
loc_22815:
inc r13
movsxd rax, dword ptr [rbx+4]
cmp r13, rax
jl loc_22768
loc_22825:
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_22833:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsScalarGr; "ggml_is_scalar(grad_acc)"
mov esi, 1792h
loc_2284D:
xor eax, eax
call _ggml_abort
loc_22854:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccTypeGgm; "grad_acc->type == GGML_TYPE_F32"
mov esi, 1791h
jmp short loc_2284D
loc_22870:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGradAccData; "grad_acc->data"
mov esi, 1798h
jmp short loc_2284D
loc_2288C:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCgraphGradsNul; "cgraph->grads != NULL"
mov esi, 1782h
jmp short loc_2284D
|
void ggml_graph_reset(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long i; // r13
long long v7; // r12
long long v8; // rdx
long long v9; // rcx
long long grad_acc; // r15
long long v11; // rdx
long long v12; // rcx
int v13; // r8d
int v14; // r9d
_DWORD *v15; // rax
const char *v16; // rcx
int v17; // esi
int v18[11]; // [rsp+Ch] [rbp-2Ch] BYREF
if ( !*(_QWORD *)(a1 + 24) )
{
v16 = "cgraph->grads != NULL";
v17 = 6018;
LABEL_21:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
v17,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v16,
a5,
a6);
}
if ( *(int *)(a1 + 4) > 0 )
{
for ( i = 0LL; i < *(int *)(a1 + 4); ++i )
{
v7 = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * i);
grad_acc = ggml_graph_get_grad_acc(a1, v7);
if ( *(_DWORD *)(v7 + 80) == 82 )
{
ggml_set_zero(*(_QWORD *)(v7 + 168), v7, v8, v9, a5, a6);
ggml_set_zero(*(_QWORD *)(v7 + 176), v7, v11, v12, v13, v14);
}
if ( grad_acc )
{
if ( (*(_BYTE *)(v7 + 148) & 8) != 0 )
{
if ( *(_DWORD *)grad_acc )
{
v16 = "grad_acc->type == GGML_TYPE_F32";
v17 = 6033;
goto LABEL_21;
}
if ( *(_QWORD *)(grad_acc + 16) != 1LL
|| *(_QWORD *)(grad_acc + 24) != 1LL
|| *(_QWORD *)(grad_acc + 32) != 1LL
|| *(_QWORD *)(grad_acc + 40) != 1LL )
{
v16 = "ggml_is_scalar(grad_acc)";
v17 = 6034;
goto LABEL_21;
}
v18[0] = 1065353216;
if ( *(_QWORD *)(grad_acc + 8) )
{
ggml_backend_tensor_set(grad_acc, v18, 0LL, 4LL);
}
else
{
v15 = *(_DWORD **)(grad_acc + 248);
if ( !v15 )
{
v16 = "grad_acc->data";
v17 = 6040;
goto LABEL_21;
}
*v15 = 1065353216;
}
}
else
{
ggml_set_zero(grad_acc, v7, v8, v9, a5, a6);
}
}
}
}
}
|
ggml_graph_reset:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
CMP qword ptr [RDI + 0x18],0x0
JZ 0x0012288c
MOV RBX,RDI
CMP dword ptr [RDI + 0x4],0x0
JLE 0x00122825
XOR R13D,R13D
LEA R14,[RSP + 0xc]
LAB_00122768:
MOV RAX,qword ptr [RBX + 0x10]
MOV R12,qword ptr [RAX + R13*0x8]
MOV RDI,RBX
MOV RSI,R12
CALL 0x00117130
MOV R15,RAX
CMP dword ptr [R12 + 0x50],0x52
JNZ 0x001227a0
MOV RDI,qword ptr [R12 + 0xa8]
CALL 0x00116f50
MOV RDI,qword ptr [R12 + 0xb0]
CALL 0x00116f50
LAB_001227a0:
TEST R15,R15
JZ 0x00122815
TEST byte ptr [R12 + 0x94],0x8
JNZ 0x001227ba
MOV RDI,R15
CALL 0x00116f50
JMP 0x00122815
LAB_001227ba:
CMP dword ptr [R15],0x0
JNZ 0x00122854
CMP qword ptr [R15 + 0x10],0x1
JNZ 0x00122833
CMP qword ptr [R15 + 0x18],0x1
JNZ 0x00122833
CMP qword ptr [R15 + 0x20],0x1
JNZ 0x00122833
CMP qword ptr [R15 + 0x28],0x1
JNZ 0x00122833
MOV dword ptr [RSP + 0xc],0x3f800000
CMP qword ptr [R15 + 0x8],0x0
JZ 0x00122803
MOV ECX,0x4
MOV RDI,R15
MOV RSI,R14
XOR EDX,EDX
CALL 0x001168e0
JMP 0x00122815
LAB_00122803:
MOV RAX,qword ptr [R15 + 0xf8]
TEST RAX,RAX
JZ 0x00122870
MOV dword ptr [RAX],0x3f800000
LAB_00122815:
INC R13
MOVSXD RAX,dword ptr [RBX + 0x4]
CMP R13,RAX
JL 0x00122768
LAB_00122825:
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_00122833:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14d870]
MOV ESI,0x1792
LAB_0012284d:
XOR EAX,EAX
CALL 0x00117cd0
LAB_00122854:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14d850]
MOV ESI,0x1791
JMP 0x0012284d
LAB_00122870:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14d889]
MOV ESI,0x1798
JMP 0x0012284d
LAB_0012288c:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14d83a]
MOV ESI,0x1782
JMP 0x0012284d
|
void ggml_graph_reset(long param_1)
{
long lVar1;
int *piVar2;
char *pcVar3;
int8 uVar4;
long lVar5;
int4 local_2c;
if (*(long *)(param_1 + 0x18) == 0) {
pcVar3 = "cgraph->grads != NULL";
uVar4 = 0x1782;
LAB_0012284d:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c",
uVar4,"GGML_ASSERT(%s) failed",pcVar3);
}
if (0 < *(int *)(param_1 + 4)) {
lVar5 = 0;
do {
lVar1 = *(long *)(*(long *)(param_1 + 0x10) + lVar5 * 8);
piVar2 = (int *)ggml_graph_get_grad_acc(param_1,lVar1);
if (*(int *)(lVar1 + 0x50) == 0x52) {
ggml_set_zero(*(int8 *)(lVar1 + 0xa8));
ggml_set_zero(*(int8 *)(lVar1 + 0xb0));
}
if (piVar2 != (int *)0x0) {
if ((*(byte *)(lVar1 + 0x94) & 8) == 0) {
ggml_set_zero(piVar2);
}
else {
if (*piVar2 != 0) {
pcVar3 = "grad_acc->type == GGML_TYPE_F32";
uVar4 = 0x1791;
goto LAB_0012284d;
}
if ((((*(long *)(piVar2 + 4) != 1) || (*(long *)(piVar2 + 6) != 1)) ||
(*(long *)(piVar2 + 8) != 1)) || (*(long *)(piVar2 + 10) != 1)) {
pcVar3 = "ggml_is_scalar(grad_acc)";
uVar4 = 0x1792;
goto LAB_0012284d;
}
local_2c = 0x3f800000;
if (*(long *)(piVar2 + 2) == 0) {
if (*(int4 **)(piVar2 + 0x3e) == (int4 *)0x0) {
pcVar3 = "grad_acc->data";
uVar4 = 0x1798;
goto LAB_0012284d;
}
**(int4 **)(piVar2 + 0x3e) = 0x3f800000;
}
else {
ggml_backend_tensor_set(piVar2,&local_2c,0,4);
}
}
}
lVar5 = lVar5 + 1;
} while (lVar5 < *(int *)(param_1 + 4));
}
return;
}
|
|
17,765
|
testing::internal::PrintOnOneLine(char const*, int)
|
AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc
|
static void PrintOnOneLine(const char* str, int max_length) {
if (str != nullptr) {
for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) {
printf("...");
break;
}
if (*str == '\n') {
printf("\\n");
i += 2;
} else {
printf("%c", *str);
++i;
}
}
}
}
|
O0
|
cpp
|
testing::internal::PrintOnOneLine(char const*, int):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xdbd78
movl $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xdbd76
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jl 0xdbd18
leaq 0x3827b(%rip), %rdi # 0x113f8a
movb $0x0, %al
callq 0x14060
jmp 0xdbd76
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xdbd40
leaq 0x380d6(%rip), %rdi # 0x113e02
movb $0x0, %al
callq 0x14060
movl 0x8(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x8(%rsp)
jmp 0xdbd61
movq 0x10(%rsp), %rax
movsbl (%rax), %esi
leaq 0x38fbd(%rip), %rdi # 0x114d0c
movb $0x0, %al
callq 0x14060
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xdbd63
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0xdbcf1
jmp 0xdbd78
addq $0x18, %rsp
retq
nopl (%rax)
|
_ZN7testing8internalL14PrintOnOneLineEPKci:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_C], esi
cmp [rsp+18h+var_8], 0
jz loc_DBD78
mov [rsp+18h+var_10], 0
loc_DBCF1:
mov rax, [rsp+18h+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_DBD76
mov eax, [rsp+18h+var_10]
cmp eax, [rsp+18h+var_C]
jl short loc_DBD18
lea rdi, aGoogleTestInte+20h; "..."
mov al, 0
call _printf
jmp short loc_DBD76
loc_DBD18:
mov rax, [rsp+18h+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0Ah
jnz short loc_DBD40
lea rdi, aN; "\\n"
mov al, 0
call _printf
mov eax, [rsp+18h+var_10]
add eax, 2
mov [rsp+18h+var_10], eax
jmp short loc_DBD61
loc_DBD40:
mov rax, [rsp+18h+var_8]
movsx esi, byte ptr [rax]
lea rdi, aC; "%c"
mov al, 0
call _printf
mov eax, [rsp+18h+var_10]
add eax, 1
mov [rsp+18h+var_10], eax
loc_DBD61:
jmp short $+2
loc_DBD63:
mov rax, [rsp+18h+var_8]
add rax, 1
mov [rsp+18h+var_8], rax
jmp loc_DBCF1
loc_DBD76:
jmp short $+2
loc_DBD78:
add rsp, 18h
retn
|
long long testing::internal::PrintOnOneLine(testing::internal *this, const char *a2)
{
long long result; // rax
int v3; // [rsp+8h] [rbp-10h]
testing::internal *v4; // [rsp+10h] [rbp-8h]
v4 = this;
if ( this )
{
v3 = 0;
while ( 1 )
{
result = (unsigned int)*(char *)v4;
if ( !*(_BYTE *)v4 )
break;
if ( v3 >= (int)a2 )
return printf("...");
if ( *(_BYTE *)v4 == 10 )
{
printf("\\n");
v3 += 2;
}
else
{
printf("%c", (unsigned int)*(char *)v4);
++v3;
}
v4 = (testing::internal *)((char *)v4 + 1);
}
}
return result;
}
|
PrintOnOneLine:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001dbd78
MOV dword ptr [RSP + 0x8],0x0
LAB_001dbcf1:
MOV RAX,qword ptr [RSP + 0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x001dbd76
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,dword ptr [RSP + 0xc]
JL 0x001dbd18
LEA RDI,[0x213f8a]
MOV AL,0x0
CALL 0x00114060
JMP 0x001dbd76
LAB_001dbd18:
MOV RAX,qword ptr [RSP + 0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xa
JNZ 0x001dbd40
LEA RDI,[0x213e02]
MOV AL,0x0
CALL 0x00114060
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x2
MOV dword ptr [RSP + 0x8],EAX
JMP 0x001dbd61
LAB_001dbd40:
MOV RAX,qword ptr [RSP + 0x10]
MOVSX ESI,byte ptr [RAX]
LEA RDI,[0x214d0c]
MOV AL,0x0
CALL 0x00114060
MOV EAX,dword ptr [RSP + 0x8]
ADD EAX,0x1
MOV dword ptr [RSP + 0x8],EAX
LAB_001dbd61:
JMP 0x001dbd63
LAB_001dbd63:
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,0x1
MOV qword ptr [RSP + 0x10],RAX
JMP 0x001dbcf1
LAB_001dbd76:
JMP 0x001dbd78
LAB_001dbd78:
ADD RSP,0x18
RET
|
/* testing::internal::PrintOnOneLine(char const*, int) */
void testing::internal::PrintOnOneLine(char *param_1,int param_2)
{
int local_10;
char *local_8;
if (param_1 != (char *)0x0) {
local_10 = 0;
for (local_8 = param_1; *local_8 != '\0'; local_8 = local_8 + 1) {
if (param_2 <= local_10) {
printf("...");
return;
}
if (*local_8 == '\n') {
printf("\\n");
local_10 = local_10 + 2;
}
else {
printf("%c",(ulong)(uint)(int)*local_8);
local_10 = local_10 + 1;
}
}
}
return;
}
|
|
17,766
|
my_instr_simple
|
eloqsql/strings/ctype-simple.c
|
uint my_instr_simple(CHARSET_INFO *cs,
const char *b, size_t b_length,
const char *s, size_t s_length,
my_match_t *match, uint nmatch)
{
register const uchar *str, *search, *end, *search_end;
if (s_length <= b_length)
{
if (!s_length)
{
if (nmatch)
{
match->beg= 0;
match->end= 0;
match->mb_len= 0;
}
return 1; /* Empty string is always found */
}
str= (const uchar*) b;
search= (const uchar*) s;
end= (const uchar*) b+b_length-s_length+1;
search_end= (const uchar*) s + s_length;
skip:
while (str != end)
{
if (cs->sort_order[*str++] == cs->sort_order[*search])
{
register const uchar *i,*j;
i= str;
j= search+1;
while (j != search_end)
if (cs->sort_order[*i++] != cs->sort_order[*j++])
goto skip;
if (nmatch > 0)
{
match[0].beg= 0;
match[0].end= (uint) (str- (const uchar*)b-1);
match[0].mb_len= match[0].end;
if (nmatch > 1)
{
match[1].beg= match[0].end;
match[1].end= (uint)(match[0].end+s_length);
match[1].mb_len= match[1].end-match[1].beg;
}
}
return 2;
}
}
}
return 0;
}
|
O0
|
c
|
my_instr_simple:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
ja 0x447de
cmpq $0x0, -0x30(%rbp)
jne 0x44676
cmpl $0x0, 0x10(%rbp)
je 0x4466a
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x447e5
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
xorl %ecx, %ecx
subq -0x30(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x446ad
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x447dc
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x40(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x40(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x48(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x447d7
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x44759
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x60(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x58(%rcx), %rcx
movq -0x68(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x68(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x44757
jmp 0x446ab
jmp 0x44708
cmpl $0x0, 0x10(%rbp)
jbe 0x447ce
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x8(%rax)
cmpl $0x1, 0x10(%rbp)
jbe 0x447cc
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x38(%rbp), %rax
subl 0xc(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x447ce
movl $0x2, -0x4(%rbp)
jmp 0x447e5
jmp 0x446ad
jmp 0x447de
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_instr_simple:
push rbp
mov rbp, rsp
mov eax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
ja loc_447DE
cmp [rbp+var_30], 0
jnz short loc_44676
cmp [rbp+arg_0], 0
jz short loc_4466A
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+4], 0
mov rax, [rbp+var_38]
mov dword ptr [rax+8], 0
loc_4466A:
mov [rbp+var_4], 1
jmp loc_447E5
loc_44676:
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
xor ecx, ecx
sub rcx, [rbp+var_30]
add rax, rcx
add rax, 1
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_58], rax
loc_446AB:
jmp short $+2
loc_446AD:
mov rax, [rbp+var_40]
cmp rax, [rbp+var_50]
jz loc_447DC
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_40]
mov rdx, rcx
add rdx, 1
mov [rbp+var_40], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_48]
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jnz loc_447D7
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov rax, [rbp+var_48]
add rax, 1
mov [rbp+var_68], rax
loc_44708:
mov rax, [rbp+var_68]
cmp rax, [rbp+var_58]
jz short loc_44759
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov rcx, [rbp+var_60]
mov rdx, rcx
add rdx, 1
mov [rbp+var_60], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_10]
mov rcx, [rcx+58h]
mov rdx, [rbp+var_68]
mov rsi, rdx
add rsi, 1
mov [rbp+var_68], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_44757
jmp loc_446AB
loc_44757:
jmp short loc_44708
loc_44759:
cmp [rbp+arg_0], 0
jbe short loc_447CE
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_40]
mov rcx, [rbp+var_18]
sub rax, rcx
sub rax, 1
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+4], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+8], ecx
cmp [rbp+arg_0], 1
jbe short loc_447CC
mov rax, [rbp+var_38]
mov ecx, [rax+4]
mov rax, [rbp+var_38]
mov [rax+0Ch], ecx
mov rax, [rbp+var_38]
mov eax, [rax+4]
add rax, [rbp+var_30]
mov ecx, eax
mov rax, [rbp+var_38]
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov ecx, [rax+10h]
mov rax, [rbp+var_38]
sub ecx, [rax+0Ch]
mov rax, [rbp+var_38]
mov [rax+14h], ecx
loc_447CC:
jmp short $+2
loc_447CE:
mov [rbp+var_4], 2
jmp short loc_447E5
loc_447D7:
jmp loc_446AD
loc_447DC:
jmp short $+2
loc_447DE:
mov [rbp+var_4], 0
loc_447E5:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_instr_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
_DWORD *a6,
unsigned int a7)
{
unsigned __int8 *v7; // rcx
unsigned __int8 *v8; // rcx
unsigned __int8 *v9; // rdx
unsigned __int8 *v11; // [rsp+0h] [rbp-68h]
unsigned __int8 *v12; // [rsp+8h] [rbp-60h]
unsigned __int8 *v13; // [rsp+10h] [rbp-58h]
long long v14; // [rsp+18h] [rbp-50h]
unsigned __int8 *v15; // [rsp+28h] [rbp-40h]
if ( a5 > a3 )
return 0;
if ( a5 )
{
v15 = a2;
v14 = (long long)&a2[a3 - a5 + 1];
v13 = &a4[a5];
LABEL_7:
while ( v15 != (unsigned __int8 *)v14 )
{
v7 = v15++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v7) == *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *a4) )
{
v12 = v15;
v11 = a4 + 1;
while ( v11 != v13 )
{
v8 = v12++;
v9 = v11++;
if ( *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v8) != *(unsigned __int8 *)(*(_QWORD *)(a1 + 88) + *v9) )
goto LABEL_7;
}
if ( a7 )
{
*a6 = 0;
a6[1] = (_DWORD)v15 - (_DWORD)a2 - 1;
a6[2] = a6[1];
if ( a7 > 1 )
{
a6[3] = a6[1];
a6[4] = a5 + a6[1];
a6[5] = a6[4] - a6[3];
}
}
return 2;
}
}
return 0;
}
if ( a7 )
{
*a6 = 0;
a6[1] = 0;
a6[2] = 0;
}
return 1;
}
|
my_instr_simple:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JA 0x001447de
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00144676
CMP dword ptr [RBP + 0x10],0x0
JZ 0x0014466a
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],0x0
LAB_0014466a:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001447e5
LAB_00144676:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
XOR ECX,ECX
SUB RCX,qword ptr [RBP + -0x30]
ADD RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x58],RAX
LAB_001446ab:
JMP 0x001446ad
LAB_001446ad:
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x50]
JZ 0x001447dc
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x40],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x48]
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JNZ 0x001447d7
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x48]
ADD RAX,0x1
MOV qword ptr [RBP + -0x68],RAX
LAB_00144708:
MOV RAX,qword ptr [RBP + -0x68]
CMP RAX,qword ptr [RBP + -0x58]
JZ 0x00144759
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x58]
MOV RDX,qword ptr [RBP + -0x68]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x68],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x00144757
JMP 0x001446ab
LAB_00144757:
JMP 0x00144708
LAB_00144759:
CMP dword ptr [RBP + 0x10],0x0
JBE 0x001447ce
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SUB RAX,0x1
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x4],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x8],ECX
CMP dword ptr [RBP + 0x10],0x1
JBE 0x001447cc
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x4]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x4]
ADD RAX,qword ptr [RBP + -0x30]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x38]
SUB ECX,dword ptr [RAX + 0xc]
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX + 0x14],ECX
LAB_001447cc:
JMP 0x001447ce
LAB_001447ce:
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001447e5
LAB_001447d7:
JMP 0x001446ad
LAB_001447dc:
JMP 0x001447de
LAB_001447de:
MOV dword ptr [RBP + -0x4],0x0
LAB_001447e5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4
my_instr_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
int4 *param_6,uint param_7)
{
byte bVar1;
byte bVar2;
byte *pbVar3;
byte *local_70;
byte *local_68;
byte *local_48;
if (param_5 <= param_3) {
if (param_5 == 0) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = 0;
param_6[2] = 0;
}
return 1;
}
local_48 = param_2;
while (local_48 != param_2 + (param_3 - param_5) + 1) {
pbVar3 = local_48 + 1;
bVar1 = *local_48;
local_48 = pbVar3;
if (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)*param_4)) {
local_70 = param_4 + 1;
local_68 = pbVar3;
do {
if (local_70 == param_4 + param_5) {
if (param_7 != 0) {
*param_6 = 0;
param_6[1] = ((int)pbVar3 - (int)param_2) + -1;
param_6[2] = param_6[1];
if (1 < param_7) {
param_6[3] = param_6[1];
param_6[4] = param_6[1] + (int)param_5;
param_6[5] = param_6[4] - param_6[3];
}
}
return 2;
}
bVar1 = *local_68;
bVar2 = *local_70;
local_70 = local_70 + 1;
local_68 = local_68 + 1;
} while (*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar1) ==
*(char *)(*(long *)(param_1 + 0x58) + (ulong)bVar2));
}
}
}
return 0;
}
|
|
17,767
|
ma_fetch_keypage
|
eloqsql/storage/maria/ma_page.c
|
my_bool _ma_fetch_keypage(MARIA_PAGE *page, MARIA_HA *info,
const MARIA_KEYDEF *keyinfo,
my_off_t pos, enum pagecache_page_lock lock,
int level, uchar *buff,
my_bool return_buffer __attribute__ ((unused)))
{
uchar *tmp;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
uint block_size= share->block_size;
DBUG_ENTER("_ma_fetch_keypage");
DBUG_PRINT("enter",("page: %lu", (ulong) (pos / block_size)));
tmp= pagecache_read(share->pagecache, &share->kfile,
(pgcache_page_no_t) (pos / block_size), level, buff,
share->page_type, lock, &page_link.link);
if (lock != PAGECACHE_LOCK_LEFT_UNLOCKED)
{
DBUG_ASSERT(lock == PAGECACHE_LOCK_WRITE || lock == PAGECACHE_LOCK_READ);
page_link.unlock= (lock == PAGECACHE_LOCK_WRITE ?
PAGECACHE_LOCK_WRITE_UNLOCK :
PAGECACHE_LOCK_READ_UNLOCK);
page_link.changed= 0;
push_dynamic(&info->pinned_pages, (void*) &page_link);
page->link_offset= info->pinned_pages.elements-1;
}
if (tmp == info->buff)
info->keyread_buff_used=1;
else if (!tmp)
{
DBUG_PRINT("error",("Got errno: %d from pagecache_read",my_errno));
info->last_keypage=HA_OFFSET_ERROR;
_ma_set_fatal_error(info, my_errno);
DBUG_RETURN(1);
}
info->last_keypage= pos;
/*
Setup page structure to make pages easy to use
This is same as page_fill_info, but here inlined as this si used
so often.
*/
page->info= info;
page->keyinfo= keyinfo;
page->buff= tmp;
page->pos= pos;
page->size= _ma_get_page_used(share, tmp);
page->org_size= page->size; /* For debugging */
page->flag= _ma_get_keypage_flag(share, tmp);
page->node= ((page->flag & KEYPAGE_FLAG_ISNOD) ?
share->base.key_reflength : 0);
#ifdef EXTRA_DEBUG
{
uint page_size= page->size;
if (page_size < 4 || page_size > share->max_index_block_size ||
_ma_get_keynr(share, tmp) != keyinfo->key_nr)
{
DBUG_PRINT("error",("page %lu had wrong page length: %u page_header: %u keynr: %u",
(ulong) (pos / block_size), page_size,
share->keypage_header,
_ma_get_keynr(share, tmp)));
DBUG_DUMP("page", tmp, page_size);
info->last_keypage = HA_OFFSET_ERROR;
_ma_set_fatal_error(info, HA_ERR_CRASHED);
DBUG_RETURN(1);
}
}
#endif
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_fetch_keypage:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb 0x18(%rbp), %al
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x5c(%rbp)
jmp 0x99764
movq -0x58(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x58(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x28(%rbp), %rax
movl -0x5c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rdx
movl -0x30(%rbp), %ecx
movq 0x10(%rbp), %r8
movq -0x58(%rbp), %rax
movl 0x7d4(%rax), %r9d
movl -0x2c(%rbp), %r10d
leaq -0x50(%rbp), %rax
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3cfe0
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x99801
jmp 0x997bd
jmp 0x997bf
movl -0x2c(%rbp), %edx
movl $0x5, %eax
movl $0x6, %ecx
cmpl $0x4, %edx
cmovel %ecx, %eax
movl %eax, -0x48(%rbp)
movb $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xda660
movq -0x18(%rbp), %rax
movl 0x2f0(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x378(%rcx), %rax
jne 0x9981f
movq -0x18(%rbp), %rax
movb $0x1, 0x685(%rax)
jmp 0x9985c
cmpq $0x0, -0x38(%rbp)
jne 0x9985a
jmp 0x99828
jmp 0x9982a
movq -0x18(%rbp), %rax
movq $-0x1, 0x440(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0xf6060
movq -0x68(%rbp), %rdi
movl (%rax), %esi
callq 0x43d70
movb $0x1, -0x1(%rbp)
jmp 0x99937
jmp 0x9985c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x440(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
subl $0x2, %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x99922
movq -0x58(%rbp), %rax
movl 0x3e4(%rax), %eax
movl %eax, -0x6c(%rbp)
jmp 0x99929
xorl %eax, %eax
movl %eax, -0x6c(%rbp)
jmp 0x99929
movl -0x6c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x28(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_ma_fetch_keypage:
push rbp
mov rbp, rsp
sub rsp, 80h
mov al, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_2C], r8d
mov [rbp+var_30], r9d
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov eax, [rax+7BCh]
mov [rbp+var_5C], eax
jmp short $+2
loc_99764:
mov rax, [rbp+var_58]
mov rdi, [rax+600h]
mov rsi, [rbp+var_58]
add rsi, 750h
mov rax, [rbp+var_28]
mov ecx, [rbp+var_5C]
xor edx, edx
div rcx
mov rdx, rax
mov ecx, [rbp+var_30]
mov r8, [rbp+arg_0]
mov rax, [rbp+var_58]
mov r9d, [rax+7D4h]
mov r10d, [rbp+var_2C]
lea rax, [rbp+var_50]
mov [rsp+80h+var_80], r10d
mov [rsp+80h+var_78], rax
call pagecache_read
mov [rbp+var_38], rax
cmp [rbp+var_2C], 0
jz short loc_99801
jmp short $+2
loc_997BD:
jmp short $+2
loc_997BF:
mov edx, [rbp+var_2C]
mov eax, 5
mov ecx, 6
cmp edx, 4
cmovz eax, ecx
mov [rbp+var_48], eax
mov [rbp+var_40], 0
mov rdi, [rbp+var_18]
add rdi, 2E8h
lea rsi, [rbp+var_50]
call insert_dynamic
mov rax, [rbp+var_18]
mov ecx, [rax+2F0h]
sub ecx, 1
mov rax, [rbp+var_10]
mov [rax+30h], ecx
loc_99801:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_18]
cmp rax, [rcx+378h]
jnz short loc_9981F
mov rax, [rbp+var_18]
mov byte ptr [rax+685h], 1
jmp short loc_9985C
loc_9981F:
cmp [rbp+var_38], 0
jnz short loc_9985A
jmp short $+2
loc_99828:
jmp short $+2
loc_9982A:
mov rax, [rbp+var_18]
mov qword ptr [rax+440h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_18]
mov [rbp+var_68], rax
call _my_thread_var
mov rdi, [rbp+var_68]
mov esi, [rax]
call _ma_set_fatal_error
mov [rbp+var_1], 1
jmp loc_99937
loc_9985A:
jmp short $+2
loc_9985C:
mov rcx, [rbp+var_28]
mov rax, [rbp+var_18]
mov [rax+440h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rax, [rbp+var_38]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_38]
mov rdx, [rbp+var_58]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx ecx, ax
mov rax, [rbp+var_10]
mov [rax+20h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+24h], ecx
mov rax, [rbp+var_38]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
sub ecx, 2
sub ecx, 1
mov ecx, ecx
movzx ecx, byte ptr [rax+rcx]
mov rax, [rbp+var_10]
mov [rax+2Ch], ecx
mov rax, [rbp+var_10]
mov eax, [rax+2Ch]
and eax, 1
cmp eax, 0
jz short loc_99922
mov rax, [rbp+var_58]
mov eax, [rax+3E4h]
mov [rbp+var_6C], eax
jmp short loc_99929
loc_99922:
xor eax, eax
mov [rbp+var_6C], eax
jmp short $+2
loc_99929:
mov ecx, [rbp+var_6C]
mov rax, [rbp+var_10]
mov [rax+28h], ecx
mov [rbp+var_1], 0
loc_99937:
mov al, [rbp+var_1]
add rsp, 80h
pop rbp
retn
|
char ma_fetch_keypage(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
unsigned int a5,
int a6,
long long a7)
{
_QWORD *v7; // rdi
const char *v8; // rsi
int v9; // eax
int *v10; // rax
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
int v14; // r9d
int v16; // [rsp+14h] [rbp-6Ch]
_DWORD *v17; // [rsp+18h] [rbp-68h]
unsigned int v18; // [rsp+24h] [rbp-5Ch]
_DWORD *v19; // [rsp+28h] [rbp-58h]
char v20[8]; // [rsp+30h] [rbp-50h] BYREF
int v21; // [rsp+38h] [rbp-48h]
char v22; // [rsp+40h] [rbp-40h]
long long v23; // [rsp+48h] [rbp-38h]
int v24; // [rsp+50h] [rbp-30h]
unsigned int v25; // [rsp+54h] [rbp-2Ch]
unsigned long long v26; // [rsp+58h] [rbp-28h]
long long v27; // [rsp+60h] [rbp-20h]
long long v28; // [rsp+68h] [rbp-18h]
long long v29; // [rsp+70h] [rbp-10h]
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5;
v24 = a6;
v19 = *(_DWORD **)a2;
v18 = *(_DWORD *)(*(_QWORD *)a2 + 1980LL);
v7 = *(_QWORD **)(*(_QWORD *)a2 + 1536LL);
v8 = (const char *)(*(_QWORD *)a2 + 1872LL);
v23 = pagecache_read(v7, (long long)(v19 + 468), a4 / v18, a6, a7, v19[501], a5, v20);
if ( v25 )
{
v9 = 5;
if ( v25 == 4 )
v9 = 6;
v21 = v9;
v22 = 0;
v7 = (_QWORD *)(v28 + 744);
v8 = v20;
insert_dynamic(v28 + 744, v20);
*(_DWORD *)(v29 + 48) = *(_DWORD *)(v28 + 752) - 1;
}
if ( v23 == *(_QWORD *)(v28 + 888) )
{
*(_BYTE *)(v28 + 1669) = 1;
}
else if ( !v23 )
{
*(_QWORD *)(v28 + 1088) = -1LL;
v17 = (_DWORD *)v28;
v10 = (int *)my_thread_var(v7, v8);
ma_set_fatal_error(v17, *v10, v11, v12, v13, v14);
return 1;
}
*(_QWORD *)(v28 + 1088) = v26;
*(_QWORD *)v29 = v28;
*(_QWORD *)(v29 + 8) = v27;
*(_QWORD *)(v29 + 16) = v23;
*(_QWORD *)(v29 + 24) = v26;
*(_DWORD *)(v29 + 32) = _byteswap_ushort(*(_WORD *)(v23 + (unsigned int)v19[465] - 2));
*(_DWORD *)(v29 + 36) = *(_DWORD *)(v29 + 32);
*(_DWORD *)(v29 + 44) = *(unsigned __int8 *)(v23 + (unsigned int)(v19[465] - 3));
if ( (*(_DWORD *)(v29 + 44) & 1) != 0 )
v16 = v19[249];
else
v16 = 0;
*(_DWORD *)(v29 + 40) = v16;
return 0;
}
|
_ma_fetch_keypage:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV AL,byte ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x2c],R8D
MOV dword ptr [RBP + -0x30],R9D
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x00199764
LAB_00199764:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x750
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RBP + -0x5c]
XOR EDX,EDX
DIV RCX
MOV RDX,RAX
MOV ECX,dword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x58]
MOV R9D,dword ptr [RAX + 0x7d4]
MOV R10D,dword ptr [RBP + -0x2c]
LEA RAX,[RBP + -0x50]
MOV dword ptr [RSP],R10D
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0013cfe0
MOV qword ptr [RBP + -0x38],RAX
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x00199801
JMP 0x001997bd
LAB_001997bd:
JMP 0x001997bf
LAB_001997bf:
MOV EDX,dword ptr [RBP + -0x2c]
MOV EAX,0x5
MOV ECX,0x6
CMP EDX,0x4
CMOVZ EAX,ECX
MOV dword ptr [RBP + -0x48],EAX
MOV byte ptr [RBP + -0x40],0x0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x50]
CALL 0x001da660
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RAX + 0x2f0]
SUB ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x30],ECX
LAB_00199801:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX + 0x378]
JNZ 0x0019981f
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x685],0x1
JMP 0x0019985c
LAB_0019981f:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x0019985a
JMP 0x00199828
LAB_00199828:
JMP 0x0019982a
LAB_0019982a:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x440],-0x1
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],RAX
CALL 0x001f6060
MOV RDI,qword ptr [RBP + -0x68]
MOV ESI,dword ptr [RAX]
CALL 0x00143d70
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00199937
LAB_0019985a:
JMP 0x0019985c
LAB_0019985c:
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x440],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x58]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX ECX,AX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x20],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x2
SUB ECX,0x1
MOV ECX,ECX
MOVZX ECX,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x2c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c]
AND EAX,0x1
CMP EAX,0x0
JZ 0x00199922
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x3e4]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x00199929
LAB_00199922:
XOR EAX,EAX
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x00199929
LAB_00199929:
MOV ECX,dword ptr [RBP + -0x6c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],ECX
MOV byte ptr [RBP + -0x1],0x0
LAB_00199937:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x80
POP RBP
RET
|
int1
_ma_fetch_keypage(int8 *param_1,long *param_2,int8 param_3,ulong param_4,int param_5,
int4 param_6,int8 param_7)
{
long lVar1;
long *plVar2;
int4 *puVar3;
int4 local_74;
int1 local_58 [8];
int4 local_50;
int1 local_48;
long local_40;
int4 local_38;
int local_34;
ulong local_30;
int8 local_28;
long *local_20;
int8 *local_18;
lVar1 = *param_2;
local_38 = param_6;
local_34 = param_5;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_40 = pagecache_read(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,
param_4 / *(uint *)(lVar1 + 0x7bc),param_6,param_7,
*(int4 *)(lVar1 + 0x7d4),param_5,local_58);
if (local_34 != 0) {
local_50 = 5;
if (local_34 == 4) {
local_50 = 6;
}
local_48 = 0;
insert_dynamic(local_20 + 0x5d,local_58);
*(int *)(local_18 + 6) = (int)local_20[0x5e] + -1;
}
plVar2 = local_20;
if (local_40 == local_20[0x6f]) {
*(int1 *)((long)local_20 + 0x685) = 1;
}
else if (local_40 == 0) {
local_20[0x88] = -1;
puVar3 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar2,*puVar3);
return 1;
}
local_20[0x88] = local_30;
*local_18 = local_20;
local_18[1] = local_28;
local_18[2] = local_40;
local_18[3] = local_30;
*(uint *)(local_18 + 4) =
(uint)CONCAT11(*(int1 *)(local_40 + -2 + (ulong)*(uint *)(lVar1 + 0x744)),
*(int1 *)(local_40 + -1 + (ulong)*(uint *)(lVar1 + 0x744)));
*(int4 *)((long)local_18 + 0x24) = *(int4 *)(local_18 + 4);
*(uint *)((long)local_18 + 0x2c) =
(uint)*(byte *)(local_40 + (ulong)(*(int *)(lVar1 + 0x744) - 3));
if ((*(uint *)((long)local_18 + 0x2c) & 1) == 0) {
local_74 = 0;
}
else {
local_74 = *(int4 *)(lVar1 + 0x3e4);
}
*(int4 *)(local_18 + 5) = local_74;
return 0;
}
|
|
17,768
|
ma_search
|
eloqsql/storage/maria/ma_search.c
|
int _ma_search(register MARIA_HA *info, MARIA_KEY *key, uint32 nextflag,
my_off_t pos)
{
int error;
MARIA_PINNED_PAGE *page_link;
uchar *page_buff;
info->page_changed= 1; /* If page not saved */
if (!(error= _ma_search_no_save(info, key, nextflag, pos, &page_link,
&page_buff)))
{
if (nextflag & SEARCH_SAVE_BUFF)
{
memcpy(info->keyread_buff, page_buff, info->s->block_size);
/* Save position for a possible read next / previous */
info->int_keypos= info->keyread_buff + info->keypos_offset;
info->int_maxpos= info->keyread_buff + info->maxpos_offset;
info->int_keytree_version= key->keyinfo->version;
info->last_search_keypage= info->last_keypage;
info->page_changed= 0;
info->keyread_buff_used= 0;
}
}
_ma_unpin_all_pages(info, LSN_IMPOSSIBLE);
return (error);
}
|
O0
|
c
|
ma_search:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x684(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
callq 0x95c00
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x95be8
movl -0x14(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x95be6
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rdi
movq -0x38(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x7bc(%rax), %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x3c0(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b0(%rax)
movq -0x8(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x8(%rbp), %rax
movl 0x3c4(%rax), %eax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x3b8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0xb8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3d4(%rax)
movq -0x8(%rbp), %rax
movq 0x440(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x448(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x684(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x685(%rax)
jmp 0x95be8
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x45ef0
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
|
_ma_search:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rax, [rbp+var_8]
mov byte ptr [rax+684h], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
lea r8, [rbp+var_30]
lea r9, [rbp+var_38]
call _ma_search_no_save
mov [rbp+var_24], eax
cmp eax, 0
jnz loc_95BE8
mov eax, [rbp+var_14]
and eax, 20h
cmp eax, 0
jz loc_95BE6
mov rax, [rbp+var_8]
mov rdi, [rax+380h]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+7BCh]
mov edx, eax
call _memcpy
mov rax, [rbp+var_8]
mov rcx, [rax+380h]
mov rax, [rbp+var_8]
mov eax, [rax+3C0h]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+3B0h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+380h]
mov rax, [rbp+var_8]
mov eax, [rax+3C4h]
add rcx, rax
mov rax, [rbp+var_8]
mov [rax+3B8h], rcx
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov ecx, [rax+0B8h]
mov rax, [rbp+var_8]
mov [rax+3D4h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+440h]
mov rax, [rbp+var_8]
mov [rax+448h], rcx
mov rax, [rbp+var_8]
mov byte ptr [rax+684h], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+685h], 0
loc_95BE6:
jmp short $+2
loc_95BE8:
mov rdi, [rbp+var_8]
xor eax, eax
mov esi, eax
call _ma_unpin_all_pages
mov eax, [rbp+var_24]
add rsp, 40h
pop rbp
retn
|
long long ma_search(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // [rsp+8h] [rbp-38h] BYREF
_BYTE v6[12]; // [rsp+10h] [rbp-30h] BYREF
unsigned int v7; // [rsp+1Ch] [rbp-24h]
long long v8; // [rsp+20h] [rbp-20h]
unsigned int v9; // [rsp+2Ch] [rbp-14h]
long long v10; // [rsp+30h] [rbp-10h]
long long v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
v8 = a4;
*(_BYTE *)(a1 + 1668) = 1;
v7 = ma_search_no_save(v11, v10, v9, v8, v6, &v5);
if ( !v7 && (v9 & 0x20) != 0 )
{
memcpy(*(_QWORD *)(v11 + 896), v5, *(unsigned int *)(*(_QWORD *)v11 + 1980LL));
*(_QWORD *)(v11 + 944) = *(unsigned int *)(v11 + 960) + *(_QWORD *)(v11 + 896);
*(_QWORD *)(v11 + 952) = *(unsigned int *)(v11 + 964) + *(_QWORD *)(v11 + 896);
*(_DWORD *)(v11 + 980) = *(_DWORD *)(*(_QWORD *)(v10 + 8) + 184LL);
*(_QWORD *)(v11 + 1096) = *(_QWORD *)(v11 + 1088);
*(_BYTE *)(v11 + 1668) = 0;
*(_BYTE *)(v11 + 1669) = 0;
}
ma_unpin_all_pages(v11, 0LL);
return v7;
}
|
_ma_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x684],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x20]
LEA R8,[RBP + -0x30]
LEA R9,[RBP + -0x38]
CALL 0x00195c00
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JNZ 0x00195be8
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,0x20
CMP EAX,0x0
JZ 0x00195be6
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x380]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x3c0]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x3b0],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x3c4]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x3b8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x3d4],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x440]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x448],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x684],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x685],0x0
LAB_00195be6:
JMP 0x00195be8
LAB_00195be8:
MOV RDI,qword ptr [RBP + -0x8]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00145ef0
MOV EAX,dword ptr [RBP + -0x24]
ADD RSP,0x40
POP RBP
RET
|
int _ma_search(long *param_1,long param_2,uint param_3,int8 param_4)
{
void *local_40;
int1 local_38 [12];
int local_2c;
int8 local_28;
uint local_1c;
long local_18;
long *local_10;
*(int1 *)((long)param_1 + 0x684) = 1;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_2c = _ma_search_no_save(param_1,param_2,param_3,param_4,local_38,&local_40);
if ((local_2c == 0) && ((local_1c & 0x20) != 0)) {
memcpy((void *)local_10[0x70],local_40,(ulong)*(uint *)(*local_10 + 0x7bc));
local_10[0x76] = local_10[0x70] + (ulong)*(uint *)(local_10 + 0x78);
local_10[0x77] = local_10[0x70] + (ulong)*(uint *)((long)local_10 + 0x3c4);
*(int4 *)((long)local_10 + 0x3d4) = *(int4 *)(*(long *)(local_18 + 8) + 0xb8);
local_10[0x89] = local_10[0x88];
*(int1 *)((long)local_10 + 0x684) = 0;
*(int1 *)((long)local_10 + 0x685) = 0;
}
_ma_unpin_all_pages(local_10,0);
return local_2c;
}
|
|
17,769
|
rw_pr_rdlock
|
eloqsql/mysys/thr_rwlock.c
|
int rw_pr_rdlock(rw_pr_lock_t *rwlock)
{
pthread_mutex_lock(&rwlock->lock);
/*
The fact that we were able to acquire 'lock' mutex means
that there are no active writers and we can acquire rd-lock.
Increment active readers counter to prevent requests for
wr-lock from succeeding and unlock mutex.
*/
rwlock->active_readers++;
pthread_mutex_unlock(&rwlock->lock);
return 0;
}
|
O3
|
c
|
rw_pr_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2a200
incl 0x58(%rbx)
movq %rbx, %rdi
callq 0x2a1d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
rw_pr_rdlock:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
call _pthread_mutex_lock
inc dword ptr [rbx+58h]
mov rdi, rbx
call _pthread_mutex_unlock
xor eax, eax
add rsp, 8
pop rbx
pop rbp
retn
|
long long rw_pr_rdlock(long long a1)
{
pthread_mutex_lock(a1);
++*(_DWORD *)(a1 + 88);
pthread_mutex_unlock(a1);
return 0LL;
}
|
rw_pr_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0012a200
INC dword ptr [RBX + 0x58]
MOV RDI,RBX
CALL 0x0012a1d0
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
int8 rw_pr_rdlock(pthread_mutex_t *param_1)
{
pthread_mutex_lock(param_1);
*(int *)((long)param_1 + 0x58) = *(int *)((long)param_1 + 0x58) + 1;
pthread_mutex_unlock(param_1);
return 0;
}
|
|
17,770
|
get_simple_key_cache_statistics
|
eloqsql/mysys/mf_keycache.c
|
static
void get_simple_key_cache_statistics(SIMPLE_KEY_CACHE_CB *keycache,
uint partition_no __attribute__((unused)),
KEY_CACHE_STATISTICS *keycache_stats)
{
DBUG_ENTER("simple_get_key_cache_statistics");
keycache_stats->mem_size= (longlong) keycache->key_cache_mem_size;
keycache_stats->block_size= (longlong) keycache->key_cache_block_size;
keycache_stats->blocks_used= keycache->blocks_used;
keycache_stats->blocks_unused= keycache->blocks_unused;
keycache_stats->blocks_changed= keycache->global_blocks_changed;
keycache_stats->blocks_warm= keycache->warm_blocks;
keycache_stats->read_requests= keycache->global_cache_r_requests;
keycache_stats->reads= keycache->global_cache_read;
keycache_stats->write_requests= keycache->global_cache_w_requests;
keycache_stats->writes= keycache->global_cache_write;
DBUG_VOID_RETURN;
}
|
O3
|
c
|
get_simple_key_cache_statistics:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq %rax, (%rdx)
movl 0x18(%rdi), %eax
movq %rax, 0x8(%rdx)
movq 0x50(%rdi), %rax
movq %rax, 0x10(%rdx)
movq 0x58(%rdi), %rax
movq %rax, 0x18(%rdx)
movq 0x138(%rdi), %rax
movq %rax, 0x20(%rdx)
movq 0x68(%rdi), %rax
movq %rax, 0x28(%rdx)
movq 0x150(%rdi), %rax
movq %rax, 0x30(%rdx)
movq 0x158(%rdi), %rax
movq %rax, 0x38(%rdx)
movq 0x140(%rdi), %rax
movq %rax, 0x40(%rdx)
movq 0x148(%rdi), %rax
movq %rax, 0x48(%rdx)
popq %rbp
retq
|
get_simple_key_cache_statistics:
push rbp
mov rbp, rsp
mov rax, [rdi+8]
mov [rdx], rax
mov eax, [rdi+18h]
mov [rdx+8], rax
mov rax, [rdi+50h]
mov [rdx+10h], rax
mov rax, [rdi+58h]
mov [rdx+18h], rax
mov rax, [rdi+138h]
mov [rdx+20h], rax
mov rax, [rdi+68h]
mov [rdx+28h], rax
mov rax, [rdi+150h]
mov [rdx+30h], rax
mov rax, [rdi+158h]
mov [rdx+38h], rax
mov rax, [rdi+140h]
mov [rdx+40h], rax
mov rax, [rdi+148h]
mov [rdx+48h], rax
pop rbp
retn
|
long long get_simple_key_cache_statistics(long long a1, long long a2, _QWORD *a3)
{
long long result; // rax
*a3 = *(_QWORD *)(a1 + 8);
a3[1] = *(unsigned int *)(a1 + 24);
a3[2] = *(_QWORD *)(a1 + 80);
a3[3] = *(_QWORD *)(a1 + 88);
a3[4] = *(_QWORD *)(a1 + 312);
a3[5] = *(_QWORD *)(a1 + 104);
a3[6] = *(_QWORD *)(a1 + 336);
a3[7] = *(_QWORD *)(a1 + 344);
a3[8] = *(_QWORD *)(a1 + 320);
result = *(_QWORD *)(a1 + 328);
a3[9] = result;
return result;
}
|
get_simple_key_cache_statistics:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI + 0x8]
MOV qword ptr [RDX],RAX
MOV EAX,dword ptr [RDI + 0x18]
MOV qword ptr [RDX + 0x8],RAX
MOV RAX,qword ptr [RDI + 0x50]
MOV qword ptr [RDX + 0x10],RAX
MOV RAX,qword ptr [RDI + 0x58]
MOV qword ptr [RDX + 0x18],RAX
MOV RAX,qword ptr [RDI + 0x138]
MOV qword ptr [RDX + 0x20],RAX
MOV RAX,qword ptr [RDI + 0x68]
MOV qword ptr [RDX + 0x28],RAX
MOV RAX,qword ptr [RDI + 0x150]
MOV qword ptr [RDX + 0x30],RAX
MOV RAX,qword ptr [RDI + 0x158]
MOV qword ptr [RDX + 0x38],RAX
MOV RAX,qword ptr [RDI + 0x140]
MOV qword ptr [RDX + 0x40],RAX
MOV RAX,qword ptr [RDI + 0x148]
MOV qword ptr [RDX + 0x48],RAX
POP RBP
RET
|
void get_simple_key_cache_statistics(long param_1,int8 param_2,int8 *param_3)
{
*param_3 = *(int8 *)(param_1 + 8);
param_3[1] = (ulong)*(uint *)(param_1 + 0x18);
param_3[2] = *(int8 *)(param_1 + 0x50);
param_3[3] = *(int8 *)(param_1 + 0x58);
param_3[4] = *(int8 *)(param_1 + 0x138);
param_3[5] = *(int8 *)(param_1 + 0x68);
param_3[6] = *(int8 *)(param_1 + 0x150);
param_3[7] = *(int8 *)(param_1 + 0x158);
param_3[8] = *(int8 *)(param_1 + 0x140);
param_3[9] = *(int8 *)(param_1 + 0x148);
return;
}
|
|
17,771
|
make_empty_page
|
eloqsql/storage/maria/ma_blockrec.c
|
static void make_empty_page(MARIA_HA *info, uchar *buff, uint page_type,
my_bool create_dir_entry)
{
uint block_size= info->s->block_size;
DBUG_ENTER("make_empty_page");
bzero(buff, PAGE_HEADER_SIZE(info->s));
#if !defined(DONT_ZERO_PAGE_BLOCKS) || defined(HAVE_valgrind)
/*
We zero the rest of the block to avoid getting old memory information
to disk and to allow the file to be compressed better if archived.
The code does not assume the block is zeroed.
*/
if (page_type != BLOB_PAGE)
bzero(buff+ PAGE_HEADER_SIZE(info->s),
block_size - PAGE_HEADER_SIZE(info->s));
#endif
buff[PAGE_TYPE_OFFSET]= (uchar) page_type;
buff[DIR_COUNT_OFFSET]= (int) create_dir_entry;
buff[DIR_FREE_OFFSET]= END_OF_DIR_FREE_LIST;
if (create_dir_entry)
{
/* Create directory entry to point to start of page with size 0 */
buff+= block_size - PAGE_SUFFIX_SIZE - DIR_ENTRY_SIZE;
int2store(buff, PAGE_HEADER_SIZE(info->s));
int2store(buff+2, 0);
}
DBUG_VOID_RETURN;
}
|
O3
|
c
|
make_empty_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movl 0x7bc(%rax), %r13d
movl 0xc18(%rax), %edx
addl $0xc, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x292c0
cmpl $0x3, %r12d
je 0x5f3c3
movq (%r14), %rax
movl 0xc18(%rax), %eax
addl $0xc, %eax
leaq (%rbx,%rax), %rdi
movl %r13d, %edx
subl %eax, %edx
xorl %esi, %esi
callq 0x292c0
movb %r12b, 0x7(%rbx)
movb %r15b, 0x8(%rbx)
movb $-0x1, 0x9(%rbx)
testb %r15b, %r15b
je 0x5f3f1
addl $-0x8, %r13d
movq (%r14), %rax
movl 0xc18(%rax), %eax
addl $0xc, %eax
movw %ax, (%rbx,%r13)
movw $0x0, 0x2(%rbx,%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
make_empty_page:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15d, ecx
mov r12d, edx
mov rbx, rsi
mov r14, rdi
mov rax, [rdi]
mov r13d, [rax+7BCh]
mov edx, [rax+0C18h]
add edx, 0Ch
mov rdi, rsi
xor esi, esi
call _memset
cmp r12d, 3
jz short loc_5F3C3
mov rax, [r14]
mov eax, [rax+0C18h]
add eax, 0Ch
lea rdi, [rbx+rax]
mov edx, r13d
sub edx, eax
xor esi, esi
call _memset
loc_5F3C3:
mov [rbx+7], r12b
mov [rbx+8], r15b
mov byte ptr [rbx+9], 0FFh
test r15b, r15b
jz short loc_5F3F1
add r13d, 0FFFFFFF8h
mov rax, [r14]
mov eax, [rax+0C18h]
add eax, 0Ch
mov [rbx+r13], ax
mov word ptr [rbx+r13+2], 0
loc_5F3F1:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long make_empty_page(long long a1, _BYTE *a2, int a3, char a4)
{
int v6; // r13d
long long result; // rax
long long v8; // rax
v6 = *(_DWORD *)(*(_QWORD *)a1 + 1980LL);
result = memset(a2, 0LL, (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 3096LL) + 12));
if ( a3 != 3 )
{
v8 = (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 3096LL) + 12);
result = memset(&a2[v8], 0LL, (unsigned int)(v6 - v8));
}
a2[7] = a3;
a2[8] = a4;
a2[9] = -1;
if ( a4 )
{
result = (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 3096LL) + 12);
*(_DWORD *)&a2[v6 - 8] = (unsigned __int16)(*(_WORD *)(*(_QWORD *)a1 + 3096LL) + 12);
}
return result;
}
|
make_empty_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15D,ECX
MOV R12D,EDX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI]
MOV R13D,dword ptr [RAX + 0x7bc]
MOV EDX,dword ptr [RAX + 0xc18]
ADD EDX,0xc
MOV RDI,RSI
XOR ESI,ESI
CALL 0x001292c0
CMP R12D,0x3
JZ 0x0015f3c3
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0xc
LEA RDI,[RBX + RAX*0x1]
MOV EDX,R13D
SUB EDX,EAX
XOR ESI,ESI
CALL 0x001292c0
LAB_0015f3c3:
MOV byte ptr [RBX + 0x7],R12B
MOV byte ptr [RBX + 0x8],R15B
MOV byte ptr [RBX + 0x9],0xff
TEST R15B,R15B
JZ 0x0015f3f1
ADD R13D,-0x8
MOV RAX,qword ptr [R14]
MOV EAX,dword ptr [RAX + 0xc18]
ADD EAX,0xc
MOV word ptr [RBX + R13*0x1],AX
MOV word ptr [RBX + R13*0x1 + 0x2],0x0
LAB_0015f3f1:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void make_empty_page(long *param_1,void *param_2,int param_3,char param_4)
{
int iVar1;
uint uVar2;
ulong uVar3;
iVar1 = *(int *)(*param_1 + 0x7bc);
memset(param_2,0,(ulong)(*(int *)(*param_1 + 0xc18) + 0xc));
if (param_3 != 3) {
uVar2 = *(int *)(*param_1 + 0xc18) + 0xc;
memset((void *)((long)param_2 + (ulong)uVar2),0,(ulong)(iVar1 - uVar2));
}
*(char *)((long)param_2 + 7) = (char)param_3;
*(char *)((long)param_2 + 8) = param_4;
*(int1 *)((long)param_2 + 9) = 0xff;
if (param_4 != '\0') {
uVar3 = (ulong)(iVar1 - 8);
*(short *)((long)param_2 + uVar3) = (short)*(int4 *)(*param_1 + 0xc18) + 0xc;
*(int2 *)((long)param_2 + uVar3 + 2) = 0;
}
return;
}
|
|
17,772
|
void alaya::normalize<unsigned char>(unsigned char*, unsigned long)
|
AlayaLite/include/utils/data_utils.hpp
|
inline void normalize(DataType *data, size_t dim) {
float sum = 0;
for (size_t i = 0; i < dim; ++i) {
sum += data[i] * data[i];
}
sum = 1.0 / std::sqrt(sum);
for (size_t i = 0; i < dim; ++i) {
data[i] *= sum;
}
}
|
O0
|
cpp
|
void alaya::normalize<unsigned char>(unsigned char*, unsigned long):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2ae3b
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
imull %ecx, %eax
cvtsi2ss %eax, %xmm0
addss 0x14(%rsp), %xmm0
movss %xmm0, 0x14(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2adf0
movss 0x14(%rsp), %xmm0
callq 0x27d10
cvtss2sd %xmm0, %xmm1
movsd 0xeab2e(%rip), %xmm0 # 0x115980
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x14(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2aea6
movss 0x14(%rsp), %xmm1
movq 0x20(%rsp), %rax
movq (%rsp), %rdx
movq %rdx, %rcx
movzbl (%rax,%rdx), %edx
cvtsi2ss %edx, %xmm0
mulss %xmm1, %xmm0
cvttss2si %xmm0, %edx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2ae68
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZN5alaya9normalizeIhEEvPT_m:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
xorps xmm0, xmm0
movss [rsp+28h+var_14], xmm0
mov [rsp+28h+var_20], 0
loc_2ADF0:
mov rax, [rsp+28h+var_20]
cmp rax, [rsp+28h+var_10]
jnb short loc_2AE3B
mov rax, [rsp+28h+var_8]
mov rcx, [rsp+28h+var_20]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rsp+28h+var_8]
mov rdx, [rsp+28h+var_20]
movzx ecx, byte ptr [rcx+rdx]
imul eax, ecx
cvtsi2ss xmm0, eax
addss xmm0, [rsp+28h+var_14]
movss [rsp+28h+var_14], xmm0
mov rax, [rsp+28h+var_20]
add rax, 1
mov [rsp+28h+var_20], rax
jmp short loc_2ADF0
loc_2AE3B:
movss xmm0, [rsp+28h+var_14]; float
call _ZSt4sqrtf; std::sqrt(float)
cvtss2sd xmm1, xmm0
movsd xmm0, cs:qword_115980
divsd xmm0, xmm1
cvtsd2ss xmm0, xmm0
movss [rsp+28h+var_14], xmm0
mov [rsp+28h+var_28], 0
loc_2AE68:
mov rax, [rsp+28h+var_28]
cmp rax, [rsp+28h+var_10]
jnb short loc_2AEA6
movss xmm1, [rsp+28h+var_14]
mov rax, [rsp+28h+var_8]
mov rdx, [rsp+28h+var_28]
mov rcx, rdx
movzx edx, byte ptr [rax+rdx]
cvtsi2ss xmm0, edx
mulss xmm0, xmm1
cvttss2si edx, xmm0
mov [rax+rcx], dl
mov rax, [rsp+28h+var_28]
add rax, 1
mov [rsp+28h+var_28], rax
jmp short loc_2AE68
loc_2AEA6:
add rsp, 28h
retn
|
unsigned long long alaya::normalize<unsigned char>(long long a1, unsigned long long a2)
{
float v2; // xmm0_4
unsigned long long result; // rax
unsigned long long j; // [rsp+0h] [rbp-28h]
unsigned long long i; // [rsp+8h] [rbp-20h]
float v6; // [rsp+14h] [rbp-14h]
v6 = 0.0;
for ( i = 0LL; i < a2; ++i )
v6 = (float)(*(unsigned __int8 *)(a1 + i) * *(unsigned __int8 *)(a1 + i)) + v6;
v2 = 1.0 / std::sqrt(v6);
for ( j = 0LL; ; ++j )
{
result = j;
if ( j >= a2 )
break;
*(_BYTE *)(a1 + j) = (int)(float)((float)*(unsigned __int8 *)(a1 + j) * v2);
}
return result;
}
|
normalize<unsigned_char>:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0x14],XMM0
MOV qword ptr [RSP + 0x8],0x0
LAB_0012adf0:
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,qword ptr [RSP + 0x18]
JNC 0x0012ae3b
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x8]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x8]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
IMUL EAX,ECX
CVTSI2SS XMM0,EAX
ADDSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [RSP + 0x14],XMM0
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,0x1
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0012adf0
LAB_0012ae3b:
MOVSS XMM0,dword ptr [RSP + 0x14]
CALL 0x00127d10
CVTSS2SD XMM1,XMM0
MOVSD XMM0,qword ptr [0x00215980]
DIVSD XMM0,XMM1
CVTSD2SS XMM0,XMM0
MOVSS dword ptr [RSP + 0x14],XMM0
MOV qword ptr [RSP],0x0
LAB_0012ae68:
MOV RAX,qword ptr [RSP]
CMP RAX,qword ptr [RSP + 0x18]
JNC 0x0012aea6
MOVSS XMM1,dword ptr [RSP + 0x14]
MOV RAX,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP]
MOV RCX,RDX
MOVZX EDX,byte ptr [RAX + RDX*0x1]
CVTSI2SS XMM0,EDX
MULSS XMM0,XMM1
CVTTSS2SI EDX,XMM0
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RSP]
ADD RAX,0x1
MOV qword ptr [RSP],RAX
JMP 0x0012ae68
LAB_0012aea6:
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* void alaya::normalize<unsigned char>(unsigned char*, unsigned long) */
void alaya::normalize<unsigned_char>(uchar *param_1,ulong param_2)
{
float fVar1;
double dVar2;
ulong local_28;
ulong local_20;
float local_14;
local_14 = 0.0;
for (local_20 = 0; local_20 < param_2; local_20 = local_20 + 1) {
local_14 = (float)((uint)param_1[local_20] * (uint)param_1[local_20]) + local_14;
}
fVar1 = (float)std::sqrt(local_14);
dVar2 = _DAT_00215980 / (double)fVar1;
for (local_28 = 0; local_28 < param_2; local_28 = local_28 + 1) {
param_1[local_28] = (uchar)(int)((float)param_1[local_28] * (float)dVar2);
}
return;
}
|
|
17,773
|
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
|
seiftnesse[P]memoryallocator/build_O2/_deps/googletest-src/googletest/src/gtest.cc
|
Message& Message::operator<<(const ::std::wstring& wstr) {
internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this);
return *this;
}
|
O2
|
cpp
|
testing::Message::operator<<(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
xorl %r13d, %r13d
movq %rsp, %r14
cmpq %r13, %r12
je 0x1855c
cmpl $0x0, (%r15,%r13,4)
je 0x18543
leaq (%r15,%r13,4), %rsi
movl %r12d, %edx
subl %r13d, %edx
movq %r14, %rdi
callq 0x1a420
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26452
movq %r14, %rdi
callq 0x9af8
cmpq %r13, %r12
je 0x18557
cmpl $0x0, (%r15,%r13,4)
je 0x18501
incq %r13
jmp 0x18532
movb $0x0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28ad4
incq %r13
jmp 0x18501
movq %r12, %r13
jmp 0x18501
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9af8
movq %rbx, %rdi
callq 0x99d0
|
_ZN7testing7MessagelsERKNSt7__cxx1112basic_stringIwSt11char_traitsIwESaIwEEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov rbx, rdi
mov r15, [rsi]
mov r12, [rsi+8]
xor r13d, r13d
mov r14, rsp
loc_18501:
cmp r12, r13
jz short loc_1855C
cmp dword ptr [r15+r13*4], 0
jz short loc_18543
lea rsi, [r15+r13*4]
mov edx, r12d
sub edx, r13d
mov rdi, r14
call _ZN7testing8internal16WideStringToUtf8B5cxx11EPKwi; testing::internal::WideStringToUtf8(wchar_t const*,int)
mov rdi, rbx
mov rsi, r14
call _ZN7testing7MessagelsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS0_RKT_; testing::Message::operator<<<std::string>(std::string const&)
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_18532:
cmp r12, r13
jz short loc_18557
cmp dword ptr [r15+r13*4], 0
jz short loc_18501
inc r13
jmp short loc_18532
loc_18543:
mov [rsp+48h+var_48], 0
mov rdi, rbx
mov rsi, r14
call _ZN7testing7MessagelsIcEERS0_RKT_; testing::Message::operator<<<char>(char const&)
inc r13
jmp short loc_18501
loc_18557:
mov r13, r12
jmp short loc_18501
loc_1855C:
mov rax, rbx
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
|
long long testing::Message::operator<<(long long a1, long long *a2, long long a3, int a4, int a5, int a6)
{
long long v6; // r15
long long v7; // r12
long long v8; // r13
_DWORD v10[6]; // [rsp+0h] [rbp-48h] BYREF
char v11; // [rsp+18h] [rbp-30h]
v6 = *a2;
v7 = a2[1];
v8 = 0LL;
LABEL_2:
while ( v7 != v8 )
{
if ( *(_DWORD *)(v6 + 4 * v8) )
{
testing::internal::WideStringToUtf8[abi:cxx11](
(unsigned int)v10,
v6 + 4 * v8,
v7 - v8,
a4,
a5,
a6,
v10[0],
v10[2],
v10[4],
v11);
testing::Message::operator<<<std::string>(a1, v10);
std::string::~string(v10);
while ( v7 != v8 )
{
if ( !*(_DWORD *)(v6 + 4 * v8) )
goto LABEL_2;
++v8;
}
v8 = v7;
}
else
{
LOBYTE(v10[0]) = 0;
testing::Message::operator<<<char>(a1, v10);
++v8;
}
}
return a1;
}
|
operator<<:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDI
MOV R15,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
XOR R13D,R13D
MOV R14,RSP
LAB_00118501:
CMP R12,R13
JZ 0x0011855c
CMP dword ptr [R15 + R13*0x4],0x0
JZ 0x00118543
LEA RSI,[R15 + R13*0x4]
MOV EDX,R12D
SUB EDX,R13D
MOV RDI,R14
CALL 0x0011a420
LAB_0011851f:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00126452
LAB_0011852a:
MOV RDI,R14
CALL 0x00109af8
LAB_00118532:
CMP R12,R13
JZ 0x00118557
CMP dword ptr [R15 + R13*0x4],0x0
JZ 0x00118501
INC R13
JMP 0x00118532
LAB_00118543:
MOV byte ptr [RSP],0x0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00128ad4
INC R13
JMP 0x00118501
LAB_00118557:
MOV R13,R12
JMP 0x00118501
LAB_0011855c:
MOV RAX,RBX
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* testing::Message::TEMPNAMEPLACEHOLDERVALUE(std::__cxx11::wstring const&) */
Message * __thiscall testing::Message::operator<<(Message *this,wstring *param_1)
{
long lVar1;
long lVar2;
long lVar3;
long lVar4;
internal local_48 [32];
lVar1 = *(long *)param_1;
lVar2 = *(long *)(param_1 + 8);
lVar3 = 0;
while (lVar4 = lVar3, lVar2 != lVar4) {
if (*(int *)(lVar1 + lVar4 * 4) == 0) {
local_48[0] = (internal)0x0;
operator<<(this,(char *)local_48);
lVar3 = lVar4 + 1;
}
else {
internal::WideStringToUtf8_abi_cxx11_
(local_48,(wchar_t *)(lVar1 + lVar4 * 4),(int)lVar2 - (int)lVar4);
/* try { // try from 0011851f to 00118529 has its CatchHandler @ 0011856d */
operator<<(this,(string *)local_48);
std::__cxx11::string::~string((string *)local_48);
for (; (lVar3 = lVar2, lVar2 != lVar4 && (lVar3 = lVar4, *(int *)(lVar1 + lVar4 * 4) != 0));
lVar4 = lVar4 + 1) {
}
}
}
return this;
}
|
|
17,774
|
ggml_tallocr_new
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c
|
struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t buffer) {
void * base = ggml_backend_buffer_get_base(buffer);
size_t align = ggml_backend_buffer_get_alignment(buffer);
assert(align && !(align & (align - 1))); // power of 2
struct ggml_tallocr talloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.base = */ base,
/*.alignment = */ align,
/*.offset = */ aligned_offset(base, 0, align),
};
return talloc;
}
|
O1
|
c
|
ggml_tallocr_new:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x18550
movq %rax, %r15
movq %r14, %rdi
callq 0x187a0
movq %rax, %rcx
decq %rax
movq %rcx, %rdx
xorq %rax, %rdx
cmpq %rax, %rdx
jbe 0x2501e
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x29f23(%rip), %rdi # 0x4ef48
leaq 0x29f3c(%rip), %rsi # 0x4ef68
leaq 0x29f8d(%rip), %rcx # 0x4efc0
movl $0x4c, %edx
callq 0x17b00
|
ggml_tallocr_new:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _ggml_backend_buffer_get_base
mov r15, rax
mov rdi, r14
call _ggml_backend_buffer_get_alignment
mov rcx, rax
dec rax
mov rdx, rcx
xor rdx, rax
cmp rdx, rax
jbe short loc_2501E
mov [rbx], r14
mov [rbx+8], r15
mov [rbx+10h], rcx
mov rax, r15
xor edx, edx
div rcx
mov rax, rcx
sub rax, rdx
xor edx, edx
div rcx
mov [rbx+18h], rdx
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_2501E:
lea rdi, aAlignAlignAlig; "align && !(align & (align - 1))"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStructGgmlTall; "struct ggml_tallocr ggml_tallocr_new(gg"...
mov edx, 4Ch ; 'L'
call ___assert_fail
|
_QWORD * ggml_tallocr_new(_QWORD *a1, long long a2)
{
unsigned long long base; // r15
unsigned long long alignment; // rcx
base = ggml_backend_buffer_get_base(a2);
alignment = ggml_backend_buffer_get_alignment(a2);
if ( ((alignment - 1) ^ alignment) <= alignment - 1 )
__assert_fail(
"align && !(align & (align - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
76LL,
"struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t)");
*a1 = a2;
a1[1] = base;
a1[2] = alignment;
a1[3] = (alignment - base % alignment) % alignment;
return a1;
}
|
ggml_tallocr_new:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x00118550
MOV R15,RAX
MOV RDI,R14
CALL 0x001187a0
MOV RCX,RAX
DEC RAX
MOV RDX,RCX
XOR RDX,RAX
CMP RDX,RAX
JBE 0x0012501e
MOV qword ptr [RBX],R14
MOV qword ptr [RBX + 0x8],R15
MOV qword ptr [RBX + 0x10],RCX
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV RAX,RCX
SUB RAX,RDX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x18],RDX
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0012501e:
LEA RDI,[0x14ef48]
LEA RSI,[0x14ef68]
LEA RCX,[0x14efc0]
MOV EDX,0x4c
CALL 0x00117b00
|
int8 * ggml_tallocr_new(int8 *param_1,int8 param_2)
{
ulong uVar1;
ulong uVar2;
uVar1 = ggml_backend_buffer_get_base(param_2);
uVar2 = ggml_backend_buffer_get_alignment(param_2);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
*param_1 = param_2;
param_1[1] = uVar1;
param_1[2] = uVar2;
param_1[3] = (uVar2 - uVar1 % uVar2) % uVar2;
return param_1;
}
/* WARNING: Subroutine does not return */
__assert_fail("align && !(align & (align - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x4c,"struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t)");
}
|
|
17,775
|
ggml_tallocr_new
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c
|
struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t buffer) {
void * base = ggml_backend_buffer_get_base(buffer);
size_t align = ggml_backend_buffer_get_alignment(buffer);
assert(align && !(align & (align - 1))); // power of 2
struct ggml_tallocr talloc = (struct ggml_tallocr) {
/*.buffer = */ buffer,
/*.base = */ base,
/*.alignment = */ align,
/*.offset = */ aligned_offset(base, 0, align),
};
return talloc;
}
|
O3
|
c
|
ggml_tallocr_new:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x17540
movq %rax, %r15
movq %r14, %rdi
callq 0x17790
movq %rax, %rcx
decq %rax
movq %rcx, %rdx
xorq %rax, %rdx
cmpq %rax, %rdx
jbe 0x23cce
movq %r14, (%rbx)
movq %r15, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movq %r15, %rax
xorl %edx, %edx
divq %rcx
movq %rcx, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b313(%rip), %rdi # 0x4efe8
leaq 0x2b32c(%rip), %rsi # 0x4f008
leaq 0x2b37d(%rip), %rcx # 0x4f060
movl $0x4c, %edx
callq 0x16b00
|
ggml_tallocr_new:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _ggml_backend_buffer_get_base
mov r15, rax
mov rdi, r14
call _ggml_backend_buffer_get_alignment
mov rcx, rax
dec rax
mov rdx, rcx
xor rdx, rax
cmp rdx, rax
jbe short loc_23CCE
mov [rbx], r14
mov [rbx+8], r15
mov [rbx+10h], rcx
mov rax, r15
xor edx, edx
div rcx
mov rax, rcx
sub rax, rdx
xor edx, edx
div rcx
mov [rbx+18h], rdx
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_23CCE:
lea rdi, aAlignAlignAlig; "align && !(align & (align - 1))"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStructGgmlTall; "struct ggml_tallocr ggml_tallocr_new(gg"...
mov edx, 4Ch ; 'L'
call ___assert_fail
|
_QWORD * ggml_tallocr_new(_QWORD *a1, long long a2)
{
unsigned long long base; // r15
unsigned long long alignment; // rcx
base = ggml_backend_buffer_get_base(a2);
alignment = ggml_backend_buffer_get_alignment(a2);
if ( ((alignment - 1) ^ alignment) <= alignment - 1 )
__assert_fail(
"align && !(align & (align - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c",
76LL,
"struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t)");
*a1 = a2;
a1[1] = base;
a1[2] = alignment;
a1[3] = (alignment - base % alignment) % alignment;
return a1;
}
|
ggml_tallocr_new:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x00117540
MOV R15,RAX
MOV RDI,R14
CALL 0x00117790
MOV RCX,RAX
DEC RAX
MOV RDX,RCX
XOR RDX,RAX
CMP RDX,RAX
JBE 0x00123cce
MOV qword ptr [RBX],R14
MOV qword ptr [RBX + 0x8],R15
MOV qword ptr [RBX + 0x10],RCX
MOV RAX,R15
XOR EDX,EDX
DIV RCX
MOV RAX,RCX
SUB RAX,RDX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x18],RDX
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_00123cce:
LEA RDI,[0x14efe8]
LEA RSI,[0x14f008]
LEA RCX,[0x14f060]
MOV EDX,0x4c
CALL 0x00116b00
|
int8 * ggml_tallocr_new(int8 *param_1,int8 param_2)
{
ulong uVar1;
ulong uVar2;
uVar1 = ggml_backend_buffer_get_base(param_2);
uVar2 = ggml_backend_buffer_get_alignment(param_2);
if (uVar2 - 1 < (uVar2 ^ uVar2 - 1)) {
*param_1 = param_2;
param_1[1] = uVar1;
param_1[2] = uVar2;
param_1[3] = (uVar2 - uVar1 % uVar2) % uVar2;
return param_1;
}
/* WARNING: Subroutine does not return */
__assert_fail("align && !(align & (align - 1))",
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-alloc.c"
,0x4c,"struct ggml_tallocr ggml_tallocr_new(ggml_backend_buffer_t)");
}
|
|
17,776
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>)
|
7CodeWizard[P]stablediffusion/ggml_extend.hpp
|
void alloc_compute_buffer(get_graph_cb_t get_graph) {
if (compute_buffer_size == 0) {
// alignment required by the backend
compute_allocr = ggml_allocr_new_measure_from_backend(backend);
struct ggml_cgraph* gf = get_graph();
// compute the required memory
compute_buffer_size = ggml_allocr_alloc_graph(compute_allocr, gf) + 1024 * 1024;
// recreate the allocator with the required memory
ggml_allocr_free(compute_allocr);
LOG_DEBUG("%s compute buffer size: %.2f MB", name.c_str(), compute_buffer_size / 1024.0 / 1024.0);
}
compute_buffer = ggml_backend_alloc_buffer(backend, compute_buffer_size);
compute_allocr = ggml_allocr_new_from_buffer(compute_buffer);
}
|
O0
|
cpp
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>):
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x38(%rax)
jne 0x66552
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x1659b0
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
callq 0x66650
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x50(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x165af0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x100000, %rcx # imm = 0x100000
movq %rcx, 0x38(%rax)
movq 0x50(%rax), %rdi
callq 0x165a20
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0xb280
movq %rax, %r8
movq 0x8(%rsp), %rax
movq 0x38(%rax), %xmm0
movaps 0x118d1d(%rip), %xmm1 # 0x17f220
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x118d21(%rip), %xmm1 # 0x17f230
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0 # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x118d6a(%rip), %xmm1 # 0x17f290
divsd %xmm1, %xmm0
movsd 0x118d5e(%rip), %xmm1 # 0x17f290
divsd %xmm1, %xmm0
xorl %edi, %edi
leaq 0x11981d(%rip), %rsi # 0x17fd5c
movl $0x257, %edx # imm = 0x257
leaq 0x119efc(%rip), %rcx # 0x180447
movb $0x1, %al
callq 0xeb5e0
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rax), %rsi
callq 0x166ba0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x48(%rax), %rdi
callq 0x165960
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
|
_ZN10GGMLModule20alloc_compute_bufferESt8functionIFP11ggml_cgraphvEE:
sub rsp, 28h
mov [rsp+28h+var_28], rsi
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_20], rax
cmp qword ptr [rax+38h], 0
jnz loc_66552
mov rax, [rsp+28h+var_20]
mov rdi, [rax+60h]
call ggml_allocr_new_measure_from_backend
mov rdi, [rsp+28h+var_28]
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rax+50h], rcx
call _ZNKSt8functionIFP11ggml_cgraphvEEclEv; std::function<ggml_cgraph * ()(void)>::operator()(void)
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_18], rcx
mov rdi, [rax+50h]
mov rsi, [rsp+28h+var_18]
call ggml_allocr_alloc_graph
mov rcx, rax
mov rax, [rsp+28h+var_20]
add rcx, 100000h
mov [rax+38h], rcx
mov rdi, [rax+50h]
call ggml_allocr_free
mov rdi, [rsp+28h+var_20]
add rdi, 8
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov r8, rax
mov rax, [rsp+28h+var_20]
movq xmm0, qword ptr [rax+38h]
movaps xmm1, cs:xmmword_17F220
punpckldq xmm0, xmm1
movapd xmm1, cs:xmmword_17F230
subpd xmm0, xmm1
movaps xmm1, xmm0
unpckhpd xmm0, xmm0
addsd xmm0, xmm1
movsd xmm1, cs:qword_17F290
divsd xmm0, xmm1
movsd xmm1, cs:qword_17F290
divsd xmm0, xmm1
xor edi, edi
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 257h
lea rcx, aSComputeBuffer; "%s compute buffer size: %.2f MB"
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
loc_66552:
mov rax, [rsp+28h+var_20]
mov rdi, [rax+60h]
mov rsi, [rax+38h]
call ggml_backend_alloc_buffer
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rax+48h], rcx
mov rdi, [rax+48h]
call ggml_allocr_new_from_buffer
mov rcx, rax
mov rax, [rsp+28h+var_20]
mov [rax+50h], rcx
add rsp, 28h
retn
|
_QWORD * GGMLModule::alloc_compute_buffer(_QWORD *a1, long long a2)
{
long long v2; // rax
int v3; // eax
int v4; // r9d
long long v5; // rcx
_QWORD *result; // rax
if ( !a1[7] )
{
a1[10] = ggml_allocr_new_measure_from_backend(a1[12]);
v2 = std::function<ggml_cgraph * ()(void)>::operator()(a2);
a1[7] = ggml_allocr_alloc_graph(a1[10], v2) + 0x100000;
ggml_allocr_free(a1[10]);
v3 = std::string::c_str(a1 + 1);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
599,
(unsigned int)"%s compute buffer size: %.2f MB",
v3,
v4);
}
a1[9] = ggml_backend_alloc_buffer(a1[12], a1[7]);
v5 = ggml_allocr_new_from_buffer(a1[9]);
result = a1;
a1[10] = v5;
return result;
}
|
alloc_compute_buffer:
SUB RSP,0x28
MOV qword ptr [RSP],RSI
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x00166552
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x60]
CALL 0x002659b0
MOV RDI,qword ptr [RSP]
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x50],RCX
CALL 0x00166650
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RCX
MOV RDI,qword ptr [RAX + 0x50]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00265af0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
ADD RCX,0x100000
MOV qword ptr [RAX + 0x38],RCX
MOV RDI,qword ptr [RAX + 0x50]
CALL 0x00265a20
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x8
CALL 0x0010b280
MOV R8,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOVQ XMM0,qword ptr [RAX + 0x38]
MOVAPS XMM1,xmmword ptr [0x0027f220]
PUNPCKLDQ XMM0,XMM1
MOVAPD XMM1,xmmword ptr [0x0027f230]
SUBPD XMM0,XMM1
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x0027f290]
DIVSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x0027f290]
DIVSD XMM0,XMM1
XOR EDI,EDI
LEA RSI,[0x27fd5c]
MOV EDX,0x257
LEA RCX,[0x280447]
MOV AL,0x1
CALL 0x001eb5e0
LAB_00166552:
MOV RAX,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RAX + 0x60]
MOV RSI,qword ptr [RAX + 0x38]
CALL 0x00266ba0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x48],RCX
MOV RDI,qword ptr [RAX + 0x48]
CALL 0x00265960
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x50],RCX
ADD RSP,0x28
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>) */
void __thiscall GGMLModule::alloc_compute_buffer(GGMLModule *this,function<ggml_cgraph*()> *param_2)
{
int8 uVar1;
long lVar2;
int8 uVar3;
int1 auVar4 [16];
if (*(long *)(this + 0x38) == 0) {
uVar1 = ggml_allocr_new_measure_from_backend(*(int8 *)(this + 0x60));
*(int8 *)(this + 0x50) = uVar1;
uVar1 = std::function<ggml_cgraph*()>::operator()(param_2);
lVar2 = ggml_allocr_alloc_graph(*(int8 *)(this + 0x50),uVar1);
*(long *)(this + 0x38) = lVar2 + 0x100000;
ggml_allocr_free(*(int8 *)(this + 0x50));
uVar3 = std::__cxx11::string::c_str();
uVar1 = *(int8 *)(this + 0x38);
auVar4._8_4_ = (int)((ulong)uVar1 >> 0x20);
auVar4._0_8_ = uVar1;
auVar4._12_4_ = _UNK_0027f224;
log_printf((((auVar4._8_8_ - _UNK_0027f238) +
((double)CONCAT44(_DAT_0027f220,(int)uVar1) - _DAT_0027f230)) / DAT_0027f290) /
DAT_0027f290,0,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,599,"%s compute buffer size: %.2f MB",uVar3);
}
uVar1 = ggml_backend_alloc_buffer(*(int8 *)(this + 0x60),*(int8 *)(this + 0x38));
*(int8 *)(this + 0x48) = uVar1;
uVar1 = ggml_allocr_new_from_buffer(*(int8 *)(this + 0x48));
*(int8 *)(this + 0x50) = uVar1;
return;
}
|
|
17,777
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>)
|
7CodeWizard[P]stablediffusion/ggml_extend.hpp
|
void alloc_compute_buffer(get_graph_cb_t get_graph) {
if (compute_buffer_size == 0) {
// alignment required by the backend
compute_allocr = ggml_allocr_new_measure_from_backend(backend);
struct ggml_cgraph* gf = get_graph();
// compute the required memory
compute_buffer_size = ggml_allocr_alloc_graph(compute_allocr, gf) + 1024 * 1024;
// recreate the allocator with the required memory
ggml_allocr_free(compute_allocr);
LOG_DEBUG("%s compute buffer size: %.2f MB", name.c_str(), compute_buffer_size / 1024.0 / 1024.0);
}
compute_buffer = ggml_backend_alloc_buffer(backend, compute_buffer_size);
compute_allocr = ggml_allocr_new_from_buffer(compute_buffer);
}
|
O1
|
cpp
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x47af7
movq %rsi, %r14
movq 0x60(%rbx), %rdi
callq 0xb3726
movq %rax, 0x50(%rbx)
cmpq $0x0, 0x10(%r14)
je 0x47b1c
movq %r14, %rdi
callq *0x18(%r14)
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq 0xb37c4
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x38(%rbx)
movq 0x50(%rbx), %rdi
callq 0xb377b
movq 0x8(%rbx), %r8
movsd 0x38(%rbx), %xmm1
unpcklps 0x75e69(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x75e71(%rip), %xmm1 # 0xbd930
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x75fad(%rip), %xmm1 # 0xbda80
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
leaq 0x7694e(%rip), %rsi # 0xbe430
leaq 0x77032(%rip), %rcx # 0xbeb1b
xorl %edi, %edi
movl $0x257, %edx # imm = 0x257
movb $0x1, %al
callq 0x7a4d6
movq 0x38(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0xb3ed3
movq %rax, 0x48(%rbx)
movq %rax, %rdi
callq 0xb3690
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xa1e0
nop
|
_ZN10GGMLModule20alloc_compute_bufferESt8functionIFP11ggml_cgraphvEE:
push r14
push rbx
push rax
mov rbx, rdi
cmp qword ptr [rdi+38h], 0
jnz loc_47AF7
mov r14, rsi
mov rdi, [rbx+60h]
call ggml_allocr_new_measure_from_backend
mov [rbx+50h], rax
cmp qword ptr [r14+10h], 0
jz loc_47B1C
mov rdi, r14
call qword ptr [r14+18h]
mov rdi, [rbx+50h]
mov rsi, rax
call ggml_allocr_alloc_graph
add rax, 100000h
mov [rbx+38h], rax
mov rdi, [rbx+50h]
call ggml_allocr_free
mov r8, [rbx+8]
movsd xmm1, qword ptr [rbx+38h]
unpcklps xmm1, cs:xmmword_BD920
subpd xmm1, cs:xmmword_BD930
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
movsd xmm1, cs:qword_BDA80
mulsd xmm0, xmm1
mulsd xmm0, xmm1
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSComputeBuffer; "%s compute buffer size: %.2f MB"
xor edi, edi
mov edx, 257h
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
loc_47AF7:
mov rsi, [rbx+38h]
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+48h], rax
mov rdi, rax
call ggml_allocr_new_from_buffer
mov [rbx+50h], rax
add rsp, 8
pop rbx
pop r14
retn
loc_47B1C:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
|
long long GGMLModule::alloc_compute_buffer(_QWORD *a1, long long a2)
{
long long v2; // rax
int v3; // r9d
long long v4; // rax
long long result; // rax
if ( !a1[7] )
{
a1[10] = ggml_allocr_new_measure_from_backend(a1[12]);
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
v2 = (*(long long ( **)(long long))(a2 + 24))(a2);
a1[7] = ggml_allocr_alloc_graph(a1[10], v2) + 0x100000;
ggml_allocr_free(a1[10]);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
599,
(unsigned int)"%s compute buffer size: %.2f MB",
a1[1],
v3);
}
v4 = ggml_backend_alloc_buffer(a1[12], a1[7]);
a1[9] = v4;
result = ggml_allocr_new_from_buffer(v4);
a1[10] = result;
return result;
}
| |||
17,778
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>)
|
7CodeWizard[P]stablediffusion/ggml_extend.hpp
|
void alloc_compute_buffer(get_graph_cb_t get_graph) {
if (compute_buffer_size == 0) {
// alignment required by the backend
compute_allocr = ggml_allocr_new_measure_from_backend(backend);
struct ggml_cgraph* gf = get_graph();
// compute the required memory
compute_buffer_size = ggml_allocr_alloc_graph(compute_allocr, gf) + 1024 * 1024;
// recreate the allocator with the required memory
ggml_allocr_free(compute_allocr);
LOG_DEBUG("%s compute buffer size: %.2f MB", name.c_str(), compute_buffer_size / 1024.0 / 1024.0);
}
compute_buffer = ggml_backend_alloc_buffer(backend, compute_buffer_size);
compute_allocr = ggml_allocr_new_from_buffer(compute_buffer);
}
|
O2
|
cpp
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
jne 0x2d467
movq 0x60(%rbx), %rdi
callq 0x8f53a
movq %rax, 0x50(%rbx)
movq %r14, %rdi
callq 0x2d4d0
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq 0x8f59f
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x38(%rbx)
movq 0x50(%rbx), %rdi
callq 0x8f556
movq 0x8(%rbx), %r8
movsd 0x38(%rbx), %xmm1
unpcklps 0x6c43d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6c445(%rip), %xmm1 # 0x99870
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x6c571(%rip), %xmm1 # 0x999b0
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
leaq 0x6cf12(%rip), %rsi # 0x9a360
leaq 0x6d5f6(%rip), %rcx # 0x9aa4b
xorl %edi, %edi
movl $0x257, %edx # imm = 0x257
movb $0x1, %al
callq 0x55f59
movq 0x38(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0x8fd01
movq %rax, 0x48(%rbx)
movq %rax, %rdi
callq 0x8f522
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
_ZN10GGMLModule20alloc_compute_bufferESt8functionIFP11ggml_cgraphvEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rdi+38h]
test rsi, rsi
jnz loc_2D467
mov rdi, [rbx+60h]
call ggml_allocr_new_measure_from_backend
mov [rbx+50h], rax
mov rdi, r14
call _ZNKSt8functionIFP11ggml_cgraphvEEclEv; std::function<ggml_cgraph * ()(void)>::operator()(void)
mov rdi, [rbx+50h]
mov rsi, rax
call ggml_allocr_alloc_graph
add rax, 100000h
mov [rbx+38h], rax
mov rdi, [rbx+50h]
call ggml_allocr_free
mov r8, [rbx+8]
movsd xmm1, qword ptr [rbx+38h]
unpcklps xmm1, cs:xmmword_99860
subpd xmm1, cs:xmmword_99870
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
movsd xmm1, cs:qword_999B0
mulsd xmm0, xmm1
mulsd xmm0, xmm1
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSComputeBuffer; "%s compute buffer size: %.2f MB"
xor edi, edi
mov edx, 257h
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
mov rsi, [rbx+38h]
loc_2D467:
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+48h], rax
mov rdi, rax
call ggml_allocr_new_from_buffer
mov [rbx+50h], rax
add rsp, 8
pop rbx
pop r14
retn
|
long long GGMLModule::alloc_compute_buffer(_QWORD *a1, long long a2)
{
long long v3; // rsi
long long v4; // rax
int v5; // r9d
long long v6; // rax
long long result; // rax
v3 = a1[7];
if ( !v3 )
{
a1[10] = ggml_allocr_new_measure_from_backend(a1[12]);
v4 = std::function<ggml_cgraph * ()(void)>::operator()(a2);
a1[7] = ggml_allocr_alloc_graph(a1[10], v4) + 0x100000;
ggml_allocr_free(a1[10]);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
599,
(unsigned int)"%s compute buffer size: %.2f MB",
a1[1],
v5);
v3 = a1[7];
}
v6 = ggml_backend_alloc_buffer(a1[12], v3);
a1[9] = v6;
result = ggml_allocr_new_from_buffer(v6);
a1[10] = result;
return result;
}
|
alloc_compute_buffer:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x38]
TEST RSI,RSI
JNZ 0x0012d467
MOV RDI,qword ptr [RBX + 0x60]
CALL 0x0018f53a
MOV qword ptr [RBX + 0x50],RAX
MOV RDI,R14
CALL 0x0012d4d0
MOV RDI,qword ptr [RBX + 0x50]
MOV RSI,RAX
CALL 0x0018f59f
ADD RAX,0x100000
MOV qword ptr [RBX + 0x38],RAX
MOV RDI,qword ptr [RBX + 0x50]
CALL 0x0018f556
MOV R8,qword ptr [RBX + 0x8]
MOVSD XMM1,qword ptr [RBX + 0x38]
UNPCKLPS XMM1,xmmword ptr [0x00199860]
SUBPD XMM1,xmmword ptr [0x00199870]
MOVAPD XMM0,XMM1
UNPCKHPD XMM0,XMM1
ADDSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x001999b0]
MULSD XMM0,XMM1
MULSD XMM0,XMM1
LEA RSI,[0x19a360]
LEA RCX,[0x19aa4b]
XOR EDI,EDI
MOV EDX,0x257
MOV AL,0x1
CALL 0x00155f59
MOV RSI,qword ptr [RBX + 0x38]
LAB_0012d467:
MOV RDI,qword ptr [RBX + 0x60]
CALL 0x0018fd01
MOV qword ptr [RBX + 0x48],RAX
MOV RDI,RAX
CALL 0x0018f522
MOV qword ptr [RBX + 0x50],RAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>) */
void __thiscall GGMLModule::alloc_compute_buffer(GGMLModule *this,function<ggml_cgraph*()> *param_2)
{
int8 uVar1;
long lVar2;
lVar2 = *(long *)(this + 0x38);
if (lVar2 == 0) {
uVar1 = ggml_allocr_new_measure_from_backend(*(int8 *)(this + 0x60));
*(int8 *)(this + 0x50) = uVar1;
uVar1 = std::function<ggml_cgraph*()>::operator()(param_2);
lVar2 = ggml_allocr_alloc_graph(*(int8 *)(this + 0x50),uVar1);
*(long *)(this + 0x38) = lVar2 + 0x100000;
ggml_allocr_free(*(int8 *)(this + 0x50));
log_printf((((double)CONCAT44(DAT_00199860._4_4_,
(int)((ulong)*(int8 *)(this + 0x38) >> 0x20)) -
_UNK_00199878) +
((double)CONCAT44((int4)DAT_00199860,(int)*(int8 *)(this + 0x38)) -
_DAT_00199870)) * DAT_001999b0 * DAT_001999b0,0,
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp"
,599,"%s compute buffer size: %.2f MB",*(int8 *)(this + 8));
lVar2 = *(long *)(this + 0x38);
}
uVar1 = ggml_backend_alloc_buffer(*(int8 *)(this + 0x60),lVar2);
*(int8 *)(this + 0x48) = uVar1;
uVar1 = ggml_allocr_new_from_buffer(uVar1);
*(int8 *)(this + 0x50) = uVar1;
return;
}
|
|
17,779
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>)
|
7CodeWizard[P]stablediffusion/ggml_extend.hpp
|
void alloc_compute_buffer(get_graph_cb_t get_graph) {
if (compute_buffer_size == 0) {
// alignment required by the backend
compute_allocr = ggml_allocr_new_measure_from_backend(backend);
struct ggml_cgraph* gf = get_graph();
// compute the required memory
compute_buffer_size = ggml_allocr_alloc_graph(compute_allocr, gf) + 1024 * 1024;
// recreate the allocator with the required memory
ggml_allocr_free(compute_allocr);
LOG_DEBUG("%s compute buffer size: %.2f MB", name.c_str(), compute_buffer_size / 1024.0 / 1024.0);
}
compute_buffer = ggml_backend_alloc_buffer(backend, compute_buffer_size);
compute_allocr = ggml_allocr_new_from_buffer(compute_buffer);
}
|
O3
|
cpp
|
GGMLModule::alloc_compute_buffer(std::function<ggml_cgraph* ()>):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
jne 0x47061
movq 0x60(%rbx), %rdi
callq 0xb238d
movq %rax, 0x50(%rbx)
cmpq $0x0, 0x10(%r14)
je 0x47082
movq %r14, %rdi
callq *0x18(%r14)
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq 0xb2420
addq $0x100000, %rax # imm = 0x100000
movq %rax, 0x38(%rbx)
movq 0x50(%rbx), %rdi
callq 0xb23d7
movq 0x8(%rbx), %r8
movsd 0x38(%rbx), %xmm1
unpcklps 0x75913(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x7591b(%rip), %xmm1 # 0xbc940
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x75a57(%rip), %xmm1 # 0xbca90
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
leaq 0x763f8(%rip), %rsi # 0xbd440
leaq 0x76adc(%rip), %rcx # 0xbdb2b
xorl %edi, %edi
movl $0x257, %edx # imm = 0x257
movb $0x1, %al
callq 0x7947e
movq 0x38(%rbx), %rsi
movq 0x60(%rbx), %rdi
callq 0xb2abb
movq %rax, 0x48(%rbx)
movq %rax, %rdi
callq 0xb230d
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xa1e0
nop
|
_ZN10GGMLModule20alloc_compute_bufferESt8functionIFP11ggml_cgraphvEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rsi, [rdi+38h]
test rsi, rsi
jnz loc_47061
mov rdi, [rbx+60h]
call ggml_allocr_new_measure_from_backend
mov [rbx+50h], rax
cmp qword ptr [r14+10h], 0
jz loc_47082
mov rdi, r14
call qword ptr [r14+18h]
mov rdi, [rbx+50h]
mov rsi, rax
call ggml_allocr_alloc_graph
add rax, 100000h
mov [rbx+38h], rax
mov rdi, [rbx+50h]
call ggml_allocr_free
mov r8, [rbx+8]
movsd xmm1, qword ptr [rbx+38h]
unpcklps xmm1, cs:xmmword_BC930
subpd xmm1, cs:xmmword_BC940
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
movsd xmm1, cs:qword_BCA90
mulsd xmm0, xmm1
mulsd xmm0, xmm1
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aSComputeBuffer; "%s compute buffer size: %.2f MB"
xor edi, edi
mov edx, 257h
mov al, 1
call _Z10log_printf14sd_log_level_tPKciS1_z; log_printf(sd_log_level_t,char const*,int,char const*,...)
mov rsi, [rbx+38h]
loc_47061:
mov rdi, [rbx+60h]
call ggml_backend_alloc_buffer
mov [rbx+48h], rax
mov rdi, rax
call ggml_allocr_new_from_buffer
mov [rbx+50h], rax
add rsp, 8
pop rbx
pop r14
retn
loc_47082:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
|
long long GGMLModule::alloc_compute_buffer(_QWORD *a1, long long a2)
{
long long v3; // rsi
long long v4; // rax
int v5; // r9d
long long v6; // rax
long long result; // rax
v3 = a1[7];
if ( !v3 )
{
a1[10] = ggml_allocr_new_measure_from_backend(a1[12]);
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
v4 = (*(long long ( **)(long long))(a2 + 24))(a2);
a1[7] = ggml_allocr_alloc_graph(a1[10], v4) + 0x100000;
ggml_allocr_free(a1[10]);
log_printf(
0,
(unsigned int)"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml_extend.hpp",
599,
(unsigned int)"%s compute buffer size: %.2f MB",
a1[1],
v5);
v3 = a1[7];
}
v6 = ggml_backend_alloc_buffer(a1[12], v3);
a1[9] = v6;
result = ggml_allocr_new_from_buffer(v6);
a1[10] = result;
return result;
}
| |||
17,780
|
scoreboard::init()
|
untodesu[P]voxelius/game/client/scoreboard.cc
|
void scoreboard::init(void)
{
globals::client_config.add_value("scoreboard.key", list_key);
settings::add_keybind(3, list_key, settings_location::KEYBOARD_MISC, "key.scoreboard");
globals::dispatcher.sink<protocol::ScoreboardUpdate>().connect<&on_scoreboard_update_packet>();
}
|
O2
|
cpp
|
scoreboard::init():
pushq %rbx
subq $0x20, %rsp
leaq 0x1f4e74(%rip), %rdi # 0x254fc0
leaq 0x115a99(%rip), %rsi # 0x175bec
leaq 0x1f63f6(%rip), %rbx # 0x256550
movq %rbx, %rdx
callq 0x11566c
leaq 0x115a92(%rip), %rcx # 0x175bfb
pushq $0x3
popq %rdi
movq %rbx, %rsi
movl %edi, %edx
callq 0x65201
leaq 0x1f76f3(%rip), %rdi # 0x257870
movl $0xfcaab8ba, %esi # imm = 0xFCAAB8BA
callq 0x60524
leaq 0x8(%rax), %rbx
leaq 0x8(%rsp), %rdi
movq %rbx, (%rdi)
callq 0x604aa
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x362(%rip), %rax # 0x6050a
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x60d4c
addq $0x20, %rsp
popq %rbx
retq
|
_ZN10scoreboard4initEv:
push rbx
sub rsp, 20h
lea rdi, _ZN7globals13client_configE; this
lea rsi, aScoreboardKey; "scoreboard.key"
lea rbx, _ZL8list_key; list_key
mov rdx, rbx; IConfigValue *
call _ZN6Config9add_valueEPKcR12IConfigValue; Config::add_value(char const*,IConfigValue &)
lea rcx, aKeyScoreboard; "key.scoreboard"
push 3
pop rdi
mov rsi, rbx
mov edx, edi
call _ZN8settings11add_keybindEiR13ConfigKeyBind17settings_locationPKc; settings::add_keybind(int,ConfigKeyBind &,settings_location,char const*)
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
mov esi, 0FCAAB8BAh
call _ZN4entt16basic_dispatcherISaIvEE6assureIN8protocol16ScoreboardUpdateEEERNS_8internal18dispatcher_handlerIT_S1_EEj; entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>(uint)
lea rbx, [rax+8]
lea rdi, [rsp+28h+var_20]
mov [rdi], rbx
call _ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_
lea rsi, [rsp+28h+var_18]
and qword ptr [rsi], 0
lea rax, _ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_
mov [rsi+8], rax
mov rdi, rbx
call _ZNSt6vectorIN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEEESaIS6_EE12emplace_backIJS6_EEERS6_DpOT_; std::vector<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>::emplace_back<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>(entt::delegate<void ()(protocol::ScoreboardUpdate &)> &&)
add rsp, 20h
pop rbx
retn
|
long long scoreboard::init(scoreboard *this)
{
long long v2; // [rsp+8h] [rbp-20h]
_QWORD v3[3]; // [rsp+10h] [rbp-18h] BYREF
Config::add_value((Config *)&globals::client_config, "scoreboard.key", (IConfigValue *)&list_key);
settings::add_keybind(3LL, &list_key, 3LL, "key.scoreboard");
v2 = entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>(
globals::dispatcher,
4239046842LL)
+ 8;
ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_();
v3[0] = 0LL;
v3[1] = ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_;
return std::vector<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>::emplace_back<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>(
v2,
v3);
}
|
init:
PUSH RBX
SUB RSP,0x20
LEA RDI,[0x354fc0]
LEA RSI,[0x275bec]
LEA RBX,[0x356550]
MOV RDX,RBX
CALL 0x0021566c
LEA RCX,[0x275bfb]
PUSH 0x3
POP RDI
MOV RSI,RBX
MOV EDX,EDI
CALL 0x00165201
LEA RDI,[0x357870]
MOV ESI,0xfcaab8ba
CALL 0x00160524
LEA RBX,[RAX + 0x8]
LEA RDI,[RSP + 0x8]
MOV qword ptr [RDI],RBX
CALL 0x001604aa
LEA RSI,[RSP + 0x10]
AND qword ptr [RSI],0x0
LEA RAX,[0x16050a]
MOV qword ptr [RSI + 0x8],RAX
MOV RDI,RBX
CALL 0x00160d4c
ADD RSP,0x20
POP RBX
RET
|
/* scoreboard::init() */
void scoreboard::init(void)
{
dispatcher_handler *pdVar1;
int8 local_18;
code *local_10;
Config::add_value((Config *)globals::client_config,"scoreboard.key",(IConfigValue *)list_key);
settings::add_keybind(3,list_key,3,"key.scoreboard");
pdVar1 = entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,0xfcaab8ba);
_ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_
();
local_18 = 0;
local_10 =
_ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_
;
std::
vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
::emplace_back<entt::delegate<void(protocol::ScoreboardUpdate&)>>
((vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
*)(pdVar1 + 8),(delegate *)&local_18);
return;
}
|
|
17,781
|
scoreboard::init()
|
untodesu[P]voxelius/game/client/scoreboard.cc
|
void scoreboard::init(void)
{
globals::client_config.add_value("scoreboard.key", list_key);
settings::add_keybind(3, list_key, settings_location::KEYBOARD_MISC, "key.scoreboard");
globals::dispatcher.sink<protocol::ScoreboardUpdate>().connect<&on_scoreboard_update_packet>();
}
|
O3
|
cpp
|
scoreboard::init():
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x1f4c2a(%rip), %rdi # 0x259f68
leaq 0x135717(%rip), %rsi # 0x19aa5c
leaq 0x1f61bc(%rip), %rbx # 0x25b508
movq %rbx, %rdx
callq 0x12e100
leaq 0x135710(%rip), %rcx # 0x19aa6b
movl $0x3, %edi
movq %rbx, %rsi
movl $0x3, %edx
callq 0x6b3bb
leaq 0x1f74ac(%rip), %rdi # 0x25c820
movl $0xfcaab8ba, %esi # imm = 0xFCAAB8BA
callq 0x6576c
movq %rax, %rbx
leaq 0x8(%rax), %r14
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
callq 0x656fa
movq $0x0, (%rsp)
leaq 0x3ad(%rip), %rax # 0x6574e
movq %rax, 0x8(%rsp)
movq 0x10(%rbx), %rsi
cmpq 0x18(%rbx), %rsi
je 0x653be
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x10(%rbx)
jmp 0x653c9
movq %rsp, %rdx
movq %r14, %rdi
callq 0x65f2c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
_ZN10scoreboard4initEv:
push r14
push rbx
sub rsp, 18h
lea rdi, _ZN7globals13client_configE; this
lea rsi, aScoreboardKey; "scoreboard.key"
lea rbx, _ZL8list_key; list_key
mov rdx, rbx; IConfigValue *
call _ZN6Config9add_valueEPKcR12IConfigValue; Config::add_value(char const*,IConfigValue &)
lea rcx, aKeyScoreboard; "key.scoreboard"
mov edi, 3
mov rsi, rbx
mov edx, 3
call _ZN8settings11add_keybindEiR13ConfigKeyBind17settings_locationPKc; settings::add_keybind(int,ConfigKeyBind &,settings_location,char const*)
lea rdi, _ZN7globals10dispatcherE; globals::dispatcher
mov esi, 0FCAAB8BAh
call _ZN4entt16basic_dispatcherISaIvEE6assureIN8protocol16ScoreboardUpdateEEERNS_8internal18dispatcher_handlerIT_S1_EEj; entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>(uint)
mov rbx, rax
lea r14, [rax+8]
lea rdi, [rsp+28h+var_18]
mov [rdi], r14
call _ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_
mov qword ptr [rsp+28h+var_28], 0
lea rax, _ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_
mov qword ptr [rsp+28h+var_28+8], rax
mov rsi, [rbx+10h]
cmp rsi, [rbx+18h]
jz short loc_653BE
movups xmm0, [rsp+28h+var_28]
movups xmmword ptr [rsi], xmm0
add qword ptr [rbx+10h], 10h
jmp short loc_653C9
loc_653BE:
mov rdx, rsp
mov rdi, r14
call _ZNSt6vectorIN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEEESaIS6_EE17_M_realloc_insertIJS6_EEEvN9__gnu_cxx17__normal_iteratorIPS6_S8_EEDpOT_; std::vector<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>::_M_realloc_insert<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>(__gnu_cxx::__normal_iterator<entt::delegate<void ()(protocol::ScoreboardUpdate &)>*,std::vector<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>>,entt::delegate<void ()(protocol::ScoreboardUpdate &)> &&)
loc_653C9:
add rsp, 18h
pop rbx
pop r14
retn
|
long long ( * scoreboard::init(scoreboard *this))()
{
long long v1; // rbx
long long ( *result)(); // rax
_OWORD *v3; // rsi
__int128 v4; // [rsp+0h] [rbp-28h] BYREF
long long v5; // [rsp+10h] [rbp-18h]
Config::add_value((Config *)&globals::client_config, "scoreboard.key", (IConfigValue *)&list_key);
settings::add_keybind(3LL, &list_key, 3LL, "key.scoreboard");
v1 = entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>(
globals::dispatcher,
4239046842LL);
v5 = v1 + 8;
ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_();
*(_QWORD *)&v4 = 0LL;
result = ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_;
*((_QWORD *)&v4 + 1) = ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_;
v3 = *(_OWORD **)(v1 + 16);
if ( v3 == *(_OWORD **)(v1 + 24) )
return (long long ( *)())std::vector<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>::_M_realloc_insert<entt::delegate<void ()(protocol::ScoreboardUpdate &)>>(
v1 + 8,
v3,
&v4);
*v3 = v4;
*(_QWORD *)(v1 + 16) += 16LL;
return result;
}
|
init:
PUSH R14
PUSH RBX
SUB RSP,0x18
LEA RDI,[0x359f68]
LEA RSI,[0x29aa5c]
LEA RBX,[0x35b508]
MOV RDX,RBX
CALL 0x0022e100
LEA RCX,[0x29aa6b]
MOV EDI,0x3
MOV RSI,RBX
MOV EDX,0x3
CALL 0x0016b3bb
LEA RDI,[0x35c820]
MOV ESI,0xfcaab8ba
CALL 0x0016576c
MOV RBX,RAX
LEA R14,[RAX + 0x8]
LEA RDI,[RSP + 0x10]
MOV qword ptr [RDI],R14
CALL 0x001656fa
MOV qword ptr [RSP],0x0
LEA RAX,[0x16574e]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RBX + 0x10]
CMP RSI,qword ptr [RBX + 0x18]
JZ 0x001653be
MOVUPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RSI],XMM0
ADD qword ptr [RBX + 0x10],0x10
JMP 0x001653c9
LAB_001653be:
MOV RDX,RSP
MOV RDI,R14
CALL 0x00165f2c
LAB_001653c9:
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* scoreboard::init() */
void scoreboard::init(void)
{
int8 *puVar1;
dispatcher_handler *pdVar2;
int8 local_28;
code *pcStack_20;
vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
*local_18;
Config::add_value((Config *)globals::client_config,"scoreboard.key",(IConfigValue *)list_key);
settings::add_keybind(3,list_key,3,"key.scoreboard");
pdVar2 = entt::basic_dispatcher<std::allocator<void>>::assure<protocol::ScoreboardUpdate>
((basic_dispatcher<std::allocator<void>> *)globals::dispatcher,0xfcaab8ba);
local_18 = (vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
*)(pdVar2 + 8);
_ZN4entt4sinkINS_4sighIFvRN8protocol16ScoreboardUpdateEESaIvEEEE10disconnectITnDaXadL_ZL27on_scoreboard_update_packetRKS3_EEJEEEvDpOT0_
();
local_28 = 0;
pcStack_20 =
_ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_
;
puVar1 = *(int8 **)(pdVar2 + 0x10);
if (puVar1 == *(int8 **)(pdVar2 + 0x18)) {
std::
vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
::_M_realloc_insert<entt::delegate<void(protocol::ScoreboardUpdate&)>>
((vector<entt::delegate<void(protocol::ScoreboardUpdate&)>,std::allocator<entt::delegate<void(protocol::ScoreboardUpdate&)>>>
*)(pdVar2 + 8),puVar1,&local_28);
}
else {
*puVar1 = 0;
puVar1[1] =
_ZZN4entt8delegateIFvRN8protocol16ScoreboardUpdateEEE7connectITnDaXadL_ZL27on_scoreboard_update_packetRKS2_EEEEvvENUlPKvS3_E_8__invokeESA_S3_
;
*(long *)(pdVar2 + 0x10) = *(long *)(pdVar2 + 0x10) + 0x10;
}
return;
}
|
|
17,782
|
ma_stmt_execute_generate_simple_request
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
unsigned char* ma_stmt_execute_generate_simple_request(MYSQL_STMT *stmt, size_t *request_len)
{
/* execute packet has the following format:
Offset Length Description
-----------------------------------------
0 4 Statement id
4 1 Flags (cursor type)
5 4 Iteration count
-----------------------------------------
if (stmt->param_count):
6 (paramcount+7)/8 null bitmap
------------------------------------------
if (stmt->send_types_to_server):
param_count*2 parameter types
1st byte: parameter type
2nd byte flag:
unsigned flag (32768)
indicator variable exists (16384)
------------------------------------------
n data from bind_buffer
*/
size_t length= 1024;
size_t free_bytes= 0;
size_t null_byte_offset= 0;
uint i;
uchar *start= NULL, *p;
/* preallocate length bytes */
/* check: gr */
if (!(start= p= (uchar *)malloc(length)))
goto mem_error;
int4store(p, stmt->stmt_id);
p += STMT_ID_LENGTH;
/* flags is 4 bytes, we store just 1 */
int1store(p, (unsigned char) stmt->flags);
p++;
int4store(p, 1);
p+= 4;
if (stmt->param_count)
{
size_t null_count= (stmt->param_count + 7) / 8;
free_bytes= length - (p - start);
if (null_count + 20 > free_bytes)
{
size_t offset= p - start;
length+= offset + null_count + 20;
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
null_byte_offset= p - start;
memset(p, 0, null_count);
p += null_count;
int1store(p, stmt->send_types_to_server);
p++;
free_bytes= length - (p - start);
/* Store type information:
2 bytes per type
*/
if (stmt->send_types_to_server)
{
if (free_bytes < stmt->param_count * 2 + 20)
{
size_t offset= p - start;
length= offset + stmt->param_count * 2 + 20;
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
for (i = 0; i < stmt->param_count; i++)
{
/* this differs from mysqlnd, c api supports unsigned !! */
uint buffer_type= stmt->params[i].buffer_type | (stmt->params[i].is_unsigned ? 32768 : 0);
/* check if parameter requires indicator variable */
int2store(p, buffer_type);
p+= 2;
}
}
/* calculate data size */
for (i=0; i < stmt->param_count; i++)
{
size_t size= 0;
my_bool has_data= TRUE;
if (stmt->params[i].long_data_used)
{
has_data= FALSE;
stmt->params[i].long_data_used= 0;
}
if (has_data)
{
switch (stmt->params[i].buffer_type) {
case MYSQL_TYPE_NULL:
has_data= FALSE;
break;
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_JSON:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_GEOMETRY:
case MYSQL_TYPE_NEWDATE:
case MYSQL_TYPE_ENUM:
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_SET:
size+= 9; /* max 8 bytes for size */
size+= (size_t)ma_get_length(stmt, i, 0);
break;
case MYSQL_TYPE_TIME:
size+= MAX_TIME_STR_LEN;
break;
case MYSQL_TYPE_DATE:
size+= MAX_DATE_STR_LEN;
break;
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
size+= MAX_DATETIME_STR_LEN;
break;
default:
size+= mysql_ps_fetch_functions[stmt->params[i].buffer_type].pack_len;
break;
}
}
free_bytes= length - (p - start);
if (free_bytes < size + 20)
{
size_t offset= p - start;
length= MAX(2 * length, offset + size + 20);
if (!(start= (uchar *)realloc(start, length)))
goto mem_error;
p= start + offset;
}
if (((stmt->params[i].is_null && *stmt->params[i].is_null) ||
stmt->params[i].buffer_type == MYSQL_TYPE_NULL ||
!stmt->params[i].buffer))
{
has_data= FALSE;
(start + null_byte_offset)[i/8] |= (unsigned char) (1 << (i & 7));
}
if (has_data)
{
store_param(stmt, i, &p, 0);
}
}
}
stmt->send_types_to_server= 0;
*request_len = (size_t)(p - start);
return start;
mem_error:
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
free(start);
*request_len= 0;
return NULL;
}
|
O3
|
c
|
ma_stmt_execute_generate_simple_request:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, -0x30(%rbp)
movl $0x400, %edi # imm = 0x400
callq 0x13600
testq %rax, %rax
je 0x22f1b
movq %rax, %r15
movq -0x30(%rbp), %rdi
movl 0x40(%rdi), %eax
movl %eax, (%r15)
movb 0x48(%rdi), %al
movb %al, 0x4(%r15)
movl $0x1, 0x5(%r15)
movq %r15, %rbx
addq $0x9, %rbx
movl 0x64(%rdi), %eax
testl %eax, %eax
je 0x22db8
movq %rax, -0x40(%rbp)
addl $0x7, %eax
movl %eax, %r13d
shrl $0x3, %r13d
movl $0x400, %r12d # imm = 0x400
cmpl $0x1f20, %eax # imm = 0x1F20
jb 0x22cf5
leaq 0x41d(%r13), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13730
testq %rax, %rax
je 0x22f1b
movq %rax, %r15
movq %rax, %rbx
addq $0x9, %rbx
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbx, %r14
callq 0x13260
movq %rbx, %r9
movq -0x30(%rbp), %rdi
movb 0x68(%rdi), %al
addq %r13, %rbx
incq %rbx
movb %al, -0x1(%rbx)
movq %rbx, -0x38(%rbp)
testb %al, %al
je 0x22dc0
movq %rbx, %r13
subq %r15, %r13
movq %r12, %rax
subq %r13, %rax
movq -0x40(%rbp), %rdx
leal 0x14(,%rdx,2), %ecx
movq %r15, %r10
cmpq %rcx, %rax
jae 0x22d73
addl %edx, %edx
movl %edx, %eax
leaq (%rax,%r13), %r12
addq $0x14, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x13730
testq %rax, %rax
je 0x22f1b
movq %rax, %r10
addq %rax, %r13
movq %r13, %rbx
movq -0x30(%rbp), %rdi
movq %r14, %r9
movl $0x30, %eax
xorl %ecx, %ecx
movq 0x70(%rdi), %rsi
movl (%rsi,%rax,2), %r8d
xorl %edx, %edx
cmpb $0x0, 0x5(%rsi,%rax,2)
setne %dl
shll $0xf, %edx
orl %r8d, %edx
movb %r8b, (%rbx)
movb %dh, 0x1(%rbx)
addq $0x2, %rbx
incq %rcx
movl 0x64(%rdi), %edx
addq $0x38, %rax
cmpq %rdx, %rcx
jb 0x22d7a
movq %rbx, -0x38(%rbp)
testl %edx, %edx
jne 0x22dc3
jmp 0x22f12
movq %r15, %r10
jmp 0x22f12
movq %r15, %r10
subq %r15, %r9
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %r9, -0x40(%rbp)
movq 0x70(%rdi), %rax
cmpb $0x0, 0x66(%rax,%r15)
je 0x22de8
movb $0x0, 0x66(%rax,%r15)
movb $0x1, %r13b
xorl %eax, %eax
jmp 0x22e50
movl 0x60(%rax,%r15), %ecx
leal -0xf5(%rcx), %edx
cmpl $0xb, %edx
jb 0x22e0f
cmpl $0x10, %ecx
ja 0x22e3d
movl %ecx, %edx
leaq 0x1a262(%rip), %rsi # 0x3d068
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x22e21
movq (%rax), %rax
addq $0x9, %rax
jmp 0x22e4d
movl $0x9, %eax
jmp 0x22e4d
movl $0xc, %eax
jmp 0x22e4d
movl $0x5, %eax
jmp 0x22e4d
movl $0xd, %eax
jmp 0x22e4d
leaq (%rcx,%rcx,2), %rax
leaq 0x2c488(%rip), %rcx # 0x4f2d0
movslq 0x8(%rcx,%rax,8), %rax
xorl %r13d, %r13d
movq -0x38(%rbp), %r14
subq %r10, %r14
movq %r12, %rcx
subq %r14, %rcx
addq $0x14, %rax
cmpq %rax, %rcx
jae 0x22e9f
movq %r12, %rcx
addq %r12, %rcx
addq %r14, %rax
cmpq %rax, %rcx
movq %rax, %r12
cmovaq %rcx, %r12
movq %r10, %rdi
movq %r12, %rsi
callq 0x13730
testq %rax, %rax
je 0x22f1b
movq %rax, %r10
addq %rax, %r14
movq %r14, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %r9
movq 0x70(%rdi), %rax
movq 0x8(%rax,%r15), %rcx
testq %rcx, %rcx
je 0x22eb2
cmpb $0x0, (%rcx)
jne 0x22ee4
cmpl $0x6, 0x60(%rax,%r15)
je 0x22ee4
cmpq $0x0, 0x10(%rax,%r15)
je 0x22ee4
testb %r13b, %r13b
jne 0x22efb
movl %ebx, %esi
leaq -0x38(%rbp), %rdx
xorl %ecx, %ecx
movq %r10, %r14
callq 0x227b1
movq %r14, %r10
movq -0x40(%rbp), %r9
movq -0x30(%rbp), %rdi
jmp 0x22efb
movl %ebx, %ecx
andb $0x7, %cl
movb $0x1, %al
shlb %cl, %al
leaq (%r10,%r9), %rcx
movq %rbx, %rdx
shrq $0x3, %rdx
orb %al, (%rdx,%rcx)
incq %rbx
movl 0x64(%rdi), %eax
addq $0x70, %r15
cmpq %rax, %rbx
jb 0x22dcf
movq -0x38(%rbp), %rbx
movb $0x0, 0x68(%rdi)
subq %r10, %rbx
jmp 0x22f74
movq -0x30(%rbp), %r14
movl $0x7d8, 0x108(%r14) # imm = 0x7D8
leaq 0x30d(%r14), %rdi
leaq 0x2be58(%rip), %rax # 0x4ed90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %ebx, %ebx
movb %bl, 0x312(%r14)
leaq 0x10c(%r14), %rdi
leaq 0x2be44(%rip), %rax # 0x4eda0
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %bl, 0x30b(%r14)
xorl %r10d, %r10d
movq -0x48(%rbp), %rax
movq %rbx, (%rax)
movq %r10, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ma_stmt_execute_generate_simple_request:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_48], rsi
mov [rbp+var_30], rdi
mov edi, 400h
call _malloc
test rax, rax
jz loc_22F1B
mov r15, rax
mov rdi, [rbp+var_30]
mov eax, [rdi+40h]
mov [r15], eax
mov al, [rdi+48h]
mov [r15+4], al
mov dword ptr [r15+5], 1
mov rbx, r15
add rbx, 9
mov eax, [rdi+64h]
test eax, eax
jz loc_22DB8
mov [rbp+var_40], rax
add eax, 7
mov r13d, eax
shr r13d, 3
mov r12d, 400h
cmp eax, 1F20h
jb short loc_22CF5
lea r12, [r13+41Dh]
mov rdi, r15
mov rsi, r12
call _realloc
test rax, rax
jz loc_22F1B
mov r15, rax
mov rbx, rax
add rbx, 9
loc_22CF5:
mov rdi, rbx
xor esi, esi
mov rdx, r13
mov r14, rbx
call _memset
mov r9, rbx
mov rdi, [rbp+var_30]
mov al, [rdi+68h]
add rbx, r13
inc rbx
mov [rbx-1], al
mov [rbp+var_38], rbx
test al, al
jz loc_22DC0
mov r13, rbx
sub r13, r15
mov rax, r12
sub rax, r13
mov rdx, [rbp+var_40]
lea ecx, ds:14h[rdx*2]
mov r10, r15
cmp rax, rcx
jnb short loc_22D73
add edx, edx
mov eax, edx
lea r12, [rax+r13]
add r12, 14h
mov rdi, r15
mov rsi, r12
call _realloc
test rax, rax
jz loc_22F1B
mov r10, rax
add r13, rax
mov rbx, r13
mov rdi, [rbp+var_30]
mov r9, r14
loc_22D73:
mov eax, 30h ; '0'
xor ecx, ecx
loc_22D7A:
mov rsi, [rdi+70h]
mov r8d, [rsi+rax*2]
xor edx, edx
cmp byte ptr [rsi+rax*2+5], 0
setnz dl
shl edx, 0Fh
or edx, r8d
mov [rbx], r8b
mov [rbx+1], dh
add rbx, 2
inc rcx
mov edx, [rdi+64h]
add rax, 38h ; '8'
cmp rcx, rdx
jb short loc_22D7A
mov [rbp+var_38], rbx
test edx, edx
jnz short loc_22DC3
jmp loc_22F12
loc_22DB8:
mov r10, r15
jmp loc_22F12
loc_22DC0:
mov r10, r15
loc_22DC3:
sub r9, r15
xor r15d, r15d
xor ebx, ebx
mov [rbp+var_40], r9
loc_22DCF:
mov rax, [rdi+70h]
cmp byte ptr [rax+r15+66h], 0
jz short loc_22DE8
mov byte ptr [rax+r15+66h], 0
loc_22DE1:
mov r13b, 1; jumptable 0000000000022E0D case 6
xor eax, eax
jmp short loc_22E50
loc_22DE8:
mov ecx, [rax+r15+60h]
lea edx, [rcx-0F5h]
cmp edx, 0Bh
jb short loc_22E0F; jumptable 0000000000022E0D cases 0,14-16
cmp ecx, 10h; switch 17 cases
ja short def_22E0D; jumptable 0000000000022E0D default case, cases 1-5,8,9,13
mov edx, ecx
lea rsi, jpt_22E0D
movsxd rdx, ds:(jpt_22E0D - 3D068h)[rsi+rdx*4]
add rdx, rsi
jmp rdx; switch jump
loc_22E0F:
mov rax, [rax+r15]; jumptable 0000000000022E0D cases 0,14-16
test rax, rax
jz short loc_22E21
mov rax, [rax]
add rax, 9
jmp short loc_22E4D
loc_22E21:
mov eax, 9
jmp short loc_22E4D
loc_22E28:
mov eax, 0Ch; jumptable 0000000000022E0D cases 7,12
jmp short loc_22E4D
loc_22E2F:
mov eax, 5; jumptable 0000000000022E0D case 10
jmp short loc_22E4D
loc_22E36:
mov eax, 0Dh; jumptable 0000000000022E0D case 11
jmp short loc_22E4D
def_22E0D:
lea rax, [rcx+rcx*2]; jumptable 0000000000022E0D default case, cases 1-5,8,9,13
lea rcx, mysql_ps_fetch_functions
movsxd rax, dword ptr [rcx+rax*8+8]
loc_22E4D:
xor r13d, r13d
loc_22E50:
mov r14, [rbp+var_38]
sub r14, r10
mov rcx, r12
sub rcx, r14
add rax, 14h
cmp rcx, rax
jnb short loc_22E9F
mov rcx, r12
add rcx, r12
add rax, r14
cmp rcx, rax
mov r12, rax
cmova r12, rcx
mov rdi, r10
mov rsi, r12
call _realloc
test rax, rax
jz loc_22F1B
mov r10, rax
add r14, rax
mov [rbp+var_38], r14
mov rdi, [rbp+var_30]
mov r9, [rbp+var_40]
loc_22E9F:
mov rax, [rdi+70h]
mov rcx, [rax+r15+8]
test rcx, rcx
jz short loc_22EB2
cmp byte ptr [rcx], 0
jnz short loc_22EE4
loc_22EB2:
cmp dword ptr [rax+r15+60h], 6
jz short loc_22EE4
cmp qword ptr [rax+r15+10h], 0
jz short loc_22EE4
test r13b, r13b
jnz short loc_22EFB
mov esi, ebx
lea rdx, [rbp+var_38]
xor ecx, ecx
mov r14, r10
call store_param
mov r10, r14
mov r9, [rbp+var_40]
mov rdi, [rbp+var_30]
jmp short loc_22EFB
loc_22EE4:
mov ecx, ebx
and cl, 7
mov al, 1
shl al, cl
lea rcx, [r10+r9]
mov rdx, rbx
shr rdx, 3
or [rdx+rcx], al
loc_22EFB:
inc rbx
mov eax, [rdi+64h]
add r15, 70h ; 'p'
cmp rbx, rax
jb loc_22DCF
mov rbx, [rbp+var_38]
loc_22F12:
mov byte ptr [rdi+68h], 0
sub rbx, r10
jmp short loc_22F74
loc_22F1B:
mov r14, [rbp+var_30]
mov dword ptr [r14+108h], 7D8h
lea rdi, [r14+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor ebx, ebx
mov [r14+312h], bl
lea rdi, [r14+10Ch]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 200h
call _strncpy
mov [r14+30Bh], bl
xor r10d, r10d
loc_22F74:
mov rax, [rbp+var_48]
mov [rax], rbx
mov rax, r10
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ma_stmt_execute_generate_simple_request(long long a1, _QWORD *a2)
{
long long v2; // rax
long long v3; // r15
long long v4; // rdi
_BYTE *v5; // rbx
int v6; // eax
unsigned int v7; // eax
long long v8; // r13
long long v9; // r12
long long v10; // rax
_BYTE *v11; // r14
_BYTE *v12; // r9
char v13; // al
_BYTE *v14; // r13
long long v15; // r10
long long v16; // rax
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // rsi
int v20; // r8d
char v21; // dh
unsigned long long v22; // rdx
_BYTE *v23; // r9
long long v24; // r15
unsigned long long v25; // rbx
long long v26; // rax
char v27; // r13
long long v28; // rax
long long v29; // rcx
_QWORD *v30; // rax
_BYTE *v31; // r14
unsigned long long v32; // rax
long long v33; // rcx
unsigned long long v34; // rax
bool v35; // cc
long long v36; // rax
long long v37; // rax
_BYTE *v38; // rcx
long long v39; // r14
_BYTE *v40; // rbx
long long v41; // r14
int v44; // [rsp+10h] [rbp-40h]
_BYTE *v45; // [rsp+10h] [rbp-40h]
_BYTE *v46; // [rsp+18h] [rbp-38h] BYREF
long long v47; // [rsp+20h] [rbp-30h]
v47 = a1;
v2 = malloc(1024LL);
if ( !v2 )
goto LABEL_45;
v3 = v2;
v4 = v47;
*(_DWORD *)v2 = *(_DWORD *)(v47 + 64);
*(_BYTE *)(v2 + 4) = *(_BYTE *)(v4 + 72);
*(_DWORD *)(v2 + 5) = 1;
v5 = (_BYTE *)(v2 + 9);
v6 = *(_DWORD *)(v4 + 100);
if ( v6 )
{
v44 = *(_DWORD *)(v4 + 100);
v7 = v6 + 7;
v8 = v7 >> 3;
v9 = 1024LL;
if ( v7 >= 0x1F20 )
{
v9 = v8 + 1053;
v10 = realloc(v3, v8 + 1053);
if ( !v10 )
goto LABEL_45;
v3 = v10;
v5 = (_BYTE *)(v10 + 9);
}
v11 = v5;
memset(v5, 0LL, v8);
v12 = v5;
v4 = v47;
v13 = *(_BYTE *)(v47 + 104);
v5 += v8 + 1;
*(v5 - 1) = v13;
v46 = v5;
if ( !v13 )
{
v15 = v3;
goto LABEL_16;
}
v14 = &v5[-v3];
v15 = v3;
if ( v9 - (long long)&v5[-v3] >= (unsigned long long)(unsigned int)(2 * v44 + 20) )
{
LABEL_10:
v17 = 48LL;
v18 = 0LL;
do
{
v19 = *(_QWORD *)(v4 + 112);
v20 = *(_DWORD *)(v19 + 2 * v17);
v21 = BYTE1(v20) | ((*(_BYTE *)(v19 + 2 * v17 + 5) != 0) << 7);
*v5 = v20;
v5[1] = v21;
v5 += 2;
++v18;
v22 = *(unsigned int *)(v4 + 100);
v17 += 56LL;
}
while ( v18 < v22 );
v46 = v5;
if ( !(_DWORD)v22 )
goto LABEL_44;
LABEL_16:
v23 = &v12[-v3];
v24 = 0LL;
v25 = 0LL;
v45 = v23;
do
{
v26 = *(_QWORD *)(v4 + 112);
if ( *(_BYTE *)(v26 + v24 + 102) )
{
*(_BYTE *)(v26 + v24 + 102) = 0;
LABEL_19:
v27 = 1;
v28 = 0LL;
}
else
{
v29 = *(unsigned int *)(v26 + v24 + 96);
if ( (unsigned int)(v29 - 245) >= 0xB )
{
switch ( (int)v29 )
{
case 0:
case 14:
case 15:
case 16:
break;
case 6:
goto LABEL_19;
case 7:
case 12:
v28 = 12LL;
goto LABEL_29;
case 10:
v28 = 5LL;
goto LABEL_29;
case 11:
v28 = 13LL;
goto LABEL_29;
default:
v28 = mysql_ps_fetch_functions[6 * v29 + 2];
goto LABEL_29;
}
}
v30 = *(_QWORD **)(v26 + v24);
if ( v30 )
v28 = *v30 + 9LL;
else
v28 = 9LL;
LABEL_29:
v27 = 0;
}
v31 = &v46[-v15];
v32 = v28 + 20;
if ( v9 - (long long)&v46[-v15] < v32 )
{
v33 = 2 * v9;
v34 = (unsigned long long)&v31[v32];
v35 = 2 * v9 <= v34;
v9 = v34;
if ( !v35 )
v9 = v33;
v36 = realloc(v15, v9);
if ( !v36 )
goto LABEL_45;
v15 = v36;
v46 = &v31[v36];
v4 = v47;
v23 = v45;
}
v37 = *(_QWORD *)(v4 + 112);
v38 = *(_BYTE **)(v37 + v24 + 8);
if ( v38 && *v38 || *(_DWORD *)(v37 + v24 + 96) == 6 || !*(_QWORD *)(v37 + v24 + 16) )
{
v23[v15 + (v25 >> 3)] |= 1 << (v25 & 7);
}
else if ( !v27 )
{
v39 = v15;
store_param(v4, v25, &v46, 0LL);
v15 = v39;
v23 = v45;
v4 = v47;
}
++v25;
v24 += 112LL;
}
while ( v25 < *(unsigned int *)(v4 + 100) );
v5 = v46;
goto LABEL_44;
}
v9 = (long long)&v14[2 * v44 + 20];
v16 = realloc(v3, v9);
if ( v16 )
{
v15 = v16;
v5 = &v14[v16];
v4 = v47;
v12 = v11;
goto LABEL_10;
}
LABEL_45:
v41 = v47;
*(_DWORD *)(v47 + 264) = 2008;
strncpy(v41 + 781, SQLSTATE_UNKNOWN, 5LL);
v40 = 0LL;
*(_BYTE *)(v41 + 786) = 0;
strncpy(v41 + 268, client_errors[8], 512LL);
*(_BYTE *)(v41 + 779) = 0;
v15 = 0LL;
goto LABEL_46;
}
v15 = v3;
LABEL_44:
*(_BYTE *)(v4 + 104) = 0;
v40 = &v5[-v15];
LABEL_46:
*a2 = v40;
return v15;
}
|
ma_stmt_execute_generate_simple_request:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x48],RSI
MOV qword ptr [RBP + -0x30],RDI
MOV EDI,0x400
CALL 0x00113600
TEST RAX,RAX
JZ 0x00122f1b
MOV R15,RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RDI + 0x40]
MOV dword ptr [R15],EAX
MOV AL,byte ptr [RDI + 0x48]
MOV byte ptr [R15 + 0x4],AL
MOV dword ptr [R15 + 0x5],0x1
MOV RBX,R15
ADD RBX,0x9
MOV EAX,dword ptr [RDI + 0x64]
TEST EAX,EAX
JZ 0x00122db8
MOV qword ptr [RBP + -0x40],RAX
ADD EAX,0x7
MOV R13D,EAX
SHR R13D,0x3
MOV R12D,0x400
CMP EAX,0x1f20
JC 0x00122cf5
LEA R12,[R13 + 0x41d]
MOV RDI,R15
MOV RSI,R12
CALL 0x00113730
TEST RAX,RAX
JZ 0x00122f1b
MOV R15,RAX
MOV RBX,RAX
ADD RBX,0x9
LAB_00122cf5:
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R13
MOV R14,RBX
CALL 0x00113260
MOV R9,RBX
MOV RDI,qword ptr [RBP + -0x30]
MOV AL,byte ptr [RDI + 0x68]
ADD RBX,R13
INC RBX
MOV byte ptr [RBX + -0x1],AL
MOV qword ptr [RBP + -0x38],RBX
TEST AL,AL
JZ 0x00122dc0
MOV R13,RBX
SUB R13,R15
MOV RAX,R12
SUB RAX,R13
MOV RDX,qword ptr [RBP + -0x40]
LEA ECX,[0x14 + RDX*0x2]
MOV R10,R15
CMP RAX,RCX
JNC 0x00122d73
ADD EDX,EDX
MOV EAX,EDX
LEA R12,[RAX + R13*0x1]
ADD R12,0x14
MOV RDI,R15
MOV RSI,R12
CALL 0x00113730
TEST RAX,RAX
JZ 0x00122f1b
MOV R10,RAX
ADD R13,RAX
MOV RBX,R13
MOV RDI,qword ptr [RBP + -0x30]
MOV R9,R14
LAB_00122d73:
MOV EAX,0x30
XOR ECX,ECX
LAB_00122d7a:
MOV RSI,qword ptr [RDI + 0x70]
MOV R8D,dword ptr [RSI + RAX*0x2]
XOR EDX,EDX
CMP byte ptr [RSI + RAX*0x2 + 0x5],0x0
SETNZ DL
SHL EDX,0xf
OR EDX,R8D
MOV byte ptr [RBX],R8B
MOV byte ptr [RBX + 0x1],DH
ADD RBX,0x2
INC RCX
MOV EDX,dword ptr [RDI + 0x64]
ADD RAX,0x38
CMP RCX,RDX
JC 0x00122d7a
MOV qword ptr [RBP + -0x38],RBX
TEST EDX,EDX
JNZ 0x00122dc3
JMP 0x00122f12
LAB_00122db8:
MOV R10,R15
JMP 0x00122f12
LAB_00122dc0:
MOV R10,R15
LAB_00122dc3:
SUB R9,R15
XOR R15D,R15D
XOR EBX,EBX
MOV qword ptr [RBP + -0x40],R9
LAB_00122dcf:
MOV RAX,qword ptr [RDI + 0x70]
CMP byte ptr [RAX + R15*0x1 + 0x66],0x0
JZ 0x00122de8
MOV byte ptr [RAX + R15*0x1 + 0x66],0x0
caseD_6:
MOV R13B,0x1
XOR EAX,EAX
JMP 0x00122e50
LAB_00122de8:
MOV ECX,dword ptr [RAX + R15*0x1 + 0x60]
LEA EDX,[RCX + -0xf5]
CMP EDX,0xb
JC 0x00122e0f
CMP ECX,0x10
JA 0x00122e3d
MOV EDX,ECX
LEA RSI,[0x13d068]
MOVSXD RDX,dword ptr [RSI + RDX*0x4]
ADD RDX,RSI
switchD:
JMP RDX
caseD_0:
MOV RAX,qword ptr [RAX + R15*0x1]
TEST RAX,RAX
JZ 0x00122e21
MOV RAX,qword ptr [RAX]
ADD RAX,0x9
JMP 0x00122e4d
LAB_00122e21:
MOV EAX,0x9
JMP 0x00122e4d
caseD_7:
MOV EAX,0xc
JMP 0x00122e4d
caseD_a:
MOV EAX,0x5
JMP 0x00122e4d
caseD_b:
MOV EAX,0xd
JMP 0x00122e4d
caseD_1:
LEA RAX,[RCX + RCX*0x2]
LEA RCX,[0x14f2d0]
MOVSXD RAX,dword ptr [RCX + RAX*0x8 + 0x8]
LAB_00122e4d:
XOR R13D,R13D
LAB_00122e50:
MOV R14,qword ptr [RBP + -0x38]
SUB R14,R10
MOV RCX,R12
SUB RCX,R14
ADD RAX,0x14
CMP RCX,RAX
JNC 0x00122e9f
MOV RCX,R12
ADD RCX,R12
ADD RAX,R14
CMP RCX,RAX
MOV R12,RAX
CMOVA R12,RCX
MOV RDI,R10
MOV RSI,R12
CALL 0x00113730
TEST RAX,RAX
JZ 0x00122f1b
MOV R10,RAX
ADD R14,RAX
MOV qword ptr [RBP + -0x38],R14
MOV RDI,qword ptr [RBP + -0x30]
MOV R9,qword ptr [RBP + -0x40]
LAB_00122e9f:
MOV RAX,qword ptr [RDI + 0x70]
MOV RCX,qword ptr [RAX + R15*0x1 + 0x8]
TEST RCX,RCX
JZ 0x00122eb2
CMP byte ptr [RCX],0x0
JNZ 0x00122ee4
LAB_00122eb2:
CMP dword ptr [RAX + R15*0x1 + 0x60],0x6
JZ 0x00122ee4
CMP qword ptr [RAX + R15*0x1 + 0x10],0x0
JZ 0x00122ee4
TEST R13B,R13B
JNZ 0x00122efb
MOV ESI,EBX
LEA RDX,[RBP + -0x38]
XOR ECX,ECX
MOV R14,R10
CALL 0x001227b1
MOV R10,R14
MOV R9,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x00122efb
LAB_00122ee4:
MOV ECX,EBX
AND CL,0x7
MOV AL,0x1
SHL AL,CL
LEA RCX,[R10 + R9*0x1]
MOV RDX,RBX
SHR RDX,0x3
OR byte ptr [RDX + RCX*0x1],AL
LAB_00122efb:
INC RBX
MOV EAX,dword ptr [RDI + 0x64]
ADD R15,0x70
CMP RBX,RAX
JC 0x00122dcf
MOV RBX,qword ptr [RBP + -0x38]
LAB_00122f12:
MOV byte ptr [RDI + 0x68],0x0
SUB RBX,R10
JMP 0x00122f74
LAB_00122f1b:
MOV R14,qword ptr [RBP + -0x30]
MOV dword ptr [R14 + 0x108],0x7d8
LEA RDI,[R14 + 0x30d]
LEA RAX,[0x14ed90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR EBX,EBX
MOV byte ptr [R14 + 0x312],BL
LEA RDI,[R14 + 0x10c]
LEA RAX,[0x14eda0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [R14 + 0x30b],BL
XOR R10D,R10D
LAB_00122f74:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],RBX
MOV RAX,R10
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 * ma_stmt_execute_generate_simple_request(long param_1,long *param_2)
{
char cVar1;
int iVar2;
int4 uVar3;
uint uVar4;
ulong uVar5;
bool bVar6;
int4 *__ptr;
int4 *__ptr_00;
long lVar7;
ulong uVar8;
char *__s;
char *pcVar9;
long lVar10;
size_t __size;
long lVar11;
long lVar12;
char *local_40;
long local_38;
local_38 = param_1;
__ptr = (int4 *)malloc(0x400);
if (__ptr == (int4 *)0x0) {
LAB_00122f1b:
lVar11 = local_38;
*(int4 *)(local_38 + 0x108) = 0x7d8;
strncpy((char *)(local_38 + 0x30d),SQLSTATE_UNKNOWN,5);
lVar10 = 0;
*(int1 *)(lVar11 + 0x312) = 0;
strncpy((char *)(lVar11 + 0x10c),PTR_s_Client_run_out_of_memory_0014ede0,0x200);
*(int1 *)(lVar11 + 0x30b) = 0;
__ptr = (int4 *)0x0;
goto LAB_00122f74;
}
*__ptr = *(int4 *)(local_38 + 0x40);
*(int1 *)(__ptr + 1) = *(int1 *)(local_38 + 0x48);
*(int4 *)((long)__ptr + 5) = 1;
__s = (char *)((long)__ptr + 9);
iVar2 = *(int *)(local_38 + 100);
pcVar9 = __s;
lVar11 = local_38;
if (iVar2 != 0) {
uVar8 = (ulong)(iVar2 + 7U >> 3);
__size = 0x400;
__ptr_00 = __ptr;
if (0x1f1f < iVar2 + 7U) {
__size = uVar8 + 0x41d;
__ptr_00 = (int4 *)realloc(__ptr,__size);
if (__ptr_00 == (int4 *)0x0) goto LAB_00122f1b;
__s = (char *)((long)__ptr_00 + 9);
}
memset(__s,0,uVar8);
cVar1 = *(char *)(local_38 + 0x68);
local_40 = __s + uVar8 + 1;
__s[uVar8] = cVar1;
__ptr = __ptr_00;
if (cVar1 != '\0') {
lVar11 = (long)local_40 - (long)__ptr_00;
if (__size - lVar11 < (ulong)(iVar2 * 2 + 0x14)) {
__size = (ulong)(uint)(iVar2 * 2) + lVar11 + 0x14;
__ptr = (int4 *)realloc(__ptr_00,__size);
if (__ptr == (int4 *)0x0) goto LAB_00122f1b;
local_40 = (char *)(lVar11 + (long)__ptr);
}
lVar11 = 0x30;
uVar8 = 0;
do {
uVar3 = *(int4 *)(*(long *)(local_38 + 0x70) + lVar11 * 2);
cVar1 = *(char *)(*(long *)(local_38 + 0x70) + 5 + lVar11 * 2);
*local_40 = (char)uVar3;
local_40[1] = (byte)(((uint)(cVar1 != '\0') << 0xf) >> 8) | (byte)((uint)uVar3 >> 8);
local_40 = local_40 + 2;
uVar8 = uVar8 + 1;
lVar11 = lVar11 + 0x38;
} while (uVar8 < *(uint *)(local_38 + 100));
pcVar9 = local_40;
lVar11 = local_38;
if (*(uint *)(local_38 + 100) == 0) goto LAB_00122f12;
}
lVar10 = 0;
uVar8 = 0;
lVar11 = local_38;
do {
lVar7 = *(long *)(lVar11 + 0x70);
if (*(char *)(lVar7 + 0x66 + lVar10) == '\0') {
uVar4 = *(uint *)(lVar7 + 0x60 + lVar10);
if (uVar4 - 0xf5 < 0xb) {
switchD_00122e0d_caseD_0:
if (*(long **)(lVar7 + lVar10) == (long *)0x0) {
lVar7 = 9;
}
else {
lVar7 = **(long **)(lVar7 + lVar10) + 9;
}
}
else {
switch(uVar4) {
case 0:
case 0xe:
case 0xf:
case 0x10:
goto switchD_00122e0d_caseD_0;
default:
lVar7 = (long)(int)(&DAT_0014f2d8)[(ulong)uVar4 * 6];
break;
case 6:
goto switchD_00122e0d_caseD_6;
case 7:
case 0xc:
lVar7 = 0xc;
break;
case 10:
lVar7 = 5;
break;
case 0xb:
lVar7 = 0xd;
}
}
bVar6 = false;
}
else {
*(int1 *)(lVar7 + 0x66 + lVar10) = 0;
switchD_00122e0d_caseD_6:
bVar6 = true;
lVar7 = 0;
}
lVar12 = (long)local_40 - (long)__ptr;
if (__size - lVar12 < lVar7 + 0x14U) {
uVar5 = __size * 2;
__size = lVar7 + 0x14U + lVar12;
if (__size < uVar5) {
__size = uVar5;
}
__ptr = (int4 *)realloc(__ptr,__size);
if (__ptr == (int4 *)0x0) goto LAB_00122f1b;
local_40 = (char *)(lVar12 + (long)__ptr);
lVar11 = local_38;
}
lVar7 = *(long *)(lVar11 + 0x70);
pcVar9 = *(char **)(lVar7 + 8 + lVar10);
if ((((pcVar9 == (char *)0x0) || (*pcVar9 == '\0')) && (*(int *)(lVar7 + 0x60 + lVar10) != 6))
&& (*(long *)(lVar7 + 0x10 + lVar10) != 0)) {
if (!bVar6) {
store_param(lVar11,uVar8 & 0xffffffff,&local_40,0);
lVar11 = local_38;
}
}
else {
*(byte *)((long)__ptr + (long)(__s + ((uVar8 >> 3) - (long)__ptr_00))) =
*(byte *)((long)__ptr + (long)(__s + ((uVar8 >> 3) - (long)__ptr_00))) |
'\x01' << ((byte)uVar8 & 7);
}
uVar8 = uVar8 + 1;
lVar10 = lVar10 + 0x70;
pcVar9 = local_40;
} while (uVar8 < *(uint *)(lVar11 + 100));
}
LAB_00122f12:
*(int1 *)(lVar11 + 0x68) = 0;
lVar10 = (long)pcVar9 - (long)__ptr;
LAB_00122f74:
*param_2 = lVar10;
return __ptr;
}
|
|
17,783
|
my_numchars_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_numchars_utf16(CHARSET_INFO *cs,
const char *b, const char *e)
{
size_t nchars= 0;
for ( ; ; nchars++)
{
size_t charlen= my_ismbchar(cs, b, e);
if (!charlen)
break;
b+= charlen;
}
return nchars;
}
|
O0
|
c
|
my_numchars_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6e320
movl %eax, %eax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6abec
jmp 0x6ac06
movq -0x28(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6abcc
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
|
my_numchars_utf16:
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], 0
loc_6ABCC:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_1
mov eax, eax
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_6ABEC
jmp short loc_6AC06
loc_6ABEC:
mov rax, [rbp+var_28]
add rax, [rbp+var_10]
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_6ABCC
loc_6AC06:
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
|
long long my_numchars_utf16(long long a1, long long a2, long long a3)
{
unsigned int v3; // eax
long long i; // [rsp+10h] [rbp-20h]
for ( i = 0LL; ; ++i )
{
v3 = my_ismbchar_1(a1, a2, a3);
if ( !v3 )
break;
a2 += v3;
}
return i;
}
|
my_numchars_utf16:
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],0x0
LAB_0016abcc:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x0016e320
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0016abec
JMP 0x0016ac06
LAB_0016abec:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016abcc
LAB_0016ac06:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
long my_numchars_utf16(int8 param_1,long param_2,int8 param_3)
{
uint uVar1;
int8 local_28;
int8 local_18;
local_28 = 0;
local_18 = param_2;
while( true ) {
uVar1 = my_ismbchar(param_1,local_18,param_3);
if ((ulong)uVar1 == 0) break;
local_18 = (ulong)uVar1 + local_18;
local_28 = local_28 + 1;
}
return local_28;
}
|
|
17,784
|
my_hash_init2
|
eloqsql/mysys/hash.c
|
my_bool
my_hash_init2(PSI_memory_key psi_key, HASH *hash, uint growth_size,
CHARSET_INFO *charset, ulong size, size_t key_offset,
size_t key_length, my_hash_get_key get_key,
my_hash_function hash_function,
void (*free_element)(void*), uint flags)
{
my_bool res;
DBUG_ENTER("my_hash_init2");
DBUG_PRINT("enter",("hash:%p size: %u", hash, (uint) size));
hash->records=0;
hash->key_offset=key_offset;
hash->key_length=key_length;
hash->blength=1;
hash->get_key=get_key;
hash->hash_function= hash_function ? hash_function : my_hash_sort;
hash->free=free_element;
hash->flags=flags;
hash->charset=charset;
res= init_dynamic_array2(psi_key, &hash->array, sizeof(HASH_LINK), NULL, size,
growth_size, MYF((flags & HASH_THREAD_SPECIFIC ?
MY_THREAD_SPECIFIC : 0)));
DBUG_RETURN(res);
}
|
O0
|
c
|
my_hash_init2:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x30(%rbp), %eax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x33d73
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x1, 0x10(%rax)
movq 0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
cmpq $0x0, 0x20(%rbp)
je 0x33dbf
movq 0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33dcc
leaq -0x126(%rip), %rax # 0x33ca0
movq %rax, -0x40(%rbp)
jmp 0x33dcc
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq 0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movl 0x30(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x68(%rax)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rax
movl %eax, %r8d
movl -0x14(%rbp), %r9d
movl 0x30(%rbp), %edx
andl $0x2, %edx
xorl %eax, %eax
movl $0x10000, %ecx # imm = 0x10000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, %eax
movl $0x10, %edx
xorl %ecx, %ecx
movq %rax, (%rsp)
callq 0x39dd0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_hash_init2:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_20]
mov rax, [rbp+arg_18]
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_33D73:
mov rax, [rbp+var_10]
mov qword ptr [rax+18h], 0
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov qword ptr [rax+10h], 1
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_10]
mov [rax+50h], rcx
cmp [rbp+arg_10], 0
jz short loc_33DBF
mov rax, [rbp+arg_10]
mov [rbp+var_40], rax
jmp short loc_33DCC
loc_33DBF:
lea rax, my_hash_sort
mov [rbp+var_40], rax
jmp short $+2
loc_33DCC:
mov rcx, [rbp+var_40]
mov rax, [rbp+var_10]
mov [rax+58h], rcx
mov rcx, [rbp+arg_18]
mov rax, [rbp+var_10]
mov [rax+60h], rcx
mov ecx, [rbp+arg_20]
mov rax, [rbp+var_10]
mov [rax+20h], ecx
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax+68h], rcx
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
add rsi, 28h ; '('
mov rax, [rbp+var_28]
mov r8d, eax
mov r9d, [rbp+var_14]
mov edx, [rbp+arg_20]
and edx, 2
xor eax, eax
mov ecx, 10000h
cmp edx, 0
cmovnz eax, ecx
mov eax, eax
mov edx, 10h
xor ecx, ecx
mov [rsp+50h+var_50], rax
call init_dynamic_array2
mov [rbp+var_31], al
mov al, [rbp+var_31]
mov [rbp+var_41], al
mov al, [rbp+var_41]
add rsp, 50h
pop rbp
retn
|
long long my_hash_init2(
int a1,
long long a2,
int a3,
long long a4,
int a5,
long long a6,
long long a7,
long long a8,
long long ( *a9)(long long a1, long long a2, long long a3),
long long a10,
int a11)
{
int v11; // esi
unsigned int v12; // eax
long long ( *v14)(long long, long long, long long); // [rsp+10h] [rbp-40h]
*(_QWORD *)(a2 + 24) = 0LL;
*(_QWORD *)a2 = a6;
*(_QWORD *)(a2 + 8) = a7;
*(_QWORD *)(a2 + 16) = 1LL;
*(_QWORD *)(a2 + 80) = a8;
if ( a9 )
v14 = a9;
else
v14 = my_hash_sort;
*(_QWORD *)(a2 + 88) = v14;
*(_QWORD *)(a2 + 96) = a10;
*(_DWORD *)(a2 + 32) = a11;
*(_QWORD *)(a2 + 104) = a4;
v11 = a2 + 40;
v12 = 0;
if ( (a11 & 2) != 0 )
v12 = 0x10000;
return init_dynamic_array2(a1, v11, 16, 0, a5, a3, v12);
}
|
my_hash_init2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV EAX,dword ptr [RBP + 0x30]
MOV RAX,qword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x00133d73
LAB_00133d73:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],0x0
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],0x1
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x50],RCX
CMP qword ptr [RBP + 0x20],0x0
JZ 0x00133dbf
MOV RAX,qword ptr [RBP + 0x20]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00133dcc
LAB_00133dbf:
LEA RAX,[0x133ca0]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00133dcc
LAB_00133dcc:
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x58],RCX
MOV RCX,qword ptr [RBP + 0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x60],RCX
MOV ECX,dword ptr [RBP + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x20],ECX
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x68],RCX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x28
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + -0x14]
MOV EDX,dword ptr [RBP + 0x30]
AND EDX,0x2
XOR EAX,EAX
MOV ECX,0x10000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV EAX,EAX
MOV EDX,0x10
XOR ECX,ECX
MOV qword ptr [RSP],RAX
CALL 0x00139dd0
MOV byte ptr [RBP + -0x31],AL
MOV AL,byte ptr [RBP + -0x31]
MOV byte ptr [RBP + -0x41],AL
MOV AL,byte ptr [RBP + -0x41]
ADD RSP,0x50
POP RBP
RET
|
int8
my_hash_init2(int4 param_1,int8 *param_2,int4 param_3,int8 param_4,
int4 param_5,int8 param_6,int8 param_7,int8 param_8,
code *param_9,int8 param_10,uint param_11)
{
int4 uVar1;
int8 uVar2;
code *local_48;
param_2[3] = 0;
*param_2 = param_6;
param_2[1] = param_7;
param_2[2] = 1;
param_2[10] = param_8;
if (param_9 == (code *)0x0) {
local_48 = my_hash_sort;
}
else {
local_48 = param_9;
}
param_2[0xb] = local_48;
param_2[0xc] = param_10;
*(uint *)(param_2 + 4) = param_11;
param_2[0xd] = param_4;
uVar1 = 0;
if ((param_11 & 2) != 0) {
uVar1 = 0x10000;
}
uVar2 = init_dynamic_array2(param_1,param_2 + 5,0x10,0,param_5,param_3,uVar1);
return uVar2;
}
|
|
17,785
|
blst_sign_pk2_in_g1
|
corpus-core[P]colibri-stateless/build_O0/_deps/blst-src/src/e2.c
|
void blst_sign_pk2_in_g1(unsigned char out[192], POINTonE2_affine *sig,
const POINTonE2 *hash, const pow256 SK)
{
POINTonE2 P[1];
POINTonE2_sign(P, hash, SK);
if (sig != NULL)
vec_copy(sig, P, sizeof(*sig));
if (out != NULL) {
limb_t sgn0_pty = POINTonE2_Serialize_BE(out, P);
out[0] |= (sgn0_pty & 2) << 4; /* pre-decorate */
out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;
}
}
|
O0
|
c
|
blst_sign_pk2_in_g1:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xad8d0
cmpq $0x0, -0x10(%rbp)
je 0xadb6b
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
movl $0xc0, %edx
callq 0xa8ad0
cmpq $0x0, -0x8(%rbp)
je 0xadbcf
movq -0x8(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0xadab0
movq %rax, -0x148(%rbp)
movq -0x148(%rbp), %rdx
andq $0x2, %rdx
shlq $0x4, %rdx
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
orq %rdx, %rcx
movb %cl, (%rax)
leaq -0x140(%rbp), %rdi
addq $0xc0, %rdi
movl $0x60, %esi
callq 0xa8cd0
movq %rax, %rdx
shlq $0x6, %rdx
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
orq %rdx, %rcx
movb %cl, (%rax)
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
nopl (%rax,%rax)
|
blst_sign_pk2_in_g1:
push rbp
mov rbp, rsp
sub rsp, 150h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
lea rdi, [rbp+var_140]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call POINTonE2_sign
cmp [rbp+var_10], 0
jz short loc_ADB6B
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_140]
mov edx, 0C0h
call vec_copy
loc_ADB6B:
cmp [rbp+var_8], 0
jz short loc_ADBCF
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_140]
call POINTonE2_Serialize_BE
mov [rbp+var_148], rax
mov rdx, [rbp+var_148]
and rdx, 2
shl rdx, 4
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax]
or rcx, rdx
mov [rax], cl
lea rdi, [rbp+var_140]
add rdi, 0C0h
mov esi, 60h ; '`'
call vec_is_zero
mov rdx, rax
shl rdx, 6
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax]
or rcx, rdx
mov [rax], cl
loc_ADBCF:
add rsp, 150h
pop rbp
retn
|
_BYTE * blst_sign_pk2_in_g1(_BYTE *a1, long long a2, long long a3, long long a4)
{
_BYTE *result; // rax
char v5; // dl
char v6; // [rsp+8h] [rbp-148h]
_BYTE v7[192]; // [rsp+10h] [rbp-140h] BYREF
_QWORD v8[14]; // [rsp+D0h] [rbp-80h] BYREF
long long v9; // [rsp+140h] [rbp-10h]
_BYTE *v10; // [rsp+148h] [rbp-8h]
v10 = a1;
v9 = a2;
v8[13] = a3;
v8[12] = a4;
result = (_BYTE *)POINTonE2_sign((long long)v7, a3, a4);
if ( v9 )
result = (_BYTE *)vec_copy(v9, (long long)v7, 0xC0uLL);
if ( v10 )
{
v6 = POINTonE2_Serialize_BE((long long)v10, (long long)v7);
*v10 |= 16 * (v6 & 2);
v5 = (unsigned __int8)vec_is_zero((long long)v8, 0x60uLL) << 6;
result = v10;
*v10 |= v5;
}
return result;
}
|
blst_sign_pk2_in_g1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
LEA RDI,[RBP + -0x140]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001ad8d0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001adb6b
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x140]
MOV EDX,0xc0
CALL 0x001a8ad0
LAB_001adb6b:
CMP qword ptr [RBP + -0x8],0x0
JZ 0x001adbcf
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x140]
CALL 0x001adab0
MOV qword ptr [RBP + -0x148],RAX
MOV RDX,qword ptr [RBP + -0x148]
AND RDX,0x2
SHL RDX,0x4
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX]
OR RCX,RDX
MOV byte ptr [RAX],CL
LEA RDI,[RBP + -0x140]
ADD RDI,0xc0
MOV ESI,0x60
CALL 0x001a8cd0
MOV RDX,RAX
SHL RDX,0x6
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX]
OR RCX,RDX
MOV byte ptr [RAX],CL
LAB_001adbcf:
ADD RSP,0x150
POP RBP
RET
|
void blst_sign_pk2_in_g1(byte *param_1,long param_2,int8 param_3,int8 param_4)
{
ulong uVar1;
long lVar2;
int1 local_148 [192];
int1 auStack_88 [96];
int8 local_28;
int8 local_20;
long local_18;
byte *local_10;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
POINTonE2_sign(local_148,param_3,param_4);
if (local_18 != 0) {
vec_copy(local_18,local_148,0xc0);
}
if (local_10 != (byte *)0x0) {
uVar1 = POINTonE2_Serialize_BE(local_10,local_148);
*local_10 = *local_10 | (byte)((uVar1 & 2) << 4);
lVar2 = vec_is_zero(auStack_88,0x60);
*local_10 = *local_10 | (byte)(lVar2 << 6);
}
return;
}
|
|
17,786
|
ma_apply_redo_free_blocks
|
eloqsql/storage/maria/ma_blockrec.c
|
uint _ma_apply_redo_free_blocks(MARIA_HA *info,
LSN lsn __attribute__((unused)),
LSN redo_lsn,
const uchar *header)
{
MARIA_SHARE *share= info->s;
uint ranges;
uint16 sid;
DBUG_ENTER("_ma_apply_redo_free_blocks");
share->state.changed|= (STATE_CHANGED | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
sid= fileid_korr(header);
header+= FILEID_STORE_SIZE;
ranges= pagerange_korr(header);
header+= PAGERANGE_STORE_SIZE;
DBUG_ASSERT(ranges > 0);
/** @todo leave bitmap lock to the bitmap code... */
mysql_mutex_lock(&share->bitmap.bitmap_lock);
while (ranges--)
{
my_bool res;
uint page_range;
pgcache_page_no_t page, start_page;
start_page= page= page_korr(header);
header+= PAGE_STORE_SIZE;
/* Page range may have this bit set to indicate a tail page */
page_range= pagerange_korr(header) & ~(TAIL_BIT | START_EXTENT_BIT);
DBUG_ASSERT(page_range > 0);
header+= PAGERANGE_STORE_SIZE;
DBUG_PRINT("info", ("page: %lu pages: %u", (long) page, page_range));
for ( ; page_range-- ; start_page++)
{
if (_ma_redo_not_needed_for_page(sid, redo_lsn, start_page, FALSE))
continue;
res= _ma_bitmap_reset_full_page_bits(info, &share->bitmap, start_page,
1);
if (res)
{
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
_ma_mark_file_crashed(share);
DBUG_ASSERT(!maria_assert_if_crashed_table);
DBUG_RETURN(res);
}
}
}
mysql_mutex_unlock(&share->bitmap.bitmap_lock);
DBUG_RETURN(0);
}
|
O0
|
c
|
ma_apply_redo_free_blocks:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x181, %ecx # imm = 0x181
movl %ecx, 0x170(%rax)
movq -0x28(%rbp), %rax
movw (%rax), %ax
movw %ax, -0x36(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x7ac28
movq -0x30(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xd7e0b(%rip), %rsi # 0x152a4c
movl $0x1a2a, %edx # imm = 0x1A2A
callq 0x7ad60
movl -0x34(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x34(%rbp)
cmpl $0x0, %eax
je 0x7ad38
movq -0x28(%rbp), %rdi
callq 0x7a040
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
andl $0xffff3fff, %eax # imm = 0xFFFF3FFF
movl %eax, -0x3c(%rbp)
jmp 0x7ac8d
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
jmp 0x7ac9b
jmp 0x7ac9d
movl -0x3c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x7ad33
movw -0x36(%rbp), %ax
movq -0x20(%rbp), %rsi
movq -0x50(%rbp), %rdx
xorl %ecx, %ecx
movzwl %ax, %edi
callq 0x5dc70
cmpb $0x0, %al
je 0x7accd
jmp 0x7ad22
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0xa10, %rsi # imm = 0xA10
movq -0x50(%rbp), %rdx
movl $0x1, %ecx
callq 0x43450
movb %al, -0x37(%rbp)
cmpb $0x0, -0x37(%rbp)
je 0x7ad20
movq -0x30(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x7add0
movq -0x30(%rbp), %rdi
callq 0x36250
jmp 0x7ad15
jmp 0x7ad17
movsbl -0x37(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ad56
jmp 0x7ad22
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x7ac9d
jmp 0x7ac4b
movq -0x30(%rbp), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x7add0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
|
_ma_apply_redo_free_blocks:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov ecx, [rax+170h]
or ecx, 181h
mov [rax+170h], ecx
mov rax, [rbp+var_28]
mov ax, [rax]
mov [rbp+var_36], ax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movzx eax, word ptr [rax]
mov [rbp+var_34], eax
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short $+2
loc_7AC28:
mov rdi, [rbp+var_30]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 1A2Ah
call inline_mysql_mutex_lock_14
loc_7AC4B:
mov eax, [rbp+var_34]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_34], ecx
cmp eax, 0
jz loc_7AD38
mov rdi, [rbp+var_28]
call uint5korr_1
mov [rbp+var_48], rax
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
add rax, 5
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
movzx eax, word ptr [rax]
and eax, 0FFFF3FFFh
mov [rbp+var_3C], eax
jmp short $+2
loc_7AC8D:
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
jmp short $+2
loc_7AC9B:
jmp short $+2
loc_7AC9D:
mov eax, [rbp+var_3C]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_3C], ecx
cmp eax, 0
jz loc_7AD33
mov ax, [rbp+var_36]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_50]
xor ecx, ecx
movzx edi, ax
call _ma_redo_not_needed_for_page
cmp al, 0
jz short loc_7ACCD
jmp short loc_7AD22
loc_7ACCD:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
add rsi, 0A10h
mov rdx, [rbp+var_50]
mov ecx, 1
call _ma_bitmap_reset_full_page_bits
mov [rbp+var_37], al
cmp [rbp+var_37], 0
jz short loc_7AD20
mov rdi, [rbp+var_30]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_14
mov rdi, [rbp+var_30]
call _ma_mark_file_crashed
jmp short $+2
loc_7AD15:
jmp short $+2
loc_7AD17:
movsx eax, [rbp+var_37]
mov [rbp+var_4], eax
jmp short loc_7AD56
loc_7AD20:
jmp short $+2
loc_7AD22:
mov rax, [rbp+var_50]
add rax, 1
mov [rbp+var_50], rax
jmp loc_7AC9D
loc_7AD33:
jmp loc_7AC4B
loc_7AD38:
mov rdi, [rbp+var_30]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_14
mov [rbp+var_4], 0
loc_7AD56:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long ma_apply_redo_free_blocks(
long long *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9,
long long a10,
long long a11,
unsigned __int16 *a12)
{
double v13; // xmm4_8
double v14; // xmm5_8
unsigned long long v17; // [rsp+0h] [rbp-50h]
int v18; // [rsp+14h] [rbp-3Ch]
char v19; // [rsp+19h] [rbp-37h]
unsigned __int16 v20; // [rsp+1Ah] [rbp-36h]
int v21; // [rsp+1Ch] [rbp-34h]
long long v22; // [rsp+20h] [rbp-30h]
unsigned int *v23; // [rsp+28h] [rbp-28h]
_WORD *v24; // [rsp+28h] [rbp-28h]
v22 = *a1;
*(_DWORD *)(*a1 + 368) |= 0x181u;
v20 = *a12;
v21 = a12[1];
v23 = (unsigned int *)(a12 + 2);
inline_mysql_mutex_lock_14(v22 + 2712, "/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c", 6698LL);
while ( v21-- )
{
v17 = uint5korr_1(v23);
v24 = (_WORD *)((char *)v23 + 5);
v18 = *v24 & 0x3FFF;
v23 = (unsigned int *)(v24 + 1);
while ( v18-- )
{
if ( !ma_redo_not_needed_for_page(v20, a11, v17, 0, a2, a3, a4, a5, v13, v14, a8, a9) )
{
v19 = ma_bitmap_reset_full_page_bits(a1, v22 + 2576, v17, 1);
if ( v19 )
{
inline_mysql_mutex_unlock_14(v22 + 2712);
ma_mark_file_crashed(v22);
return (unsigned int)v19;
}
}
++v17;
}
}
inline_mysql_mutex_unlock_14(v22 + 2712);
return 0;
}
|
_ma_apply_redo_free_blocks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x181
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV AX,word ptr [RAX]
MOV word ptr [RBP + -0x36],AX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017ac28
LAB_0017ac28:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x252a4c]
MOV EDX,0x1a2a
CALL 0x0017ad60
LAB_0017ac4b:
MOV EAX,dword ptr [RBP + -0x34]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x34],ECX
CMP EAX,0x0
JZ 0x0017ad38
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0017a040
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x5
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX]
AND EAX,0xffff3fff
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0017ac8d
LAB_0017ac8d:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0017ac9b
LAB_0017ac9b:
JMP 0x0017ac9d
LAB_0017ac9d:
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
ADD ECX,-0x1
MOV dword ptr [RBP + -0x3c],ECX
CMP EAX,0x0
JZ 0x0017ad33
MOV AX,word ptr [RBP + -0x36]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x50]
XOR ECX,ECX
MOVZX EDI,AX
CALL 0x0015dc70
CMP AL,0x0
JZ 0x0017accd
JMP 0x0017ad22
LAB_0017accd:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
ADD RSI,0xa10
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,0x1
CALL 0x00143450
MOV byte ptr [RBP + -0x37],AL
CMP byte ptr [RBP + -0x37],0x0
JZ 0x0017ad20
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x0017add0
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00136250
JMP 0x0017ad15
LAB_0017ad15:
JMP 0x0017ad17
LAB_0017ad17:
MOVSX EAX,byte ptr [RBP + -0x37]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017ad56
LAB_0017ad20:
JMP 0x0017ad22
LAB_0017ad22:
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x1
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0017ac9d
LAB_0017ad33:
JMP 0x0017ac4b
LAB_0017ad38:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x0017add0
MOV dword ptr [RBP + -0x4],0x0
LAB_0017ad56:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int _ma_apply_redo_free_blocks
(long *param_1,int8 param_2,int8 param_3,int2 *param_4)
{
int2 uVar1;
ushort uVar2;
long lVar3;
char cVar4;
ushort *puVar5;
uint uVar6;
long local_58;
uint local_44;
uint local_3c;
int2 *local_30;
lVar3 = *param_1;
*(uint *)(lVar3 + 0x170) = *(uint *)(lVar3 + 0x170) | 0x181;
uVar1 = *param_4;
uVar2 = param_4[1];
local_30 = param_4 + 2;
inline_mysql_mutex_lock
(lVar3 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_blockrec.c",
0x1a2a);
local_3c = (uint)uVar2;
do {
uVar6 = local_3c - 1;
if (local_3c == 0) {
inline_mysql_mutex_unlock(lVar3 + 0xa98);
return 0;
}
local_58 = uint5korr(local_30);
puVar5 = (ushort *)((long)local_30 + 5);
local_30 = (int2 *)((long)local_30 + 7);
local_44 = *puVar5 & 0xffff3fff;
while (local_3c = uVar6, local_44 != 0) {
cVar4 = _ma_redo_not_needed_for_page(uVar1,param_3,local_58,0);
if ((cVar4 == '\0') &&
(cVar4 = _ma_bitmap_reset_full_page_bits(param_1,lVar3 + 0xa10,local_58,1), cVar4 != '\0'))
{
inline_mysql_mutex_unlock(lVar3 + 0xa98);
_ma_mark_file_crashed(lVar3);
return (int)cVar4;
}
local_58 = local_58 + 1;
local_44 = local_44 - 1;
}
} while( true );
}
|
|
17,787
|
get_cpu_info[abi:cxx11]()
|
monkey531[P]llama/examples/llama-bench/llama-bench.cpp
|
static std::string get_cpu_info() {
std::vector<std::string> cpu_list;
for (size_t i = 0; i < ggml_backend_dev_count(); i++) {
auto * dev = ggml_backend_dev_get(i);
auto dev_type = ggml_backend_dev_type(dev);
if (dev_type == GGML_BACKEND_DEVICE_TYPE_CPU || dev_type == GGML_BACKEND_DEVICE_TYPE_ACCEL) {
cpu_list.push_back(ggml_backend_dev_description(dev));
}
}
return join(cpu_list, ", ");
}
|
O0
|
cpp
|
get_cpu_info[abi:cxx11]():
subq $0xe8, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xe0(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x67c10
movq $0x0, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x56b70
movq %rax, 0x38(%rsp)
jmp 0x5c12e
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x5c27e
movq 0xc0(%rsp), %rdi
callq 0x567f0
movq %rax, 0x28(%rsp)
jmp 0x5c155
movq 0x28(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x568f0
movl %eax, 0x24(%rsp)
jmp 0x5c175
movl 0x24(%rsp), %eax
movl %eax, 0xa4(%rsp)
cmpl $0x0, 0xa4(%rsp)
je 0x5c198
cmpl $0x2, 0xa4(%rsp)
jne 0x5c263
movq 0xa8(%rsp), %rdi
callq 0x56a20
movq %rax, 0x18(%rsp)
jmp 0x5c1ac
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x56f00
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x66600
jmp 0x5c1d4
leaq 0xc8(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x67c20
jmp 0x5c1eb
leaq 0x80(%rsp), %rdi
callq 0x572d0
leaq 0x7f(%rsp), %rdi
callq 0x572b0
jmp 0x5c263
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5c32a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5c254
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x572d0
leaq 0x7f(%rsp), %rdi
callq 0x572b0
jmp 0x5c32a
jmp 0x5c265
movq 0xc0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xc0(%rsp)
jmp 0x5c115
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x56f00
movq 0x8(%rsp), %rdx
leaq 0x18af70(%rip), %rsi # 0x1e7209
leaq 0x58(%rsp), %rdi
callq 0x66600
jmp 0x5c2a5
movq 0x40(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x63670
jmp 0x5c2be
leaq 0x58(%rsp), %rdi
callq 0x572d0
leaq 0x57(%rsp), %rdi
callq 0x572b0
leaq 0xc8(%rsp), %rdi
callq 0x66d00
movq 0x48(%rsp), %rax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x5c320
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x572d0
leaq 0x57(%rsp), %rdi
callq 0x572b0
leaq 0xc8(%rsp), %rdi
callq 0x66d00
movq 0xb8(%rsp), %rdi
callq 0x56a10
nopw %cs:(%rax,%rax)
|
_ZL12get_cpu_infoB5cxx11v:
sub rsp, 0E8h
mov [rsp+0E8h+var_A8], rdi
mov rax, rdi
mov [rsp+0E8h+var_A0], rax
mov [rsp+0E8h+var_8], rdi
lea rdi, [rsp+0E8h+var_20]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2Ev; std::vector<std::string>::vector(void)
mov [rsp+0E8h+var_28], 0
loc_5C115:
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_B8], rax
call _ggml_backend_dev_count
mov [rsp+0E8h+var_B0], rax
jmp short $+2
loc_5C12E:
mov rax, [rsp+0E8h+var_B8]
mov rcx, [rsp+0E8h+var_B0]
cmp rax, rcx
jnb loc_5C27E
mov rdi, [rsp+0E8h+var_28]
call _ggml_backend_dev_get
mov [rsp+0E8h+var_C0], rax
jmp short $+2
loc_5C155:
mov rax, [rsp+0E8h+var_C0]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_40]
call _ggml_backend_dev_type
mov [rsp+0E8h+var_C4], eax
jmp short $+2
loc_5C175:
mov eax, [rsp+0E8h+var_C4]
mov [rsp+0E8h+var_44], eax
cmp [rsp+0E8h+var_44], 0
jz short loc_5C198
cmp [rsp+0E8h+var_44], 2
jnz loc_5C263
loc_5C198:
mov rdi, [rsp+0E8h+var_40]
call _ggml_backend_dev_description
mov [rsp+0E8h+var_D0], rax
jmp short $+2
loc_5C1AC:
lea rdi, [rsp+0E8h+var_69]
mov [rsp+0E8h+var_D8], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+0E8h+var_D0]
mov rdx, [rsp+0E8h+var_D8]
lea rdi, [rsp+0E8h+var_68]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_5C1D4:
lea rdi, [rsp+0E8h+var_20]
lea rsi, [rsp+0E8h+var_68]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE9push_backEOS5_; std::vector<std::string>::push_back(std::string&&)
jmp short $+2
loc_5C1EB:
lea rdi, [rsp+0E8h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_69]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp short loc_5C263
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
jmp loc_5C32A
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
jmp short loc_5C254
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_5C254:
lea rdi, [rsp+arg_77]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_5C32A
loc_5C263:
jmp short $+2
loc_5C265:
mov rax, [rsp+0E8h+var_28]
add rax, 1
mov [rsp+0E8h+var_28], rax
jmp loc_5C115
loc_5C27E:
lea rdi, [rsp+0E8h+var_91]
mov [rsp+0E8h+var_E0], rdi
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, [rsp+0E8h+var_E0]
lea rsi, aZuD+6; ", "
lea rdi, [rsp+0E8h+var_90]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_5C2A5:
mov rdi, [rsp+0E8h+var_A8]
lea rsi, [rsp+0E8h+var_20]
lea rdx, [rsp+0E8h+var_90]
call _ZL4joinINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEES5_RKSt6vectorIT_SaIS7_EERKS5_; join<std::string>(std::vector<std::string> const&,std::string const&)
jmp short $+2
loc_5C2BE:
lea rdi, [rsp+0E8h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+0E8h+var_91]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
lea rdi, [rsp+0E8h+var_20]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+0E8h+var_A0]
add rsp, 0E8h
retn
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
jmp short loc_5C320
mov rcx, rax
mov eax, edx
mov [rsp+arg_B0], rcx
mov [rsp+arg_AC], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_5C320:
lea rdi, [rsp+arg_4F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
loc_5C32A:
lea rdi, [rsp+arg_C0]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_B0]
call __Unwind_Resume
|
long long get_cpu_info[abi:cxx11](long long a1)
{
int v1; // ecx
int v2; // r8d
int v3; // r9d
int v4; // ecx
int v5; // r8d
int v6; // r9d
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v11; // [rsp+18h] [rbp-D0h]
unsigned long long v12; // [rsp+30h] [rbp-B8h]
char v13; // [rsp+57h] [rbp-91h] BYREF
_BYTE v14[39]; // [rsp+58h] [rbp-90h] BYREF
char v15; // [rsp+7Fh] [rbp-69h] BYREF
_BYTE v16[36]; // [rsp+80h] [rbp-68h] BYREF
int v17; // [rsp+A4h] [rbp-44h]
long long v18; // [rsp+A8h] [rbp-40h]
unsigned long long i; // [rsp+C0h] [rbp-28h]
_BYTE v20[24]; // [rsp+C8h] [rbp-20h] BYREF
long long v21; // [rsp+E0h] [rbp-8h]
v21 = a1;
std::vector<std::string>::vector(v20);
for ( i = 0LL; ; ++i )
{
v12 = i;
if ( v12 >= ggml_backend_dev_count() )
break;
v18 = ggml_backend_dev_get(i);
v17 = ggml_backend_dev_type(v18);
if ( !v17 || v17 == 2 )
{
v11 = ggml_backend_dev_description(v18);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((unsigned int)v16, v11, (unsigned int)&v15, v1, v2, v3);
std::vector<std::string>::push_back(v20, v16);
std::string::~string(v16);
std::allocator<char>::~allocator(&v15);
}
}
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((unsigned int)v14, (unsigned int)", ", (unsigned int)&v13, v4, v5, v6);
join<std::string>(a1, (unsigned int)v20, (unsigned int)v14, v7, v8, v9);
std::string::~string(v14);
std::allocator<char>::~allocator(&v13);
std::vector<std::string>::~vector(v20);
return a1;
}
|
get_cpu_info[abi:cxx11]:
SUB RSP,0xe8
MOV qword ptr [RSP + 0x40],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x48],RAX
MOV qword ptr [RSP + 0xe0],RDI
LEA RDI,[RSP + 0xc8]
CALL 0x00167c10
MOV qword ptr [RSP + 0xc0],0x0
LAB_0015c115:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x30],RAX
LAB_0015c122:
CALL 0x00156b70
MOV qword ptr [RSP + 0x38],RAX
JMP 0x0015c12e
LAB_0015c12e:
MOV RAX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
CMP RAX,RCX
JNC 0x0015c27e
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x001567f0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x0015c155
LAB_0015c155:
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001568f0
MOV dword ptr [RSP + 0x24],EAX
JMP 0x0015c175
LAB_0015c175:
MOV EAX,dword ptr [RSP + 0x24]
MOV dword ptr [RSP + 0xa4],EAX
CMP dword ptr [RSP + 0xa4],0x0
JZ 0x0015c198
CMP dword ptr [RSP + 0xa4],0x2
JNZ 0x0015c263
LAB_0015c198:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x00156a20
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0015c1ac
LAB_0015c1ac:
LEA RDI,[RSP + 0x7f]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00156f00
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
LAB_0015c1c5:
LEA RDI,[RSP + 0x80]
CALL 0x00166600
JMP 0x0015c1d4
LAB_0015c1d4:
LEA RDI,[RSP + 0xc8]
LEA RSI,[RSP + 0x80]
CALL 0x00167c20
JMP 0x0015c1eb
LAB_0015c1eb:
LEA RDI,[RSP + 0x80]
CALL 0x001572d0
LEA RDI,[RSP + 0x7f]
CALL 0x001572b0
JMP 0x0015c263
LAB_0015c263:
JMP 0x0015c265
LAB_0015c265:
MOV RAX,qword ptr [RSP + 0xc0]
ADD RAX,0x1
MOV qword ptr [RSP + 0xc0],RAX
JMP 0x0015c115
LAB_0015c27e:
LEA RDI,[RSP + 0x57]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x00156f00
MOV RDX,qword ptr [RSP + 0x8]
LAB_0015c292:
LEA RSI,[0x2e7209]
LEA RDI,[RSP + 0x58]
CALL 0x00166600
JMP 0x0015c2a5
LAB_0015c2a5:
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[RSP + 0xc8]
LEA RDX,[RSP + 0x58]
CALL 0x00163670
LAB_0015c2bc:
JMP 0x0015c2be
LAB_0015c2be:
LEA RDI,[RSP + 0x58]
CALL 0x001572d0
LEA RDI,[RSP + 0x57]
CALL 0x001572b0
LEA RDI,[RSP + 0xc8]
CALL 0x00166d00
MOV RAX,qword ptr [RSP + 0x48]
ADD RSP,0xe8
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* get_cpu_info[abi:cxx11]() */
vector * get_cpu_info_abi_cxx11_(void)
{
ulong uVar1;
ulong uVar2;
char *pcVar3;
vector *in_RDI;
allocator local_91;
string local_90 [39];
allocator local_69;
string local_68 [36];
int local_44;
int8 local_40;
ulong local_28;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_20 [32];
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector(local_20);
local_28 = 0;
while( true ) {
uVar1 = local_28;
/* try { // try from 0015c122 to 0015c1a4 has its CatchHandler @ 0015c204 */
uVar2 = ggml_backend_dev_count();
if (uVar2 <= uVar1) break;
local_40 = ggml_backend_dev_get(local_28);
local_44 = ggml_backend_dev_type(local_40);
if ((local_44 == 0) || (local_44 == 2)) {
pcVar3 = (char *)ggml_backend_dev_description(local_40);
std::allocator<char>::allocator();
/* try { // try from 0015c1c5 to 0015c1d1 has its CatchHandler @ 0015c21d */
std::__cxx11::string::string<std::allocator<char>>(local_68,pcVar3,&local_69);
/* try { // try from 0015c1d4 to 0015c1e8 has its CatchHandler @ 0015c233 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::push_back
(local_20,local_68);
std::__cxx11::string::~string(local_68);
std::allocator<char>::~allocator((allocator<char> *)&local_69);
}
local_28 = local_28 + 1;
}
std::allocator<char>::allocator();
/* try { // try from 0015c292 to 0015c2a2 has its CatchHandler @ 0015c2ec */
std::__cxx11::string::string<std::allocator<char>>(local_90,", ",&local_91);
/* try { // try from 0015c2a5 to 0015c2bb has its CatchHandler @ 0015c302 */
join<std::__cxx11::string>(in_RDI,(string *)local_20);
std::__cxx11::string::~string(local_90);
std::allocator<char>::~allocator((allocator<char> *)&local_91);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_20);
return in_RDI;
}
|
|
17,788
|
blst_p1_on_curve
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/e1.c
|
int blst_p1_on_curve(const POINTonE1 *p)
{ return (int)POINTonE1_on_curve(p); }
|
O3
|
c
|
blst_p1_on_curve:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
leaq 0x60(%rdi), %rbx
movl $0x30, %esi
movq %rbx, %rdi
callq 0x70940
movq %rax, -0x30(%rbp)
leaq 0x33604(%rip), %r15 # 0x8cca0
leaq -0x60(%rbp), %r13
movabsq $-0x760c000300030003, %r12 # imm = 0x89F3FFFCFFFCFFFD
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x74720
movq %r13, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x74ea0
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x74720
movl $0x2, %edx
movq %r13, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x6f940
leaq -0xc0(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x74720
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x74ea0
movq %rbx, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x6f640
addq $0x30, %r14
leaq -0x90(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x74720
movl $0x30, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x70980
orl -0x30(%rbp), %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
blst_p1_on_curve:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov r14, rdi
lea rbx, [rdi+60h]
mov esi, 30h ; '0'
mov rdi, rbx
call vec_is_zero_16x
mov [rbp+var_30], rax
lea r15, BLS12_381_P
lea r13, [rbp+var_60]
mov r12, 89F3FFFCFFFCFFFDh
mov rdi, r13
mov rsi, rbx
mov rdx, r15
mov rcx, r12
call sqr_mont_384
mov rdi, r13
mov rsi, r13
mov rdx, rbx
mov rcx, r15
mov r8, r12
call mul_mont_384
mov rdi, r13
mov rsi, r13
mov rdx, r15
mov rcx, r12
call sqr_mont_384
mov edx, 2
mov rdi, r13
mov rsi, r13
mov rcx, r15
call lshift_mod_384
lea rbx, [rbp+var_C0]
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, r12
call sqr_mont_384
mov rdi, rbx
mov rsi, rbx
mov rdx, r14
mov rcx, r15
mov r8, r12
call mul_mont_384
mov rdi, rbx
mov rsi, rbx
mov rdx, r13
mov rcx, r15
call add_mod_384
add r14, 30h ; '0'
lea r13, [rbp+var_90]
mov rdi, r13
mov rsi, r14
mov rdx, r15
mov rcx, r12
call sqr_mont_384
mov edx, 30h ; '0'
mov rdi, rbx
mov rsi, r13
call vec_is_equal_16x
or eax, dword ptr [rbp+var_30]
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long blst_p1_on_curve(long long a1)
{
int is_equal_16x; // eax
_BYTE v3[48]; // [rsp+0h] [rbp-C0h] BYREF
_BYTE v4[48]; // [rsp+30h] [rbp-90h] BYREF
_BYTE v5[48]; // [rsp+60h] [rbp-60h] BYREF
long long is_zero_16x; // [rsp+90h] [rbp-30h]
is_zero_16x = vec_is_zero_16x(a1 + 96, 48LL);
sqr_mont_384(v5, a1 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v5, v5, a1 + 96, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
sqr_mont_384(v5, v5, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
lshift_mod_384(v5, v5, 2LL, &BLS12_381_P);
sqr_mont_384(v3, a1, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
mul_mont_384(v3, v3, a1, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
add_mod_384(v3, v3, v5, &BLS12_381_P);
sqr_mont_384(v4, a1 + 48, &BLS12_381_P, 0x89F3FFFCFFFCFFFDLL);
is_equal_16x = vec_is_equal_16x(v3, v4, 48LL);
return (unsigned int)is_zero_16x | is_equal_16x;
}
|
blst_p1_on_curve:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R14,RDI
LEA RBX,[RDI + 0x60]
MOV ESI,0x30
MOV RDI,RBX
CALL 0x00170940
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[0x18cca0]
LEA R13,[RBP + -0x60]
MOV R12,-0x760c000300030003
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R15
MOV RCX,R12
CALL 0x00174720
MOV RDI,R13
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R15
MOV R8,R12
CALL 0x00174ea0
MOV RDI,R13
MOV RSI,R13
MOV RDX,R15
MOV RCX,R12
CALL 0x00174720
MOV EDX,0x2
MOV RDI,R13
MOV RSI,R13
MOV RCX,R15
CALL 0x0016f940
LEA RBX,[RBP + -0xc0]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x00174720
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R14
MOV RCX,R15
MOV R8,R12
CALL 0x00174ea0
MOV RDI,RBX
MOV RSI,RBX
MOV RDX,R13
MOV RCX,R15
CALL 0x0016f640
ADD R14,0x30
LEA R13,[RBP + -0x90]
MOV RDI,R13
MOV RSI,R14
MOV RDX,R15
MOV RCX,R12
CALL 0x00174720
MOV EDX,0x30
MOV RDI,RBX
MOV RSI,R13
CALL 0x00170980
OR EAX,dword ptr [RBP + -0x30]
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint blst_p1_on_curve(long param_1)
{
long lVar1;
uint uVar2;
int1 local_c8 [48];
int1 local_98 [48];
int1 local_68 [48];
int8 local_38;
lVar1 = param_1 + 0x60;
local_38 = vec_is_zero_16x(lVar1,0x30);
sqr_mont_384(local_68,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_68,local_68,lVar1,BLS12_381_P,0x89f3fffcfffcfffd);
sqr_mont_384(local_68,local_68,BLS12_381_P,0x89f3fffcfffcfffd);
lshift_mod_384(local_68,local_68,2,BLS12_381_P);
sqr_mont_384(local_c8,param_1,BLS12_381_P,0x89f3fffcfffcfffd);
mul_mont_384(local_c8,local_c8,param_1,BLS12_381_P,0x89f3fffcfffcfffd);
add_mod_384(local_c8,local_c8,local_68,BLS12_381_P);
sqr_mont_384(local_98,param_1 + 0x30,BLS12_381_P,0x89f3fffcfffcfffd);
uVar2 = vec_is_equal_16x(local_c8,local_98,0x30);
return uVar2 | (uint)local_38;
}
|
|
17,789
|
minja::CommentTemplateToken::~CommentTemplateToken()
|
monkey531[P]llama/common/minja.hpp
|
CommentTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::string& t) : TemplateToken(Type::Comment, location, pre, post), text(t) {}
|
O3
|
cpp
|
minja::CommentTemplateToken::~CommentTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0xa4c31(%rip), %rax # 0x1292b0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x8469e
movq (%rax), %rsi
incq %rsi
callq 0x1a8c0
leaq 0xa4c53(%rip), %rax # 0x1292f8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x846ba
callq 0x6d25e
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8c0
|
_ZN5minja20CommentTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja20CommentTemplateTokenE; `vtable for'minja::CommentTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+30h]; void *
lea rax, [rbx+40h]
cmp rdi, rax
jz short loc_8469E
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8469E:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_846BA
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_846BA:
mov esi, 50h ; 'P'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
|
void minja::CommentTemplateToken::~CommentTemplateToken(minja::CommentTemplateToken *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::CommentTemplateToken + 2;
v2 = (char *)*((_QWORD *)this + 6);
if ( v2 != (char *)this + 64 )
operator delete(v2, *((_QWORD *)this + 8) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x50uLL);
}
|
~CommentTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x2292b0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x30]
LEA RAX,[RBX + 0x40]
CMP RDI,RAX
JZ 0x0018469e
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a8c0
LAB_0018469e:
LEA RAX,[0x2292f8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x001846ba
CALL 0x0016d25e
LAB_001846ba:
MOV ESI,0x50
MOV RDI,RBX
POP RBX
JMP 0x0011a8c0
|
/* minja::CommentTemplateToken::~CommentTemplateToken() */
void __thiscall minja::CommentTemplateToken::~CommentTemplateToken(CommentTemplateToken *this)
{
*(int ***)this = &PTR__CommentTemplateToken_002292c0;
if (*(CommentTemplateToken **)(this + 0x30) != this + 0x40) {
operator_delete(*(CommentTemplateToken **)(this + 0x30),*(long *)(this + 0x40) + 1);
}
*(int ***)this = &PTR__TemplateToken_00229308;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x50);
return;
}
|
|
17,790
|
ma_bitmap_reset_full_page_bits
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_bitmap_reset_full_page_bits(MARIA_HA *info,
MARIA_FILE_BITMAP *bitmap,
pgcache_page_no_t page,
uint page_count)
{
ulonglong bitmap_page;
uint offset, bit_start, bit_count, tmp, byte_offset;
uchar *data;
DBUG_ENTER("_ma_bitmap_reset_full_page_bits");
DBUG_PRINT("enter", ("page: %lu page_count: %u", (ulong) page, page_count));
mysql_mutex_assert_owner(&info->s->bitmap.bitmap_lock);
bitmap_page= page - page % bitmap->pages_covered;
DBUG_ASSERT(page != bitmap_page);
if (bitmap_page != bitmap->page &&
_ma_change_bitmap_page(info, bitmap, bitmap_page))
DBUG_RETURN(1);
/* Find page number from start of bitmap */
offset= (uint) (page - bitmap->page - 1);
/* Clear bits from 'page * 3' -> '(page + page_count) * 3' */
bit_start= offset * 3;
bit_count= page_count * 3;
byte_offset= bit_start/8;
data= bitmap->map + byte_offset;
offset= bit_start & 7;
tmp= (255 << offset); /* Bits to keep */
if (bit_count + offset < 8)
{
/* Only clear bits between 'offset' and 'offset+bit_count-1' */
tmp^= (255 << (offset + bit_count));
}
*data&= ~tmp;
set_if_smaller(bitmap->full_head_size, byte_offset);
set_if_smaller(bitmap->full_tail_size, byte_offset);
if ((int) (bit_count-= (8 - offset)) > 0)
{
uint fill;
data++;
/*
-1 is here to avoid one 'if' statement and to let the following code
handle the last byte
*/
if ((fill= (bit_count - 1) / 8))
{
bzero(data, fill);
data+= fill;
}
bit_count-= fill * 8; /* Bits left to clear */
tmp= (1 << bit_count) - 1;
*data&= ~tmp;
}
set_if_smaller(info->s->state.first_bitmap_with_space, bitmap_page);
bitmap->changed= 1;
DBUG_EXECUTE("bitmap", _ma_print_bitmap_changes(bitmap););
DBUG_RETURN(0);
}
|
O3
|
c
|
ma_bitmap_reset_full_page_bits:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r8
xorl %r14d, %r14d
movq %rdx, %rax
xorl %edx, %edx
divq 0x138(%rsi)
movq %r12, %r15
subq %rdx, %r15
movq %r15, %rax
cmpq 0x10(%rsi), %r15
je 0x410cb
movq %r8, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r8, -0x30(%rbp)
callq 0x40c31
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x41189
movq 0x10(%rbx), %rax
movq -0x30(%rbp), %r8
notl %eax
addl %eax, %r12d
leal (%r12,%r12,2), %r12d
leal (%r13,%r13,2), %edx
movl %r12d, %eax
shrl $0x3, %eax
movq 0x8(%rbx), %r13
movl %r12d, %ecx
andl $0x7, %ecx
movl $0xff, %esi
movl $0xff, %edi
shll %cl, %edi
addl %edx, %ecx
shll %cl, %esi
cmpl $0x8, %ecx
cmovbl %esi, %r14d
xorl %edi, %r14d
notb %r14b
andb %r14b, (%r13,%rax)
cmpl %eax, 0x28(%rbx)
jbe 0x41113
movl %eax, 0x28(%rbx)
cmpl %eax, 0x2c(%rbx)
jbe 0x4111b
movl %eax, 0x2c(%rbx)
orl $-0x8, %r12d
addl %edx, %r12d
testl %r12d, %r12d
jle 0x41170
addq %rax, %r13
incq %r13
leal -0x1(%r12), %r14d
cmpl $0x9, %r12d
jb 0x41158
movl %r14d, %edx
shrl $0x3, %edx
movq %rdx, -0x38(%rbp)
movq %r13, %rdi
xorl %esi, %esi
movq %r8, -0x30(%rbp)
callq 0x292c0
movq -0x30(%rbp), %r8
addq -0x38(%rbp), %r13
andl $0xf8, %r14d
subl %r14d, %r12d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
movl %r12d, %ecx
shll %cl, %eax
andb %al, (%r13)
movq (%r8), %rax
cmpq %r15, 0xd0(%rax)
jbe 0x41183
movq %r15, 0xd0(%rax)
movb $0x1, 0x20(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ma_bitmap_reset_full_page_bits:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13d, ecx
mov r12, rdx
mov rbx, rsi
mov r8, rdi
xor r14d, r14d
mov rax, rdx
xor edx, edx
div qword ptr [rsi+138h]
mov r15, r12
sub r15, rdx
mov rax, r15
cmp r15, [rsi+10h]
jz short loc_410CB
mov rdi, r8
mov rsi, rbx
mov rdx, r15
mov [rbp+var_30], r8
call _ma_change_bitmap_page
mov ecx, eax
mov al, 1
test cl, cl
jnz loc_41189
mov rax, [rbx+10h]
mov r8, [rbp+var_30]
loc_410CB:
not eax
add r12d, eax
lea r12d, [r12+r12*2]
lea edx, [r13+r13*2+0]
mov eax, r12d
shr eax, 3
mov r13, [rbx+8]
mov ecx, r12d
and ecx, 7
mov esi, 0FFh
mov edi, 0FFh
shl edi, cl
add ecx, edx
shl esi, cl
cmp ecx, 8
cmovb r14d, esi
xor r14d, edi
not r14b
and [r13+rax+0], r14b
cmp [rbx+28h], eax
jbe short loc_41113
mov [rbx+28h], eax
loc_41113:
cmp [rbx+2Ch], eax
jbe short loc_4111B
mov [rbx+2Ch], eax
loc_4111B:
or r12d, 0FFFFFFF8h
add r12d, edx
test r12d, r12d
jle short loc_41170
add r13, rax
inc r13
lea r14d, [r12-1]
cmp r12d, 9
jb short loc_41158
mov edx, r14d
shr edx, 3
mov [rbp+var_38], rdx
mov rdi, r13
xor esi, esi
mov [rbp+var_30], r8
call _memset
mov r8, [rbp+var_30]
add r13, [rbp+var_38]
loc_41158:
and r14d, 0F8h
sub r12d, r14d
mov eax, 0FFFFFFFFh
mov ecx, r12d
shl eax, cl
and [r13+0], al
loc_41170:
mov rax, [r8]
cmp [rax+0D0h], r15
jbe short loc_41183
mov [rax+0D0h], r15
loc_41183:
mov byte ptr [rbx+20h], 1
xor eax, eax
loc_41189:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char ma_bitmap_reset_full_page_bits(long long *a1, long long a2, unsigned long long a3, long long a4)
{
int v4; // r13d
int v5; // r12d
long long *v6; // r8
char v7; // r14
unsigned long long v8; // r15
long long v9; // rax
char v10; // cl
char result; // al
unsigned int v12; // r12d
int v13; // edx
long long v14; // rax
long long v15; // r13
int v16; // ecx
int v17; // edi
unsigned int v18; // ecx
int v19; // r12d
_BYTE *v20; // r13
unsigned int v21; // r14d
long long *v22; // [rsp+10h] [rbp-30h]
v4 = a4;
v5 = a3;
v6 = a1;
v7 = 0;
v8 = a3 - a3 % *(_QWORD *)(a2 + 312);
LODWORD(v9) = a3 - a3 % *(_QWORD *)(a2 + 312);
if ( v8 != *(_QWORD *)(a2 + 16) )
{
v10 = ma_change_bitmap_page(a1, a2, a3 - a3 % *(_QWORD *)(a2 + 312), a4, (long long)a1);
result = 1;
if ( v10 )
return result;
v9 = *(_QWORD *)(a2 + 16);
v6 = a1;
}
v12 = 3 * (~(_DWORD)v9 + v5);
v13 = 3 * v4;
v14 = v12 >> 3;
v15 = *(_QWORD *)(a2 + 8);
v16 = v12 & 7;
v17 = 255 << v16;
v18 = v13 + v16;
if ( v18 < 8 )
v7 = 255 << v18;
*(_BYTE *)(v15 + v14) &= ~(v17 ^ v7);
if ( *(_DWORD *)(a2 + 40) > (unsigned int)v14 )
*(_DWORD *)(a2 + 40) = v14;
if ( *(_DWORD *)(a2 + 44) > (unsigned int)v14 )
*(_DWORD *)(a2 + 44) = v14;
v19 = v13 + (v12 | 0xFFFFFFF8);
if ( v19 > 0 )
{
v20 = (_BYTE *)(v14 + v15 + 1);
v21 = v19 - 1;
if ( (unsigned int)v19 >= 9 )
{
v22 = v6;
memset(v20, 0LL, v21 >> 3);
v6 = v22;
v20 += v21 >> 3;
}
*v20 &= -1 << (v19 - (v21 & 0xF8));
}
if ( *(_QWORD *)(*v6 + 208) > v8 )
*(_QWORD *)(*v6 + 208) = v8;
*(_BYTE *)(a2 + 32) = 1;
return 0;
}
|
_ma_bitmap_reset_full_page_bits:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13D,ECX
MOV R12,RDX
MOV RBX,RSI
MOV R8,RDI
XOR R14D,R14D
MOV RAX,RDX
XOR EDX,EDX
DIV qword ptr [RSI + 0x138]
MOV R15,R12
SUB R15,RDX
MOV RAX,R15
CMP R15,qword ptr [RSI + 0x10]
JZ 0x001410cb
MOV RDI,R8
MOV RSI,RBX
MOV RDX,R15
MOV qword ptr [RBP + -0x30],R8
CALL 0x00140c31
MOV ECX,EAX
MOV AL,0x1
TEST CL,CL
JNZ 0x00141189
MOV RAX,qword ptr [RBX + 0x10]
MOV R8,qword ptr [RBP + -0x30]
LAB_001410cb:
NOT EAX
ADD R12D,EAX
LEA R12D,[R12 + R12*0x2]
LEA EDX,[R13 + R13*0x2]
MOV EAX,R12D
SHR EAX,0x3
MOV R13,qword ptr [RBX + 0x8]
MOV ECX,R12D
AND ECX,0x7
MOV ESI,0xff
MOV EDI,0xff
SHL EDI,CL
ADD ECX,EDX
SHL ESI,CL
CMP ECX,0x8
CMOVC R14D,ESI
XOR R14D,EDI
NOT R14B
AND byte ptr [R13 + RAX*0x1],R14B
CMP dword ptr [RBX + 0x28],EAX
JBE 0x00141113
MOV dword ptr [RBX + 0x28],EAX
LAB_00141113:
CMP dword ptr [RBX + 0x2c],EAX
JBE 0x0014111b
MOV dword ptr [RBX + 0x2c],EAX
LAB_0014111b:
OR R12D,0xfffffff8
ADD R12D,EDX
TEST R12D,R12D
JLE 0x00141170
ADD R13,RAX
INC R13
LEA R14D,[R12 + -0x1]
CMP R12D,0x9
JC 0x00141158
MOV EDX,R14D
SHR EDX,0x3
MOV qword ptr [RBP + -0x38],RDX
MOV RDI,R13
XOR ESI,ESI
MOV qword ptr [RBP + -0x30],R8
CALL 0x001292c0
MOV R8,qword ptr [RBP + -0x30]
ADD R13,qword ptr [RBP + -0x38]
LAB_00141158:
AND R14D,0xf8
SUB R12D,R14D
MOV EAX,0xffffffff
MOV ECX,R12D
SHL EAX,CL
AND byte ptr [R13],AL
LAB_00141170:
MOV RAX,qword ptr [R8]
CMP qword ptr [RAX + 0xd0],R15
JBE 0x00141183
MOV qword ptr [RAX + 0xd0],R15
LAB_00141183:
MOV byte ptr [RBX + 0x20],0x1
XOR EAX,EAX
LAB_00141189:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _ma_bitmap_reset_full_page_bits(long *param_1,long param_2,ulong param_3,int param_4)
{
long lVar1;
ulong __n;
uint uVar2;
char cVar3;
uint uVar4;
uint uVar5;
byte *pbVar6;
byte bVar7;
ulong uVar8;
uVar8 = param_3 - param_3 % *(ulong *)(param_2 + 0x138);
uVar5 = (uint)uVar8;
if (uVar8 != *(ulong *)(param_2 + 0x10)) {
cVar3 = _ma_change_bitmap_page(param_1,param_2,uVar8);
if (cVar3 != '\0') {
return 1;
}
uVar5 = (uint)*(int8 *)(param_2 + 0x10);
}
uVar5 = ((int)param_3 + ~uVar5) * 3;
uVar2 = uVar5 >> 3;
lVar1 = *(long *)(param_2 + 8);
uVar4 = (uVar5 & 7) + param_4 * 3;
bVar7 = 0;
if (uVar4 < 8) {
bVar7 = (byte)(0xff << ((byte)uVar4 & 0x1f));
}
pbVar6 = (byte *)(lVar1 + (ulong)uVar2);
*pbVar6 = *pbVar6 & ~(bVar7 ^ (byte)(0xff << (sbyte)(uVar5 & 7)));
if (uVar2 < *(uint *)(param_2 + 0x28)) {
*(uint *)(param_2 + 0x28) = uVar2;
}
if (uVar2 < *(uint *)(param_2 + 0x2c)) {
*(uint *)(param_2 + 0x2c) = uVar2;
}
uVar5 = (uVar5 | 0xfffffff8) + param_4 * 3;
if (0 < (int)uVar5) {
pbVar6 = (byte *)(lVar1 + (ulong)uVar2 + 1);
if (8 < uVar5) {
__n = (ulong)(uVar5 - 1 >> 3);
memset(pbVar6,0,__n);
pbVar6 = pbVar6 + __n;
}
*pbVar6 = *pbVar6 & (byte)(-1 << ((char)uVar5 - ((byte)(uVar5 - 1) & 0xf8) & 0x1f));
}
if (uVar8 < *(ulong *)(*param_1 + 0xd0)) {
*(ulong *)(*param_1 + 0xd0) = uVar8;
}
*(int1 *)(param_2 + 0x20) = 1;
return 0;
}
|
|
17,791
|
c4_tx_verify_receipt_proof
|
corpus-core[P]colibri-stateless/src/chains/eth/verifier/eth_tx.c
|
INTERNAL bool c4_tx_verify_receipt_proof(verify_ctx_t* ctx, ssz_ob_t receipt_proof, uint32_t tx_index, bytes32_t receipt_root, bytes_t* receipt_raw) {
bytes32_t tmp = {0};
buffer_t path_buf = stack_buffer(tmp);
if (patricia_verify(receipt_root, c4_eth_create_tx_path(tx_index, &path_buf), receipt_proof, receipt_raw) != PATRICIA_FOUND)
RETURN_VERIFY_ERROR(ctx, "invalid account proof on execution layer!");
return true;
}
|
O2
|
c
|
c4_tx_verify_receipt_proof:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %eax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
leaq 0x18(%rsp), %rsi
andl $0x0, (%rsi)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movq %rcx, 0x8(%rsi)
movl $0xffffffe0, 0x10(%rsi) # imm = 0xFFFFFFE0
movl %eax, %edi
callq 0xd92b
movq 0x90(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rcx
callq 0xfce0
movl %eax, %ebp
cmpl $0x1, %eax
je 0xda17
leaq 0x70(%rbx), %rdi
leaq 0x2ba14(%rip), %rsi # 0x39422
callq 0x16fd9
movb $0x0, 0x68(%rbx)
cmpl $0x1, %ebp
sete %al
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
c4_tx_verify_receipt_proof:
push rbp
push r15
push r14
push rbx
sub rsp, 58h
mov r14, rcx
mov r15, rdx
mov eax, esi
mov rbx, rdi
xorps xmm0, xmm0
lea rcx, [rsp+78h+var_48]
lea rsi, [rsp+78h+var_60]
and dword ptr [rsi], 0
movaps xmmword ptr [rcx+10h], xmm0
movaps xmmword ptr [rcx], xmm0
mov [rsi+8], rcx
mov dword ptr [rsi+10h], 0FFFFFFE0h
mov edi, eax
call c4_eth_create_tx_path
mov rcx, [rsp+78h+arg_10]
mov [rsp+78h+var_68], rcx
movaps xmm0, [rsp+78h+arg_0]
movups [rsp+78h+var_78], xmm0
mov rdi, r15
mov esi, eax
mov rcx, r14
call patricia_verify
mov ebp, eax
cmp eax, 1
jz short loc_DA17
lea rdi, [rbx+70h]
lea rsi, aInvalidAccount; "invalid account proof on execution laye"...
call c4_state_add_error
mov byte ptr [rbx+68h], 0
loc_DA17:
cmp ebp, 1
setz al
add rsp, 58h
pop rbx
pop r14
pop r15
pop rbp
retn
|
bool c4_tx_verify_receipt_proof(
long long a1,
unsigned int a2,
int a3,
int a4,
long long a5,
long long a6,
__int128 a7,
long long a8)
{
int v10; // eax
int v11; // edx
int v12; // r8d
int v13; // r9d
int v14; // ebp
unsigned int v16; // [rsp+18h] [rbp-60h] BYREF
_BYTE *v17; // [rsp+20h] [rbp-58h]
int v18; // [rsp+28h] [rbp-50h]
_BYTE v19[72]; // [rsp+30h] [rbp-48h] BYREF
v16 = 0;
memset(v19, 0, 32);
v17 = v19;
v18 = -32;
v10 = c4_eth_create_tx_path(a2, &v16);
v14 = patricia_verify(a3, v10, v11, a4, v12, v13, a7, a8);
if ( v14 != 1 )
{
c4_state_add_error(a1 + 112, "invalid account proof on execution layer!");
*(_BYTE *)(a1 + 104) = 0;
}
return v14 == 1;
}
|
c4_tx_verify_receipt_proof:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x58
MOV R14,RCX
MOV R15,RDX
MOV EAX,ESI
MOV RBX,RDI
XORPS XMM0,XMM0
LEA RCX,[RSP + 0x30]
LEA RSI,[RSP + 0x18]
AND dword ptr [RSI],0x0
MOVAPS xmmword ptr [RCX + 0x10],XMM0
MOVAPS xmmword ptr [RCX],XMM0
MOV qword ptr [RSI + 0x8],RCX
MOV dword ptr [RSI + 0x10],0xffffffe0
MOV EDI,EAX
CALL 0x0010d92b
MOV RCX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x10],RCX
MOVAPS XMM0,xmmword ptr [RSP + 0x80]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R15
MOV ESI,EAX
MOV RCX,R14
CALL 0x0010fce0
MOV EBP,EAX
CMP EAX,0x1
JZ 0x0010da17
LEA RDI,[RBX + 0x70]
LEA RSI,[0x139422]
CALL 0x00116fd9
MOV byte ptr [RBX + 0x68],0x0
LAB_0010da17:
CMP EBP,0x1
SETZ AL
ADD RSP,0x58
POP RBX
POP R14
POP R15
POP RBP
RET
|
bool c4_tx_verify_receipt_proof
(long param_1,int4 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int4 param_7,int4 param_8,
int8 param_9)
{
int4 uVar1;
int iVar2;
int8 extraout_RDX;
uVar1 = c4_eth_create_tx_path(param_2);
iVar2 = patricia_verify(param_3,uVar1,extraout_RDX,param_4,param_5,param_6,param_7,param_8,param_9
);
if (iVar2 != 1) {
c4_state_add_error(param_1 + 0x70,"invalid account proof on execution layer!");
*(int1 *)(param_1 + 0x68) = 0;
}
return iVar2 == 1;
}
|
|
17,792
|
my_l10tostr_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_l10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *db, *de;
long int new_val;
int sl= 0;
unsigned long int uval = (unsigned long int) val;
p= &buffer[sizeof(buffer) - 1];
*p= '\0';
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val= new_val;
while (val != 0)
{
new_val= val / 10;
*--p= '0' + (char) (val - new_val * 10);
val= new_val;
}
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst - db);
}
|
O0
|
c
|
my_l10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x50(%rbp), %rax
addq $0x41, %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x6c(%rbp)
jge 0xbb39c
cmpq $0x0, -0x78(%rbp)
jge 0xbb39a
movl $0x1, -0x9c(%rbp)
xorl %eax, %eax
subq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
jmp 0xbb39c
movq -0xa8(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rax
imulq $0xa, -0x98(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
je 0xbb43d
movq -0x78(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x98(%rbp)
movq -0x78(%rbp), %rax
imulq $0xa, -0x98(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0xbb3eb
cmpl $0x0, -0x9c(%rbp)
je 0xbb459
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0x2d, -0x1(%rax)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
addq -0x68(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x90(%rbp), %rcx
movb %al, -0xad(%rbp)
jae 0xbb49b
movq -0x80(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xad(%rbp)
movb -0xad(%rbp), %al
testb $0x1, %al
jne 0xbb4a7
jmp 0xbb509
movq -0x58(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq -0x58(%rbp), %rdi
movq -0x80(%rbp), %rcx
movsbq (%rcx), %rsi
movq -0x60(%rbp), %rdx
movq -0x90(%rbp), %rcx
callq *%rax
movl %eax, -0xac(%rbp)
cmpl $0x0, -0xac(%rbp)
jle 0xbb4f4
movl -0xac(%rbp), %ecx
movq -0x60(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0xbb4f6
jmp 0xbb509
jmp 0xbb4f8
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xbb473
movl -0x60(%rbp), %eax
movl -0x88(%rbp), %ecx
subl %ecx, %eax
cltq
movq %rax, -0xb8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xbb53f
movq -0xb8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
callq 0x283c0
nopw %cs:(%rax,%rax)
|
my_l10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_9C], 0
mov rax, [rbp+var_78]
mov [rbp+var_A8], rax
lea rax, [rbp+var_50]
add rax, 41h ; 'A'
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_6C], 0
jge short loc_BB39C
cmp [rbp+var_78], 0
jge short loc_BB39A
mov [rbp+var_9C], 1
xor eax, eax
sub rax, [rbp+var_A8]
mov [rbp+var_A8], rax
loc_BB39A:
jmp short $+2
loc_BB39C:
mov rax, [rbp+var_A8]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_A8]
imul rcx, [rbp+var_98], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_78], rax
loc_BB3EB:
cmp [rbp+var_78], 0
jz short loc_BB43D
mov rax, [rbp+var_78]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_78]
imul rcx, [rbp+var_98], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_78], rax
jmp short loc_BB3EB
loc_BB43D:
cmp [rbp+var_9C], 0
jz short loc_BB459
mov rax, [rbp+var_80]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rcx
mov byte ptr [rax-1], 2Dh ; '-'
loc_BB459:
mov rax, [rbp+var_60]
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
add rax, [rbp+var_68]
mov [rbp+var_90], rax
loc_BB473:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_90]
mov [rbp+var_AD], al
jnb short loc_BB49B
mov rax, [rbp+var_80]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_AD], al
loc_BB49B:
mov al, [rbp+var_AD]
test al, 1
jnz short loc_BB4A7
jmp short loc_BB509
loc_BB4A7:
mov rax, [rbp+var_58]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov rdi, [rbp+var_58]
mov rcx, [rbp+var_80]
movsx rsi, byte ptr [rcx]
mov rdx, [rbp+var_60]
mov rcx, [rbp+var_90]
call rax
mov [rbp+var_AC], eax
cmp [rbp+var_AC], 0
jle short loc_BB4F4
mov ecx, [rbp+var_AC]
mov rax, [rbp+var_60]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_BB4F6
loc_BB4F4:
jmp short loc_BB509
loc_BB4F6:
jmp short $+2
loc_BB4F8:
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
jmp loc_BB473
loc_BB509:
mov eax, dword ptr [rbp+var_60]
mov ecx, dword ptr [rbp+var_88]
sub eax, ecx
cdqe
mov [rbp+var_B8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_BB53F
mov rax, [rbp+var_B8]
add rsp, 0C0h
pop rbp
retn
loc_BB53F:
call ___stack_chk_fail
|
long long my_l10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, long long a5)
{
_BYTE *v5; // rax
_BYTE *v6; // rax
bool v8; // [rsp+13h] [rbp-ADh]
int v9; // [rsp+14h] [rbp-ACh]
unsigned long long v10; // [rsp+18h] [rbp-A8h]
int v11; // [rsp+24h] [rbp-9Ch]
unsigned long long v12; // [rsp+30h] [rbp-90h]
_BYTE *v13; // [rsp+40h] [rbp-80h]
signed long long i; // [rsp+48h] [rbp-78h]
unsigned long long v15; // [rsp+60h] [rbp-60h]
_BYTE v16[8]; // [rsp+B0h] [rbp-10h] BYREF
unsigned long long v17; // [rsp+B8h] [rbp-8h]
v17 = __readfsqword(0x28u);
v15 = a2;
v11 = 0;
v10 = a5;
v16[1] = 0;
if ( a4 < 0 && a5 < 0 )
{
v11 = 1;
v10 = -a5;
}
v13 = v16;
v16[0] = v10 % 0xA + 48;
for ( i = v10 / 0xA; i; i /= 10LL )
{
v5 = v13--;
*(v5 - 1) = i % 10 + 48;
}
if ( v11 )
{
v6 = v13--;
*(v6 - 1) = 45;
}
v12 = a3 + a2;
while ( 1 )
{
v8 = 0;
if ( v15 < v12 )
v8 = *v13 != 0;
if ( !v8 )
break;
v9 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
(char)*v13,
v15,
v12);
if ( v9 <= 0 )
break;
v15 += v9;
++v13;
}
return (int)v15 - (int)a2;
}
|
my_l10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x9c],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa8],RAX
LEA RAX,[RBP + -0x50]
ADD RAX,0x41
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x001bb39c
CMP qword ptr [RBP + -0x78],0x0
JGE 0x001bb39a
MOV dword ptr [RBP + -0x9c],0x1
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xa8],RAX
LAB_001bb39a:
JMP 0x001bb39c
LAB_001bb39c:
MOV RAX,qword ptr [RBP + -0xa8]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0xa8]
IMUL RCX,qword ptr [RBP + -0x98],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x78],RAX
LAB_001bb3eb:
CMP qword ptr [RBP + -0x78],0x0
JZ 0x001bb43d
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x78]
IMUL RCX,qword ptr [RBP + -0x98],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x001bb3eb
LAB_001bb43d:
CMP dword ptr [RBP + -0x9c],0x0
JZ 0x001bb459
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x80],RCX
MOV byte ptr [RAX + -0x1],0x2d
LAB_001bb459:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x90],RAX
LAB_001bb473:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0xad],AL
JNC 0x001bb49b
MOV RAX,qword ptr [RBP + -0x80]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0xad],AL
LAB_001bb49b:
MOV AL,byte ptr [RBP + -0xad]
TEST AL,0x1
JNZ 0x001bb4a7
JMP 0x001bb509
LAB_001bb4a7:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x80]
MOVSX RSI,byte ptr [RCX]
MOV RDX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x90]
CALL RAX
MOV dword ptr [RBP + -0xac],EAX
CMP dword ptr [RBP + -0xac],0x0
JLE 0x001bb4f4
MOV ECX,dword ptr [RBP + -0xac]
MOV RAX,qword ptr [RBP + -0x60]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001bb4f6
LAB_001bb4f4:
JMP 0x001bb509
LAB_001bb4f6:
JMP 0x001bb4f8
LAB_001bb4f8:
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
JMP 0x001bb473
LAB_001bb509:
MOV EAX,dword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x88]
SUB EAX,ECX
CDQE
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001bb53f
MOV RAX,qword ptr [RBP + -0xb8]
ADD RSP,0xc0
POP RBP
RET
LAB_001bb53f:
CALL 0x001283c0
|
long my_l10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
int iVar1;
long in_FS_OFFSET;
bool bVar2;
ulong local_b0;
int local_90;
char *local_88;
ulong local_80;
ulong local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
bVar2 = false;
local_19[2] = 0;
local_b0 = param_5;
if ((param_4 < 0) && (bVar2 = (long)param_5 < 0, bVar2)) {
local_b0 = -param_5;
}
local_19[1] = (char)local_b0 + (char)(local_b0 / 10) * -10 + '0';
local_88 = local_19 + 1;
local_80 = local_b0 / 10;
while (local_80 != 0) {
local_88[-1] = (char)local_80 + (char)((long)local_80 / 10) * -10 + '0';
local_88 = local_88 + -1;
local_80 = (long)local_80 / 10;
}
if (bVar2) {
local_88[-1] = '-';
local_88 = local_88 + -1;
}
local_68 = param_2;
while( true ) {
bVar2 = false;
if (local_68 < param_2 + param_3) {
bVar2 = *local_88 != '\0';
}
if ((!bVar2) ||
(iVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*local_88,local_68,param_2 + param_3), iVar1 < 1)) break;
local_68 = local_68 + (long)iVar1;
local_88 = local_88 + 1;
}
local_90 = (int)param_2;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)((int)local_68 - local_90);
}
|
|
17,793
|
my_l10tostr_mb2_or_mb4
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_l10tostr_mb2_or_mb4(CHARSET_INFO *cs,
char *dst, size_t len, int radix, long int val)
{
char buffer[66];
register char *p, *db, *de;
long int new_val;
int sl= 0;
unsigned long int uval = (unsigned long int) val;
p= &buffer[sizeof(buffer) - 1];
*p= '\0';
if (radix < 0)
{
if (val < 0)
{
sl= 1;
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
new_val = (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val= new_val;
while (val != 0)
{
new_val= val / 10;
*--p= '0' + (char) (val - new_val * 10);
val= new_val;
}
if (sl)
{
*--p= '-';
}
for ( db= dst, de= dst + len ; (dst < de) && *p ; p++)
{
int cnvres= my_ci_wc_mb(cs, (my_wc_t) p[0], (uchar*) dst, (uchar*) de);
if (cnvres > 0)
dst+= cnvres;
else
break;
}
return (int) (dst - db);
}
|
O3
|
c
|
my_l10tostr_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %r13
testl %ecx, %ecx
setns %al
testq %r8, %r8
setns %dil
orb %al, %dil
movq %r8, %rsi
negq %rsi
testb %dil, %dil
cmovneq %r8, %rsi
movabsq $-0x3333333333333333, %r8 # imm = 0xCCCCCCCCCCCCCCCD
movq %rsi, %rax
mulq %r8
movq %rdx, %rcx
movb $0x0, 0x1(%r13)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %esi, %eax
addb $0x30, %al
movb %al, (%r13)
cmpq $0xa, %rsi
jb 0x7e626
movq %rcx, %rax
mulq %r8
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r13)
decq %r13
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x7e602
testb %dil, %dil
jne 0x7e633
movb $0x2d, -0x1(%r13)
decq %r13
movq %rbx, %r12
testq %r14, %r14
jle 0x7e66f
addq %rbx, %r14
movq %rbx, %r12
movsbq (%r13), %rsi
testq %rsi, %rsi
je 0x7e66f
movq 0xb8(%r15), %rax
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *0x30(%rax)
testl %eax, %eax
jle 0x7e66f
movl %eax, %eax
addq %rax, %r12
incq %r13
cmpq %r14, %r12
jb 0x7e641
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x7e693
subl %ebx, %r12d
movslq %r12d, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28400
|
my_l10tostr_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r13, [rbp+var_40]
test ecx, ecx
setns al
test r8, r8
setns dil
or dil, al
mov rsi, r8
neg rsi
test dil, dil
cmovnz rsi, r8
mov r8, 0CCCCCCCCCCCCCCCDh
mov rax, rsi
mul r8
mov rcx, rdx
mov byte ptr [r13+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, esi
add al, 30h ; '0'
mov [r13+0], al
cmp rsi, 0Ah
jb short loc_7E626
loc_7E602:
mov rax, rcx
mul r8
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r13-1], al
dec r13
cmp rcx, 9
mov rcx, rdx
ja short loc_7E602
loc_7E626:
test dil, dil
jnz short loc_7E633
mov byte ptr [r13-1], 2Dh ; '-'
dec r13
loc_7E633:
mov r12, rbx
test r14, r14
jle short loc_7E66F
add r14, rbx
mov r12, rbx
loc_7E641:
movsx rsi, byte ptr [r13+0]
test rsi, rsi
jz short loc_7E66F
mov rax, [r15+0B8h]
mov rdi, r15
mov rdx, r12
mov rcx, r14
call qword ptr [rax+30h]
test eax, eax
jle short loc_7E66F
mov eax, eax
add r12, rax
inc r13
cmp r12, r14
jb short loc_7E641
loc_7E66F:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_7E693
sub r12d, ebx
movsxd rax, r12d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7E693:
call ___stack_chk_fail
|
long long my_l10tostr_mb2_or_mb4(long long a1, unsigned long long a2, long long a3, int a4, signed long long a5)
{
_BYTE *v7; // r13
bool v8; // di
unsigned long long v9; // rsi
unsigned long long v10; // rcx
bool v11; // cc
unsigned long long v12; // r12
unsigned long long v13; // r14
int v14; // eax
_BYTE v16[16]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v17; // [rsp+50h] [rbp-30h]
v17 = __readfsqword(0x28u);
v7 = v16;
v8 = a4 >= 0 || a5 >= 0;
v9 = -a5;
if ( v8 )
v9 = a5;
v16[1] = 0;
v10 = v9 / 0xA;
v16[0] = v9 % 0xA + 48;
if ( v9 >= 0xA )
{
do
{
*--v7 = v10 % 0xA + 48;
v11 = v10 <= 9;
v10 /= 0xAuLL;
}
while ( !v11 );
}
if ( !v8 )
*--v7 = 45;
LODWORD(v12) = a2;
if ( a3 > 0 )
{
v13 = a2 + a3;
v12 = a2;
do
{
if ( !*v7 )
break;
v14 = (*(long long ( **)(long long, _QWORD, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 48LL))(
a1,
(char)*v7,
v12,
v13);
if ( v14 <= 0 )
break;
v12 += (unsigned int)v14;
++v7;
}
while ( v12 < v13 );
}
return (int)v12 - (int)a2;
}
|
my_l10tostr_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R13,[RBP + -0x40]
TEST ECX,ECX
SETNS AL
TEST R8,R8
SETNS DIL
OR DIL,AL
MOV RSI,R8
NEG RSI
TEST DIL,DIL
CMOVNZ RSI,R8
MOV R8,-0x3333333333333333
MOV RAX,RSI
MUL R8
MOV RCX,RDX
MOV byte ptr [R13 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,ESI
ADD AL,0x30
MOV byte ptr [R13],AL
CMP RSI,0xa
JC 0x0017e626
LAB_0017e602:
MOV RAX,RCX
MUL R8
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R13 + -0x1],AL
DEC R13
CMP RCX,0x9
MOV RCX,RDX
JA 0x0017e602
LAB_0017e626:
TEST DIL,DIL
JNZ 0x0017e633
MOV byte ptr [R13 + -0x1],0x2d
DEC R13
LAB_0017e633:
MOV R12,RBX
TEST R14,R14
JLE 0x0017e66f
ADD R14,RBX
MOV R12,RBX
LAB_0017e641:
MOVSX RSI,byte ptr [R13]
TEST RSI,RSI
JZ 0x0017e66f
MOV RAX,qword ptr [R15 + 0xb8]
MOV RDI,R15
MOV RDX,R12
MOV RCX,R14
CALL qword ptr [RAX + 0x30]
TEST EAX,EAX
JLE 0x0017e66f
MOV EAX,EAX
ADD R12,RAX
INC R13
CMP R12,R14
JC 0x0017e641
LAB_0017e66f:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0017e693
SUB R12D,EBX
MOVSXD RAX,R12D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017e693:
CALL 0x00128400
|
long my_l10tostr_mb2_or_mb4(long param_1,ulong param_2,long param_3,int param_4,ulong param_5)
{
ulong uVar1;
ulong uVar2;
uint uVar3;
ulong uVar4;
char *pcVar5;
long in_FS_OFFSET;
char local_49 [17];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar5 = local_49 + 1;
uVar4 = -param_5;
if ((long)param_5 >= 0 || param_4 >= 0) {
uVar4 = param_5;
}
local_49[2] = 0;
local_49[1] = (char)(uVar4 / 10) * -10 + (char)uVar4 + '0';
uVar2 = uVar4 / 10;
while (uVar1 = uVar2, 9 < uVar4) {
pcVar5[-1] = (char)(uVar1 / 10) * -10 + (char)uVar1 + '0';
pcVar5 = pcVar5 + -1;
uVar2 = uVar1 / 10;
uVar4 = uVar1;
}
if ((long)param_5 < 0 && param_4 < 0) {
pcVar5[-1] = '-';
pcVar5 = pcVar5 + -1;
}
uVar4 = param_2;
if (0 < param_3) {
do {
if (((long)*pcVar5 == 0) ||
(uVar3 = (**(code **)(*(long *)(param_1 + 0xb8) + 0x30))
(param_1,(long)*pcVar5,uVar4,param_3 + param_2), (int)uVar3 < 1)) break;
uVar4 = uVar4 + uVar3;
pcVar5 = pcVar5 + 1;
} while (uVar4 < param_3 + param_2);
}
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return (long)((int)uVar4 - (int)param_2);
}
|
|
17,794
|
my_uca_contraction_find
|
eloqsql/strings/ctype-uca.c
|
static inline const MY_CONTRACTION *
my_uca_contraction_find(const MY_CONTRACTIONS *list, my_wc_t *wc, size_t len)
{
MY_CONTRACTION *c, *last;
DBUG_ASSERT(len <= MY_UCA_MAX_CONTRACTION);
for (c= list->item, last= c + list->nitems; c < last; c++)
{
if ((len >= MY_UCA_MAX_CONTRACTION || c->ch[len] == 0) &&
!c->with_context &&
!my_wmemcmp(c->ch, wc, len))
return c;
}
return NULL;
}
|
O0
|
c
|
my_uca_contraction_find:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0xaf2d6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq $0x58, (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xaf34f
cmpq $0x6, -0x20(%rbp)
jae 0xaf315
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0xaf33f
movq -0x28(%rbp), %rax
cmpb $0x0, 0x52(%rax)
jne 0xaf33f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xaf370
cmpl $0x0, %eax
jne 0xaf33f
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf357
jmp 0xaf341
movq -0x28(%rbp), %rax
addq $0x58, %rax
movq %rax, -0x28(%rbp)
jmp 0xaf2f5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_uca_contraction_find:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
jmp short $+2
loc_AF2D6:
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_28], rax
mov rax, [rbp+var_28]
mov rcx, [rbp+var_10]
imul rcx, [rcx], 58h ; 'X'
add rax, rcx
mov [rbp+var_30], rax
loc_AF2F5:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_AF34F
cmp [rbp+var_20], 6
jnb short loc_AF315
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
cmp qword ptr [rax+rcx*8], 0
jnz short loc_AF33F
loc_AF315:
mov rax, [rbp+var_28]
cmp byte ptr [rax+52h], 0
jnz short loc_AF33F
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_wmemcmp
cmp eax, 0
jnz short loc_AF33F
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_AF357
loc_AF33F:
jmp short $+2
loc_AF341:
mov rax, [rbp+var_28]
add rax, 58h ; 'X'
mov [rbp+var_28], rax
jmp short loc_AF2F5
loc_AF34F:
mov [rbp+var_8], 0
loc_AF357:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
unsigned long long my_uca_contraction_find(_QWORD *a1, long long a2, unsigned long long a3)
{
unsigned long long v4; // [rsp+0h] [rbp-30h]
unsigned long long v5; // [rsp+8h] [rbp-28h]
v5 = a1[1];
v4 = 88LL * *a1 + v5;
while ( v5 < v4 )
{
if ( (a3 >= 6 || !*(_QWORD *)(v5 + 8 * a3)) && !*(_BYTE *)(v5 + 82) && !(unsigned int)my_wmemcmp(v5, a2, a3) )
return v5;
v5 += 88LL;
}
return 0LL;
}
|
my_uca_contraction_find:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x001af2d6
LAB_001af2d6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
IMUL RCX,qword ptr [RCX],0x58
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
LAB_001af2f5:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001af34f
CMP qword ptr [RBP + -0x20],0x6
JNC 0x001af315
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + RCX*0x8],0x0
JNZ 0x001af33f
LAB_001af315:
MOV RAX,qword ptr [RBP + -0x28]
CMP byte ptr [RAX + 0x52],0x0
JNZ 0x001af33f
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001af370
CMP EAX,0x0
JNZ 0x001af33f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001af357
LAB_001af33f:
JMP 0x001af341
LAB_001af341:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x58
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001af2f5
LAB_001af34f:
MOV qword ptr [RBP + -0x8],0x0
LAB_001af357:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
ulong my_uca_contraction_find(long *param_1,int8 param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
ulong local_30;
local_30 = param_1[1];
uVar2 = local_30 + *param_1 * 0x58;
while( true ) {
if (uVar2 <= local_30) {
return 0;
}
if ((((5 < param_3) || (*(long *)(local_30 + param_3 * 8) == 0)) &&
(*(char *)(local_30 + 0x52) == '\0')) &&
(iVar1 = my_wmemcmp(local_30,param_2,param_3), iVar1 == 0)) break;
local_30 = local_30 + 0x58;
}
return local_30;
}
|
|
17,795
|
LefDefParser::defwBeginextDate()
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwBeginextDate()
{
time_t todayTime;
char *rettime;
if (!defwFile)
return DEFW_UNINITIALIZED;
if (!defwDidInit)
return DEFW_BAD_ORDER;
if (defwState != DEFW_BEGINEXT_START &&
defwState != DEFW_BEGINEXT)
return DEFW_BAD_ORDER;
todayTime = time(NULL); // time in UTC
rettime = ctime(&todayTime); // convert to string
rettime[strlen(rettime) - 1] = '\0'; // replace \n with \0
fprintf(defwFile, " DATE \"%s\"", rettime);
defwState = DEFW_BEGINEXT;
defwLines++;
return DEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::defwBeginextDate():
subq $0x28, %rsp
leaq 0x930d(%rip), %rax # 0x2b158
cmpq $0x0, (%rax)
jne 0x21e5e
movl $0x1, 0x24(%rsp)
jmp 0x21f24
leaq 0x930f(%rip), %rax # 0x2b174
cmpl $0x0, (%rax)
jne 0x21e77
movl $0x2, 0x24(%rsp)
jmp 0x21f24
leaq 0x92e6(%rip), %rax # 0x2b164
cmpl $0x60, (%rax)
je 0x21e9c
leaq 0x92da(%rip), %rax # 0x2b164
cmpl $0x61, (%rax)
je 0x21e9c
movl $0x2, 0x24(%rsp)
jmp 0x21f24
xorl %eax, %eax
movl %eax, %edi
callq 0x1070
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1040
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1050
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
leaq 0x9274(%rip), %rax # 0x2b158
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x3489(%rip), %rsi # 0x2537c
movb $0x0, %al
callq 0x10f0
leaq 0x9263(%rip), %rax # 0x2b164
movl $0x61, (%rax)
leaq 0x9252(%rip), %rax # 0x2b160
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9246(%rip), %rax # 0x2b160
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
|
_ZN12LefDefParser16defwBeginextDateEv:
sub rsp, 28h
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
cmp qword ptr [rax], 0
jnz short loc_21E5E
mov [rsp+28h+var_4], 1
jmp loc_21F24
loc_21E5E:
lea rax, _ZN12LefDefParser11defwDidInitE; LefDefParser::defwDidInit
cmp dword ptr [rax], 0
jnz short loc_21E77
mov [rsp+28h+var_4], 2
jmp loc_21F24
loc_21E77:
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 60h ; '`'
jz short loc_21E9C
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
cmp dword ptr [rax], 61h ; 'a'
jz short loc_21E9C
mov [rsp+28h+var_4], 2
jmp loc_21F24
loc_21E9C:
xor eax, eax
mov edi, eax
call _time
mov [rsp+28h+var_10], rax
lea rdi, [rsp+28h+var_10]
call _ctime
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_18]
call _strlen
mov rcx, rax
mov rax, [rsp+28h+var_20]
sub rcx, 1
mov byte ptr [rax+rcx], 0
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
mov rdx, [rsp+28h+var_18]
lea rsi, aDateS; " DATE \"%s\""
mov al, 0
call _fprintf
lea rax, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov dword ptr [rax], 61h ; 'a'
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
mov [rax], ecx
mov [rsp+28h+var_4], 0
loc_21F24:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
|
long long LefDefParser::defwBeginextDate(LefDefParser *this)
{
const char *v2; // [rsp+8h] [rbp-20h]
long long v3; // [rsp+18h] [rbp-10h] BYREF
if ( LefDefParser::defwFile )
{
if ( LefDefParser::defwDidInit )
{
if ( LefDefParser::defwState == 96 || LefDefParser::defwState == 97 )
{
v3 = time(0LL);
v2 = (const char *)ctime(&v3);
v2[strlen(v2) - 1] = 0;
fprintf(LefDefParser::defwFile, " DATE \"%s\"", v2);
LefDefParser::defwState = 97;
++LefDefParser::defwLines;
return 0;
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
defwBeginextDate:
SUB RSP,0x28
LEA RAX,[0x12b158]
CMP qword ptr [RAX],0x0
JNZ 0x00121e5e
MOV dword ptr [RSP + 0x24],0x1
JMP 0x00121f24
LAB_00121e5e:
LEA RAX,[0x12b174]
CMP dword ptr [RAX],0x0
JNZ 0x00121e77
MOV dword ptr [RSP + 0x24],0x2
JMP 0x00121f24
LAB_00121e77:
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x60
JZ 0x00121e9c
LEA RAX,[0x12b164]
CMP dword ptr [RAX],0x61
JZ 0x00121e9c
MOV dword ptr [RSP + 0x24],0x2
JMP 0x00121f24
LAB_00121e9c:
XOR EAX,EAX
MOV EDI,EAX
CALL 0x00101070
MOV qword ptr [RSP + 0x18],RAX
LEA RDI,[RSP + 0x18]
CALL 0x00101040
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x00101050
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
SUB RCX,0x1
MOV byte ptr [RAX + RCX*0x1],0x0
LEA RAX,[0x12b158]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x10]
LEA RSI,[0x12537c]
MOV AL,0x0
CALL 0x001010f0
LEA RAX,[0x12b164]
MOV dword ptr [RAX],0x61
LEA RAX,[0x12b160]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x12b160]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x24],0x0
LAB_00121f24:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
/* LefDefParser::defwBeginextDate() */
int4 LefDefParser::defwBeginextDate(void)
{
char *__s;
size_t sVar1;
time_t local_10;
int4 local_4;
if (defwFile == (FILE *)0x0) {
local_4 = 1;
}
else if (defwDidInit == 0) {
local_4 = 2;
}
else if ((defwState == 0x60) || (defwState == 0x61)) {
local_10 = time((time_t *)0x0);
__s = ctime(&local_10);
sVar1 = strlen(__s);
__s[sVar1 - 1] = '\0';
fprintf(defwFile," DATE \"%s\"",__s);
defwState = 0x61;
defwLines = defwLines + 1;
local_4 = 0;
}
else {
local_4 = 2;
}
return local_4;
}
|
|
17,796
|
stbi_is_16_bit_from_file
|
mnn-tts/MNN/3rd_party/imageHelper/stb_image.h
|
STBIDEF int stbi_is_16_bit_from_file(FILE *f)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__is_16_main(&s);
fseek(f,pos,SEEK_SET);
return r;
}
|
O0
|
c
|
stbi_is_16_bit_from_file:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rdi
callq 0x20a0
movq %rax, 0x8(%rsp)
movq 0xf0(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x2710
leaq 0x10(%rsp), %rdi
callq 0x4160
movl %eax, 0xec(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0x20f0
movl 0xec(%rsp), %eax
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
|
stbi_is_16_bit_from_file:
sub rsp, 0F8h
mov [rsp+0F8h+var_8], rdi
mov rdi, [rsp+0F8h+var_8]
call _ftell
mov [rsp+0F8h+var_F0], rax
mov rsi, [rsp+0F8h+var_8]
lea rdi, [rsp+0F8h+var_E8]
call _ZL16stbi__start_fileP13stbi__contextP8_IO_FILE; stbi__start_file(stbi__context *,_IO_FILE *)
lea rdi, [rsp+0F8h+var_E8]
call _ZL16stbi__is_16_mainP13stbi__context; stbi__is_16_main(stbi__context *)
mov [rsp+0F8h+var_C], eax
mov rdi, [rsp+0F8h+var_8]
mov rsi, [rsp+0F8h+var_F0]
xor edx, edx
call _fseek
mov eax, [rsp+0F8h+var_C]
add rsp, 0F8h
retn
|
long long stbi_is_16_bit_from_file(long long a1)
{
long long v2; // [rsp+8h] [rbp-F0h]
_BYTE v3[220]; // [rsp+10h] [rbp-E8h] BYREF
unsigned int is_16_main; // [rsp+ECh] [rbp-Ch]
long long v5; // [rsp+F0h] [rbp-8h]
v5 = a1;
v2 = ftell(a1);
stbi__start_file((long long)v3, a1);
is_16_main = stbi__is_16_main(v3);
fseek(v5, v2, 0LL);
return is_16_main;
}
|
stbi_is_16_bit_from_file:
SUB RSP,0xf8
MOV qword ptr [RSP + 0xf0],RDI
MOV RDI,qword ptr [RSP + 0xf0]
CALL 0x001020a0
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP + 0xf0]
LEA RDI,[RSP + 0x10]
CALL 0x00102710
LEA RDI,[RSP + 0x10]
CALL 0x00104160
MOV dword ptr [RSP + 0xec],EAX
MOV RDI,qword ptr [RSP + 0xf0]
MOV RSI,qword ptr [RSP + 0x8]
XOR EDX,EDX
CALL 0x001020f0
MOV EAX,dword ptr [RSP + 0xec]
ADD RSP,0xf8
RET
|
int4 stbi_is_16_bit_from_file(FILE *param_1)
{
long __off;
stbi__context local_e8 [220];
int4 local_c;
_IO_FILE *local_8;
local_8 = param_1;
__off = ftell(param_1);
stbi__start_file(local_e8,local_8);
local_c = stbi__is_16_main(local_e8);
fseek(local_8,__off,0);
return local_c;
}
|
|
17,797
|
my_xml_parse
|
eloqsql/strings/xml.c
|
int my_xml_parse(MY_XML_PARSER *p,const char *str, size_t len)
{
my_xml_attr_rewind(p);
p->beg=str;
p->cur=str;
p->end=str+len;
while ( p->cur < p->end )
{
MY_XML_ATTR a;
if (p->cur[0] == '<')
{
int lex;
int question=0;
int exclam=0;
lex=my_xml_scan(p,&a);
if (MY_XML_COMMENT == lex)
continue;
if (lex == MY_XML_CDATA)
{
a.beg+= 9;
a.end-= 3;
my_xml_value(p, a.beg, (size_t) (a.end-a.beg));
continue;
}
lex=my_xml_scan(p,&a);
if (MY_XML_SLASH == lex)
{
if (MY_XML_IDENT != (lex=my_xml_scan(p,&a)))
{
sprintf(p->errstr,"%s unexpected (ident wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
goto gt;
}
if (MY_XML_EXCLAM == lex)
{
lex=my_xml_scan(p,&a);
exclam=1;
}
else if (MY_XML_QUESTION == lex)
{
lex=my_xml_scan(p,&a);
question=1;
}
if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_TAG;
if (MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg)))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or '/' wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
while ((MY_XML_IDENT == (lex=my_xml_scan(p,&a))) ||
((MY_XML_STRING == lex && exclam)))
{
MY_XML_ATTR b;
if (MY_XML_EQ == (lex=my_xml_scan(p,&b)))
{
lex=my_xml_scan(p,&b);
if ( (lex == MY_XML_IDENT) || (lex == MY_XML_STRING) )
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_value(p,b.beg,(size_t) (b.end-b.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else
{
sprintf(p->errstr,"%s unexpected (ident or string wanted)",
lex2str(lex));
return MY_XML_ERROR;
}
}
else if (MY_XML_IDENT == lex)
{
p->current_node_type= MY_XML_NODE_ATTR;
if ((MY_XML_OK != my_xml_enter(p,a.beg,(size_t) (a.end-a.beg))) ||
(MY_XML_OK != my_xml_leave(p,a.beg,(size_t) (a.end-a.beg))))
return MY_XML_ERROR;
}
else if ((MY_XML_STRING == lex) && exclam)
{
/*
We are in <!DOCTYPE>, e.g.
<!DOCTYPE name SYSTEM "SystemLiteral">
<!DOCTYPE name PUBLIC "PublidLiteral" "SystemLiteral">
Just skip "SystemLiteral" and "PublicidLiteral"
*/
}
else
break;
}
if (lex == MY_XML_SLASH)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
gt:
if (question)
{
if (lex != MY_XML_QUESTION)
{
sprintf(p->errstr,"%s unexpected ('?' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
lex=my_xml_scan(p,&a);
}
if (exclam)
{
if (MY_XML_OK != my_xml_leave(p,NULL,0))
return MY_XML_ERROR;
}
if (lex != MY_XML_GT)
{
sprintf(p->errstr,"%s unexpected ('>' wanted)",lex2str(lex));
return MY_XML_ERROR;
}
}
else
{
a.beg=p->cur;
for ( ; (p->cur < p->end) && (p->cur[0] != '<') ; p->cur++);
a.end=p->cur;
if (!(p->flags & MY_XML_FLAG_SKIP_TEXT_NORMALIZATION))
my_xml_norm_text(&a);
if (a.beg != a.end)
{
my_xml_value(p,a.beg,(size_t) (a.end-a.beg));
}
}
}
if (p->attr.start[0])
{
sprintf(p->errstr,"unexpected END-OF-INPUT");
return MY_XML_ERROR;
}
return MY_XML_OK;
}
|
O3
|
c
|
my_xml_parse:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x118(%rdi), %rcx
movq %rcx, 0x120(%rdi)
movq %rsi, 0x128(%rdi)
movq %rsi, 0x130(%rdi)
leaq (%rsi,%rdx), %rax
movq %rax, 0x138(%rdi)
testq %rdx, %rdx
jle 0xdd66d
leaq -0x40(%rbp), %r15
cmpb $0x3c, (%rsi)
jne 0xdd3af
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
cmpl $0x43, %eax
je 0xdd64f
cmpl $0x44, %eax
jne 0xdd414
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xdd64f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x9, %rsi
subq %rsi, %rdx
addq $-0x3, %rdx
jmp 0xdd40a
movq %rsi, -0x40(%rbp)
movq %rsi, %rdx
cmpq %rax, %rsi
jae 0xdd3d5
subq %rsi, %rax
movq %rsi, %rdx
cmpb $0x3c, (%rdx)
je 0xdd3d5
incq %rdx
movq %rdx, 0x130(%rbx)
decq %rax
jne 0xdd3c1
movq %rdx, -0x38(%rbp)
testb $0x2, (%rbx)
jne 0xdd3ee
movq %r15, %rdi
callq 0xddd6f
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
cmpq %rdx, %rsi
je 0xdd64f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xdd64f
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
jmp 0xdd64f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
cmpl $0x2f, %eax
jne 0xdd466
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
cmpl $0x49, %eax
jne 0xdd6cd
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0xdda35
testl %eax, %eax
jne 0xdd71f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
movl %eax, %r13d
jmp 0xdd649
movl %eax, %r14d
cmpl $0x21, %eax
sete %r12b
cmpl $0x3f, %eax
je 0xdd47b
cmpl $0x21, %r14d
jne 0xdd488
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
jmp 0xdd48e
movb $0x1, %r12b
movl %r14d, %eax
cmpl $0x49, %eax
jne 0xdd6b9
movl $0x0, 0x4(%rbx)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0xddbf8
testl %eax, %eax
jne 0xdd71f
movb %r12b, -0x29(%rbp)
movl %r14d, %r12d
xorl $0x21, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
movl %eax, %r13d
xorl $0x53, %eax
orl %r12d, %eax
sete %al
cmpl $0x49, %r13d
je 0xdd4e9
testb %al, %al
je 0xdd5d2
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xdd737
cmpl $0x49, %eax
je 0xdd577
movl %eax, %r13d
cmpl $0x3d, %eax
jne 0xdd5b6
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0xdd737
cmpl $0x53, %eax
je 0xdd520
cmpl $0x49, %eax
jne 0xdd6e1
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r13
movq -0x38(%rbp), %r15
subq %r13, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xddbf8
testl %eax, %eax
jne 0xdd71f
movq 0x150(%rbx), %rax
testq %rax, %rax
je 0xdd56c
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq *%rax
testl %eax, %eax
jne 0xdd71f
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
jmp 0xdd5a8
movl $0x1, 0x4(%rbx)
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r13
subq %r15, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xddbf8
testl %eax, %eax
jne 0xdd71f
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xdda35
testl %eax, %eax
je 0xdd5c2
jmp 0xdd71f
cmpl $0x21, %r14d
jne 0xdd5ce
cmpl $0x53, %r13d
jne 0xdd5ce
movq %rbx, %rdi
leaq -0x40(%rbp), %r15
jmp 0xdd4c7
leaq -0x40(%rbp), %r15
cmpl $0x2f, %r13d
movb -0x29(%rbp), %r12b
jne 0xdd5fe
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xdda35
testl %eax, %eax
jne 0xdd71f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
movl %eax, %r13d
testb %r12b, %r12b
jne 0xdd62f
cmpl $0x3f, %r13d
jne 0xdd6f5
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xdda35
testl %eax, %eax
jne 0xdd71f
movq %rbx, %rdi
movq %r15, %rsi
callq 0xdd737
movl %eax, %r13d
cmpl $0x21, %r14d
jne 0xdd649
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xdda35
testl %eax, %eax
jne 0xdd71f
cmpl $0x3e, %r13d
jne 0xdd6a4
movq 0x130(%rbx), %rsi
movq 0x138(%rbx), %rax
cmpq %rax, %rsi
jb 0xdd368
movq 0x118(%rbx), %rcx
cmpb $0x0, (%rcx)
je 0xdd69c
addq $0x8, %rbx
leaq 0x945c(%rip), %rcx # 0xe6ad9
movl $0x1, %r14d
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x29920
jmp 0xdd725
xorl %r14d, %r14d
jmp 0xdd725
addq $0x8, %rbx
movl %r13d, %edi
callq 0xdd99a
leaq 0x9407(%rip), %rcx # 0xe6abe
jmp 0xdd708
addq $0x8, %rbx
movl %eax, %edi
callq 0xdd99a
leaq 0x938d(%rip), %rcx # 0xe6a58
jmp 0xdd708
addq $0x8, %rbx
movl %eax, %edi
callq 0xdd99a
leaq 0x935c(%rip), %rcx # 0xe6a3b
jmp 0xdd708
addq $0x8, %rbx
movl %eax, %edi
callq 0xdd99a
leaq 0x9389(%rip), %rcx # 0xe6a7c
jmp 0xdd708
addq $0x8, %rbx
movl %r13d, %edi
callq 0xdd99a
leaq 0x939b(%rip), %rcx # 0xe6aa3
movl $0x80, %edx
movq %rbx, %rdi
movl $0x1, %esi
movq %rax, %r8
xorl %eax, %eax
callq 0x29920
movl $0x1, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_xml_parse:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdi
mov rcx, [rdi+118h]
mov [rdi+120h], rcx
mov [rdi+128h], rsi
mov [rdi+130h], rsi
lea rax, [rsi+rdx]
mov [rdi+138h], rax
test rdx, rdx
jle loc_DD66D
lea r15, [rbp+var_40]
loc_DD368:
cmp byte ptr [rsi], 3Ch ; '<'
jnz short loc_DD3AF
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 43h ; 'C'
jz loc_DD64F
cmp eax, 44h ; 'D'
jnz loc_DD414
mov rax, [rbx+150h]
test rax, rax
jz loc_DD64F
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
add rsi, 9
sub rdx, rsi
add rdx, 0FFFFFFFFFFFFFFFDh
jmp short loc_DD40A
loc_DD3AF:
mov [rbp+var_40], rsi
mov rdx, rsi
cmp rsi, rax
jnb short loc_DD3D5
sub rax, rsi
mov rdx, rsi
loc_DD3C1:
cmp byte ptr [rdx], 3Ch ; '<'
jz short loc_DD3D5
inc rdx
mov [rbx+130h], rdx
dec rax
jnz short loc_DD3C1
loc_DD3D5:
mov [rbp+var_38], rdx
test byte ptr [rbx], 2
jnz short loc_DD3EE
mov rdi, r15
call my_xml_norm_text
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
loc_DD3EE:
cmp rsi, rdx
jz loc_DD64F
mov rax, [rbx+150h]
test rax, rax
jz loc_DD64F
sub rdx, rsi
loc_DD40A:
mov rdi, rbx
call rax
jmp loc_DD64F
loc_DD414:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 2Fh ; '/'
jnz short loc_DD466
mov rdi, rbx
mov rsi, r15
call my_xml_scan
cmp eax, 49h ; 'I'
jnz loc_DD6CD
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_leave
test eax, eax
jnz loc_DD71F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
jmp loc_DD649
loc_DD466:
mov r14d, eax
cmp eax, 21h ; '!'
setz r12b
cmp eax, 3Fh ; '?'
jz short loc_DD47B
cmp r14d, 21h ; '!'
jnz short loc_DD488
loc_DD47B:
mov rdi, rbx
mov rsi, r15
call my_xml_scan
jmp short loc_DD48E
loc_DD488:
mov r12b, 1
mov eax, r14d
loc_DD48E:
cmp eax, 49h ; 'I'
jnz loc_DD6B9
mov dword ptr [rbx+4], 0
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
sub rdx, rsi
mov rdi, rbx
call my_xml_enter
test eax, eax
jnz loc_DD71F
mov [rbp+var_29], r12b
mov r12d, r14d
xor r12d, 21h
mov rdi, rbx
loc_DD4C7:
mov rsi, r15
call my_xml_scan
mov r13d, eax
xor eax, 53h
or eax, r12d
setz al
cmp r13d, 49h ; 'I'
jz short loc_DD4E9
test al, al
jz loc_DD5D2
loc_DD4E9:
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 49h ; 'I'
jz short loc_DD577
mov r13d, eax
cmp eax, 3Dh ; '='
jnz loc_DD5B6
mov rdi, rbx
lea rsi, [rbp+var_50]
call my_xml_scan
cmp eax, 53h ; 'S'
jz short loc_DD520
cmp eax, 49h ; 'I'
jnz loc_DD6E1
loc_DD520:
mov dword ptr [rbx+4], 1
mov r13, [rbp+var_40]
mov r15, [rbp+var_38]
sub r15, r13
mov rdi, rbx
mov rsi, r13
mov rdx, r15
call my_xml_enter
test eax, eax
jnz loc_DD71F
mov rax, [rbx+150h]
test rax, rax
jz short loc_DD56C
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_48]
sub rdx, rsi
mov rdi, rbx
call rax
test eax, eax
jnz loc_DD71F
loc_DD56C:
mov rdi, rbx
mov rsi, r13
mov rdx, r15
jmp short loc_DD5A8
loc_DD577:
mov dword ptr [rbx+4], 1
mov r15, [rbp+var_40]
mov r13, [rbp+var_38]
sub r13, r15
mov rdi, rbx
mov rsi, r15
mov rdx, r13
call my_xml_enter
test eax, eax
jnz loc_DD71F
mov rdi, rbx
mov rsi, r15
mov rdx, r13
loc_DD5A8:
call my_xml_leave
test eax, eax
jz short loc_DD5C2
jmp loc_DD71F
loc_DD5B6:
cmp r14d, 21h ; '!'
jnz short loc_DD5CE
cmp r13d, 53h ; 'S'
jnz short loc_DD5CE
loc_DD5C2:
mov rdi, rbx
lea r15, [rbp+var_40]
jmp loc_DD4C7
loc_DD5CE:
lea r15, [rbp+var_40]
loc_DD5D2:
cmp r13d, 2Fh ; '/'
mov r12b, [rbp+var_29]
jnz short loc_DD5FE
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_DD71F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_DD5FE:
test r12b, r12b
jnz short loc_DD62F
cmp r13d, 3Fh ; '?'
jnz loc_DD6F5
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_DD71F
mov rdi, rbx
mov rsi, r15
call my_xml_scan
mov r13d, eax
loc_DD62F:
cmp r14d, 21h ; '!'
jnz short loc_DD649
mov rdi, rbx
xor esi, esi
xor edx, edx
call my_xml_leave
test eax, eax
jnz loc_DD71F
loc_DD649:
cmp r13d, 3Eh ; '>'
jnz short loc_DD6A4
loc_DD64F:
mov rsi, [rbx+130h]
mov rax, [rbx+138h]
cmp rsi, rax
jb loc_DD368
mov rcx, [rbx+118h]
loc_DD66D:
cmp byte ptr [rcx], 0
jz short loc_DD69C
add rbx, 8
lea rcx, aUnexpectedEndO; "unexpected END-OF-INPUT"
mov r14d, 1
mov edx, 80h
mov rdi, rbx
mov esi, 1
xor eax, eax
call ___sprintf_chk
jmp loc_DD725
loc_DD69C:
xor r14d, r14d
jmp loc_DD725
loc_DD6A4:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan; "%s unexpected ('>' wanted)"
jmp short loc_DD708
loc_DD6B9:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde; "%s unexpected (ident or '/' wanted)"
jmp short loc_DD708
loc_DD6CD:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_0; "%s unexpected (ident wanted)"
jmp short loc_DD708
loc_DD6E1:
add rbx, 8
mov edi, eax
call lex2str
lea rcx, aSUnexpectedIde_1; "%s unexpected (ident or string wanted)"
jmp short loc_DD708
loc_DD6F5:
add rbx, 8
mov edi, r13d
call lex2str
lea rcx, aSUnexpectedWan_0; "%s unexpected ('?' wanted)"
loc_DD708:
mov edx, 80h
mov rdi, rbx
mov esi, 1
mov r8, rax
xor eax, eax
call ___sprintf_chk
loc_DD71F:
mov r14d, 1
loc_DD725:
mov eax, r14d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_xml_parse(long long a1, _BYTE *a2, long long a3)
{
_BYTE *v4; // rcx
_BYTE *v5; // rax
int v6; // eax
void ( *v7)(long long, _BYTE *, long long); // rax
long long v8; // rdx
_BYTE *v9; // rdx
long long v10; // rax
unsigned int v11; // eax
unsigned int v12; // eax
unsigned int v13; // r13d
unsigned int v14; // r14d
bool v15; // r12
long long i; // rdi
unsigned int v17; // eax
unsigned int v18; // eax
_BYTE *v19; // r13
long long v20; // r15
unsigned int ( *v21)(long long, _QWORD, _QWORD); // rax
long long v22; // rdi
_BYTE *v23; // rsi
long long v24; // rdx
_BYTE *v25; // r15
long long v26; // r13
bool v27; // r12
unsigned int v28; // r14d
long long v29; // rax
long long v30; // rax
long long v31; // rax
long long v32; // rax
long long v33; // rax
_QWORD v35[2]; // [rsp+0h] [rbp-50h] BYREF
_BYTE *v36; // [rsp+10h] [rbp-40h] BYREF
_BYTE *v37; // [rsp+18h] [rbp-38h]
bool v38; // [rsp+27h] [rbp-29h]
v4 = *(_BYTE **)(a1 + 280);
*(_QWORD *)(a1 + 288) = v4;
*(_QWORD *)(a1 + 296) = a2;
*(_QWORD *)(a1 + 304) = a2;
v5 = &a2[a3];
*(_QWORD *)(a1 + 312) = &a2[a3];
if ( a3 <= 0 )
goto LABEL_57;
while ( *a2 != 60 )
{
v36 = a2;
v9 = a2;
if ( a2 < v5 )
{
v10 = v5 - a2;
v9 = a2;
do
{
if ( *v9 == 60 )
break;
*(_QWORD *)(a1 + 304) = ++v9;
--v10;
}
while ( v10 );
}
v37 = v9;
if ( (*(_BYTE *)a1 & 2) == 0 )
{
my_xml_norm_text(&v36);
a2 = v36;
v9 = v37;
}
if ( a2 != v9 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( v7 )
{
v8 = v9 - a2;
LABEL_16:
v7(a1, a2, v8);
}
}
LABEL_55:
a2 = *(_BYTE **)(a1 + 304);
v5 = *(_BYTE **)(a1 + 312);
if ( a2 >= v5 )
{
v4 = *(_BYTE **)(a1 + 280);
LABEL_57:
if ( *v4 )
{
v28 = 1;
__sprintf_chk(a1 + 8, 1LL, 128LL, "unexpected END-OF-INPUT");
}
else
{
return 0;
}
return v28;
}
}
v6 = my_xml_scan(a1, &v36);
if ( v6 == 67 )
goto LABEL_55;
if ( v6 == 68 )
{
v7 = *(void ( **)(long long, _BYTE *, long long))(a1 + 336);
if ( !v7 )
goto LABEL_55;
a2 = v36 + 9;
v8 = v37 - (v36 + 9) - 3;
goto LABEL_16;
}
v11 = my_xml_scan(a1, &v36);
if ( v11 == 47 )
{
v12 = my_xml_scan(a1, &v36);
if ( v12 == 73 )
{
if ( !(unsigned int)my_xml_leave(a1, v36, v37 - v36) )
{
v13 = my_xml_scan(a1, &v36);
goto LABEL_54;
}
}
else
{
v31 = lex2str(v12);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident wanted)", v31);
}
return 1;
}
v14 = v11;
v15 = v11 == 33;
if ( v11 == 63 || v11 == 33 )
v11 = my_xml_scan(a1, &v36);
else
v15 = 1;
if ( v11 != 73 )
{
v30 = lex2str(v11);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or '/' wanted)", v30);
return 1;
}
*(_DWORD *)(a1 + 4) = 0;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v38 = v15;
for ( i = a1; ; i = a1 )
{
v13 = my_xml_scan(i, &v36);
if ( v13 != 73 )
{
if ( v14 ^ 0x21 | v13 ^ 0x53 )
break;
}
v17 = my_xml_scan(a1, v35);
if ( v17 == 73 )
{
*(_DWORD *)(a1 + 4) = 1;
v25 = v36;
v26 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v22 = a1;
v23 = v25;
v24 = v26;
LABEL_40:
if ( (unsigned int)my_xml_leave(v22, v23, v24) )
return 1;
continue;
}
v13 = v17;
if ( v17 == 61 )
{
v18 = my_xml_scan(a1, v35);
if ( v18 != 83 && v18 != 73 )
{
v32 = lex2str(v18);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected (ident or string wanted)", v32);
return 1;
}
*(_DWORD *)(a1 + 4) = 1;
v19 = v36;
v20 = v37 - v36;
if ( (unsigned int)my_xml_enter(a1, v36, v37 - v36) )
return 1;
v21 = *(unsigned int ( **)(long long, _QWORD, _QWORD))(a1 + 336);
if ( v21 )
{
if ( v21(a1, v35[0], v35[1] - v35[0]) )
return 1;
}
v22 = a1;
v23 = v19;
v24 = v20;
goto LABEL_40;
}
if ( v14 != 33 || v17 != 83 )
break;
}
v27 = v38;
if ( v13 == 47 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
}
if ( v27 )
goto LABEL_52;
if ( v13 == 63 )
{
if ( (unsigned int)my_xml_leave(a1, 0LL, 0LL) )
return 1;
v13 = my_xml_scan(a1, &v36);
LABEL_52:
if ( v14 != 33 || !(unsigned int)my_xml_leave(a1, 0LL, 0LL) )
{
LABEL_54:
if ( v13 == 62 )
goto LABEL_55;
v29 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('>' wanted)", v29);
}
}
else
{
v33 = lex2str(v13);
__sprintf_chk(a1 + 8, 1LL, 128LL, "%s unexpected ('?' wanted)", v33);
}
return 1;
}
|
my_xml_parse:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
MOV RCX,qword ptr [RDI + 0x118]
MOV qword ptr [RDI + 0x120],RCX
MOV qword ptr [RDI + 0x128],RSI
MOV qword ptr [RDI + 0x130],RSI
LEA RAX,[RSI + RDX*0x1]
MOV qword ptr [RDI + 0x138],RAX
TEST RDX,RDX
JLE 0x001dd66d
LEA R15,[RBP + -0x40]
LAB_001dd368:
CMP byte ptr [RSI],0x3c
JNZ 0x001dd3af
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
CMP EAX,0x43
JZ 0x001dd64f
CMP EAX,0x44
JNZ 0x001dd414
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001dd64f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
ADD RSI,0x9
SUB RDX,RSI
ADD RDX,-0x3
JMP 0x001dd40a
LAB_001dd3af:
MOV qword ptr [RBP + -0x40],RSI
MOV RDX,RSI
CMP RSI,RAX
JNC 0x001dd3d5
SUB RAX,RSI
MOV RDX,RSI
LAB_001dd3c1:
CMP byte ptr [RDX],0x3c
JZ 0x001dd3d5
INC RDX
MOV qword ptr [RBX + 0x130],RDX
DEC RAX
JNZ 0x001dd3c1
LAB_001dd3d5:
MOV qword ptr [RBP + -0x38],RDX
TEST byte ptr [RBX],0x2
JNZ 0x001dd3ee
MOV RDI,R15
CALL 0x001ddd6f
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
LAB_001dd3ee:
CMP RSI,RDX
JZ 0x001dd64f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001dd64f
SUB RDX,RSI
LAB_001dd40a:
MOV RDI,RBX
CALL RAX
JMP 0x001dd64f
LAB_001dd414:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
CMP EAX,0x2f
JNZ 0x001dd466
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
CMP EAX,0x49
JNZ 0x001dd6cd
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x001dda35
TEST EAX,EAX
JNZ 0x001dd71f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
MOV R13D,EAX
JMP 0x001dd649
LAB_001dd466:
MOV R14D,EAX
CMP EAX,0x21
SETZ R12B
CMP EAX,0x3f
JZ 0x001dd47b
CMP R14D,0x21
JNZ 0x001dd488
LAB_001dd47b:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
JMP 0x001dd48e
LAB_001dd488:
MOV R12B,0x1
MOV EAX,R14D
LAB_001dd48e:
CMP EAX,0x49
JNZ 0x001dd6b9
MOV dword ptr [RBX + 0x4],0x0
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
SUB RDX,RSI
MOV RDI,RBX
CALL 0x001ddbf8
TEST EAX,EAX
JNZ 0x001dd71f
MOV byte ptr [RBP + -0x29],R12B
MOV R12D,R14D
XOR R12D,0x21
MOV RDI,RBX
LAB_001dd4c7:
MOV RSI,R15
CALL 0x001dd737
MOV R13D,EAX
XOR EAX,0x53
OR EAX,R12D
SETZ AL
CMP R13D,0x49
JZ 0x001dd4e9
TEST AL,AL
JZ 0x001dd5d2
LAB_001dd4e9:
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x001dd737
CMP EAX,0x49
JZ 0x001dd577
MOV R13D,EAX
CMP EAX,0x3d
JNZ 0x001dd5b6
MOV RDI,RBX
LEA RSI,[RBP + -0x50]
CALL 0x001dd737
CMP EAX,0x53
JZ 0x001dd520
CMP EAX,0x49
JNZ 0x001dd6e1
LAB_001dd520:
MOV dword ptr [RBX + 0x4],0x1
MOV R13,qword ptr [RBP + -0x40]
MOV R15,qword ptr [RBP + -0x38]
SUB R15,R13
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
CALL 0x001ddbf8
TEST EAX,EAX
JNZ 0x001dd71f
MOV RAX,qword ptr [RBX + 0x150]
TEST RAX,RAX
JZ 0x001dd56c
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x48]
SUB RDX,RSI
MOV RDI,RBX
CALL RAX
TEST EAX,EAX
JNZ 0x001dd71f
LAB_001dd56c:
MOV RDI,RBX
MOV RSI,R13
MOV RDX,R15
JMP 0x001dd5a8
LAB_001dd577:
MOV dword ptr [RBX + 0x4],0x1
MOV R15,qword ptr [RBP + -0x40]
MOV R13,qword ptr [RBP + -0x38]
SUB R13,R15
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
CALL 0x001ddbf8
TEST EAX,EAX
JNZ 0x001dd71f
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R13
LAB_001dd5a8:
CALL 0x001dda35
TEST EAX,EAX
JZ 0x001dd5c2
JMP 0x001dd71f
LAB_001dd5b6:
CMP R14D,0x21
JNZ 0x001dd5ce
CMP R13D,0x53
JNZ 0x001dd5ce
LAB_001dd5c2:
MOV RDI,RBX
LEA R15,[RBP + -0x40]
JMP 0x001dd4c7
LAB_001dd5ce:
LEA R15,[RBP + -0x40]
LAB_001dd5d2:
CMP R13D,0x2f
MOV R12B,byte ptr [RBP + -0x29]
JNZ 0x001dd5fe
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001dda35
TEST EAX,EAX
JNZ 0x001dd71f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
MOV R13D,EAX
LAB_001dd5fe:
TEST R12B,R12B
JNZ 0x001dd62f
CMP R13D,0x3f
JNZ 0x001dd6f5
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001dda35
TEST EAX,EAX
JNZ 0x001dd71f
MOV RDI,RBX
MOV RSI,R15
CALL 0x001dd737
MOV R13D,EAX
LAB_001dd62f:
CMP R14D,0x21
JNZ 0x001dd649
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x001dda35
TEST EAX,EAX
JNZ 0x001dd71f
LAB_001dd649:
CMP R13D,0x3e
JNZ 0x001dd6a4
LAB_001dd64f:
MOV RSI,qword ptr [RBX + 0x130]
MOV RAX,qword ptr [RBX + 0x138]
CMP RSI,RAX
JC 0x001dd368
MOV RCX,qword ptr [RBX + 0x118]
LAB_001dd66d:
CMP byte ptr [RCX],0x0
JZ 0x001dd69c
ADD RBX,0x8
LEA RCX,[0x1e6ad9]
MOV R14D,0x1
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
XOR EAX,EAX
CALL 0x00129920
JMP 0x001dd725
LAB_001dd69c:
XOR R14D,R14D
JMP 0x001dd725
LAB_001dd6a4:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x001dd99a
LEA RCX,[0x1e6abe]
JMP 0x001dd708
LAB_001dd6b9:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001dd99a
LEA RCX,[0x1e6a58]
JMP 0x001dd708
LAB_001dd6cd:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001dd99a
LEA RCX,[0x1e6a3b]
JMP 0x001dd708
LAB_001dd6e1:
ADD RBX,0x8
MOV EDI,EAX
CALL 0x001dd99a
LEA RCX,[0x1e6a7c]
JMP 0x001dd708
LAB_001dd6f5:
ADD RBX,0x8
MOV EDI,R13D
CALL 0x001dd99a
LEA RCX,[0x1e6aa3]
LAB_001dd708:
MOV EDX,0x80
MOV RDI,RBX
MOV ESI,0x1
MOV R8,RAX
XOR EAX,EAX
CALL 0x00129920
LAB_001dd71f:
MOV R14D,0x1
LAB_001dd725:
MOV EAX,R14D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Type propagation algorithm not settling */
bool my_xml_parse(byte *param_1,char *param_2,long param_3)
{
char cVar1;
int iVar2;
int iVar3;
code *pcVar4;
int8 uVar5;
char *pcVar6;
char *pcVar7;
long lVar8;
bool bVar9;
long local_58;
long local_50;
char *local_48;
char *local_40;
char local_31;
pcVar7 = *(char **)(param_1 + 0x118);
*(char **)(param_1 + 0x120) = pcVar7;
*(char **)(param_1 + 0x128) = param_2;
*(char **)(param_1 + 0x130) = param_2;
pcVar6 = param_2 + param_3;
*(char **)(param_1 + 0x138) = pcVar6;
if (0 < param_3) {
do {
if (*param_2 == '<') {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x43) {
if (iVar2 == 0x44) {
pcVar4 = *(code **)(param_1 + 0x150);
if (pcVar4 != (code *)0x0) {
pcVar7 = local_40 + (-3 - (long)(local_48 + 9));
pcVar6 = local_48 + 9;
goto LAB_001dd40a;
}
}
else {
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x2f) {
bVar9 = iVar2 == 0x21;
if ((iVar2 == 0x3f) || (iVar2 == 0x21)) {
iVar3 = my_xml_scan(param_1,&local_48);
}
else {
bVar9 = true;
iVar3 = iVar2;
}
if (iVar3 == 0x49) {
param_1[4] = 0;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
iVar3 = my_xml_enter(param_1,local_48,(long)local_40 - (long)local_48);
local_31 = bVar9;
do {
if (iVar3 != 0) {
return true;
}
LAB_001dd4c7:
iVar3 = my_xml_scan(param_1,&local_48);
if ((iVar3 != 0x49) && (iVar3 != 0x53 || iVar2 != 0x21)) goto LAB_001dd5d2;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if (iVar3 == 0x49) {
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
goto joined_r0x001dd599;
}
if (iVar3 != 0x3d) goto LAB_001dd5b6;
iVar3 = my_xml_scan(param_1,&local_58);
pcVar6 = local_48;
if ((iVar3 != 0x53) && (iVar3 != 0x49)) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or string wanted)";
goto LAB_001dd708;
}
param_1[4] = 1;
param_1[5] = 0;
param_1[6] = 0;
param_1[7] = 0;
lVar8 = (long)local_40 - (long)local_48;
iVar3 = my_xml_enter(param_1,local_48,lVar8);
if (iVar3 != 0) {
return true;
}
if (*(code **)(param_1 + 0x150) != (code *)0x0) {
iVar3 = (**(code **)(param_1 + 0x150))(param_1,local_58,local_50 - local_58);
joined_r0x001dd599:
if (iVar3 != 0) {
return true;
}
}
iVar3 = my_xml_leave(param_1,pcVar6,lVar8);
} while( true );
}
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (ident or \'/\' wanted)";
LAB_001dd708:
__sprintf_chk(param_1 + 8,1,0x80,pcVar6,uVar5);
return true;
}
iVar2 = my_xml_scan(param_1,&local_48);
if (iVar2 != 0x49) {
uVar5 = lex2str(iVar2);
pcVar6 = "%s unexpected (ident wanted)";
goto LAB_001dd708;
}
iVar2 = my_xml_leave(param_1,local_48,(long)local_40 - (long)local_48);
if (iVar2 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
LAB_001dd649:
if (iVar3 != 0x3e) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'>\' wanted)";
goto LAB_001dd708;
}
}
}
}
else {
local_40 = param_2;
if (param_2 < pcVar6) {
lVar8 = (long)pcVar6 - (long)param_2;
do {
if (*local_40 == '<') break;
local_40 = local_40 + 1;
*(char **)(param_1 + 0x130) = local_40;
lVar8 = lVar8 + -1;
} while (lVar8 != 0);
}
local_48 = param_2;
if ((*param_1 & 2) == 0) {
my_xml_norm_text(&local_48);
}
if ((local_48 != local_40) && (pcVar4 = *(code **)(param_1 + 0x150), pcVar4 != (code *)0x0))
{
pcVar7 = local_40 + -(long)local_48;
pcVar6 = local_48;
LAB_001dd40a:
(*pcVar4)(param_1,pcVar6,pcVar7);
}
}
param_2 = *(char **)(param_1 + 0x130);
pcVar6 = *(char **)(param_1 + 0x138);
} while (param_2 < pcVar6);
pcVar7 = *(char **)(param_1 + 0x118);
}
cVar1 = *pcVar7;
if (cVar1 != '\0') {
__sprintf_chk(param_1 + 8,1,0x80,"unexpected END-OF-INPUT");
}
return cVar1 != '\0';
LAB_001dd5b6:
if ((iVar2 != 0x21) || (iVar3 != 0x53)) {
LAB_001dd5d2:
cVar1 = local_31;
if (iVar3 == 0x2f) {
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if (cVar1 == '\0') {
if (iVar3 != 0x3f) {
uVar5 = lex2str(iVar3);
pcVar6 = "%s unexpected (\'?\' wanted)";
goto LAB_001dd708;
}
iVar3 = my_xml_leave(param_1,0,0);
if (iVar3 != 0) {
return true;
}
iVar3 = my_xml_scan(param_1,&local_48);
}
if ((iVar2 == 0x21) && (iVar2 = my_xml_leave(param_1,0,0), iVar2 != 0)) {
return true;
}
goto LAB_001dd649;
}
goto LAB_001dd4c7;
}
|
|
17,798
|
bool 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>::contains<char const (&) [3], 0>(char const (&) [3]) const
|
monkey531[P]llama/common/json.hpp
|
constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
}
|
O3
|
cpp
|
bool 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>::contains<char const (&) [3], 0>(char const (&) [3]) const:
cmpb $0x1, (%rdi)
jne 0xc33b9
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xc33bc
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a220
testl %eax, %eax
je 0xc33ac
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xc3392
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xc33bf
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C33B9
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_C33BC
mov r15, rsi
loc_C3392:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C33AC
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_C3392
loc_C33AC:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_C33BF
loc_C33B9:
xor eax, eax
retn
loc_C33BC:
mov rax, rbx
loc_C33BF:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c33b9
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001c33bc
MOV R15,RSI
LAB_001c3392:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a220
TEST EAX,EAX
JZ 0x001c33ac
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001c3392
LAB_001c33ac:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001c33bf
LAB_001c33b9:
XOR EAX,EAX
RET
LAB_001c33bc:
MOV RAX,RBX
LAB_001c33bf:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
|
|
17,799
|
ma_bitmap_set
|
eloqsql/storage/maria/ma_bitmap.c
|
my_bool _ma_bitmap_set(MARIA_HA *info, pgcache_page_no_t page, my_bool head,
uint empty_space)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
uint bits;
my_bool res;
DBUG_ENTER("_ma_bitmap_set");
DBUG_PRINT("enter", ("page: %lu head: %d empty_space: %u",
(ulong) page, head, empty_space));
mysql_mutex_lock(&info->s->bitmap.bitmap_lock);
bits= (head ?
_ma_free_size_to_head_pattern(bitmap, empty_space) :
free_size_to_tail_pattern(bitmap, empty_space));
res= set_page_bits(info, bitmap, page, bits);
mysql_mutex_unlock(&info->s->bitmap.bitmap_lock);
DBUG_RETURN(res);
}
|
O0
|
c
|
ma_bitmap_set:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
jmp 0x6362b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
leaq 0xf5e1f(%rip), %rsi # 0x159466
movl $0xb55, %edx # imm = 0xB55
callq 0x61210
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
je 0x6366b
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x61ac0
movl %eax, -0x2c(%rbp)
jmp 0x6367a
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x63440
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x63230
movb %al, -0x25(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0xa10, %rdi # imm = 0xA10
addq $0x88, %rdi
callq 0x614c0
movb -0x25(%rbp), %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
|
_ma_bitmap_set:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_11], al
mov [rbp+var_18], ecx
mov rax, [rbp+var_8]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_20], rax
jmp short $+2
loc_6362B:
mov rax, [rbp+var_8]
mov rdi, [rax]
add rdi, 0A10h
add rdi, 88h
lea rsi, aWorkspaceLlm4b_13; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0B55h
call inline_mysql_mutex_lock_7
movsx eax, [rbp+var_11]
cmp eax, 0
jz short loc_6366B
mov rdi, [rbp+var_20]
mov esi, [rbp+var_18]
call _ma_free_size_to_head_pattern
mov [rbp+var_2C], eax
jmp short loc_6367A
loc_6366B:
mov rdi, [rbp+var_20]
mov esi, [rbp+var_18]
call free_size_to_tail_pattern
mov [rbp+var_2C], eax
loc_6367A:
mov eax, [rbp+var_2C]
mov [rbp+var_24], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_24]
call set_page_bits
mov [rbp+var_25], al
mov rax, [rbp+var_8]
mov rdi, [rax]
add rdi, 0A10h
add rdi, 88h
call inline_mysql_mutex_unlock_7
mov al, [rbp+var_25]
mov [rbp+var_2D], al
mov al, [rbp+var_2D]
add rsp, 30h
pop rbp
retn
|
char ma_bitmap_set(long long *a1, unsigned long long a2, char a3, unsigned int a4)
{
unsigned int v5; // [rsp+4h] [rbp-2Ch]
char v6; // [rsp+Bh] [rbp-25h]
_DWORD *v7; // [rsp+10h] [rbp-20h]
v7 = (_DWORD *)(*a1 + 2576);
inline_mysql_mutex_lock_7(
*a1 + 2712,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xB55u);
if ( a3 )
v5 = ma_free_size_to_head_pattern(v7, a4);
else
v5 = free_size_to_tail_pattern(v7, a4);
v6 = set_page_bits(a1, (long long)v7, a2, v5);
inline_mysql_mutex_unlock_7(*a1 + 2712);
return v6;
}
|
_ma_bitmap_set:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016362b
LAB_0016362b:
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0xa10
ADD RDI,0x88
LEA RSI,[0x259466]
MOV EDX,0xb55
CALL 0x00161210
MOVSX EAX,byte ptr [RBP + -0x11]
CMP EAX,0x0
JZ 0x0016366b
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x00161ac0
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0016367a
LAB_0016366b:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,dword ptr [RBP + -0x18]
CALL 0x00163440
MOV dword ptr [RBP + -0x2c],EAX
LAB_0016367a:
MOV EAX,dword ptr [RBP + -0x2c]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x24]
CALL 0x00163230
MOV byte ptr [RBP + -0x25],AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX]
ADD RDI,0xa10
ADD RDI,0x88
CALL 0x001614c0
MOV AL,byte ptr [RBP + -0x25]
MOV byte ptr [RBP + -0x2d],AL
MOV AL,byte ptr [RBP + -0x2d]
ADD RSP,0x30
POP RBP
RET
|
int1 _ma_bitmap_set(long *param_1,int8 param_2,char param_3,int4 param_4)
{
int1 uVar1;
long lVar2;
int4 local_34;
lVar2 = *param_1 + 0xa10;
inline_mysql_mutex_lock
(*param_1 + 0xa98,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_bitmap.c",
0xb55);
if (param_3 == '\0') {
local_34 = free_size_to_tail_pattern(lVar2,param_4);
}
else {
local_34 = _ma_free_size_to_head_pattern(lVar2,param_4);
}
uVar1 = set_page_bits(param_1,lVar2,param_2,local_34);
inline_mysql_mutex_unlock(*param_1 + 0xa98);
return uVar1;
}
|
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.