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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
57,600
|
js_finrec_unregister
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_finrec_unregister(JSContext *ctx, JSValue this_val, int argc, JSValue *argv)
{
JSFinalizationRegistryData *frd = JS_GetOpaque2(ctx, this_val, JS_CLASS_FINALIZATION_REGISTRY);
if (!frd)
return JS_EXCEPTION;
JSValue token = argv[0];
if (!is_valid_weakref_target(token))
return JS_ThrowTypeError(ctx, "invalid unregister token");
struct list_head *el, *el1;
BOOL removed = FALSE;
list_for_each_safe(el, el1, &frd->entries) {
JSFinRecEntry *fre = list_entry(el, JSFinRecEntry, link);
if (js_same_value(ctx, fre->token, token)) {
list_del(&fre->link);
delete_finrec_weakref(ctx->rt, fre);
JS_FreeValue(ctx, fre->held_val);
JS_FreeValue(ctx, fre->token);
js_free(ctx, fre);
removed = TRUE;
}
}
return js_bool(removed);
}
|
O3
|
c
|
js_finrec_unregister:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, %edx
jne 0x8b093
cmpw $0x3b, 0x6(%rsi)
jne 0x8b093
movq 0x30(%rsi), %r14
testq %r14, %r14
je 0x8b093
movq (%r8), %rax
movq %rax, (%rsp)
movq 0x8(%r8), %r12
cmpl $-0x1, %r12d
je 0x8b0b9
cmpl $-0x8, %r12d
jne 0x8b079
movq (%rsp), %rax
movq 0x4(%rax), %rax
shrq $0x3e, %rax
cmpl $0x2, %eax
jne 0x8b0b9
leaq 0x1e93a(%rip), %rsi # 0xa99ba
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %eax, %eax
callq 0x26d97
movl $0x6, %edx
jmp 0x8b0a7
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x2bd03
movl $0x6, %edx
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %r13
movl $0x1, %edx
xorl %ebp, %ebp
cmpq %r14, %r13
je 0x8b0a7
movq 0x8(%r13), %r15
movq 0x40(%r13), %rsi
movq 0x48(%r13), %rdx
movq %rbx, %rdi
movq (%rsp), %rcx
movq %r12, %r8
callq 0x2aaf1
testl %eax, %eax
je 0x8b15f
movq (%r13), %rax
movq 0x8(%r13), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0x8ad68
movq 0x38(%r13), %rdx
movq 0x18(%rbx), %rdi
cmpl $-0x9, %edx
jb 0x8b131
movq 0x30(%r13), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x8b131
callq 0x259d8
movq 0x18(%rbx), %rdi
movq 0x48(%r13), %rdx
cmpl $-0x9, %edx
jb 0x8b14f
movq 0x40(%r13), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x8b14f
callq 0x259d8
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2148d
movl $0x1, %ebp
movq %r15, %r13
cmpq %r14, %r15
jne 0x8b0c9
xorl %eax, %eax
testl %ebp, %ebp
setne %al
movq %rax, %rbp
movl $0x1, %edx
jmp 0x8b0a7
|
js_finrec_unregister:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
cmp edx, 0FFFFFFFFh
jnz short loc_8B093
cmp word ptr [rsi+6], 3Bh ; ';'
jnz short loc_8B093
mov r14, [rsi+30h]
test r14, r14
jz short loc_8B093
mov rax, [r8]
mov [rsp+38h+var_38], rax
mov r12, [r8+8]
cmp r12d, 0FFFFFFFFh
jz short loc_8B0B9
cmp r12d, 0FFFFFFF8h
jnz short loc_8B079
mov rax, [rsp+38h+var_38]
mov rax, [rax+4]
shr rax, 3Eh
cmp eax, 2
jnz short loc_8B0B9
loc_8B079:
lea rsi, aInvalidUnregis; "invalid unregister token"
xor ebp, ebp
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp short loc_8B0A7
loc_8B093:
mov rdi, rbx
mov esi, 3Bh ; ';'
call JS_ThrowTypeErrorInvalidClass
mov edx, 6
xor ebp, ebp
loc_8B0A7:
mov rax, rbp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8B0B9:
mov r13, [r14+8]
mov edx, 1
xor ebp, ebp
cmp r13, r14
jz short loc_8B0A7
loc_8B0C9:
mov r15, [r13+8]
mov rsi, [r13+40h]
mov rdx, [r13+48h]
mov rdi, rbx
mov rcx, [rsp+38h+var_38]
mov r8, r12
call js_same_value
test eax, eax
jz short loc_8B15F
mov rax, [r13+0]
mov rcx, [r13+8]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r13+0], xmm0
mov rdi, [rbx+18h]
mov rsi, r13
call delete_finrec_weakref
mov rdx, [r13+38h]
mov rdi, [rbx+18h]
cmp edx, 0FFFFFFF7h
jb short loc_8B131
mov rsi, [r13+30h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_8B131
call js_free_value_rt
mov rdi, [rbx+18h]
loc_8B131:
mov rdx, [r13+48h]
cmp edx, 0FFFFFFF7h
jb short loc_8B14F
mov rsi, [r13+40h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_8B14F
call js_free_value_rt
loc_8B14F:
mov rdi, rbx
mov rsi, r13
call js_free
mov ebp, 1
loc_8B15F:
mov r13, r15
cmp r15, r14
jnz loc_8B0C9
xor eax, eax
test ebp, ebp
setnz al
mov rbp, rax
mov edx, 1
jmp loc_8B0A7
|
_BOOL8 js_finrec_unregister(
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)
{
long long *v15; // r14
long long v16; // r12
long long v17; // rbp
long long *v19; // r13
long long *v20; // r15
long long v21; // rax
_QWORD *v22; // rcx
long long v23; // r8
long long v24; // r9
long long v25; // rdx
long long v26; // rdi
_QWORD *v27; // rsi
int v28; // eax
long long v29; // rcx
long long v30; // rdx
_QWORD *v31; // rsi
int v32; // eax
long long v33; // rcx
long long v34; // [rsp+0h] [rbp-38h]
if ( (_DWORD)a3 == -1 && *(_WORD *)(a2 + 6) == 59 && (v15 = *(long long **)(a2 + 48)) != 0LL )
{
v34 = *a5;
v16 = a5[1];
if ( (_DWORD)v16 == -1 || (_DWORD)v16 == -8 && *(_QWORD *)(v34 + 4) >> 62 != 2 )
{
v19 = (long long *)v15[1];
v17 = 0LL;
if ( v19 != v15 )
{
do
{
v20 = (long long *)v19[1];
if ( (unsigned int)js_same_value(a1, (_DWORD *)v19[8], v19[9], (_DWORD *)v34, v16) )
{
v21 = *v19;
v22 = (_QWORD *)v19[1];
*(_QWORD *)(v21 + 8) = v22;
*v22 = v21;
*(_OWORD *)v19 = 0LL;
delete_finrec_weakref(*(_QWORD *)(a1 + 24), (long long)v19);
v25 = v19[7];
v26 = *(_QWORD *)(a1 + 24);
if ( (unsigned int)v25 >= 0xFFFFFFF7 )
{
v27 = (_QWORD *)v19[6];
v28 = *(_DWORD *)v27;
v29 = (unsigned int)(*(_DWORD *)v27 - 1);
*(_DWORD *)v27 = v29;
if ( v28 <= 1 )
{
js_free_value_rt(v26, v27, v25, v29, v23, v24);
v26 = *(_QWORD *)(a1 + 24);
}
}
v30 = v19[9];
if ( (unsigned int)v30 >= 0xFFFFFFF7 )
{
v31 = (_QWORD *)v19[8];
v32 = *(_DWORD *)v31;
v33 = (unsigned int)(*(_DWORD *)v31 - 1);
*(_DWORD *)v31 = v33;
if ( v32 <= 1 )
js_free_value_rt(v26, v31, v30, v33, v23, v24);
}
js_free(a1, (long long)v19);
LODWORD(v17) = 1;
}
v19 = v20;
}
while ( v20 != v15 );
return (_DWORD)v17 != 0;
}
}
else
{
v17 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"invalid unregister token",
a3,
a4,
(long long)a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v34);
}
}
else
{
JS_ThrowTypeErrorInvalidClass(a1, 59, a7, a8, a9, a10, *(double *)a11.m128_u64, *(double *)a12.m128_u64, a13, a14);
return 0LL;
}
return v17;
}
|
js_finrec_unregister:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP EDX,-0x1
JNZ 0x0018b093
CMP word ptr [RSI + 0x6],0x3b
JNZ 0x0018b093
MOV R14,qword ptr [RSI + 0x30]
TEST R14,R14
JZ 0x0018b093
MOV RAX,qword ptr [R8]
MOV qword ptr [RSP],RAX
MOV R12,qword ptr [R8 + 0x8]
CMP R12D,-0x1
JZ 0x0018b0b9
CMP R12D,-0x8
JNZ 0x0018b079
MOV RAX,qword ptr [RSP]
MOV RAX,qword ptr [RAX + 0x4]
SHR RAX,0x3e
CMP EAX,0x2
JNZ 0x0018b0b9
LAB_0018b079:
LEA RSI,[0x1a99ba]
XOR EBP,EBP
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00126d97
MOV EDX,0x6
JMP 0x0018b0a7
LAB_0018b093:
MOV RDI,RBX
MOV ESI,0x3b
CALL 0x0012bd03
MOV EDX,0x6
XOR EBP,EBP
LAB_0018b0a7:
MOV RAX,RBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018b0b9:
MOV R13,qword ptr [R14 + 0x8]
MOV EDX,0x1
XOR EBP,EBP
CMP R13,R14
JZ 0x0018b0a7
LAB_0018b0c9:
MOV R15,qword ptr [R13 + 0x8]
MOV RSI,qword ptr [R13 + 0x40]
MOV RDX,qword ptr [R13 + 0x48]
MOV RDI,RBX
MOV RCX,qword ptr [RSP]
MOV R8,R12
CALL 0x0012aaf1
TEST EAX,EAX
JZ 0x0018b15f
MOV RAX,qword ptr [R13]
MOV RCX,qword ptr [R13 + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R13],XMM0
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R13
CALL 0x0018ad68
MOV RDX,qword ptr [R13 + 0x38]
MOV RDI,qword ptr [RBX + 0x18]
CMP EDX,-0x9
JC 0x0018b131
MOV RSI,qword ptr [R13 + 0x30]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0018b131
CALL 0x001259d8
MOV RDI,qword ptr [RBX + 0x18]
LAB_0018b131:
MOV RDX,qword ptr [R13 + 0x48]
CMP EDX,-0x9
JC 0x0018b14f
MOV RSI,qword ptr [R13 + 0x40]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x0018b14f
CALL 0x001259d8
LAB_0018b14f:
MOV RDI,RBX
MOV RSI,R13
CALL 0x0012148d
MOV EBP,0x1
LAB_0018b15f:
MOV R13,R15
CMP R15,R14
JNZ 0x0018b0c9
XOR EAX,EAX
TEST EBP,EBP
SETNZ AL
MOV RBP,RAX
MOV EDX,0x1
JMP 0x0018b0a7
|
int1
js_finrec_unregister(long param_1,long param_2,int param_3,int8 param_4,long *param_5)
{
long *plVar1;
long lVar2;
long lVar3;
long *plVar4;
long lVar5;
long *plVar6;
long *plVar7;
int iVar8;
int1 uVar9;
int8 uVar10;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x3b)) &&
(plVar1 = *(long **)(param_2 + 0x30), plVar1 != (long *)0x0)) {
lVar2 = *param_5;
lVar3 = param_5[1];
iVar8 = (int)lVar3;
if ((iVar8 == -1) || ((iVar8 == -8 && ((uint)((ulong)*(int8 *)(lVar2 + 4) >> 0x3e) != 2)))
) {
uVar9 = 0;
plVar4 = (long *)plVar1[1];
while (plVar7 = plVar4, plVar7 != plVar1) {
plVar4 = (long *)plVar7[1];
iVar8 = js_same_value(param_1,plVar7[8],plVar7[9],lVar2,lVar3);
if (iVar8 != 0) {
lVar5 = *plVar7;
plVar6 = (long *)plVar7[1];
*(long **)(lVar5 + 8) = plVar6;
*plVar6 = lVar5;
*plVar7 = 0;
plVar7[1] = 0;
delete_finrec_weakref(*(int8 *)(param_1 + 0x18),plVar7);
uVar10 = *(int8 *)(param_1 + 0x18);
if ((0xfffffff6 < (uint)plVar7[7]) &&
(iVar8 = *(int *)plVar7[6], *(int *)plVar7[6] = iVar8 + -1, iVar8 < 2)) {
js_free_value_rt(uVar10);
uVar10 = *(int8 *)(param_1 + 0x18);
}
if ((0xfffffff6 < (uint)plVar7[9]) &&
(iVar8 = *(int *)plVar7[8], *(int *)plVar7[8] = iVar8 + -1, iVar8 < 2)) {
js_free_value_rt(uVar10);
}
js_free(param_1,plVar7);
uVar9 = 1;
}
}
}
else {
uVar9 = 0;
JS_ThrowTypeError(param_1,"invalid unregister token");
}
}
else {
JS_ThrowTypeErrorInvalidClass(param_1,0x3b);
uVar9 = 0;
}
return uVar9;
}
|
|
57,601
|
plutovg_path_add_round_rect
|
dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-path.c
|
void plutovg_path_add_round_rect(plutovg_path_t* path, float x, float y, float w, float h, float rx, float ry)
{
rx = plutovg_min(rx, w * 0.5f);
ry = plutovg_min(ry, h * 0.5f);
if(rx == 0.f && ry == 0.f) {
plutovg_path_add_rect(path, x, y, w, h);
return;
}
float right = x + w;
float bottom = y + h;
float cpx = rx * PLUTOVG_KAPPA;
float cpy = ry * PLUTOVG_KAPPA;
plutovg_path_reserve(path, 6 * 2 + 4 * 4);
plutovg_path_move_to(path, x, y+ry);
plutovg_path_cubic_to(path, x, y+ry-cpy, x+rx-cpx, y, x+rx, y);
plutovg_path_line_to(path, right-rx, y);
plutovg_path_cubic_to(path, right-rx+cpx, y, right, y+ry-cpy, right, y+ry);
plutovg_path_line_to(path, right, bottom-ry);
plutovg_path_cubic_to(path, right, bottom-ry+cpy, right-rx+cpx, bottom, right-rx, bottom);
plutovg_path_line_to(path, x+rx, bottom);
plutovg_path_cubic_to(path, x+rx-cpx, bottom, x, bottom-ry+cpy, x, bottom-ry);
plutovg_path_line_to(path, x, y+ry);
plutovg_path_close(path);
}
|
O1
|
c
|
plutovg_path_add_round_rect:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movss 0x18bc6(%rip), %xmm7 # 0x4384c
movaps %xmm2, %xmm6
mulss %xmm7, %xmm6
minss %xmm6, %xmm4
mulss %xmm3, %xmm7
minss %xmm7, %xmm5
xorps %xmm6, %xmm6
ucomiss %xmm6, %xmm4
jne 0x2acb7
jp 0x2acb7
ucomiss %xmm6, %xmm5
jne 0x2acb7
jp 0x2acb7
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
jmp 0x2ab9a
addss %xmm0, %xmm2
movss %xmm2, 0x8(%rsp)
addss %xmm1, %xmm3
movss %xmm3, 0x14(%rsp)
movss 0x1a95d(%rip), %xmm3 # 0x45630
movaps %xmm4, %xmm6
mulss %xmm3, %xmm6
movss %xmm6, 0xc(%rsp)
mulss %xmm5, %xmm3
movss %xmm3, 0x10(%rsp)
movq %rbx, %rdi
movl $0x1c, %esi
movss %xmm0, 0x18(%rsp)
movss %xmm5, 0x20(%rsp)
movss %xmm1, (%rsp)
movss %xmm4, 0x4(%rsp)
callq 0x2ab43
movss 0x20(%rsp), %xmm0
addss (%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2a2d3
movss 0x18(%rsp), %xmm0
movss %xmm0, (%rax)
movss 0x1c(%rsp), %xmm1
movss %xmm1, 0x4(%rax)
movss %xmm0, 0x10(%rbx)
movss %xmm1, 0x14(%rbx)
incl 0x8(%rbx)
subss 0x10(%rsp), %xmm1
movss %xmm1, 0x24(%rsp)
movss 0x4(%rsp), %xmm3
addss %xmm0, %xmm3
movaps %xmm3, %xmm2
movaps %xmm3, %xmm4
movss %xmm3, 0x28(%rsp)
subss 0xc(%rsp), %xmm2
movss %xmm2, 0x2c(%rsp)
movq %rbx, %rdi
movss (%rsp), %xmm3
movaps %xmm3, %xmm5
callq 0x2a452
movss 0x8(%rsp), %xmm0
subss 0x4(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movq %rbx, %rdi
movss (%rsp), %xmm1
callq 0x2a349
movss 0xc(%rsp), %xmm0
addss 0x4(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movss (%rsp), %xmm1
movss 0x8(%rsp), %xmm2
movss 0x24(%rsp), %xmm3
movaps %xmm2, %xmm4
movss 0x1c(%rsp), %xmm5
callq 0x2a452
movss 0x14(%rsp), %xmm1
subss 0x20(%rsp), %xmm1
movss %xmm1, (%rsp)
movq %rbx, %rdi
movss 0x8(%rsp), %xmm0
callq 0x2a349
movss 0x10(%rsp), %xmm1
addss (%rsp), %xmm1
movss %xmm1, 0x10(%rsp)
movq %rbx, %rdi
movss 0x8(%rsp), %xmm0
movss 0xc(%rsp), %xmm2
movss 0x14(%rsp), %xmm3
movss 0x4(%rsp), %xmm4
movaps %xmm3, %xmm5
callq 0x2a452
movq %rbx, %rdi
movss 0x28(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
callq 0x2a349
movq %rbx, %rdi
movss 0x2c(%rsp), %xmm0
movss 0x14(%rsp), %xmm1
movss 0x18(%rsp), %xmm2
movss 0x10(%rsp), %xmm3
movaps %xmm2, %xmm4
movss (%rsp), %xmm5
callq 0x2a452
movq %rbx, %rdi
movss 0x18(%rsp), %xmm0
movss 0x1c(%rsp), %xmm1
callq 0x2a349
cmpl $0x0, 0x20(%rbx)
je 0x2aea3
movq %rbx, %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x2a2d3
movq 0x10(%rbx), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbx
retq
|
plutovg_path_add_round_rect:
push rbx
sub rsp, 30h
mov rbx, rdi
movss xmm7, cs:dword_4384C
movaps xmm6, xmm2
mulss xmm6, xmm7
minss xmm4, xmm6
mulss xmm7, xmm3
minss xmm5, xmm7
xorps xmm6, xmm6
ucomiss xmm4, xmm6
jnz short loc_2ACB7
jp short loc_2ACB7
ucomiss xmm5, xmm6
jnz short loc_2ACB7
jp short loc_2ACB7
mov rdi, rbx
add rsp, 30h
pop rbx
jmp plutovg_path_add_rect
loc_2ACB7:
addss xmm2, xmm0
movss [rsp+38h+var_30], xmm2
addss xmm3, xmm1
movss [rsp+38h+var_24], xmm3
movss xmm3, cs:dword_45630
movaps xmm6, xmm4
mulss xmm6, xmm3
movss [rsp+38h+var_2C], xmm6
mulss xmm3, xmm5
movss [rsp+38h+var_28], xmm3
mov rdi, rbx
mov esi, 1Ch
movss [rsp+38h+var_20], xmm0
movss [rsp+38h+var_18], xmm5
movss [rsp+38h+var_38], xmm1
movss [rsp+38h+var_34], xmm4
call plutovg_path_reserve
movss xmm0, [rsp+38h+var_18]
addss xmm0, [rsp+38h+var_38]
movss [rsp+38h+var_1C], xmm0
mov rdi, rbx
xor esi, esi
mov edx, 1
call plutovg_path_add_command
movss xmm0, [rsp+38h+var_20]
movss dword ptr [rax], xmm0
movss xmm1, [rsp+38h+var_1C]
movss dword ptr [rax+4], xmm1
movss dword ptr [rbx+10h], xmm0
movss dword ptr [rbx+14h], xmm1
inc dword ptr [rbx+8]
subss xmm1, [rsp+38h+var_28]
movss [rsp+38h+var_14], xmm1
movss xmm3, [rsp+38h+var_34]
addss xmm3, xmm0
movaps xmm2, xmm3
movaps xmm4, xmm3
movss [rsp+38h+var_10], xmm3
subss xmm2, [rsp+38h+var_2C]
movss [rsp+38h+var_C], xmm2
mov rdi, rbx
movss xmm3, [rsp+38h+var_38]
movaps xmm5, xmm3
call plutovg_path_cubic_to
movss xmm0, [rsp+38h+var_30]
subss xmm0, [rsp+38h+var_34]
movss [rsp+38h+var_34], xmm0
mov rdi, rbx
movss xmm1, [rsp+38h+var_38]
call plutovg_path_line_to
movss xmm0, [rsp+38h+var_2C]
addss xmm0, [rsp+38h+var_34]
movss [rsp+38h+var_2C], xmm0
mov rdi, rbx
movss xmm1, [rsp+38h+var_38]
movss xmm2, [rsp+38h+var_30]
movss xmm3, [rsp+38h+var_14]
movaps xmm4, xmm2
movss xmm5, [rsp+38h+var_1C]
call plutovg_path_cubic_to
movss xmm1, [rsp+38h+var_24]
subss xmm1, [rsp+38h+var_18]
movss [rsp+38h+var_38], xmm1
mov rdi, rbx
movss xmm0, [rsp+38h+var_30]
call plutovg_path_line_to
movss xmm1, [rsp+38h+var_28]
addss xmm1, [rsp+38h+var_38]
movss [rsp+38h+var_28], xmm1
mov rdi, rbx
movss xmm0, [rsp+38h+var_30]
movss xmm2, [rsp+38h+var_2C]
movss xmm3, [rsp+38h+var_24]
movss xmm4, [rsp+38h+var_34]
movaps xmm5, xmm3
call plutovg_path_cubic_to
mov rdi, rbx
movss xmm0, [rsp+38h+var_10]
movss xmm1, [rsp+38h+var_24]
call plutovg_path_line_to
mov rdi, rbx
movss xmm0, [rsp+38h+var_C]
movss xmm1, [rsp+38h+var_24]
movss xmm2, [rsp+38h+var_20]
movss xmm3, [rsp+38h+var_28]
movaps xmm4, xmm2
movss xmm5, [rsp+38h+var_38]
call plutovg_path_cubic_to
mov rdi, rbx
movss xmm0, [rsp+38h+var_20]
movss xmm1, [rsp+38h+var_1C]
call plutovg_path_line_to
cmp dword ptr [rbx+20h], 0
jz short loc_2AEA3
mov rdi, rbx
mov esi, 3
mov edx, 1
call plutovg_path_add_command
mov rcx, [rbx+10h]
mov [rax], rcx
loc_2AEA3:
add rsp, 30h
pop rbx
retn
|
_QWORD * plutovg_path_add_round_rect(
long long a1,
long long a2,
long long a3,
float a4,
float a5,
float a6,
float a7,
float a8,
float a9)
{
float v9; // xmm4_4
float v10; // xmm5_4
_QWORD *result; // rax
float *v12; // rax
float v13; // [rsp+4h] [rbp-34h]
float v14; // [rsp+4h] [rbp-34h]
float v15; // [rsp+Ch] [rbp-2Ch]
float v16; // [rsp+Ch] [rbp-2Ch]
float v17; // [rsp+10h] [rbp-28h]
float v18; // [rsp+10h] [rbp-28h]
float v19; // [rsp+14h] [rbp-24h]
float v21; // [rsp+20h] [rbp-18h]
float v22; // [rsp+28h] [rbp-10h]
float v23; // [rsp+2Ch] [rbp-Ch]
v9 = fminf(a8, a6 * 0.5);
v10 = fminf(a9, 0.5 * a7);
if ( v9 == 0.0 && v10 == 0.0 )
return plutovg_path_add_rect(a1, a4, a5, a6, a7, a2, a3);
v19 = a7 + a5;
v15 = v9 * 0.55228478;
v17 = 0.55228478 * v10;
v21 = v10;
v13 = v9;
plutovg_path_reserve(a1, 28, a3);
v12 = (float *)plutovg_path_add_command(a1, 0, 1);
*v12 = a4;
v12[1] = v21 + a5;
*(float *)(a1 + 16) = a4;
*(float *)(a1 + 20) = v21 + a5;
++*(_DWORD *)(a1 + 8);
v22 = v13 + a4;
v23 = (float)(v13 + a4) - v15;
plutovg_path_cubic_to(a1, a4, (float)(v21 + a5) - v17, (float)(v13 + a4) - v15, a5, v13 + a4, a5);
v14 = (float)(a6 + a4) - v13;
plutovg_path_line_to(a1, v14, a5);
v16 = v15 + v14;
plutovg_path_cubic_to(a1, v16, a5, a6 + a4, (float)(v21 + a5) - v17, a6 + a4, v21 + a5);
plutovg_path_line_to(a1, a6 + a4, (float)(a7 + a5) - v21);
v18 = v17 + (float)((float)(a7 + a5) - v21);
plutovg_path_cubic_to(a1, a6 + a4, v18, v16, v19, v14, v19);
plutovg_path_line_to(a1, v22, a7 + a5);
plutovg_path_cubic_to(a1, v23, v19, a4, v18, a4, v19 - v21);
result = plutovg_path_line_to(a1, a4, v21 + a5);
if ( *(_DWORD *)(a1 + 32) )
{
result = (_QWORD *)plutovg_path_add_command(a1, 3, 1);
*result = *(_QWORD *)(a1 + 16);
}
return result;
}
|
plutovg_path_add_round_rect:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOVSS XMM7,dword ptr [0x0014384c]
MOVAPS XMM6,XMM2
MULSS XMM6,XMM7
MINSS XMM4,XMM6
MULSS XMM7,XMM3
MINSS XMM5,XMM7
XORPS XMM6,XMM6
UCOMISS XMM4,XMM6
JNZ 0x0012acb7
JP 0x0012acb7
UCOMISS XMM5,XMM6
JNZ 0x0012acb7
JP 0x0012acb7
MOV RDI,RBX
ADD RSP,0x30
POP RBX
JMP 0x0012ab9a
LAB_0012acb7:
ADDSS XMM2,XMM0
MOVSS dword ptr [RSP + 0x8],XMM2
ADDSS XMM3,XMM1
MOVSS dword ptr [RSP + 0x14],XMM3
MOVSS XMM3,dword ptr [0x00145630]
MOVAPS XMM6,XMM4
MULSS XMM6,XMM3
MOVSS dword ptr [RSP + 0xc],XMM6
MULSS XMM3,XMM5
MOVSS dword ptr [RSP + 0x10],XMM3
MOV RDI,RBX
MOV ESI,0x1c
MOVSS dword ptr [RSP + 0x18],XMM0
MOVSS dword ptr [RSP + 0x20],XMM5
MOVSS dword ptr [RSP],XMM1
MOVSS dword ptr [RSP + 0x4],XMM4
CALL 0x0012ab43
MOVSS XMM0,dword ptr [RSP + 0x20]
ADDSS XMM0,dword ptr [RSP]
MOVSS dword ptr [RSP + 0x1c],XMM0
MOV RDI,RBX
XOR ESI,ESI
MOV EDX,0x1
CALL 0x0012a2d3
MOVSS XMM0,dword ptr [RSP + 0x18]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM1,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RAX + 0x4],XMM1
MOVSS dword ptr [RBX + 0x10],XMM0
MOVSS dword ptr [RBX + 0x14],XMM1
INC dword ptr [RBX + 0x8]
SUBSS XMM1,dword ptr [RSP + 0x10]
MOVSS dword ptr [RSP + 0x24],XMM1
MOVSS XMM3,dword ptr [RSP + 0x4]
ADDSS XMM3,XMM0
MOVAPS XMM2,XMM3
MOVAPS XMM4,XMM3
MOVSS dword ptr [RSP + 0x28],XMM3
SUBSS XMM2,dword ptr [RSP + 0xc]
MOVSS dword ptr [RSP + 0x2c],XMM2
MOV RDI,RBX
MOVSS XMM3,dword ptr [RSP]
MOVAPS XMM5,XMM3
CALL 0x0012a452
MOVSS XMM0,dword ptr [RSP + 0x8]
SUBSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RDI,RBX
MOVSS XMM1,dword ptr [RSP]
CALL 0x0012a349
MOVSS XMM0,dword ptr [RSP + 0xc]
ADDSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RSP + 0xc],XMM0
MOV RDI,RBX
MOVSS XMM1,dword ptr [RSP]
MOVSS XMM2,dword ptr [RSP + 0x8]
MOVSS XMM3,dword ptr [RSP + 0x24]
MOVAPS XMM4,XMM2
MOVSS XMM5,dword ptr [RSP + 0x1c]
CALL 0x0012a452
MOVSS XMM1,dword ptr [RSP + 0x14]
SUBSS XMM1,dword ptr [RSP + 0x20]
MOVSS dword ptr [RSP],XMM1
MOV RDI,RBX
MOVSS XMM0,dword ptr [RSP + 0x8]
CALL 0x0012a349
MOVSS XMM1,dword ptr [RSP + 0x10]
ADDSS XMM1,dword ptr [RSP]
MOVSS dword ptr [RSP + 0x10],XMM1
MOV RDI,RBX
MOVSS XMM0,dword ptr [RSP + 0x8]
MOVSS XMM2,dword ptr [RSP + 0xc]
MOVSS XMM3,dword ptr [RSP + 0x14]
MOVSS XMM4,dword ptr [RSP + 0x4]
MOVAPS XMM5,XMM3
CALL 0x0012a452
MOV RDI,RBX
MOVSS XMM0,dword ptr [RSP + 0x28]
MOVSS XMM1,dword ptr [RSP + 0x14]
CALL 0x0012a349
MOV RDI,RBX
MOVSS XMM0,dword ptr [RSP + 0x2c]
MOVSS XMM1,dword ptr [RSP + 0x14]
MOVSS XMM2,dword ptr [RSP + 0x18]
MOVSS XMM3,dword ptr [RSP + 0x10]
MOVAPS XMM4,XMM2
MOVSS XMM5,dword ptr [RSP]
CALL 0x0012a452
MOV RDI,RBX
MOVSS XMM0,dword ptr [RSP + 0x18]
MOVSS XMM1,dword ptr [RSP + 0x1c]
CALL 0x0012a349
CMP dword ptr [RBX + 0x20],0x0
JZ 0x0012aea3
MOV RDI,RBX
MOV ESI,0x3
MOV EDX,0x1
CALL 0x0012a2d3
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX],RCX
LAB_0012aea3:
ADD RSP,0x30
POP RBX
RET
|
void plutovg_path_add_round_rect
(float param_1,float param_2,float param_3,float param_4,float param_5,float param_6,
long param_7)
{
float *pfVar1;
int8 *puVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
if (param_3 * DAT_0014384c <= param_5) {
param_5 = param_3 * DAT_0014384c;
}
if (DAT_0014384c * param_4 <= param_6) {
param_6 = DAT_0014384c * param_4;
}
if ((((param_5 == 0.0) && (!NAN(param_5))) && (param_6 == 0.0)) && (!NAN(param_6))) {
plutovg_path_add_rect(param_7);
return;
}
param_3 = param_3 + param_1;
param_4 = param_4 + param_2;
fVar7 = param_5 * DAT_00145630;
fVar6 = DAT_00145630 * param_6;
plutovg_path_reserve(param_7,0x1c);
fVar3 = param_6 + param_2;
pfVar1 = (float *)plutovg_path_add_command(param_7,0,1);
*pfVar1 = param_1;
pfVar1[1] = fVar3;
*(float *)(param_7 + 0x10) = param_1;
*(float *)(param_7 + 0x14) = fVar3;
*(int *)(param_7 + 8) = *(int *)(param_7 + 8) + 1;
plutovg_path_cubic_to(param_7);
fVar4 = param_3 - param_5;
plutovg_path_line_to(fVar4,param_2,param_7);
fVar5 = fVar7 + fVar4;
plutovg_path_cubic_to(fVar5,param_2,param_3,fVar3 - fVar6,param_3,fVar3,param_7);
plutovg_path_line_to(param_3,param_7);
fVar6 = fVar6 + (param_4 - param_6);
plutovg_path_cubic_to(param_3,fVar6,fVar5,param_4,fVar4,param_4,param_7);
plutovg_path_line_to(param_5 + param_1,param_4,param_7);
plutovg_path_cubic_to
((param_5 + param_1) - fVar7,param_4,param_1,fVar6,param_1,param_4 - param_6,param_7);
plutovg_path_line_to(param_1,fVar3,param_7);
if (*(int *)(param_7 + 0x20) != 0) {
puVar2 = (int8 *)plutovg_path_add_command(param_7,3,1);
*puVar2 = *(int8 *)(param_7 + 0x10);
}
return;
}
|
|
57,602
|
rtree_get_next
|
eloqsql/storage/myisam/rt_index.c
|
int rtree_get_next(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root= info->s->state.key_root[keynr];
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if (root == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
if (!info->buff_used && !info->page_changed)
{
uint k_len = keyinfo->keylength - info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(info->int_keypos) */
uchar *key = info->buff + *(int*)info->int_keypos + k_len +
info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(key) */
uchar *after_key = key + k_len + info->s->base.rec_reflength;
info->lastpos = _mi_dpos(info, 0, after_key);
info->lastkey_length = k_len + info->s->base.rec_reflength;
memcpy(info->lastkey, key, k_len + info->s->base.rec_reflength);
*(uint*)info->int_keypos = (uint) (key - info->buff);
if (after_key >= info->int_maxpos)
{
info->buff_used = 1;
}
return 0;
}
return rtree_get_req(info, keyinfo, key_length, root, 0);
}
|
O0
|
c
|
rtree_get_next:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xcb285
callq 0xfe8f0
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcb3d2
movq -0x10(%rbp), %rax
cmpb $0x0, 0x33d(%rax)
jne 0xcb3b8
movq -0x10(%rbp), %rax
cmpb $0x0, 0x33c(%rax)
jne 0xcb3b8
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subl 0x178(%rcx), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x100(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x128(%rcx), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x178(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0x178(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rdx
xorl %esi, %esi
callq 0xc1020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addl 0x178(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1d8(%rax)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addl 0x178(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a0b0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x100(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x128(%rax), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x130(%rcx), %rax
jb 0xcb3af
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xcb3d2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xcada0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
rtree_get_next:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_28], rax
cmp [rbp+var_20], 0FFFFFFFFFFFFFFFFh
jnz short loc_CB285
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp loc_CB3D2
loc_CB285:
mov rax, [rbp+var_10]
cmp byte ptr [rax+33Dh], 0
jnz loc_CB3B8
mov rax, [rbp+var_10]
cmp byte ptr [rax+33Ch], 0
jnz loc_CB3B8
mov rax, [rbp+var_28]
movzx eax, word ptr [rax+12h]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
sub eax, [rcx+178h]
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rax, [rax+100h]
mov rcx, [rbp+var_10]
mov rcx, [rcx+128h]
movsxd rcx, dword ptr [rcx]
add rax, rcx
mov ecx, [rbp+var_2C]
add rax, rcx
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov ecx, [rcx+178h]
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_2C]
add rax, rcx
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov ecx, [rcx+178h]
add rax, rcx
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_40]
xor esi, esi
call _mi_dpos
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+170h], rcx
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_10]
mov rax, [rax]
add ecx, [rax+178h]
mov rax, [rbp+var_10]
mov [rax+1D8h], ecx
mov rax, [rbp+var_10]
mov rdi, [rax+108h]
mov rsi, [rbp+var_38]
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
add eax, [rcx+178h]
mov eax, eax
mov edx, eax
call _memcpy
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
mov rcx, [rcx+100h]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_10]
mov rax, [rax+128h]
mov [rax], ecx
mov rax, [rbp+var_40]
mov rcx, [rbp+var_10]
cmp rax, [rcx+130h]
jb short loc_CB3AF
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
loc_CB3AF:
mov [rbp+var_4], 0
jmp short loc_CB3D2
loc_CB3B8:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_18]
mov rcx, [rbp+var_20]
xor r8d, r8d
call rtree_get_req
mov [rbp+var_4], eax
loc_CB3D2:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
|
long long rtree_get_next(long long a1, const char *a2, unsigned int a3)
{
unsigned long long v4; // [rsp+0h] [rbp-40h]
long long v5; // [rsp+8h] [rbp-38h]
unsigned int v6; // [rsp+14h] [rbp-2Ch]
long long v7; // [rsp+18h] [rbp-28h]
long long v8; // [rsp+20h] [rbp-20h]
v8 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * (unsigned int)a2);
v7 = 112LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
if ( v8 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else if ( *(_BYTE *)(a1 + 829) || *(_BYTE *)(a1 + 828) )
{
return (unsigned int)rtree_get_req((_QWORD *)a1, v7, a3, v8, 0);
}
else
{
v6 = *(unsigned __int16 *)(v7 + 18) - *(_DWORD *)(*(_QWORD *)a1 + 376LL);
v5 = *(unsigned int *)(*(_QWORD *)a1 + 376LL) + v6 + **(int **)(a1 + 296) + *(_QWORD *)(a1 + 256);
v4 = *(unsigned int *)(*(_QWORD *)a1 + 376LL) + v6 + v5;
*(_QWORD *)(a1 + 368) = mi_dpos(a1, 0, v4);
*(_DWORD *)(a1 + 472) = *(_DWORD *)(*(_QWORD *)a1 + 376LL) + v6;
memcpy(*(_QWORD *)(a1 + 264), v5, *(_DWORD *)(*(_QWORD *)a1 + 376LL) + v6);
**(_DWORD **)(a1 + 296) = v5 - *(_QWORD *)(a1 + 256);
if ( v4 >= *(_QWORD *)(a1 + 304) )
*(_BYTE *)(a1 + 829) = 1;
return 0;
}
}
|
rtree_get_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x20],-0x1
JNZ 0x001cb285
CALL 0x001fe8f0
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001cb3d2
LAB_001cb285:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x33d],0x0
JNZ 0x001cb3b8
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x33c],0x0
JNZ 0x001cb3b8
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX + 0x12]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
SUB EAX,dword ptr [RCX + 0x178]
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x100]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x128]
MOVSXD RCX,dword ptr [RCX]
ADD RAX,RCX
MOV ECX,dword ptr [RBP + -0x2c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x178]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x2c]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x178]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x40]
XOR ESI,ESI
CALL 0x001c1020
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x170],RCX
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
ADD ECX,dword ptr [RAX + 0x178]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x1d8],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x108]
MOV RSI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
ADD EAX,dword ptr [RCX + 0x178]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a0b0
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x100]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x128]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x130]
JC 0x001cb3af
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
LAB_001cb3af:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001cb3d2
LAB_001cb3b8:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001cada0
MOV dword ptr [RBP + -0x4],EAX
LAB_001cb3d2:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 rtree_get_next(long *param_1,uint param_2,int4 param_3)
{
uint uVar1;
long lVar2;
int4 *puVar3;
void *__src;
ulong uVar4;
long lVar5;
int4 local_c;
lVar5 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
lVar2 = *(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70;
if (lVar5 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else if ((*(char *)((long)param_1 + 0x33d) == '\0') && (*(char *)((long)param_1 + 0x33c) == '\0'))
{
uVar1 = (uint)*(ushort *)(lVar2 + 0x12) - *(int *)(*param_1 + 0x178);
__src = (void *)(param_1[0x20] + (long)*(int *)param_1[0x25] + (ulong)uVar1 +
(ulong)*(uint *)(*param_1 + 0x178));
uVar4 = (long)__src + (ulong)*(uint *)(*param_1 + 0x178) + (ulong)uVar1;
lVar5 = _mi_dpos(param_1,0,uVar4);
param_1[0x2e] = lVar5;
*(uint *)(param_1 + 0x3b) = uVar1 + *(int *)(*param_1 + 0x178);
memcpy((void *)param_1[0x21],__src,(ulong)(uVar1 + *(int *)(*param_1 + 0x178)));
*(int *)param_1[0x25] = (int)__src - (int)param_1[0x20];
if ((ulong)param_1[0x26] <= uVar4) {
*(int1 *)((long)param_1 + 0x33d) = 1;
}
local_c = 0;
}
else {
local_c = rtree_get_req(param_1,lVar2,param_3,lVar5,0);
}
return local_c;
}
|
|
57,603
|
rtree_get_next
|
eloqsql/storage/myisam/rt_index.c
|
int rtree_get_next(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root= info->s->state.key_root[keynr];
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if (root == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
if (!info->buff_used && !info->page_changed)
{
uint k_len = keyinfo->keylength - info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(info->int_keypos) */
uchar *key = info->buff + *(int*)info->int_keypos + k_len +
info->s->base.rec_reflength;
/* rt_PAGE_NEXT_KEY(key) */
uchar *after_key = key + k_len + info->s->base.rec_reflength;
info->lastpos = _mi_dpos(info, 0, after_key);
info->lastkey_length = k_len + info->s->base.rec_reflength;
memcpy(info->lastkey, key, k_len + info->s->base.rec_reflength);
*(uint*)info->int_keypos = (uint) (key - info->buff);
if (after_key >= info->int_maxpos)
{
info->buff_used = 1;
}
return 0;
}
return rtree_get_req(info, keyinfo, key_length, root, 0);
}
|
O3
|
c
|
rtree_get_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x98(%rax), %rdx
movl %esi, %ecx
movq (%rdx,%rcx,8), %rdx
cmpq $-0x1, %rdx
je 0x8cf8b
movq %rdi, %rbx
imulq $0x70, %rcx, %rsi
addq 0x218(%rax), %rsi
cmpb $0x0, 0x33d(%rdi)
jne 0x8cf73
cmpb $0x0, 0x33c(%rbx)
je 0x8cfae
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8cc9f
callq 0xa8156
movl $0x89, (%rax)
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl 0x12(%rsi), %r12d
movl 0x178(%rax), %r14d
subl %r14d, %r12d
movq 0x128(%rbx), %rax
movslq (%rax), %r13
addq 0x100(%rbx), %r13
addq %r14, %r13
addq %r12, %r13
addq %r12, %r14
addq %r13, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x8748d
movq %rax, 0x170(%rbx)
movq (%rbx), %rax
movq 0x108(%rbx), %rdi
movl 0x178(%rax), %ecx
addl %r12d, %ecx
movl %ecx, 0x1d8(%rbx)
addl 0x178(%rax), %r12d
movq %r13, %rsi
movq %r12, %rdx
callq 0x2a0a0
subl 0x100(%rbx), %r13d
movq 0x128(%rbx), %rax
movl %r13d, (%rax)
cmpq 0x130(%rbx), %r14
jb 0x8cf9c
movb $0x1, 0x33d(%rbx)
jmp 0x8cf9c
|
rtree_get_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rax, [rdi]
mov rdx, [rax+98h]
mov ecx, esi
mov rdx, [rdx+rcx*8]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_8CF8B
mov rbx, rdi
imul rsi, rcx, 70h ; 'p'
add rsi, [rax+218h]
cmp byte ptr [rdi+33Dh], 0
jnz short loc_8CF73
cmp byte ptr [rbx+33Ch], 0
jz short loc_8CFAE
loc_8CF73:
mov rdi, rbx
xor ecx, ecx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rtree_get_req
loc_8CF8B:
call _my_thread_var
mov dword ptr [rax], 89h
mov r15d, 0FFFFFFFFh
loc_8CF9C:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8CFAE:
movzx r12d, word ptr [rsi+12h]
mov r14d, [rax+178h]
sub r12d, r14d
mov rax, [rbx+128h]
movsxd r13, dword ptr [rax]
add r13, [rbx+100h]
add r13, r14
add r13, r12
add r14, r12
add r14, r13
xor r15d, r15d
mov rdi, rbx
xor esi, esi
mov rdx, r14
call _mi_dpos
mov [rbx+170h], rax
mov rax, [rbx]
mov rdi, [rbx+108h]
mov ecx, [rax+178h]
add ecx, r12d
mov [rbx+1D8h], ecx
add r12d, [rax+178h]
mov rsi, r13
mov rdx, r12
call _memcpy
sub r13d, [rbx+100h]
mov rax, [rbx+128h]
mov [rax], r13d
cmp r14, [rbx+130h]
jb loc_8CF9C
mov byte ptr [rbx+33Dh], 1
jmp loc_8CF9C
|
long long rtree_get_next(long long *a1, unsigned int a2)
{
long long v2; // rax
long long v3; // rdx
long long v5; // rsi
unsigned int v7; // r15d
long long v8; // r14
long long v9; // r12
long long v10; // r13
unsigned long long v11; // r14
long long v12; // rax
long long v13; // rdi
v2 = *a1;
v3 = *(_QWORD *)(*(_QWORD *)(*a1 + 152) + 8LL * a2);
if ( v3 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return (unsigned int)-1;
}
else
{
v5 = *(_QWORD *)(v2 + 536) + 112LL * a2;
if ( *((_BYTE *)a1 + 829) || *((_BYTE *)a1 + 828) )
return rtree_get_req(a1, v5, v3, 0LL);
v8 = *(unsigned int *)(v2 + 376);
v9 = *(unsigned __int16 *)(v5 + 18) - (unsigned int)v8;
v10 = v9 + v8 + a1[32] + *(int *)a1[37];
v11 = v10 + v9 + v8;
v7 = 0;
a1[46] = mi_dpos(a1, 0, v11);
v12 = *a1;
v13 = a1[33];
*((_DWORD *)a1 + 118) = v9 + *(_DWORD *)(*a1 + 376);
memcpy(v13, v10, (unsigned int)(*(_DWORD *)(v12 + 376) + v9));
*(_DWORD *)a1[37] = v10 - *((_DWORD *)a1 + 64);
if ( v11 >= a1[38] )
*((_BYTE *)a1 + 829) = 1;
}
return v7;
}
|
rtree_get_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RAX + 0x98]
MOV ECX,ESI
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP RDX,-0x1
JZ 0x0018cf8b
MOV RBX,RDI
IMUL RSI,RCX,0x70
ADD RSI,qword ptr [RAX + 0x218]
CMP byte ptr [RDI + 0x33d],0x0
JNZ 0x0018cf73
CMP byte ptr [RBX + 0x33c],0x0
JZ 0x0018cfae
LAB_0018cf73:
MOV RDI,RBX
XOR ECX,ECX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0018cc9f
LAB_0018cf8b:
CALL 0x001a8156
MOV dword ptr [RAX],0x89
MOV R15D,0xffffffff
LAB_0018cf9c:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018cfae:
MOVZX R12D,word ptr [RSI + 0x12]
MOV R14D,dword ptr [RAX + 0x178]
SUB R12D,R14D
MOV RAX,qword ptr [RBX + 0x128]
MOVSXD R13,dword ptr [RAX]
ADD R13,qword ptr [RBX + 0x100]
ADD R13,R14
ADD R13,R12
ADD R14,R12
ADD R14,R13
XOR R15D,R15D
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,R14
CALL 0x0018748d
MOV qword ptr [RBX + 0x170],RAX
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x108]
MOV ECX,dword ptr [RAX + 0x178]
ADD ECX,R12D
MOV dword ptr [RBX + 0x1d8],ECX
ADD R12D,dword ptr [RAX + 0x178]
MOV RSI,R13
MOV RDX,R12
CALL 0x0012a0a0
SUB R13D,dword ptr [RBX + 0x100]
MOV RAX,qword ptr [RBX + 0x128]
MOV dword ptr [RAX],R13D
CMP R14,qword ptr [RBX + 0x130]
JC 0x0018cf9c
MOV byte ptr [RBX + 0x33d],0x1
JMP 0x0018cf9c
|
int8 rtree_get_next(long *param_1,ulong param_2)
{
uint uVar1;
long lVar2;
int8 uVar3;
int4 *puVar4;
long lVar5;
long lVar6;
uint uVar7;
void *__src;
ulong uVar8;
lVar5 = *param_1;
lVar2 = *(long *)(*(long *)(lVar5 + 0x98) + (param_2 & 0xffffffff) * 8);
if (lVar2 == -1) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
uVar3 = 0xffffffff;
}
else {
lVar6 = (param_2 & 0xffffffff) * 0x70 + *(long *)(lVar5 + 0x218);
if ((*(char *)((long)param_1 + 0x33d) != '\0') || (*(char *)((long)param_1 + 0x33c) != '\0')) {
uVar3 = rtree_get_req(param_1,lVar6,lVar2,0);
return uVar3;
}
uVar1 = *(uint *)(lVar5 + 0x178);
uVar7 = *(ushort *)(lVar6 + 0x12) - uVar1;
__src = (void *)((long)*(int *)param_1[0x25] + param_1[0x20] + (ulong)uVar1 + (ulong)uVar7);
uVar8 = (ulong)uVar1 + (ulong)uVar7 + (long)__src;
uVar3 = 0;
lVar5 = _mi_dpos(param_1,0,uVar8);
param_1[0x2e] = lVar5;
*(uint *)(param_1 + 0x3b) = *(int *)(*param_1 + 0x178) + uVar7;
memcpy((void *)param_1[0x21],__src,(ulong)(uVar7 + *(int *)(*param_1 + 0x178)));
*(int *)param_1[0x25] = (int)__src - (int)param_1[0x20];
if ((ulong)param_1[0x26] <= uVar8) {
*(int1 *)((long)param_1 + 0x33d) = 1;
}
}
return uVar3;
}
|
|
57,604
|
dbuf_put_self
|
bluesky950520[P]quickjs/cutils.c
|
int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
}
|
O0
|
c
|
dbuf_put_self:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1e677
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
addq 0x8(%rsp), %rsi
callq 0x1e3f0
cmpl $0x0, %eax
je 0x1e675
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e6b9
jmp 0x1e677
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe5b0
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
dbuf_put_self:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
add rax, [rsp+28h+var_20]
mov rcx, [rsp+28h+var_10]
cmp rax, [rcx+10h]
setnbe al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_1E677
mov rdi, [rsp+28h+var_10]
mov rax, [rsp+28h+var_10]
mov rsi, [rax+8]
add rsi, [rsp+28h+var_20]
call dbuf_realloc
cmp eax, 0
jz short loc_1E675
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_1E6B9
loc_1E675:
jmp short $+2
loc_1E677:
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
mov rax, [rsp+28h+var_10]
add rdi, [rax+8]
mov rax, [rsp+28h+var_10]
mov rsi, [rax]
add rsi, [rsp+28h+var_18]
mov rdx, [rsp+28h+var_20]
call _memcpy
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov [rsp+28h+var_4], 0
loc_1E6B9:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
|
long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
if ( (unsigned long long)(a3 + a1[1]) > a1[2] && (unsigned int)dbuf_realloc((long long)a1, a3 + a1[1]) )
{
return (unsigned int)-1;
}
else
{
memcpy(a1[1] + *a1, a2 + *a1, a3);
a1[1] += a3;
return 0;
}
}
|
dbuf_put_self:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RCX + 0x10]
SETA AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0011e677
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
ADD RSI,qword ptr [RSP + 0x8]
CALL 0x0011e3f0
CMP EAX,0x0
JZ 0x0011e675
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x0011e6b9
LAB_0011e675:
JMP 0x0011e677
LAB_0011e677:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x18]
ADD RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
ADD RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0010e5b0
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_0011e6b9:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 dbuf_put_self(long *param_1,long param_2,size_t param_3)
{
int iVar1;
int4 local_4;
if (((ulong)param_1[2] < param_1[1] + param_3) &&
(iVar1 = dbuf_realloc(param_1,param_1[1] + param_3), iVar1 != 0)) {
local_4 = 0xffffffff;
}
else {
memcpy((void *)(*param_1 + param_1[1]),(void *)(*param_1 + param_2),param_3);
param_1[1] = param_3 + param_1[1];
local_4 = 0;
}
return local_4;
}
|
|
57,605
|
dbuf_put_self
|
bluesky950520[P]quickjs/cutils.c
|
int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
}
|
O1
|
c
|
dbuf_put_self:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rsi
addq %rdx, %rsi
cmpq 0x10(%rdi), %rsi
ja 0x1b4bb
movq (%r14), %rax
movq 0x8(%r14), %rdi
addq %rax, %rdi
addq %rax, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe5b0
addq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1b375
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1b4b5
jmp 0x1b497
|
dbuf_put_self:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rsi, [rdi+8]
add rsi, rdx
cmp rsi, [rdi+10h]
ja short loc_1B4BB
loc_1B497:
mov rax, [r14]
mov rdi, [r14+8]
add rdi, rax
add r15, rax
mov rsi, r15
mov rdx, rbx
call _memcpy
add [r14+8], rbx
xor eax, eax
loc_1B4B5:
pop rbx
pop r14
pop r15
retn
loc_1B4BB:
mov rdi, r14
call dbuf_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_1B4B5
jmp short loc_1B497
|
long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v5; // rsi
long long result; // rax
int v7; // ecx
v5 = a3 + a1[1];
if ( v5 <= a1[2] || (v7 = dbuf_realloc((long long)a1, v5), result = 0xFFFFFFFFLL, !v7) )
{
memcpy(*a1 + a1[1], *a1 + a2, a3);
a1[1] += a3;
return 0LL;
}
return result;
}
|
dbuf_put_self:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RSI,qword ptr [RDI + 0x8]
ADD RSI,RDX
CMP RSI,qword ptr [RDI + 0x10]
JA 0x0011b4bb
LAB_0011b497:
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [R14 + 0x8]
ADD RDI,RAX
ADD R15,RAX
MOV RSI,R15
MOV RDX,RBX
CALL 0x0010e5b0
ADD qword ptr [R14 + 0x8],RBX
XOR EAX,EAX
LAB_0011b4b5:
POP RBX
POP R14
POP R15
RET
LAB_0011b4bb:
MOV RDI,R14
CALL 0x0011b375
MOV ECX,EAX
MOV EAX,0xffffffff
TEST ECX,ECX
JNZ 0x0011b4b5
JMP 0x0011b497
|
int8 dbuf_put_self(long *param_1,long param_2,size_t param_3)
{
int iVar1;
if (((ulong)param_1[2] < param_1[1] + param_3) && (iVar1 = dbuf_realloc(param_1), iVar1 != 0)) {
return 0xffffffff;
}
memcpy((void *)(param_1[1] + *param_1),(void *)(param_2 + *param_1),param_3);
param_1[1] = param_1[1] + param_3;
return 0;
}
|
|
57,606
|
dbuf_put_self
|
bluesky950520[P]quickjs/cutils.c
|
int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
}
|
O2
|
c
|
dbuf_put_self:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rdx), %rsi
cmpq 0x10(%r14), %rsi
ja 0x15d1c
movq (%r14), %rax
addq %rax, %rdi
addq %rax, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe5c0
addq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x15bdf
testl %eax, %eax
je 0x15d2d
pushq $-0x1
popq %rax
jmp 0x15d16
movq 0x8(%r14), %rdi
jmp 0x15cfc
|
dbuf_put_self:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rdi, [rdi+8]
lea rsi, [rdi+rdx]
cmp rsi, [r14+10h]
ja short loc_15D1C
loc_15CFC:
mov rax, [r14]
add rdi, rax
add r15, rax
mov rsi, r15
mov rdx, rbx
call _memcpy
add [r14+8], rbx
xor eax, eax
loc_15D16:
pop rbx
pop r14
pop r15
retn
loc_15D1C:
mov rdi, r14
call dbuf_realloc
test eax, eax
jz short loc_15D2D
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_15D16
loc_15D2D:
mov rdi, [r14+8]
jmp short loc_15CFC
|
long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
long long v5; // rdi
v5 = a1[1];
if ( (unsigned long long)(v5 + a3) <= a1[2] )
goto LABEL_2;
if ( !(unsigned int)dbuf_realloc((long long)a1, v5 + a3) )
{
v5 = a1[1];
LABEL_2:
memcpy(*a1 + v5, *a1 + a2, a3);
a1[1] += a3;
return 0LL;
}
return -1LL;
}
|
dbuf_put_self:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RSI,[RDI + RDX*0x1]
CMP RSI,qword ptr [R14 + 0x10]
JA 0x00115d1c
LAB_00115cfc:
MOV RAX,qword ptr [R14]
ADD RDI,RAX
ADD R15,RAX
MOV RSI,R15
MOV RDX,RBX
CALL 0x0010e5c0
ADD qword ptr [R14 + 0x8],RBX
XOR EAX,EAX
LAB_00115d16:
POP RBX
POP R14
POP R15
RET
LAB_00115d1c:
MOV RDI,R14
CALL 0x00115bdf
TEST EAX,EAX
JZ 0x00115d2d
PUSH -0x1
POP RAX
JMP 0x00115d16
LAB_00115d2d:
MOV RDI,qword ptr [R14 + 0x8]
JMP 0x00115cfc
|
int8 dbuf_put_self(long *param_1,long param_2,size_t param_3)
{
int iVar1;
long lVar2;
lVar2 = param_1[1];
if ((ulong)param_1[2] < lVar2 + param_3) {
iVar1 = dbuf_realloc(param_1);
if (iVar1 != 0) {
return 0xffffffffffffffff;
}
lVar2 = param_1[1];
}
memcpy((void *)(lVar2 + *param_1),(void *)(param_2 + *param_1),param_3);
param_1[1] = param_1[1] + param_3;
return 0;
}
|
|
57,607
|
mi_pack_get_block_info
|
eloqsql/storage/myisam/mi_packrec.c
|
uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info, uchar **rec_buff_p,
File file, my_off_t filepos)
{
uchar *header=info->header;
uint head_length, UNINIT_VAR(ref_length);
if (file >= 0)
{
ref_length=myisam->s->pack.ref_length;
/*
We can't use mysql_file_pread() here because mi_read_rnd_pack_record
assumes position is ok
*/
mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, header, ref_length, MYF(MY_NABP)))
return BLOCK_FATAL_ERROR;
DBUG_DUMP("header",(uchar*) header,ref_length);
}
head_length= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
head_length+= read_pack_length((uint) myisam->s->pack.version,
header + head_length, &info->blob_len);
/*
Ensure that the record buffer is big enough for the compressed
record plus all expanded blobs. [We do not have an extra buffer
for the resulting blobs. Sigh.]
*/
if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
rec_buff_p)))
return BLOCK_FATAL_ERROR; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p + info->rec_len;
bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
myisam->blob_length=info->blob_len;
}
info->filepos=filepos+head_length;
if (file > 0)
{
info->offset=MY_MIN(info->rec_len, ref_length - head_length);
memcpy(*rec_buff_p, header + head_length, info->offset);
}
return 0;
}
|
O0
|
c
|
mi_pack_get_block_info:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xbb560
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x240(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rcx
leaq 0x986ab(%rip), %rdi # 0x153bbd
movl $0x565, %esi # imm = 0x565
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0xbba70
movl -0x2c(%rbp), %edx
movq -0x40(%rbp), %rcx
movl -0x48(%rbp), %eax
movl %eax, %r8d
leaq 0x98685(%rip), %rdi # 0x153bbd
movl $0x566, %esi # imm = 0x566
movl $0x4, %r9d
callq 0xba930
cmpq $0x0, %rax
je 0xbb55a
movl $0x20, -0x4(%rbp)
jmp 0xbb6ac
jmp 0xbb55c
jmp 0xbb55e
jmp 0xbb560
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x244(%rax), %edi
movq -0x40(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x18, %rdx
callq 0xbbb60
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xbb632
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl 0x244(%rax), %edi
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %eax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
addq $0x30, %rdx
callq 0xbbb60
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rax
addq 0x30(%rax), %rsi
movq -0x28(%rbp), %rdx
callq 0xb6da0
cmpq $0x0, %rax
jne 0xbb5f0
movl $0x20, -0x4(%rbp)
jmp 0xbb6ac
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
addq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b8(%rax)
movq -0x38(%rbp), %rcx
movl -0x44(%rbp), %eax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpl $0x0, -0x2c(%rbp)
jle 0xbb6a5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x48(%rbp), %ecx
subl -0x44(%rbp), %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0xbb66d
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xbb679
movl -0x48(%rbp), %eax
subl -0x44(%rbp), %eax
movl %eax, %eax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
movl -0x44(%rbp), %eax
addq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, %edx
callq 0x2a090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_mi_pack_get_block_info:
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 [rbp+var_2C], r8d
mov [rbp+var_38], r9
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov eax, [rbp+var_48]
mov [rbp+var_48], eax
cmp [rbp+var_2C], 0
jl short loc_BB560
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+240h]
mov [rbp+var_48], eax
mov edx, [rbp+var_2C]
mov rcx, [rbp+var_38]
lea rdi, aWorkspaceLlm4b_30; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 565h
xor r8d, r8d
xor eax, eax
mov r9d, eax
call inline_mysql_file_seek_5
mov edx, [rbp+var_2C]
mov rcx, [rbp+var_40]
mov eax, [rbp+var_48]
mov r8d, eax
lea rdi, aWorkspaceLlm4b_30; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 566h
mov r9d, 4
call inline_mysql_file_read_3
cmp rax, 0
jz short loc_BB55A
mov [rbp+var_4], 20h ; ' '
jmp loc_BB6AC
loc_BB55A:
jmp short $+2
loc_BB55C:
jmp short $+2
loc_BB55E:
jmp short $+2
loc_BB560:
mov rax, [rbp+var_10]
mov rax, [rax]
movzx edi, byte ptr [rax+244h]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_20]
add rdx, 18h
call read_pack_length_0
mov [rbp+var_44], eax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz loc_BB632
mov rax, [rbp+var_10]
mov rax, [rax]
movzx edi, byte ptr [rax+244h]
mov rsi, [rbp+var_40]
mov eax, [rbp+var_44]
add rsi, rax
mov rdx, [rbp+var_20]
add rdx, 30h ; '0'
call read_pack_length_0
add eax, [rbp+var_44]
mov [rbp+var_44], eax
mov rdi, [rbp+var_10]
mov rax, [rbp+var_20]
mov rsi, [rax+18h]
mov rax, [rbp+var_20]
add rsi, [rax+30h]
mov rdx, [rbp+var_28]
call mi_alloc_rec_buff
cmp rax, 0
jnz short loc_BB5F0
mov [rbp+var_4], 20h ; ' '
jmp loc_BB6AC
loc_BB5F0:
mov rax, [rbp+var_28]
mov rcx, [rax]
mov rax, [rbp+var_20]
add rcx, [rax+18h]
mov rax, [rbp+var_18]
mov [rax+18h], rcx
mov rax, [rbp+var_18]
mov rcx, [rax+18h]
mov rax, [rbp+var_20]
add rcx, [rax+30h]
mov rax, [rbp+var_18]
mov [rax+20h], rcx
mov rax, [rbp+var_20]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
mov [rax+1B8h], rcx
loc_BB632:
mov rcx, [rbp+var_38]
mov eax, [rbp+var_44]
add rcx, rax
mov rax, [rbp+var_20]
mov [rax+38h], rcx
cmp [rbp+var_2C], 0
jle short loc_BB6A5
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov ecx, [rbp+var_48]
sub ecx, [rbp+var_44]
mov ecx, ecx
cmp rax, rcx
jnb short loc_BB66D
mov rax, [rbp+var_20]
mov rax, [rax+18h]
mov [rbp+var_50], rax
jmp short loc_BB679
loc_BB66D:
mov eax, [rbp+var_48]
sub eax, [rbp+var_44]
mov eax, eax
mov [rbp+var_50], rax
loc_BB679:
mov rax, [rbp+var_50]
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+54h], ecx
mov rax, [rbp+var_28]
mov rdi, [rax]
mov rsi, [rbp+var_40]
mov eax, [rbp+var_44]
add rsi, rax
mov rax, [rbp+var_20]
mov eax, [rax+54h]
mov edx, eax
call _memcpy
loc_BB6A5:
mov [rbp+var_4], 0
loc_BB6AC:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long mi_pack_get_block_info(_QWORD *a1, long long a2, long long a3, long long *a4, signed int a5, long long a6)
{
long long v7; // [rsp+0h] [rbp-50h]
unsigned int v8; // [rsp+8h] [rbp-48h]
unsigned int pack_length_0; // [rsp+Ch] [rbp-44h]
if ( a5 >= 0
&& (v8 = *(_DWORD *)(*a1 + 576LL),
inline_mysql_file_seek_5(
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
1381LL,
(unsigned int)a5,
a6,
0LL,
0LL),
inline_mysql_file_read_3(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
0x566u,
a5,
a3,
v8,
4LL)) )
{
return 32;
}
else
{
pack_length_0 = read_pack_length_0(*(unsigned __int8 *)(*a1 + 580LL), a3, a3 + 24);
if ( *(_DWORD *)(*a1 + 392LL) )
{
pack_length_0 += read_pack_length_0(*(unsigned __int8 *)(*a1 + 580LL), pack_length_0 + a3, a3 + 48);
if ( !mi_alloc_rec_buff((long long)a1, *(_QWORD *)(a3 + 48) + *(_QWORD *)(a3 + 24), a4) )
return 32;
*(_QWORD *)(a2 + 24) = *(_QWORD *)(a3 + 24) + *a4;
*(_QWORD *)(a2 + 32) = *(_QWORD *)(a3 + 48) + *(_QWORD *)(a2 + 24);
a1[55] = *(_QWORD *)(a3 + 48);
}
*(_QWORD *)(a3 + 56) = pack_length_0 + a6;
if ( a5 > 0 )
{
if ( *(_QWORD *)(a3 + 24) >= (unsigned long long)(v8 - pack_length_0) )
LODWORD(v7) = v8 - pack_length_0;
else
v7 = *(_QWORD *)(a3 + 24);
*(_DWORD *)(a3 + 84) = v7;
memcpy(*a4, pack_length_0 + a3, *(unsigned int *)(a3 + 84));
}
return 0;
}
}
|
_mi_pack_get_block_info:
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 dword ptr [RBP + -0x2c],R8D
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x48],EAX
CMP dword ptr [RBP + -0x2c],0x0
JL 0x001bb560
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x240]
MOV dword ptr [RBP + -0x48],EAX
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x38]
LEA RDI,[0x253bbd]
MOV ESI,0x565
XOR R8D,R8D
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001bba70
MOV EDX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x48]
MOV R8D,EAX
LEA RDI,[0x253bbd]
MOV ESI,0x566
MOV R9D,0x4
CALL 0x001ba930
CMP RAX,0x0
JZ 0x001bb55a
MOV dword ptr [RBP + -0x4],0x20
JMP 0x001bb6ac
LAB_001bb55a:
JMP 0x001bb55c
LAB_001bb55c:
JMP 0x001bb55e
LAB_001bb55e:
JMP 0x001bb560
LAB_001bb560:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVZX EDI,byte ptr [RAX + 0x244]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,0x18
CALL 0x001bbb60
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001bb632
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVZX EDI,byte ptr [RAX + 0x244]
MOV RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x44]
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x20]
ADD RDX,0x30
CALL 0x001bbb60
ADD EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x44],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x20]
ADD RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x001b6da0
CMP RAX,0x0
JNZ 0x001bb5f0
MOV dword ptr [RBP + -0x4],0x20
JMP 0x001bb6ac
LAB_001bb5f0:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x20]
ADD RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x1b8],RCX
LAB_001bb632:
MOV RCX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x44]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x38],RCX
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001bb6a5
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV ECX,dword ptr [RBP + -0x48]
SUB ECX,dword ptr [RBP + -0x44]
MOV ECX,ECX
CMP RAX,RCX
JNC 0x001bb66d
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001bb679
LAB_001bb66d:
MOV EAX,dword ptr [RBP + -0x48]
SUB EAX,dword ptr [RBP + -0x44]
MOV EAX,EAX
MOV qword ptr [RBP + -0x50],RAX
LAB_001bb679:
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x54],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x44]
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x54]
MOV EDX,EAX
CALL 0x0012a090
LAB_001bb6a5:
MOV dword ptr [RBP + -0x4],0x0
LAB_001bb6ac:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
_mi_pack_get_block_info
(long *param_1,long param_2,long param_3,long *param_4,int param_5,long param_6)
{
int iVar1;
long lVar2;
int local_58;
int local_50;
uint local_4c;
if (-1 < param_5) {
local_50 = *(int *)(*param_1 + 0x240);
inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",0x565,param_5,
param_6,0,0);
lVar2 = inline_mysql_file_read
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",0x566,
param_5,param_3,local_50,4);
if (lVar2 != 0) {
return 0x20;
}
}
local_4c = read_pack_length(*(int1 *)(*param_1 + 0x244),param_3,param_3 + 0x18);
if (*(int *)(*param_1 + 0x188) != 0) {
iVar1 = read_pack_length(*(int1 *)(*param_1 + 0x244),param_3 + (ulong)local_4c,
param_3 + 0x30);
local_4c = iVar1 + local_4c;
lVar2 = mi_alloc_rec_buff(param_1,*(long *)(param_3 + 0x18) + *(long *)(param_3 + 0x30),param_4)
;
if (lVar2 == 0) {
return 0x20;
}
*(long *)(param_2 + 0x18) = *param_4 + *(long *)(param_3 + 0x18);
*(long *)(param_2 + 0x20) = *(long *)(param_2 + 0x18) + *(long *)(param_3 + 0x30);
param_1[0x37] = *(long *)(param_3 + 0x30);
}
*(ulong *)(param_3 + 0x38) = param_6 + (ulong)local_4c;
if (0 < param_5) {
if (*(ulong *)(param_3 + 0x18) < (ulong)(local_50 - local_4c)) {
local_58 = (int)*(int8 *)(param_3 + 0x18);
}
else {
local_58 = local_50 - local_4c;
}
*(int *)(param_3 + 0x54) = local_58;
memcpy((void *)*param_4,(void *)(param_3 + (ulong)local_4c),(ulong)*(uint *)(param_3 + 0x54));
}
return 0;
}
|
|
57,608
|
mi_pack_get_block_info
|
eloqsql/storage/myisam/mi_packrec.c
|
uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info, uchar **rec_buff_p,
File file, my_off_t filepos)
{
uchar *header=info->header;
uint head_length, UNINIT_VAR(ref_length);
if (file >= 0)
{
ref_length=myisam->s->pack.ref_length;
/*
We can't use mysql_file_pread() here because mi_read_rnd_pack_record
assumes position is ok
*/
mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, header, ref_length, MYF(MY_NABP)))
return BLOCK_FATAL_ERROR;
DBUG_DUMP("header",(uchar*) header,ref_length);
}
head_length= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
head_length+= read_pack_length((uint) myisam->s->pack.version,
header + head_length, &info->blob_len);
/*
Ensure that the record buffer is big enough for the compressed
record plus all expanded blobs. [We do not have an extra buffer
for the resulting blobs. Sigh.]
*/
if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
rec_buff_p)))
return BLOCK_FATAL_ERROR; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p + info->rec_len;
bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
myisam->blob_length=info->blob_len;
}
info->filepos=filepos+head_length;
if (file > 0)
{
info->offset=MY_MIN(info->rec_len, ref_length - head_length);
memcpy(*rec_buff_p, header + head_length, info->offset);
}
return 0;
}
|
O3
|
c
|
mi_pack_get_block_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
testl %r8d, %r8d
movq %r9, -0x48(%rbp)
js 0x8193f
movq %r9, %r15
movq %rcx, -0x30(%rbp)
movq (%r14), %rax
movl 0x240(%rax), %r13d
leaq 0x304758(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x81aa1
movl %r12d, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa0a88
leaq 0x304721(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %r13, -0x38(%rbp)
jne 0x81ab4
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa0888
movq %rax, %r13
movl $0x20, %r15d
testq %r13, %r13
movq -0x30(%rbp), %rcx
jne 0x81a8f
jmp 0x81943
movq %rax, -0x38(%rbp)
movzbl (%rbx), %esi
cmpq $0xfd, %rsi
ja 0x8195b
movl $0x1, %r15d
movq -0x38(%rbp), %rdi
jmp 0x8199e
cmpl $0xfe, %esi
movq -0x38(%rbp), %rdi
jne 0x81973
movzwl 0x1(%rbx), %esi
movl $0x3, %r15d
jmp 0x8199e
movq (%r14), %rax
cmpb $0x1, 0x244(%rax)
jne 0x81995
movzwl 0x1(%rbx), %eax
movzbl 0x3(%rbx), %esi
shll $0x10, %esi
orq %rax, %rsi
movl $0x4, %r15d
jmp 0x8199e
movl 0x1(%rbx), %esi
movl $0x5, %r15d
movq %rsi, 0x18(%rbx)
movq (%r14), %rdx
cmpl $0x0, 0x188(%rdx)
je 0x81a54
movl %r15d, %edi
movzbl (%rbx,%rdi), %eax
cmpq $0xfd, %rax
ja 0x819ca
movl $0x1, -0x30(%rbp)
jmp 0x81a0c
cmpl $0xfe, %eax
jne 0x819df
movzwl 0x1(%rbx,%rdi), %eax
movl $0x3, -0x30(%rbp)
jmp 0x81a0c
cmpb $0x1, 0x244(%rdx)
jne 0x81a01
movzwl 0x1(%rbx,%rdi), %edx
movzbl 0x3(%rbx,%rdi), %eax
shll $0x10, %eax
orq %rdx, %rax
movl $0x4, -0x30(%rbp)
jmp 0x81a0c
movl 0x1(%rbx,%rdi), %eax
movl $0x5, -0x30(%rbp)
movq %rax, 0x30(%rbx)
addq %rax, %rsi
movq %r14, %rdi
movq %rcx, %rdx
movq %rcx, %r13
callq 0x7fbe5
testq %rax, %rax
je 0x81a89
movq (%r13), %rax
addq 0x18(%rbx), %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x18(%rcx)
addq 0x30(%rbx), %rax
addl -0x30(%rbp), %r15d
movq %rax, 0x20(%rcx)
movq 0x30(%rbx), %rax
movq %rax, 0x1b8(%r14)
movq %r13, %rcx
movq -0x38(%rbp), %rdi
movl %r15d, %eax
movq -0x48(%rbp), %rdx
addq %rax, %rdx
movq %rdx, 0x38(%rbx)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x81a8f
movq 0x18(%rbx), %rdx
subl %eax, %edi
cmpq %rdi, %rdx
cmovael %edi, %edx
movl %edx, 0x54(%rbx)
movq (%rcx), %rdi
addq %rax, %rbx
movq %rbx, %rsi
callq 0x29080
jmp 0x81a8f
movl $0x20, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x2e479
jmp 0x818e8
movq %rax, %r15
leaq 0x304552(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x5a26e(%rip), %rdx # 0xdbd36
movq %r15, %rdi
movq %r13, %rsi
movl $0x566, %ecx # imm = 0x566
callq *0x210(%rax)
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa0888
movq %r13, %rcx
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
cmoveq %rcx, %rsi
leaq 0x30450e(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x8192a
|
_mi_pack_get_block_info:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov rbx, rdx
mov [rbp+var_40], rsi
mov r14, rdi
test r8d, r8d
mov [rbp+var_48], r9
js loc_8193F
mov r15, r9
mov [rbp+var_30], rcx
mov rax, [r14]
mov r13d, [rax+240h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_81AA1
mov edi, r12d
mov rsi, r15
xor edx, edx
xor ecx, ecx
call my_seek
loc_818E8:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_38], r13
jnz loc_81AB4
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov r13, rax
loc_8192A:
mov r15d, 20h ; ' '
test r13, r13
mov rcx, [rbp+var_30]
jnz loc_81A8F
jmp short loc_81943
loc_8193F:
mov [rbp+var_38], rax
loc_81943:
movzx esi, byte ptr [rbx]
cmp rsi, 0FDh
ja short loc_8195B
mov r15d, 1
mov rdi, [rbp+var_38]
jmp short loc_8199E
loc_8195B:
cmp esi, 0FEh
mov rdi, [rbp+var_38]
jnz short loc_81973
movzx esi, word ptr [rbx+1]
mov r15d, 3
jmp short loc_8199E
loc_81973:
mov rax, [r14]
cmp byte ptr [rax+244h], 1
jnz short loc_81995
movzx eax, word ptr [rbx+1]
movzx esi, byte ptr [rbx+3]
shl esi, 10h
or rsi, rax
mov r15d, 4
jmp short loc_8199E
loc_81995:
mov esi, [rbx+1]
mov r15d, 5
loc_8199E:
mov [rbx+18h], rsi
mov rdx, [r14]
cmp dword ptr [rdx+188h], 0
jz loc_81A54
mov edi, r15d
movzx eax, byte ptr [rbx+rdi]
cmp rax, 0FDh
ja short loc_819CA
mov dword ptr [rbp+var_30], 1
jmp short loc_81A0C
loc_819CA:
cmp eax, 0FEh
jnz short loc_819DF
movzx eax, word ptr [rbx+rdi+1]
mov dword ptr [rbp+var_30], 3
jmp short loc_81A0C
loc_819DF:
cmp byte ptr [rdx+244h], 1
jnz short loc_81A01
movzx edx, word ptr [rbx+rdi+1]
movzx eax, byte ptr [rbx+rdi+3]
shl eax, 10h
or rax, rdx
mov dword ptr [rbp+var_30], 4
jmp short loc_81A0C
loc_81A01:
mov eax, [rbx+rdi+1]
mov dword ptr [rbp+var_30], 5
loc_81A0C:
mov [rbx+30h], rax
add rsi, rax
mov rdi, r14
mov rdx, rcx
mov r13, rcx
call mi_alloc_rec_buff
test rax, rax
jz short loc_81A89
mov rax, [r13+0]
add rax, [rbx+18h]
mov rcx, [rbp+var_40]
mov [rcx+18h], rax
add rax, [rbx+30h]
add r15d, dword ptr [rbp+var_30]
mov [rcx+20h], rax
mov rax, [rbx+30h]
mov [r14+1B8h], rax
mov rcx, r13
mov rdi, [rbp+var_38]
loc_81A54:
mov eax, r15d
mov rdx, [rbp+var_48]
add rdx, rax
mov [rbx+38h], rdx
xor r15d, r15d
test r12d, r12d
jle short loc_81A8F
mov rdx, [rbx+18h]
sub edi, eax
cmp rdx, rdi
cmovnb edx, edi
mov [rbx+54h], edx
mov rdi, [rcx]
add rbx, rax
mov rsi, rbx
call _memcpy
jmp short loc_81A8F
loc_81A89:
mov r15d, 20h ; ' '
loc_81A8F:
mov eax, r15d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_81AA1:
mov rdi, rax
mov esi, r12d
mov rdx, r15
call _mi_pack_get_block_info_cold_1
jmp loc_818E8
loc_81AB4:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r13
mov ecx, 566h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov rcx, r13
mov r13, rax
xor esi, esi
test rax, rax
cmovz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_8192A
|
long long mi_pack_get_block_info(
long long *a1,
long long a2,
unsigned __int8 *a3,
_QWORD *a4,
long long a5,
long long a6)
{
long long v6; // rax
unsigned int v7; // r12d
long long v11; // r13
long long v12; // rax
long long v13; // rax
long long v14; // r13
unsigned int v15; // r15d
unsigned long long v16; // rsi
unsigned int v17; // r15d
int v18; // edi
unsigned long long v19; // rax
_QWORD *v20; // r13
long long v21; // rax
long long v22; // rcx
long long v23; // rax
unsigned long long v24; // rdx
unsigned long long v25; // rdi
long long v27; // r15
long long v28; // rax
long long v29; // rcx
long long v30; // rsi
_BYTE v31[72]; // [rsp+0h] [rbp-90h] BYREF
long long v32; // [rsp+48h] [rbp-48h]
long long v33; // [rsp+50h] [rbp-40h]
long long v34; // [rsp+58h] [rbp-38h]
_QWORD *v35; // [rsp+60h] [rbp-30h]
v7 = a5;
v33 = a2;
v32 = a6;
if ( (int)a5 < 0 )
{
v34 = v6;
}
else
{
v35 = a4;
v11 = *(unsigned int *)(*a1 + 576);
v12 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, (unsigned int)a5, 8LL);
if ( v12 )
mi_pack_get_block_info_cold_1(v12, v7, a6);
else
my_seek(v7, a6, 0LL, 0LL);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, v7, 6LL);
v34 = v11;
if ( v13 )
{
v27 = v13;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v13,
v11,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
1382LL);
v28 = my_read(v7, a3, v11, 4LL);
v29 = v11;
v14 = v28;
v30 = 0LL;
if ( !v28 )
v30 = v29;
((void ( *)(long long, long long))PSI_server[67])(v27, v30);
}
else
{
v14 = my_read(v7, a3, v11, 4LL);
}
v15 = 32;
a4 = v35;
if ( v14 )
return v15;
}
v16 = *a3;
if ( v16 > 0xFD )
{
v18 = v34;
if ( (_DWORD)v16 == 254 )
{
v16 = *(unsigned __int16 *)(a3 + 1);
v17 = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v16 = *(unsigned __int16 *)(a3 + 1) | (unsigned long long)(a3[3] << 16);
v17 = 4;
}
else
{
v16 = *(unsigned int *)(a3 + 1);
v17 = 5;
}
}
else
{
v17 = 1;
v18 = v34;
}
*((_QWORD *)a3 + 3) = v16;
if ( *(_DWORD *)(*a1 + 392) )
{
v19 = a3[v17];
if ( v19 > 0xFD )
{
if ( (_DWORD)v19 == 254 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1];
LODWORD(v35) = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1] | (unsigned long long)(a3[v17 + 3] << 16);
LODWORD(v35) = 4;
}
else
{
v19 = *(unsigned int *)&a3[v17 + 1];
LODWORD(v35) = 5;
}
}
else
{
LODWORD(v35) = 1;
}
*((_QWORD *)a3 + 6) = v19;
v20 = a4;
if ( !mi_alloc_rec_buff(a1, v19 + v16, a4, (long long)a4, a5, a6) )
return 32;
v21 = *((_QWORD *)a3 + 3) + *v20;
v22 = v33;
*(_QWORD *)(v33 + 24) = v21;
v17 += (unsigned int)v35;
*(_QWORD *)(v22 + 32) = *((_QWORD *)a3 + 6) + v21;
a1[55] = *((_QWORD *)a3 + 6);
a4 = v20;
v18 = v34;
}
v23 = v17;
*((_QWORD *)a3 + 7) = v17 + v32;
v15 = 0;
if ( (int)v7 > 0 )
{
v24 = *((_QWORD *)a3 + 3);
v25 = (unsigned int)(v18 - v23);
if ( v24 >= v25 )
v24 = (unsigned int)v25;
*((_DWORD *)a3 + 21) = v24;
memcpy(*a4, &a3[v23], v24);
}
return v15;
}
|
_mi_pack_get_block_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV RBX,RDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
TEST R8D,R8D
MOV qword ptr [RBP + -0x48],R9
JS 0x0018193f
MOV R15,R9
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [R14]
MOV R13D,dword ptr [RAX + 0x240]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00181aa1
MOV EDI,R12D
MOV RSI,R15
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a0a88
LAB_001818e8:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x38],R13
JNZ 0x00181ab4
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a0888
MOV R13,RAX
LAB_0018192a:
MOV R15D,0x20
TEST R13,R13
MOV RCX,qword ptr [RBP + -0x30]
JNZ 0x00181a8f
JMP 0x00181943
LAB_0018193f:
MOV qword ptr [RBP + -0x38],RAX
LAB_00181943:
MOVZX ESI,byte ptr [RBX]
CMP RSI,0xfd
JA 0x0018195b
MOV R15D,0x1
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x0018199e
LAB_0018195b:
CMP ESI,0xfe
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x00181973
MOVZX ESI,word ptr [RBX + 0x1]
MOV R15D,0x3
JMP 0x0018199e
LAB_00181973:
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x00181995
MOVZX EAX,word ptr [RBX + 0x1]
MOVZX ESI,byte ptr [RBX + 0x3]
SHL ESI,0x10
OR RSI,RAX
MOV R15D,0x4
JMP 0x0018199e
LAB_00181995:
MOV ESI,dword ptr [RBX + 0x1]
MOV R15D,0x5
LAB_0018199e:
MOV qword ptr [RBX + 0x18],RSI
MOV RDX,qword ptr [R14]
CMP dword ptr [RDX + 0x188],0x0
JZ 0x00181a54
MOV EDI,R15D
MOVZX EAX,byte ptr [RBX + RDI*0x1]
CMP RAX,0xfd
JA 0x001819ca
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00181a0c
LAB_001819ca:
CMP EAX,0xfe
JNZ 0x001819df
MOVZX EAX,word ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x3
JMP 0x00181a0c
LAB_001819df:
CMP byte ptr [RDX + 0x244],0x1
JNZ 0x00181a01
MOVZX EDX,word ptr [RBX + RDI*0x1 + 0x1]
MOVZX EAX,byte ptr [RBX + RDI*0x1 + 0x3]
SHL EAX,0x10
OR RAX,RDX
MOV dword ptr [RBP + -0x30],0x4
JMP 0x00181a0c
LAB_00181a01:
MOV EAX,dword ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x5
LAB_00181a0c:
MOV qword ptr [RBX + 0x30],RAX
ADD RSI,RAX
MOV RDI,R14
MOV RDX,RCX
MOV R13,RCX
CALL 0x0017fbe5
TEST RAX,RAX
JZ 0x00181a89
MOV RAX,qword ptr [R13]
ADD RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX + 0x18],RAX
ADD RAX,qword ptr [RBX + 0x30]
ADD R15D,dword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x20],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x1b8],RAX
MOV RCX,R13
MOV RDI,qword ptr [RBP + -0x38]
LAB_00181a54:
MOV EAX,R15D
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV qword ptr [RBX + 0x38],RDX
XOR R15D,R15D
TEST R12D,R12D
JLE 0x00181a8f
MOV RDX,qword ptr [RBX + 0x18]
SUB EDI,EAX
CMP RDX,RDI
CMOVNC EDX,EDI
MOV dword ptr [RBX + 0x54],EDX
MOV RDI,qword ptr [RCX]
ADD RBX,RAX
MOV RSI,RBX
CALL 0x00129080
JMP 0x00181a8f
LAB_00181a89:
MOV R15D,0x20
LAB_00181a8f:
MOV EAX,R15D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00181aa1:
MOV RDI,RAX
MOV ESI,R12D
MOV RDX,R15
CALL 0x0012e479
JMP 0x001818e8
LAB_00181ab4:
MOV R15,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dbd36]
MOV RDI,R15
MOV RSI,R13
MOV ECX,0x566
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a0888
MOV RCX,R13
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RCX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x0018192a
|
int8
_mi_pack_get_block_info
(long *param_1,long param_2,byte *param_3,long *param_4,int param_5,long param_6)
{
ulong in_RAX;
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 local_98 [72];
long local_50;
long local_48;
ulong local_40;
long *local_38;
local_50 = param_6;
local_48 = param_2;
local_40 = in_RAX;
if (-1 < param_5) {
uVar4 = (ulong)*(uint *)(*param_1 + 0x240);
local_38 = param_4;
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,8);
if (lVar1 == 0) {
my_seek(param_5,param_6,0,0);
}
else {
_mi_pack_get_block_info_cold_1(lVar1,param_5,param_6);
}
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,6);
local_40 = uVar4;
if (lVar1 == 0) {
lVar2 = my_read(param_5,param_3,uVar4,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,uVar4,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
0x566);
lVar2 = my_read(param_5,param_3,uVar4,4);
uVar6 = 0;
if (lVar2 == 0) {
uVar6 = uVar4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar6);
}
param_4 = local_38;
if (lVar2 != 0) {
return 0x20;
}
}
uVar4 = (ulong)*param_3;
if (uVar4 < 0xfe) {
uVar6 = 1;
}
else if (*param_3 == 0xfe) {
uVar4 = (ulong)*(ushort *)(param_3 + 1);
uVar6 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar4 = (ulong)*(uint3 *)(param_3 + 1);
uVar6 = 4;
}
else {
uVar4 = (ulong)*(uint *)(param_3 + 1);
uVar6 = 5;
}
iVar5 = (int)local_40;
*(ulong *)(param_3 + 0x18) = uVar4;
if (*(int *)(*param_1 + 0x188) != 0) {
uVar3 = (ulong)param_3[uVar6];
if (uVar3 < 0xfe) {
local_38 = (long *)CONCAT44(local_38._4_4_,1);
}
else if (param_3[uVar6] == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,3);
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)CONCAT12(param_3[uVar6 + 3],*(int2 *)(param_3 + uVar6 + 1));
local_38 = (long *)CONCAT44(local_38._4_4_,4);
}
else {
uVar3 = (ulong)*(uint *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,5);
}
*(ulong *)(param_3 + 0x30) = uVar3;
lVar1 = mi_alloc_rec_buff(param_1,uVar4 + uVar3,param_4);
if (lVar1 == 0) {
return 0x20;
}
lVar1 = *param_4;
lVar2 = *(long *)(param_3 + 0x18);
*(long *)(local_48 + 0x18) = lVar1 + lVar2;
uVar6 = (ulong)(uint)((int)uVar6 + (int)local_38);
*(long *)(local_48 + 0x20) = lVar1 + lVar2 + *(long *)(param_3 + 0x30);
param_1[0x37] = *(long *)(param_3 + 0x30);
iVar5 = (int)local_40;
}
*(ulong *)(param_3 + 0x38) = local_50 + uVar6;
if (0 < param_5) {
uVar3 = (ulong)(uint)(iVar5 - (int)uVar6);
uVar4 = *(ulong *)(param_3 + 0x18) & 0xffffffff;
if (uVar3 <= *(ulong *)(param_3 + 0x18)) {
uVar4 = uVar3;
}
*(int *)(param_3 + 0x54) = (int)uVar4;
memcpy((void *)*param_4,param_3 + uVar6,uVar4);
}
return 0;
}
|
|
57,609
|
my_hash_sort_utf8mb4_nopad
|
eloqsql/strings/ctype-utf8.c
|
static void
my_hash_sort_utf8mb4_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_mb_wc_utf8mb4(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, (uint) (wc & 0xFFFF));
if (wc > 0xFFFF)
{
/*
Put the highest byte only if it is non-zero,
to make hash functions for utf8mb3 and utf8mb4
compatible for BMP characters.
This is useful to keep order of records in
test results, e.g. for "SHOW GRANTS".
*/
MY_HASH_ADD(m1, m2, (uint) ((wc >> 16) & 0xFF));
}
s+= res;
}
*nr1= m1;
*nr2= m2;
}
|
O0
|
c
|
my_hash_sort_utf8mb4_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x79e20
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x7ee9a
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0x7a540
jmp 0x7edb1
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x7edf5
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
shrl $0x8, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x7ee36
cmpq $0xffff, -0x30(%rbp) # imm = 0xFFFF
jbe 0x7ee84
jmp 0x7ee42
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x10, %rcx
andq $0xff, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0x7ee84
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x7ed7a
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_hash_sort_utf8mb4_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_7ED7A:
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
jle loc_7EE9A
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_7EDB1:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_7EDF5:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
shr ecx, 8
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_7EE36:
cmp [rbp+var_30], 0FFFFh
jbe short loc_7EE84
jmp short $+2
loc_7EE42:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 10h
and rcx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_7EE84:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_7ED7A
loc_7EE9A:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
|
_QWORD * my_hash_sort_utf8mb4_nopad(long long a1, long long a2, long long a3, long long *a4, _QWORD *a5, long long a6)
{
_QWORD *result; // rax
long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
long long v10; // [rsp+10h] [rbp-50h]
_QWORD *v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v15; // [rsp+38h] [rbp-28h]
long long *v16; // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v12 = a3 + a2;
v11 = *(_QWORD **)(a1 + 120);
v9 = *a4;
v7 = *a5;
while ( 1 )
{
v13 = my_mb_wc_utf8mb4(v19, (long long)&v14, v18, v12, (long long)a5, a6);
if ( v13 <= 0 )
break;
my_tosort_unicode(v11, &v14, *(_DWORD *)(v19 + 12));
v10 = v9 ^ ((v9 << 8) + (unsigned __int8)v14 * (v7 + (v9 & 0x3F)));
v8 = v7 + 3;
v9 = v10 ^ ((v10 << 8) + BYTE1(v14) * (v8 + (v10 & 0x3F)));
v7 = v8 + 3;
if ( v14 > 0xFFFF )
{
v9 ^= (v9 << 8) + BYTE2(v14) * (v7 + (v9 & 0x3F));
v7 += 3LL;
}
v18 += v13;
}
*v16 = v9;
result = v15;
*v15 = v7;
return result;
}
|
my_hash_sort_utf8mb4_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_0017ed7a:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00179e20
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x0017ee9a
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x0017a540
JMP 0x0017edb1
LAB_0017edb1:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0017edf5
LAB_0017edf5:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
SHR ECX,0x8
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0017ee36
LAB_0017ee36:
CMP qword ptr [RBP + -0x30],0xffff
JBE 0x0017ee84
JMP 0x0017ee42
LAB_0017ee42:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x10
AND RCX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0017ee84
LAB_0017ee84:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0017ed7a
LAB_0017ee9a:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb4_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
long lVar2;
int iVar3;
long local_60;
ulong local_58;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
long local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
iVar3 = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
if (iVar3 < 1) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (ulong)((uint)local_38 & 0xff) + local_58 * 0x100 ^
local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (ulong)(((uint)local_38 & 0xffff) >> 8) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 6;
if (0xffff < local_38) {
local_58 = ((local_58 & 0x3f) + local_60 + 6) * (ulong)((uint)(local_38 >> 0x10) & 0xff) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 9;
}
local_60 = lVar2;
local_18 = local_18 + iVar3;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
|
|
57,610
|
coro::io_scheduler::process_events_dedicated_thread()
|
AlayaLite/build_O3/_deps/libcoro-src/src/io_scheduler.cpp
|
auto io_scheduler::process_events_dedicated_thread() -> void
{
if (m_opts.on_io_thread_start_functor != nullptr)
{
m_opts.on_io_thread_start_functor();
}
m_io_processing.exchange(true, std::memory_order::release);
// Execute tasks until stopped or there are no more tasks to complete.
while (!m_shutdown_requested.load(std::memory_order::acquire) || size() > 0)
{
process_events_execute(m_default_timeout);
}
m_io_processing.exchange(false, std::memory_order::release);
if (m_opts.on_io_thread_stop_functor != nullptr)
{
m_opts.on_io_thread_stop_functor();
}
}
|
O3
|
cpp
|
coro::io_scheduler::process_events_dedicated_thread():
pushq %rbx
movq %rdi, %rdx
cmpq $0x0, 0x28(%rdi)
movq %rdi, %rbx
je 0x7816
leaq 0x18(%rdx), %rdi
callq *0x30(%rbx)
movq %rbx, %rdx
movb $0x1, %al
xchgb %al, 0x131(%rdx)
movb 0x130(%rdx), %al
testb $0x1, %al
je 0x784e
cmpl $0x1, 0xa0(%rdx)
movq 0xc0(%rdx), %rax
je 0x7849
movq 0xd0(%rdx), %rcx
movq 0x120(%rcx), %rcx
addq %rcx, %rax
testq %rax, %rax
je 0x7860
movl $0x3e8, %esi # imm = 0x3E8
movq %rdx, %rdi
callq 0x776a
movq %rbx, %rdx
jmp 0x781e
xorl %eax, %eax
xchgb %al, 0x131(%rdx)
cmpq $0x0, 0x48(%rdx)
je 0x7877
leaq 0x38(%rdx), %rdi
popq %rbx
jmpq *0x50(%rdx)
popq %rbx
retq
nop
|
_ZN4coro12io_scheduler31process_events_dedicated_threadEv:
push rbx
mov rdx, rdi
cmp qword ptr [rdi+28h], 0
mov rbx, rdi
jz short loc_7816
lea rdi, [rdx+18h]
call qword ptr [rbx+30h]
mov rdx, rbx
loc_7816:
mov al, 1
xchg al, [rdx+131h]
loc_781E:
mov al, [rdx+130h]
test al, 1
jz short loc_784E
cmp dword ptr [rdx+0A0h], 1
mov rax, [rdx+0C0h]
jz short loc_7849
mov rcx, [rdx+0D0h]
mov rcx, [rcx+120h]
add rax, rcx
loc_7849:
test rax, rax
jz short loc_7860
loc_784E:
mov esi, 3E8h
mov rdi, rdx
call _ZN4coro12io_scheduler22process_events_executeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE; coro::io_scheduler::process_events_execute(std::chrono::duration<long,std::ratio<1l,1000l>>)
mov rdx, rbx
jmp short loc_781E
loc_7860:
xor eax, eax
xchg al, [rdx+131h]
cmp qword ptr [rdx+48h], 0
jz short loc_7877
lea rdi, [rdx+38h]
pop rbx
jmp qword ptr [rdx+50h]
loc_7877:
pop rbx
retn
|
long long coro::io_scheduler::process_events_dedicated_thread(coro::io_scheduler *this)
{
coro::io_scheduler *v1; // rdx
long long v2; // rax
long long result; // rax
v1 = this;
if ( *((_QWORD *)this + 5) )
{
(*((void ( **)(char *))this + 6))((char *)this + 24);
v1 = this;
}
*((_BYTE *)v1 + 305) = 1;
while ( 1 )
{
if ( (*((_BYTE *)v1 + 304) & 1) != 0 )
{
v2 = *((_QWORD *)v1 + 24);
if ( *((_DWORD *)v1 + 40) != 1 )
v2 += *(_QWORD *)(*((_QWORD *)v1 + 26) + 288LL);
if ( !v2 )
break;
}
coro::io_scheduler::process_events_execute((long long)v1, 1000LL);
v1 = this;
}
result = *((unsigned __int8 *)v1 + 305);
*((_BYTE *)v1 + 305) = 0;
if ( *((_QWORD *)v1 + 9) )
return (*((long long ( **)(long long))v1 + 10))((long long)v1 + 56);
return result;
}
|
process_events_dedicated_thread:
PUSH RBX
MOV RDX,RDI
CMP qword ptr [RDI + 0x28],0x0
MOV RBX,RDI
JZ 0x00107816
LEA RDI,[RDX + 0x18]
CALL qword ptr [RBX + 0x30]
MOV RDX,RBX
LAB_00107816:
MOV AL,0x1
XCHG byte ptr [RDX + 0x131],AL
LAB_0010781e:
MOV AL,byte ptr [RDX + 0x130]
TEST AL,0x1
JZ 0x0010784e
CMP dword ptr [RDX + 0xa0],0x1
MOV RAX,qword ptr [RDX + 0xc0]
JZ 0x00107849
MOV RCX,qword ptr [RDX + 0xd0]
MOV RCX,qword ptr [RCX + 0x120]
ADD RAX,RCX
LAB_00107849:
TEST RAX,RAX
JZ 0x00107860
LAB_0010784e:
MOV ESI,0x3e8
MOV RDI,RDX
CALL 0x0010776a
MOV RDX,RBX
JMP 0x0010781e
LAB_00107860:
XOR EAX,EAX
XCHG byte ptr [RDX + 0x131],AL
CMP qword ptr [RDX + 0x48],0x0
JZ 0x00107877
LEA RDI,[RDX + 0x38]
POP RBX
JMP qword ptr [RDX + 0x50]
LAB_00107877:
POP RBX
RET
|
/* coro::io_scheduler::process_events_dedicated_thread() */
ulong __thiscall coro::io_scheduler::process_events_dedicated_thread(io_scheduler *this)
{
io_scheduler iVar1;
long lVar2;
ulong uVar3;
if (*(long *)(this + 0x28) != 0) {
(**(code **)(this + 0x30))(this + 0x18);
}
LOCK();
this[0x131] = (io_scheduler)0x1;
UNLOCK();
do {
if (((byte)this[0x130] & 1) != 0) {
lVar2 = *(long *)(this + 0xc0);
if (*(int *)(this + 0xa0) != 1) {
lVar2 = lVar2 + *(long *)(*(long *)(this + 0xd0) + 0x120);
}
if (lVar2 == 0) {
LOCK();
iVar1 = this[0x131];
this[0x131] = (io_scheduler)0x0;
UNLOCK();
if (*(long *)(this + 0x48) != 0) {
/* WARNING: Could not recover jumptable at 0x00107874. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (**(code **)(this + 0x50))(this + 0x38);
return uVar3;
}
return (ulong)(byte)iVar1;
}
}
process_events_execute(this,1000);
} while( true );
}
|
|
57,611
|
Cache::writeBlockToLowerLevel(Cache::Block&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::writeBlockToLowerLevel(Cache::Block &b) {
uint32_t addrBegin = this->getAddr(b);
if (this->lowerCache == nullptr) {
for (uint32_t i = 0; i < b.size; ++i) {
this->memory->setByteNoCache(addrBegin + i, b.data[i]);
}
} else {
for (uint32_t i = 0; i < b.size; ++i) {
this->lowerCache->setByte(addrBegin + i, b.data[i]);
}
}
}
|
O0
|
cpp
|
Cache::writeBlockToLowerLevel(Cache::Block&):
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x38(%rsp), %rsi
callq 0x95a0
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x34(%rsp)
cmpq $0x0, 0x28(%rax)
jne 0x9138
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x9136
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movl 0x30(%rsp), %eax
movl %eax, %esi
callq 0x9640
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %esi
movzbl (%rax), %edx
callq 0x7960
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x90dc
jmp 0x919c
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x919a
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
movl 0x34(%rsp), %eax
addl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x9640
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
xorl %ecx, %ecx
movzbl (%rax), %edx
callq 0x8e30
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x9140
jmp 0x919c
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
|
_ZN5Cache22writeBlockToLowerLevelERNS_5BlockE:
sub rsp, 48h
mov [rsp+48h+var_8], rdi
mov [rsp+48h+var_10], rsi
mov rdi, [rsp+48h+var_8]
mov [rsp+48h+var_28], rdi
mov rsi, [rsp+48h+var_10]
call _ZN5Cache7getAddrERNS_5BlockE; Cache::getAddr(Cache::Block &)
mov ecx, eax
mov rax, [rsp+48h+var_28]
mov [rsp+48h+var_14], ecx
cmp qword ptr [rax+28h], 0
jnz short loc_9138
mov [rsp+48h+var_18], 0
loc_90DC:
mov eax, [rsp+48h+var_18]
mov rcx, [rsp+48h+var_10]
cmp eax, [rcx+0Ch]
jnb short loc_9136
mov rax, [rsp+48h+var_28]
mov rax, [rax+20h]
mov [rsp+48h+var_38], rax
mov eax, [rsp+48h+var_14]
add eax, [rsp+48h+var_18]
mov [rsp+48h+var_2C], eax
mov rdi, [rsp+48h+var_10]
add rdi, 18h
mov eax, [rsp+48h+var_18]
mov esi, eax
call _ZNSt6vectorIhSaIhEEixEm; std::vector<uchar>::operator[](ulong)
mov rdi, [rsp+48h+var_38]; this
mov esi, [rsp+48h+var_2C]; unsigned int
movzx edx, byte ptr [rax]; unsigned __int8
call _ZN13MemoryManager14setByteNoCacheEjh; MemoryManager::setByteNoCache(uint,uchar)
mov eax, [rsp+48h+var_18]
add eax, 1
mov [rsp+48h+var_18], eax
jmp short loc_90DC
loc_9136:
jmp short loc_919C
loc_9138:
mov [rsp+48h+var_1C], 0
loc_9140:
mov eax, [rsp+48h+var_1C]
mov rcx, [rsp+48h+var_10]
cmp eax, [rcx+0Ch]
jnb short loc_919A
mov rax, [rsp+48h+var_28]
mov rax, [rax+28h]
mov [rsp+48h+var_48], rax
mov eax, [rsp+48h+var_14]
add eax, [rsp+48h+var_1C]
mov [rsp+48h+var_3C], eax
mov rdi, [rsp+48h+var_10]
add rdi, 18h
mov eax, [rsp+48h+var_1C]
mov esi, eax
call _ZNSt6vectorIhSaIhEEixEm; std::vector<uchar>::operator[](ulong)
mov rdi, [rsp+48h+var_48]; this
mov esi, [rsp+48h+var_3C]; unsigned int
xor ecx, ecx; unsigned int *
movzx edx, byte ptr [rax]; unsigned __int8
call _ZN5Cache7setByteEjhPj; Cache::setByte(uint,uchar,uint *)
mov eax, [rsp+48h+var_1C]
add eax, 1
mov [rsp+48h+var_1C], eax
jmp short loc_9140
loc_919A:
jmp short $+2
loc_919C:
add rsp, 48h
retn
|
long long Cache::writeBlockToLowerLevel(
MemoryManager **this,
Cache::Block *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long result; // rax
char *v11; // rax
double v12; // xmm4_8
double v13; // xmm5_8
char *v14; // rax
double v15; // xmm4_8
double v16; // xmm5_8
Cache *v17; // [rsp+0h] [rbp-48h]
MemoryManager *v18; // [rsp+10h] [rbp-38h]
unsigned int i; // [rsp+2Ch] [rbp-1Ch]
unsigned int j; // [rsp+30h] [rbp-18h]
int Addr; // [rsp+34h] [rbp-14h]
Addr = Cache::getAddr((Cache *)this, a2);
if ( this[5] )
{
for ( i = 0; ; ++i )
{
result = i;
if ( i >= *((_DWORD *)a2 + 3) )
break;
v17 = this[5];
v14 = (char *)std::vector<unsigned char>::operator[]((char *)a2 + 24, i);
Cache::setByte(v17, i + Addr, *v14, 0LL, a3, a4, a5, a6, v15, v16, a9, a10);
}
}
else
{
for ( j = 0; ; ++j )
{
result = j;
if ( j >= *((_DWORD *)a2 + 3) )
break;
v18 = this[4];
v11 = (char *)std::vector<unsigned char>::operator[]((char *)a2 + 24, j);
MemoryManager::setByteNoCache(v18, j + Addr, *v11, a3, a4, a5, a6, v12, v13, a9, a10);
}
}
return result;
}
|
writeBlockToLowerLevel:
SUB RSP,0x48
MOV qword ptr [RSP + 0x40],RDI
MOV qword ptr [RSP + 0x38],RSI
MOV RDI,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x20],RDI
MOV RSI,qword ptr [RSP + 0x38]
CALL 0x001095a0
MOV ECX,EAX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x34],ECX
CMP qword ptr [RAX + 0x28],0x0
JNZ 0x00109138
MOV dword ptr [RSP + 0x30],0x0
LAB_001090dc:
MOV EAX,dword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x38]
CMP EAX,dword ptr [RCX + 0xc]
JNC 0x00109136
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RSP + 0x10],RAX
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,dword ptr [RSP + 0x30]
MOV dword ptr [RSP + 0x1c],EAX
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,0x18
MOV EAX,dword ptr [RSP + 0x30]
MOV ESI,EAX
CALL 0x00109640
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0x1c]
MOVZX EDX,byte ptr [RAX]
CALL 0x00107960
MOV EAX,dword ptr [RSP + 0x30]
ADD EAX,0x1
MOV dword ptr [RSP + 0x30],EAX
JMP 0x001090dc
LAB_00109136:
JMP 0x0010919c
LAB_00109138:
MOV dword ptr [RSP + 0x2c],0x0
LAB_00109140:
MOV EAX,dword ptr [RSP + 0x2c]
MOV RCX,qword ptr [RSP + 0x38]
CMP EAX,dword ptr [RCX + 0xc]
JNC 0x0010919a
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RSP],RAX
MOV EAX,dword ptr [RSP + 0x34]
ADD EAX,dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0xc],EAX
MOV RDI,qword ptr [RSP + 0x38]
ADD RDI,0x18
MOV EAX,dword ptr [RSP + 0x2c]
MOV ESI,EAX
CALL 0x00109640
MOV RDI,qword ptr [RSP]
MOV ESI,dword ptr [RSP + 0xc]
XOR ECX,ECX
MOVZX EDX,byte ptr [RAX]
CALL 0x00108e30
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00109140
LAB_0010919a:
JMP 0x0010919c
LAB_0010919c:
ADD RSP,0x48
RET
|
/* Cache::writeBlockToLowerLevel(Cache::Block&) */
void __thiscall Cache::writeBlockToLowerLevel(Cache *this,Block *param_1)
{
MemoryManager *this_00;
Cache *this_01;
int iVar1;
uchar *puVar2;
uint local_1c;
uint local_18;
iVar1 = getAddr(this,param_1);
if (*(long *)(this + 0x28) == 0) {
for (local_18 = 0; local_18 < *(uint *)(param_1 + 0xc); local_18 = local_18 + 1) {
this_00 = *(MemoryManager **)(this + 0x20);
puVar2 = (uchar *)std::vector<unsigned_char,std::allocator<unsigned_char>>::operator[]
((vector<unsigned_char,std::allocator<unsigned_char>> *)
(param_1 + 0x18),(ulong)local_18);
MemoryManager::setByteNoCache(this_00,iVar1 + local_18,*puVar2);
}
}
else {
for (local_1c = 0; local_1c < *(uint *)(param_1 + 0xc); local_1c = local_1c + 1) {
this_01 = *(Cache **)(this + 0x28);
puVar2 = (uchar *)std::vector<unsigned_char,std::allocator<unsigned_char>>::operator[]
((vector<unsigned_char,std::allocator<unsigned_char>> *)
(param_1 + 0x18),(ulong)local_1c);
setByte(this_01,iVar1 + local_1c,*puVar2,(uint *)0x0);
}
}
return;
}
|
|
57,612
|
Cache::writeBlockToLowerLevel(Cache::Block&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::writeBlockToLowerLevel(Cache::Block &b) {
uint32_t addrBegin = this->getAddr(b);
if (this->lowerCache == nullptr) {
for (uint32_t i = 0; i < b.size; ++i) {
this->memory->setByteNoCache(addrBegin + i, b.data[i]);
}
} else {
for (uint32_t i = 0; i < b.size; ++i) {
this->lowerCache->setByte(addrBegin + i, b.data[i]);
}
}
}
|
O1
|
cpp
|
Cache::writeBlockToLowerLevel(Cache::Block&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4f46
cmpq $0x0, 0x28(%r14)
movl 0xc(%rbx), %ecx
je 0x4c72
testl %ecx, %ecx
je 0x4c9d
movl %eax, %r15d
xorl %r12d, %r12d
movq 0x28(%r14), %rdi
leal (%r15,%r12), %esi
movq 0x18(%rbx), %rax
movzbl (%rax,%r12), %edx
xorl %ecx, %ecx
callq 0x4aba
incq %r12
movl 0xc(%rbx), %eax
cmpq %rax, %r12
jb 0x4c4d
jmp 0x4c9d
testl %ecx, %ecx
je 0x4c9d
movl %eax, %r15d
xorl %r12d, %r12d
movq 0x20(%r14), %rdi
leal (%r15,%r12), %esi
movq 0x18(%rbx), %rax
movzbl (%rax,%r12), %edx
callq 0x3eb6
incq %r12
movl 0xc(%rbx), %eax
cmpq %rax, %r12
jb 0x4c7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
_ZN5Cache22writeBlockToLowerLevelERNS_5BlockE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call _ZN5Cache7getAddrERNS_5BlockE; Cache::getAddr(Cache::Block &)
cmp qword ptr [r14+28h], 0
mov ecx, [rbx+0Ch]
jz short loc_4C72
test ecx, ecx
jz short loc_4C9D
mov r15d, eax
xor r12d, r12d
loc_4C4D:
mov rdi, [r14+28h]; this
lea esi, [r15+r12]; unsigned int
mov rax, [rbx+18h]
movzx edx, byte ptr [rax+r12]; unsigned __int8
xor ecx, ecx; unsigned int *
call _ZN5Cache7setByteEjhPj; Cache::setByte(uint,uchar,uint *)
inc r12
mov eax, [rbx+0Ch]
cmp r12, rax
jb short loc_4C4D
jmp short loc_4C9D
loc_4C72:
test ecx, ecx
jz short loc_4C9D
mov r15d, eax
xor r12d, r12d
loc_4C7C:
mov rdi, [r14+20h]; this
lea esi, [r15+r12]; unsigned int
mov rax, [rbx+18h]
movzx edx, byte ptr [rax+r12]; unsigned __int8
call _ZN13MemoryManager14setByteNoCacheEjh; MemoryManager::setByteNoCache(uint,uchar)
inc r12
mov eax, [rbx+0Ch]
cmp r12, rax
jb short loc_4C7C
loc_4C9D:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long Cache::writeBlockToLowerLevel(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
unsigned long long result; // rax
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
long long v15; // rcx
int v16; // r15d
unsigned long long v17; // r12
int v18; // r15d
unsigned long long v19; // r12
result = Cache::getAddr(a1);
v15 = *(unsigned int *)(a2 + 12);
if ( *(_QWORD *)(a1 + 40) )
{
if ( (_DWORD)v15 )
{
v16 = result;
v17 = 0LL;
do
{
Cache::setByte(
*(Cache **)(a1 + 40),
v16 + v17,
*(_BYTE *)(*(_QWORD *)(a2 + 24) + v17),
0LL,
a3,
a4,
a5,
a6,
*(double *)v13.m128_u64,
*(double *)v14.m128_u64,
a9,
a10);
++v17;
result = *(unsigned int *)(a2 + 12);
}
while ( v17 < result );
}
}
else if ( (_DWORD)v15 )
{
v18 = result;
v19 = 0LL;
do
{
MemoryManager::setByteNoCache(
*(MemoryManager **)(a1 + 32),
v18 + v19,
*(unsigned __int8 *)(*(_QWORD *)(a2 + 24) + v19),
v15,
v11,
v12,
a3,
a4,
a5,
a6,
v13,
v14,
a9,
a10);
++v19;
result = *(unsigned int *)(a2 + 12);
}
while ( v19 < result );
}
return result;
}
|
writeBlockToLowerLevel:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00104f46
CMP qword ptr [R14 + 0x28],0x0
MOV ECX,dword ptr [RBX + 0xc]
JZ 0x00104c72
TEST ECX,ECX
JZ 0x00104c9d
MOV R15D,EAX
XOR R12D,R12D
LAB_00104c4d:
MOV RDI,qword ptr [R14 + 0x28]
LEA ESI,[R15 + R12*0x1]
MOV RAX,qword ptr [RBX + 0x18]
MOVZX EDX,byte ptr [RAX + R12*0x1]
XOR ECX,ECX
CALL 0x00104aba
INC R12
MOV EAX,dword ptr [RBX + 0xc]
CMP R12,RAX
JC 0x00104c4d
JMP 0x00104c9d
LAB_00104c72:
TEST ECX,ECX
JZ 0x00104c9d
MOV R15D,EAX
XOR R12D,R12D
LAB_00104c7c:
MOV RDI,qword ptr [R14 + 0x20]
LEA ESI,[R15 + R12*0x1]
MOV RAX,qword ptr [RBX + 0x18]
MOVZX EDX,byte ptr [RAX + R12*0x1]
CALL 0x00103eb6
INC R12
MOV EAX,dword ptr [RBX + 0xc]
CMP R12,RAX
JC 0x00104c7c
LAB_00104c9d:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Cache::writeBlockToLowerLevel(Cache::Block&) */
void __thiscall Cache::writeBlockToLowerLevel(Cache *this,Block *param_1)
{
int iVar1;
ulong uVar2;
iVar1 = getAddr(this,param_1);
if (*(long *)(this + 0x28) == 0) {
if (*(int *)(param_1 + 0xc) != 0) {
uVar2 = 0;
do {
MemoryManager::setByteNoCache
(*(MemoryManager **)(this + 0x20),iVar1 + (int)uVar2,
*(uchar *)(*(long *)(param_1 + 0x18) + uVar2));
uVar2 = uVar2 + 1;
} while (uVar2 < *(uint *)(param_1 + 0xc));
}
}
else if (*(int *)(param_1 + 0xc) != 0) {
uVar2 = 0;
do {
setByte((uint)*(int8 *)(this + 0x28),(char)iVar1 + (char)uVar2,
(uint *)(ulong)*(byte *)(*(long *)(param_1 + 0x18) + uVar2));
uVar2 = uVar2 + 1;
} while (uVar2 < *(uint *)(param_1 + 0xc));
}
return;
}
|
|
57,613
|
Cache::writeBlockToLowerLevel(Cache::Block&)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::writeBlockToLowerLevel(Cache::Block &b) {
uint32_t addrBegin = this->getAddr(b);
if (this->lowerCache == nullptr) {
for (uint32_t i = 0; i < b.size; ++i) {
this->memory->setByteNoCache(addrBegin + i, b.data[i]);
}
} else {
for (uint32_t i = 0; i < b.size; ++i) {
this->lowerCache->setByte(addrBegin + i, b.data[i]);
}
}
}
|
O2
|
cpp
|
Cache::writeBlockToLowerLevel(Cache::Block&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4aa2
cmpq $0x0, 0x28(%r14)
je 0x483b
movl %eax, %r15d
xorl %r12d, %r12d
movl 0xc(%rbx), %eax
cmpq %rax, %r12
jae 0x4864
movq 0x28(%r14), %rdi
leal (%r15,%r12), %esi
movq 0x18(%rbx), %rax
movzbl (%rax,%r12), %edx
xorl %ecx, %ecx
callq 0x46ba
incq %r12
jmp 0x4816
movl %eax, %r15d
xorl %r12d, %r12d
movl 0xc(%rbx), %eax
cmpq %rax, %r12
jae 0x4864
movq 0x20(%r14), %rdi
leal (%r15,%r12), %esi
movq 0x18(%rbx), %rax
movzbl (%rax,%r12), %edx
callq 0x3c3e
incq %r12
jmp 0x4841
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN5Cache22writeBlockToLowerLevelERNS_5BlockE:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call _ZN5Cache7getAddrERNS_5BlockE; Cache::getAddr(Cache::Block &)
cmp qword ptr [r14+28h], 0
jz short loc_483B
mov r15d, eax
xor r12d, r12d
loc_4816:
mov eax, [rbx+0Ch]
cmp r12, rax
jnb short loc_4864
mov rdi, [r14+28h]; this
lea esi, [r15+r12]; unsigned int
mov rax, [rbx+18h]
movzx edx, byte ptr [rax+r12]; unsigned __int8
xor ecx, ecx; unsigned int *
call _ZN5Cache7setByteEjhPj; Cache::setByte(uint,uchar,uint *)
inc r12
jmp short loc_4816
loc_483B:
mov r15d, eax
xor r12d, r12d
loc_4841:
mov eax, [rbx+0Ch]
cmp r12, rax
jnb short loc_4864
mov rdi, [r14+20h]; this
lea esi, [r15+r12]; unsigned int
mov rax, [rbx+18h]
movzx edx, byte ptr [rax+r12]; unsigned __int8
call _ZN13MemoryManager14setByteNoCacheEjh; MemoryManager::setByteNoCache(uint,uchar)
inc r12
jmp short loc_4841
loc_4864:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
unsigned long long Cache::writeBlockToLowerLevel(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
int Addr; // eax
long long v11; // rcx
long long v12; // r8
long long v13; // r9
__m128 v14; // xmm4
__m128 v15; // xmm5
int v16; // r15d
unsigned long long i; // r12
unsigned long long result; // rax
int v19; // r15d
unsigned long long j; // r12
Addr = Cache::getAddr(a1);
if ( *(_QWORD *)(a1 + 40) )
{
v16 = Addr;
for ( i = 0LL; ; ++i )
{
result = *(unsigned int *)(a2 + 12);
if ( i >= result )
break;
Cache::setByte(
*(Cache **)(a1 + 40),
v16 + i,
*(_BYTE *)(*(_QWORD *)(a2 + 24) + i),
0LL,
a3,
a4,
a5,
a6,
*(double *)v14.m128_u64,
*(double *)v15.m128_u64,
a9,
a10);
}
}
else
{
v19 = Addr;
for ( j = 0LL; ; ++j )
{
result = *(unsigned int *)(a2 + 12);
if ( j >= result )
break;
MemoryManager::setByteNoCache(
*(MemoryManager **)(a1 + 32),
v19 + j,
*(unsigned __int8 *)(*(_QWORD *)(a2 + 24) + j),
v11,
v12,
v13,
a3,
a4,
a5,
a6,
v14,
v15,
a9,
a10);
}
}
return result;
}
|
writeBlockToLowerLevel:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00104aa2
CMP qword ptr [R14 + 0x28],0x0
JZ 0x0010483b
MOV R15D,EAX
XOR R12D,R12D
LAB_00104816:
MOV EAX,dword ptr [RBX + 0xc]
CMP R12,RAX
JNC 0x00104864
MOV RDI,qword ptr [R14 + 0x28]
LEA ESI,[R15 + R12*0x1]
MOV RAX,qword ptr [RBX + 0x18]
MOVZX EDX,byte ptr [RAX + R12*0x1]
XOR ECX,ECX
CALL 0x001046ba
INC R12
JMP 0x00104816
LAB_0010483b:
MOV R15D,EAX
XOR R12D,R12D
LAB_00104841:
MOV EAX,dword ptr [RBX + 0xc]
CMP R12,RAX
JNC 0x00104864
MOV RDI,qword ptr [R14 + 0x20]
LEA ESI,[R15 + R12*0x1]
MOV RAX,qword ptr [RBX + 0x18]
MOVZX EDX,byte ptr [RAX + R12*0x1]
CALL 0x00103c3e
INC R12
JMP 0x00104841
LAB_00104864:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* Cache::writeBlockToLowerLevel(Cache::Block&) */
void __thiscall Cache::writeBlockToLowerLevel(Cache *this,Block *param_1)
{
int iVar1;
ulong uVar2;
iVar1 = getAddr(this,param_1);
if (*(long *)(this + 0x28) == 0) {
for (uVar2 = 0; uVar2 < *(uint *)(param_1 + 0xc); uVar2 = uVar2 + 1) {
MemoryManager::setByteNoCache
(*(MemoryManager **)(this + 0x20),iVar1 + (int)uVar2,
*(uchar *)(*(long *)(param_1 + 0x18) + uVar2));
}
}
else {
for (uVar2 = 0; uVar2 < *(uint *)(param_1 + 0xc); uVar2 = uVar2 + 1) {
setByte(*(Cache **)(this + 0x28),iVar1 + (int)uVar2,
*(uchar *)(*(long *)(param_1 + 0x18) + uVar2),(uint *)0x0);
}
}
return;
}
|
|
57,614
|
my_strnncoll_win1250ch
|
eloqsql/strings/ctype-win1250ch.c
|
static int my_strnncoll_win1250ch(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s1, size_t len1,
const uchar *s2, size_t len2,
my_bool s2_is_prefix)
{
int v1, v2;
const uchar *p1, * p2;
int pass1 = 0, pass2 = 0;
int diff;
if (s2_is_prefix && len1 > len2)
len1=len2;
p1 = s1; p2 = s2;
do
{
NEXT_CMP_VALUE(s1, p1, pass1, v1, (int)len1);
NEXT_CMP_VALUE(s2, p2, pass2, v2, (int)len2);
if ((diff = v1 - v2))
return diff;
} while (v1);
return 0;
}
|
O3
|
c
|
my_strnncoll_win1250ch:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpq %r8, %rdx
movq %r8, %rax
cmovbq %rdx, %rax
testb %r9b, %r9b
cmoveq %rdx, %rax
movq %rax, -0x70(%rbp)
movslq %eax, %rdx
movq %r8, -0x78(%rbp)
movslq %r8d, %r9
movl $0x1, %eax
movl $0x1, %edi
subq %rsi, %rdi
movq %rdi, -0x60(%rbp)
subq %rcx, %rax
movq %rax, -0x68(%rbp)
xorl %r13d, %r13d
leaq 0x28722e(%rip), %r14 # 0x2fda10
movq %rsi, %r15
movq %rcx, %r12
xorl %ebx, %ebx
movq %rcx, -0x48(%rbp)
movq %rsi, -0x58(%rbp)
movq %r15, %rax
subq %rsi, %rax
cmpq %rdx, %rax
jge 0x7680a
testl %r13d, %r13d
je 0x76838
movl $0x9, %r8d
jmp 0x76833
testl %r13d, %r13d
sete %r8b
cmpl $0x0, -0x70(%rbp)
setg %dil
xorl %eax, %eax
testb %r8b, %dil
je 0x768fe
movl $0x1, %r13d
movl $0x9, %r8d
movq %rsi, %r15
movq %r14, %rax
jmp 0x76848
xorl %r13d, %r13d
movl $0x8, %r8d
leaq 0x2870c8(%rip), %rax # 0x2fd910
movzbl (%r15), %edi
movb (%rax,%rdi), %al
cmpb $-0x1, %al
jne 0x768f8
movq %r8, -0x50(%rbp)
movq %r12, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r15, %r11
subq %rsi, %r11
movq -0x60(%rbp), %rax
leaq (%rax,%r15), %rcx
xorl %edi, %edi
movq %r15, %r12
movq %rdi, %r8
shlq $0x4, %r8
leaq 0x2a4c29(%rip), %rax # 0x31b4b0
movq (%r8,%rax), %r13
movb (%r13), %r10b
testb %r10b, %r10b
je 0x768bf
cmpq %rdx, %r11
jge 0x768bf
incq %r13
movq %rcx, %rbx
cmpb (%r15), %r10b
jne 0x768c4
incq %r15
movb (%r13), %r10b
testb %r10b, %r10b
je 0x768bf
leaq 0x1(%rbx), %rax
incq %r13
cmpq %rdx, %rbx
movq %rax, %rbx
jl 0x7689f
testb %r10b, %r10b
je 0x768d4
incq %rdi
cmpq $0x50, %rdi
movq %r12, %r15
jne 0x76879
movb $-0x1, %al
jmp 0x768e9
leaq 0x2a4bd5(%rip), %rax # 0x31b4b0
addq %rax, %r8
movq -0x50(%rbp), %rax
movb (%r8,%rax), %al
decq %r15
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r12
movzbl %al, %eax
incq %r15
movq %r12, %rdi
subq %rcx, %rdi
cmpq %r9, %rdi
jge 0x76915
testl %ebx, %ebx
je 0x76942
movl $0x9, %r10d
jmp 0x7693d
testl %ebx, %ebx
sete %dil
cmpl $0x0, -0x78(%rbp)
setg %r8b
xorl %r10d, %r10d
testb %dil, %r8b
je 0x76a3c
movl $0x1, %ebx
movl $0x9, %r10d
movq %rcx, %r12
movq %r14, %r8
jmp 0x76951
xorl %ebx, %ebx
movl $0x8, %r10d
leaq 0x286fbf(%rip), %r8 # 0x2fd910
movzbl (%r12), %edi
movb (%r8,%rdi), %dil
cmpb $-0x1, %dil
jne 0x76a35
movq %r10, -0x50(%rbp)
movq %r15, -0x38(%rbp)
movl %ebx, -0x2c(%rbp)
movq %r13, -0x40(%rbp)
movq %r12, %r14
subq %rcx, %r14
movq -0x68(%rbp), %rcx
movq %r12, %r11
leaq (%rcx,%r12), %rsi
xorl %r8d, %r8d
movq %r8, %r15
shlq $0x4, %r15
leaq 0x2a4b1b(%rip), %rcx # 0x31b4b0
movq (%r15,%rcx), %rbx
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x769d0
cmpq %r9, %r14
jge 0x769d0
incq %rbx
movq %rsi, %rdi
movq %r11, %r10
cmpb (%r10), %r13b
jne 0x769d8
incq %r10
movb (%rbx), %r13b
testb %r13b, %r13b
je 0x769d3
leaq 0x1(%rdi), %r12
incq %rbx
cmpq %r9, %rdi
movq %r12, %rdi
jl 0x769af
jmp 0x769d3
movq %r11, %r10
testb %r13b, %r13b
je 0x76a03
incq %r8
cmpq $0x50, %r8
jne 0x76987
movb $-0x1, %dil
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x28701d(%rip), %r14 # 0x2fda10
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movq %r11, %r12
jmp 0x76a35
leaq 0x2a4aa6(%rip), %rcx # 0x31b4b0
addq %rcx, %r15
movq -0x50(%rbp), %rcx
movb (%r15,%rcx), %dil
decq %r10
movq %r10, %r12
movq -0x48(%rbp), %rcx
movq -0x58(%rbp), %rsi
leaq 0x286fe6(%rip), %r14 # 0x2fda10
movq -0x40(%rbp), %r13
movl -0x2c(%rbp), %ebx
movq -0x38(%rbp), %r15
movzbl %dil, %r10d
incq %r12
testl %eax, %eax
je 0x76a49
cmpl %r10d, %eax
je 0x767f2
subl %r10d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strnncoll_win1250ch:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
cmp rdx, r8
mov rax, r8
cmovb rax, rdx
test r9b, r9b
cmovz rax, rdx
mov [rbp+var_70], rax
movsxd rdx, eax
mov [rbp+var_78], r8
movsxd r9, r8d
mov eax, 1
mov edi, 1
sub rdi, rsi
mov [rbp+var_60], rdi
sub rax, rcx
mov [rbp+var_68], rax
xor r13d, r13d
lea r14, _sort_order_win1250ch2
mov r15, rsi
mov r12, rcx
xor ebx, ebx
mov [rbp+var_48], rcx
mov [rbp+var_58], rsi
loc_767F2:
mov rax, r15
sub rax, rsi
cmp rax, rdx
jge short loc_7680A
test r13d, r13d
jz short loc_76838
mov r8d, 9
jmp short loc_76833
loc_7680A:
test r13d, r13d
setz r8b
cmp dword ptr [rbp+var_70], 0
setnle dil
xor eax, eax
test dil, r8b
jz loc_768FE
mov r13d, 1
mov r8d, 9
mov r15, rsi
loc_76833:
mov rax, r14
jmp short loc_76848
loc_76838:
xor r13d, r13d
mov r8d, 8
lea rax, _sort_order_win1250ch1
loc_76848:
movzx edi, byte ptr [r15]
mov al, [rax+rdi]
cmp al, 0FFh
jnz loc_768F8
mov [rbp+var_50], r8
mov [rbp+var_38], r12
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r11, r15
sub r11, rsi
mov rax, [rbp+var_60]
lea rcx, [rax+r15]
xor edi, edi
mov r12, r15
loc_76879:
mov r8, rdi
shl r8, 4
lea rax, doubles_0
mov r13, [r8+rax]
mov r10b, [r13+0]
test r10b, r10b
jz short loc_768BF
cmp r11, rdx
jge short loc_768BF
inc r13
mov rbx, rcx
loc_7689F:
cmp r10b, [r15]
jnz short loc_768C4
inc r15
mov r10b, [r13+0]
test r10b, r10b
jz short loc_768BF
lea rax, [rbx+1]
inc r13
cmp rbx, rdx
mov rbx, rax
jl short loc_7689F
loc_768BF:
test r10b, r10b
jz short loc_768D4
loc_768C4:
inc rdi
cmp rdi, 50h ; 'P'
mov r15, r12
jnz short loc_76879
mov al, 0FFh
jmp short loc_768E9
loc_768D4:
lea rax, doubles_0
add r8, rax
mov rax, [rbp+var_50]
mov al, [r8+rax]
dec r15
loc_768E9:
mov rcx, [rbp+var_48]
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_38]
loc_768F8:
movzx eax, al
inc r15
loc_768FE:
mov rdi, r12
sub rdi, rcx
cmp rdi, r9
jge short loc_76915
test ebx, ebx
jz short loc_76942
mov r10d, 9
jmp short loc_7693D
loc_76915:
test ebx, ebx
setz dil
cmp dword ptr [rbp+var_78], 0
setnle r8b
xor r10d, r10d
test r8b, dil
jz loc_76A3C
mov ebx, 1
mov r10d, 9
mov r12, rcx
loc_7693D:
mov r8, r14
jmp short loc_76951
loc_76942:
xor ebx, ebx
mov r10d, 8
lea r8, _sort_order_win1250ch1
loc_76951:
movzx edi, byte ptr [r12]
mov dil, [r8+rdi]
cmp dil, 0FFh
jnz loc_76A35
mov [rbp+var_50], r10
mov [rbp+var_38], r15
mov [rbp+var_2C], ebx
mov [rbp+var_40], r13
mov r14, r12
sub r14, rcx
mov rcx, [rbp+var_68]
mov r11, r12
lea rsi, [rcx+r12]
xor r8d, r8d
loc_76987:
mov r15, r8
shl r15, 4
lea rcx, doubles_0
mov rbx, [r15+rcx]
mov r13b, [rbx]
test r13b, r13b
jz short loc_769D0
cmp r14, r9
jge short loc_769D0
inc rbx
mov rdi, rsi
mov r10, r11
loc_769AF:
cmp r13b, [r10]
jnz short loc_769D8
inc r10
mov r13b, [rbx]
test r13b, r13b
jz short loc_769D3
lea r12, [rdi+1]
inc rbx
cmp rdi, r9
mov rdi, r12
jl short loc_769AF
jmp short loc_769D3
loc_769D0:
mov r10, r11
loc_769D3:
test r13b, r13b
jz short loc_76A03
loc_769D8:
inc r8
cmp r8, 50h ; 'P'
jnz short loc_76987
mov dil, 0FFh
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
mov r12, r11
jmp short loc_76A35
loc_76A03:
lea rcx, doubles_0
add r15, rcx
mov rcx, [rbp+var_50]
mov dil, [r15+rcx]
dec r10
mov r12, r10
mov rcx, [rbp+var_48]
mov rsi, [rbp+var_58]
lea r14, _sort_order_win1250ch2
mov r13, [rbp+var_40]
mov ebx, [rbp+var_2C]
mov r15, [rbp+var_38]
loc_76A35:
movzx r10d, dil
inc r12
loc_76A3C:
test eax, eax
jz short loc_76A49
cmp eax, r10d
jz loc_767F2
loc_76A49:
sub eax, r10d
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strnncoll_win1250ch(
long long a1,
_BYTE *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
int v6; // eax
long long v7; // rdx
long long v8; // r9
long long v9; // r13
_BYTE *v10; // r15
unsigned __int8 *v11; // r12
int v12; // ebx
long long v13; // r8
_BYTE *v14; // rax
_BYTE *v15; // r11
_BYTE *v16; // rcx
long long v17; // rdi
_BYTE *v18; // r12
char *v19; // r13
char v20; // r10
char *v21; // r13
_BYTE *v22; // rbx
bool v23; // cc
long long v24; // r10
int v25; // r10d
_BYTE *v26; // r8
unsigned __int8 v27; // di
long long v28; // r8
char *v29; // rbx
char v30; // r13
char *v31; // rbx
unsigned __int8 *v32; // rdi
_BYTE *v33; // r10
int v35; // [rsp+0h] [rbp-78h]
int v36; // [rsp+8h] [rbp-70h]
long long v37; // [rsp+10h] [rbp-68h]
long long v38; // [rsp+18h] [rbp-60h]
_BYTE *v39; // [rsp+20h] [rbp-58h]
long long v40; // [rsp+28h] [rbp-50h]
unsigned __int8 *v41; // [rsp+30h] [rbp-48h]
long long v42; // [rsp+38h] [rbp-40h]
long long v43; // [rsp+38h] [rbp-40h]
unsigned __int8 *v44; // [rsp+40h] [rbp-38h]
int v45; // [rsp+4Ch] [rbp-2Ch]
int v46; // [rsp+4Ch] [rbp-2Ch]
v6 = a5;
if ( a3 < a5 )
v6 = a3;
if ( !a6 )
v6 = a3;
v36 = v6;
v7 = v6;
v35 = a5;
v8 = (int)a5;
v38 = 1LL - (_QWORD)a2;
v37 = 1LL - (_QWORD)a4;
v9 = 0LL;
v10 = a2;
v11 = a4;
v12 = 0;
v41 = a4;
v39 = a2;
do
{
if ( v10 - a2 >= v7 )
{
LODWORD(v14) = 0;
if ( (_DWORD)v9 != 0 || v36 <= 0 )
goto LABEL_27;
v9 = 1LL;
v13 = 9LL;
v10 = a2;
}
else
{
if ( !(_DWORD)v9 )
{
v9 = 0LL;
v13 = 8LL;
v14 = &sort_order_win1250ch1;
goto LABEL_13;
}
v13 = 9LL;
}
v14 = &sort_order_win1250ch2;
LABEL_13:
LOBYTE(v14) = v14[(unsigned __int8)*v10];
if ( (_BYTE)v14 != 0xFF )
goto LABEL_26;
v44 = v11;
v45 = v12;
v42 = v9;
v15 = (_BYTE *)(v10 - a2);
v16 = &v10[v38];
v17 = 0LL;
v18 = v10;
while ( 1 )
{
v19 = (char *)*(&doubles_0 + 2 * v17);
v20 = *v19;
if ( *v19 && (long long)v15 < v7 )
{
v21 = v19 + 1;
v22 = v16;
while ( v20 == *v10 )
{
++v10;
v20 = *v21;
if ( *v21 )
{
++v21;
v23 = (long long)v22++ < v7;
if ( v23 )
continue;
}
goto LABEL_21;
}
goto LABEL_22;
}
LABEL_21:
if ( !v20 )
break;
LABEL_22:
++v17;
v10 = v18;
if ( v17 == 80 )
{
LOBYTE(v14) = -1;
goto LABEL_25;
}
}
LOBYTE(v14) = *((_BYTE *)&doubles_0 + 16 * v17 + v13);
--v10;
LABEL_25:
a4 = v41;
v9 = v42;
v12 = v45;
v11 = v44;
LABEL_26:
LODWORD(v14) = (unsigned __int8)v14;
++v10;
LABEL_27:
if ( v11 - a4 >= v8 )
{
v25 = 0;
if ( v12 != 0 || v35 <= 0 )
continue;
v12 = 1;
v24 = 9LL;
v11 = a4;
LABEL_32:
v26 = &sort_order_win1250ch2;
}
else
{
if ( v12 )
{
v24 = 9LL;
goto LABEL_32;
}
v12 = 0;
v24 = 8LL;
v26 = &sort_order_win1250ch1;
}
v27 = v26[*v11];
if ( v27 != 0xFF )
goto LABEL_48;
v40 = v24;
v46 = v12;
v43 = v9;
v28 = 0LL;
while ( 2 )
{
v29 = (char *)*(&doubles_0 + 2 * v28);
v30 = *v29;
if ( *v29 && v11 - a4 < v8 )
{
v31 = v29 + 1;
v32 = &v11[v37];
v33 = v11;
while ( v30 == *v33 )
{
++v33;
v30 = *v31;
if ( *v31 )
{
++v31;
v23 = (long long)v32++ < v8;
if ( v23 )
continue;
}
goto LABEL_44;
}
goto LABEL_45;
}
v33 = v11;
LABEL_44:
if ( v30 )
{
LABEL_45:
if ( ++v28 == 80 )
{
v27 = -1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
goto LABEL_48;
}
continue;
}
break;
}
v27 = *((_BYTE *)&doubles_0 + 16 * v28 + v40);
v11 = v33 - 1;
a4 = v41;
a2 = v39;
v9 = v43;
v12 = v46;
LABEL_48:
v25 = v27;
++v11;
}
while ( (_DWORD)v14 && (_DWORD)v14 == v25 );
return (unsigned int)((_DWORD)v14 - v25);
}
|
my_strnncoll_win1250ch:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
CMP RDX,R8
MOV RAX,R8
CMOVC RAX,RDX
TEST R9B,R9B
CMOVZ RAX,RDX
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RDX,EAX
MOV qword ptr [RBP + -0x78],R8
MOVSXD R9,R8D
MOV EAX,0x1
MOV EDI,0x1
SUB RDI,RSI
MOV qword ptr [RBP + -0x60],RDI
SUB RAX,RCX
MOV qword ptr [RBP + -0x68],RAX
XOR R13D,R13D
LEA R14,[0x3fda10]
MOV R15,RSI
MOV R12,RCX
XOR EBX,EBX
MOV qword ptr [RBP + -0x48],RCX
MOV qword ptr [RBP + -0x58],RSI
LAB_001767f2:
MOV RAX,R15
SUB RAX,RSI
CMP RAX,RDX
JGE 0x0017680a
TEST R13D,R13D
JZ 0x00176838
MOV R8D,0x9
JMP 0x00176833
LAB_0017680a:
TEST R13D,R13D
SETZ R8B
CMP dword ptr [RBP + -0x70],0x0
SETG DIL
XOR EAX,EAX
TEST DIL,R8B
JZ 0x001768fe
MOV R13D,0x1
MOV R8D,0x9
MOV R15,RSI
LAB_00176833:
MOV RAX,R14
JMP 0x00176848
LAB_00176838:
XOR R13D,R13D
MOV R8D,0x8
LEA RAX,[0x3fd910]
LAB_00176848:
MOVZX EDI,byte ptr [R15]
MOV AL,byte ptr [RAX + RDI*0x1]
CMP AL,0xff
JNZ 0x001768f8
MOV qword ptr [RBP + -0x50],R8
MOV qword ptr [RBP + -0x38],R12
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R11,R15
SUB R11,RSI
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[RAX + R15*0x1]
XOR EDI,EDI
MOV R12,R15
LAB_00176879:
MOV R8,RDI
SHL R8,0x4
LEA RAX,[0x41b4b0]
MOV R13,qword ptr [R8 + RAX*0x1]
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x001768bf
CMP R11,RDX
JGE 0x001768bf
INC R13
MOV RBX,RCX
LAB_0017689f:
CMP R10B,byte ptr [R15]
JNZ 0x001768c4
INC R15
MOV R10B,byte ptr [R13]
TEST R10B,R10B
JZ 0x001768bf
LEA RAX,[RBX + 0x1]
INC R13
CMP RBX,RDX
MOV RBX,RAX
JL 0x0017689f
LAB_001768bf:
TEST R10B,R10B
JZ 0x001768d4
LAB_001768c4:
INC RDI
CMP RDI,0x50
MOV R15,R12
JNZ 0x00176879
MOV AL,0xff
JMP 0x001768e9
LAB_001768d4:
LEA RAX,[0x41b4b0]
ADD R8,RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [R8 + RAX*0x1]
DEC R15
LAB_001768e9:
MOV RCX,qword ptr [RBP + -0x48]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x38]
LAB_001768f8:
MOVZX EAX,AL
INC R15
LAB_001768fe:
MOV RDI,R12
SUB RDI,RCX
CMP RDI,R9
JGE 0x00176915
TEST EBX,EBX
JZ 0x00176942
MOV R10D,0x9
JMP 0x0017693d
LAB_00176915:
TEST EBX,EBX
SETZ DIL
CMP dword ptr [RBP + -0x78],0x0
SETG R8B
XOR R10D,R10D
TEST R8B,DIL
JZ 0x00176a3c
MOV EBX,0x1
MOV R10D,0x9
MOV R12,RCX
LAB_0017693d:
MOV R8,R14
JMP 0x00176951
LAB_00176942:
XOR EBX,EBX
MOV R10D,0x8
LEA R8,[0x3fd910]
LAB_00176951:
MOVZX EDI,byte ptr [R12]
MOV DIL,byte ptr [R8 + RDI*0x1]
CMP DIL,0xff
JNZ 0x00176a35
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x38],R15
MOV dword ptr [RBP + -0x2c],EBX
MOV qword ptr [RBP + -0x40],R13
MOV R14,R12
SUB R14,RCX
MOV RCX,qword ptr [RBP + -0x68]
MOV R11,R12
LEA RSI,[RCX + R12*0x1]
XOR R8D,R8D
LAB_00176987:
MOV R15,R8
SHL R15,0x4
LEA RCX,[0x41b4b0]
MOV RBX,qword ptr [R15 + RCX*0x1]
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x001769d0
CMP R14,R9
JGE 0x001769d0
INC RBX
MOV RDI,RSI
MOV R10,R11
LAB_001769af:
CMP R13B,byte ptr [R10]
JNZ 0x001769d8
INC R10
MOV R13B,byte ptr [RBX]
TEST R13B,R13B
JZ 0x001769d3
LEA R12,[RDI + 0x1]
INC RBX
CMP RDI,R9
MOV RDI,R12
JL 0x001769af
JMP 0x001769d3
LAB_001769d0:
MOV R10,R11
LAB_001769d3:
TEST R13B,R13B
JZ 0x00176a03
LAB_001769d8:
INC R8
CMP R8,0x50
JNZ 0x00176987
MOV DIL,0xff
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x3fda10]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
MOV R12,R11
JMP 0x00176a35
LAB_00176a03:
LEA RCX,[0x41b4b0]
ADD R15,RCX
MOV RCX,qword ptr [RBP + -0x50]
MOV DIL,byte ptr [R15 + RCX*0x1]
DEC R10
MOV R12,R10
MOV RCX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x58]
LEA R14,[0x3fda10]
MOV R13,qword ptr [RBP + -0x40]
MOV EBX,dword ptr [RBP + -0x2c]
MOV R15,qword ptr [RBP + -0x38]
LAB_00176a35:
MOVZX R10D,DIL
INC R12
LAB_00176a3c:
TEST EAX,EAX
JZ 0x00176a49
CMP EAX,R10D
JZ 0x001767f2
LAB_00176a49:
SUB EAX,R10D
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_strnncoll_win1250ch
(int8 param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
bool bVar1;
bool bVar2;
byte *pbVar3;
byte *pbVar4;
byte *pbVar5;
byte bVar6;
int iVar7;
ulong uVar9;
int1 *puVar10;
long lVar11;
int iVar12;
uint uVar13;
long lVar14;
byte *pbVar15;
byte *pbVar16;
byte *pbVar17;
byte *pbVar18;
uint uVar8;
uVar9 = param_5;
if (param_3 < param_5) {
uVar9 = param_3;
}
if (param_6 == '\0') {
uVar9 = param_3;
}
iVar7 = (int)uVar9;
iVar12 = (int)param_5;
bVar2 = false;
bVar1 = false;
pbVar15 = param_4;
pbVar18 = param_2;
do {
if ((long)pbVar18 - (long)param_2 < (long)iVar7) {
if (bVar2) {
LAB_00176833:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar2 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar18];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar18;
pbVar5 = pbVar18 + (1 - (long)param_2);
pbVar4 = pbVar18 + -(long)param_2;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar7) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_001768c4;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar18 = pbVar17 + -1;
goto LAB_001768f8;
}
LAB_001768c4:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_001768f8:
uVar8 = (uint)bVar6;
pbVar18 = pbVar18 + 1;
}
else {
uVar8 = 0;
if (0 < iVar7 && !bVar2) {
bVar2 = true;
pbVar18 = param_2;
goto LAB_00176833;
}
}
if ((long)pbVar15 - (long)param_4 < (long)iVar12) {
if (bVar1) {
LAB_0017693d:
lVar14 = 9;
puVar10 = _sort_order_win1250ch2;
}
else {
bVar1 = false;
lVar14 = 8;
puVar10 = _sort_order_win1250ch1;
}
bVar6 = puVar10[*pbVar15];
if (bVar6 == 0xff) {
lVar11 = 0;
do {
pbVar16 = (&doubles)[lVar11 * 2];
bVar6 = *pbVar16;
pbVar17 = pbVar15;
pbVar5 = pbVar15 + (1 - (long)param_4);
pbVar4 = pbVar15 + -(long)param_4;
if (bVar6 != 0) {
while (pbVar3 = pbVar5, (long)pbVar4 < (long)iVar12) {
pbVar16 = pbVar16 + 1;
if (bVar6 != *pbVar17) goto LAB_001769d8;
pbVar17 = pbVar17 + 1;
bVar6 = *pbVar16;
if (bVar6 == 0) break;
pbVar5 = pbVar3 + 1;
pbVar4 = pbVar3;
}
}
if (bVar6 == 0) {
bVar6 = *(byte *)((long)&doubles + lVar14 + lVar11 * 0x10);
pbVar15 = pbVar17 + -1;
goto LAB_00176a35;
}
LAB_001769d8:
lVar11 = lVar11 + 1;
} while (lVar11 != 0x50);
bVar6 = 0xff;
}
LAB_00176a35:
uVar13 = (uint)bVar6;
pbVar15 = pbVar15 + 1;
}
else {
uVar13 = 0;
if (0 < iVar12 && !bVar1) {
bVar1 = true;
pbVar15 = param_4;
goto LAB_0017693d;
}
}
if ((uVar8 == 0) || (uVar8 != uVar13)) {
return uVar8 - uVar13;
}
} while( true );
}
|
|
57,615
|
my_thread_init_common_mutex
|
eloqsql/mysys/my_thr_init.c
|
static void my_thread_init_common_mutex(void)
{
mysql_mutex_init(key_THR_LOCK_open, &THR_LOCK_open, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_lock, &THR_LOCK_lock, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_myisam, &THR_LOCK_myisam, MY_MUTEX_INIT_SLOW);
mysql_mutex_init(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_heap, &THR_LOCK_heap, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_net, &THR_LOCK_net, MY_MUTEX_INIT_FAST);
mysql_mutex_init(key_THR_LOCK_charset, &THR_LOCK_charset, MY_MUTEX_INIT_FAST);
#if !defined(HAVE_LOCALTIME_R) || !defined(HAVE_GMTIME_R)
mysql_mutex_init(key_LOCK_localtime_r, &LOCK_localtime_r, MY_MUTEX_INIT_SLOW);
#endif
}
|
O0
|
c
|
my_thread_init_common_mutex:
pushq %rbp
movq %rsp, %rbp
leaq 0xb8f5cd(%rip), %rax # 0xc8dd28
movl (%rax), %edi
leaq 0xb8ffac(%rip), %rsi # 0xc8e710
leaq 0xb902a5(%rip), %rdx # 0xc8ea10
callq 0xff460
leaq 0xb8f59d(%rip), %rax # 0xc8dd14
movl (%rax), %edi
leaq 0xb8ffd8(%rip), %rsi # 0xc8e758
leaq 0xb90289(%rip), %rdx # 0xc8ea10
callq 0xff460
leaq 0xb8f58d(%rip), %rax # 0xc8dd20
movl (%rax), %edi
leaq 0xb90004(%rip), %rsi # 0xc8e7a0
xorl %eax, %eax
movl %eax, %edx
callq 0xff460
leaq 0xb8f588(%rip), %rax # 0xc8dd34
movl (%rax), %edi
leaq 0xb90033(%rip), %rsi # 0xc8e7e8
leaq 0xb90254(%rip), %rdx # 0xc8ea10
callq 0xff460
leaq 0xb8f548(%rip), %rax # 0xc8dd10
movl (%rax), %edi
leaq 0xb9005f(%rip), %rsi # 0xc8e830
leaq 0xb90238(%rip), %rdx # 0xc8ea10
callq 0xff460
leaq 0xb8f540(%rip), %rax # 0xc8dd24
movl (%rax), %edi
leaq 0xb9008b(%rip), %rsi # 0xc8e878
leaq 0xb9021c(%rip), %rdx # 0xc8ea10
callq 0xff460
leaq 0xb8f50c(%rip), %rax # 0xc8dd0c
movl (%rax), %edi
leaq 0xb900b7(%rip), %rsi # 0xc8e8c0
leaq 0xb90200(%rip), %rdx # 0xc8ea10
callq 0xff460
popq %rbp
retq
nopw (%rax,%rax)
|
my_thread_init_common_mutex:
push rbp
mov rbp, rsp
lea rax, key_THR_LOCK_open
mov edi, [rax]
lea rsi, THR_LOCK_open
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_lock
mov edi, [rax]
lea rsi, THR_LOCK_lock
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_myisam
mov edi, [rax]
lea rsi, THR_LOCK_myisam
xor eax, eax
mov edx, eax
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_myisam_mmap
mov edi, [rax]
lea rsi, THR_LOCK_myisam_mmap
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_heap
mov edi, [rax]
lea rsi, THR_LOCK_heap
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_net
mov edi, [rax]
lea rsi, THR_LOCK_net
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
lea rax, key_THR_LOCK_charset
mov edi, [rax]
lea rsi, THR_LOCK_charset
lea rdx, my_fast_mutexattr
call inline_mysql_mutex_init_10
pop rbp
retn
|
long long my_thread_init_common_mutex()
{
inline_mysql_mutex_init_10(key_THR_LOCK_open, &THR_LOCK_open, &my_fast_mutexattr);
inline_mysql_mutex_init_10(key_THR_LOCK_lock, &THR_LOCK_lock, &my_fast_mutexattr);
inline_mysql_mutex_init_10(key_THR_LOCK_myisam, &THR_LOCK_myisam, 0LL);
inline_mysql_mutex_init_10(key_THR_LOCK_myisam_mmap, &THR_LOCK_myisam_mmap, &my_fast_mutexattr);
inline_mysql_mutex_init_10(key_THR_LOCK_heap, &THR_LOCK_heap, &my_fast_mutexattr);
inline_mysql_mutex_init_10(key_THR_LOCK_net, &THR_LOCK_net, &my_fast_mutexattr);
return inline_mysql_mutex_init_10(key_THR_LOCK_charset, &THR_LOCK_charset, &my_fast_mutexattr);
}
|
my_thread_init_common_mutex:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0xd8dd28]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e710]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
LEA RAX,[0xd8dd14]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e758]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
LEA RAX,[0xd8dd20]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e7a0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001ff460
LEA RAX,[0xd8dd34]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e7e8]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
LEA RAX,[0xd8dd10]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e830]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
LEA RAX,[0xd8dd24]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e878]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
LEA RAX,[0xd8dd0c]
MOV EDI,dword ptr [RAX]
LEA RSI,[0xd8e8c0]
LEA RDX,[0xd8ea10]
CALL 0x001ff460
POP RBP
RET
|
void my_thread_init_common_mutex(void)
{
inline_mysql_mutex_init(key_THR_LOCK_open,THR_LOCK_open,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_lock,THR_LOCK_lock,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_myisam,THR_LOCK_myisam,0);
inline_mysql_mutex_init(key_THR_LOCK_myisam_mmap,THR_LOCK_myisam_mmap,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_heap,THR_LOCK_heap,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_net,THR_LOCK_net,&my_fast_mutexattr);
inline_mysql_mutex_init(key_THR_LOCK_charset,THR_LOCK_charset,&my_fast_mutexattr);
return;
}
|
|
57,616
|
LefDefParser::defwNetFrequency(double)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defwWriter.cpp
|
int
defwNetFrequency(double frequency)
{
defwFunc = DEFW_NET; // Current function of writer
if (!defwFile)
return DEFW_UNINITIALIZED;
if (!defwNetOptions())
return DEFW_BAD_ORDER;
fprintf(defwFile, "\n + FREQUENCY %.11g", frequency);
defwLines++;
return DEFW_OK;
}
|
O3
|
cpp
|
LefDefParser::defwNetFrequency(double):
leaq 0x109a7(%rip), %rax # 0x1e178
movl $0x3a, (%rax)
leaq 0x1098a(%rip), %rax # 0x1e168
movq (%rax), %rdi
testq %rdi, %rdi
je 0xd823
leaq 0x10987(%rip), %rcx # 0x1e174
movl (%rcx), %edx
cmpl $0x3b, %edx
je 0xd804
movl $0x2, %eax
cmpl $0x3a, %edx
jne 0xd822
movl $0x3b, (%rcx)
pushq %rax
leaq 0x8540(%rip), %rsi # 0x15d4c
movb $0x1, %al
callq 0x10e0
leaq 0x10956(%rip), %rax # 0x1e170
incl (%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0x1, %eax
retq
|
_ZN12LefDefParser16defwNetFrequencyEd:
lea rax, _ZN12LefDefParser8defwFuncE; LefDefParser::defwFunc
mov dword ptr [rax], 3Ah ; ':'
lea rax, _ZN12LefDefParser8defwFileE; LefDefParser::defwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_D823
lea rcx, _ZN12LefDefParser9defwStateE; LefDefParser::defwState
mov edx, [rcx]
cmp edx, 3Bh ; ';'
jz short loc_D804
mov eax, 2
cmp edx, 3Ah ; ':'
jnz short locret_D822
mov dword ptr [rcx], 3Bh ; ';'
loc_D804:
push rax
lea rsi, aFrequency11g; "\n + FREQUENCY %.11g"
mov al, 1
call _fprintf
lea rax, _ZN12LefDefParser9defwLinesE; LefDefParser::defwLines
inc dword ptr [rax]
xor eax, eax
add rsp, 8
locret_D822:
retn
loc_D823:
mov eax, 1
retn
|
long long LefDefParser::defwNetFrequency(LefDefParser *this, double a2)
{
long long result; // rax
LefDefParser::defwFunc = 58;
if ( !LefDefParser::defwFile )
return 1LL;
if ( LefDefParser::defwState != 59 )
{
result = 2LL;
if ( LefDefParser::defwState != 58 )
return result;
LefDefParser::defwState = 59;
}
fprintf(LefDefParser::defwFile, "\n + FREQUENCY %.11g", a2);
++LefDefParser::defwLines;
return 0LL;
}
|
defwNetFrequency:
LEA RAX,[0x11e178]
MOV dword ptr [RAX],0x3a
LEA RAX,[0x11e168]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x0010d823
LEA RCX,[0x11e174]
MOV EDX,dword ptr [RCX]
CMP EDX,0x3b
JZ 0x0010d804
MOV EAX,0x2
CMP EDX,0x3a
JNZ 0x0010d822
MOV dword ptr [RCX],0x3b
LAB_0010d804:
PUSH RAX
LEA RSI,[0x115d4c]
MOV AL,0x1
CALL 0x001010e0
LEA RAX,[0x11e170]
INC dword ptr [RAX]
XOR EAX,EAX
ADD RSP,0x8
LAB_0010d822:
RET
LAB_0010d823:
MOV EAX,0x1
RET
|
/* LefDefParser::defwNetFrequency(double) */
int8 LefDefParser::defwNetFrequency(double param_1)
{
defwFunc = 0x3a;
if (defwFile == (FILE *)0x0) {
return 1;
}
if (defwState != 0x3b) {
if (defwState != 0x3a) {
defwFunc = 0x3a;
return 2;
}
defwState = 0x3b;
}
fprintf(defwFile,"\n + FREQUENCY %.11g");
defwLines = defwLines + 1;
return 0;
}
|
|
57,617
|
httplib::detail::get_multipart_ranges_data_length(httplib::Request const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline size_t get_multipart_ranges_data_length(const Request &req,
const std::string &boundary,
const std::string &content_type,
size_t content_length) {
size_t data_length = 0;
process_multipart_ranges_data(
req, boundary, content_type, content_length,
[&](const std::string &token) { data_length += token.size(); },
[&](const std::string &token) { data_length += token.size(); },
[&](size_t /*offset*/, size_t length) {
data_length += length;
return true;
});
return data_length;
}
|
O2
|
c
|
httplib::detail::get_multipart_ranges_data_length(httplib::Request const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long):
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
movq %rbx, (%rsp)
movq %rbx, %r8
movq %rbx, %r9
callq 0x2ba5b
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
|
_ZN7httplib6detail32get_multipart_ranges_data_lengthERKNS_7RequestERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESB_m:
push rbx
sub rsp, 10h
lea rbx, [rsp+18h+var_10]
and qword ptr [rbx], 0
mov [rsp+18h+var_18], rbx
mov r8, rbx
mov r9, rbx
call _ZN7httplib6detail29process_multipart_ranges_dataIZNS0_32get_multipart_ranges_data_lengthERKNS_7RequestERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESC_mEUlSC_E_ZNS0_32get_multipart_ranges_data_lengthES4_SC_SC_mEUlSC_E0_ZNS0_32get_multipart_ranges_data_lengthES4_SC_SC_mEUlmmE_EEbS4_SC_SC_mT_T0_T1_; httplib::detail::process_multipart_ranges_data<httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(std::string const&)#1},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(std::string const&)#2},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(ulong,ulong)#1}>(httplib::Request const&,std::string const&,std::string const&,ulong,httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(std::string const&)#1},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(std::string const&)#2},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,ulong)::{lambda(ulong,ulong)#1})
mov rax, [rbx]
add rsp, 10h
pop rbx
retn
|
long long httplib::detail::get_multipart_ranges_data_length(int a1, int a2, int a3, int a4)
{
_QWORD v5[2]; // [rsp+8h] [rbp-10h] BYREF
v5[0] = 0LL;
httplib::detail::process_multipart_ranges_data<httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,unsigned long)::{lambda(std::string const&)#1},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,unsigned long)::{lambda(std::string const&)#2},httplib::detail::get_multipart_ranges_data_length(httplib::Request const&,std::string const&,std::string const&,unsigned long)::{lambda(unsigned long,unsigned long)#1}>(
a1,
a2,
a3,
a4,
(unsigned int)v5,
(unsigned int)v5,
(long long)v5);
return v5[0];
}
|
get_multipart_ranges_data_length:
PUSH RBX
SUB RSP,0x10
LEA RBX,[RSP + 0x8]
AND qword ptr [RBX],0x0
MOV qword ptr [RSP],RBX
MOV R8,RBX
MOV R9,RBX
CALL 0x0012ba5b
MOV RAX,qword ptr [RBX]
ADD RSP,0x10
POP RBX
RET
|
/* httplib::detail::get_multipart_ranges_data_length(httplib::Request const&, std::__cxx11::string
const&, std::__cxx11::string const&, unsigned long) */
int8
httplib::detail::get_multipart_ranges_data_length
(Request *param_1,string *param_2,string *param_3,ulong param_4)
{
process_multipart_ranges_data<httplib::detail::get_multipart_ranges_data_length(httplib::Request_const&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long)::_lambda(std::__cxx11::string_const&)_1_,httplib::detail::get_multipart_ranges_data_length(httplib::Request_const&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long)::_lambda(std::__cxx11::string_const&)_2_,httplib::detail::get_multipart_ranges_data_length(httplib::Request_const&,std::__cxx11::string_const&,std::__cxx11::string_const&,unsigned_long)::_lambda(unsigned_long,unsigned_long)_1_>
();
return 0;
}
|
|
57,618
|
test_bug4030
|
eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c
|
static int test_bug4030(MYSQL *mysql)
{
MYSQL_STMT *stmt;
MYSQL_BIND my_bind[3];
MYSQL_TIME time_canonical, time_out;
MYSQL_TIME date_canonical, date_out;
MYSQL_TIME datetime_canonical, datetime_out;
const char *stmt_text;
int rc;
/* Check that microseconds are inserted and selected successfully */
/* Execute a query with time values in prepared mode */
stmt= mysql_stmt_init(mysql);
stmt_text= "SELECT '23:59:59.123456', '2003-12-31', "
"'2003-12-31 23:59:59.123456'";
rc= mysql_stmt_prepare(stmt, SL(stmt_text));
check_stmt_rc(rc, stmt);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
/* Bind output buffers */
memset(my_bind, '\0', sizeof(my_bind));
memset(&time_canonical, '\0', sizeof(time_canonical));
memset(&time_out, '\0', sizeof(time_out));
memset(&date_canonical, '\0', sizeof(date_canonical));
memset(&date_out, '\0', sizeof(date_out));
memset(&datetime_canonical, '\0', sizeof(datetime_canonical));
memset(&datetime_out, '\0', sizeof(datetime_out));
my_bind[0].buffer_type= MYSQL_TYPE_TIME;
my_bind[0].buffer= (void *) &time_out;
my_bind[1].buffer_type= MYSQL_TYPE_DATE;
my_bind[1].buffer= (void *) &date_out;
my_bind[2].buffer_type= MYSQL_TYPE_DATETIME;
my_bind[2].buffer= (void *) &datetime_out;
time_canonical.hour= 23;
time_canonical.minute= 59;
time_canonical.second= 59;
time_canonical.second_part= 123456;
time_canonical.time_type= MYSQL_TIMESTAMP_TIME;
date_canonical.year= 2003;
date_canonical.month= 12;
date_canonical.day= 31;
date_canonical.time_type= MYSQL_TIMESTAMP_DATE;
datetime_canonical= time_canonical;
datetime_canonical.year= 2003;
datetime_canonical.month= 12;
datetime_canonical.day= 31;
datetime_canonical.time_type= MYSQL_TIMESTAMP_DATETIME;
mysql_stmt_bind_result(stmt, my_bind);
rc= mysql_stmt_fetch(stmt);
FAIL_UNLESS(rc == 0, "rc != 0");
FAIL_UNLESS(memcmp(&time_canonical, &time_out, sizeof(time_out)) == 0, "time_canonical != time_out");
FAIL_UNLESS(memcmp(&date_canonical, &date_out, sizeof(date_out)) == 0, "date_canoncical != date_out");
FAIL_UNLESS(memcmp(&datetime_canonical, &datetime_out, sizeof(datetime_out)) == 0, "datetime_canonical != datetime_out");
mysql_stmt_close(stmt);
return OK;
}
|
O0
|
c
|
test_bug4030:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp # imm = 0x280
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, -0x18(%rbp)
leaq 0x428aa(%rip), %rax # 0x68d8d
movq %rax, -0x268(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x268(%rbp), %rax
movq %rax, -0x278(%rbp)
movq -0x268(%rbp), %rdi
callq 0x141a0
movq -0x280(%rbp), %rdi
movq -0x278(%rbp), %rsi
movq %rax, %rdx
callq 0x45070
movl %eax, -0x26c(%rbp)
cmpl $0x0, -0x26c(%rbp)
je 0x26566
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3f049(%rip), %rdi # 0x65590
leaq 0x3fb1f(%rip), %rdx # 0x6606d
movl $0x901, %ecx # imm = 0x901
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x26568
movq -0x18(%rbp), %rdi
callq 0x46580
movl %eax, -0x26c(%rbp)
cmpl $0x0, -0x26c(%rbp)
je 0x265b2
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3effd(%rip), %rdi # 0x65590
leaq 0x3fad3(%rip), %rdx # 0x6606d
movl $0x903, %ecx # imm = 0x903
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x265b4
leaq -0x170(%rbp), %rdi
xorl %esi, %esi
movl $0x150, %edx # imm = 0x150
callq 0x14260
leaq -0x198(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x1c0(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x1e8(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x238(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
leaq -0x260(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x14260
movl $0xb, -0x110(%rbp)
leaq -0x1c0(%rbp), %rax
movq %rax, -0x160(%rbp)
movl $0xa, -0xa0(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0xf0(%rbp)
movl $0xc, -0x30(%rbp)
leaq -0x260(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x17, -0x18c(%rbp)
movl $0x3b, -0x188(%rbp)
movl $0x3b, -0x184(%rbp)
movq $0x1e240, -0x180(%rbp) # imm = 0x1E240
movl $0x2, -0x174(%rbp)
movl $0x7d3, -0x1e8(%rbp) # imm = 0x7D3
movl $0xc, -0x1e4(%rbp)
movl $0x1f, -0x1e0(%rbp)
movl $0x0, -0x1c4(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x198(%rbp), %rsi
movl $0x28, %edx
callq 0x14370
movl $0x7d3, -0x238(%rbp) # imm = 0x7D3
movl $0xc, -0x234(%rbp)
movl $0x1f, -0x230(%rbp)
movl $0x1, -0x214(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x170(%rbp), %rsi
callq 0x43940
movq -0x18(%rbp), %rdi
callq 0x44020
movl %eax, -0x26c(%rbp)
cmpl $0x0, -0x26c(%rbp)
je 0x2676b
leaq 0x3ee4b(%rip), %rdi # 0x65590
leaq 0x4261d(%rip), %rsi # 0x68d69
leaq 0x3f91a(%rip), %rdx # 0x6606d
movl $0x927, %ecx # imm = 0x927
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x2676d
jmp 0x2676f
leaq -0x198(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
movl $0x28, %edx
callq 0x141b0
cmpl $0x0, %eax
je 0x267b9
leaq 0x3edfd(%rip), %rdi # 0x65590
leaq 0x42638(%rip), %rsi # 0x68dd2
leaq 0x3f8cc(%rip), %rdx # 0x6606d
movl $0x928, %ecx # imm = 0x928
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x267bb
jmp 0x267bd
leaq -0x1e8(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movl $0x28, %edx
callq 0x141b0
cmpl $0x0, %eax
je 0x26804
leaq 0x3edaf(%rip), %rdi # 0x65590
leaq 0x42605(%rip), %rsi # 0x68ded
leaq 0x3f87e(%rip), %rdx # 0x6606d
movl $0x929, %ecx # imm = 0x929
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x26806
jmp 0x26808
leaq -0x238(%rbp), %rdi
leaq -0x260(%rbp), %rsi
movl $0x28, %edx
callq 0x141b0
cmpl $0x0, %eax
je 0x2684f
leaq 0x3ed64(%rip), %rdi # 0x65590
leaq 0x425d6(%rip), %rsi # 0x68e09
leaq 0x3f833(%rip), %rdx # 0x6606d
movl $0x92a, %ecx # imm = 0x92A
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x26861
jmp 0x26851
movq -0x18(%rbp), %rdi
callq 0x43eb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x280, %rsp # imm = 0x280
popq %rbp
retq
nopl (%rax)
|
test_bug4030:
push rbp
mov rbp, rsp
sub rsp, 280h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov [rbp+var_18], rax
lea rax, aSelect23595912; "SELECT '23:59:59.123456', '2003-12-31',"...
mov [rbp+var_268], rax
mov rax, [rbp+var_18]
mov [rbp+var_280], rax
mov rax, [rbp+var_268]
mov [rbp+var_278], rax
mov rdi, [rbp+var_268]
call _strlen
mov rdi, [rbp+var_280]
mov rsi, [rbp+var_278]
mov rdx, rax
call mysql_stmt_prepare
mov [rbp+var_26C], eax
cmp [rbp+var_26C], 0
jz short loc_26566
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 901h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_26861
loc_26566:
jmp short $+2
loc_26568:
mov rdi, [rbp+var_18]
call mysql_stmt_execute
mov [rbp+var_26C], eax
cmp [rbp+var_26C], 0
jz short loc_265B2
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 903h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_26861
loc_265B2:
jmp short $+2
loc_265B4:
lea rdi, [rbp+var_170]
xor esi, esi
mov edx, 150h
call _memset
lea rdi, [rbp+var_198]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_1C0]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_1E8]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_210]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_238]
xor esi, esi
mov edx, 28h ; '('
call _memset
lea rdi, [rbp+var_260]
xor esi, esi
mov edx, 28h ; '('
call _memset
mov [rbp+var_110], 0Bh
lea rax, [rbp+var_1C0]
mov [rbp+var_160], rax
mov [rbp+var_A0], 0Ah
lea rax, [rbp+var_210]
mov [rbp+var_F0], rax
mov [rbp+var_30], 0Ch
lea rax, [rbp+var_260]
mov [rbp+var_80], rax
mov [rbp+var_18C], 17h
mov [rbp+var_188], 3Bh ; ';'
mov [rbp+var_184], 3Bh ; ';'
mov [rbp+var_180], offset loc_1E240
mov [rbp+var_174], 2
mov [rbp+var_1E8], 7D3h
mov [rbp+var_1E4], 0Ch
mov [rbp+var_1E0], 1Fh
mov [rbp+var_1C4], 0
lea rdi, [rbp+var_238]
lea rsi, [rbp+var_198]
mov edx, 28h ; '('
call _memcpy
mov [rbp+var_238], 7D3h
mov [rbp+var_234], 0Ch
mov [rbp+var_230], 1Fh
mov [rbp+var_214], 1
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_170]
call mysql_stmt_bind_result
mov rdi, [rbp+var_18]
call mysql_stmt_fetch
mov [rbp+var_26C], eax
cmp [rbp+var_26C], 0
jz short loc_2676B
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aRc0_0; "rc != 0"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 927h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_26861
loc_2676B:
jmp short $+2
loc_2676D:
jmp short $+2
loc_2676F:
lea rdi, [rbp+var_198]
lea rsi, [rbp+var_1C0]
mov edx, 28h ; '('
call _memcmp
cmp eax, 0
jz short loc_267B9
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aTimeCanonicalT; "time_canonical != time_out"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 928h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_26861
loc_267B9:
jmp short $+2
loc_267BB:
jmp short $+2
loc_267BD:
lea rdi, [rbp+var_1E8]
lea rsi, [rbp+var_210]
mov edx, 28h ; '('
call _memcmp
cmp eax, 0
jz short loc_26804
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aDateCanoncical; "date_canoncical != date_out"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 929h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_26861
loc_26804:
jmp short $+2
loc_26806:
jmp short $+2
loc_26808:
lea rdi, [rbp+var_238]
lea rsi, [rbp+var_260]
mov edx, 28h ; '('
call _memcmp
cmp eax, 0
jz short loc_2684F
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aDatetimeCanoni; "datetime_canonical != datetime_out"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 92Ah
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_26861
loc_2684F:
jmp short $+2
loc_26851:
mov rdi, [rbp+var_18]
call mysql_stmt_close
mov [rbp+var_4], 0
loc_26861:
mov eax, [rbp+var_4]
add rsp, 280h
pop rbp
retn
|
long long test_bug4030(long long a1)
{
long long v1; // rax
int v2; // eax
int v3; // r8d
int v4; // r9d
int v5; // eax
int v6; // r8d
int v7; // r9d
int v8; // r8d
int v9; // r9d
int v10; // r8d
int v11; // r9d
int v12; // r8d
int v13; // r9d
int v14; // r8d
int v15; // r9d
_BYTE v17[40]; // [rsp+20h] [rbp-260h] BYREF
_DWORD v18[10]; // [rsp+48h] [rbp-238h] BYREF
_BYTE v19[40]; // [rsp+70h] [rbp-210h] BYREF
_DWORD v20[10]; // [rsp+98h] [rbp-1E8h] BYREF
_BYTE v21[40]; // [rsp+C0h] [rbp-1C0h] BYREF
_BYTE v22[12]; // [rsp+E8h] [rbp-198h] BYREF
int v23; // [rsp+F4h] [rbp-18Ch]
int v24; // [rsp+F8h] [rbp-188h]
int v25; // [rsp+FCh] [rbp-184h]
void *v26; // [rsp+100h] [rbp-180h]
int v27; // [rsp+10Ch] [rbp-174h]
_BYTE v28[16]; // [rsp+110h] [rbp-170h] BYREF
_BYTE *v29; // [rsp+120h] [rbp-160h]
int v30; // [rsp+170h] [rbp-110h]
_BYTE *v31; // [rsp+190h] [rbp-F0h]
int v32; // [rsp+1E0h] [rbp-A0h]
_BYTE *v33; // [rsp+200h] [rbp-80h]
int v34; // [rsp+250h] [rbp-30h]
long long v35; // [rsp+268h] [rbp-18h]
long long v36; // [rsp+270h] [rbp-10h]
v36 = a1;
v35 = mysql_stmt_init(a1);
v1 = strlen("SELECT '23:59:59.123456', '2003-12-31', '2003-12-31 23:59:59.123456'");
if ( (unsigned int)mysql_stmt_prepare(v35, "SELECT '23:59:59.123456', '2003-12-31', '2003-12-31 23:59:59.123456'", v1) )
{
v2 = mysql_stmt_error(v35);
diag(
(unsigned int)"Error: %s (%s: %d)",
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2305,
v3,
v4);
return 1;
}
else if ( (unsigned int)mysql_stmt_execute(v35) )
{
v5 = mysql_stmt_error(v35);
diag(
(unsigned int)"Error: %s (%s: %d)",
v5,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2307,
v6,
v7);
return 1;
}
else
{
memset(v28, 0LL, 336LL);
memset(v22, 0LL, 40LL);
memset(v21, 0LL, sizeof(v21));
memset(v20, 0LL, sizeof(v20));
memset(v19, 0LL, sizeof(v19));
memset(v18, 0LL, sizeof(v18));
memset(v17, 0LL, sizeof(v17));
v30 = 11;
v29 = v21;
v32 = 10;
v31 = v19;
v34 = 12;
v33 = v17;
v23 = 23;
v24 = 59;
v25 = 59;
v26 = &loc_1E240;
v27 = 2;
v20[0] = 2003;
v20[1] = 12;
v20[2] = 31;
v20[9] = 0;
memcpy(v18, v22, sizeof(v18));
v18[0] = 2003;
v18[1] = 12;
v18[2] = 31;
v18[9] = 1;
mysql_stmt_bind_result(v35, v28);
if ( (unsigned int)mysql_stmt_fetch(v35) )
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"rc != 0",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2343,
v8,
v9);
return 1;
}
else if ( !(unsigned int)memcmp(v22, v21, 40LL) )
{
if ( !(unsigned int)memcmp(v20, v19, 40LL) )
{
if ( !(unsigned int)memcmp(v18, v17, 40LL) )
{
mysql_stmt_close(v35);
return 0;
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"datetime_canonical != datetime_out",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2346,
v14,
v15);
return 1;
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"date_canoncical != date_out",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2345,
v12,
v13);
return 1;
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"time_canonical != time_out",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
2344,
v10,
v11);
return 1;
}
}
}
|
test_bug4030:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x280
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x168d8d]
MOV qword ptr [RBP + -0x268],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x280],RAX
MOV RAX,qword ptr [RBP + -0x268]
MOV qword ptr [RBP + -0x278],RAX
MOV RDI,qword ptr [RBP + -0x268]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x280]
MOV RSI,qword ptr [RBP + -0x278]
MOV RDX,RAX
CALL 0x00145070
MOV dword ptr [RBP + -0x26c],EAX
CMP dword ptr [RBP + -0x26c],0x0
JZ 0x00126566
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x901
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_00126566:
JMP 0x00126568
LAB_00126568:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00146580
MOV dword ptr [RBP + -0x26c],EAX
CMP dword ptr [RBP + -0x26c],0x0
JZ 0x001265b2
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x903
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_001265b2:
JMP 0x001265b4
LAB_001265b4:
LEA RDI,[RBP + -0x170]
XOR ESI,ESI
MOV EDX,0x150
CALL 0x00114260
LEA RDI,[RBP + -0x198]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x1c0]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x1e8]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x210]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x238]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
LEA RDI,[RBP + -0x260]
XOR ESI,ESI
MOV EDX,0x28
CALL 0x00114260
MOV dword ptr [RBP + -0x110],0xb
LEA RAX,[RBP + -0x1c0]
MOV qword ptr [RBP + -0x160],RAX
MOV dword ptr [RBP + -0xa0],0xa
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0xf0],RAX
MOV dword ptr [RBP + -0x30],0xc
LEA RAX,[RBP + -0x260]
MOV qword ptr [RBP + -0x80],RAX
MOV dword ptr [RBP + -0x18c],0x17
MOV dword ptr [RBP + -0x188],0x3b
MOV dword ptr [RBP + -0x184],0x3b
MOV qword ptr [RBP + -0x180],0x1e240
MOV dword ptr [RBP + -0x174],0x2
MOV dword ptr [RBP + -0x1e8],0x7d3
MOV dword ptr [RBP + -0x1e4],0xc
MOV dword ptr [RBP + -0x1e0],0x1f
MOV dword ptr [RBP + -0x1c4],0x0
LEA RDI,[RBP + -0x238]
LEA RSI,[RBP + -0x198]
MOV EDX,0x28
CALL 0x00114370
MOV dword ptr [RBP + -0x238],0x7d3
MOV dword ptr [RBP + -0x234],0xc
MOV dword ptr [RBP + -0x230],0x1f
MOV dword ptr [RBP + -0x214],0x1
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0x170]
CALL 0x00143940
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00144020
MOV dword ptr [RBP + -0x26c],EAX
CMP dword ptr [RBP + -0x26c],0x0
JZ 0x0012676b
LEA RDI,[0x165590]
LEA RSI,[0x168d69]
LEA RDX,[0x16606d]
MOV ECX,0x927
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_0012676b:
JMP 0x0012676d
LAB_0012676d:
JMP 0x0012676f
LAB_0012676f:
LEA RDI,[RBP + -0x198]
LEA RSI,[RBP + -0x1c0]
MOV EDX,0x28
CALL 0x001141b0
CMP EAX,0x0
JZ 0x001267b9
LEA RDI,[0x165590]
LEA RSI,[0x168dd2]
LEA RDX,[0x16606d]
MOV ECX,0x928
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_001267b9:
JMP 0x001267bb
LAB_001267bb:
JMP 0x001267bd
LAB_001267bd:
LEA RDI,[RBP + -0x1e8]
LEA RSI,[RBP + -0x210]
MOV EDX,0x28
CALL 0x001141b0
CMP EAX,0x0
JZ 0x00126804
LEA RDI,[0x165590]
LEA RSI,[0x168ded]
LEA RDX,[0x16606d]
MOV ECX,0x929
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_00126804:
JMP 0x00126806
LAB_00126806:
JMP 0x00126808
LAB_00126808:
LEA RDI,[RBP + -0x238]
LEA RSI,[RBP + -0x260]
MOV EDX,0x28
CALL 0x001141b0
CMP EAX,0x0
JZ 0x0012684f
LEA RDI,[0x165590]
LEA RSI,[0x168e09]
LEA RDX,[0x16606d]
MOV ECX,0x92a
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00126861
LAB_0012684f:
JMP 0x00126851
LAB_00126851:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143eb0
MOV dword ptr [RBP + -0x4],0x0
LAB_00126861:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x280
POP RBP
RET
|
int4 test_bug4030(int8 param_1)
{
int iVar1;
int8 uVar2;
size_t sVar3;
int1 local_268 [40];
int4 local_240;
int4 local_23c;
int4 local_238;
int4 local_21c;
int1 local_218 [40];
int4 local_1f0;
int4 local_1ec;
int4 local_1e8;
int4 local_1cc;
int1 local_1c8 [40];
int1 local_1a0 [12];
int4 local_194;
int4 local_190;
int4 local_18c;
int8 local_188;
int4 local_17c;
int1 local_178 [16];
int1 *local_168;
int4 local_118;
int1 *local_f8;
int4 local_a8;
int1 *local_88;
int4 local_38;
int8 local_20;
int8 local_18;
int4 local_c;
local_18 = param_1;
uVar2 = mysql_stmt_init(param_1);
local_20 = uVar2;
sVar3 = strlen("SELECT \'23:59:59.123456\', \'2003-12-31\', \'2003-12-31 23:59:59.123456\'");
iVar1 = mysql_stmt_prepare(uVar2,
"SELECT \'23:59:59.123456\', \'2003-12-31\', \'2003-12-31 23:59:59.123456\'"
,sVar3);
if (iVar1 == 0) {
iVar1 = mysql_stmt_execute(local_20);
if (iVar1 == 0) {
memset(local_178,0,0x150);
memset(local_1a0,0,0x28);
memset(local_1c8,0,0x28);
memset(&local_1f0,0,0x28);
memset(local_218,0,0x28);
memset(&local_240,0,0x28);
memset(local_268,0,0x28);
local_118 = 0xb;
local_168 = local_1c8;
local_a8 = 10;
local_f8 = local_218;
local_38 = 0xc;
local_88 = local_268;
local_194 = 0x17;
local_190 = 0x3b;
local_18c = 0x3b;
local_188 = 0x1e240;
local_17c = 2;
local_1f0 = 0x7d3;
local_1ec = 0xc;
local_1e8 = 0x1f;
local_1cc = 0;
memcpy(&local_240,local_1a0,0x28);
local_240 = 0x7d3;
local_23c = 0xc;
local_238 = 0x1f;
local_21c = 1;
mysql_stmt_bind_result(local_20,local_178);
iVar1 = mysql_stmt_fetch(local_20);
if (iVar1 == 0) {
iVar1 = memcmp(local_1a0,local_1c8,0x28);
if (iVar1 == 0) {
iVar1 = memcmp(&local_1f0,local_218,0x28);
if (iVar1 == 0) {
iVar1 = memcmp(&local_240,local_268,0x28);
if (iVar1 == 0) {
mysql_stmt_close(local_20);
local_c = 0;
}
else {
diag("Error: %s (%s: %d)","datetime_canonical != datetime_out",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x92a);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","date_canoncical != date_out",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x929);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","time_canonical != time_out",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x928);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","rc != 0",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x927);
local_c = 1;
}
}
else {
uVar2 = mysql_stmt_error(local_20);
diag("Error: %s (%s: %d)",uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x903
);
local_c = 1;
}
}
else {
uVar2 = mysql_stmt_error(local_20);
diag("Error: %s (%s: %d)",uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x901);
local_c = 1;
}
return local_c;
}
|
|
57,619
|
ExportWave
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raudio.c
|
bool ExportWave(Wave wave, const char *fileName)
{
bool success = false;
if (false) { }
#if defined(SUPPORT_FILEFORMAT_WAV)
else if (IsFileExtension(fileName, ".wav"))
{
drwav wav = { 0 };
drwav_data_format format = { 0 };
format.container = drwav_container_riff;
if (wave.sampleSize == 32) format.format = DR_WAVE_FORMAT_IEEE_FLOAT;
else format.format = DR_WAVE_FORMAT_PCM;
format.channels = wave.channels;
format.sampleRate = wave.sampleRate;
format.bitsPerSample = wave.sampleSize;
void *fileData = NULL;
size_t fileDataSize = 0;
success = drwav_init_memory_write(&wav, &fileData, &fileDataSize, &format, NULL);
if (success) success = (int)drwav_write_pcm_frames(&wav, wave.frameCount, wave.data);
drwav_result result = drwav_uninit(&wav);
if (result == DRWAV_SUCCESS) success = SaveFileData(fileName, (unsigned char *)fileData, (unsigned int)fileDataSize);
drwav_free(fileData, NULL);
}
#endif
#if defined(SUPPORT_FILEFORMAT_QOA)
else if (IsFileExtension(fileName, ".qoa"))
{
if (wave.sampleSize == 16)
{
qoa_desc qoa = { 0 };
qoa.channels = wave.channels;
qoa.samplerate = wave.sampleRate;
qoa.samples = wave.frameCount;
int bytesWritten = qoa_write(fileName, wave.data, &qoa);
if (bytesWritten > 0) success = true;
}
else TRACELOG(LOG_WARNING, "AUDIO: Wave data must be 16 bit per sample for QOA format export");
}
#endif
else if (IsFileExtension(fileName, ".raw"))
{
// Export raw sample data (without header)
// NOTE: It's up to the user to track wave parameters
success = SaveFileData(fileName, wave.data, wave.frameCount*wave.channels*wave.sampleSize/8);
}
if (success) TRACELOG(LOG_INFO, "FILEIO: [%s] Wave data exported successfully", fileName);
else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to export wave data", fileName);
return success;
}
|
O3
|
c
|
ExportWave:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdi, %rbx
leaq 0x1f0(%rsp), %r15
leaq 0x92926(%rip), %rsi # 0xd5e8c
callq 0x75b52
testb %al, %al
je 0x43623
leaq 0x30(%rsp), %r14
xorl %r12d, %r12d
movl $0x190, %edx # imm = 0x190
movq %r14, %rdi
xorl %esi, %esi
callq 0xa2d0
leaq 0x1c(%rsp), %rcx
movl $0x0, (%rcx)
movl 0x8(%r15), %eax
xorl %edx, %edx
cmpl $0x20, %eax
sete %dl
leal 0x1(%rdx,%rdx), %edx
movl %edx, 0x4(%rcx)
movl 0xc(%r15), %edx
movl %edx, 0x8(%rcx)
movl 0x4(%r15), %edx
movl %edx, 0xc(%rcx)
movl %eax, 0x10(%rcx)
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
leaq 0x10(%rsp), %rdx
movq %r12, (%rdx)
movq %r12, (%rsp)
movq %r14, %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2ee66
testl %eax, %eax
je 0x435f6
movl (%r15), %esi
movq 0x10(%r15), %rdx
leaq 0x30(%rsp), %rdi
callq 0x3027a
testl %eax, %eax
setne %r12b
leaq 0x30(%rsp), %rdi
callq 0x2ef48
movq 0x8(%rsp), %rsi
testl %eax, %eax
je 0x436bc
movq %rsi, %rdi
callq 0xa650
testb %r12b, %r12b
jne 0x436d9
jmp 0x43707
leaq 0x928da(%rip), %rsi # 0xd5f04
movq %rbx, %rdi
callq 0x75b52
testb %al, %al
je 0x43687
cmpl $0x10, 0x8(%r15)
jne 0x436f4
leaq 0x3c(%rsp), %r14
movl $0x100, %edx # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0xa2d0
movl 0xc(%r15), %eax
movl %eax, -0xc(%r14)
movq (%r15), %xmm0
pshufd $0xe1, %xmm0, %xmm0 # xmm0 = xmm0[1,0,2,3]
movq %xmm0, -0x8(%r14)
movq 0x10(%r15), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x3d8bb
testl %eax, %eax
jg 0x436d9
jmp 0x43707
leaq 0x929b1(%rip), %rsi # 0xd603f
movq %rbx, %rdi
callq 0x75b52
testb %al, %al
je 0x43707
movl 0xc(%r15), %edx
imull (%r15), %edx
movq 0x10(%r15), %rsi
imull 0x8(%r15), %edx
shrl $0x3, %edx
movq %rbx, %rdi
callq 0xba11d
testb %al, %al
jne 0x436d9
jmp 0x43707
movl 0x10(%rsp), %edx
movq %rbx, %rdi
callq 0xba11d
movl %eax, %ebp
movq 0x8(%rsp), %rdi
callq 0xa650
testb %bpl, %bpl
je 0x43707
leaq 0x92964(%rip), %rsi # 0xd6044
movl $0x3, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb9db7
movb $0x1, %bpl
jmp 0x4371f
leaq 0x92903(%rip), %rsi # 0xd5ffe
movl $0x4, %edi
xorl %eax, %eax
callq 0xb9db7
leaq 0x92963(%rip), %rsi # 0xd6071
xorl %ebp, %ebp
movl $0x4, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb9db7
movl %ebp, %eax
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
ExportWave:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 1C0h
mov rbx, rdi
lea r15, [rsp+1E8h+arg_0]
lea rsi, aWav; ".wav"
call IsFileExtension
test al, al
jz loc_43623
lea r14, [rsp+1E8h+var_1B8]
xor r12d, r12d
mov edx, 190h
mov rdi, r14
xor esi, esi
call _memset
lea rcx, [rsp+1E8h+var_1CC]
mov dword ptr [rcx], 0
mov eax, [r15+8]
xor edx, edx
cmp eax, 20h ; ' '
setz dl
lea edx, [rdx+rdx+1]
mov [rcx+4], edx
mov edx, [r15+0Ch]
mov [rcx+8], edx
mov edx, [r15+4]
mov [rcx+0Ch], edx
mov [rcx+10h], eax
lea rsi, [rsp+1E8h+var_1E0]
mov [rsi], r12
lea rdx, [rsp+1E8h+var_1D8]
mov [rdx], r12
mov [rsp+1E8h+var_1E8], r12
mov rdi, r14
xor r8d, r8d
xor r9d, r9d
call drwav_init_memory_write__internal
test eax, eax
jz short loc_435F6
mov esi, [r15]
mov rdx, [r15+10h]
lea rdi, [rsp+1E8h+var_1B8]
call drwav_write_pcm_frames_le
test eax, eax
setnz r12b
loc_435F6:
lea rdi, [rsp+1E8h+var_1B8]
call drwav_uninit
mov rsi, [rsp+1E8h+var_1E0]
test eax, eax
jz loc_436BC
mov rdi, rsi
call _free
test r12b, r12b
jnz loc_436D9
jmp loc_43707
loc_43623:
lea rsi, aQoa; ".qoa"
mov rdi, rbx
call IsFileExtension
test al, al
jz short loc_43687
cmp dword ptr [r15+8], 10h
jnz loc_436F4
lea r14, [rsp+1E8h+var_1AC]
mov edx, 100h
mov rdi, r14
xor esi, esi
call _memset
mov eax, [r15+0Ch]
mov [r14-0Ch], eax
movq xmm0, qword ptr [r15]
pshufd xmm0, xmm0, 0E1h
movq qword ptr [r14-8], xmm0
mov rsi, [r15+10h]
lea rdx, [rsp+1E8h+var_1B8]
mov rdi, rbx
call qoa_write
test eax, eax
jg short loc_436D9
jmp loc_43707
loc_43687:
lea rsi, aRaw; ".raw"
mov rdi, rbx
call IsFileExtension
test al, al
jz short loc_43707
mov edx, [r15+0Ch]
imul edx, [r15]
mov rsi, [r15+10h]
imul edx, [r15+8]
shr edx, 3
mov rdi, rbx
call SaveFileData
test al, al
jnz short loc_436D9
jmp short loc_43707
loc_436BC:
mov edx, [rsp+1E8h+var_1D8]
mov rdi, rbx
call SaveFileData
mov ebp, eax
mov rdi, [rsp+1E8h+var_1E0]
call _free
test bpl, bpl
jz short loc_43707
loc_436D9:
lea rsi, aFileioSWaveDat; "FILEIO: [%s] Wave data exported success"...
mov edi, 3
mov rdx, rbx
xor eax, eax
call TraceLog
mov bpl, 1
jmp short loc_4371F
loc_436F4:
lea rsi, aAudioWaveDataM; "AUDIO: Wave data must be 16 bit per sam"...
mov edi, 4
xor eax, eax
call TraceLog
loc_43707:
lea rsi, aFileioSFailedT; "FILEIO: [%s] Failed to export wave data"
xor ebp, ebp
mov edi, 4
mov rdx, rbx
xor eax, eax
call TraceLog
loc_4371F:
mov eax, ebp
add rsp, 1C0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
long long ExportWave(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
const __m128i a7,
long long a8)
{
unsigned int v8; // ebp
bool v9; // r12
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
long long v18; // [rsp+8h] [rbp-1E0h] BYREF
long long v19; // [rsp+10h] [rbp-1D8h] BYREF
int v20[5]; // [rsp+1Ch] [rbp-1CCh] BYREF
unsigned int v21; // [rsp+30h] [rbp-1B8h] BYREF
unsigned long long v22; // [rsp+34h] [rbp-1B4h]
_BYTE v23[428]; // [rsp+3Ch] [rbp-1ACh] BYREF
if ( !(unsigned __int8)IsFileExtension(a1, ".wav") )
{
if ( !(unsigned __int8)IsFileExtension(a1, ".qoa") )
{
if ( !(unsigned __int8)IsFileExtension(a1, ".raw")
|| !(unsigned __int8)SaveFileData(
a1,
a8,
(unsigned int)(a7.m128i_i32[2] * a7.m128i_i32[0] * a7.m128i_i32[3]) >> 3) )
{
goto LABEL_17;
}
goto LABEL_15;
}
if ( a7.m128i_i32[2] == 16 )
{
memset(v23, 0LL, 256LL);
v21 = a7.m128i_u32[3];
v22 = _mm_shuffle_epi32(_mm_loadl_epi64(&a7), 225).m128i_u64[0];
if ( (int)qoa_write(a1, a8, &v21) <= 0 )
goto LABEL_17;
goto LABEL_15;
}
TraceLog(4, (unsigned int)"AUDIO: Wave data must be 16 bit per sample for QOA format export", v13, v14, v15, v16);
LABEL_17:
v8 = 0;
TraceLog(4, (unsigned int)"FILEIO: [%s] Failed to export wave data", a1, v10, v11, v12);
return v8;
}
v9 = 0;
memset(&v21, 0LL, 400LL);
v20[0] = 0;
v20[1] = 2 * (a7.m128i_i32[2] == 32) + 1;
v20[2] = a7.m128i_i32[3];
v20[3] = a7.m128i_i32[1];
v20[4] = a7.m128i_i32[2];
v18 = 0LL;
v19 = 0LL;
if ( (unsigned int)drwav_init_memory_write__internal((long long)&v21, &v18, &v19, v20, 0LL, 0, 0LL) )
v9 = (unsigned int)drwav_write_pcm_frames_le((long long)&v21, a7.m128i_u32[0], a8) != 0;
if ( !(unsigned int)drwav_uninit((long long)&v21) )
{
v8 = SaveFileData(a1, v18, (unsigned int)v19);
free(v18);
if ( (_BYTE)v8 )
goto LABEL_15;
goto LABEL_17;
}
free(v18);
if ( !v9 )
goto LABEL_17;
LABEL_15:
TraceLog(3, (unsigned int)"FILEIO: [%s] Wave data exported successfully", a1, v10, v11, v12);
LOBYTE(v8) = 1;
return v8;
}
|
ExportWave:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1c0
MOV RBX,RDI
LEA R15,[RSP + 0x1f0]
LEA RSI,[0x1d5e8c]
CALL 0x00175b52
TEST AL,AL
JZ 0x00143623
LEA R14,[RSP + 0x30]
XOR R12D,R12D
MOV EDX,0x190
MOV RDI,R14
XOR ESI,ESI
CALL 0x0010a2d0
LEA RCX,[RSP + 0x1c]
MOV dword ptr [RCX],0x0
MOV EAX,dword ptr [R15 + 0x8]
XOR EDX,EDX
CMP EAX,0x20
SETZ DL
LEA EDX,[RDX + RDX*0x1 + 0x1]
MOV dword ptr [RCX + 0x4],EDX
MOV EDX,dword ptr [R15 + 0xc]
MOV dword ptr [RCX + 0x8],EDX
MOV EDX,dword ptr [R15 + 0x4]
MOV dword ptr [RCX + 0xc],EDX
MOV dword ptr [RCX + 0x10],EAX
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],R12
LEA RDX,[RSP + 0x10]
MOV qword ptr [RDX],R12
MOV qword ptr [RSP],R12
MOV RDI,R14
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0012ee66
TEST EAX,EAX
JZ 0x001435f6
MOV ESI,dword ptr [R15]
MOV RDX,qword ptr [R15 + 0x10]
LEA RDI,[RSP + 0x30]
CALL 0x0013027a
TEST EAX,EAX
SETNZ R12B
LAB_001435f6:
LEA RDI,[RSP + 0x30]
CALL 0x0012ef48
MOV RSI,qword ptr [RSP + 0x8]
TEST EAX,EAX
JZ 0x001436bc
MOV RDI,RSI
CALL 0x0010a650
TEST R12B,R12B
JNZ 0x001436d9
JMP 0x00143707
LAB_00143623:
LEA RSI,[0x1d5f04]
MOV RDI,RBX
CALL 0x00175b52
TEST AL,AL
JZ 0x00143687
CMP dword ptr [R15 + 0x8],0x10
JNZ 0x001436f4
LEA R14,[RSP + 0x3c]
MOV EDX,0x100
MOV RDI,R14
XOR ESI,ESI
CALL 0x0010a2d0
MOV EAX,dword ptr [R15 + 0xc]
MOV dword ptr [R14 + -0xc],EAX
MOVQ XMM0,qword ptr [R15]
PSHUFD XMM0,XMM0,0xe1
MOVQ qword ptr [R14 + -0x8],XMM0
MOV RSI,qword ptr [R15 + 0x10]
LEA RDX,[RSP + 0x30]
MOV RDI,RBX
CALL 0x0013d8bb
TEST EAX,EAX
JG 0x001436d9
JMP 0x00143707
LAB_00143687:
LEA RSI,[0x1d603f]
MOV RDI,RBX
CALL 0x00175b52
TEST AL,AL
JZ 0x00143707
MOV EDX,dword ptr [R15 + 0xc]
IMUL EDX,dword ptr [R15]
MOV RSI,qword ptr [R15 + 0x10]
IMUL EDX,dword ptr [R15 + 0x8]
SHR EDX,0x3
MOV RDI,RBX
CALL 0x001ba11d
TEST AL,AL
JNZ 0x001436d9
JMP 0x00143707
LAB_001436bc:
MOV EDX,dword ptr [RSP + 0x10]
MOV RDI,RBX
CALL 0x001ba11d
MOV EBP,EAX
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010a650
TEST BPL,BPL
JZ 0x00143707
LAB_001436d9:
LEA RSI,[0x1d6044]
MOV EDI,0x3
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001b9db7
MOV BPL,0x1
JMP 0x0014371f
LAB_001436f4:
LEA RSI,[0x1d5ffe]
MOV EDI,0x4
XOR EAX,EAX
CALL 0x001b9db7
LAB_00143707:
LEA RSI,[0x1d6071]
XOR EBP,EBP
MOV EDI,0x4
MOV RDX,RBX
XOR EAX,EAX
CALL 0x001b9db7
LAB_0014371f:
MOV EAX,EBP
ADD RSP,0x1c0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
ulong ExportWave(int8 param_1)
{
char cVar1;
int iVar2;
uint uVar3;
ulong unaff_RBP;
ulong uVar4;
bool bVar5;
int iStack0000000000000008;
int4 uStack000000000000000c;
int iStack0000000000000010;
int iStack0000000000000014;
int8 in_stack_00000018;
int1 local_1b8 [4];
int8 local_1b4;
int1 local_1ac [388];
cVar1 = IsFileExtension();
if (cVar1 == '\0') {
cVar1 = IsFileExtension(param_1);
if (cVar1 == '\0') {
cVar1 = IsFileExtension(param_1,&DAT_001d603f);
if (cVar1 != '\0') {
cVar1 = SaveFileData(param_1,in_stack_00000018,
(uint)(iStack0000000000000014 * iStack0000000000000008 *
iStack0000000000000010) >> 3);
goto joined_r0x001436b8;
}
}
else if (iStack0000000000000010 == 0x10) {
memset(local_1ac,0,0x100);
local_1b4 = CONCAT44(iStack0000000000000008,uStack000000000000000c);
iVar2 = qoa_write(param_1,in_stack_00000018,local_1b8);
if (0 < iVar2) goto LAB_001436d9;
}
else {
TraceLog(4,"AUDIO: Wave data must be 16 bit per sample for QOA format export");
}
}
else {
bVar5 = false;
memset(local_1b8,0,400);
iVar2 = drwav_init_memory_write__internal(local_1b8);
if (iVar2 != 0) {
iVar2 = drwav_write_pcm_frames_le(local_1b8,iStack0000000000000008,in_stack_00000018);
bVar5 = iVar2 != 0;
}
iVar2 = drwav_uninit(local_1b8);
if (iVar2 == 0) {
uVar3 = SaveFileData(param_1,0,0);
unaff_RBP = (ulong)uVar3;
free((void *)0x0);
cVar1 = (char)uVar3;
joined_r0x001436b8:
if (cVar1 != '\0') goto LAB_001436d9;
}
else {
free((void *)0x0);
if (bVar5) {
LAB_001436d9:
TraceLog(3,"FILEIO: [%s] Wave data exported successfully",param_1);
uVar4 = CONCAT71((int7)(unaff_RBP >> 8),1);
goto LAB_0014371f;
}
}
}
uVar4 = 0;
TraceLog(4,"FILEIO: [%s] Failed to export wave data",param_1);
LAB_0014371f:
return uVar4 & 0xffffffff;
}
|
|
57,620
|
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& 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>::at<char const (&) [12], 0>(char const (&) [12]) const
|
llama.cpp/common/json.hpp
|
const_reference at(KeyType && key) const
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return it->second;
}
|
O3
|
cpp
|
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& 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>::at<char const (&) [12], 0>(char const (&) [12]) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xb1113
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xb10fd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20f60
testl %eax, %eax
je 0xb10f2
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xb10d3
jmp 0xb10f5
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xb1171
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20650
movq %rax, %rbx
movq %r14, %rdi
callq 0x8a292
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x6a493(%rip), %rsi # 0x11b5c8
leaq 0x20(%rsp), %rdi
callq 0x7f80f
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0xbbb9c
xorl %ebp, %ebp
leaq 0xafee0(%rip), %rsi # 0x161040
leaq -0x3b005(%rip), %rdx # 0x76162
movq %rbx, %rdi
callq 0x20a60
jmp 0xb11ea
movl $0x20, %edi
callq 0x20650
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x20680
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x287ce
leaq 0x6a438(%rip), %rsi # 0x11b5de
leaq 0x6a437(%rip), %rcx # 0x11b5e4
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x7f897
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0xd0c14
xorl %ebp, %ebp
leaq 0xafde5(%rip), %rsi # 0x160fc0
leaq -0x3b080(%rip), %rdx # 0x76162
movq %rbx, %rdi
callq 0x20a60
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1208
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20180
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb1253
movq 0x10(%rsp), %rsi
jmp 0xb124b
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xb125d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x20180
jmp 0xb125d
jmp 0xb125a
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1253
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xb125d
jmp 0xb1265
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f00
movq %r14, %rdi
callq 0x20b00
nop
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
push rbp; void *
push r15; int
push r14; __int64
push r12; int
push rbx; void *
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_B1113
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_B10FD
loc_B10D3:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_B10F2
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_B10D3
jmp short loc_B10F5
loc_B10F2:
mov rax, rbx
loc_B10F5:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_B10FD:
cmp rax, rbx
jz short loc_B1171
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B1113:
mov edi, 20h ; ' '; 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)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; 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
jmp short loc_B11EA
loc_B1171:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_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_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_B11EA:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1208
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1208:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_B1253
mov rsi, [rsp+68h+var_58]
jmp short loc_B124B
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_B125D
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_B125D
jmp short loc_B125A
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1253
mov rsi, [rsp+68h+var_38]
loc_B124B:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1253:
test bpl, bpl
jnz short loc_B125D
jmp short loc_B1265
loc_B125A:
mov r14, rax
loc_B125D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B1265:
mov rdi, r14
call __Unwind_Resume
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001b1113
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001b10fd
LAB_001b10d3:
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120f60
TEST EAX,EAX
JZ 0x001b10f2
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001b10d3
JMP 0x001b10f5
LAB_001b10f2:
MOV RAX,RBX
LAB_001b10f5:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001b10fd:
CMP RAX,RBX
JZ 0x001b1171
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b1113:
MOV EDI,0x20
CALL 0x00120650
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018a292
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001b112e:
LEA RSI,[0x21b5c8]
LEA RDI,[RSP + 0x20]
CALL 0x0017f80f
MOV BPL,0x1
LAB_001b1142:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x001bbb9c
XOR EBP,EBP
LEA RSI,[0x261040]
LEA RDX,[0x176162]
MOV RDI,RBX
CALL 0x00120a60
LAB_001b1171:
MOV EDI,0x20
CALL 0x00120650
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x00120680
LEA RDX,[RAX + R15*0x1]
LAB_001b1194:
MOV RDI,RSP
MOV RSI,R15
CALL 0x001287ce
LAB_001b119f:
LEA RSI,[0x21b5de]
LEA RCX,[0x21b5e4]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x0017f897
MOV BPL,0x1
LAB_001b11bd:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x001d0c14
XOR EBP,EBP
LEA RSI,[0x260fc0]
LEA RDX,[0x176162]
MOV RDI,RBX
CALL 0x00120a60
|
char * _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA12_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(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)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*param_1 !=
(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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (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 001b112e to 001b113e has its CatchHandler @ 001b125a */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001b1142 to 001b116e has its CatchHandler @ 001b1235 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001b1194 to 001b119e has its CatchHandler @ 001b1233 */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001b119f to 001b11b9 has its CatchHandler @ 001b1218 */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001b11bd to 001b11e9 has its CatchHandler @ 001b11ea */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
|
||
57,621
|
test_conc512
|
eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c
|
static int test_conc512(MYSQL *mysql)
{
int rc;
MYSQL_STMT *stmt;
MYSQL_BIND bind;
float f;
rc= mysql_query(mysql, "drop table if exists t1");
rc= mysql_real_query(mysql, SL("CREATE TABLE t1 (a int)"));
rc= mysql_real_query(mysql, SL("INSERT INTO t1 VALUES (1073741825)"));
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, SL("SELECT a FROM t1"));
check_stmt_rc(rc, stmt);
memset(&bind, 0, sizeof(MYSQL_BIND));
bind.buffer= &f;
bind.buffer_type= MYSQL_TYPE_FLOAT;
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_bind_result(stmt, &bind);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
FAIL_IF(rc != 101, "Truncation expected");
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE t1");
check_mysql_rc(rc, mysql);
return OK;
}
|
O0
|
c
|
test_conc512:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4f7f8(%rip), %rsi # 0x664d2
callq 0x38a70
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4f7fd(%rip), %rsi # 0x664ea
movl $0x17, %edx
callq 0x377f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x4f7fd(%rip), %rsi # 0x66502
movl $0x22, %edx
callq 0x377f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x4f7fb(%rip), %rsi # 0x66525
movl $0x10, %edx
callq 0x45070
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16d6f
movq -0x20(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x4e840(%rip), %rdi # 0x65590
leaq 0x4f316(%rip), %rdx # 0x6606d
movl $0x14ce, %ecx # imm = 0x14CE
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x16eed
jmp 0x16d71
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x70, %edx
callq 0x14260
leaq -0x94(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x4, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x46580
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16dda
movq -0x20(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x4e7d5(%rip), %rdi # 0x65590
leaq 0x4f2ab(%rip), %rdx # 0x6606d
movl $0x14d5, %ecx # imm = 0x14D5
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x16eed
jmp 0x16ddc
movq -0x20(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x43940
movsbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16e2a
movq -0x20(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x4e785(%rip), %rdi # 0x65590
leaq 0x4f25b(%rip), %rdx # 0x6606d
movl $0x14d8, %ecx # imm = 0x14D8
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x16eed
jmp 0x16e2c
movq -0x20(%rbp), %rdi
callq 0x44020
movl %eax, -0x14(%rbp)
cmpl $0x65, -0x14(%rbp)
je 0x16e6b
leaq 0x4e74b(%rip), %rdi # 0x65590
leaq 0x4f6ea(%rip), %rsi # 0x66536
leaq 0x4f21a(%rip), %rdx # 0x6606d
movl $0x14db, %ecx # imm = 0x14DB
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x16eed
jmp 0x16e6d
movq -0x20(%rbp), %rdi
callq 0x43eb0
movq -0x10(%rbp), %rdi
leaq 0x4f6c9(%rip), %rsi # 0x6654a
callq 0x38a70
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16ee4
movl -0x14(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdx
movl %eax, %ecx
leaq 0x4e80e(%rip), %rdi # 0x656d5
leaq 0x4f19f(%rip), %r8 # 0x6606d
movl $0x14e0, %r9d # imm = 0x14E0
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x16eed
jmp 0x16ee6
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
|
test_conc512:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
lea rsi, aDropTableIfExi; "drop table if exists t1"
call mysql_query
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
lea rsi, aCreateTableT1A; "CREATE TABLE t1 (a int)"
mov edx, 17h
call mysql_real_query
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
lea rsi, aInsertIntoT1Va; "INSERT INTO t1 VALUES (1073741825)"
mov edx, 22h ; '"'
call mysql_real_query
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
lea rsi, aSelectAFromT1; "SELECT a FROM t1"
mov edx, 10h
call mysql_stmt_prepare
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_16D6F
mov rdi, [rbp+var_20]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 14CEh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_16EED
loc_16D6F:
jmp short $+2
loc_16D71:
lea rdi, [rbp+var_90]
xor esi, esi
mov edx, 70h ; 'p'
call _memset
lea rax, [rbp+var_94]
mov [rbp+var_80], rax
mov [rbp+var_30], 4
mov rdi, [rbp+var_20]
call mysql_stmt_execute
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_16DDA
mov rdi, [rbp+var_20]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 14D5h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_16EED
loc_16DDA:
jmp short $+2
loc_16DDC:
mov rdi, [rbp+var_20]
lea rsi, [rbp+var_90]
call mysql_stmt_bind_result
movsx eax, al
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_16E2A
mov rdi, [rbp+var_20]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 14D8h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_16EED
loc_16E2A:
jmp short $+2
loc_16E2C:
mov rdi, [rbp+var_20]
call mysql_stmt_fetch
mov [rbp+var_14], eax
cmp [rbp+var_14], 65h ; 'e'
jz short loc_16E6B
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rsi, aTruncationExpe; "Truncation expected"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 14DBh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_16EED
loc_16E6B:
jmp short $+2
loc_16E6D:
mov rdi, [rbp+var_20]
call mysql_stmt_close
mov rdi, [rbp+var_10]
lea rsi, aDropTableT1; "DROP TABLE t1"
call mysql_query
mov [rbp+var_14], eax
cmp [rbp+var_14], 0
jz short loc_16EE4
mov eax, [rbp+var_14]
mov [rbp+var_A4], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_A0], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_A4]
mov rdx, [rbp+var_A0]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 14E0h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_16EED
loc_16EE4:
jmp short $+2
loc_16EE6:
mov [rbp+var_4], 0
loc_16EED:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
|
long long test_conc512(long long a1)
{
int v1; // eax
int v2; // r8d
int v3; // r9d
int v4; // eax
int v5; // r8d
int v6; // r9d
char v7; // al
int v8; // eax
int v9; // r8d
int v10; // r9d
int v11; // r8d
int v12; // r9d
int v13; // eax
int v15; // [rsp+Ch] [rbp-A4h]
int v16; // [rsp+10h] [rbp-A0h]
char v17; // [rsp+1Ch] [rbp-94h] BYREF
_BYTE v18[16]; // [rsp+20h] [rbp-90h] BYREF
char *v19; // [rsp+30h] [rbp-80h]
int v20; // [rsp+80h] [rbp-30h]
long long v21; // [rsp+90h] [rbp-20h]
int v22; // [rsp+9Ch] [rbp-14h]
long long v23; // [rsp+A0h] [rbp-10h]
v23 = a1;
mysql_query(a1, "drop table if exists t1");
mysql_real_query(a1, "CREATE TABLE t1 (a int)", 23LL);
mysql_real_query(a1, "INSERT INTO t1 VALUES (1073741825)", 34LL);
v21 = mysql_stmt_init(a1);
v22 = mysql_stmt_prepare(v21, "SELECT a FROM t1", 16LL);
if ( v22 )
{
v1 = mysql_stmt_error(v21);
diag(
(unsigned int)"Error: %s (%s: %d)",
v1,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
5326,
v2,
v3);
return 1;
}
else
{
memset(v18, 0LL, 112LL);
v19 = &v17;
v20 = 4;
v22 = mysql_stmt_execute(v21);
if ( v22 )
{
v4 = mysql_stmt_error(v21);
diag(
(unsigned int)"Error: %s (%s: %d)",
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
5333,
v5,
v6);
return 1;
}
else
{
v7 = mysql_stmt_bind_result(v21, v18);
v22 = v7;
if ( v7 )
{
v8 = mysql_stmt_error(v21);
diag(
(unsigned int)"Error: %s (%s: %d)",
v8,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
5336,
v9,
v10);
return 1;
}
else
{
v22 = mysql_stmt_fetch(v21);
if ( v22 == 101 )
{
mysql_stmt_close(v21);
v22 = mysql_query(v23, "DROP TABLE t1");
if ( v22 )
{
v15 = v22;
v16 = mysql_error(v23);
v13 = mysql_errno(v23);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v15,
v16,
v13,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
5344);
return 1;
}
else
{
return 0;
}
}
else
{
diag(
(unsigned int)"Error: %s (%s: %d)",
(unsigned int)"Truncation expected",
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
5339,
v11,
v12);
return 1;
}
}
}
}
}
|
test_conc512:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1664d2]
CALL 0x00138a70
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x1664ea]
MOV EDX,0x17
CALL 0x001377f0
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x166502]
MOV EDX,0x22
CALL 0x001377f0
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x166525]
MOV EDX,0x10
CALL 0x00145070
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00116d6f
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x14ce
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00116eed
LAB_00116d6f:
JMP 0x00116d71
LAB_00116d71:
LEA RDI,[RBP + -0x90]
XOR ESI,ESI
MOV EDX,0x70
CALL 0x00114260
LEA RAX,[RBP + -0x94]
MOV qword ptr [RBP + -0x80],RAX
MOV dword ptr [RBP + -0x30],0x4
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00146580
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00116dda
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x14d5
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00116eed
LAB_00116dda:
JMP 0x00116ddc
LAB_00116ddc:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x90]
CALL 0x00143940
MOVSX EAX,AL
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00116e2a
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0x14d8
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00116eed
LAB_00116e2a:
JMP 0x00116e2c
LAB_00116e2c:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00144020
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x65
JZ 0x00116e6b
LEA RDI,[0x165590]
LEA RSI,[0x166536]
LEA RDX,[0x16606d]
MOV ECX,0x14db
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00116eed
LAB_00116e6b:
JMP 0x00116e6d
LAB_00116e6d:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00143eb0
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x16654a]
CALL 0x00138a70
MOV dword ptr [RBP + -0x14],EAX
CMP dword ptr [RBP + -0x14],0x0
JZ 0x00116ee4
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0xa4],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xa4]
MOV RDX,qword ptr [RBP + -0xa0]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0x14e0
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00116eed
LAB_00116ee4:
JMP 0x00116ee6
LAB_00116ee6:
MOV dword ptr [RBP + -0x4],0x0
LAB_00116eed:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 test_conc512(int8 param_1)
{
char cVar1;
int iVar2;
int4 uVar3;
int8 uVar4;
int1 local_9c [4];
int1 local_98 [16];
int1 *local_88;
int4 local_38;
int8 local_28;
int local_1c;
int8 local_18;
int4 local_c;
local_18 = param_1;
local_1c = mysql_query(param_1,"drop table if exists t1");
local_1c = mysql_real_query(local_18,"CREATE TABLE t1 (a int)",0x17);
local_1c = mysql_real_query(local_18,"INSERT INTO t1 VALUES (1073741825)",0x22);
local_28 = mysql_stmt_init(local_18);
local_1c = mysql_stmt_prepare(local_28,"SELECT a FROM t1",0x10);
if (local_1c == 0) {
memset(local_98,0,0x70);
local_88 = local_9c;
local_38 = 4;
local_1c = mysql_stmt_execute(local_28);
if (local_1c == 0) {
cVar1 = mysql_stmt_bind_result(local_28,local_98);
local_1c = (int)cVar1;
if (local_1c == 0) {
local_1c = mysql_stmt_fetch(local_28);
if (local_1c == 0x65) {
mysql_stmt_close(local_28);
iVar2 = mysql_query(local_18,"DROP TABLE t1");
if (iVar2 == 0) {
local_c = 0;
}
else {
local_1c = iVar2;
uVar4 = mysql_error(local_18);
uVar3 = mysql_errno(local_18);
diag("Error (%d): %s (%d) in %s line %d",iVar2,uVar4,uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0x14e0);
local_c = 1;
}
}
else {
diag("Error: %s (%s: %d)","Truncation expected",
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x14db);
local_c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_28);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x14d8);
local_c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_28);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0x14d5);
local_c = 1;
}
}
else {
uVar4 = mysql_stmt_error(local_28);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0x14ce)
;
local_c = 1;
}
return local_c;
}
|
|
57,622
|
AccountInfo::LoadResult(Field*)
|
SylCore-WoTLK/src/server/apps/authserver/Server/AuthSession.cpp
|
void AccountInfo::LoadResult(Field* fields)
{
// 0 1 2 3 4 5
// SELECT a.id, a.username, a.locked, a.lock_country, a.last_ip, a.failed_logins,
// 6 7
// ab.unbandate > UNIX_TIMESTAMP() OR ab.unbandate = ab.bandate, ab.unbandate = ab.bandate,
// 8 9
// ipb.unbandate > UNIX_TIMESTAMP() OR ipb.unbandate = ipb.bandate, ipb.unbandate = ipb.bandate,
// 10
// aa.gmlevel (, more query-specific fields)
// FROM account a LEFT JOIN account_access aa ON a.id = aa.id LEFT JOIN account_banned ab ON ab.id = a.id AND ab.active = 1 LEFT JOIN ip_banned ipb ON ipb.ip = ? WHERE a.username = ?
Id = fields[0].Get<uint32>();
Login = fields[1].Get<std::string>();
IsLockedToIP = fields[2].Get<bool>();
LockCountry = fields[3].Get<std::string>();
LastIP = fields[4].Get<std::string>();
FailedLogins = fields[5].Get<uint32>();
IsBanned = fields[6].Get<bool>() || fields[8].Get<bool>();
IsPermanentlyBanned = fields[7].Get<bool>() || fields[9].Get<bool>();
SecurityLevel = static_cast<AccountTypes>(fields[10].Get<uint8>()) > SEC_CONSOLE ? SEC_CONSOLE : static_cast<AccountTypes>(fields[10].Get<uint8>());
// Use our own uppercasing of the account name instead of using UPPER() in mysql query
// This is how the account was created in the first place and changing it now would result in breaking
// login for all accounts having accented characters in their name
Utf8ToUpperOnlyLatin(Login);
}
|
O3
|
cpp
|
AccountInfo::LoadResult(Field*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x67206
movl %eax, (%rbx)
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x63480
leaq 0x8(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c916
movq (%r12), %rdi
leaq 0x18(%rsp), %r13
cmpq %r13, %rdi
je 0x438e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd32e8
leaq 0x30(%r14), %rdi
callq 0x6369a
movb %al, 0x28(%rbx)
leaq 0x48(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x63480
leaq 0x30(%rbx), %rdi
movq %r12, %rsi
callq 0x1c916
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x43922
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd32e8
leaq 0x60(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x63480
leaq 0x50(%rbx), %rdi
movq %r12, %rsi
callq 0x1c916
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x43955
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xd32e8
leaq 0x78(%r14), %rdi
callq 0x67206
movl %eax, 0x70(%rbx)
leaq 0x90(%r14), %rdi
callq 0x6369a
movl %eax, %ecx
movb $0x1, %bpl
movb $0x1, %al
testb %cl, %cl
jne 0x43984
leaq 0xc0(%r14), %rdi
callq 0x6369a
movb %al, 0x74(%rbx)
leaq 0xa8(%r14), %rdi
callq 0x6369a
testb %al, %al
jne 0x439a5
leaq 0xd8(%r14), %rdi
callq 0x6369a
movl %eax, %ebp
movb %bpl, 0x75(%rbx)
addq $0xf0, %r14
movq %r14, %rdi
callq 0x65a38
movl $0x4, %ecx
cmpb $0x4, %al
ja 0x439cc
movq %r14, %rdi
callq 0x65a38
movzbl %al, %ecx
movl %ecx, 0x78(%rbx)
movq %r15, %rdi
callq 0xc5ced
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN11AccountInfo10LoadResultEP5Field:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
call _ZNK5Field7GetDataIjEET_v; Field::GetData<uint>(void)
mov [rbx], eax
lea rsi, [r14+18h]
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNK5Field13GetDataStringB5cxx11Ev; Field::GetDataString(void)
lea r15, [rbx+8]
mov rdi, r15
mov rsi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea r13, [rsp+58h+var_40]
cmp rdi, r13
jz short loc_438E3
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_438E3:
lea rdi, [r14+30h]
call _ZNK5Field7GetDataIbEET_v; Field::GetData<bool>(void)
mov [rbx+28h], al
lea rsi, [r14+48h]
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNK5Field13GetDataStringB5cxx11Ev; Field::GetDataString(void)
lea rdi, [rbx+30h]
mov rsi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
cmp rdi, r13
jz short loc_43922
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_43922:
lea rsi, [r14+60h]
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNK5Field13GetDataStringB5cxx11Ev; Field::GetDataString(void)
lea rdi, [rbx+50h]
mov rsi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
cmp rdi, r13
jz short loc_43955
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call _ZdlPvm; operator delete(void *,ulong)
loc_43955:
lea rdi, [r14+78h]
call _ZNK5Field7GetDataIjEET_v; Field::GetData<uint>(void)
mov [rbx+70h], eax
lea rdi, [r14+90h]
call _ZNK5Field7GetDataIbEET_v; Field::GetData<bool>(void)
mov ecx, eax
mov bpl, 1
mov al, 1
test cl, cl
jnz short loc_43984
lea rdi, [r14+0C0h]
call _ZNK5Field7GetDataIbEET_v; Field::GetData<bool>(void)
loc_43984:
mov [rbx+74h], al
lea rdi, [r14+0A8h]
call _ZNK5Field7GetDataIbEET_v; Field::GetData<bool>(void)
test al, al
jnz short loc_439A5
lea rdi, [r14+0D8h]
call _ZNK5Field7GetDataIbEET_v; Field::GetData<bool>(void)
mov ebp, eax
loc_439A5:
mov [rbx+75h], bpl
add r14, 0F0h
mov rdi, r14
call _ZNK5Field7GetDataIhEET_v; Field::GetData<uchar>(void)
mov ecx, 4
cmp al, 4
ja short loc_439CC
mov rdi, r14
call _ZNK5Field7GetDataIhEET_v; Field::GetData<uchar>(void)
movzx ecx, al
loc_439CC:
mov [rbx+78h], ecx
mov rdi, r15
call _Z20Utf8ToUpperOnlyLatinRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; Utf8ToUpperOnlyLatin(std::string &)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long AccountInfo::LoadResult(AccountInfo *this, Field *a2)
{
void **v3; // rsi
char v4; // cl
char v5; // bp
char v6; // al
Log *v7; // r14
unsigned __int8 v8; // al
int v9; // edx
int v10; // r8d
int v11; // r9d
int v12; // ecx
void *v14[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
*(_DWORD *)this = Field::GetData<unsigned int>(a2);
Field::GetDataString[abi:cxx11](v14, (char *)a2 + 24);
std::string::operator=((long long)this + 8, (long long)v14);
if ( v14[0] != v15 )
operator delete(v14[0], v15[0] + 1LL);
*((_BYTE *)this + 40) = Field::GetData<bool>((Field *)((char *)a2 + 48));
Field::GetDataString[abi:cxx11](v14, (char *)a2 + 72);
std::string::operator=((long long)this + 48, (long long)v14);
if ( v14[0] != v15 )
operator delete(v14[0], v15[0] + 1LL);
Field::GetDataString[abi:cxx11](v14, (char *)a2 + 96);
v3 = v14;
std::string::operator=((long long)this + 80, (long long)v14);
if ( v14[0] != v15 )
{
LODWORD(v3) = LODWORD(v15[0]) + 1;
operator delete(v14[0], v15[0] + 1LL);
}
*((_DWORD *)this + 28) = Field::GetData<unsigned int>((Field *)((char *)a2 + 120));
v4 = Field::GetData<bool>((Field *)((char *)a2 + 144));
v5 = 1;
v6 = 1;
if ( !v4 )
v6 = Field::GetData<bool>((Field *)((char *)a2 + 192));
*((_BYTE *)this + 116) = v6;
if ( !(unsigned __int8)Field::GetData<bool>((Field *)((char *)a2 + 168)) )
v5 = Field::GetData<bool>((Field *)((char *)a2 + 216));
*((_BYTE *)this + 117) = v5;
v7 = (Field *)((char *)a2 + 240);
v8 = Field::GetData<unsigned char>(v7);
v12 = 4;
if ( v8 <= 4u )
v12 = (unsigned __int8)Field::GetData<unsigned char>(v7);
*((_DWORD *)this + 30) = v12;
return Utf8ToUpperOnlyLatin((int)this + 8, (_DWORD)v3, v9, v12, v10, v11);
}
|
LoadResult:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
CALL 0x00167206
MOV dword ptr [RBX],EAX
LEA RSI,[R14 + 0x18]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00163480
LEA R15,[RBX + 0x8]
MOV RDI,R15
MOV RSI,R12
CALL 0x0011c916
MOV RDI,qword ptr [R12]
LEA R13,[RSP + 0x18]
CMP RDI,R13
JZ 0x001438e3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001d32e8
LAB_001438e3:
LEA RDI,[R14 + 0x30]
CALL 0x0016369a
MOV byte ptr [RBX + 0x28],AL
LEA RSI,[R14 + 0x48]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00163480
LEA RDI,[RBX + 0x30]
MOV RSI,R12
CALL 0x0011c916
MOV RDI,qword ptr [R12]
CMP RDI,R13
JZ 0x00143922
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001d32e8
LAB_00143922:
LEA RSI,[R14 + 0x60]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x00163480
LEA RDI,[RBX + 0x50]
MOV RSI,R12
CALL 0x0011c916
MOV RDI,qword ptr [R12]
CMP RDI,R13
JZ 0x00143955
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001d32e8
LAB_00143955:
LEA RDI,[R14 + 0x78]
CALL 0x00167206
MOV dword ptr [RBX + 0x70],EAX
LEA RDI,[R14 + 0x90]
CALL 0x0016369a
MOV ECX,EAX
MOV BPL,0x1
MOV AL,0x1
TEST CL,CL
JNZ 0x00143984
LEA RDI,[R14 + 0xc0]
CALL 0x0016369a
LAB_00143984:
MOV byte ptr [RBX + 0x74],AL
LEA RDI,[R14 + 0xa8]
CALL 0x0016369a
TEST AL,AL
JNZ 0x001439a5
LEA RDI,[R14 + 0xd8]
CALL 0x0016369a
MOV EBP,EAX
LAB_001439a5:
MOV byte ptr [RBX + 0x75],BPL
ADD R14,0xf0
MOV RDI,R14
CALL 0x00165a38
MOV ECX,0x4
CMP AL,0x4
JA 0x001439cc
MOV RDI,R14
CALL 0x00165a38
MOVZX ECX,AL
LAB_001439cc:
MOV dword ptr [RBX + 0x78],ECX
MOV RDI,R15
CALL 0x001c5ced
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* AccountInfo::LoadResult(Field*) */
void __thiscall AccountInfo::LoadResult(AccountInfo *this,Field *param_1)
{
AccountInfo AVar1;
bool bVar2;
AccountInfo AVar3;
byte bVar4;
uint uVar5;
long *local_50 [2];
long local_40 [2];
uVar5 = Field::GetData<unsigned_int>(param_1);
*(uint *)this = uVar5;
Field::GetDataString_abi_cxx11_();
std::__cxx11::string::operator=((string *)(this + 8),(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
AVar1 = (AccountInfo)Field::GetData<bool>(param_1 + 0x30);
this[0x28] = AVar1;
Field::GetDataString_abi_cxx11_();
std::__cxx11::string::operator=((string *)(this + 0x30),(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
Field::GetDataString_abi_cxx11_();
std::__cxx11::string::operator=((string *)(this + 0x50),(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
uVar5 = Field::GetData<unsigned_int>(param_1 + 0x78);
*(uint *)(this + 0x70) = uVar5;
bVar2 = Field::GetData<bool>(param_1 + 0x90);
AVar3 = (AccountInfo)0x1;
AVar1 = (AccountInfo)0x1;
if (!bVar2) {
AVar1 = (AccountInfo)Field::GetData<bool>(param_1 + 0xc0);
}
this[0x74] = AVar1;
bVar2 = Field::GetData<bool>(param_1 + 0xa8);
if (!bVar2) {
AVar3 = (AccountInfo)Field::GetData<bool>(param_1 + 0xd8);
}
this[0x75] = AVar3;
bVar4 = Field::GetData<unsigned_char>(param_1 + 0xf0);
uVar5 = 4;
if (bVar4 < 5) {
bVar4 = Field::GetData<unsigned_char>(param_1 + 0xf0);
uVar5 = (uint)bVar4;
}
*(uint *)(this + 0x78) = uVar5;
Utf8ToUpperOnlyLatin((string *)(this + 8));
return;
}
|
|
57,623
|
my_round_up_to_next_power
|
eloqsql/include/my_bit.h
|
static inline uint32 my_round_up_to_next_power(uint32 v)
{
v--; /* 01100000000000000000000000001010 */
v|= v >> 1; /* 01110000000000000000000000001111 */
v|= v >> 2; /* 01111100000000000000000000001111 */
v|= v >> 4; /* 01111111110000000000000000001111 */
v|= v >> 8; /* 01111111111111111100000000001111 */
v|= v >> 16; /* 01111111111111111111111111111111 */
return v+1; /* 10000000000000000000000000000000 */
}
|
O0
|
c
|
my_round_up_to_next_power:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x2, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x4, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_round_up_to_next_power_0:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
add eax, 0FFFFFFFFh
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 1
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 2
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 4
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 8
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
shr eax, 10h
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_4]
add eax, 1
pop rbp
retn
|
long long my_round_up_to_next_power_0(int a1)
{
unsigned int v2; // [rsp+0h] [rbp-4h]
unsigned int v3; // [rsp+0h] [rbp-4h]
v2 = (a1 - 1) | ((unsigned int)(a1 - 1) >> 1) | (((a1 - 1) | ((unsigned int)(a1 - 1) >> 1)) >> 2);
v3 = v2 | (v2 >> 4) | ((v2 | (v2 >> 4)) >> 8);
return (v3 | HIWORD(v3)) + 1;
}
|
my_round_up_to_next_power:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x1
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x2
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x4
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x8
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x10
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x4]
ADD EAX,0x1
POP RBP
RET
|
int my_round_up_to_next_power(int param_1)
{
uint uVar1;
uVar1 = param_1 - 1U >> 1 | param_1 - 1U;
uVar1 = uVar1 >> 2 | uVar1;
uVar1 = uVar1 >> 4 | uVar1;
uVar1 = uVar1 >> 8 | uVar1;
return (uVar1 >> 0x10 | uVar1) + 1;
}
|
|
57,624
|
my_utf8mb3_uni_no_range
|
eloqsql/strings/ctype-utf8.c
|
static int my_utf8mb3_uni_no_range(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t * pwc, const uchar *s)
{
uchar c;
c= s[0];
if (c < 0x80)
{
*pwc = c;
return 1;
}
if (c < 0xc2)
return MY_CS_ILSEQ;
if (c < 0xe0)
{
if (!((s[1] ^ 0x80) < 0x40))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
if (c < 0xf0)
{
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
return MY_CS_ILSEQ;
}
|
O3
|
c
|
my_utf8mb3_uni_no_range:
pushq %rbp
movq %rsp, %rbp
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xcc4c1
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0xcc4c8
xorl %eax, %eax
cmpb $-0x3e, %cl
jae 0xcc4ca
popq %rbp
retq
cmpb $-0x21, %cl
ja 0xcc4ed
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
cmpb $0x3f, %dl
ja 0xcc4c8
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0xcc4bc
cmpb $-0x11, %cl
ja 0xcc4c8
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0xcc4c8
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0xcc4c8
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
testb %r9b, %r8b
jne 0xcc4c8
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0xcc4bc
|
my_utf8mb3_uni_no_range:
push rbp
mov rbp, rsp
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_CC4C1
mov eax, 1
loc_CC4BC:
mov [rdi], rcx
jmp short loc_CC4C8
loc_CC4C1:
xor eax, eax
cmp cl, 0C2h
jnb short loc_CC4CA
loc_CC4C8:
pop rbp
retn
loc_CC4CA:
cmp cl, 0DFh
ja short loc_CC4ED
movzx edx, byte ptr [rsi+1]
xor edx, 80h
cmp dl, 3Fh ; '?'
ja short loc_CC4C8
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_CC4BC
loc_CC4ED:
cmp cl, 0EFh
ja short loc_CC4C8
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_CC4C8
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_CC4C8
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
test r8b, r9b
jnz short loc_CC4C8
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
mov rcx, rsi
jmp short loc_CC4BC
|
long long my_utf8mb3_uni_no_range(unsigned long long *a1, unsigned __int8 *a2)
{
unsigned long long v2; // rcx
long long result; // rax
char v4; // dl
char v5; // si
v2 = *a2;
if ( (v2 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_3:
*a1 = v2;
return result;
}
result = 0LL;
if ( (unsigned __int8)v2 >= 0xC2u )
{
if ( (unsigned __int8)v2 > 0xDFu )
{
if ( (unsigned __int8)v2 <= 0xEFu )
{
v4 = a2[1];
if ( v4 <= -65 )
{
v5 = a2[2];
if ( v5 <= -65 && ((unsigned __int8)v4 >= 0xA0u || (_DWORD)v2 != 224) )
{
result = 3LL;
v2 = (unsigned __int16)((_WORD)v2 << 12) | ((unsigned __int8)(v4 & 0x3F) << 6) | (unsigned long long)(v5 & 0x3F);
goto LABEL_3;
}
}
}
}
else if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v2 = a2[1] ^ 0x80 | ((unsigned __int8)(v2 & 0x1F) << 6);
result = 2LL;
goto LABEL_3;
}
}
return result;
}
|
my_utf8mb3_uni_no_range:
PUSH RBP
MOV RBP,RSP
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x001cc4c1
MOV EAX,0x1
LAB_001cc4bc:
MOV qword ptr [RDI],RCX
JMP 0x001cc4c8
LAB_001cc4c1:
XOR EAX,EAX
CMP CL,0xc2
JNC 0x001cc4ca
LAB_001cc4c8:
POP RBP
RET
LAB_001cc4ca:
CMP CL,0xdf
JA 0x001cc4ed
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
CMP DL,0x3f
JA 0x001cc4c8
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x001cc4bc
LAB_001cc4ed:
CMP CL,0xef
JA 0x001cc4c8
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cc4c8
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x001cc4c8
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
TEST R8B,R9B
JNZ 0x001cc4c8
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
MOV RCX,RSI
JMP 0x001cc4bc
|
int8 my_utf8mb3_uni_no_range(ulong *param_1,byte *param_2)
{
byte bVar1;
byte bVar2;
int8 uVar3;
ulong uVar4;
bVar1 = *param_2;
uVar4 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (bVar1 < 0xc2) {
return 0;
}
if (bVar1 < 0xe0) {
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar4 = (ulong)((bVar1 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
}
else {
if (0xef < bVar1) {
return 0;
}
bVar2 = param_2[1];
if (-0x41 < (char)bVar2) {
return 0;
}
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = (ulong)(param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc);
uVar3 = 3;
}
}
else {
uVar3 = 1;
}
*param_1 = uVar4;
return uVar3;
}
|
|
57,625
|
JS_ToFloat64Free
|
bluesky950520[P]quickjs/quickjs.c
|
static inline int JS_ToFloat64Free(JSContext *ctx, double *pres, JSValue val)
{
uint32_t tag;
tag = JS_VALUE_GET_TAG(val);
if (tag <= JS_TAG_NULL) {
*pres = JS_VALUE_GET_INT(val);
return 0;
} else if (JS_TAG_IS_FLOAT64(tag)) {
*pres = JS_VALUE_GET_FLOAT64(val);
return 0;
} else {
return __JS_ToFloat64Free(ctx, pres, val);
}
}
|
O0
|
c
|
JS_ToFloat64Free:
subq $0x38, %rsp
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movl %eax, 0xc(%rsp)
cmpl $0x2, 0xc(%rsp)
ja 0x38631
cvtsi2sdl 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x3866e
cmpl $0x7, 0xc(%rsp)
jne 0x38651
movsd 0x20(%rsp), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x3866e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x61c90
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
JS_ToFloat64Free:
sub rsp, 38h
mov [rsp+38h+var_18], rdx
mov [rsp+38h+var_10], rcx
mov [rsp+38h+var_20], rdi
mov [rsp+38h+var_28], rsi
mov rax, [rsp+38h+var_10]
mov [rsp+38h+var_2C], eax
cmp [rsp+38h+var_2C], 2
ja short loc_38631
cvtsi2sd xmm0, dword ptr [rsp+38h+var_18]
mov rax, [rsp+38h+var_28]
movsd qword ptr [rax], xmm0
mov [rsp+38h+var_4], 0
jmp short loc_3866E
loc_38631:
cmp [rsp+38h+var_2C], 7
jnz short loc_38651
movsd xmm0, [rsp+38h+var_18]
mov rax, [rsp+38h+var_28]
movsd qword ptr [rax], xmm0
mov [rsp+38h+var_4], 0
jmp short loc_3866E
loc_38651:
mov rdi, [rsp+38h+var_20]
mov rsi, [rsp+38h+var_28]
mov rdx, [rsp+38h+var_18]
mov rcx, [rsp+38h+var_10]
call __JS_ToFloat64Free
mov [rsp+38h+var_4], eax
loc_3866E:
mov eax, [rsp+38h+var_4]
add rsp, 38h
retn
|
long long JS_ToFloat64Free(long long a1, double *a2, long long a3, long long a4)
{
if ( (unsigned int)a4 > 2 )
{
if ( (_DWORD)a4 == 7 )
{
*(_QWORD *)a2 = a3;
return 0;
}
else
{
return (unsigned int)_JS_ToFloat64Free(a1, a2, a3, a4);
}
}
else
{
*a2 = (double)(int)a3;
return 0;
}
}
|
JS_ToFloat64Free:
SUB RSP,0x38
MOV qword ptr [RSP + 0x20],RDX
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x2
JA 0x00138631
CVTSI2SD XMM0,dword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOVSD qword ptr [RAX],XMM0
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0013866e
LAB_00138631:
CMP dword ptr [RSP + 0xc],0x7
JNZ 0x00138651
MOVSD XMM0,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOVSD qword ptr [RAX],XMM0
MOV dword ptr [RSP + 0x34],0x0
JMP 0x0013866e
LAB_00138651:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x00161c90
MOV dword ptr [RSP + 0x34],EAX
LAB_0013866e:
MOV EAX,dword ptr [RSP + 0x34]
ADD RSP,0x38
RET
|
int4 JS_ToFloat64Free(int8 param_1,double *param_2,double param_3,int8 param_4)
{
int4 local_18;
int4 local_4;
if ((uint)param_4 < 3) {
local_18 = SUB84(param_3,0);
*param_2 = (double)local_18;
local_4 = 0;
}
else if ((uint)param_4 == 7) {
*param_2 = param_3;
local_4 = 0;
}
else {
local_4 = __JS_ToFloat64Free(param_1,param_2,param_3,param_4);
}
return local_4;
}
|
|
57,626
|
JS_ToFloat64Free
|
bluesky950520[P]quickjs/quickjs.c
|
static inline int JS_ToFloat64Free(JSContext *ctx, double *pres, JSValue val)
{
uint32_t tag;
tag = JS_VALUE_GET_TAG(val);
if (tag <= JS_TAG_NULL) {
*pres = JS_VALUE_GET_INT(val);
return 0;
} else if (JS_TAG_IS_FLOAT64(tag)) {
*pres = JS_VALUE_GET_FLOAT64(val);
return 0;
} else {
return __JS_ToFloat64Free(ctx, pres, val);
}
}
|
O2
|
c
|
JS_ToFloat64Free:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %ecx
ja 0x212a5
cvtsi2sd %edx, %xmm0
movsd %xmm0, (%rbx)
jmp 0x212ad
cmpl $0x7, %ecx
jne 0x212b1
movq %rdx, (%rbx)
xorl %ebp, %ebp
jmp 0x21327
movq %rdi, %r14
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x2e216
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x212d5
pushq $-0x1
popq %rbp
movsd 0x644fd(%rip), %xmm0 # 0x857d0
jmp 0x21323
movq %rax, %r15
cmpl $-0x9, %r12d
je 0x212f9
xorl %ebp, %ebp
cmpl $0x7, %r12d
je 0x212f2
testl %r12d, %r12d
jne 0x21338
cvtsi2sd %r15d, %xmm0
jmp 0x21323
movq %r15, %xmm0
jmp 0x21323
movq %r15, %rdi
addq $0x8, %rdi
movq %rsp, %r13
xorl %ebp, %ebp
movq %r13, %rsi
xorl %edx, %edx
callq 0x723c2
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1801e
movsd (%r13), %xmm0
movsd %xmm0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xe090
|
JS_ToFloat64Free:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
cmp ecx, 2
ja short loc_212A5
cvtsi2sd xmm0, edx
movsd qword ptr [rbx], xmm0
jmp short loc_212AD
loc_212A5:
cmp ecx, 7
jnz short loc_212B1
mov [rbx], rdx
loc_212AD:
xor ebp, ebp
jmp short loc_21327
loc_212B1:
mov r14, rdi
mov rsi, rdx
mov rdx, rcx
call JS_ToNumberFree
mov r12, rdx
cmp r12d, 6
jnz short loc_212D5
push 0FFFFFFFFFFFFFFFFh
pop rbp
movsd xmm0, cs:qword_857D0
jmp short loc_21323
loc_212D5:
mov r15, rax
cmp r12d, 0FFFFFFF7h
jz short loc_212F9
xor ebp, ebp
cmp r12d, 7
jz short loc_212F2
test r12d, r12d
jnz short loc_21338
cvtsi2sd xmm0, r15d
jmp short loc_21323
loc_212F2:
movq xmm0, r15
jmp short loc_21323
loc_212F9:
mov rdi, r15
add rdi, 8
mov r13, rsp
xor ebp, ebp
mov rsi, r13
xor edx, edx
call bf_get_float64
mov rdi, r14
mov rsi, r15
mov rdx, r12
call JS_FreeValue
movsd xmm0, qword ptr [r13+0]
loc_21323:
movsd qword ptr [rbx], xmm0
loc_21327:
mov eax, ebp
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_21338:
call _abort
|
long long JS_ToFloat64Free(const char *a1, double *a2, long long a3, long long a4)
{
double v4; // rax
unsigned int v5; // ebp
long long v6; // rax
long long v7; // rdx
long long v8; // r12
double v9; // xmm0_8
long long v10; // r15
double v12; // [rsp-8h] [rbp-38h] BYREF
v12 = v4;
if ( (unsigned int)a4 <= 2 )
{
*a2 = (double)(int)a3;
return 0;
}
if ( (_DWORD)a4 == 7 )
{
*(_QWORD *)a2 = a3;
return 0;
}
*(double *)&v6 = COERCE_DOUBLE(JS_ToNumberFree(a1, a3, a4));
v8 = v7;
if ( (_DWORD)v7 == 6 )
{
v5 = -1;
v9 = NAN;
}
else
{
v10 = v6;
if ( (_DWORD)v7 == -9 )
{
v5 = 0;
bf_get_float64(v6 + 8, &v12, 0LL);
JS_FreeValue((long long)a1, v10, v8);
v9 = v12;
}
else
{
v5 = 0;
if ( (_DWORD)v7 == 7 )
{
v9 = *(double *)&v6;
}
else
{
if ( (_DWORD)v7 )
abort(a1);
v9 = (double)(int)v6;
}
}
}
*a2 = v9;
return v5;
}
|
JS_ToFloat64Free:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
CMP ECX,0x2
JA 0x001212a5
CVTSI2SD XMM0,EDX
MOVSD qword ptr [RBX],XMM0
JMP 0x001212ad
LAB_001212a5:
CMP ECX,0x7
JNZ 0x001212b1
MOV qword ptr [RBX],RDX
LAB_001212ad:
XOR EBP,EBP
JMP 0x00121327
LAB_001212b1:
MOV R14,RDI
MOV RSI,RDX
MOV RDX,RCX
CALL 0x0012e216
MOV R12,RDX
CMP R12D,0x6
JNZ 0x001212d5
PUSH -0x1
POP RBP
MOVSD XMM0,qword ptr [0x001857d0]
JMP 0x00121323
LAB_001212d5:
MOV R15,RAX
CMP R12D,-0x9
JZ 0x001212f9
XOR EBP,EBP
CMP R12D,0x7
JZ 0x001212f2
TEST R12D,R12D
JNZ 0x00121338
CVTSI2SD XMM0,R15D
JMP 0x00121323
LAB_001212f2:
MOVQ XMM0,R15
JMP 0x00121323
LAB_001212f9:
MOV RDI,R15
ADD RDI,0x8
MOV R13,RSP
XOR EBP,EBP
MOV RSI,R13
XOR EDX,EDX
CALL 0x001723c2
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x0011801e
MOVSD XMM0,qword ptr [R13]
LAB_00121323:
MOVSD qword ptr [RBX],XMM0
LAB_00121327:
MOV EAX,EBP
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00121338:
CALL 0x0010e090
|
int4 JS_ToFloat64Free(int8 param_1,double *param_2,double param_3,int8 param_4)
{
double in_RAX;
int4 uVar1;
int iVar2;
double dVar3;
int1 auVar4 [16];
double local_38;
if ((uint)param_4 < 3) {
*param_2 = (double)SUB84(param_3,0);
}
else {
if ((uint)param_4 != 7) {
local_38 = in_RAX;
auVar4 = JS_ToNumberFree(param_1,param_3,param_4);
dVar3 = auVar4._0_8_;
iVar2 = auVar4._8_4_;
if (iVar2 == 6) {
uVar1 = 0xffffffff;
dVar3 = DAT_001857d0;
}
else if (iVar2 == -9) {
uVar1 = 0;
bf_get_float64((long)dVar3 + 8,&local_38,0);
JS_FreeValue(param_1,dVar3,auVar4._8_8_);
dVar3 = local_38;
}
else {
uVar1 = 0;
if (iVar2 != 7) {
if (iVar2 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
dVar3 = (double)auVar4._0_4_;
}
}
*param_2 = dVar3;
return uVar1;
}
*param_2 = param_3;
}
return 0;
}
|
|
57,627
|
nglog::LogMessage::WriteToStringAndLog()
|
ng-log[P]ng-log/src/logging.cc
|
EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
if (data_->message_ != nullptr) {
RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
data_->message_text_[data_->num_chars_to_log_ - 1] == '\n',
"");
// Omit prefix of message and trailing newline when writing to message_.
const char* start = data_->message_text_ + data_->num_prefix_chars_;
size_t len = data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1;
data_->message_->assign(start, len);
}
SendToLog();
}
|
O0
|
cpp
|
nglog::LogMessage::WriteToStringAndLog():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
cmpq $0x0, 0x76b0(%rax)
je 0x14f1f
jmp 0x14e68
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x76c0(%rax)
jbe 0x14e9b
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq 0x8(%rcx), %rcx
movq 0x76c0(%rcx), %rcx
subq $0x1, %rcx
movsbl 0x4(%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x14ecc
jmp 0x14e9d
movl $0x3, %edi
leaq 0x3caf1(%rip), %rsi # 0x5199a
movl $0x78c, %edx # imm = 0x78C
leaq 0x3cb2c(%rip), %rcx # 0x519e1
leaq 0x3cb39(%rip), %r8 # 0x519f5
leaq 0x3d054(%rip), %r9 # 0x51f17
movb $0x0, %al
callq 0x4c080
jmp 0x14ecc
jmp 0x14ece
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq 0x8(%rax), %rdx
addq 0x76b8(%rdx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rcx
movq 0x76c0(%rcx), %rcx
movq 0x8(%rax), %rdx
subq 0x76b8(%rdx), %rcx
subq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq 0x76b0(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x9a00
movq -0x20(%rbp), %rdi
callq 0x14460
addq $0x20, %rsp
popq %rbp
retq
nop
|
_ZN5nglog10LogMessage19WriteToStringAndLogEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
mov rax, [rax+8]
cmp qword ptr [rax+76B0h], 0
jz loc_14F1F
jmp short $+2
loc_14E68:
mov rax, [rbp+var_20]
mov rax, [rax+8]
cmp qword ptr [rax+76C0h], 0
jbe short loc_14E9B
mov rcx, [rbp+var_20]
mov rax, [rcx+8]
mov rcx, [rcx+8]
mov rcx, [rcx+76C0h]
sub rcx, 1
movsx eax, byte ptr [rax+rcx+4]
cmp eax, 0Ah
jz short loc_14ECC
loc_14E9B:
jmp short $+2
loc_14E9D:
mov edi, 3
lea rsi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov edx, 78Ch
lea rcx, aCheckSFailedS; "Check %s failed: %s"
lea r8, aDataNumCharsTo; "data_->num_chars_to_log_ > 0 && data_->"...
lea r9, asc_51F15+2; ""
mov al, 0
call _ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z; nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)
jmp short $+2
loc_14ECC:
jmp short $+2
loc_14ECE:
mov rax, [rbp+var_20]
mov rcx, [rax+8]
add rcx, 4
mov rdx, [rax+8]
add rcx, [rdx+76B8h]
mov [rbp+var_10], rcx
mov rcx, [rax+8]
mov rcx, [rcx+76C0h]
mov rdx, [rax+8]
sub rcx, [rdx+76B8h]
sub rcx, 1
mov [rbp+var_18], rcx
mov rax, [rax+8]
mov rdi, [rax+76B0h]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKcm; std::string::assign(char const*,ulong)
loc_14F1F:
mov rdi, [rbp+var_20]; this
call _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
add rsp, 20h
pop rbp
retn
|
nglog::LogDestination * nglog::LogMessage::WriteToStringAndLog(nglog::LogMessage *this)
{
if ( *(_QWORD *)(*((_QWORD *)this + 1) + 30384LL) )
{
if ( !*(_QWORD *)(*((_QWORD *)this + 1) + 30400LL)
|| *(_BYTE *)(*((_QWORD *)this + 1) + *(_QWORD *)(*((_QWORD *)this + 1) + 30400LL) - 1LL + 4) != 10 )
{
nglog::RawLog(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1932,
(unsigned int)"Check %s failed: %s",
(unsigned int)"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == '\\n'",
(unsigned int)"");
}
std::string::assign(
*(_QWORD *)(*((_QWORD *)this + 1) + 30384LL),
*(_QWORD *)(*((_QWORD *)this + 1) + 30392LL) + *((_QWORD *)this + 1) + 4LL,
*(_QWORD *)(*((_QWORD *)this + 1) + 30400LL) - *(_QWORD *)(*((_QWORD *)this + 1) + 30392LL) - 1LL);
}
return nglog::LogMessage::SendToLog(this);
}
|
WriteToStringAndLog:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + 0x76b0],0x0
JZ 0x00114f1f
JMP 0x00114e68
LAB_00114e68:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
CMP qword ptr [RAX + 0x76c0],0x0
JBE 0x00114e9b
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RCX + 0x8]
MOV RCX,qword ptr [RCX + 0x76c0]
SUB RCX,0x1
MOVSX EAX,byte ptr [RAX + RCX*0x1 + 0x4]
CMP EAX,0xa
JZ 0x00114ecc
LAB_00114e9b:
JMP 0x00114e9d
LAB_00114e9d:
MOV EDI,0x3
LEA RSI,[0x15199a]
MOV EDX,0x78c
LEA RCX,[0x1519e1]
LEA R8,[0x1519f5]
LEA R9,[0x151f17]
MOV AL,0x0
CALL 0x0014c080
JMP 0x00114ecc
LAB_00114ecc:
JMP 0x00114ece
LAB_00114ece:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x8]
ADD RCX,0x4
MOV RDX,qword ptr [RAX + 0x8]
ADD RCX,qword ptr [RDX + 0x76b8]
MOV qword ptr [RBP + -0x10],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RCX + 0x76c0]
MOV RDX,qword ptr [RAX + 0x8]
SUB RCX,qword ptr [RDX + 0x76b8]
SUB RCX,0x1
MOV qword ptr [RBP + -0x18],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00109a00
LAB_00114f1f:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00114460
ADD RSP,0x20
POP RBP
RET
|
/* nglog::LogMessage::WriteToStringAndLog() */
void __thiscall nglog::LogMessage::WriteToStringAndLog(LogMessage *this)
{
if (*(long *)(*(long *)(this + 8) + 0x76b0) != 0) {
if ((*(long *)(*(long *)(this + 8) + 0x76c0) == 0) ||
(*(char *)(*(long *)(this + 8) + *(long *)(*(long *)(this + 8) + 0x76c0) + 3) != '\n')) {
RawLog(3,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x78c,
"Check %s failed: %s",
"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == \'\\n\'"
,&DAT_00151f17);
}
std::__cxx11::string::assign
(*(char **)(*(long *)(this + 8) + 0x76b0),
*(long *)(this + 8) + 4 + *(long *)(*(long *)(this + 8) + 0x76b8));
}
SendToLog(this);
return;
}
|
|
57,628
|
nglog::LogMessage::WriteToStringAndLog()
|
ng-log[P]ng-log/src/logging.cc
|
EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
if (data_->message_ != nullptr) {
RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
data_->message_text_[data_->num_chars_to_log_ - 1] == '\n',
"");
// Omit prefix of message and trailing newline when writing to message_.
const char* start = data_->message_text_ + data_->num_prefix_chars_;
size_t len = data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1;
data_->message_->assign(start, len);
}
SendToLog();
}
|
O3
|
cpp
|
nglog::LogMessage::WriteToStringAndLog():
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x76b0(%rax), %rdi
testq %rdi, %rdi
je 0xb938
movq 0x76c0(%rax), %rdx
testq %rdx, %rdx
je 0xb8d9
cmpb $0xa, 0x3(%rdx,%rax)
je 0xb918
leaq 0x17fea(%rip), %rsi # 0x238ca
leaq 0x1802a(%rip), %rcx # 0x23911
leaq 0x18037(%rip), %r8 # 0x23925
leaq 0x18546(%rip), %r9 # 0x23e3b
movl $0x3, %edi
movl $0x78c, %edx # imm = 0x78C
xorl %eax, %eax
callq 0x20128
movq 0x8(%rbx), %rax
movq 0x76b0(%rax), %rdi
movq 0x76c0(%rax), %rdx
movq 0x76b8(%rax), %r8
leaq (%rax,%r8), %rcx
addq $0x4, %rcx
notq %r8
addq %rdx, %r8
movq 0x8(%rdi), %rdx
xorl %esi, %esi
callq 0x78b0
movq %rbx, %rdi
popq %rbx
jmp 0xb07e
nop
|
_ZN5nglog10LogMessage19WriteToStringAndLogEv:
push rbx
mov rbx, rdi
mov rax, [rdi+8]
mov rdi, [rax+76B0h]
test rdi, rdi
jz short loc_B938
mov rdx, [rax+76C0h]
test rdx, rdx
jz short loc_B8D9
cmp byte ptr [rdx+rax+3], 0Ah
jz short loc_B918
loc_B8D9:
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCheckSFailedS; "Check %s failed: %s"
lea r8, aDataNumCharsTo; "data_->num_chars_to_log_ > 0 && data_->"...
lea r9, asc_23E39+2; ""
mov edi, 3
mov edx, 78Ch
xor eax, eax
call _ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z; nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)
mov rax, [rbx+8]
mov rdi, [rax+76B0h]
mov rdx, [rax+76C0h]
loc_B918:
mov r8, [rax+76B8h]
lea rcx, [rax+r8]
add rcx, 4
not r8
add r8, rdx
mov rdx, [rdi+8]
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
loc_B938:
mov rdi, rbx; this
pop rbx
jmp _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
|
long long nglog::LogMessage::WriteToStringAndLog(nglog::LogMessage *this)
{
_QWORD *v2; // rax
long long v3; // rdi
long long v4; // rdx
v2 = (_QWORD *)*((_QWORD *)this + 1);
v3 = v2[3798];
if ( v3 )
{
v4 = v2[3800];
if ( !v4 || *((_BYTE *)v2 + v4 + 3) != 10 )
{
nglog::RawLog(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1932,
(unsigned int)"Check %s failed: %s",
(unsigned int)"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == '\\n'",
(unsigned int)"");
v2 = (_QWORD *)*((_QWORD *)this + 1);
v3 = v2[3798];
v4 = v2[3800];
}
std::string::_M_replace(v3, 0LL, *(_QWORD *)(v3 + 8), (char *)v2 + v2[3799] + 4, v4 + ~v2[3799]);
}
return nglog::LogMessage::SendToLog(this);
}
|
WriteToStringAndLog:
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
TEST RDI,RDI
JZ 0x0010b938
MOV RDX,qword ptr [RAX + 0x76c0]
TEST RDX,RDX
JZ 0x0010b8d9
CMP byte ptr [RDX + RAX*0x1 + 0x3],0xa
JZ 0x0010b918
LAB_0010b8d9:
LEA RSI,[0x1238ca]
LEA RCX,[0x123911]
LEA R8,[0x123925]
LEA R9,[0x123e3b]
MOV EDI,0x3
MOV EDX,0x78c
XOR EAX,EAX
CALL 0x00120128
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
MOV RDX,qword ptr [RAX + 0x76c0]
LAB_0010b918:
MOV R8,qword ptr [RAX + 0x76b8]
LEA RCX,[RAX + R8*0x1]
ADD RCX,0x4
NOT R8
ADD R8,RDX
MOV RDX,qword ptr [RDI + 0x8]
XOR ESI,ESI
CALL 0x001078b0
LAB_0010b938:
MOV RDI,RBX
POP RBX
JMP 0x0010b07e
|
/* nglog::LogMessage::WriteToStringAndLog() */
void __thiscall nglog::LogMessage::WriteToStringAndLog(LogMessage *this)
{
long lVar1;
ulong uVar2;
lVar1 = *(long *)(this + 8);
uVar2 = *(ulong *)(lVar1 + 0x76b0);
if (uVar2 != 0) {
if ((*(long *)(lVar1 + 0x76c0) == 0) ||
(*(char *)(*(long *)(lVar1 + 0x76c0) + 3 + lVar1) != '\n')) {
RawLog(3,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x78c,
"Check %s failed: %s",
"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == \'\\n\'"
,&DAT_00123e3b);
lVar1 = *(long *)(this + 8);
uVar2 = *(ulong *)(lVar1 + 0x76b0);
}
std::__cxx11::string::_M_replace
(uVar2,0,*(char **)(uVar2 + 8),lVar1 + *(long *)(lVar1 + 0x76b8) + 4);
}
SendToLog(this);
return;
}
|
|
57,629
|
my_coll_rule_shift_at_level
|
eloqsql/strings/ctype-uca.c
|
static void
my_coll_rule_shift_at_level(MY_COLL_RULE *r, int level)
{
switch (level)
{
case 4: /* Quaternary difference */
r->diff[3]++;
break;
case 3: /* Tertiary difference */
r->diff[2]++;
r->diff[3]= 0;
break;
case 2: /* Secondary difference */
r->diff[1]++;
r->diff[2]= r->diff[3]= 0;
break;
case 1: /* Primary difference */
r->diff[0]++;
r->diff[1]= r->diff[2]= r->diff[3]= 0;
break;
case 0:
/* Do nothing for '=': use the previous offsets for all levels */
break;
default:
DBUG_ASSERT(0);
}
}
|
O0
|
c
|
my_coll_rule_shift_at_level:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x4f15d
movq -0x18(%rbp), %rax
leaq 0xf1b39(%rip), %rcx # 0x140be0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movl 0x8c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8c(%rax)
jmp 0x4f163
movq -0x8(%rbp), %rax
movl 0x88(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
jmp 0x4f163
movq -0x8(%rbp), %rax
movl 0x84(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
jmp 0x4f163
movq -0x8(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x84(%rax)
jmp 0x4f163
jmp 0x4f163
jmp 0x4f15f
jmp 0x4f161
jmp 0x4f163
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_coll_rule_shift_at_level:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov eax, [rbp+var_C]
mov [rbp+var_18], rax
sub rax, 4; switch 5 cases
ja def_4F0AE; jumptable 000000000004F0AE default case
mov rax, [rbp+var_18]
lea rcx, jpt_4F0AE
movsxd rax, ds:(jpt_4F0AE - 140BE0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_4F0B0:
mov rax, [rbp+var_8]; jumptable 000000000004F0AE case 4
mov ecx, [rax+8Ch]
add ecx, 1
mov [rax+8Ch], ecx
jmp loc_4F163
loc_4F0C8:
mov rax, [rbp+var_8]; jumptable 000000000004F0AE case 3
mov ecx, [rax+88h]
add ecx, 1
mov [rax+88h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
jmp short loc_4F163
loc_4F0EB:
mov rax, [rbp+var_8]; jumptable 000000000004F0AE case 2
mov ecx, [rax+84h]
add ecx, 1
mov [rax+84h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
jmp short loc_4F163
loc_4F11C:
mov rax, [rbp+var_8]; jumptable 000000000004F0AE case 1
mov ecx, [rax+80h]
add ecx, 1
mov [rax+80h], ecx
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+84h], 0
jmp short loc_4F163
loc_4F15B:
jmp short loc_4F163; jumptable 000000000004F0AE case 0
def_4F0AE:
jmp short $+2; jumptable 000000000004F0AE default case
loc_4F15F:
jmp short $+2
loc_4F161:
jmp short $+2
loc_4F163:
pop rbp
retn
|
unsigned long long my_coll_rule_shift_at_level(_DWORD *a1, unsigned int a2)
{
unsigned long long result; // rax
result = a2;
switch ( a2 )
{
case 1u:
++a1[32];
a1[35] = 0;
a1[34] = 0;
result = (unsigned long long)a1;
a1[33] = 0;
break;
case 2u:
++a1[33];
a1[35] = 0;
result = (unsigned long long)a1;
a1[34] = 0;
break;
case 3u:
++a1[34];
result = (unsigned long long)a1;
a1[35] = 0;
break;
case 4u:
result = (unsigned long long)a1;
++a1[35];
break;
default:
return result;
}
return result;
}
|
my_coll_rule_shift_at_level:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x4
JA 0x0014f15d
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x240be0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_4:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x8c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x8c],ECX
JMP 0x0014f163
caseD_3:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x88]
ADD ECX,0x1
MOV dword ptr [RAX + 0x88],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
JMP 0x0014f163
caseD_2:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x84]
ADD ECX,0x1
MOV dword ptr [RAX + 0x84],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
JMP 0x0014f163
caseD_1:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x80]
ADD ECX,0x1
MOV dword ptr [RAX + 0x80],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x84],0x0
JMP 0x0014f163
caseD_0:
JMP 0x0014f163
LAB_0014f15d:
JMP 0x0014f15f
LAB_0014f15f:
JMP 0x0014f161
LAB_0014f161:
JMP 0x0014f163
default:
POP RBP
RET
|
void my_coll_rule_shift_at_level(long param_1,int4 param_2)
{
switch(param_2) {
case 0:
break;
case 1:
*(int *)(param_1 + 0x80) = *(int *)(param_1 + 0x80) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
*(int4 *)(param_1 + 0x84) = 0;
break;
case 2:
*(int *)(param_1 + 0x84) = *(int *)(param_1 + 0x84) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
*(int4 *)(param_1 + 0x88) = 0;
break;
case 3:
*(int *)(param_1 + 0x88) = *(int *)(param_1 + 0x88) + 1;
*(int4 *)(param_1 + 0x8c) = 0;
break;
case 4:
*(int *)(param_1 + 0x8c) = *(int *)(param_1 + 0x8c) + 1;
}
return;
}
|
|
57,630
|
evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&)
|
corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline Result keccak256(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto& index = stack.pop();
auto& size = stack.top();
if (!check_memory(gas_left, state.memory, index, size))
return {EVMC_OUT_OF_GAS, gas_left};
const auto i = static_cast<size_t>(index);
const auto s = static_cast<size_t>(size);
const auto w = num_words(s);
const auto cost = w * 6;
if ((gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
auto data = s != 0 ? &state.memory[i] : nullptr;
size = intx::be::load<uint256>(ethash::keccak256(data, s));
return {EVMC_SUCCESS, gas_left};
}
|
O3
|
cpp
|
evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movdqu -0x20(%rdi), %xmm0
movdqu -0x10(%rdi), %xmm1
por %xmm0, %xmm1
leaq 0x8(%rdx), %r15
ptest %xmm1, %xmm1
je 0x3fb6e
movq -0x10(%r14), %rax
orq -0x8(%r14), %rax
movl $0x3, %ebp
orq -0x18(%r14), %rax
jne 0x3fbd5
movq -0x20(%r14), %rcx
movq %rcx, %rax
shrq $0x20, %rax
jne 0x3fbd5
movq 0x10(%r14), %rax
orq 0x18(%r14), %rax
orq 0x8(%r14), %rax
jne 0x3fbd5
movq (%r14), %rax
movq %rax, %rsi
shrq $0x20, %rsi
jne 0x3fbd5
addq %rcx, %rax
cmpq 0x10(%rdx), %rax
jbe 0x3fb69
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3fbe5
movq %rax, %rbx
testq %rbx, %rbx
js 0x3fbd5
movq -0x20(%r14), %rdx
leaq 0x1f(%rdx), %rax
shrq $0x4, %rax
andq $-0x2, %rax
leaq (%rax,%rax,2), %rax
subq %rax, %rbx
js 0x3fb97
testq %rdx, %rdx
je 0x3fb9e
movq (%r14), %rsi
addq (%r15), %rsi
movq %rsp, %rdi
jmp 0x3fba5
movl $0x3, %ebp
jmp 0x3fbd5
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4f3da
movdqa 0x10(%rsp), %xmm0
movdqa 0x41448(%rip), %xmm1 # 0x81000
pshufb %xmm1, %xmm0
movdqu %xmm0, -0x20(%r14)
movdqa (%rsp), %xmm0
pshufb %xmm1, %xmm0
movdqu %xmm0, -0x10(%r14)
xorl %ebp, %ebp
movl %ebp, %eax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
_ZN6evmone5instr4core9keccak256ENS_8StackTopElRNS_14ExecutionStateE:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
movdqu xmm0, xmmword ptr [rdi-20h]
movdqu xmm1, xmmword ptr [rdi-10h]
por xmm1, xmm0
lea r15, [rdx+8]
ptest xmm1, xmm1
jz short loc_3FB6E
mov rax, [r14-10h]
or rax, [r14-8]
mov ebp, 3
or rax, [r14-18h]
jnz loc_3FBD5
mov rcx, [r14-20h]; unsigned __int64
mov rax, rcx
shr rax, 20h
jnz loc_3FBD5
mov rax, [r14+10h]
or rax, [r14+18h]
or rax, [r14+8]
jnz loc_3FBD5
mov rax, [r14]
mov rsi, rax
shr rsi, 20h
jnz loc_3FBD5
add rax, rcx
cmp rax, [rdx+10h]
jbe short loc_3FB69
mov rdi, rbx; this
mov rsi, r15; __int64
mov rdx, rax; evmone::Memory *
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
mov rbx, rax
loc_3FB69:
test rbx, rbx
js short loc_3FBD5
loc_3FB6E:
mov rdx, [r14-20h]
lea rax, [rdx+1Fh]
shr rax, 4
and rax, 0FFFFFFFFFFFFFFFEh
lea rax, [rax+rax*2]
sub rbx, rax
js short loc_3FB97
test rdx, rdx
jz short loc_3FB9E
mov rsi, [r14]
add rsi, [r15]
mov rdi, rsp
jmp short loc_3FBA5
loc_3FB97:
mov ebp, 3
jmp short loc_3FBD5
loc_3FB9E:
mov rdi, rsp
xor esi, esi
xor edx, edx
loc_3FBA5:
call ethash_keccak256
movdqa xmm0, [rsp+48h+var_38]
movdqa xmm1, cs:xmmword_81000
pshufb xmm0, xmm1
movdqu xmmword ptr [r14-20h], xmm0
movdqa xmm0, [rsp+48h+var_48]
pshufb xmm0, xmm1
movdqu xmmword ptr [r14-10h], xmm0
xor ebp, ebp
loc_3FBD5:
mov eax, ebp
mov rdx, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long evmone::instr::core::keccak256(__m128i *a1, evmone *a2, long long a3)
{
long long v3; // rbx
__m128i v4; // xmm1
_QWORD *v5; // r15
unsigned int v6; // ebp
unsigned long long v7; // rcx
long long v8; // rdx
long long v9; // rsi
__m128i si128; // xmm1
__m128i v12; // [rsp+0h] [rbp-48h] BYREF
__m128i v13[3]; // [rsp+10h] [rbp-38h] BYREF
v3 = (long long)a2;
v4 = _mm_or_si128(_mm_loadu_si128(a1 - 1), _mm_loadu_si128(a1 - 2));
v5 = (_QWORD *)(a3 + 8);
if ( _mm_testz_si128(v4, v4) )
goto LABEL_9;
v6 = 3;
if ( !(a1[-2].m128i_i64[1] | a1[-1].m128i_i64[1] | a1[-1].m128i_i64[0]) )
{
v7 = a1[-2].m128i_u64[0];
if ( !HIDWORD(v7) && !(a1->m128i_i64[1] | a1[1].m128i_i64[1] | a1[1].m128i_i64[0]) && !HIDWORD(a1->m128i_i64[0]) )
{
if ( v7 + a1->m128i_i64[0] > *(_QWORD *)(a3 + 16) )
v3 = evmone::grow_memory(a2, a3 + 8, (evmone::Memory *)(v7 + a1->m128i_i64[0]), v7);
if ( v3 >= 0 )
{
LABEL_9:
v8 = a1[-2].m128i_i64[0];
if ( (long long)(v3 - 3 * (((unsigned long long)(v8 + 31) >> 4) & 0xFFFFFFFFFFFFFFFELL)) < 0 )
{
return 3;
}
else
{
if ( v8 )
{
v9 = *v5 + a1->m128i_i64[0];
}
else
{
v9 = 0LL;
v8 = 0LL;
}
ethash_keccak256(&v12, v9, v8);
si128 = _mm_load_si128((const __m128i *)&xmmword_81000);
a1[-2] = _mm_shuffle_epi8(_mm_load_si128(v13), si128);
a1[-1] = _mm_shuffle_epi8(_mm_load_si128(&v12), si128);
return 0;
}
}
}
}
return v6;
}
|
keccak256:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOVDQU XMM0,xmmword ptr [RDI + -0x20]
MOVDQU XMM1,xmmword ptr [RDI + -0x10]
POR XMM1,XMM0
LEA R15,[RDX + 0x8]
PTEST XMM1,XMM1
JZ 0x0013fb6e
MOV RAX,qword ptr [R14 + -0x10]
OR RAX,qword ptr [R14 + -0x8]
MOV EBP,0x3
OR RAX,qword ptr [R14 + -0x18]
JNZ 0x0013fbd5
MOV RCX,qword ptr [R14 + -0x20]
MOV RAX,RCX
SHR RAX,0x20
JNZ 0x0013fbd5
MOV RAX,qword ptr [R14 + 0x10]
OR RAX,qword ptr [R14 + 0x18]
OR RAX,qword ptr [R14 + 0x8]
JNZ 0x0013fbd5
MOV RAX,qword ptr [R14]
MOV RSI,RAX
SHR RSI,0x20
JNZ 0x0013fbd5
ADD RAX,RCX
CMP RAX,qword ptr [RDX + 0x10]
JBE 0x0013fb69
MOV RDI,RBX
MOV RSI,R15
MOV RDX,RAX
CALL 0x0013fbe5
MOV RBX,RAX
LAB_0013fb69:
TEST RBX,RBX
JS 0x0013fbd5
LAB_0013fb6e:
MOV RDX,qword ptr [R14 + -0x20]
LEA RAX,[RDX + 0x1f]
SHR RAX,0x4
AND RAX,-0x2
LEA RAX,[RAX + RAX*0x2]
SUB RBX,RAX
JS 0x0013fb97
TEST RDX,RDX
JZ 0x0013fb9e
MOV RSI,qword ptr [R14]
ADD RSI,qword ptr [R15]
MOV RDI,RSP
JMP 0x0013fba5
LAB_0013fb97:
MOV EBP,0x3
JMP 0x0013fbd5
LAB_0013fb9e:
MOV RDI,RSP
XOR ESI,ESI
XOR EDX,EDX
LAB_0013fba5:
CALL 0x0014f3da
MOVDQA XMM0,xmmword ptr [RSP + 0x10]
MOVDQA XMM1,xmmword ptr [0x00181000]
PSHUFB XMM0,XMM1
MOVDQU xmmword ptr [R14 + -0x20],XMM0
MOVDQA XMM0,xmmword ptr [RSP]
PSHUFB XMM0,XMM1
MOVDQU xmmword ptr [R14 + -0x10],XMM0
XOR EBP,EBP
LAB_0013fbd5:
MOV EAX,EBP
MOV RDX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* evmone::instr::core::keccak256(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::keccak256(ulong *param_1,long param_2,long param_3)
{
ulong uVar1;
int8 uVar2;
long lVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 local_48 [16];
int1 local_38 [16];
if (*(int1 (*) [16])(param_1 + -2) != (int1 [16])0x0 ||
*(int1 (*) [16])(param_1 + -4) != (int1 [16])0x0) {
uVar2 = 3;
if (((((param_1[-2] != 0 || param_1[-1] != 0) || param_1[-3] != 0) || (param_1[-4] >> 0x20 != 0)
) || ((param_1[2] != 0 || param_1[3] != 0) || param_1[1] != 0)) || (*param_1 >> 0x20 != 0))
goto LAB_0013fbd5;
uVar1 = *param_1 + param_1[-4];
if (*(ulong *)(param_3 + 0x10) < uVar1) {
param_2 = grow_memory(param_2,(Memory *)(param_3 + 8),uVar1);
}
if (param_2 < 0) goto LAB_0013fbd5;
}
uVar1 = param_1[-4];
param_2 = param_2 + (uVar1 + 0x1f >> 4 & 0xfffffffffffffffe) * -3;
if (param_2 < 0) {
uVar2 = 3;
}
else {
if (uVar1 == 0) {
lVar3 = 0;
uVar1 = 0;
}
else {
lVar3 = *param_1 + *(long *)(param_3 + 8);
}
ethash_keccak256(local_48,lVar3,uVar1);
auVar5 = _DAT_00181000;
auVar4 = pshufb(local_38,_DAT_00181000);
*(int1 (*) [16])(param_1 + -4) = auVar4;
auVar5 = pshufb(local_48,auVar5);
*(int1 (*) [16])(param_1 + -2) = auVar5;
uVar2 = 0;
}
LAB_0013fbd5:
auVar5._8_8_ = param_2;
auVar5._0_8_ = uVar2;
return auVar5;
}
|
|
57,631
|
list_cons
|
eloqsql/mysys/list.c
|
LIST *list_cons(void *data, LIST *list)
{
LIST *new_charset=(LIST*) my_malloc(key_memory_LIST, sizeof(LIST),MYF(MY_FAE));
if (!new_charset)
return 0;
new_charset->data=data;
return list_add(list,new_charset);
}
|
O3
|
c
|
list_cons:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x365df1(%rip), %rax # 0x3b8c3c
movl (%rax), %edi
movl $0x18, %esi
movl $0x8, %edx
callq 0x60401
testq %rax, %rax
je 0x52e90
movq %r14, 0x10(%rax)
testq %rbx, %rbx
je 0x52e7b
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x52e84
movq %rax, 0x8(%rcx)
movq (%rbx), %rcx
jmp 0x52e86
movq $0x0, (%rax)
jmp 0x52e8c
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %rax, (%rbx)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
|
list_cons:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
lea rax, key_memory_LIST
mov edi, [rax]
mov esi, 18h
mov edx, 8
call my_malloc
test rax, rax
jz short loc_52E90
mov [rax+10h], r14
test rbx, rbx
jz short loc_52E7B
mov rcx, [rbx]
test rcx, rcx
jz short loc_52E84
mov [rcx+8], rax
mov rcx, [rbx]
jmp short loc_52E86
loc_52E7B:
mov qword ptr [rax], 0
jmp short loc_52E8C
loc_52E84:
xor ecx, ecx
loc_52E86:
mov [rax], rcx
mov [rbx], rax
loc_52E8C:
mov [rax+8], rbx
loc_52E90:
pop rbx
pop r14
pop rbp
retn
|
_QWORD * list_cons(long long a1, long long *a2)
{
_QWORD *result; // rax
long long v3; // rcx
result = (_QWORD *)my_malloc(key_memory_LIST, 24LL);
if ( result )
{
result[2] = a1;
if ( a2 )
{
if ( *a2 )
{
*(_QWORD *)(*a2 + 8) = result;
v3 = *a2;
}
else
{
v3 = 0LL;
}
*result = v3;
*a2 = (long long)result;
}
else
{
*result = 0LL;
}
result[1] = a2;
}
return result;
}
|
list_cons:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
LEA RAX,[0x4b8c3c]
MOV EDI,dword ptr [RAX]
MOV ESI,0x18
MOV EDX,0x8
CALL 0x00160401
TEST RAX,RAX
JZ 0x00152e90
MOV qword ptr [RAX + 0x10],R14
TEST RBX,RBX
JZ 0x00152e7b
MOV RCX,qword ptr [RBX]
TEST RCX,RCX
JZ 0x00152e84
MOV qword ptr [RCX + 0x8],RAX
MOV RCX,qword ptr [RBX]
JMP 0x00152e86
LAB_00152e7b:
MOV qword ptr [RAX],0x0
JMP 0x00152e8c
LAB_00152e84:
XOR ECX,ECX
LAB_00152e86:
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX],RAX
LAB_00152e8c:
MOV qword ptr [RAX + 0x8],RBX
LAB_00152e90:
POP RBX
POP R14
POP RBP
RET
|
void list_cons(long param_1,long *param_2)
{
long *plVar1;
long lVar2;
plVar1 = (long *)my_malloc(key_memory_LIST,0x18,8);
if (plVar1 != (long *)0x0) {
plVar1[2] = param_1;
if (param_2 == (long *)0x0) {
*plVar1 = 0;
}
else {
if (*param_2 == 0) {
lVar2 = 0;
}
else {
*(long **)(*param_2 + 8) = plVar1;
lVar2 = *param_2;
}
*plVar1 = lVar2;
*param_2 = (long)plVar1;
}
plVar1[1] = (long)param_2;
}
return;
}
|
|
57,632
|
my_coll_parser_scan_shift_sequence
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_shift_sequence(MY_COLL_RULE_PARSER *p)
{
MY_COLL_RULE before_extend;
memset(&p->rule.curr, 0, sizeof(p->rule.curr));
/* Scan single shift character or contraction */
if (!my_coll_parser_scan_character_list(p, p->rule.curr,
MY_UCA_MAX_CONTRACTION,
"Contraction"))
return 0;
before_extend= p->rule; /* Remember the part before "/" */
/* Append the part after "/" as expansion */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_EXTEND)
{
my_coll_parser_scan(p);
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION,
"Expansion"))
return 0;
}
else if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CONTEXT)
{
/*
We support 2-character long context sequences only:
one character is the previous context, plus the current character.
It's OK as Unicode's CLDR does not have longer examples.
*/
my_coll_parser_scan(p);
p->rule.with_context= TRUE;
if (!my_coll_parser_scan_character_list(p, p->rule.curr + 1, 1, "context"))
return 0;
}
/* Add rule to the rule list */
if (my_coll_rules_add(p->rules, &p->rule))
return 0;
p->rule= before_extend; /* Restore to the state before "/" */
return 1;
}
|
O3
|
c
|
my_coll_parser_scan_shift_sequence:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0xa0(%rdi), %rsi
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xa0(%rdi)
leaq 0x1e554(%rip), %rcx # 0x5ec91
movl $0x6, %edx
callq 0x40895
xorl %r14d, %r14d
testl %eax, %eax
je 0x40884
leaq 0x50(%r15), %rbx
leaq -0xb8(%rbp), %rdi
movl $0xa0, %edx
movq %rbx, %rsi
callq 0x24290
movl (%r15), %eax
cmpl $0x9, %eax
je 0x407b3
cmpl $0x8, %eax
jne 0x40802
leaq 0x28(%r15), %rdi
movq 0x48(%r15), %rax
movq %rax, 0x20(%r15)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
callq 0x4039b
leaq 0x1e31f(%rip), %rcx # 0x5eac5
movl $0xa, %edx
movq %r15, %rdi
movq %rbx, %rsi
jmp 0x407f5
leaq 0x28(%r15), %rdi
movq 0x48(%r15), %rax
movq %rax, 0x20(%r15)
movups 0x28(%r15), %xmm0
movups 0x38(%r15), %xmm1
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
callq 0x4039b
movb $0x1, 0xe8(%r15)
leaq 0xa8(%r15), %rsi
leaq 0x1efdb(%rip), %rcx # 0x5f7c8
movl $0x1, %edx
movq %r15, %rdi
callq 0x40895
testl %eax, %eax
je 0x40884
movq 0xf0(%r15), %r15
movq 0x10(%r15), %rcx
cmpq 0x18(%r15), %rcx
jae 0x40819
movq 0x20(%r15), %rax
jmp 0x4084a
movq 0x20(%r15), %rdi
movq 0x28(%r15), %rax
movq 0x90(%rax), %rax
addq $0x81, %rcx
movq %rcx, 0x18(%r15)
shlq $0x5, %rcx
leaq (%rcx,%rcx,4), %rsi
callq *%rax
movq %rax, 0x20(%r15)
testq %rax, %rax
je 0x40884
movq 0x10(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r15)
leaq (%rcx,%rcx,4), %rdi
shlq $0x5, %rdi
addq %rax, %rdi
movl $0xa0, %edx
movq %rbx, %rsi
callq 0x24290
leaq -0xb8(%rbp), %rsi
movl $0xa0, %edx
movq %rbx, %rdi
callq 0x24290
movl $0x1, %r14d
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
my_coll_parser_scan_shift_sequence:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0A8h
mov r15, rdi
lea rsi, [rdi+0A0h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+0C0h], xmm0
movups xmmword ptr [rdi+0B0h], xmm0
movups xmmword ptr [rdi+0A0h], xmm0
lea rcx, aContraction; "Contraction"
mov edx, 6
call my_coll_parser_scan_character_list
xor r14d, r14d
test eax, eax
jz loc_40884
lea rbx, [r15+50h]
lea rdi, [rbp+var_B8]
mov edx, 0A0h
mov rsi, rbx
call _memcpy
mov eax, [r15]
cmp eax, 9
jz short loc_407B3
cmp eax, 8
jnz loc_40802
lea rdi, [r15+28h]
mov rax, [r15+48h]
mov [r15+20h], rax
movups xmm0, xmmword ptr [r15+28h]
movups xmm1, xmmword ptr [r15+38h]
movups xmmword ptr [r15+10h], xmm1
movups xmmword ptr [r15], xmm0
call my_coll_lexem_next
lea rcx, aExpansion; "Expansion"
mov edx, 0Ah
mov rdi, r15
mov rsi, rbx
jmp short loc_407F5
loc_407B3:
lea rdi, [r15+28h]
mov rax, [r15+48h]
mov [r15+20h], rax
movups xmm0, xmmword ptr [r15+28h]
movups xmm1, xmmword ptr [r15+38h]
movups xmmword ptr [r15+10h], xmm1
movups xmmword ptr [r15], xmm0
call my_coll_lexem_next
mov byte ptr [r15+0E8h], 1
lea rsi, [r15+0A8h]
lea rcx, aCharsetsCharse_52+23h; "context"
mov edx, 1
mov rdi, r15
loc_407F5:
call my_coll_parser_scan_character_list
test eax, eax
jz loc_40884
loc_40802:
mov r15, [r15+0F0h]
mov rcx, [r15+10h]
cmp rcx, [r15+18h]
jnb short loc_40819
mov rax, [r15+20h]
jmp short loc_4084A
loc_40819:
mov rdi, [r15+20h]
mov rax, [r15+28h]
mov rax, [rax+90h]
add rcx, 81h
mov [r15+18h], rcx
shl rcx, 5
lea rsi, [rcx+rcx*4]
call rax
mov [r15+20h], rax
test rax, rax
jz short loc_40884
mov rcx, [r15+10h]
loc_4084A:
lea rdx, [rcx+1]
mov [r15+10h], rdx
lea rdi, [rcx+rcx*4]
shl rdi, 5
add rdi, rax
mov edx, 0A0h
mov rsi, rbx
call _memcpy
lea rsi, [rbp+var_B8]
mov edx, 0A0h
mov rdi, rbx
call _memcpy
mov r14d, 1
loc_40884:
mov eax, r14d
add rsp, 0A8h
pop rbx
pop r14
pop r15
pop rbp
retn
|
long long my_coll_parser_scan_shift_sequence(long long a1)
{
unsigned int v1; // r14d
long long v2; // rbx
__int128 v3; // xmm0
char *v4; // rcx
long long v5; // rdx
long long v6; // rsi
__int128 v7; // xmm0
_QWORD *v8; // r15
unsigned long long v9; // rcx
long long v10; // rax
long long v11; // rdi
long long ( *v12)(long long, long long); // rax
unsigned long long v13; // rcx
_BYTE v15[184]; // [rsp+8h] [rbp-B8h] BYREF
*(_OWORD *)(a1 + 192) = 0LL;
*(_OWORD *)(a1 + 176) = 0LL;
*(_OWORD *)(a1 + 160) = 0LL;
v1 = 0;
if ( !(unsigned int)my_coll_parser_scan_character_list(a1, a1 + 160, 6LL, "Contraction") )
return v1;
v2 = a1 + 80;
memcpy(v15, a1 + 80, 160LL);
if ( *(_DWORD *)a1 == 9 )
{
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v7 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v7;
my_coll_lexem_next(a1 + 40);
*(_BYTE *)(a1 + 232) = 1;
v6 = a1 + 168;
v4 = "context";
v5 = 1LL;
LABEL_6:
if ( !(unsigned int)my_coll_parser_scan_character_list(a1, v6, v5, v4) )
return v1;
goto LABEL_7;
}
if ( *(_DWORD *)a1 == 8 )
{
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v3 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v3;
my_coll_lexem_next(a1 + 40);
v4 = "Expansion";
v5 = 10LL;
v6 = a1 + 80;
goto LABEL_6;
}
LABEL_7:
v8 = *(_QWORD **)(a1 + 240);
v9 = v8[2];
if ( v9 < v8[3] )
{
v10 = v8[4];
LABEL_11:
v8[2] = v9 + 1;
memcpy(v10 + 160 * v9, v2, 160LL);
memcpy(v2, v15, 160LL);
return 1;
}
v11 = v8[4];
v12 = *(long long ( **)(long long, long long))(v8[5] + 144LL);
v13 = v9 + 129;
v8[3] = v13;
v10 = v12(v11, 160 * v13);
v8[4] = v10;
if ( v10 )
{
v9 = v8[2];
goto LABEL_11;
}
return v1;
}
|
my_coll_parser_scan_shift_sequence:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xa8
MOV R15,RDI
LEA RSI,[RDI + 0xa0]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0xc0],XMM0
MOVUPS xmmword ptr [RDI + 0xb0],XMM0
MOVUPS xmmword ptr [RDI + 0xa0],XMM0
LEA RCX,[0x15ec91]
MOV EDX,0x6
CALL 0x00140895
XOR R14D,R14D
TEST EAX,EAX
JZ 0x00140884
LEA RBX,[R15 + 0x50]
LEA RDI,[RBP + -0xb8]
MOV EDX,0xa0
MOV RSI,RBX
CALL 0x00124290
MOV EAX,dword ptr [R15]
CMP EAX,0x9
JZ 0x001407b3
CMP EAX,0x8
JNZ 0x00140802
LEA RDI,[R15 + 0x28]
MOV RAX,qword ptr [R15 + 0x48]
MOV qword ptr [R15 + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x28]
MOVUPS XMM1,xmmword ptr [R15 + 0x38]
MOVUPS xmmword ptr [R15 + 0x10],XMM1
MOVUPS xmmword ptr [R15],XMM0
CALL 0x0014039b
LEA RCX,[0x15eac5]
MOV EDX,0xa
MOV RDI,R15
MOV RSI,RBX
JMP 0x001407f5
LAB_001407b3:
LEA RDI,[R15 + 0x28]
MOV RAX,qword ptr [R15 + 0x48]
MOV qword ptr [R15 + 0x20],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x28]
MOVUPS XMM1,xmmword ptr [R15 + 0x38]
MOVUPS xmmword ptr [R15 + 0x10],XMM1
MOVUPS xmmword ptr [R15],XMM0
CALL 0x0014039b
MOV byte ptr [R15 + 0xe8],0x1
LEA RSI,[R15 + 0xa8]
LEA RCX,[0x15f7c8]
MOV EDX,0x1
MOV RDI,R15
LAB_001407f5:
CALL 0x00140895
TEST EAX,EAX
JZ 0x00140884
LAB_00140802:
MOV R15,qword ptr [R15 + 0xf0]
MOV RCX,qword ptr [R15 + 0x10]
CMP RCX,qword ptr [R15 + 0x18]
JNC 0x00140819
MOV RAX,qword ptr [R15 + 0x20]
JMP 0x0014084a
LAB_00140819:
MOV RDI,qword ptr [R15 + 0x20]
MOV RAX,qword ptr [R15 + 0x28]
MOV RAX,qword ptr [RAX + 0x90]
ADD RCX,0x81
MOV qword ptr [R15 + 0x18],RCX
SHL RCX,0x5
LEA RSI,[RCX + RCX*0x4]
CALL RAX
MOV qword ptr [R15 + 0x20],RAX
TEST RAX,RAX
JZ 0x00140884
MOV RCX,qword ptr [R15 + 0x10]
LAB_0014084a:
LEA RDX,[RCX + 0x1]
MOV qword ptr [R15 + 0x10],RDX
LEA RDI,[RCX + RCX*0x4]
SHL RDI,0x5
ADD RDI,RAX
MOV EDX,0xa0
MOV RSI,RBX
CALL 0x00124290
LEA RSI,[RBP + -0xb8]
MOV EDX,0xa0
MOV RDI,RBX
CALL 0x00124290
MOV R14D,0x1
LAB_00140884:
MOV EAX,R14D
ADD RSP,0xa8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 my_coll_parser_scan_shift_sequence(int *param_1)
{
int *__src;
long lVar1;
code *pcVar2;
int iVar3;
long lVar4;
char *pcVar5;
ulong uVar6;
int8 uVar7;
int *piVar8;
int1 local_c0 [160];
param_1[0x30] = 0;
param_1[0x31] = 0;
param_1[0x32] = 0;
param_1[0x33] = 0;
param_1[0x2c] = 0;
param_1[0x2d] = 0;
param_1[0x2e] = 0;
param_1[0x2f] = 0;
param_1[0x28] = 0;
param_1[0x29] = 0;
param_1[0x2a] = 0;
param_1[0x2b] = 0;
iVar3 = my_coll_parser_scan_character_list(param_1,param_1 + 0x28,6,"Contraction");
if (iVar3 == 0) {
return 0;
}
__src = param_1 + 0x14;
memcpy(local_c0,__src,0xa0);
if (*param_1 == 9) {
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
*(int1 *)(param_1 + 0x3a) = 1;
piVar8 = param_1 + 0x2a;
pcVar5 = "context";
uVar7 = 1;
}
else {
if (*param_1 != 8) goto LAB_00140802;
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
pcVar5 = "Expansion";
uVar7 = 10;
piVar8 = __src;
}
iVar3 = my_coll_parser_scan_character_list(param_1,piVar8,uVar7,pcVar5);
if (iVar3 == 0) {
return 0;
}
LAB_00140802:
lVar1 = *(long *)(param_1 + 0x3c);
uVar6 = *(ulong *)(lVar1 + 0x10);
if (uVar6 < *(ulong *)(lVar1 + 0x18)) {
lVar4 = *(long *)(lVar1 + 0x20);
}
else {
pcVar2 = *(code **)(*(long *)(lVar1 + 0x28) + 0x90);
*(ulong *)(lVar1 + 0x18) = uVar6 + 0x81;
lVar4 = (*pcVar2)(*(int8 *)(lVar1 + 0x20),(uVar6 + 0x81) * 0xa0);
*(long *)(lVar1 + 0x20) = lVar4;
if (lVar4 == 0) {
return 0;
}
uVar6 = *(ulong *)(lVar1 + 0x10);
}
*(ulong *)(lVar1 + 0x10) = uVar6 + 1;
memcpy((void *)(uVar6 * 0xa0 + lVar4),__src,0xa0);
memcpy(__src,local_c0,0xa0);
return 1;
}
|
|
57,633
|
convert_from_long
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static void convert_from_long(MYSQL_BIND *r_param, const MYSQL_FIELD *field, longlong val, my_bool is_unsigned)
{
switch (r_param->buffer_type) {
case MYSQL_TYPE_TINY:
*(uchar *)r_param->buffer= (uchar)val;
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX8) : NUMERIC_TRUNCATION(val, INT_MIN8, INT_MAX8);
r_param->buffer_length= 1;
break;
case MYSQL_TYPE_SHORT:
case MYSQL_TYPE_YEAR:
shortstore(r_param->buffer, (short)val);
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX16) : NUMERIC_TRUNCATION(val, INT_MIN16, INT_MAX16);
r_param->buffer_length= 2;
break;
case MYSQL_TYPE_LONG:
longstore(r_param->buffer, (int32)val);
*r_param->error= r_param->is_unsigned ? NUMERIC_TRUNCATION(val, 0, UINT_MAX32) : NUMERIC_TRUNCATION(val, INT_MIN32, INT_MAX32);
r_param->buffer_length= 4;
break;
case MYSQL_TYPE_LONGLONG:
*r_param->error= (val < 0 && r_param->is_unsigned != is_unsigned);
longlongstore(r_param->buffer, val);
r_param->buffer_length= 8;
break;
case MYSQL_TYPE_DOUBLE:
{
volatile double dbl;
dbl= (is_unsigned) ? ulonglong2double((ulonglong)val) : (double)val;
doublestore(r_param->buffer, dbl);
*r_param->error = (dbl != ceil(dbl)) ||
(is_unsigned ? (ulonglong )dbl != (ulonglong)val :
(longlong)dbl != (longlong)val);
r_param->buffer_length= 8;
break;
}
case MYSQL_TYPE_FLOAT:
{
volatile float fval;
fval= is_unsigned ? (float)(ulonglong)(val) : (float)val;
floatstore((uchar *)r_param->buffer, fval);
*r_param->error= (fval != ceilf(fval)) ||
(is_unsigned ? (ulonglong)fval != (ulonglong)val :
(longlong)fval != val);
r_param->buffer_length= 4;
}
break;
default:
{
char *buffer;
char *endptr;
uint len;
my_bool zf_truncated= 0;
buffer= alloca(MAX(field->length, 22));
endptr= ma_ll2str(val, buffer, is_unsigned ? 10 : -10);
len= (uint)(endptr - buffer);
/* check if field flag is zerofill */
if (field->flags & ZEROFILL_FLAG)
{
uint display_width= MAX(field->length, len);
if (display_width < r_param->buffer_length)
{
ma_bmove_upp(buffer + display_width, buffer + len, len);
/* coverity[bad_memset] */
memset((void*) buffer, (int) '0', display_width - len);
len= display_width;
}
else
zf_truncated= 1;
}
convert_froma_string(r_param, buffer, len);
*r_param->error+= zf_truncated;
}
break;
}
}
|
O3
|
c
|
convert_from_long:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movl 0x60(%rdi), %eax
decl %eax
cmpl $0xc, %eax
ja 0x244ef
leaq 0x13d16(%rip), %rcx # 0x381bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r14), %rax
movb %bl, (%rax)
movq 0x10(%r14), %rax
movb %bh, 0x1(%rax)
xorl %eax, %eax
cmpq $0x10000, %rbx # imm = 0x10000
setae %al
movswq %bx, %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %eax
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x2, 0x40(%r14)
jmp 0x247ba
movq 0x38(%r13), %rax
cmpq $0x17, %rax
movl $0x16, %ecx
cmovaeq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r12
subq %rcx, %r12
movq %r12, %rsp
testb %r15b, %r15b
movl $0xfffffff6, %eax # imm = 0xFFFFFFF6
movl $0xa, %edx
cmovel %eax, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x32988
subq %r12, %rax
testb $0x40, 0x64(%r13)
jne 0x2461e
movl %eax, %ebx
jmp 0x24672
testb %r15b, %r15b
je 0x2467a
movq %rbx, %xmm1
punpckldq 0x13d19(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x13d21(%rip), %xmm1 # 0x38280
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0 # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x2467f
testq %rbx, %rbx
js 0x24784
xorl %eax, %eax
jmp 0x2478b
movq 0x10(%r14), %rax
movb %bl, (%rax)
xorl %eax, %eax
cmpq $0x100, %rbx # imm = 0x100
setae %al
movsbq %bl, %rcx
xorl %edx, %edx
cmpq %rbx, %rcx
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %eax
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x1, 0x40(%r14)
jmp 0x247ba
movq 0x10(%r14), %rax
movb %bl, (%rax)
movq 0x10(%r14), %rax
movb %bh, 0x1(%rax)
movl %ebx, %eax
shrl $0x10, %eax
movq 0x10(%r14), %rcx
movb %al, 0x2(%rcx)
movslq %ebx, %rax
movl %ebx, %ecx
shrl $0x18, %ecx
movq 0x10(%r14), %rdx
movb %cl, 0x3(%rdx)
xorl %ecx, %ecx
movq %rbx, %rdx
shrq $0x20, %rdx
setne %cl
xorl %edx, %edx
cmpq %rbx, %rax
setne %dl
cmpb $0x0, 0x65(%r14)
cmovel %edx, %ecx
movq 0x18(%r14), %rax
movb %cl, (%rax)
jmp 0x2477a
cvtsi2ss %rbx, %xmm0
testq %rbx, %rbx
js 0x246f0
movaps %xmm0, %xmm1
jmp 0x24707
movq 0x38(%r13), %rdx
movl %eax, %ecx
cmpq %rcx, %rdx
cmovbeq %rcx, %rdx
movl %edx, %ebx
movb $0x1, %r15b
cmpq 0x40(%r14), %rbx
jae 0x247a2
testq %rcx, %rcx
je 0x24663
leaq (%rcx,%r12), %rsi
decq %rsi
negq %rcx
leaq (%rbx,%r12), %rdi
decq %rdi
xorl %r8d, %r8d
movb (%rsi,%r8), %r9b
movb %r9b, (%rdi,%r8)
decq %r8
cmpq %r8, %rcx
jne 0x24653
subl %eax, %edx
movq %r12, %rdi
movl $0x30, %esi
callq 0x13260
xorl %r15d, %r15d
jmp 0x247a5
cvtsi2sd %rbx, %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movsd %xmm0, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x130e0
movb $0x1, %al
movsd -0x40(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x246e5
jp 0x246e5
movsd -0x38(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
cvttsd2si %xmm0, %rdx
subsd 0x134bf(%rip), %xmm0 # 0x37b88
cvttsd2si %xmm0, %rsi
sarq $0x3f, %rcx
andq %rcx, %rsi
orq %rax, %rsi
testb %r15b, %r15b
cmoveq %rdx, %rsi
cmpq %rbx, %rsi
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
jmp 0x24798
movq %rbx, %rax
shrq %rax
movl %ebx, %ecx
andl $0x1, %ecx
orq %rax, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
testb %r15b, %r15b
je 0x2470f
movaps %xmm1, %xmm0
movss %xmm0, -0x38(%rbp)
movq 0x10(%r14), %rax
movss %xmm0, (%rax)
movss -0x38(%rbp), %xmm0
movss %xmm0, -0x40(%rbp)
movss -0x38(%rbp), %xmm0
callq 0x13270
movb $0x1, %al
movss -0x40(%rbp), %xmm1
ucomiss %xmm0, %xmm1
jne 0x24774
jp 0x24774
movss -0x38(%rbp), %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
cvttss2si %xmm0, %rdx
subss 0xf8ac(%rip), %xmm0 # 0x34004
cvttss2si %xmm0, %rsi
sarq $0x3f, %rcx
andq %rcx, %rsi
orq %rax, %rsi
testb %r15b, %r15b
cmoveq %rdx, %rsi
cmpq %rbx, %rsi
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq $0x4, 0x40(%r14)
jmp 0x247ba
cmpb %r15b, 0x65(%r14)
setne %al
movq 0x18(%r14), %rcx
movb %al, (%rcx)
movq 0x10(%r14), %rax
movq %rbx, (%rax)
movq $0x8, 0x40(%r14)
jmp 0x247ba
movq %rcx, %rbx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x247dd
movq 0x18(%r14), %rax
addb %r15b, (%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x247d8
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
|
convert_from_long:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, ecx
mov rbx, rdx
mov r13, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov eax, [rdi+60h]
dec eax; switch 13 cases
cmp eax, 0Ch
ja short def_244AD; jumptable 00000000000244AD default case, cases 6,7,9-12
lea rcx, jpt_244AD
movsxd rax, ds:(jpt_244AD - 381BCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_244AF:
mov rax, [r14+10h]; jumptable 00000000000244AD cases 2,13
mov [rax], bl
mov rax, [r14+10h]
mov [rax+1], bh
xor eax, eax
cmp rbx, 10000h
setnb al
movsx rcx, bx
xor edx, edx
cmp rcx, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz eax, edx
mov rcx, [r14+18h]
mov [rcx], al
mov qword ptr [r14+40h], 2
jmp loc_247BA
def_244AD:
mov rax, [r13+38h]; jumptable 00000000000244AD default case, cases 6,7,9-12
cmp rax, 17h
mov ecx, 16h
cmovnb rcx, rax
add rcx, 0Fh
and rcx, 0FFFFFFFFFFFFFFF0h
mov r12, rsp
sub r12, rcx
mov rsp, r12
test r15b, r15b
mov eax, 0FFFFFFF6h
mov edx, 0Ah
cmovz edx, eax
mov rdi, rbx
mov rsi, r12
call ma_ll2str
sub rax, r12
test byte ptr [r13+64h], 40h
jnz loc_2461E
mov ebx, eax
jmp loc_24672
loc_24541:
test r15b, r15b; jumptable 00000000000244AD case 5
jz loc_2467A
movq xmm1, rbx
punpckldq xmm1, cs:xmmword_38270
subpd xmm1, cs:xmmword_38280
movapd xmm0, xmm1
unpckhpd xmm0, xmm1
addsd xmm0, xmm1
jmp loc_2467F
loc_24570:
test rbx, rbx; jumptable 00000000000244AD case 8
js loc_24784
xor eax, eax
jmp loc_2478B
loc_24580:
mov rax, [r14+10h]; jumptable 00000000000244AD case 1
mov [rax], bl
xor eax, eax
cmp rbx, 100h
setnb al
movsx rcx, bl
xor edx, edx
cmp rcx, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz eax, edx
mov rcx, [r14+18h]
mov [rcx], al
mov qword ptr [r14+40h], 1
jmp loc_247BA
loc_245B9:
mov rax, [r14+10h]; jumptable 00000000000244AD case 3
mov [rax], bl
mov rax, [r14+10h]
mov [rax+1], bh
mov eax, ebx
shr eax, 10h
mov rcx, [r14+10h]
mov [rcx+2], al
movsxd rax, ebx
mov ecx, ebx
shr ecx, 18h
mov rdx, [r14+10h]
mov [rdx+3], cl
xor ecx, ecx
mov rdx, rbx
shr rdx, 20h
setnz cl
xor edx, edx
cmp rax, rbx
setnz dl
cmp byte ptr [r14+65h], 0
cmovz ecx, edx
mov rax, [r14+18h]
mov [rax], cl
jmp loc_2477A
loc_24608:
cvtsi2ss xmm0, rbx; jumptable 00000000000244AD case 4
test rbx, rbx
js loc_246F0
movaps xmm1, xmm0
jmp loc_24707
loc_2461E:
mov rdx, [r13+38h]
mov ecx, eax
cmp rdx, rcx
cmovbe rdx, rcx
mov ebx, edx
mov r15b, 1
cmp rbx, [r14+40h]
jnb loc_247A2
test rcx, rcx
jz short loc_24663
lea rsi, [rcx+r12]
dec rsi
neg rcx
lea rdi, [rbx+r12]
dec rdi
xor r8d, r8d
loc_24653:
mov r9b, [rsi+r8]
mov [rdi+r8], r9b
dec r8
cmp rcx, r8
jnz short loc_24653
loc_24663:
sub edx, eax
mov rdi, r12
mov esi, 30h ; '0'
call _memset
loc_24672:
xor r15d, r15d
jmp loc_247A5
loc_2467A:
cvtsi2sd xmm0, rbx
loc_2467F:
movsd [rbp+var_38], xmm0
mov rax, [r14+10h]
movsd qword ptr [rax], xmm0
movsd xmm0, [rbp+var_38]
movsd [rbp+var_40], xmm0
movsd xmm0, [rbp+var_38]
call _ceil
mov al, 1
movsd xmm1, [rbp+var_40]
ucomisd xmm1, xmm0
jnz short loc_246E5
jp short loc_246E5
movsd xmm0, [rbp+var_38]
cvttsd2si rax, xmm0
mov rcx, rax
cvttsd2si rdx, xmm0
subsd xmm0, cs:qword_37B88
cvttsd2si rsi, xmm0
sar rcx, 3Fh
and rsi, rcx
or rsi, rax
test r15b, r15b
cmovz rsi, rdx
cmp rsi, rbx
setnz al
loc_246E5:
mov rcx, [r14+18h]
mov [rcx], al
jmp loc_24798
loc_246F0:
mov rax, rbx
shr rax, 1
mov ecx, ebx
and ecx, 1
or rcx, rax
cvtsi2ss xmm1, rcx
addss xmm1, xmm1
loc_24707:
test r15b, r15b
jz short loc_2470F
movaps xmm0, xmm1
loc_2470F:
movss dword ptr [rbp+var_38], xmm0
mov rax, [r14+10h]
movss dword ptr [rax], xmm0
movss xmm0, dword ptr [rbp+var_38]
movss dword ptr [rbp+var_40], xmm0
movss xmm0, dword ptr [rbp+var_38]
call _ceilf
mov al, 1
movss xmm1, dword ptr [rbp+var_40]
ucomiss xmm1, xmm0
jnz short loc_24774
jp short loc_24774
movss xmm0, dword ptr [rbp+var_38]
cvttss2si rax, xmm0
mov rcx, rax
cvttss2si rdx, xmm0
subss xmm0, cs:dword_34004
cvttss2si rsi, xmm0
sar rcx, 3Fh
and rsi, rcx
or rsi, rax
test r15b, r15b
cmovz rsi, rdx
cmp rsi, rbx
setnz al
loc_24774:
mov rcx, [r14+18h]
mov [rcx], al
loc_2477A:
mov qword ptr [r14+40h], 4
jmp short loc_247BA
loc_24784:
cmp [r14+65h], r15b
setnz al
loc_2478B:
mov rcx, [r14+18h]
mov [rcx], al
mov rax, [r14+10h]
mov [rax], rbx
loc_24798:
mov qword ptr [r14+40h], 8
jmp short loc_247BA
loc_247A2:
mov rbx, rcx
loc_247A5:
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call convert_froma_string
mov rax, [r14+18h]
add [rax], r15b
loc_247BA:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_247D8
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_247D8:
call ___stack_chk_fail
|
unsigned long long convert_from_long(
long long a1,
long long a2,
unsigned long long a3,
unsigned __int8 a4,
double a5,
double a6)
{
bool v8; // al
bool v9; // dl
long long v10; // rcx
unsigned long long v11; // rcx
char *v12; // r12
long long v13; // rdx
unsigned int v14; // eax
long long v15; // rbx
__m128d v16; // xmm1
double v17; // xmm0_8
bool v18; // al
bool v19; // al
bool v20; // dl
bool v21; // cl
bool v22; // dl
unsigned long long v23; // rdx
char v24; // r15
long long v25; // r8
double v26; // xmm0_8
bool v27; // al
long long v28; // rsi
float v29; // xmm0_4
bool v30; // al
long long v31; // rsi
double v33; // [rsp+0h] [rbp-40h] BYREF
double v34; // [rsp+8h] [rbp-38h]
unsigned long long v35; // [rsp+10h] [rbp-30h]
v35 = __readfsqword(0x28u);
switch ( *(_DWORD *)(a1 + 96) )
{
case 1:
**(_BYTE **)(a1 + 16) = a3;
v19 = a3 >= 0x100;
v20 = (char)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v19 = v20;
**(_BYTE **)(a1 + 24) = v19;
*(_QWORD *)(a1 + 64) = 1LL;
return __readfsqword(0x28u);
case 2:
case 0xD:
**(_WORD **)(a1 + 16) = a3;
v8 = a3 >= 0x10000;
v9 = (__int16)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v8 = v9;
**(_BYTE **)(a1 + 24) = v8;
*(_QWORD *)(a1 + 64) = 2LL;
return __readfsqword(0x28u);
case 3:
**(_WORD **)(a1 + 16) = a3;
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 2LL) = BYTE2(a3);
*(_BYTE *)(*(_QWORD *)(a1 + 16) + 3LL) = BYTE3(a3);
v21 = HIDWORD(a3) != 0;
v22 = (int)a3 != a3;
if ( !*(_BYTE *)(a1 + 101) )
v21 = v22;
**(_BYTE **)(a1 + 24) = v21;
goto LABEL_45;
case 4:
*(float *)&a5 = (float)(int)a3;
if ( (a3 & 0x8000000000000000LL) != 0LL )
*(float *)&a6 = (float)(int)((a3 >> 1) | a3 & 1) + (float)(int)((a3 >> 1) | a3 & 1);
else
a6 = a5;
if ( a4 )
LODWORD(a5) = LODWORD(a6);
LODWORD(v34) = LODWORD(a5);
**(_DWORD **)(a1 + 16) = LODWORD(a5);
LODWORD(v33) = LODWORD(v34);
v29 = ceilf(*(float *)&v34, a6);
v30 = 1;
if ( *(float *)&v34 == v29 )
{
v31 = (unsigned int)(int)*(float *)&v34;
if ( !a4 )
v31 = (unsigned int)(int)*(float *)&v34;
v30 = v31 != a3;
}
**(_BYTE **)(a1 + 24) = v30;
LABEL_45:
*(_QWORD *)(a1 + 64) = 4LL;
return __readfsqword(0x28u);
case 5:
if ( a4 )
{
v16 = _mm_sub_pd((__m128d)_mm_unpacklo_epi32((__m128i)a3, (__m128i)xmmword_38270), (__m128d)xmmword_38280);
v17 = _mm_unpackhi_pd(v16, v16).m128d_f64[0] + v16.m128d_f64[0];
}
else
{
v17 = (double)(int)a3;
}
v34 = v17;
**(double **)(a1 + 16) = v17;
v33 = v34;
v26 = ceil(v34);
v27 = 1;
if ( v34 == v26 )
{
v28 = (unsigned int)(int)v34;
if ( !a4 )
v28 = (unsigned int)(int)v34;
v27 = v28 != a3;
}
**(_BYTE **)(a1 + 24) = v27;
goto LABEL_48;
case 8:
v18 = (a3 & 0x8000000000000000LL) != 0LL && *(_BYTE *)(a1 + 101) != a4;
**(_BYTE **)(a1 + 24) = v18;
**(_QWORD **)(a1 + 16) = a3;
LABEL_48:
*(_QWORD *)(a1 + 64) = 8LL;
return __readfsqword(0x28u);
default:
v10 = 22LL;
if ( *(_QWORD *)(a2 + 56) >= 0x17uLL )
v10 = *(_QWORD *)(a2 + 56);
v11 = (v10 + 15) & 0xFFFFFFFFFFFFFFF0LL;
v12 = (char *)&v33 - v11;
v13 = 10LL;
if ( !a4 )
v13 = 4294967286LL;
v14 = ma_ll2str(a3, (char *)&v33 - v11, v13) - (_DWORD)v12;
if ( (*(_BYTE *)(a2 + 100) & 0x40) == 0 )
{
v15 = v14;
LABEL_30:
v24 = 0;
goto LABEL_50;
}
v23 = *(_QWORD *)(a2 + 56);
if ( v23 <= v14 )
LODWORD(v23) = v14;
v15 = (unsigned int)v23;
v24 = 1;
if ( (unsigned long long)(unsigned int)v23 < *(_QWORD *)(a1 + 64) )
{
if ( v14 )
{
v25 = 0LL;
do
{
v12[(unsigned int)v23 - 1 + v25] = v12[v14 - 1 + v25];
--v25;
}
while ( -(long long)v14 != v25 );
}
memset(v12, 48LL, (unsigned int)v23 - v14);
goto LABEL_30;
}
v15 = v14;
LABEL_50:
convert_froma_string(a1, v12, v15);
**(_BYTE **)(a1 + 24) += v24;
return __readfsqword(0x28u);
}
}
|
convert_from_long:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ECX
MOV RBX,RDX
MOV R13,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RDI + 0x60]
DEC EAX
CMP EAX,0xc
JA 0x001244ef
LEA RCX,[0x1381bc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_2:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX + 0x1],BH
XOR EAX,EAX
CMP RBX,0x10000
SETNC AL
MOVSX RCX,BX
XOR EDX,EDX
CMP RCX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ EAX,EDX
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV qword ptr [R14 + 0x40],0x2
JMP 0x001247ba
caseD_6:
MOV RAX,qword ptr [R13 + 0x38]
CMP RAX,0x17
MOV ECX,0x16
CMOVNC RCX,RAX
ADD RCX,0xf
AND RCX,-0x10
MOV R12,RSP
SUB R12,RCX
MOV RSP,R12
TEST R15B,R15B
MOV EAX,0xfffffff6
MOV EDX,0xa
CMOVZ EDX,EAX
MOV RDI,RBX
MOV RSI,R12
CALL 0x00132988
SUB RAX,R12
TEST byte ptr [R13 + 0x64],0x40
JNZ 0x0012461e
MOV EBX,EAX
JMP 0x00124672
caseD_5:
TEST R15B,R15B
JZ 0x0012467a
MOVQ XMM1,RBX
PUNPCKLDQ XMM1,xmmword ptr [0x00138270]
SUBPD XMM1,xmmword ptr [0x00138280]
MOVAPD XMM0,XMM1
UNPCKHPD XMM0,XMM1
ADDSD XMM0,XMM1
JMP 0x0012467f
caseD_8:
TEST RBX,RBX
JS 0x00124784
XOR EAX,EAX
JMP 0x0012478b
caseD_1:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
XOR EAX,EAX
CMP RBX,0x100
SETNC AL
MOVSX RCX,BL
XOR EDX,EDX
CMP RCX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ EAX,EDX
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV qword ptr [R14 + 0x40],0x1
JMP 0x001247ba
caseD_3:
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX],BL
MOV RAX,qword ptr [R14 + 0x10]
MOV byte ptr [RAX + 0x1],BH
MOV EAX,EBX
SHR EAX,0x10
MOV RCX,qword ptr [R14 + 0x10]
MOV byte ptr [RCX + 0x2],AL
MOVSXD RAX,EBX
MOV ECX,EBX
SHR ECX,0x18
MOV RDX,qword ptr [R14 + 0x10]
MOV byte ptr [RDX + 0x3],CL
XOR ECX,ECX
MOV RDX,RBX
SHR RDX,0x20
SETNZ CL
XOR EDX,EDX
CMP RAX,RBX
SETNZ DL
CMP byte ptr [R14 + 0x65],0x0
CMOVZ ECX,EDX
MOV RAX,qword ptr [R14 + 0x18]
MOV byte ptr [RAX],CL
JMP 0x0012477a
caseD_4:
CVTSI2SS XMM0,RBX
TEST RBX,RBX
JS 0x001246f0
MOVAPS XMM1,XMM0
JMP 0x00124707
LAB_0012461e:
MOV RDX,qword ptr [R13 + 0x38]
MOV ECX,EAX
CMP RDX,RCX
CMOVBE RDX,RCX
MOV EBX,EDX
MOV R15B,0x1
CMP RBX,qword ptr [R14 + 0x40]
JNC 0x001247a2
TEST RCX,RCX
JZ 0x00124663
LEA RSI,[RCX + R12*0x1]
DEC RSI
NEG RCX
LEA RDI,[RBX + R12*0x1]
DEC RDI
XOR R8D,R8D
LAB_00124653:
MOV R9B,byte ptr [RSI + R8*0x1]
MOV byte ptr [RDI + R8*0x1],R9B
DEC R8
CMP RCX,R8
JNZ 0x00124653
LAB_00124663:
SUB EDX,EAX
MOV RDI,R12
MOV ESI,0x30
CALL 0x00113260
LAB_00124672:
XOR R15D,R15D
JMP 0x001247a5
LAB_0012467a:
CVTSI2SD XMM0,RBX
LAB_0012467f:
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [R14 + 0x10]
MOVSD qword ptr [RAX],XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD qword ptr [RBP + -0x40],XMM0
MOVSD XMM0,qword ptr [RBP + -0x38]
CALL 0x001130e0
MOV AL,0x1
MOVSD XMM1,qword ptr [RBP + -0x40]
UCOMISD XMM1,XMM0
JNZ 0x001246e5
JP 0x001246e5
MOVSD XMM0,qword ptr [RBP + -0x38]
CVTTSD2SI RAX,XMM0
MOV RCX,RAX
CVTTSD2SI RDX,XMM0
SUBSD XMM0,qword ptr [0x00137b88]
CVTTSD2SI RSI,XMM0
SAR RCX,0x3f
AND RSI,RCX
OR RSI,RAX
TEST R15B,R15B
CMOVZ RSI,RDX
CMP RSI,RBX
SETNZ AL
LAB_001246e5:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
JMP 0x00124798
LAB_001246f0:
MOV RAX,RBX
SHR RAX,0x1
MOV ECX,EBX
AND ECX,0x1
OR RCX,RAX
CVTSI2SS XMM1,RCX
ADDSS XMM1,XMM1
LAB_00124707:
TEST R15B,R15B
JZ 0x0012470f
MOVAPS XMM0,XMM1
LAB_0012470f:
MOVSS dword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [R14 + 0x10]
MOVSS dword ptr [RAX],XMM0
MOVSS XMM0,dword ptr [RBP + -0x38]
MOVSS dword ptr [RBP + -0x40],XMM0
MOVSS XMM0,dword ptr [RBP + -0x38]
CALL 0x00113270
MOV AL,0x1
MOVSS XMM1,dword ptr [RBP + -0x40]
UCOMISS XMM1,XMM0
JNZ 0x00124774
JP 0x00124774
MOVSS XMM0,dword ptr [RBP + -0x38]
CVTTSS2SI RAX,XMM0
MOV RCX,RAX
CVTTSS2SI RDX,XMM0
SUBSS XMM0,dword ptr [0x00134004]
CVTTSS2SI RSI,XMM0
SAR RCX,0x3f
AND RSI,RCX
OR RSI,RAX
TEST R15B,R15B
CMOVZ RSI,RDX
CMP RSI,RBX
SETNZ AL
LAB_00124774:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
LAB_0012477a:
MOV qword ptr [R14 + 0x40],0x4
JMP 0x001247ba
LAB_00124784:
CMP byte ptr [R14 + 0x65],R15B
SETNZ AL
LAB_0012478b:
MOV RCX,qword ptr [R14 + 0x18]
MOV byte ptr [RCX],AL
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RAX],RBX
LAB_00124798:
MOV qword ptr [R14 + 0x40],0x8
JMP 0x001247ba
LAB_001247a2:
MOV RBX,RCX
LAB_001247a5:
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x001247dd
MOV RAX,qword ptr [R14 + 0x18]
ADD byte ptr [RAX],R15B
LAB_001247ba:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001247d8
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001247d8:
CALL 0x00113500
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void convert_from_long(long param_1,long param_2,ulong param_3,char param_4)
{
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int8 uVar5;
ulong uVar6;
char cVar7;
int1 uVar9;
ulong uVar8;
double *__s;
long in_FS_OFFSET;
bool bVar10;
float fVar11;
double dVar12;
int1 auVar13 [16];
int8 uStack_50;
double local_48;
double local_40;
long local_38;
__s = &local_48;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
cVar7 = (char)param_3;
uVar9 = (int1)(param_3 >> 8);
switch(*(int4 *)(param_1 + 0x60)) {
case 1:
**(char **)(param_1 + 0x10) = cVar7;
bVar10 = 0xff < param_3;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)cVar7 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
*(int8 *)(param_1 + 0x40) = 1;
break;
case 2:
case 0xd:
**(char **)(param_1 + 0x10) = cVar7;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar9;
bVar10 = 0xffff < param_3;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)(short)param_3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
*(int8 *)(param_1 + 0x40) = 2;
__s = &local_48;
break;
case 3:
**(char **)(param_1 + 0x10) = cVar7;
*(int1 *)(*(long *)(param_1 + 0x10) + 1) = uVar9;
*(char *)(*(long *)(param_1 + 0x10) + 2) = (char)(param_3 >> 0x10);
*(char *)(*(long *)(param_1 + 0x10) + 3) = (char)(param_3 >> 0x18);
bVar10 = param_3 >> 0x20 != 0;
if (*(char *)(param_1 + 0x65) == '\0') {
bVar10 = (long)(int)param_3 != param_3;
}
*(bool *)*(int8 *)(param_1 + 0x18) = bVar10;
goto LAB_0012477a;
case 4:
fVar11 = (float)(long)param_3;
if (param_4 != '\0') {
fVar11 = (float)param_3;
}
local_40 = (double)CONCAT44(local_40._4_4_,fVar11);
**(float **)(param_1 + 0x10) = fVar11;
local_48 = (double)CONCAT44(local_48._4_4_,fVar11);
uStack_50 = 0x124730;
fVar11 = ceilf(fVar11);
bVar10 = true;
if ((local_48._0_4_ == fVar11) && (!NAN(local_48._0_4_) && !NAN(fVar11))) {
uVar3 = (long)(local_40._0_4_ - _DAT_00134004) & (long)local_40._0_4_ >> 0x3f |
(long)local_40._0_4_;
if (param_4 == '\0') {
uVar3 = (long)local_40._0_4_;
}
bVar10 = uVar3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
LAB_0012477a:
*(int8 *)(param_1 + 0x40) = 4;
__s = &local_48;
break;
case 5:
if (param_4 == '\0') {
local_48 = (double)(long)param_3;
}
else {
auVar13._8_4_ = (int)(param_3 >> 0x20);
auVar13._0_8_ = param_3;
auVar13._12_4_ = _UNK_00138274;
local_48 = (auVar13._8_8_ - _UNK_00138288) +
((double)CONCAT44(_DAT_00138270,(int)param_3) - _DAT_00138280);
}
**(double **)(param_1 + 0x10) = local_48;
uStack_50 = 0x1246a0;
local_40 = local_48;
dVar12 = ceil(local_48);
bVar10 = true;
if ((local_48 == dVar12) && (!NAN(local_48) && !NAN(dVar12))) {
uVar3 = (long)(local_40 - _DAT_00137b88) & (long)local_40 >> 0x3f | (long)local_40;
if (param_4 == '\0') {
uVar3 = (long)local_40;
}
bVar10 = uVar3 != param_3;
}
**(int1 **)(param_1 + 0x18) = bVar10;
goto LAB_00124798;
default:
uVar3 = 0x16;
if (0x16 < *(ulong *)(param_2 + 0x38)) {
uVar3 = *(ulong *)(param_2 + 0x38);
}
lVar1 = -(uVar3 + 0xf & 0xfffffffffffffff0);
__s = (double *)((long)&local_48 + lVar1);
uVar5 = 10;
if (param_4 == '\0') {
uVar5 = 0xfffffff6;
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x12452c;
lVar2 = ma_ll2str(param_3,__s,uVar5);
uVar3 = lVar2 - (long)__s;
if ((*(byte *)(param_2 + 100) & 0x40) == 0) {
uVar4 = uVar3 & 0xffffffff;
LAB_00124672:
cVar7 = '\0';
}
else {
uVar4 = uVar3 & 0xffffffff;
uVar6 = *(ulong *)(param_2 + 0x38);
if (*(ulong *)(param_2 + 0x38) <= uVar4) {
uVar6 = uVar4;
}
uVar8 = uVar6 & 0xffffffff;
cVar7 = '\x01';
if (uVar8 < *(ulong *)(param_1 + 0x40)) {
if (uVar4 != 0) {
lVar2 = 0;
do {
*(int1 *)((long)__s + lVar2 + (uVar8 - 1)) =
*(int1 *)((long)__s + lVar2 + (uVar4 - 1));
lVar2 = lVar2 + -1;
} while (-lVar2 != uVar4);
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x124672;
memset(__s,0x30,(ulong)(uint)((int)uVar6 - (int)uVar3));
uVar4 = uVar8;
goto LAB_00124672;
}
}
*(int8 *)((long)&uStack_50 + lVar1) = 0x1247b3;
convert_froma_string(param_1,__s,uVar4);
**(char **)(param_1 + 0x18) = **(char **)(param_1 + 0x18) + cVar7;
break;
case 8:
if ((long)param_3 < 0) {
bVar10 = *(char *)(param_1 + 0x65) != param_4;
}
else {
bVar10 = false;
}
**(int1 **)(param_1 + 0x18) = bVar10;
**(ulong **)(param_1 + 0x10) = param_3;
LAB_00124798:
*(int8 *)(param_1 + 0x40) = 8;
__s = &local_48;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
*(code **)((long)__s + -8) = convert_froma_string;
__stack_chk_fail();
}
|
|
57,634
|
my_wc_mb_latin1
|
eloqsql/strings/ctype-latin1.c
|
static
int my_wc_mb_latin1(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
if (wc > 0xFFFF)
return MY_CS_ILUNI;
pl= uni_to_cs[wc >> 8];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
}
|
O0
|
c
|
my_wc_mb_latin1:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3e05a
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3e0e1
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x3e06d
movl $0x0, -0x4(%rbp)
jmp 0x3e0e1
movq -0x18(%rbp), %rcx
shrq $0x8, %rcx
leaq 0x187354(%rip), %rax # 0x1c53d0
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x3e0a3
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0xff, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
jmp 0x3e0aa
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x3e0aa
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x35(%rbp)
jne 0x3e0ce
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_wc_mb_latin1:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3E05A
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_3E0E1
loc_3E05A:
cmp [rbp+var_18], 0FFFFh
jbe short loc_3E06D
mov [rbp+var_4], 0
jmp short loc_3E0E1
loc_3E06D:
mov rcx, [rbp+var_18]
shr rcx, 8
lea rax, uni_to_cs
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_3E0A3
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
and rcx, 0FFh
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
jmp short loc_3E0AA
loc_3E0A3:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_3E0AA:
mov eax, [rbp+var_34]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rcx, [rbp+var_20]
xor eax, eax
cmp byte ptr [rcx], 0
mov [rbp+var_35], al
jnz short loc_3E0CE
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_35], al
loc_3E0CE:
mov dl, [rbp+var_35]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_3E0E1:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_latin1(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
bool v5; // [rsp+1h] [rbp-35h]
char v6; // [rsp+2h] [rbp-34h]
long long v7; // [rsp+6h] [rbp-30h]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 <= 0xFFFF )
{
v7 = (long long)*(&uni_to_cs + (a2 >> 8));
if ( v7 )
v6 = *(_BYTE *)(v7 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
v5 = 0;
if ( !*a3 )
v5 = a2 != 0;
return !v5;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_latin1:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013e05a
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013e0e1
LAB_0013e05a:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x0013e06d
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013e0e1
LAB_0013e06d:
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x8
LEA RAX,[0x2c53d0]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0013e0a3
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
AND RCX,0xff
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0013e0aa
LAB_0013e0a3:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0013e0aa
LAB_0013e0aa:
MOV EAX,dword ptr [RBP + -0x34]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP byte ptr [RCX],0x0
MOV byte ptr [RBP + -0x35],AL
JNZ 0x0013e0ce
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0013e0ce:
MOV DL,byte ptr [RBP + -0x35]
MOV EAX,0x1
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0013e0e1:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint my_wc_mb_latin1(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
uint local_c;
if (param_3 < param_4) {
if (param_2 < 0x10000) {
if (*(long *)(uni_to_cs + (param_2 >> 8) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
local_c = (uint)(*param_3 != '\0' || param_2 == 0);
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
57,635
|
my_getwd
|
eloqsql/mysys/my_getwd.c
|
int my_getwd(char * buf, size_t size, myf MyFlags)
{
char * pos;
DBUG_ENTER("my_getwd");
DBUG_PRINT("my",("buf:%p size: %u MyFlags %lu",
buf, (uint) size, MyFlags));
if (size < 1)
DBUG_RETURN(-1);
if (curr_dir[0]) /* Current pos is saved here */
(void) strmake(buf,&curr_dir[0],size-1);
else
{
#if defined(HAVE_GETCWD)
if (size < 2)
DBUG_RETURN(-1);
if (!getcwd(buf,(uint) (size-2)) && MyFlags & MY_WME)
{
my_errno=errno;
my_error(EE_GETWD,MYF(ME_BELL),errno);
DBUG_RETURN(-1);
}
#elif defined(HAVE_GETWD)
{
char pathname[MAXPATHLEN];
getwd(pathname);
strmake(buf,pathname,size-1);
}
#else
#error "No way to get current directory"
#endif
if (*((pos=strend(buf))-1) != FN_LIBCHAR) /* End with FN_LIBCHAR */
{
pos[0]= FN_LIBCHAR;
pos[1]=0;
}
(void) strmake(&curr_dir[0],buf, (size_t) (FN_REFLEN-1));
}
DBUG_RETURN(0);
}
|
O3
|
c
|
my_getwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2f749
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x349998(%rip), %rax # 0x379080
cmpb $0x0, (%rax)
je 0x2f703
decq %rdx
leaq 0x349989(%rip), %rsi # 0x379080
movq %r14, %rdi
callq 0x631d4
xorl %ebx, %ebx
jmp 0x2f749
cmpq $0x1, %rdx
je 0x2f749
addl $-0x2, %edx
movq %r14, %rdi
movq %rdx, %rsi
callq 0x241c0
testb $0x10, %r15b
je 0x2f756
testq %rax, %rax
jne 0x2f756
callq 0x24050
movq %rax, %r14
movl (%rax), %r15d
callq 0x3193e
movl %r15d, (%rax)
movl (%r14), %edx
movl $0x4, %esi
movl $0x10, %edi
xorl %eax, %eax
callq 0x2cce7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x6318c
cmpb $0x2f, -0x1(%rax)
je 0x2f769
movw $0x2f, (%rax)
leaq 0x349910(%rip), %rdi # 0x379080
movl $0x1ff, %edx # imm = 0x1FF
movq %r14, %rsi
jmp 0x2f6fa
|
my_getwd:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov ebx, 0FFFFFFFFh
test rsi, rsi
jz short loc_2F749
mov r15, rdx
mov rdx, rsi
mov r14, rdi
lea rax, curr_dir
cmp byte ptr [rax], 0
jz short loc_2F703
dec rdx
lea rsi, curr_dir
mov rdi, r14
loc_2F6FA:
call strmake
xor ebx, ebx
jmp short loc_2F749
loc_2F703:
cmp rdx, 1
jz short loc_2F749
add edx, 0FFFFFFFEh
mov rdi, r14
mov rsi, rdx
call _getcwd
test r15b, 10h
jz short loc_2F756
test rax, rax
jnz short loc_2F756
call ___errno_location
mov r14, rax
mov r15d, [rax]
call _my_thread_var
mov [rax], r15d
mov edx, [r14]
mov esi, 4
mov edi, 10h
xor eax, eax
call my_error
loc_2F749:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_2F756:
mov rdi, r14
call strend
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_2F769
mov word ptr [rax], 2Fh ; '/'
loc_2F769:
lea rdi, curr_dir
mov edx, 1FFh
mov rsi, r14
jmp short loc_2F6FA
|
long long my_getwd(_BYTE *a1, long long a2, char a3)
{
unsigned int v3; // ebx
_BYTE *v5; // r14
long long v6; // rdx
_BYTE *v7; // rsi
long long v8; // rsi
long long v9; // rax
unsigned int *v10; // r14
unsigned int v11; // r15d
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
long long v15; // r9
_WORD *v17; // rax
v3 = -1;
if ( a2 )
{
v5 = a1;
if ( curr_dir[0] )
{
v6 = a2 - 1;
v7 = curr_dir;
}
else
{
if ( a2 == 1 )
return v3;
v8 = (unsigned int)(a2 - 2);
v9 = getcwd(a1, v8);
if ( (a3 & 0x10) != 0 && !v9 )
{
v10 = (unsigned int *)__errno_location(a1);
v11 = *v10;
*(_DWORD *)my_thread_var(a1, v8, v12, v13, v14, v15) = v11;
my_error(0x10u, 4LL, *v10);
return v3;
}
v17 = (_WORD *)strend(a1);
if ( *((_BYTE *)v17 - 1) != 47 )
*v17 = 47;
a1 = curr_dir;
v6 = 511LL;
v7 = v5;
}
strmake(a1, v7, v6);
return 0;
}
return v3;
}
|
my_getwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,0xffffffff
TEST RSI,RSI
JZ 0x0012f749
MOV R15,RDX
MOV RDX,RSI
MOV R14,RDI
LEA RAX,[0x479080]
CMP byte ptr [RAX],0x0
JZ 0x0012f703
DEC RDX
LEA RSI,[0x479080]
MOV RDI,R14
LAB_0012f6fa:
CALL 0x001631d4
XOR EBX,EBX
JMP 0x0012f749
LAB_0012f703:
CMP RDX,0x1
JZ 0x0012f749
ADD EDX,-0x2
MOV RDI,R14
MOV RSI,RDX
CALL 0x001241c0
TEST R15B,0x10
JZ 0x0012f756
TEST RAX,RAX
JNZ 0x0012f756
CALL 0x00124050
MOV R14,RAX
MOV R15D,dword ptr [RAX]
CALL 0x0013193e
MOV dword ptr [RAX],R15D
MOV EDX,dword ptr [R14]
MOV ESI,0x4
MOV EDI,0x10
XOR EAX,EAX
CALL 0x0012cce7
LAB_0012f749:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0012f756:
MOV RDI,R14
CALL 0x0016318c
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0012f769
MOV word ptr [RAX],0x2f
LAB_0012f769:
LEA RDI,[0x479080]
MOV EDX,0x1ff
MOV RSI,R14
JMP 0x0012f6fa
|
int8 my_getwd(char *param_1,long param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int *piVar4;
int2 *puVar5;
char *pcVar6;
if (param_2 == 0) {
return 0xffffffff;
}
if (curr_dir == '\0') {
if (param_2 == 1) {
return 0xffffffff;
}
pcVar2 = getcwd(param_1,(ulong)((int)param_2 - 2));
if (((param_3 & 0x10) != 0) && (pcVar2 == (char *)0x0)) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
my_error(0x10,4,*piVar3);
return 0xffffffff;
}
puVar5 = (int2 *)strend(param_1);
if (*(char *)((long)puVar5 + -1) != '/') {
*puVar5 = 0x2f;
}
pcVar6 = &curr_dir;
param_2 = 0x1ff;
pcVar2 = param_1;
}
else {
param_2 = param_2 + -1;
pcVar2 = &curr_dir;
pcVar6 = param_1;
}
strmake(pcVar6,pcVar2,param_2);
return 0;
}
|
|
57,636
|
std::pair<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>, bool> nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&)
|
monkey531[P]llama/common/json.hpp
|
std::pair<iterator, bool> emplace(KeyType && key, T && t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(std::forward<KeyType>(key), std::forward<T>(t));
return {std::prev(this->end()), true};
}
|
O3
|
cpp
|
std::pair<__gnu_cxx::__normal_iterator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>*, std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>>, bool> nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, minja::Value&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%rdi), %rbx
je 0x4dd47
leaq 0x18(%r14), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4dd70
testb %al, %al
jne 0x4dd61
addq $0x60, %rbx
cmpq 0x8(%r14), %rbx
jne 0x4dd2b
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4ddb4
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x4dd63
xorl %edx, %edx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
cmp rbx, [rdi+8]
jz short loc_4DD47
lea r13, [r14+18h]
loc_4DD2B:
mov rdi, r13
mov rsi, rbx
mov rdx, r12
call _ZNKSt8equal_toIvEclIRKN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEERKSC_EEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSL_OSM_
test al, al
jnz short loc_4DD61
add rbx, 60h ; '`'
cmp rbx, [r14+8]
jnz short loc_4DD2B
loc_4DD47:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRKSA_SH_EEERSI_DpOT_; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::emplace_back<std::string const&,minja::Value>(std::string const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_4DD63
loc_4DD61:
xor edx, edx
loc_4DD63:
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_(
long long *a1,
long long a2,
long long a3)
{
long long v4; // rbx
v4 = *a1;
if ( *a1 == a1[1] )
{
LABEL_4:
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::emplace_back<std::string const&,minja::Value>(
a1,
a2,
a3);
return a1[1] - 96;
}
else
{
while ( !(unsigned __int8)std::equal_to<void>::operator()<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,std::string const&>(
a1 + 3,
v4,
a2) )
{
v4 += 96LL;
if ( v4 == a1[1] )
goto LABEL_4;
}
}
return v4;
}
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
CMP RBX,qword ptr [RDI + 0x8]
JZ 0x0014dd47
LEA R13,[R14 + 0x18]
LAB_0014dd2b:
MOV RDI,R13
MOV RSI,RBX
MOV RDX,R12
CALL 0x0014dd70
TEST AL,AL
JNZ 0x0014dd61
ADD RBX,0x60
CMP RBX,qword ptr [R14 + 0x8]
JNZ 0x0014dd2b
LAB_0014dd47:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x0014ddb4
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x0014dd63
LAB_0014dd61:
XOR EDX,EDX
LAB_0014dd63:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16]
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceIRKS9_TnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEESI_IN9__gnu_cxx17__normal_iteratorIPSK_S3_ISK_SL_EEEbEOST_OSF_
(vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*param_1,string *param_2,Value *param_3)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
int1 auVar4 [16];
pbVar3 = *(basic_json **)param_1;
if (pbVar3 != *(basic_json **)(param_1 + 8)) {
do {
cVar1 = std::equal_to<void>::operator()((equal_to<void> *)(param_1 + 0x18),pbVar3,param_2);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_0014dd63;
}
pbVar3 = pbVar3 + 0x60;
} while (pbVar3 != *(basic_json **)(param_1 + 8));
}
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::emplace_back<std::__cxx11::string_const&,minja::Value>(param_1,param_2,param_3);
pbVar3 = (basic_json *)(*(long *)(param_1 + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_0014dd63:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = pbVar3;
return auVar4;
}
|
|
57,637
|
minja::SetTemplateToken::SetTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&)
|
monkey531[P]llama/common/minja.hpp
|
SetTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateToken(Type::Set, location, pre, post), ns(ns), var_names(vns), value(std::move(v)) {}
|
O1
|
cpp
|
minja::SetTemplateToken::SetTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Expression>&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %r14
movq %rdi, %rbx
leaq 0x82f2e(%rip), %r12 # 0xdd1c8
addq $0x10, %r12
movq %r12, (%rdi)
movl $0xa, 0x8(%rdi)
movq (%rsi), %rax
movq %rax, 0x10(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x18(%rdi)
testq %rax, %rax
je 0x5a2d1
movq 0x84cd5(%rip), %rdi # 0xdef98
cmpb $0x0, (%rdi)
je 0x5a2cd
incl 0x8(%rax)
jmp 0x5a2d1
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x20(%rbx)
movl %edx, 0x28(%rbx)
movl %ecx, 0x2c(%rbx)
leaq 0x83a2a(%rip), %rax # 0xddd10
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x30(%rbx), %r15
leaq 0x40(%rbx), %r13
movq %r13, 0x30(%rbx)
movq (%r8), %rsi
movq 0x8(%r8), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x36a00
leaq 0x50(%rbx), %rdi
movq %r14, %rsi
callq 0x36d62
movq 0x30(%rsp), %rax
xorl %ecx, %ecx
movq %rcx, 0x70(%rbx)
movups (%rax), %xmm0
movq %rcx, 0x8(%rax)
movups %xmm0, 0x68(%rbx)
movq %rcx, (%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x5a356
movq (%r13), %rsi
incq %rsi
callq 0x186a0
jmp 0x5a356
movq %rax, %r14
movq %r12, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5a367
callq 0x2fde4
movq %r14, %rdi
callq 0x18bb0
nop
|
_ZN5minja16SetTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKSt6vectorISA_SaISA_EEOSt10shared_ptrINS_10ExpressionEE:
push r15
push r14
push r13
push r12
push rbx
mov r14, r9
mov rbx, rdi
lea r12, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add r12, 10h
mov [rdi], r12
mov dword ptr [rdi+8], 0Ah
mov rax, [rsi]
mov [rdi+10h], rax
mov rax, [rsi+8]
mov [rdi+18h], rax
test rax, rax
jz short loc_5A2D1
mov rdi, cs:__libc_single_threaded_ptr
cmp byte ptr [rdi], 0
jz short loc_5A2CD
inc dword ptr [rax+8]
jmp short loc_5A2D1
loc_5A2CD:
lock inc dword ptr [rax+8]
loc_5A2D1:
mov rax, [rsi+10h]
mov [rbx+20h], rax
mov [rbx+28h], edx
mov [rbx+2Ch], ecx
lea rax, _ZTVN5minja16SetTemplateTokenE; `vtable for'minja::SetTemplateToken
add rax, 10h
mov [rbx], rax
lea r15, [rbx+30h]
lea r13, [rbx+40h]
mov [rbx+30h], r13
mov rsi, [r8]
mov rdx, [r8+8]
add rdx, rsi
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rdi, [rbx+50h]
mov rsi, r14
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEC2ERKS7_; std::vector<std::string>::vector(std::vector<std::string> const&)
mov rax, [rsp+28h+arg_0]
xor ecx, ecx
mov [rbx+70h], rcx
movups xmm0, xmmword ptr [rax]
mov [rax+8], rcx
movups xmmword ptr [rbx+68h], xmm0
mov [rax], rcx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [r15]; void *
cmp rdi, r13
jz short loc_5A356
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5A356
mov r14, rax
loc_5A356:
mov [rbx], r12
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_5A367
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_5A367:
mov rdi, r14
call __Unwind_Resume
|
long long minja::SetTemplateToken::SetTemplateToken(
long long a1,
_QWORD *a2,
int a3,
int a4,
long long a5,
_QWORD *a6,
__int128 *a7)
{
long long v8; // rax
long long result; // rax
__int128 v10; // xmm0
*(_QWORD *)a1 = &`vtable for'minja::TemplateToken + 2;
*(_DWORD *)(a1 + 8) = 10;
*(_QWORD *)(a1 + 16) = *a2;
v8 = a2[1];
*(_QWORD *)(a1 + 24) = v8;
if ( v8 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v8 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v8 + 8));
}
*(_QWORD *)(a1 + 32) = a2[2];
*(_DWORD *)(a1 + 40) = a3;
*(_DWORD *)(a1 + 44) = a4;
*(_QWORD *)a1 = &`vtable for'minja::SetTemplateToken + 2;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char *>((_QWORD *)(a1 + 48), *(_BYTE **)a5, *(_QWORD *)a5 + *(_QWORD *)(a5 + 8));
std::vector<std::string>::vector(a1 + 80, a6);
result = (long long)a7;
*(_QWORD *)(a1 + 112) = 0LL;
v10 = *a7;
*((_QWORD *)a7 + 1) = 0LL;
*(_OWORD *)(a1 + 104) = v10;
*(_QWORD *)a7 = 0LL;
return result;
}
|
SetTemplateToken:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,R9
MOV RBX,RDI
LEA R12,[0x1dd1c8]
ADD R12,0x10
MOV qword ptr [RDI],R12
MOV dword ptr [RDI + 0x8],0xa
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x18],RAX
TEST RAX,RAX
JZ 0x0015a2d1
MOV RDI,qword ptr [0x001def98]
CMP byte ptr [RDI],0x0
JZ 0x0015a2cd
INC dword ptr [RAX + 0x8]
JMP 0x0015a2d1
LAB_0015a2cd:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0015a2d1:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],EDX
MOV dword ptr [RBX + 0x2c],ECX
LEA RAX,[0x1ddd10]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA R15,[RBX + 0x30]
LEA R13,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],R13
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
ADD RDX,RSI
LAB_0015a303:
MOV RDI,R15
CALL 0x00136a00
LEA RDI,[RBX + 0x50]
LAB_0015a30f:
MOV RSI,R14
CALL 0x00136d62
LAB_0015a317:
MOV RAX,qword ptr [RSP + 0x30]
XOR ECX,ECX
MOV qword ptr [RBX + 0x70],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOVUPS xmmword ptr [RBX + 0x68],XMM0
MOV qword ptr [RAX],RCX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::SetTemplateToken::SetTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::__cxx11::string const&, std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::SetTemplateToken::SetTemplateToken
(SetTemplateToken *this,int8 *param_1,int4 param_3,int4 param_4,
long *param_5,vector *param_6,int8 *param_7)
{
long lVar1;
int8 uVar2;
*(int ***)this = &PTR__TemplateToken_001dd1d8;
*(int4 *)(this + 8) = 10;
*(int8 *)(this + 0x10) = *param_1;
lVar1 = param_1[1];
*(long *)(this + 0x18) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001def98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x20) = param_1[2];
*(int4 *)(this + 0x28) = param_3;
*(int4 *)(this + 0x2c) = param_4;
*(int ***)this = &PTR__SetTemplateToken_001ddd20;
*(SetTemplateToken **)(this + 0x30) = this + 0x40;
/* try { // try from 0015a303 to 0015a30a has its CatchHandler @ 0015a353 */
std::__cxx11::string::_M_construct<char*>(this + 0x30,*param_5,param_5[1] + *param_5);
/* try { // try from 0015a30f to 0015a316 has its CatchHandler @ 0015a33a */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)(this + 0x50),
param_6);
*(int8 *)(this + 0x70) = 0;
uVar2 = param_7[1];
param_7[1] = 0;
*(int8 *)(this + 0x68) = *param_7;
*(int8 *)(this + 0x70) = uVar2;
*param_7 = 0;
return;
}
|
|
57,638
|
MatrixToFloatV
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI float16 MatrixToFloatV(Matrix mat)
{
float16 result = { 0 };
result.v[0] = mat.m0;
result.v[1] = mat.m1;
result.v[2] = mat.m2;
result.v[3] = mat.m3;
result.v[4] = mat.m4;
result.v[5] = mat.m5;
result.v[6] = mat.m6;
result.v[7] = mat.m7;
result.v[8] = mat.m8;
result.v[9] = mat.m9;
result.v[10] = mat.m10;
result.v[11] = mat.m11;
result.v[12] = mat.m12;
result.v[13] = mat.m13;
result.v[14] = mat.m14;
result.v[15] = mat.m15;
return result;
}
|
O0
|
c
|
MatrixToFloatV:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0xa2d0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movss (%rcx), %xmm0
movss %xmm0, (%rdi)
movss 0x10(%rcx), %xmm0
movss %xmm0, 0x4(%rdi)
movss 0x20(%rcx), %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x30(%rcx), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0x4(%rcx), %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x14(%rcx), %xmm0
movss %xmm0, 0x14(%rdi)
movss 0x24(%rcx), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x34(%rcx), %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x8(%rcx), %xmm0
movss %xmm0, 0x20(%rdi)
movss 0x18(%rcx), %xmm0
movss %xmm0, 0x24(%rdi)
movss 0x28(%rcx), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x38(%rcx), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0xc(%rcx), %xmm0
movss %xmm0, 0x30(%rdi)
movss 0x1c(%rcx), %xmm0
movss %xmm0, 0x34(%rdi)
movss 0x2c(%rcx), %xmm0
movss %xmm0, 0x38(%rdi)
movss 0x3c(%rcx), %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
MatrixToFloatV:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, rdi
mov [rbp+var_8], rax
lea rax, [rbp+arg_0]
mov [rbp+var_18], rax
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rcx, [rbp+var_18]
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rcx]
movss dword ptr [rdi], xmm0
movss xmm0, dword ptr [rcx+10h]
movss dword ptr [rdi+4], xmm0
movss xmm0, dword ptr [rcx+20h]
movss dword ptr [rdi+8], xmm0
movss xmm0, dword ptr [rcx+30h]
movss dword ptr [rdi+0Ch], xmm0
movss xmm0, dword ptr [rcx+4]
movss dword ptr [rdi+10h], xmm0
movss xmm0, dword ptr [rcx+14h]
movss dword ptr [rdi+14h], xmm0
movss xmm0, dword ptr [rcx+24h]
movss dword ptr [rdi+18h], xmm0
movss xmm0, dword ptr [rcx+34h]
movss dword ptr [rdi+1Ch], xmm0
movss xmm0, dword ptr [rcx+8]
movss dword ptr [rdi+20h], xmm0
movss xmm0, dword ptr [rcx+18h]
movss dword ptr [rdi+24h], xmm0
movss xmm0, dword ptr [rcx+28h]
movss dword ptr [rdi+28h], xmm0
movss xmm0, dword ptr [rcx+38h]
movss dword ptr [rdi+2Ch], xmm0
movss xmm0, dword ptr [rcx+0Ch]
movss dword ptr [rdi+30h], xmm0
movss xmm0, dword ptr [rcx+1Ch]
movss dword ptr [rdi+34h], xmm0
movss xmm0, dword ptr [rcx+2Ch]
movss dword ptr [rdi+38h], xmm0
movss xmm0, dword ptr [rcx+3Ch]
movss dword ptr [rdi+3Ch], xmm0
add rsp, 20h
pop rbp
retn
|
_DWORD * MatrixToFloatV(
_DWORD *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 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
_DWORD *result; // rax
memset(a1, 0LL, 64LL);
result = a1;
*a1 = a7;
a1[1] = a9;
a1[2] = a11;
a1[3] = a13;
a1[4] = HIDWORD(a7);
a1[5] = HIDWORD(a9);
a1[6] = HIDWORD(a11);
a1[7] = HIDWORD(a13);
a1[8] = a8;
a1[9] = a10;
a1[10] = a12;
a1[11] = a14;
a1[12] = HIDWORD(a8);
a1[13] = HIDWORD(a10);
a1[14] = HIDWORD(a12);
a1[15] = HIDWORD(a14);
return result;
}
|
MatrixToFloatV:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RAX
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0010a2d0
MOV RCX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RCX]
MOVSS dword ptr [RDI],XMM0
MOVSS XMM0,dword ptr [RCX + 0x10]
MOVSS dword ptr [RDI + 0x4],XMM0
MOVSS XMM0,dword ptr [RCX + 0x20]
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RCX + 0x30]
MOVSS dword ptr [RDI + 0xc],XMM0
MOVSS XMM0,dword ptr [RCX + 0x4]
MOVSS dword ptr [RDI + 0x10],XMM0
MOVSS XMM0,dword ptr [RCX + 0x14]
MOVSS dword ptr [RDI + 0x14],XMM0
MOVSS XMM0,dword ptr [RCX + 0x24]
MOVSS dword ptr [RDI + 0x18],XMM0
MOVSS XMM0,dword ptr [RCX + 0x34]
MOVSS dword ptr [RDI + 0x1c],XMM0
MOVSS XMM0,dword ptr [RCX + 0x8]
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RCX + 0x18]
MOVSS dword ptr [RDI + 0x24],XMM0
MOVSS XMM0,dword ptr [RCX + 0x28]
MOVSS dword ptr [RDI + 0x28],XMM0
MOVSS XMM0,dword ptr [RCX + 0x38]
MOVSS dword ptr [RDI + 0x2c],XMM0
MOVSS XMM0,dword ptr [RCX + 0xc]
MOVSS dword ptr [RDI + 0x30],XMM0
MOVSS XMM0,dword ptr [RCX + 0x1c]
MOVSS dword ptr [RDI + 0x34],XMM0
MOVSS XMM0,dword ptr [RCX + 0x2c]
MOVSS dword ptr [RDI + 0x38],XMM0
MOVSS XMM0,dword ptr [RCX + 0x3c]
MOVSS dword ptr [RDI + 0x3c],XMM0
ADD RSP,0x20
POP RBP
RET
|
int4 * MatrixToFloatV(int4 *param_1)
{
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int4 uStack0000000000000010;
int4 uStack0000000000000014;
int4 uStack0000000000000018;
int4 uStack000000000000001c;
int4 uStack0000000000000020;
int4 uStack0000000000000024;
int4 uStack0000000000000028;
int4 uStack000000000000002c;
int4 uStack0000000000000030;
int4 uStack0000000000000034;
int4 uStack0000000000000038;
int4 uStack000000000000003c;
int4 uStack0000000000000040;
int4 uStack0000000000000044;
memset(param_1,0,0x40);
*param_1 = uStack0000000000000008;
param_1[1] = uStack0000000000000018;
param_1[2] = uStack0000000000000028;
param_1[3] = uStack0000000000000038;
param_1[4] = uStack000000000000000c;
param_1[5] = uStack000000000000001c;
param_1[6] = uStack000000000000002c;
param_1[7] = uStack000000000000003c;
param_1[8] = uStack0000000000000010;
param_1[9] = uStack0000000000000020;
param_1[10] = uStack0000000000000030;
param_1[0xb] = uStack0000000000000040;
param_1[0xc] = uStack0000000000000014;
param_1[0xd] = uStack0000000000000024;
param_1[0xe] = uStack0000000000000034;
param_1[0xf] = uStack0000000000000044;
return param_1;
}
|
|
57,639
|
MatrixToFloatV
|
csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h
|
RMAPI float16 MatrixToFloatV(Matrix mat)
{
float16 result = { 0 };
result.v[0] = mat.m0;
result.v[1] = mat.m1;
result.v[2] = mat.m2;
result.v[3] = mat.m3;
result.v[4] = mat.m4;
result.v[5] = mat.m5;
result.v[6] = mat.m6;
result.v[7] = mat.m7;
result.v[8] = mat.m8;
result.v[9] = mat.m9;
result.v[10] = mat.m10;
result.v[11] = mat.m11;
result.v[12] = mat.m12;
result.v[13] = mat.m13;
result.v[14] = mat.m14;
result.v[15] = mat.m15;
return result;
}
|
O2
|
c
|
MatrixToFloatV:
movq %rdi, %rax
movss 0x8(%rsp), %xmm0
movss %xmm0, (%rdi)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x4(%rdi)
movss 0x28(%rsp), %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x38(%rsp), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x1c(%rsp), %xmm0
movss %xmm0, 0x14(%rdi)
movss 0x2c(%rsp), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x3c(%rsp), %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x20(%rdi)
movss 0x20(%rsp), %xmm0
movss %xmm0, 0x24(%rdi)
movss 0x30(%rsp), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x40(%rsp), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0x14(%rsp), %xmm0
movss %xmm0, 0x30(%rdi)
movss 0x24(%rsp), %xmm0
movss %xmm0, 0x34(%rdi)
movss 0x34(%rsp), %xmm0
movss %xmm0, 0x38(%rdi)
movss 0x44(%rsp), %xmm0
movss %xmm0, 0x3c(%rdi)
retq
|
MatrixToFloatV:
mov rax, rdi
movss xmm0, [rsp+arg_0]
movss dword ptr [rdi], xmm0
movss xmm0, [rsp+arg_10]
movss dword ptr [rdi+4], xmm0
movss xmm0, [rsp+arg_20]
movss dword ptr [rdi+8], xmm0
movss xmm0, [rsp+arg_30]
movss dword ptr [rdi+0Ch], xmm0
movss xmm0, [rsp+arg_4]
movss dword ptr [rdi+10h], xmm0
movss xmm0, [rsp+arg_14]
movss dword ptr [rdi+14h], xmm0
movss xmm0, [rsp+arg_24]
movss dword ptr [rdi+18h], xmm0
movss xmm0, [rsp+arg_34]
movss dword ptr [rdi+1Ch], xmm0
movss xmm0, [rsp+arg_8]
movss dword ptr [rdi+20h], xmm0
movss xmm0, [rsp+arg_18]
movss dword ptr [rdi+24h], xmm0
movss xmm0, [rsp+arg_28]
movss dword ptr [rdi+28h], xmm0
movss xmm0, [rsp+arg_38]
movss dword ptr [rdi+2Ch], xmm0
movss xmm0, [rsp+arg_C]
movss dword ptr [rdi+30h], xmm0
movss xmm0, [rsp+arg_1C]
movss dword ptr [rdi+34h], xmm0
movss xmm0, [rsp+arg_2C]
movss dword ptr [rdi+38h], xmm0
movss xmm0, [rsp+arg_3C]
movss dword ptr [rdi+3Ch], xmm0
retn
|
_DWORD * MatrixToFloatV(
_DWORD *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 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
_DWORD *result; // rax
result = a1;
*a1 = a7;
a1[1] = a9;
a1[2] = a11;
a1[3] = a13;
a1[4] = HIDWORD(a7);
a1[5] = HIDWORD(a9);
a1[6] = HIDWORD(a11);
a1[7] = HIDWORD(a13);
a1[8] = a8;
a1[9] = a10;
a1[10] = a12;
a1[11] = a14;
a1[12] = HIDWORD(a8);
a1[13] = HIDWORD(a10);
a1[14] = HIDWORD(a12);
a1[15] = HIDWORD(a14);
return result;
}
|
MatrixToFloatV:
MOV RAX,RDI
MOVSS XMM0,dword ptr [RSP + 0x8]
MOVSS dword ptr [RDI],XMM0
MOVSS XMM0,dword ptr [RSP + 0x18]
MOVSS dword ptr [RDI + 0x4],XMM0
MOVSS XMM0,dword ptr [RSP + 0x28]
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RSP + 0x38]
MOVSS dword ptr [RDI + 0xc],XMM0
MOVSS XMM0,dword ptr [RSP + 0xc]
MOVSS dword ptr [RDI + 0x10],XMM0
MOVSS XMM0,dword ptr [RSP + 0x1c]
MOVSS dword ptr [RDI + 0x14],XMM0
MOVSS XMM0,dword ptr [RSP + 0x2c]
MOVSS dword ptr [RDI + 0x18],XMM0
MOVSS XMM0,dword ptr [RSP + 0x3c]
MOVSS dword ptr [RDI + 0x1c],XMM0
MOVSS XMM0,dword ptr [RSP + 0x10]
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RSP + 0x20]
MOVSS dword ptr [RDI + 0x24],XMM0
MOVSS XMM0,dword ptr [RSP + 0x30]
MOVSS dword ptr [RDI + 0x28],XMM0
MOVSS XMM0,dword ptr [RSP + 0x40]
MOVSS dword ptr [RDI + 0x2c],XMM0
MOVSS XMM0,dword ptr [RSP + 0x14]
MOVSS dword ptr [RDI + 0x30],XMM0
MOVSS XMM0,dword ptr [RSP + 0x24]
MOVSS dword ptr [RDI + 0x34],XMM0
MOVSS XMM0,dword ptr [RSP + 0x34]
MOVSS dword ptr [RDI + 0x38],XMM0
MOVSS XMM0,dword ptr [RSP + 0x44]
MOVSS dword ptr [RDI + 0x3c],XMM0
RET
|
int4 * MatrixToFloatV(int4 *param_1)
{
int4 uStack0000000000000008;
int4 uStack000000000000000c;
int4 uStack0000000000000010;
int4 uStack0000000000000014;
int4 uStack0000000000000018;
int4 uStack000000000000001c;
int4 uStack0000000000000020;
int4 uStack0000000000000024;
int4 uStack0000000000000028;
int4 uStack000000000000002c;
int4 uStack0000000000000030;
int4 uStack0000000000000034;
int4 uStack0000000000000038;
int4 uStack000000000000003c;
int4 uStack0000000000000040;
int4 uStack0000000000000044;
*param_1 = uStack0000000000000008;
param_1[1] = uStack0000000000000018;
param_1[2] = uStack0000000000000028;
param_1[3] = uStack0000000000000038;
param_1[4] = uStack000000000000000c;
param_1[5] = uStack000000000000001c;
param_1[6] = uStack000000000000002c;
param_1[7] = uStack000000000000003c;
param_1[8] = uStack0000000000000010;
param_1[9] = uStack0000000000000020;
param_1[10] = uStack0000000000000030;
param_1[0xb] = uStack0000000000000040;
param_1[0xc] = uStack0000000000000014;
param_1[0xd] = uStack0000000000000024;
param_1[0xe] = uStack0000000000000034;
param_1[0xf] = uStack0000000000000044;
return param_1;
}
|
|
57,640
|
google::protobuf::compiler::ParseGeneratorParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/code_generator.cc
|
void ParseGeneratorParameter(
const std::string& text,
std::vector<std::pair<std::string, std::string> >* output) {
std::vector<std::string> parts = Split(text, ",", true);
for (int i = 0; i < parts.size(); i++) {
std::string::size_type equals_pos = parts[i].find_first_of('=');
std::pair<std::string, std::string> value;
if (equals_pos == std::string::npos) {
value.first = parts[i];
value.second = "";
} else {
value.first = parts[i].substr(0, equals_pos);
value.second = parts[i].substr(equals_pos + 1);
}
output->push_back(value);
}
}
|
O0
|
cpp
|
google::protobuf::compiler::ParseGeneratorParameter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>*):
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0x28ad0
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
leaq 0x39c050(%rip), %rcx # 0x3c450b
movl $0x1, %r8d
callq 0x28a00
movl $0x0, 0xac(%rsp)
movslq 0xac(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x28b30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x28683
movslq 0xac(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x28b50
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0x3d, %esi
callq 0x216b0
movq %rax, 0xa0(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x28b70
jmp 0x28536
cmpq $-0x1, 0xa0(%rsp)
jne 0x285b0
movslq 0xac(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x28b50
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x21be0
jmp 0x28565
leaq 0x80(%rsp), %rdi
leaq 0x37fff5(%rip), %rsi # 0x3a8569
callq 0x21450
jmp 0x2857b
jmp 0x2864f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x28698
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x28c10
jmp 0x28698
movslq 0xac(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x28b50
movq %rax, %rsi
movq 0xa0(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x30(%rsp), %rdi
callq 0x21a50
jmp 0x285e0
leaq 0x60(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x215e0
movq (%rsp), %rdi
callq 0x21cc8
movslq 0xac(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x28b50
movq %rax, %rsi
movq 0xa0(%rsp), %rdx
incq %rdx
leaq 0x10(%rsp), %rdi
movq $-0x1, %rcx
callq 0x21a50
jmp 0x28632
leaq 0x60(%rsp), %rdi
addq $0x20, %rdi
leaq 0x10(%rsp), %rsi
callq 0x215e0
leaq 0x10(%rsp), %rdi
callq 0x21cc8
movq 0xd8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x28ba0
jmp 0x28663
leaq 0x60(%rsp), %rdi
callq 0x28c10
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x284d1
leaq 0xc0(%rsp), %rdi
callq 0x28c40
addq $0xe8, %rsp
retq
leaq 0xc0(%rsp), %rdi
callq 0x28c40
movq 0x58(%rsp), %rdi
callq 0x21700
nop
|
_ZN6google8protobuf8compiler23ParseGeneratorParameterERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPSt6vectorISt4pairIS7_S7_ESaISC_EE:
sub rsp, 0E8h
mov [rsp+0E8h+var_8], rdi
mov [rsp+0E8h+var_10], rsi
mov rsi, [rsp+0E8h+var_8]
lea rdi, [rsp+0E8h+var_38]
call _ZN6google8protobuf20stringpiece_internal11StringPieceC2ISaIcEEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcET_EE; google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(std::string const&)
mov rsi, [rsp+0E8h+var_38]
mov rdx, [rsp+0E8h+var_30]
lea rdi, [rsp+0E8h+var_28]
lea rcx, a12_0+9; ","
mov r8d, 1
call _ZN6google8protobuf5SplitB5cxx11ENS0_20stringpiece_internal11StringPieceEPKcb; google::protobuf::Split(google::protobuf::stringpiece_internal::StringPiece,char const*,bool)
mov [rsp+0E8h+var_3C], 0
loc_284D1:
movsxd rax, [rsp+0E8h+var_3C]
mov [rsp+0E8h+var_E0], rax
lea rdi, [rsp+0E8h+var_28]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+0E8h+var_E0]
cmp rax, rcx
jnb loc_28683
movsxd rsi, [rsp+0E8h+var_3C]
lea rdi, [rsp+0E8h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rdi, rax
xor eax, eax
mov edx, eax
mov esi, 3Dh ; '='
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE13find_first_ofEcm; std::string::find_first_of(char,ulong)
mov [rsp+0E8h+var_48], rax
lea rdi, [rsp+0E8h+var_88]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EC2IS5_S5_TnNSt9enable_ifIXsr6__and_ISt37__is_implicitly_default_constructibleIT_ES9_IT0_EEE5valueEbE4typeELb1EEEv
jmp short $+2
loc_28536:
cmp [rsp+0E8h+var_48], 0FFFFFFFFFFFFFFFFh
jnz short loc_285B0
movsxd rsi, [rsp+0E8h+var_3C]
lea rdi, [rsp+0E8h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
lea rdi, [rsp+0E8h+var_88]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_; std::string::operator=(std::string const&)
jmp short $+2
loc_28565:
lea rdi, [rsp+0E8h+var_68]
lea rsi, asc_3A8567+2; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
jmp short $+2
loc_2857B:
jmp loc_2864F
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
jmp loc_28698
mov rcx, rax
mov eax, edx
mov [rsp+arg_50], rcx
mov [rsp+arg_4C], eax
lea rdi, [rsp+arg_58]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_ED2Ev; std::pair<std::string,std::string>::~pair()
jmp loc_28698
loc_285B0:
movsxd rsi, [rsp+0E8h+var_3C]
lea rdi, [rsp+0E8h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
mov rcx, [rsp+0E8h+var_48]
xor eax, eax
mov edx, eax
lea rdi, [rsp+0E8h+var_B8]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_285E0:
lea rdi, [rsp+0E8h+var_88]
lea rsi, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_E8], rsi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [rsp+0E8h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
movsxd rsi, [rsp+0E8h+var_3C]
lea rdi, [rsp+0E8h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
mov rdx, [rsp+0E8h+var_48]
inc rdx
lea rdi, [rsp+0E8h+var_D8]
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
jmp short $+2
loc_28632:
lea rdi, [rsp+0E8h+var_88]
add rdi, 20h ; ' '
lea rsi, [rsp+0E8h+var_D8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+0E8h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_2864F:
mov rdi, [rsp+0E8h+var_10]
lea rsi, [rsp+0E8h+var_88]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_ESaIS7_EE9push_backERKS7_; std::vector<std::pair<std::string,std::string>>::push_back(std::pair<std::string,std::string> const&)
jmp short $+2
loc_28663:
lea rdi, [rsp+0E8h+var_88]
call _ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_ED2Ev; std::pair<std::string,std::string>::~pair()
mov eax, [rsp+0E8h+var_3C]
add eax, 1
mov [rsp+0E8h+var_3C], eax
jmp loc_284D1
loc_28683:
lea rdi, [rsp+0E8h+var_28]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
add rsp, 0E8h
retn
loc_28698:
lea rdi, [rsp+arg_B8]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, [rsp+arg_50]
call __Unwind_Resume
|
long long google::protobuf::compiler::ParseGeneratorParameter(long long a1, long long a2)
{
int v2; // r9d
long long v3; // rax
long long v4; // rax
long long v5; // rax
long long v6; // rax
unsigned long long v8; // [rsp+8h] [rbp-E0h]
_BYTE v9[32]; // [rsp+10h] [rbp-D8h] BYREF
_BYTE v10[48]; // [rsp+30h] [rbp-B8h] BYREF
_BYTE v11[32]; // [rsp+60h] [rbp-88h] BYREF
_BYTE v12[32]; // [rsp+80h] [rbp-68h] BYREF
long long first_of; // [rsp+A0h] [rbp-48h]
int i; // [rsp+ACh] [rbp-3Ch]
long long v15; // [rsp+B0h] [rbp-38h] BYREF
long long v16; // [rsp+B8h] [rbp-30h]
_BYTE v17[24]; // [rsp+C0h] [rbp-28h] BYREF
long long v18; // [rsp+D8h] [rbp-10h]
long long v19; // [rsp+E0h] [rbp-8h]
v19 = a1;
v18 = a2;
google::protobuf::stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>(&v15, a1);
google::protobuf::Split[abi:cxx11]((unsigned int)v17, v15, v16, (unsigned int)",", 1, v2);
for ( i = 0; ; ++i )
{
v8 = i;
if ( v8 >= std::vector<std::string>::size(v17) )
break;
v3 = std::vector<std::string>::operator[](v17, i);
first_of = std::string::find_first_of(v3, 61LL, 0LL);
ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EC2IS5_S5_TnNSt9enable_ifIXsr6__and_ISt37__is_implicitly_default_constructibleIT_ES9_IT0_EEE5valueEbE4typeELb1EEEv(v11);
if ( first_of == -1 )
{
v4 = std::vector<std::string>::operator[](v17, i);
std::string::operator=(v11, v4);
std::string::operator=(v12, "");
}
else
{
v5 = std::vector<std::string>::operator[](v17, i);
std::string::substr(v10, v5, 0LL, first_of);
std::string::operator=(v11, v10);
std::string::~string(v10);
v6 = std::vector<std::string>::operator[](v17, i);
std::string::substr(v9, v6, first_of + 1, -1LL);
std::string::operator=(v12, v9);
std::string::~string(v9);
}
std::vector<std::pair<std::string,std::string>>::push_back(v18, v11);
std::pair<std::string,std::string>::~pair(v11);
}
return std::vector<std::string>::~vector(v17);
}
|
ParseGeneratorParameter:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xe0],RDI
MOV qword ptr [RSP + 0xd8],RSI
MOV RSI,qword ptr [RSP + 0xe0]
LEA RDI,[RSP + 0xb0]
CALL 0x00128ad0
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
LEA RDI,[RSP + 0xc0]
LEA RCX,[0x4c450b]
MOV R8D,0x1
CALL 0x00128a00
MOV dword ptr [RSP + 0xac],0x0
LAB_001284d1:
MOVSXD RAX,dword ptr [RSP + 0xac]
MOV qword ptr [RSP + 0x8],RAX
LEA RDI,[RSP + 0xc0]
CALL 0x00128b30
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JNC 0x00128683
MOVSXD RSI,dword ptr [RSP + 0xac]
LEA RDI,[RSP + 0xc0]
CALL 0x00128b50
MOV RDI,RAX
XOR EAX,EAX
MOV EDX,EAX
MOV ESI,0x3d
CALL 0x001216b0
MOV qword ptr [RSP + 0xa0],RAX
LAB_0012852a:
LEA RDI,[RSP + 0x60]
CALL 0x00128b70
JMP 0x00128536
LAB_00128536:
CMP qword ptr [RSP + 0xa0],-0x1
JNZ 0x001285b0
MOVSXD RSI,dword ptr [RSP + 0xac]
LEA RDI,[RSP + 0xc0]
CALL 0x00128b50
MOV RSI,RAX
LAB_00128559:
LEA RDI,[RSP + 0x60]
CALL 0x00121be0
JMP 0x00128565
LAB_00128565:
LEA RDI,[RSP + 0x80]
LEA RSI,[0x4a8569]
CALL 0x00121450
JMP 0x0012857b
LAB_0012857b:
JMP 0x0012864f
LAB_001285b0:
MOVSXD RSI,dword ptr [RSP + 0xac]
LEA RDI,[RSP + 0xc0]
CALL 0x00128b50
MOV RSI,RAX
MOV RCX,qword ptr [RSP + 0xa0]
XOR EAX,EAX
MOV EDX,EAX
LEA RDI,[RSP + 0x30]
CALL 0x00121a50
JMP 0x001285e0
LAB_001285e0:
LEA RDI,[RSP + 0x60]
LEA RSI,[RSP + 0x30]
MOV qword ptr [RSP],RSI
CALL 0x001215e0
MOV RDI,qword ptr [RSP]
CALL 0x00121cc8
MOVSXD RSI,dword ptr [RSP + 0xac]
LEA RDI,[RSP + 0xc0]
CALL 0x00128b50
MOV RSI,RAX
MOV RDX,qword ptr [RSP + 0xa0]
INC RDX
LEA RDI,[RSP + 0x10]
MOV RCX,-0x1
CALL 0x00121a50
JMP 0x00128632
LAB_00128632:
LEA RDI,[RSP + 0x60]
ADD RDI,0x20
LEA RSI,[RSP + 0x10]
CALL 0x001215e0
LEA RDI,[RSP + 0x10]
CALL 0x00121cc8
LAB_0012864f:
MOV RDI,qword ptr [RSP + 0xd8]
LEA RSI,[RSP + 0x60]
CALL 0x00128ba0
LAB_00128661:
JMP 0x00128663
LAB_00128663:
LEA RDI,[RSP + 0x60]
CALL 0x00128c10
MOV EAX,dword ptr [RSP + 0xac]
ADD EAX,0x1
MOV dword ptr [RSP + 0xac],EAX
JMP 0x001284d1
LAB_00128683:
LEA RDI,[RSP + 0xc0]
CALL 0x00128c40
ADD RSP,0xe8
RET
|
/* google::protobuf::compiler::ParseGeneratorParameter(std::__cxx11::string const&,
std::vector<std::pair<std::__cxx11::string, std::__cxx11::string >,
std::allocator<std::pair<std::__cxx11::string, std::__cxx11::string > > >*) */
void google::protobuf::compiler::ParseGeneratorParameter(string *param_1,vector *param_2)
{
char cVar1;
ulong uVar2;
ulong uVar3;
string *psVar4;
string local_d8 [32];
string local_b8 [48];
string local_88 [32];
string local_68 [32];
long local_48;
int local_3c;
int8 local_38;
int8 local_30;
vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> local_28 [24];
vector *local_10;
string *local_8;
local_10 = param_2;
local_8 = param_1;
stringpiece_internal::StringPiece::StringPiece<std::allocator<char>>
((StringPiece *)&local_38,param_1);
Split_abi_cxx11_(local_28,local_38,local_30,&DAT_004c450b,1);
local_3c = 0;
while( true ) {
uVar2 = (ulong)local_3c;
uVar3 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::size(local_28);
if (uVar3 <= uVar2) break;
cVar1 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,(long)local_3c);
local_48 = std::__cxx11::string::find_first_of(cVar1,0x3d);
/* try { // try from 0012852a to 00128533 has its CatchHandler @ 00128580 */
_ZNSt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_EC2IS5_S5_TnNSt9enable_ifIXsr6__and_ISt37__is_implicitly_default_constructibleIT_ES9_IT0_EEE5valueEbE4typeELb1EEEv
(local_88);
if (local_48 == -1) {
psVar4 = (string *)
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,(long)local_3c);
/* try { // try from 00128559 to 00128660 has its CatchHandler @ 00128593 */
std::__cxx11::string::operator=(local_88,psVar4);
std::__cxx11::string::operator=(local_68,"");
}
else {
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,(long)local_3c);
std::__cxx11::string::substr((ulong)local_b8,uVar2);
std::__cxx11::string::operator=(local_88,local_b8);
std::__cxx11::string::~string(local_b8);
uVar2 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::operator[]
(local_28,(long)local_3c);
std::__cxx11::string::substr((ulong)local_d8,uVar2);
std::__cxx11::string::operator=(local_68,local_d8);
std::__cxx11::string::~string(local_d8);
}
std::
vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
::push_back((vector<std::pair<std::__cxx11::string,std::__cxx11::string>,std::allocator<std::pair<std::__cxx11::string,std::__cxx11::string>>>
*)local_10,(pair *)local_88);
std::pair<std::__cxx11::string,std::__cxx11::string>::~pair
((pair<std::__cxx11::string,std::__cxx11::string> *)local_88);
local_3c = local_3c + 1;
}
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector(local_28);
return;
}
|
|
57,641
|
test_rms_norm::build_graph(ggml_context*)
|
monkey531[P]llama/tests/test-backend-ops.cpp
|
ggml_tensor * build_graph(ggml_context * ctx) override {
ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
ggml_set_param(ctx, a);
ggml_set_name(a, "a");
ggml_tensor * out = ggml_rms_norm(ctx, a, eps);
ggml_set_name(out, "out");
return out;
}
|
O1
|
cpp
|
test_rms_norm::build_graph(ggml_context*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %esi
leaq 0x40(%rdi), %rcx
movq %rbx, %rdi
movl $0x4, %edx
callq 0xd080
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bc8c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xda90
leaq 0x1bd64(%rip), %rsi # 0x45df1
movq %r15, %rdi
callq 0xdb10
movss 0x60(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd650
movq %rax, %rbx
leaq 0x1c2e8(%rip), %rsi # 0x46398
movq %rax, %rdi
callq 0xdb10
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN13test_rms_norm11build_graphEP12ggml_context:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov esi, [rdi+38h]
lea rcx, [rdi+40h]
mov rdi, rbx
mov edx, 4
call _ggml_new_tensor
mov r15, rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rdi, rbx
mov rsi, r15
call _ggml_set_param
lea rsi, aViewOfA+8; "a"
mov rdi, r15
call _ggml_set_name
movss xmm0, dword ptr [r14+60h]
mov rdi, rbx
mov rsi, r15
call _ggml_rms_norm
mov rbx, rax
lea rsi, aSumOfOut+7; "out"
mov rdi, rax
call _ggml_set_name
mov rax, rbx
pop rbx
pop r14
pop r15
retn
|
long long test_rms_norm::build_graph(long long a1, long long a2)
{
long long v2; // r15
long long v3; // rbx
v2 = ggml_new_tensor(a2, *(unsigned int *)(a1 + 56), 4LL);
test_case::add_sentinel(a1, a2);
ggml_set_param(a2, v2);
ggml_set_name(v2, "a");
v3 = ggml_rms_norm(a2, v2, *(float *)(a1 + 96));
ggml_set_name(v3, "out");
return v3;
}
|
build_graph:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x38]
LEA RCX,[RDI + 0x40]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0010d080
MOV R15,RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011bc8c
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010da90
LEA RSI,[0x145df1]
MOV RDI,R15
CALL 0x0010db10
MOVSS XMM0,dword ptr [R14 + 0x60]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d650
MOV RBX,RAX
LEA RSI,[0x146398]
MOV RDI,RAX
CALL 0x0010db10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* test_rms_norm::build_graph(ggml_context*) */
int8 __thiscall test_rms_norm::build_graph(test_rms_norm *this,ggml_context *param_1)
{
int8 uVar1;
uVar1 = ggml_new_tensor(param_1,*(int4 *)(this + 0x38),4,this + 0x40);
test_case::add_sentinel((test_case *)this,param_1);
ggml_set_param(param_1,uVar1);
ggml_set_name(uVar1,"a");
uVar1 = ggml_rms_norm(*(int4 *)(this + 0x60),param_1,uVar1);
ggml_set_name(uVar1,"out");
return uVar1;
}
|
|
57,642
|
test_rms_norm::build_graph(ggml_context*)
|
monkey531[P]llama/tests/test-backend-ops.cpp
|
ggml_tensor * build_graph(ggml_context * ctx) override {
ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
ggml_set_param(ctx, a);
ggml_set_name(a, "a");
ggml_tensor * out = ggml_rms_norm(ctx, a, eps);
ggml_set_name(out, "out");
return out;
}
|
O3
|
cpp
|
test_rms_norm::build_graph(ggml_context*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %esi
leaq 0x40(%rdi), %rcx
movq %rbx, %rdi
movl $0x4, %edx
callq 0xd080
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b8ae
movq %rbx, %rdi
movq %r15, %rsi
callq 0xda90
leaq 0x1b04a(%rip), %rsi # 0x44b87
movq %r15, %rdi
callq 0xdb10
movss 0x60(%r14), %xmm0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd650
movq %rax, %rbx
leaq 0x1b5ce(%rip), %rsi # 0x4512e
movq %rax, %rdi
callq 0xdb10
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
_ZN13test_rms_norm11build_graphEP12ggml_context:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov esi, [rdi+38h]
lea rcx, [rdi+40h]
mov rdi, rbx
mov edx, 4
call _ggml_new_tensor
mov r15, rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
mov rdi, rbx
mov rsi, r15
call _ggml_set_param
lea rsi, aViewOfA+8; "a"
mov rdi, r15
call _ggml_set_name
movss xmm0, dword ptr [r14+60h]
mov rdi, rbx
mov rsi, r15
call _ggml_rms_norm
mov rbx, rax
lea rsi, aSumOfOut+7; "out"
mov rdi, rax
call _ggml_set_name
mov rax, rbx
pop rbx
pop r14
pop r15
retn
|
long long test_rms_norm::build_graph(long long a1, long long a2)
{
long long v2; // r15
long long v3; // rbx
v2 = ggml_new_tensor(a2, *(unsigned int *)(a1 + 56), 4LL);
test_case::add_sentinel(a1, a2);
ggml_set_param(a2, v2);
ggml_set_name(v2, "a");
v3 = ggml_rms_norm(a2, v2, *(float *)(a1 + 96));
ggml_set_name(v3, "out");
return v3;
}
|
build_graph:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x38]
LEA RCX,[RDI + 0x40]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0010d080
MOV R15,RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011b8ae
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010da90
LEA RSI,[0x144b87]
MOV RDI,R15
CALL 0x0010db10
MOVSS XMM0,dword ptr [R14 + 0x60]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d650
MOV RBX,RAX
LEA RSI,[0x14512e]
MOV RDI,RAX
CALL 0x0010db10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* test_rms_norm::build_graph(ggml_context*) */
int8 __thiscall test_rms_norm::build_graph(test_rms_norm *this,ggml_context *param_1)
{
int8 uVar1;
uVar1 = ggml_new_tensor(param_1,*(int4 *)(this + 0x38),4,this + 0x40);
test_case::add_sentinel((test_case *)this,param_1);
ggml_set_param(param_1,uVar1);
ggml_set_name(uVar1,"a");
uVar1 = ggml_rms_norm(*(int4 *)(this + 0x60),param_1,uVar1);
ggml_set_name(uVar1,"out");
return uVar1;
}
|
|
57,643
|
create_fromuni
|
eloqsql/strings/ctype-simple.c
|
static my_bool
create_fromuni(struct charset_info_st *cs,
MY_CHARSET_LOADER *loader)
{
uni_idx idx[PLANE_NUM];
int i,n;
/*
Check that Unicode map is loaded.
It can be not loaded when the collation is
listed in Index.xml but not specified
in the character set specific XML file.
*/
if (!cs->tab_to_uni)
return TRUE;
/* Clear plane statistics */
bzero(idx,sizeof(idx));
/* Count number of characters in each plane */
for (i=0; i< 0x100; i++)
{
uint16 wc=cs->tab_to_uni[i];
int pl= PLANE_NUMBER(wc);
if (wc || !i)
{
if (!idx[pl].nchars)
{
idx[pl].uidx.from=wc;
idx[pl].uidx.to=wc;
}else
{
idx[pl].uidx.from=wc<idx[pl].uidx.from?wc:idx[pl].uidx.from;
idx[pl].uidx.to=wc>idx[pl].uidx.to?wc:idx[pl].uidx.to;
}
idx[pl].nchars++;
}
}
/* Sort planes in descending order */
qsort(&idx,PLANE_NUM,sizeof(uni_idx),&pcmp);
for (i=0; i < PLANE_NUM; i++)
{
int ch,numchars;
uchar *tab;
/* Skip empty plane */
if (!idx[i].nchars)
break;
numchars=idx[i].uidx.to-idx[i].uidx.from+1;
if (!(idx[i].uidx.tab= tab= (uchar*)
(loader->once_alloc) (numchars *
sizeof(*idx[i].uidx.tab))))
return TRUE;
bzero(tab,numchars*sizeof(*tab));
for (ch=1; ch < PLANE_SIZE; ch++)
{
uint16 wc=cs->tab_to_uni[ch];
if (wc >= idx[i].uidx.from && wc <= idx[i].uidx.to && wc)
{
int ofs= wc - idx[i].uidx.from;
if (!tab[ofs] || tab[ofs] > 0x7F) /* Prefer ASCII*/
{
/*
Some character sets can have double encoding. For example,
in ARMSCII8, the following characters are encoded twice:
Encoding#1 Encoding#2 Unicode Character Name
---------- ---------- ------- --------------
0x27 0xFF U+0027 APOSTROPHE
0x28 0xA5 U+0028 LEFT PARENTHESIS
0x29 0xA4 U+0029 RIGHT PARENTHESIS
0x2C 0xAB U+002C COMMA
0x2D 0xAC U+002D HYPHEN-MINUS
0x2E 0xA9 U+002E FULL STOP
That is, both 0x27 and 0xFF convert to Unicode U+0027.
When converting back from Unicode to ARMSCII,
we prefer the ASCII range, that is we want U+0027
to convert to 0x27 rather than to 0xFF.
*/
tab[ofs]= ch;
}
}
}
}
/* Allocate and fill reverse table for each plane */
n=i;
if (!(cs->tab_from_uni= (MY_UNI_IDX *)
(loader->once_alloc)(sizeof(MY_UNI_IDX) * (n + 1))))
return TRUE;
for (i=0; i< n; i++)
((struct my_uni_idx_st*)cs->tab_from_uni)[i]= idx[i].uidx;
/* Set end-of-list marker */
bzero((char*) &cs->tab_from_uni[i],sizeof(MY_UNI_IDX));
return FALSE;
}
|
O0
|
c
|
create_fromuni:
pushq %rbp
movq %rsp, %rbp
subq $0x1850, %rsp # imm = 0x1850
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x3b507
movb $0x1, -0x1(%rbp)
jmp 0x3b9da
leaq -0x1820(%rbp), %rdi
xorl %esi, %esi
movl $0x1800, %edx # imm = 0x1800
callq 0x25180
movl $0x0, -0x1824(%rbp)
cmpl $0x100, -0x1824(%rbp) # imm = 0x100
jge 0x3b6f8
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1824(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x182a(%rbp)
movzwl -0x182a(%rbp), %eax
sarl $0x8, %eax
movl $0x100, %ecx # imm = 0x100
cltd
idivl %ecx
movl %edx, -0x1830(%rbp)
movzwl -0x182a(%rbp), %eax
cmpl $0x0, %eax
jne 0x3b57f
cmpl $0x0, -0x1824(%rbp)
jne 0x3b6e2
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x3b5de
movw -0x182a(%rbp), %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movw -0x182a(%rbp), %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
jmp 0x3b6c6
movzwl -0x182a(%rbp), %eax
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3b611
movzwl -0x182a(%rbp), %eax
movl %eax, -0x184c(%rbp)
jmp 0x3b630
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0x8(%rax), %eax
movl %eax, -0x184c(%rbp)
movl -0x184c(%rbp), %eax
movw %ax, %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x8(%rax)
movzwl -0x182a(%rbp), %eax
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jle 0x3b685
movzwl -0x182a(%rbp), %eax
movl %eax, -0x1850(%rbp)
jmp 0x3b6a4
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x1850(%rbp)
movl -0x1850(%rbp), %eax
movw %ax, %cx
movslq -0x1830(%rbp), %rdx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0xa(%rax)
movslq -0x1830(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x3b6e4
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x3b524
leaq -0x1820(%rbp), %rdi
movl $0x100, %esi # imm = 0x100
movl $0x18, %edx
leaq 0x2e0(%rip), %rcx # 0x3b9f0
callq 0x25540
movl $0x0, -0x1824(%rbp)
cmpl $0x100, -0x1824(%rbp) # imm = 0x100
jge 0x3b911
movslq -0x1824(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x3b74e
jmp 0x3b911
movslq -0x1824(%rbp), %rcx
leaq -0x1820(%rbp), %rax
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl 0xa(%rax), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
subl %ecx, %eax
addl $0x1, %eax
movl %eax, -0x1838(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x1838(%rbp), %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x1840(%rbp)
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x3b7d2
movb $0x1, -0x1(%rbp)
jmp 0x3b9da
movq -0x1840(%rbp), %rdi
movslq -0x1838(%rbp), %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x25180
movl $0x1, -0x1834(%rbp)
cmpl $0x100, -0x1834(%rbp) # imm = 0x100
jge 0x3b8fb
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movslq -0x1834(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x1842(%rbp)
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jl 0x3b8e5
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0xa(%rcx), %ecx
cmpl %ecx, %eax
jg 0x3b8e5
movzwl -0x1842(%rbp), %eax
cmpl $0x0, %eax
je 0x3b8e5
movzwl -0x1842(%rbp), %eax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x8(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x1848(%rbp)
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x3b8ca
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jle 0x3b8e3
movl -0x1834(%rbp), %eax
movb %al, %dl
movq -0x1840(%rbp), %rax
movslq -0x1848(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x3b8e5
jmp 0x3b8e7
movl -0x1834(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1834(%rbp)
jmp 0x3b7f5
jmp 0x3b8fd
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x3b71f
movl -0x1824(%rbp), %eax
movl %eax, -0x1828(%rbp)
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movl -0x1828(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdi
shlq $0x4, %rdi
callq *%rax
movq -0x10(%rbp), %rcx
movq %rax, 0x70(%rcx)
cmpq $0x0, %rax
jne 0x3b951
movb $0x1, -0x1(%rbp)
jmp 0x3b9da
movl $0x0, -0x1824(%rbp)
movl -0x1824(%rbp), %eax
cmpl -0x1828(%rbp), %eax
jge 0x3b9b4
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x1824(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x1824(%rbp), %rdx
leaq -0x1820(%rbp), %rcx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x1824(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1824(%rbp)
jmp 0x3b95b
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movslq -0x1824(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x25180
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x1850, %rsp # imm = 0x1850
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
create_fromuni:
push rbp
mov rbp, rsp
sub rsp, 1850h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_3B507
mov [rbp+var_1], 1
jmp loc_3B9DA
loc_3B507:
lea rdi, [rbp+var_1820]
xor esi, esi
mov edx, 1800h
call _memset
mov [rbp+var_1824], 0
loc_3B524:
cmp [rbp+var_1824], 100h
jge loc_3B6F8
mov rax, [rbp+var_10]
mov rax, [rax+68h]
movsxd rcx, [rbp+var_1824]
mov ax, [rax+rcx*2]
mov [rbp+var_182A], ax
movzx eax, [rbp+var_182A]
sar eax, 8
mov ecx, 100h
cdq
idiv ecx
mov [rbp+var_1830], edx
movzx eax, [rbp+var_182A]
cmp eax, 0
jnz short loc_3B57F
cmp [rbp+var_1824], 0
jnz loc_3B6E2
loc_3B57F:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
cmp dword ptr [rax], 0
jnz short loc_3B5DE
mov cx, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+8], cx
mov cx, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+0Ah], cx
jmp loc_3B6C6
loc_3B5DE:
movzx eax, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
cmp eax, ecx
jge short loc_3B611
movzx eax, [rbp+var_182A]
mov [rbp+var_184C], eax
jmp short loc_3B630
loc_3B611:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+8]
mov [rbp+var_184C], eax
loc_3B630:
mov eax, [rbp+var_184C]
mov cx, ax
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+8], cx
movzx eax, [rbp+var_182A]
movsxd rdx, [rbp+var_1830]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+0Ah]
cmp eax, ecx
jle short loc_3B685
movzx eax, [rbp+var_182A]
mov [rbp+var_1850], eax
jmp short loc_3B6A4
loc_3B685:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+0Ah]
mov [rbp+var_1850], eax
loc_3B6A4:
mov eax, [rbp+var_1850]
mov cx, ax
movsxd rdx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rdx, 18h
add rax, rdx
mov [rax+0Ah], cx
loc_3B6C6:
movsxd rcx, [rbp+var_1830]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
mov ecx, [rax]
add ecx, 1
mov [rax], ecx
loc_3B6E2:
jmp short $+2
loc_3B6E4:
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp loc_3B524
loc_3B6F8:
lea rdi, [rbp+var_1820]
mov esi, 100h
mov edx, 18h
lea rcx, pcmp
call _qsort
mov [rbp+var_1824], 0
loc_3B71F:
cmp [rbp+var_1824], 100h
jge loc_3B911
movsxd rcx, [rbp+var_1824]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
cmp dword ptr [rax], 0
jnz short loc_3B74E
jmp loc_3B911
loc_3B74E:
movsxd rcx, [rbp+var_1824]
lea rax, [rbp+var_1820]
imul rcx, 18h
add rax, rcx
movzx eax, word ptr [rax+0Ah]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
sub eax, ecx
add eax, 1
mov [rbp+var_1838], eax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
movsxd rdi, [rbp+var_1838]
shl rdi, 0
call rax
mov [rbp+var_1840], rax
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
mov [rcx+10h], rax
cmp rax, 0
jnz short loc_3B7D2
mov [rbp+var_1], 1
jmp loc_3B9DA
loc_3B7D2:
mov rdi, [rbp+var_1840]
movsxd rdx, [rbp+var_1838]
shl rdx, 0
xor esi, esi
call _memset
mov [rbp+var_1834], 1
loc_3B7F5:
cmp [rbp+var_1834], 100h
jge loc_3B8FB
mov rax, [rbp+var_10]
mov rax, [rax+68h]
movsxd rcx, [rbp+var_1834]
mov ax, [rax+rcx*2]
mov [rbp+var_1842], ax
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
cmp eax, ecx
jl loc_3B8E5
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+0Ah]
cmp eax, ecx
jg short loc_3B8E5
movzx eax, [rbp+var_1842]
cmp eax, 0
jz short loc_3B8E5
movzx eax, [rbp+var_1842]
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
movzx ecx, word ptr [rcx+8]
sub eax, ecx
mov [rbp+var_1848], eax
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
cmp byte ptr [rax+rcx], 0
jz short loc_3B8CA
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
movzx eax, byte ptr [rax+rcx]
cmp eax, 7Fh
jle short loc_3B8E3
loc_3B8CA:
mov eax, [rbp+var_1834]
mov dl, al
mov rax, [rbp+var_1840]
movsxd rcx, [rbp+var_1848]
mov [rax+rcx], dl
loc_3B8E3:
jmp short $+2
loc_3B8E5:
jmp short $+2
loc_3B8E7:
mov eax, [rbp+var_1834]
add eax, 1
mov [rbp+var_1834], eax
jmp loc_3B7F5
loc_3B8FB:
jmp short $+2
loc_3B8FD:
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp loc_3B71F
loc_3B911:
mov eax, [rbp+var_1824]
mov [rbp+var_1828], eax
mov rax, [rbp+var_18]
mov rax, [rax+80h]
mov ecx, [rbp+var_1828]
add ecx, 1
movsxd rdi, ecx
shl rdi, 4
call rax
mov rcx, [rbp+var_10]
mov [rcx+70h], rax
cmp rax, 0
jnz short loc_3B951
mov [rbp+var_1], 1
jmp loc_3B9DA
loc_3B951:
mov [rbp+var_1824], 0
loc_3B95B:
mov eax, [rbp+var_1824]
cmp eax, [rbp+var_1828]
jge short loc_3B9B4
mov rax, [rbp+var_10]
mov rax, [rax+70h]
movsxd rcx, [rbp+var_1824]
shl rcx, 4
add rax, rcx
movsxd rdx, [rbp+var_1824]
lea rcx, [rbp+var_1820]
imul rdx, 18h
add rcx, rdx
mov rdx, [rcx+8]
mov [rax], rdx
mov rcx, [rcx+10h]
mov [rax+8], rcx
mov eax, [rbp+var_1824]
add eax, 1
mov [rbp+var_1824], eax
jmp short loc_3B95B
loc_3B9B4:
mov rax, [rbp+var_10]
mov rdi, [rax+70h]
movsxd rax, [rbp+var_1824]
shl rax, 4
add rdi, rax
xor esi, esi
mov edx, 10h
call _memset
mov [rbp+var_1], 0
loc_3B9DA:
mov al, [rbp+var_1]
add rsp, 1850h
pop rbp
retn
|
char create_fromuni(long long a1, long long a2)
{
long long v2; // rax
_QWORD *v3; // rax
unsigned __int16 v5; // [rsp+0h] [rbp-1850h]
__int16 v6; // [rsp+4h] [rbp-184Ch]
int v7; // [rsp+8h] [rbp-1848h]
unsigned __int16 v8; // [rsp+Eh] [rbp-1842h]
long long v9; // [rsp+10h] [rbp-1840h]
int v10; // [rsp+18h] [rbp-1838h]
int k; // [rsp+1Ch] [rbp-1834h]
int v12; // [rsp+20h] [rbp-1830h]
unsigned __int16 v13; // [rsp+26h] [rbp-182Ah]
int v14; // [rsp+28h] [rbp-1828h]
int i; // [rsp+2Ch] [rbp-1824h]
int j; // [rsp+2Ch] [rbp-1824h]
int m; // [rsp+2Ch] [rbp-1824h]
_DWORD v18[1538]; // [rsp+30h] [rbp-1820h] BYREF
long long v19; // [rsp+1838h] [rbp-18h]
long long v20; // [rsp+1840h] [rbp-10h]
v20 = a1;
v19 = a2;
if ( !*(_QWORD *)(a1 + 104) )
return 1;
memset(v18, 0LL, 6144LL);
for ( i = 0; i < 256; ++i )
{
v13 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * i);
v12 = ((int)v13 >> 8) % 256;
if ( v13 || !i )
{
if ( v18[6 * v12] )
{
if ( v13 >= (int)LOWORD(v18[6 * v12 + 2]) )
v6 = v18[6 * v12 + 2];
else
v6 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * i);
LOWORD(v18[6 * v12 + 2]) = v6;
if ( v13 <= (int)HIWORD(v18[6 * v12 + 2]) )
v5 = HIWORD(v18[6 * v12 + 2]);
else
v5 = v13;
HIWORD(v18[6 * v12 + 2]) = v5;
}
else
{
LOWORD(v18[6 * v12 + 2]) = v13;
HIWORD(v18[6 * v12 + 2]) = v13;
}
++v18[6 * v12];
}
}
qsort(v18, 256LL, 24LL, pcmp);
for ( j = 0; j < 256 && v18[6 * j]; ++j )
{
v10 = HIWORD(v18[6 * j + 2]) - LOWORD(v18[6 * j + 2]) + 1;
v9 = (*(long long ( **)(_QWORD))(v19 + 128))(v10);
*(_QWORD *)&v18[6 * j + 4] = v9;
if ( !v9 )
return 1;
memset(v9, 0LL, v10);
for ( k = 1; k < 256; ++k )
{
v8 = *(_WORD *)(*(_QWORD *)(v20 + 104) + 2LL * k);
if ( v8 >= (int)LOWORD(v18[6 * j + 2]) && v8 <= (int)HIWORD(v18[6 * j + 2]) )
{
if ( v8 )
{
v7 = v8 - LOWORD(v18[6 * j + 2]);
if ( !*(_BYTE *)(v9 + v7) || *(unsigned __int8 *)(v9 + v7) > 0x7Fu )
*(_BYTE *)(v9 + v7) = k;
}
}
}
}
v14 = j;
v2 = (*(long long ( **)(long long))(v19 + 128))(16LL * (j + 1));
*(_QWORD *)(v20 + 112) = v2;
if ( !v2 )
return 1;
for ( m = 0; m < v14; ++m )
{
v3 = (_QWORD *)(16LL * m + *(_QWORD *)(v20 + 112));
*v3 = *(_QWORD *)&v18[6 * m + 2];
v3[1] = *(_QWORD *)&v18[6 * m + 4];
}
memset(16LL * m + *(_QWORD *)(v20 + 112), 0LL, 16LL);
return 0;
}
|
create_fromuni:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1850
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x0013b507
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013b9da
LAB_0013b507:
LEA RDI,[RBP + -0x1820]
XOR ESI,ESI
MOV EDX,0x1800
CALL 0x00125180
MOV dword ptr [RBP + -0x1824],0x0
LAB_0013b524:
CMP dword ptr [RBP + -0x1824],0x100
JGE 0x0013b6f8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOVSXD RCX,dword ptr [RBP + -0x1824]
MOV AX,word ptr [RAX + RCX*0x2]
MOV word ptr [RBP + -0x182a],AX
MOVZX EAX,word ptr [RBP + -0x182a]
SAR EAX,0x8
MOV ECX,0x100
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x1830],EDX
MOVZX EAX,word ptr [RBP + -0x182a]
CMP EAX,0x0
JNZ 0x0013b57f
CMP dword ptr [RBP + -0x1824],0x0
JNZ 0x0013b6e2
LAB_0013b57f:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
CMP dword ptr [RAX],0x0
JNZ 0x0013b5de
MOV CX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0x8],CX
MOV CX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0xa],CX
JMP 0x0013b6c6
LAB_0013b5de:
MOVZX EAX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
CMP EAX,ECX
JGE 0x0013b611
MOVZX EAX,word ptr [RBP + -0x182a]
MOV dword ptr [RBP + -0x184c],EAX
JMP 0x0013b630
LAB_0013b611:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x184c],EAX
LAB_0013b630:
MOV EAX,dword ptr [RBP + -0x184c]
MOV CX,AX
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0x8],CX
MOVZX EAX,word ptr [RBP + -0x182a]
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0xa]
CMP EAX,ECX
JLE 0x0013b685
MOVZX EAX,word ptr [RBP + -0x182a]
MOV dword ptr [RBP + -0x1850],EAX
JMP 0x0013b6a4
LAB_0013b685:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x1850],EAX
LAB_0013b6a4:
MOV EAX,dword ptr [RBP + -0x1850]
MOV CX,AX
MOVSXD RDX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RAX,RDX
MOV word ptr [RAX + 0xa],CX
LAB_0013b6c6:
MOVSXD RCX,dword ptr [RBP + -0x1830]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
MOV dword ptr [RAX],ECX
LAB_0013b6e2:
JMP 0x0013b6e4
LAB_0013b6e4:
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0013b524
LAB_0013b6f8:
LEA RDI,[RBP + -0x1820]
MOV ESI,0x100
MOV EDX,0x18
LEA RCX,[0x13b9f0]
CALL 0x00125540
MOV dword ptr [RBP + -0x1824],0x0
LAB_0013b71f:
CMP dword ptr [RBP + -0x1824],0x100
JGE 0x0013b911
MOVSXD RCX,dword ptr [RBP + -0x1824]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
CMP dword ptr [RAX],0x0
JNZ 0x0013b74e
JMP 0x0013b911
LAB_0013b74e:
MOVSXD RCX,dword ptr [RBP + -0x1824]
LEA RAX,[RBP + -0x1820]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOVZX EAX,word ptr [RAX + 0xa]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
SUB EAX,ECX
ADD EAX,0x1
MOV dword ptr [RBP + -0x1838],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOVSXD RDI,dword ptr [RBP + -0x1838]
SHL RDI,0x0
CALL RAX
MOV qword ptr [RBP + -0x1840],RAX
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOV qword ptr [RCX + 0x10],RAX
CMP RAX,0x0
JNZ 0x0013b7d2
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013b9da
LAB_0013b7d2:
MOV RDI,qword ptr [RBP + -0x1840]
MOVSXD RDX,dword ptr [RBP + -0x1838]
SHL RDX,0x0
XOR ESI,ESI
CALL 0x00125180
MOV dword ptr [RBP + -0x1834],0x1
LAB_0013b7f5:
CMP dword ptr [RBP + -0x1834],0x100
JGE 0x0013b8fb
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOVSXD RCX,dword ptr [RBP + -0x1834]
MOV AX,word ptr [RAX + RCX*0x2]
MOV word ptr [RBP + -0x1842],AX
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
CMP EAX,ECX
JL 0x0013b8e5
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0xa]
CMP EAX,ECX
JG 0x0013b8e5
MOVZX EAX,word ptr [RBP + -0x1842]
CMP EAX,0x0
JZ 0x0013b8e5
MOVZX EAX,word ptr [RBP + -0x1842]
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOVZX ECX,word ptr [RCX + 0x8]
SUB EAX,ECX
MOV dword ptr [RBP + -0x1848],EAX
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
CMP byte ptr [RAX + RCX*0x1],0x0
JZ 0x0013b8ca
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
CMP EAX,0x7f
JLE 0x0013b8e3
LAB_0013b8ca:
MOV EAX,dword ptr [RBP + -0x1834]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x1840]
MOVSXD RCX,dword ptr [RBP + -0x1848]
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0013b8e3:
JMP 0x0013b8e5
LAB_0013b8e5:
JMP 0x0013b8e7
LAB_0013b8e7:
MOV EAX,dword ptr [RBP + -0x1834]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1834],EAX
JMP 0x0013b7f5
LAB_0013b8fb:
JMP 0x0013b8fd
LAB_0013b8fd:
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0013b71f
LAB_0013b911:
MOV EAX,dword ptr [RBP + -0x1824]
MOV dword ptr [RBP + -0x1828],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x80]
MOV ECX,dword ptr [RBP + -0x1828]
ADD ECX,0x1
MOVSXD RDI,ECX
SHL RDI,0x4
CALL RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x70],RAX
CMP RAX,0x0
JNZ 0x0013b951
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0013b9da
LAB_0013b951:
MOV dword ptr [RBP + -0x1824],0x0
LAB_0013b95b:
MOV EAX,dword ptr [RBP + -0x1824]
CMP EAX,dword ptr [RBP + -0x1828]
JGE 0x0013b9b4
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x70]
MOVSXD RCX,dword ptr [RBP + -0x1824]
SHL RCX,0x4
ADD RAX,RCX
MOVSXD RDX,dword ptr [RBP + -0x1824]
LEA RCX,[RBP + -0x1820]
IMUL RDX,RDX,0x18
ADD RCX,RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX],RDX
MOV RCX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV EAX,dword ptr [RBP + -0x1824]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1824],EAX
JMP 0x0013b95b
LAB_0013b9b4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x70]
MOVSXD RAX,dword ptr [RBP + -0x1824]
SHL RAX,0x4
ADD RDI,RAX
XOR ESI,ESI
MOV EDX,0x10
CALL 0x00125180
MOV byte ptr [RBP + -0x1],0x0
LAB_0013b9da:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x1850
POP RBP
RET
|
int1 create_fromuni(long param_1,long param_2)
{
ushort uVar1;
ushort uVar2;
int iVar3;
void *__s;
long lVar4;
int8 *puVar5;
uint uVar6;
int local_183c;
int local_182c;
int local_1828 [2];
ushort auStack_1820 [4];
int8 auStack_1818 [767];
long local_20;
long local_18;
int1 local_9;
if (*(long *)(param_1 + 0x68) == 0) {
local_9 = 1;
}
else {
local_20 = param_2;
local_18 = param_1;
memset(local_1828,0,0x1800);
for (local_182c = 0; local_182c < 0x100; local_182c = local_182c + 1) {
uVar1 = *(ushort *)(*(long *)(local_18 + 0x68) + (long)local_182c * 2);
uVar6 = (uint)((int)(uint)uVar1 >> 8) % 0x100;
if ((uVar1 != 0) || (local_182c == 0)) {
if (local_1828[(long)(int)uVar6 * 6] == 0) {
auStack_1820[(long)(int)uVar6 * 0xc] = uVar1;
auStack_1820[(long)(int)uVar6 * 0xc + 1] = uVar1;
}
else {
uVar2 = uVar1;
if (auStack_1820[(long)(int)uVar6 * 0xc] <= uVar1) {
uVar2 = auStack_1820[(long)(int)uVar6 * 0xc];
}
auStack_1820[(long)(int)uVar6 * 0xc] = uVar2;
if (uVar1 <= auStack_1820[(long)(int)uVar6 * 0xc + 1]) {
uVar1 = auStack_1820[(long)(int)uVar6 * 0xc + 1];
}
auStack_1820[(long)(int)uVar6 * 0xc + 1] = uVar1;
}
local_1828[(long)(int)uVar6 * 6] = local_1828[(long)(int)uVar6 * 6] + 1;
}
}
qsort(local_1828,0x100,0x18,pcmp);
local_182c = 0;
while ((iVar3 = local_182c, local_182c < 0x100 && (local_1828[(long)local_182c * 6] != 0))) {
iVar3 = ((uint)auStack_1820[(long)local_182c * 0xc + 1] -
(uint)auStack_1820[(long)local_182c * 0xc]) + 1;
__s = (void *)(**(code **)(local_20 + 0x80))((long)iVar3);
auStack_1818[(long)local_182c * 3] = __s;
if (__s == (void *)0x0) {
return 1;
}
memset(__s,0,(long)iVar3);
for (local_183c = 1; local_183c < 0x100; local_183c = local_183c + 1) {
uVar1 = *(ushort *)(*(long *)(local_18 + 0x68) + (long)local_183c * 2);
if ((((auStack_1820[(long)local_182c * 0xc] <= uVar1) &&
(uVar1 <= auStack_1820[(long)local_182c * 0xc + 1])) && (uVar1 != 0)) &&
((iVar3 = (uint)uVar1 - (uint)auStack_1820[(long)local_182c * 0xc],
*(char *)((long)__s + (long)iVar3) == '\0' ||
(0x7f < *(byte *)((long)__s + (long)iVar3))))) {
*(char *)((long)__s + (long)iVar3) = (char)local_183c;
}
}
local_182c = local_182c + 1;
}
lVar4 = (**(code **)(local_20 + 0x80))((long)(local_182c + 1) << 4);
*(long *)(local_18 + 0x70) = lVar4;
if (lVar4 == 0) {
local_9 = 1;
}
else {
for (local_182c = 0; local_182c < iVar3; local_182c = local_182c + 1) {
puVar5 = (int8 *)(*(long *)(local_18 + 0x70) + (long)local_182c * 0x10);
*puVar5 = *(int8 *)(auStack_1820 + (long)local_182c * 0xc);
puVar5[1] = auStack_1818[(long)local_182c * 3];
}
memset((void *)(*(long *)(local_18 + 0x70) + (long)local_182c * 0x10),0,0x10);
local_9 = 0;
}
}
return local_9;
}
|
|
57,644
|
common_sampler_init(llama_model const*, common_params_sampling const&)
|
monkey531[P]llama/common/sampling.cpp
|
struct common_sampler * common_sampler_init(const struct llama_model * model, const struct common_params_sampling & params) {
const llama_vocab * vocab = llama_model_get_vocab(model);
llama_sampler_chain_params lparams = llama_sampler_chain_default_params();
lparams.no_perf = params.no_perf;
std::vector<const char *> trigger_words;
trigger_words.reserve(params.grammar_trigger_words.size());
for (const auto & str : params.grammar_trigger_words) {
trigger_words.push_back(str.word.c_str());
}
struct llama_sampler * grmr;
if (params.grammar.compare(0, 11, "%llguidance") == 0) {
#ifdef LLAMA_USE_LLGUIDANCE
grmr = llama_sampler_init_llg(vocab, "lark", params.grammar.c_str());
#else
GGML_ABORT("llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
#endif // LLAMA_USE_LLGUIDANCE
} else {
grmr = params.grammar_lazy
? llama_sampler_init_grammar_lazy(vocab, params.grammar.c_str(), "root",
trigger_words.data(), trigger_words.size(),
params.grammar_trigger_tokens.data(), params.grammar_trigger_tokens.size())
: llama_sampler_init_grammar(vocab, params.grammar.c_str(), "root");
}
auto * result = new common_sampler {
/* .params = */ params,
/* .grmr = */ grmr,
/* .chain = */ llama_sampler_chain_init(lparams),
/* .prev = */ ring_buffer<llama_token>(std::max(32, params.n_prev)),
/* .cur = */ {},
/* .cur_p = */ {},
};
llama_sampler_chain_add(result->chain,
llama_sampler_init_logit_bias(
llama_vocab_n_tokens(vocab),
params.logit_bias.size(),
params.logit_bias.data()));
if (params.mirostat == 0) {
for (const auto & cnstr : params.samplers) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY:
{
std::vector<const char *> c_breakers;
c_breakers.reserve(params.dry_sequence_breakers.size());
for (const auto & str : params.dry_sequence_breakers) {
c_breakers.push_back(str.c_str());
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dry (vocab, llama_model_n_ctx_train(model), params.dry_multiplier, params.dry_base, params.dry_allowed_length, params.dry_penalty_last_n, c_breakers.data(), c_breakers.size()));
}
break;
case COMMON_SAMPLER_TYPE_TOP_K:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_k (params.top_k));
break;
case COMMON_SAMPLER_TYPE_TOP_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_top_p (params.top_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_MIN_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_min_p (params.min_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_XTC:
llama_sampler_chain_add(result->chain, llama_sampler_init_xtc (params.xtc_probability, params.xtc_threshold, params.min_keep, params.seed));
break;
case COMMON_SAMPLER_TYPE_TYPICAL_P:
llama_sampler_chain_add(result->chain, llama_sampler_init_typical (params.typ_p, params.min_keep));
break;
case COMMON_SAMPLER_TYPE_TEMPERATURE:
llama_sampler_chain_add(result->chain, llama_sampler_init_temp_ext (params.temp, params.dynatemp_range, params.dynatemp_exponent));
break;
case COMMON_SAMPLER_TYPE_INFILL:
llama_sampler_chain_add(result->chain, llama_sampler_init_infill (vocab));
break;
case COMMON_SAMPLER_TYPE_PENALTIES:
llama_sampler_chain_add(result->chain, llama_sampler_init_penalties(params.penalty_last_n, params.penalty_repeat, params.penalty_freq, params.penalty_present));
break;
default:
GGML_ASSERT(false && "unknown sampler type");
}
}
llama_sampler_chain_add(result->chain, llama_sampler_init_dist(params.seed));
} else if (params.mirostat == 1) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat(llama_vocab_n_tokens(vocab), params.seed, params.mirostat_tau, params.mirostat_eta, 100));
} else if (params.mirostat == 2) {
llama_sampler_chain_add(result->chain, llama_sampler_init_temp(params.temp));
llama_sampler_chain_add(result->chain, llama_sampler_init_mirostat_v2(params.seed, params.mirostat_tau, params.mirostat_eta));
} else {
GGML_ASSERT(false && "unknown mirostat version");
}
return result;
}
|
O3
|
cpp
|
common_sampler_init(llama_model const*, common_params_sampling const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, 0x58(%rsp)
callq 0x1b180
movq %rax, 0x8(%rsp)
callq 0x1ad50
movb 0x61(%rbx), %bpl
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0xc8(%rbx), %rax
subq 0xc0(%rbx), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rsi
callq 0xce190
movq 0xc0(%rbx), %r15
movq 0xc8(%rbx), %r13
cmpq %r13, %r15
je 0xccaab
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r12
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0xce7d2
addq $0x28, %r15
cmpq %r13, %r15
jne 0xcca8f
leaq 0x98(%rbx), %rdi
leaq 0x2878c(%rip), %rcx # 0xf5245
movl $0xb, %edx
xorl %esi, %esi
callq 0x1ab80
testl %eax, %eax
je 0xcceb3
movq 0x98(%rbx), %rsi
cmpb $0x1, 0xb8(%rbx)
jne 0xccb1a
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
subq %rcx, %r8
sarq $0x3, %r8
movq 0xd8(%rbx), %r9
movq 0xe0(%rbx), %rax
subq %r9, %rax
sarq $0x2, %rax
movq %rax, (%rsp)
leaq 0x27d61(%rip), %rdx # 0xf486f
movq 0x8(%rsp), %rdi
callq 0x1a740
jmp 0xccb2b
leaq 0x27d4e(%rip), %rdx # 0xf486f
movq 0x8(%rsp), %rdi
callq 0x1a190
movq %rax, %r12
movl $0x1b8, %edi # imm = 0x1B8
callq 0x1a8c0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x54326
movq %r12, 0x138(%r14)
movzbl %bpl, %edi
callq 0x1a4e0
movq %rax, 0x140(%r14)
movl 0x4(%rbx), %eax
cmpl $0x21, %eax
movl $0x20, %esi
cmovgel %eax, %esi
movq %rsi, 0x148(%r14)
movq %r14, %rdi
addq $0x168, %rdi # imm = 0x168
xorps %xmm0, %xmm0
movups %xmm0, 0x150(%r14)
movq $0x0, 0x160(%r14)
leaq 0x10(%rsp), %rdx
callq 0x78ca2
xorps %xmm0, %xmm0
movups %xmm0, 0x1a0(%r14)
movups %xmm0, 0x190(%r14)
movups %xmm0, 0x180(%r14)
movq $0x0, 0x1b0(%r14)
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1b110
movq 0x120(%rbx), %rdx
movq 0x128(%rbx), %rsi
subq %rdx, %rsi
shrq $0x3, %rsi
movl %eax, %edi
callq 0x1ae80
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movl 0x54(%rbx), %eax
cmpl $0x2, %eax
je 0xcce3b
cmpl $0x1, %eax
je 0xccdf4
testl %eax, %eax
jne 0xcceee
movq 0x80(%rbx), %r15
movq 0x88(%rbx), %rbp
cmpq %rbp, %r15
je 0xcce71
leaq 0x10(%rsp), %r13
movq %rbp, 0x50(%rsp)
movl (%r15), %eax
decl %eax
cmpl $0x9, %eax
ja 0xccecd
leaq 0x28433(%rip), %rcx # 0xf5080
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x70(%rbx), %rsi
subq 0x68(%rbx), %rsi
sarq $0x5, %rsi
movq %r13, %rdi
callq 0xce190
movq 0x68(%rbx), %r12
movq 0x70(%rbx), %rbp
cmpq %rbp, %r12
je 0xccd8d
movq (%r12), %rax
movq %rax, 0x60(%rsp)
movq %r13, %rdi
leaq 0x60(%rsp), %rsi
callq 0xce7d2
addq $0x20, %r12
jmp 0xccc83
movq 0x140(%r14), %r12
movl 0x34(%rbx), %edi
movss 0x38(%rbx), %xmm0
movss 0x3c(%rbx), %xmm1
movss 0x40(%rbx), %xmm2
callq 0x1a700
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x24(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1a6c0
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
movss 0x2c(%rbx), %xmm1
movss 0x30(%rbx), %xmm2
callq 0x1b0d0
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x14(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1a130
jmp 0xccd70
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1ad00
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x18(%rbx), %xmm0
movslq 0xc(%rbx), %rdi
callq 0x1ac30
jmp 0xccd70
movq 0x140(%r14), %r12
movl 0x10(%rbx), %edi
callq 0x1a410
jmp 0xccd70
movq 0x140(%r14), %r12
movss 0x1c(%rbx), %xmm0
movss 0x20(%rbx), %xmm1
movslq 0xc(%rbx), %rdi
movl (%rbx), %esi
callq 0x1a2c0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
addq $0x4, %r15
cmpq %rbp, %r15
jne 0xccc38
jmp 0xcce71
movq 0x140(%r14), %r12
movq 0x58(%rsp), %rdi
callq 0x1a880
movss 0x44(%rbx), %xmm0
movss 0x48(%rbx), %xmm1
movl 0x4c(%rbx), %edx
movl 0x50(%rbx), %ecx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
subq %r8, %r9
sarq $0x3, %r9
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x1aeb0
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x50(%rsp), %rbp
je 0xccd7b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
jmp 0xccd7b
movq 0x140(%r14), %r12
movss 0x28(%rbx), %xmm0
callq 0x1a550
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x140(%r14), %r12
movq 0x8(%rsp), %rdi
callq 0x1b110
movl (%rbx), %esi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
movl %eax, %edi
movl $0x64, %edx
callq 0x1b170
jmp 0xcce7f
movq 0x140(%r14), %r15
movss 0x28(%rbx), %xmm0
callq 0x1a550
movq %r15, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x140(%r14), %r12
movl (%rbx), %edi
movss 0x58(%rbx), %xmm0
movss 0x5c(%rbx), %xmm1
callq 0x1ae90
jmp 0xcce7f
movq 0x140(%r14), %r12
movl (%rbx), %edi
callq 0x1ad70
movq %r12, %rdi
movq %rax, %rsi
callq 0x1a990
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xccea1
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28397(%rip), %rdi # 0xf5251
leaq 0x283de(%rip), %rdx # 0xf529f
movl $0xa5, %esi
xorl %eax, %eax
callq 0x1aec0
leaq 0x2837d(%rip), %rdi # 0xf5251
leaq 0x1932f(%rip), %rdx # 0xe620a
leaq 0x283f5(%rip), %rcx # 0xf52d7
movl $0xe5, %esi
xorl %eax, %eax
callq 0x1aec0
leaq 0x2835c(%rip), %rdi # 0xf5251
leaq 0x1930e(%rip), %rdx # 0xe620a
leaq 0x283f4(%rip), %rcx # 0xf52f7
movl $0xf0, %esi
xorl %eax, %eax
callq 0x1aec0
jmp 0xccf53
jmp 0xccf13
movq %rax, %rbx
movq %r14, %rdi
callq 0x21742
jmp 0xccf23
movq %rax, %rbx
movl $0x1b8, %esi # imm = 0x1B8
movq %r14, %rdi
jmp 0xccf4c
jmp 0xccf53
jmp 0xccf37
jmp 0xccf53
jmp 0xccf53
jmp 0xccf53
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xccf56
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
jmp 0xccf56
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xccf6d
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x1a8f0
movq %rbx, %rdi
callq 0x1afd0
|
_Z19common_sampler_initPK11llama_modelRK22common_params_sampling:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rsi
mov [rsp+98h+var_40], rdi
call _llama_model_get_vocab
mov [rsp+98h+var_90], rax
call _llama_sampler_chain_default_params
mov bpl, [rbx+61h]
xorps xmm0, xmm0
lea rdi, [rsp+98h+var_68]
movaps xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rax, [rbx+0C8h]
sub rax, [rbx+0C0h]
sar rax, 3
mov rsi, 0CCCCCCCCCCCCCCCDh
imul rsi, rax
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r15, [rbx+0C0h]
mov r13, [rbx+0C8h]
cmp r15, r13
jz short loc_CCAAB
lea r14, [rsp+98h+var_68]
lea r12, [rsp+98h+var_88]
loc_CCA8F:
mov rax, [r15]
mov [rsp+98h+var_88], rax
mov rdi, r14
mov rsi, r12
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r15, 28h ; '('
cmp r15, r13
jnz short loc_CCA8F
loc_CCAAB:
lea rdi, [rbx+98h]
lea rcx, aLlguidance; "%llguidance"
mov edx, 0Bh
xor esi, esi
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEmmPKc; std::string::compare(ulong,ulong,char const*)
test eax, eax
jz loc_CCEB3
mov rsi, [rbx+98h]
cmp byte ptr [rbx+0B8h], 1
jnz short loc_CCB1A
mov rcx, [rsp+98h+var_68]
mov r8, [rsp+98h+var_60]
sub r8, rcx
sar r8, 3
mov r9, [rbx+0D8h]
mov rax, [rbx+0E0h]
sub rax, r9
sar rax, 2
mov [rsp+98h+var_98], rax
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar_lazy
jmp short loc_CCB2B
loc_CCB1A:
lea rdx, aRoot; "root"
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_grammar
loc_CCB2B:
mov r12, rax
mov edi, 1B8h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rdi, rax; this
mov rsi, rbx; common_params_sampling *
call _ZN22common_params_samplingC2ERKS_; common_params_sampling::common_params_sampling(common_params_sampling const&)
mov [r14+138h], r12
movzx edi, bpl
call _llama_sampler_chain_init
mov [r14+140h], rax
mov eax, [rbx+4]
cmp eax, 21h ; '!'
mov esi, 20h ; ' '
cmovge esi, eax
mov [r14+148h], rsi
mov rdi, r14
add rdi, 168h
xorps xmm0, xmm0
movups xmmword ptr [r14+150h], xmm0
mov qword ptr [r14+160h], 0
lea rdx, [rsp+98h+var_88]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
xorps xmm0, xmm0
movups xmmword ptr [r14+1A0h], xmm0
movups xmmword ptr [r14+190h], xmm0
movups xmmword ptr [r14+180h], xmm0
mov qword ptr [r14+1B0h], 0
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov rdx, [rbx+120h]
mov rsi, [rbx+128h]
sub rsi, rdx
shr rsi, 3
mov edi, eax
call _llama_sampler_init_logit_bias
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov eax, [rbx+54h]
cmp eax, 2
jz loc_CCE3B
cmp eax, 1
jz loc_CCDF4
test eax, eax
jnz loc_CCEEE
mov r15, [rbx+80h]
mov rbp, [rbx+88h]
cmp r15, rbp
jz loc_CCE71
lea r13, [rsp+98h+var_88]
mov [rsp+98h+var_48], rbp
loc_CCC38:
mov eax, [r15]
dec eax; switch 10 cases
cmp eax, 9
ja def_CCC54; jumptable 00000000000CCC54 default case, case 5
lea rcx, jpt_CCC54
movsxd rax, ds:(jpt_CCC54 - 0F5080h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_CCC56:
xorps xmm0, xmm0; jumptable 00000000000CCC54 case 1
movaps xmmword ptr [rsp+98h+var_88], xmm0
mov [rsp+98h+var_78], 0
mov rsi, [rbx+70h]
sub rsi, [rbx+68h]
sar rsi, 5
mov rdi, r13
call _ZNSt6vectorIPKcSaIS1_EE7reserveEm; std::vector<char const*>::reserve(ulong)
mov r12, [rbx+68h]
mov rbp, [rbx+70h]
loc_CCC83:
cmp r12, rbp
jz loc_CCD8D
mov rax, [r12]
mov [rsp+98h+var_38], rax
mov rdi, r13
lea rsi, [rsp+98h+var_38]
call _ZNSt6vectorIPKcSaIS1_EE12emplace_backIJS1_EEERS1_DpOT_; std::vector<char const*>::emplace_back<char const*>(char const* &&)
add r12, 20h ; ' '
jmp short loc_CCC83
loc_CCCA8:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 10
mov edi, [rbx+34h]
movss xmm0, dword ptr [rbx+38h]
movss xmm1, dword ptr [rbx+3Ch]
movss xmm2, dword ptr [rbx+40h]
call _llama_sampler_init_penalties
jmp loc_CCD70
loc_CCCCB:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 6
movss xmm0, dword ptr [rbx+24h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_typical
jmp loc_CCD70
loc_CCCE5:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 7
movss xmm0, dword ptr [rbx+28h]
movss xmm1, dword ptr [rbx+2Ch]
movss xmm2, dword ptr [rbx+30h]
call _llama_sampler_init_temp_ext
jmp short loc_CCD70
loc_CCD02:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 3
movss xmm0, dword ptr [rbx+14h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_top_p
jmp short loc_CCD70
loc_CCD19:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 9
mov rdi, [rsp+98h+var_90]
call _llama_sampler_init_infill
jmp short loc_CCD70
loc_CCD2C:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 4
movss xmm0, dword ptr [rbx+18h]
movsxd rdi, dword ptr [rbx+0Ch]
call _llama_sampler_init_min_p
jmp short loc_CCD70
loc_CCD43:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 2
mov edi, [rbx+10h]
call _llama_sampler_init_top_k
jmp short loc_CCD70
loc_CCD54:
mov r12, [r14+140h]; jumptable 00000000000CCC54 case 8
movss xmm0, dword ptr [rbx+1Ch]
movss xmm1, dword ptr [rbx+20h]
movsxd rdi, dword ptr [rbx+0Ch]
mov esi, [rbx]
call _llama_sampler_init_xtc
loc_CCD70:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
loc_CCD7B:
add r15, 4
cmp r15, rbp
jnz loc_CCC38
jmp loc_CCE71
loc_CCD8D:
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_40]
call _llama_model_n_ctx_train
movss xmm0, dword ptr [rbx+44h]
movss xmm1, dword ptr [rbx+48h]
mov edx, [rbx+4Ch]
mov ecx, [rbx+50h]
mov r8, [rsp+98h+var_88]
mov r9, [rsp+98h+var_88+8]
sub r9, r8
sar r9, 3
mov rdi, [rsp+98h+var_90]
mov esi, eax
call _llama_sampler_init_dry
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
mov rbp, [rsp+98h+var_48]
jz short loc_CCD7B
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CCD7B
loc_CCDF4:
mov r12, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov rdi, [rsp+98h+var_90]
call _llama_vocab_n_tokens
mov esi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
mov edi, eax
mov edx, 64h ; 'd'
call _llama_sampler_init_mirostat
jmp short loc_CCE7F
loc_CCE3B:
mov r15, [r14+140h]
movss xmm0, dword ptr [rbx+28h]
call _llama_sampler_init_temp
mov rdi, r15
mov rsi, rax
call _llama_sampler_chain_add
mov r12, [r14+140h]
mov edi, [rbx]
movss xmm0, dword ptr [rbx+58h]
movss xmm1, dword ptr [rbx+5Ch]
call _llama_sampler_init_mirostat_v2
jmp short loc_CCE7F
loc_CCE71:
mov r12, [r14+140h]
mov edi, [rbx]
call _llama_sampler_init_dist
loc_CCE7F:
mov rdi, r12
mov rsi, rax
call _llama_sampler_chain_add
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_CCEA1
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CCEA1:
mov rax, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_CCEB3:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aLlguidanceCmak; "llguidance (cmake -DLLAMA_LLGUIDANCE=ON"...
mov esi, 0A5h
xor eax, eax
call _ggml_abort
def_CCC54:
lea rdi, aWorkspaceLlm4b_3; jumptable 00000000000CCC54 default case, case 5
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownSa; "false && \"unknown sampler type\""
mov esi, 0E5h
xor eax, eax
call _ggml_abort
loc_CCEEE:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFalseUnknownMi; "false && \"unknown mirostat version\""
mov esi, 0F0h
xor eax, eax
call _ggml_abort
jmp short loc_CCF53
jmp short $+2
loc_CCF13:
mov rbx, rax
mov rdi, r14; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
jmp short loc_CCF23
mov rbx, rax
loc_CCF23:
mov esi, 1B8h
mov rdi, r14
jmp short loc_CCF4C
jmp short loc_CCF53
jmp short loc_CCF37
jmp short loc_CCF53
jmp short loc_CCF53
jmp short loc_CCF53
loc_CCF37:
mov rbx, rax
mov rdi, [rsp+98h+var_88]; void *
test rdi, rdi
jz short loc_CCF56
mov rsi, [rsp+98h+var_78]
sub rsi, rdi; unsigned __int64
loc_CCF4C:
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_CCF56
loc_CCF53:
mov rbx, rax
loc_CCF56:
mov rdi, [rsp+98h+var_68]; void *
test rdi, rdi
jz short loc_CCF6D
mov rsi, [rsp+98h+var_58]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CCF6D:
mov rdi, rbx
call __Unwind_Resume
|
long long common_sampler_init(long long a1, unsigned int *a2)
{
unsigned __int8 v3; // bp
void **v4; // r15
void **i; // r13
long long v6; // rsi
long long inited; // rax
long long v8; // r12
long long v9; // r14
int v10; // eax
unsigned long long v11; // rsi
long long v12; // r12
unsigned int v13; // eax
long long v14; // rax
unsigned int v15; // eax
_DWORD *v16; // r15
_DWORD *v17; // rbp
long long *v18; // r12
long long *v19; // rbp
long long v20; // r12
long long v21; // rax
long long v22; // r12
unsigned int v23; // eax
long long v24; // rax
long long v25; // r12
long long v26; // rax
long long v27; // r12
unsigned int v28; // eax
long long v29; // rax
long long v30; // r15
long long v31; // rax
long long v33; // rax
long long v34; // rbx
long long vocab; // [rsp+8h] [rbp-90h]
void *v36[2]; // [rsp+10h] [rbp-88h] BYREF
long long v37; // [rsp+20h] [rbp-78h]
__int128 v38; // [rsp+30h] [rbp-68h] BYREF
long long v39; // [rsp+40h] [rbp-58h]
_DWORD *v40; // [rsp+50h] [rbp-48h]
long long v41; // [rsp+58h] [rbp-40h]
long long v42[7]; // [rsp+60h] [rbp-38h] BYREF
v41 = a1;
vocab = llama_model_get_vocab(a1, a2);
llama_sampler_chain_default_params();
v3 = *((_BYTE *)a2 + 97);
v38 = 0LL;
v39 = 0LL;
std::vector<char const*>::reserve(
&v38,
0xCCCCCCCCCCCCCCCDLL * ((long long)(*((_QWORD *)a2 + 25) - *((_QWORD *)a2 + 24)) >> 3));
v4 = (void **)*((_QWORD *)a2 + 24);
for ( i = (void **)*((_QWORD *)a2 + 25); v4 != i; v4 += 5 )
{
v36[0] = *v4;
std::vector<char const*>::emplace_back<char const*>(&v38, v36);
}
if ( !(unsigned int)std::string::compare(a2 + 38, 0LL, 11LL, "%llguidance") )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
165LL,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
LABEL_38:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
229LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown sampler type\"");
goto LABEL_39;
}
v6 = *((_QWORD *)a2 + 19);
if ( *((_BYTE *)a2 + 184) == 1 )
inited = llama_sampler_init_grammar_lazy(vocab, v6, "root", v38, (long long)(*((_QWORD *)&v38 + 1) - v38) >> 3);
else
inited = llama_sampler_init_grammar(vocab, v6, "root");
v8 = inited;
v9 = operator new(0x1B8uLL);
common_params_sampling::common_params_sampling((common_params_sampling *)v9, (const common_params_sampling *)a2);
*(_QWORD *)(v9 + 312) = v8;
*(_QWORD *)(v9 + 320) = llama_sampler_chain_init(v3);
v10 = a2[1];
v11 = 32LL;
if ( v10 >= 33 )
v11 = (unsigned int)v10;
*(_QWORD *)(v9 + 328) = v11;
*(_OWORD *)(v9 + 336) = 0LL;
*(_QWORD *)(v9 + 352) = 0LL;
std::vector<int>::vector(v9 + 360, v11);
*(_OWORD *)(v9 + 416) = 0LL;
*(_OWORD *)(v9 + 400) = 0LL;
*(_OWORD *)(v9 + 384) = 0LL;
*(_QWORD *)(v9 + 432) = 0LL;
v12 = *(_QWORD *)(v9 + 320);
v13 = llama_vocab_n_tokens(vocab);
v14 = llama_sampler_init_logit_bias(v13, (*((_QWORD *)a2 + 37) - *((_QWORD *)a2 + 36)) >> 3);
llama_sampler_chain_add(v12, v14);
v15 = a2[21];
if ( v15 == 2 )
{
v30 = *(_QWORD *)(v9 + 320);
v31 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v30, v31);
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_mirostat_v2(*a2, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 == 1 )
{
v25 = *(_QWORD *)(v9 + 320);
v26 = llama_sampler_init_temp(*((float *)a2 + 10));
llama_sampler_chain_add(v25, v26);
v27 = *(_QWORD *)(v9 + 320);
v28 = llama_vocab_n_tokens(vocab);
v29 = llama_sampler_init_mirostat(v28, *a2, 100LL, *((float *)a2 + 22), *((float *)a2 + 23));
goto LABEL_34;
}
if ( v15 )
{
LABEL_39:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
240LL,
"GGML_ASSERT(%s) failed",
"false && \"unknown mirostat version\"");
v34 = v33;
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
_Unwind_Resume(v34);
}
v16 = (_DWORD *)*((_QWORD *)a2 + 16);
v17 = (_DWORD *)*((_QWORD *)a2 + 17);
if ( v16 != v17 )
{
v40 = (_DWORD *)*((_QWORD *)a2 + 17);
while ( 2 )
{
switch ( *v16 )
{
case 1:
*(_OWORD *)v36 = 0LL;
v37 = 0LL;
std::vector<char const*>::reserve(v36, (long long)(*((_QWORD *)a2 + 14) - *((_QWORD *)a2 + 13)) >> 5);
v18 = (long long *)*((_QWORD *)a2 + 13);
v19 = (long long *)*((_QWORD *)a2 + 14);
while ( v18 != v19 )
{
v42[0] = *v18;
std::vector<char const*>::emplace_back<char const*>(v36, v42);
v18 += 4;
}
v22 = *(_QWORD *)(v9 + 320);
v23 = llama_model_n_ctx_train(v41);
v24 = llama_sampler_init_dry(
vocab,
v23,
a2[19],
a2[20],
v36[0],
((char *)v36[1] - (char *)v36[0]) >> 3,
*((float *)a2 + 17),
*((float *)a2 + 18));
llama_sampler_chain_add(v22, v24);
v17 = v40;
if ( v36[0] )
operator delete(v36[0], v37 - (unsigned long long)v36[0]);
goto LABEL_27;
case 2:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_k(a2[4]);
goto LABEL_26;
case 3:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_top_p((int)a2[3], *((float *)a2 + 5));
goto LABEL_26;
case 4:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_min_p((int)a2[3], *((float *)a2 + 6));
goto LABEL_26;
case 6:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_typical((int)a2[3], *((float *)a2 + 9));
goto LABEL_26;
case 7:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_temp_ext(*((float *)a2 + 10), *((float *)a2 + 11), *((float *)a2 + 12));
goto LABEL_26;
case 8:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_xtc((int)a2[3], *a2, *((float *)a2 + 7), *((float *)a2 + 8));
goto LABEL_26;
case 9:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_infill(vocab);
goto LABEL_26;
case 0xA:
v20 = *(_QWORD *)(v9 + 320);
v21 = llama_sampler_init_penalties(a2[13], *((float *)a2 + 14), *((float *)a2 + 15), *((float *)a2 + 16));
LABEL_26:
llama_sampler_chain_add(v20, v21);
LABEL_27:
if ( ++v16 == v17 )
break;
continue;
default:
goto LABEL_38;
}
break;
}
}
v27 = *(_QWORD *)(v9 + 320);
v29 = llama_sampler_init_dist(*a2);
LABEL_34:
llama_sampler_chain_add(v27, v29);
if ( (_QWORD)v38 )
operator delete((void *)v38, v39 - v38);
return v9;
}
|
common_sampler_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
MOV qword ptr [RSP + 0x58],RDI
CALL 0x0011b180
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0011ad50
MOV BPL,byte ptr [RBX + 0x61]
XORPS XMM0,XMM0
LEA RDI,[RSP + 0x30]
MOVAPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RBX + 0xc8]
SUB RAX,qword ptr [RBX + 0xc0]
SAR RAX,0x3
MOV RSI,-0x3333333333333333
IMUL RSI,RAX
LAB_001cca6d:
CALL 0x001ce190
MOV R15,qword ptr [RBX + 0xc0]
MOV R13,qword ptr [RBX + 0xc8]
CMP R15,R13
JZ 0x001ccaab
LEA R14,[RSP + 0x30]
LEA R12,[RSP + 0x10]
LAB_001cca8f:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x10],RAX
LAB_001cca97:
MOV RDI,R14
MOV RSI,R12
CALL 0x001ce7d2
ADD R15,0x28
CMP R15,R13
JNZ 0x001cca8f
LAB_001ccaab:
LEA RDI,[RBX + 0x98]
LAB_001ccab2:
LEA RCX,[0x1f5245]
MOV EDX,0xb
XOR ESI,ESI
CALL 0x0011ab80
TEST EAX,EAX
JZ 0x001cceb3
MOV RSI,qword ptr [RBX + 0x98]
CMP byte ptr [RBX + 0xb8],0x1
JNZ 0x001ccb1a
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x38]
SUB R8,RCX
SAR R8,0x3
MOV R9,qword ptr [RBX + 0xd8]
MOV RAX,qword ptr [RBX + 0xe0]
SUB RAX,R9
SAR RAX,0x2
MOV qword ptr [RSP],RAX
LEA RDX,[0x1f486f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011a740
JMP 0x001ccb2b
LAB_001ccb1a:
LEA RDX,[0x1f486f]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011a190
LAB_001ccb2b:
MOV R12,RAX
LAB_001ccb2e:
MOV EDI,0x1b8
CALL 0x0011a8c0
LAB_001ccb38:
MOV R14,RAX
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00154326
MOV qword ptr [R14 + 0x138],R12
LAB_001ccb4d:
MOVZX EDI,BPL
CALL 0x0011a4e0
MOV qword ptr [R14 + 0x140],RAX
MOV EAX,dword ptr [RBX + 0x4]
CMP EAX,0x21
MOV ESI,0x20
CMOVGE ESI,EAX
MOV qword ptr [R14 + 0x148],RSI
MOV RDI,R14
ADD RDI,0x168
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x150],XMM0
MOV qword ptr [R14 + 0x160],0x0
LAB_001ccb92:
LEA RDX,[RSP + 0x10]
CALL 0x00178ca2
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x1a0],XMM0
MOVUPS xmmword ptr [R14 + 0x190],XMM0
MOVUPS xmmword ptr [R14 + 0x180],XMM0
MOV qword ptr [R14 + 0x1b0],0x0
MOV R12,qword ptr [R14 + 0x140]
LAB_001ccbc9:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b110
MOV RDX,qword ptr [RBX + 0x120]
MOV RSI,qword ptr [RBX + 0x128]
SUB RSI,RDX
SHR RSI,0x3
MOV EDI,EAX
CALL 0x0011ae80
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a990
MOV EAX,dword ptr [RBX + 0x54]
CMP EAX,0x2
JZ 0x001cce3b
CMP EAX,0x1
JZ 0x001ccdf4
TEST EAX,EAX
JNZ 0x001cceee
MOV R15,qword ptr [RBX + 0x80]
MOV RBP,qword ptr [RBX + 0x88]
CMP R15,RBP
JZ 0x001cce71
LEA R13,[RSP + 0x10]
MOV qword ptr [RSP + 0x50],RBP
LAB_001ccc38:
MOV EAX,dword ptr [R15]
DEC EAX
CMP EAX,0x9
JA 0x001ccecd
LEA RCX,[0x1f5080]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,qword ptr [RBX + 0x68]
SAR RSI,0x5
LAB_001ccc73:
MOV RDI,R13
CALL 0x001ce190
MOV R12,qword ptr [RBX + 0x68]
MOV RBP,qword ptr [RBX + 0x70]
LAB_001ccc83:
CMP R12,RBP
JZ 0x001ccd8d
MOV RAX,qword ptr [R12]
MOV qword ptr [RSP + 0x60],RAX
LAB_001ccc95:
MOV RDI,R13
LEA RSI,[RSP + 0x60]
CALL 0x001ce7d2
ADD R12,0x20
JMP 0x001ccc83
caseD_a:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x34]
MOVSS XMM0,dword ptr [RBX + 0x38]
MOVSS XMM1,dword ptr [RBX + 0x3c]
MOVSS XMM2,dword ptr [RBX + 0x40]
LAB_001cccc1:
CALL 0x0011a700
JMP 0x001ccd70
caseD_6:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x24]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011a6c0
JMP 0x001ccd70
caseD_7:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
MOVSS XMM1,dword ptr [RBX + 0x2c]
MOVSS XMM2,dword ptr [RBX + 0x30]
CALL 0x0011b0d0
JMP 0x001ccd70
caseD_3:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x14]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011a130
JMP 0x001ccd70
caseD_9:
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011ad00
JMP 0x001ccd70
caseD_4:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x18]
MOVSXD RDI,dword ptr [RBX + 0xc]
CALL 0x0011ac30
JMP 0x001ccd70
caseD_2:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX + 0x10]
CALL 0x0011a410
JMP 0x001ccd70
caseD_8:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x1c]
MOVSS XMM1,dword ptr [RBX + 0x20]
MOVSXD RDI,dword ptr [RBX + 0xc]
MOV ESI,dword ptr [RBX]
CALL 0x0011a2c0
LAB_001ccd70:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a990
LAB_001ccd7b:
ADD R15,0x4
CMP R15,RBP
JNZ 0x001ccc38
JMP 0x001cce71
LAB_001ccd8d:
MOV R12,qword ptr [R14 + 0x140]
LAB_001ccd94:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0011a880
MOVSS XMM0,dword ptr [RBX + 0x44]
MOVSS XMM1,dword ptr [RBX + 0x48]
MOV EDX,dword ptr [RBX + 0x4c]
MOV ECX,dword ptr [RBX + 0x50]
MOV R8,qword ptr [RSP + 0x10]
MOV R9,qword ptr [RSP + 0x18]
SUB R9,R8
SAR R9,0x3
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,EAX
CALL 0x0011aeb0
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a990
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
MOV RBP,qword ptr [RSP + 0x50]
JZ 0x001ccd7b
MOV RSI,qword ptr [RSP + 0x20]
SUB RSI,RDI
CALL 0x0011a8f0
JMP 0x001ccd7b
LAB_001ccdf4:
MOV R12,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
LAB_001cce00:
CALL 0x0011a550
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a990
MOV R12,qword ptr [R14 + 0x140]
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0011b110
MOV ESI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
MOV EDI,EAX
MOV EDX,0x64
CALL 0x0011b170
JMP 0x001cce7f
LAB_001cce3b:
MOV R15,qword ptr [R14 + 0x140]
MOVSS XMM0,dword ptr [RBX + 0x28]
CALL 0x0011a550
MOV RDI,R15
MOV RSI,RAX
CALL 0x0011a990
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
MOVSS XMM0,dword ptr [RBX + 0x58]
MOVSS XMM1,dword ptr [RBX + 0x5c]
CALL 0x0011ae90
JMP 0x001cce7f
LAB_001cce71:
MOV R12,qword ptr [R14 + 0x140]
MOV EDI,dword ptr [RBX]
CALL 0x0011ad70
LAB_001cce7f:
MOV RDI,R12
MOV RSI,RAX
CALL 0x0011a990
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x001ccea1
MOV RSI,qword ptr [RSP + 0x40]
SUB RSI,RDI
CALL 0x0011a8f0
LAB_001ccea1:
MOV RAX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001cceb3:
LEA RDI,[0x1f5251]
LEA RDX,[0x1f529f]
MOV ESI,0xa5
XOR EAX,EAX
CALL 0x0011aec0
caseD_5:
LEA RDI,[0x1f5251]
LEA RDX,[0x1e620a]
LEA RCX,[0x1f52d7]
MOV ESI,0xe5
XOR EAX,EAX
CALL 0x0011aec0
LAB_001cceee:
LEA RDI,[0x1f5251]
LEA RDX,[0x1e620a]
LEA RCX,[0x1f52f7]
MOV ESI,0xf0
XOR EAX,EAX
CALL 0x0011aec0
|
/* common_sampler_init(llama_model const*, common_params_sampling const&) */
common_params_sampling * common_sampler_init(llama_model *param_1,common_params_sampling *param_2)
{
common_params_sampling cVar1;
int8 *puVar2;
int iVar3;
int4 uVar4;
int8 uVar5;
int8 uVar6;
common_params_sampling *this;
int8 uVar7;
int4 *puVar8;
allocator *paVar9;
int8 *puVar10;
int4 *puVar11;
char *local_88;
long lStack_80;
long local_78;
void *local_68;
long lStack_60;
long local_58;
int4 *local_48;
llama_model *local_40;
char *local_38;
local_40 = param_1;
uVar5 = llama_model_get_vocab();
llama_sampler_chain_default_params();
cVar1 = param_2[0x61];
local_68 = (void *)0x0;
lStack_60 = 0;
local_58 = 0;
/* try { // try from 001cca6d to 001cca71 has its CatchHandler @ 001ccf2d */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_68,
(*(long *)(param_2 + 200) - *(long *)(param_2 + 0xc0) >> 3) * -0x3333333333333333);
puVar10 = *(int8 **)(param_2 + 0xc0);
puVar2 = *(int8 **)(param_2 + 200);
if (puVar10 != puVar2) {
do {
local_88 = (char *)*puVar10;
/* try { // try from 001cca97 to 001ccaa1 has its CatchHandler @ 001ccf53 */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_68,&local_88);
puVar10 = puVar10 + 5;
} while (puVar10 != puVar2);
}
/* try { // try from 001ccab2 to 001ccb2a has its CatchHandler @ 001ccf31 */
iVar3 = std::__cxx11::string::compare((ulong)(param_2 + 0x98),0,(char *)0xb);
if (iVar3 == 0) {
/* try { // try from 001cceb3 to 001ccecc has its CatchHandler @ 001ccf31 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",0xa5,
"llguidance (cmake -DLLAMA_LLGUIDANCE=ON) is not enabled");
}
if (param_2[0xb8] == (common_params_sampling)0x1) {
uVar6 = llama_sampler_init_grammar_lazy
(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001f486f,local_68,
lStack_60 - (long)local_68 >> 3,*(long *)(param_2 + 0xd8),
*(long *)(param_2 + 0xe0) - *(long *)(param_2 + 0xd8) >> 2);
}
else {
uVar6 = llama_sampler_init_grammar(uVar5,*(int8 *)(param_2 + 0x98),&DAT_001f486f);
}
/* try { // try from 001ccb2e to 001ccb37 has its CatchHandler @ 001ccf33 */
this = (common_params_sampling *)operator_new(0x1b8);
/* try { // try from 001ccb38 to 001ccb45 has its CatchHandler @ 001ccf20 */
common_params_sampling::common_params_sampling(this,param_2);
*(int8 *)(this + 0x138) = uVar6;
/* try { // try from 001ccb4d to 001ccb55 has its CatchHandler @ 001ccf13 */
uVar6 = llama_sampler_chain_init(cVar1);
*(int8 *)(this + 0x140) = uVar6;
paVar9 = (allocator *)0x20;
if (0x20 < (int)*(uint *)(param_2 + 4)) {
paVar9 = (allocator *)(ulong)*(uint *)(param_2 + 4);
}
*(allocator **)(this + 0x148) = paVar9;
*(int8 *)(this + 0x150) = 0;
*(int8 *)(this + 0x158) = 0;
*(int8 *)(this + 0x160) = 0;
/* try { // try from 001ccb92 to 001ccb9b has its CatchHandler @ 001ccf11 */
std::vector<int,std::allocator<int>>::vector((ulong)(this + 0x168),paVar9);
*(int8 *)(this + 0x1a0) = 0;
*(int8 *)(this + 0x1a8) = 0;
*(int8 *)(this + 400) = 0;
*(int8 *)(this + 0x198) = 0;
*(int8 *)(this + 0x180) = 0;
*(int8 *)(this + 0x188) = 0;
*(int8 *)(this + 0x1b0) = 0;
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001ccbc9 to 001ccbf9 has its CatchHandler @ 001ccf33 */
uVar4 = llama_vocab_n_tokens(uVar5);
uVar7 = llama_sampler_init_logit_bias
(uVar4,(ulong)(*(long *)(param_2 + 0x128) - *(long *)(param_2 + 0x120)) >> 3);
llama_sampler_chain_add(uVar6,uVar7);
iVar3 = *(int *)(param_2 + 0x54);
if (iVar3 == 2) {
uVar5 = *(int8 *)(this + 0x140);
uVar6 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar5,uVar6);
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_mirostat_v2
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),
*(int4 *)param_2);
}
else if (iVar3 == 1) {
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001cce00 to 001cce89 has its CatchHandler @ 001ccf33 */
uVar7 = llama_sampler_init_temp(*(int4 *)(param_2 + 0x28));
llama_sampler_chain_add(uVar6,uVar7);
uVar6 = *(int8 *)(this + 0x140);
uVar4 = llama_vocab_n_tokens(uVar5);
uVar5 = llama_sampler_init_mirostat
(*(int4 *)(param_2 + 0x58),*(int4 *)(param_2 + 0x5c),uVar4,
*(int4 *)param_2,100);
}
else {
if (iVar3 != 0) {
/* try { // try from 001cceee to 001ccf0e has its CatchHandler @ 001ccf33 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp",
0xf0,"GGML_ASSERT(%s) failed","false && \"unknown mirostat version\"");
}
puVar11 = *(int4 **)(param_2 + 0x80);
puVar8 = *(int4 **)(param_2 + 0x88);
if (puVar11 != puVar8) {
local_48 = puVar8;
do {
switch(*puVar11) {
case 1:
local_88 = (char *)0x0;
lStack_80 = 0;
local_78 = 0;
/* try { // try from 001ccc73 to 001ccc7a has its CatchHandler @ 001ccf2f */
std::vector<char_const*,std::allocator<char_const*>>::reserve
((vector<char_const*,std::allocator<char_const*>> *)&local_88,
*(long *)(param_2 + 0x70) - *(long *)(param_2 + 0x68) >> 5);
puVar2 = *(int8 **)(param_2 + 0x70);
for (puVar10 = *(int8 **)(param_2 + 0x68); puVar10 != puVar2; puVar10 = puVar10 + 4)
{
local_38 = (char *)*puVar10;
/* try { // try from 001ccc95 to 001ccca1 has its CatchHandler @ 001ccf37 */
std::vector<char_const*,std::allocator<char_const*>>::emplace_back<char_const*>
((vector<char_const*,std::allocator<char_const*>> *)&local_88,&local_38);
}
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001ccd94 to 001ccdd5 has its CatchHandler @ 001ccf2f */
uVar4 = llama_model_n_ctx_train(local_40);
uVar7 = llama_sampler_init_dry
(*(int4 *)(param_2 + 0x44),*(int4 *)(param_2 + 0x48),uVar5,
uVar4,*(int4 *)(param_2 + 0x4c),*(int4 *)(param_2 + 0x50),
local_88,lStack_80 - (long)local_88 >> 3);
llama_sampler_chain_add(uVar6,uVar7);
puVar8 = local_48;
if (local_88 != (char *)0x0) {
operator_delete(local_88,local_78 - (long)local_88);
}
goto LAB_001ccd7b;
case 2:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_k(*(int4 *)(param_2 + 0x10));
break;
case 3:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_top_p
(*(int4 *)(param_2 + 0x14),(long)*(int *)(param_2 + 0xc));
break;
case 4:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_min_p
(*(int4 *)(param_2 + 0x18),(long)*(int *)(param_2 + 0xc));
break;
default:
/* try { // try from 001ccecd to 001cceed has its CatchHandler @ 001ccf0f */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/sampling.cpp"
,0xe5,"GGML_ASSERT(%s) failed","false && \"unknown sampler type\"");
case 6:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_typical
(*(int4 *)(param_2 + 0x24),(long)*(int *)(param_2 + 0xc));
break;
case 7:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_temp_ext
(*(int4 *)(param_2 + 0x28),*(int4 *)(param_2 + 0x2c),
*(int4 *)(param_2 + 0x30));
break;
case 8:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_xtc
(*(int4 *)(param_2 + 0x1c),*(int4 *)(param_2 + 0x20),
(long)*(int *)(param_2 + 0xc),*(int4 *)param_2);
break;
case 9:
uVar6 = *(int8 *)(this + 0x140);
uVar7 = llama_sampler_init_infill(uVar5);
break;
case 10:
uVar6 = *(int8 *)(this + 0x140);
/* try { // try from 001cccc1 to 001ccd7a has its CatchHandler @ 001ccf35 */
uVar7 = llama_sampler_init_penalties
(*(int4 *)(param_2 + 0x38),*(int4 *)(param_2 + 0x3c),
*(int4 *)(param_2 + 0x40),*(int4 *)(param_2 + 0x34));
}
llama_sampler_chain_add(uVar6,uVar7);
LAB_001ccd7b:
puVar11 = puVar11 + 1;
} while (puVar11 != puVar8);
}
uVar6 = *(int8 *)(this + 0x140);
uVar5 = llama_sampler_init_dist(*(int4 *)param_2);
}
llama_sampler_chain_add(uVar6,uVar5);
if (local_68 != (void *)0x0) {
operator_delete(local_68,local_58 - (long)local_68);
}
return this;
}
|
|
57,645
|
my_strnxfrm_tis620
|
eloqsql/strings/ctype-tis620.c
|
static size_t
my_strnxfrm_tis620(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
my_ci_fill(cs, (char*) dst + len, fill_length, cs->pad_char);
len= dstlen0;
}
return len;
}
|
O0
|
c
|
my_strnxfrm_tis620:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x48f5e
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x48f66
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x24220
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x49050
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x48fa3
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x48fa5
jmp 0x48fa7
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x48fb9
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x48fbb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x43610
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4903f
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4903f
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl 0xb0(%rax), %ecx
callq 0x491f0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
my_strnxfrm_tis620:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_48F5E
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_48F66
loc_48F5E:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_48F66:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_48FA3
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_48FA3:
jmp short $+2
loc_48FA5:
jmp short $+2
loc_48FA7:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_48FB9
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_48FB9:
jmp short $+2
loc_48FBB:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_4903F
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_4903F
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, [rbp+var_38]
mov rdx, [rbp+var_48]
mov rax, [rbp+var_8]
movzx ecx, byte ptr [rax+0B0h]
call my_ci_fill_1
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_4903F:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
|
unsigned long long my_strnxfrm_tis620(
long long a1,
long long a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
unsigned long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse(a1, a2, v10 + a2, v13 + a2, (int)v13 - (int)v10, a7, 0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
my_ci_fill_1(a1, v11 + a2, a3 - v11, *(unsigned __int8 *)(a1 + 176));
return a3;
}
return v11;
}
|
my_strnxfrm_tis620:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00148f5e
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00148f66
LAB_00148f5e:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_00148f66:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00124220
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00149050
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x00148fa3
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_00148fa3:
JMP 0x00148fa5
LAB_00148fa5:
JMP 0x00148fa7
LAB_00148fa7:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00148fb9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_00148fb9:
JMP 0x00148fbb
LAB_00148fbb:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00143610
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x0014903f
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0014903f
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,byte ptr [RAX + 0xb0]
CALL 0x001491f0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_0014903f:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620(long param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
my_ci_fill(param_1,(long)param_2 + local_40,param_3 - local_40,*(int1 *)(param_1 + 0xb0));
local_40 = param_3;
}
return local_40;
}
|
|
57,646
|
pagecache_delete_pages
|
eloqsql/storage/maria/ma_pagecache.c
|
my_bool pagecache_delete_pages(PAGECACHE *pagecache,
PAGECACHE_FILE *file,
pgcache_page_no_t pageno,
uint page_count,
enum pagecache_page_lock lock,
my_bool flush)
{
pgcache_page_no_t page_end;
DBUG_ENTER("pagecache_delete_pages");
DBUG_ASSERT(page_count > 0);
page_end= pageno + page_count;
do
{
if (pagecache_delete(pagecache, file, pageno,
lock, flush))
DBUG_RETURN(1);
} while (++pageno != page_end);
DBUG_RETURN(0);
}
|
O0
|
c
|
pagecache_delete_pages:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movb %al, -0x29(%rbp)
jmp 0x56393
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x28(%rbp), %ecx
movsbl -0x29(%rbp), %r8d
callq 0x56080
cmpb $0x0, %al
je 0x563c6
jmp 0x563c0
movb $0x1, -0x1(%rbp)
jmp 0x563e0
jmp 0x563c8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x563a1
jmp 0x563dc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
pagecache_delete_pages:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_28], r8d
mov [rbp+var_29], al
jmp short $+2
loc_56393:
mov rax, [rbp+var_20]
mov ecx, [rbp+var_24]
add rax, rcx
mov [rbp+var_38], rax
loc_563A1:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov ecx, [rbp+var_28]
movsx r8d, [rbp+var_29]
call pagecache_delete
cmp al, 0
jz short loc_563C6
jmp short $+2
loc_563C0:
mov [rbp+var_1], 1
jmp short loc_563E0
loc_563C6:
jmp short $+2
loc_563C8:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
cmp rax, [rbp+var_38]
jnz short loc_563A1
jmp short $+2
loc_563DC:
mov [rbp+var_1], 0
loc_563E0:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
|
char pagecache_delete_pages(_QWORD *a1, long long a2, long long a3, unsigned int a4, unsigned int a5, bool a6)
{
long long v7; // [rsp+8h] [rbp-38h]
long long v10; // [rsp+20h] [rbp-20h]
v10 = a3;
v7 = a4 + a3;
do
{
if ( pagecache_delete(a1, a2, v10, a5, a6) )
return 1;
++v10;
}
while ( v10 != v7 );
return 0;
}
|
pagecache_delete_pages:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV dword ptr [RBP + -0x24],ECX
MOV dword ptr [RBP + -0x28],R8D
MOV byte ptr [RBP + -0x29],AL
JMP 0x00156393
LAB_00156393:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
LAB_001563a1:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
MOVSX R8D,byte ptr [RBP + -0x29]
CALL 0x00156080
CMP AL,0x0
JZ 0x001563c6
JMP 0x001563c0
LAB_001563c0:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001563e0
LAB_001563c6:
JMP 0x001563c8
LAB_001563c8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x001563a1
JMP 0x001563dc
LAB_001563dc:
MOV byte ptr [RBP + -0x1],0x0
LAB_001563e0:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1
pagecache_delete_pages
(int8 param_1,int8 param_2,long param_3,uint param_4,int4 param_5,
char param_6)
{
char cVar1;
long local_28;
local_28 = param_3;
do {
cVar1 = pagecache_delete(param_1,param_2,local_28,param_5,(int)param_6);
if (cVar1 != '\0') {
return 1;
}
local_28 = local_28 + 1;
} while (local_28 != param_3 + (ulong)param_4);
return 0;
}
|
|
57,647
|
map_delete_record
|
bluesky950520[P]quickjs/quickjs.c
|
static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
{
if (mr->empty)
return;
list_del(&mr->hash_link);
if (s->is_weak) {
delete_map_weak_ref(rt, mr);
} else {
JS_FreeValueRT(rt, mr->key);
}
JS_FreeValueRT(rt, mr->value);
if (--mr->ref_count == 0) {
list_del(&mr->link);
js_free_rt(rt, mr);
} else {
/* keep a zombie record for iterators */
mr->empty = TRUE;
mr->key = JS_UNDEFINED;
mr->value = JS_UNDEFINED;
}
s->record_count--;
}
|
O0
|
c
|
map_delete_record:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x4(%rax)
je 0x8cf93
jmp 0x8d082
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x23c30
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
je 0x8cfbc
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5c080
jmp 0x8cfd3
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
callq 0x23d10
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
callq 0x23d10
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x8d01a
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
callq 0x23c30
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x21960
jmp 0x8d074
movq 0x20(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0x10(%rsp)
movq $0x3, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rax
movl $0x0, (%rsp)
movq $0x3, 0x8(%rsp)
movq (%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
|
map_delete_record:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov [rsp+38h+var_18], rdx
mov rax, [rsp+38h+var_18]
cmp dword ptr [rax+4], 0
jz short loc_8CF93
jmp loc_8D082
loc_8CF93:
mov rdi, [rsp+38h+var_18]
add rdi, 20h ; ' '
call list_del_0
mov rax, [rsp+38h+var_10]
cmp dword ptr [rax], 0
jz short loc_8CFBC
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_18]
call delete_map_weak_ref
jmp short loc_8CFD3
loc_8CFBC:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+30h]
mov rdx, [rax+38h]
call JS_FreeValueRT
loc_8CFD3:
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_18]
mov rsi, [rax+40h]
mov rdx, [rax+48h]
call JS_FreeValueRT
mov rcx, [rsp+38h+var_18]
mov eax, [rcx]
add eax, 0FFFFFFFFh
mov [rcx], eax
cmp eax, 0
jnz short loc_8D01A
mov rdi, [rsp+38h+var_18]
add rdi, 10h
call list_del_0
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_18]
call js_free_rt
jmp short loc_8D074
loc_8D01A:
mov rax, [rsp+38h+var_18]
mov dword ptr [rax+4], 1
mov rax, [rsp+38h+var_18]
mov dword ptr [rsp+38h+var_28], 0
mov [rsp+38h+var_20], 3
mov rcx, [rsp+38h+var_28]
mov [rax+30h], rcx
mov rcx, [rsp+38h+var_20]
mov [rax+38h], rcx
mov rax, [rsp+38h+var_18]
mov dword ptr [rsp+38h+var_38], 0
mov [rsp+38h+var_30], 3
mov rcx, [rsp+38h+var_38]
mov [rax+40h], rcx
mov rcx, [rsp+38h+var_30]
mov [rax+48h], rcx
loc_8D074:
mov rax, [rsp+38h+var_10]
mov ecx, [rax+18h]
add ecx, 0FFFFFFFFh
mov [rax+18h], ecx
loc_8D082:
add rsp, 38h
retn
|
_DWORD * map_delete_record(long long a1, _DWORD *a2, long long a3)
{
_DWORD *result; // rax
int v4; // eax
long long v5; // [rsp+0h] [rbp-38h]
long long v6; // [rsp+10h] [rbp-28h]
result = (_DWORD *)a3;
if ( !*(_DWORD *)(a3 + 4) )
{
list_del_0((_QWORD *)(a3 + 32));
if ( *a2 )
delete_map_weak_ref(a1, a3);
else
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 48), *(_QWORD *)(a3 + 56));
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 64), *(_QWORD *)(a3 + 72));
v4 = *(_DWORD *)a3 - 1;
*(_DWORD *)a3 = v4;
if ( v4 )
{
*(_DWORD *)(a3 + 4) = 1;
LODWORD(v6) = 0;
*(_QWORD *)(a3 + 48) = v6;
*(_QWORD *)(a3 + 56) = 3LL;
LODWORD(v5) = 0;
*(_QWORD *)(a3 + 64) = v5;
*(_QWORD *)(a3 + 72) = 3LL;
}
else
{
list_del_0((_QWORD *)(a3 + 16));
js_free_rt(a1, a3);
}
result = a2;
--a2[6];
}
return result;
}
|
map_delete_record:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x20]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x0018cf93
JMP 0x0018d082
LAB_0018cf93:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x20
CALL 0x00123c30
MOV RAX,qword ptr [RSP + 0x28]
CMP dword ptr [RAX],0x0
JZ 0x0018cfbc
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x0015c080
JMP 0x0018cfd3
LAB_0018cfbc:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x30]
MOV RDX,qword ptr [RAX + 0x38]
CALL 0x00123d10
LAB_0018cfd3:
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX + 0x40]
MOV RDX,qword ptr [RAX + 0x48]
CALL 0x00123d10
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RCX]
ADD EAX,-0x1
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JNZ 0x0018d01a
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x10
CALL 0x00123c30
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x00121960
JMP 0x0018d074
LAB_0018d01a:
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RAX + 0x4],0x1
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x3
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x38],RCX
MOV RAX,qword ptr [RSP + 0x20]
MOV dword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],0x3
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x40],RCX
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x48],RCX
LAB_0018d074:
MOV RAX,qword ptr [RSP + 0x28]
MOV ECX,dword ptr [RAX + 0x18]
ADD ECX,-0x1
MOV dword ptr [RAX + 0x18],ECX
LAB_0018d082:
ADD RSP,0x38
RET
|
void map_delete_record(int8 param_1,int *param_2,int *param_3)
{
int iVar1;
uint uStack_34;
uint uStack_24;
if (param_3[1] == 0) {
list_del(param_3 + 8);
if (*param_2 == 0) {
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0xc),*(int8 *)(param_3 + 0xe));
}
else {
delete_map_weak_ref(param_1,param_3);
}
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x12));
iVar1 = *param_3;
*param_3 = iVar1 + -1;
if (iVar1 + -1 == 0) {
list_del(param_3 + 4);
js_free_rt(param_1,param_3);
}
else {
param_3[1] = 1;
*(ulong *)(param_3 + 0xc) = (ulong)uStack_24 << 0x20;
param_3[0xe] = 3;
param_3[0xf] = 0;
*(ulong *)(param_3 + 0x10) = (ulong)uStack_34 << 0x20;
param_3[0x12] = 3;
param_3[0x13] = 0;
}
param_2[6] = param_2[6] + -1;
}
return;
}
|
|
57,648
|
map_delete_record
|
bluesky950520[P]quickjs/quickjs.c
|
static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
{
if (mr->empty)
return;
list_del(&mr->hash_link);
if (s->is_weak) {
delete_map_weak_ref(rt, mr);
} else {
JS_FreeValueRT(rt, mr->key);
}
JS_FreeValueRT(rt, mr->value);
if (--mr->ref_count == 0) {
list_del(&mr->link);
js_free_rt(rt, mr);
} else {
/* keep a zombie record for iterators */
mr->empty = TRUE;
mr->key = JS_UNDEFINED;
mr->value = JS_UNDEFINED;
}
s->record_count--;
}
|
O1
|
c
|
map_delete_record:
cmpl $0x0, 0x4(%rdx)
je 0x5008d
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdx), %rax
movq 0x28(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
cmpl $0x0, (%rsi)
je 0x500c3
movq %r15, %rdi
movq %r14, %rsi
callq 0x3b3f6
jmp 0x500d3
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %r15, %rdi
callq 0x1d8c6
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r15, %rdi
callq 0x1d8c6
decl (%r14)
je 0x50109
movl $0x1, 0x4(%r14)
xorl %eax, %eax
movl %eax, 0x30(%r14)
movl $0x3, %ecx
movq %rcx, 0x38(%r14)
movl %eax, 0x40(%r14)
movq %rcx, 0x48(%r14)
jmp 0x50145
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
decq 0x28(%r15)
movq %r14, %rdi
callq *0x20(%r15)
movq 0x30(%r15), %rcx
movq 0x40(%r15), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r15)
movq %r14, %rsi
callq *0x10(%r15)
decl 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
map_delete_record:
cmp dword ptr [rdx+4], 0
jz short loc_5008D
retn
loc_5008D:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, [rdx+20h]
mov rcx, [rdx+28h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx+20h], xmm0
cmp dword ptr [rsi], 0
jz short loc_500C3
mov rdi, r15
mov rsi, r14
call delete_map_weak_ref
jmp short loc_500D3
loc_500C3:
mov rsi, [r14+30h]
mov rdx, [r14+38h]
mov rdi, r15
call JS_FreeValueRT
loc_500D3:
mov rsi, [r14+40h]
mov rdx, [r14+48h]
mov rdi, r15
call JS_FreeValueRT
dec dword ptr [r14]
jz short loc_50109
mov dword ptr [r14+4], 1
xor eax, eax
mov [r14+30h], eax
mov ecx, 3
mov [r14+38h], rcx
mov [r14+40h], eax
mov [r14+48h], rcx
jmp short loc_50145
loc_50109:
mov rax, [r14+10h]
mov rcx, [r14+18h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
dec qword ptr [r15+28h]
mov rdi, r14
call qword ptr [r15+20h]
mov rcx, [r15+30h]
mov rdi, [r15+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r15+30h], rcx
mov rsi, r14
call qword ptr [r15+10h]
loc_50145:
dec dword ptr [rbx+18h]
pop rbx
pop r14
pop r15
retn
|
void map_delete_record(long long a1, _DWORD *a2, long long a3)
{
long long v5; // rax
_QWORD *v6; // rcx
long long v8; // rax
_QWORD *v9; // rcx
long long v10; // rax
long long v11; // rdi
if ( !*(_DWORD *)(a3 + 4) )
{
v5 = *(_QWORD *)(a3 + 32);
v6 = *(_QWORD **)(a3 + 40);
*(_QWORD *)(v5 + 8) = v6;
*v6 = v5;
*(_OWORD *)(a3 + 32) = 0LL;
if ( *a2 )
delete_map_weak_ref(a1, a3);
else
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 48), *(_QWORD *)(a3 + 56));
JS_FreeValueRT(a1, *(_DWORD **)(a3 + 64), *(_QWORD *)(a3 + 72));
if ( (*(_DWORD *)a3)-- == 1 )
{
v8 = *(_QWORD *)(a3 + 16);
v9 = *(_QWORD **)(a3 + 24);
*(_QWORD *)(v8 + 8) = v9;
*v9 = v8;
*(_OWORD *)(a3 + 16) = 0LL;
--*(_QWORD *)(a1 + 40);
v10 = (*(long long ( **)(long long))(a1 + 32))(a3);
v11 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v10 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v11, a3);
}
else
{
*(_DWORD *)(a3 + 4) = 1;
*(_DWORD *)(a3 + 48) = 0;
*(_QWORD *)(a3 + 56) = 3LL;
*(_DWORD *)(a3 + 64) = 0;
*(_QWORD *)(a3 + 72) = 3LL;
}
--a2[6];
}
}
| |||
57,649
|
map_delete_record
|
bluesky950520[P]quickjs/quickjs.c
|
static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
{
if (mr->empty)
return;
list_del(&mr->hash_link);
if (s->is_weak) {
delete_map_weak_ref(rt, mr);
} else {
JS_FreeValueRT(rt, mr->key);
}
JS_FreeValueRT(rt, mr->value);
if (--mr->ref_count == 0) {
list_del(&mr->link);
js_free_rt(rt, mr);
} else {
/* keep a zombie record for iterators */
mr->empty = TRUE;
mr->key = JS_UNDEFINED;
mr->value = JS_UNDEFINED;
}
s->record_count--;
}
|
O2
|
c
|
map_delete_record:
cmpl $0x0, 0x4(%rdx)
je 0x44b75
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdx), %rax
movq 0x28(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
cmpl $0x0, (%rsi)
je 0x44bab
movq %r15, %rdi
movq %r14, %rsi
callq 0x341d5
jmp 0x44bbb
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %r15, %rdi
callq 0x18031
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r15, %rdi
callq 0x18031
decl (%r14)
je 0x44bef
movl $0x1, 0x4(%r14)
andl $0x0, 0x30(%r14)
pushq $0x3
popq %rax
movq %rax, 0x38(%r14)
andl $0x0, 0x40(%r14)
movq %rax, 0x48(%r14)
jmp 0x44c11
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x170cb
decl 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
map_delete_record:
cmp dword ptr [rdx+4], 0
jz short loc_44B75
retn
loc_44B75:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, [rdx+20h]
mov rcx, [rdx+28h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx+20h], xmm0
cmp dword ptr [rsi], 0
jz short loc_44BAB
mov rdi, r15
mov rsi, r14
call delete_map_weak_ref
jmp short loc_44BBB
loc_44BAB:
mov rsi, [r14+30h]
mov rdx, [r14+38h]
mov rdi, r15
call JS_FreeValueRT
loc_44BBB:
mov rsi, [r14+40h]
mov rdx, [r14+48h]
mov rdi, r15
call JS_FreeValueRT
dec dword ptr [r14]
jz short loc_44BEF
mov dword ptr [r14+4], 1
and dword ptr [r14+30h], 0
push 3
pop rax
mov [r14+38h], rax
and dword ptr [r14+40h], 0
mov [r14+48h], rax
jmp short loc_44C11
loc_44BEF:
mov rax, [r14+10h]
mov rcx, [r14+18h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
mov rdi, r15
mov rsi, r14
call js_free_rt
loc_44C11:
dec dword ptr [rbx+18h]
pop rbx
pop r14
pop r15
retn
|
long long map_delete_record(long long a1, _DWORD *a2, long long a3)
{
long long v4; // rax
_QWORD *v5; // rcx
long long result; // rax
long long v8; // rax
_QWORD *v9; // rcx
if ( !*(_DWORD *)(a3 + 4) )
{
v4 = *(_QWORD *)(a3 + 32);
v5 = *(_QWORD **)(a3 + 40);
*(_QWORD *)(v4 + 8) = v5;
*v5 = v4;
*(_OWORD *)(a3 + 32) = 0LL;
if ( *a2 )
delete_map_weak_ref(a1, a3);
else
JS_FreeValueRT(a1, *(unsigned int **)(a3 + 48), *(_QWORD *)(a3 + 56));
JS_FreeValueRT(a1, *(unsigned int **)(a3 + 64), *(_QWORD *)(a3 + 72));
if ( (*(_DWORD *)a3)-- == 1 )
{
v8 = *(_QWORD *)(a3 + 16);
v9 = *(_QWORD **)(a3 + 24);
*(_QWORD *)(v8 + 8) = v9;
*v9 = v8;
*(_OWORD *)(a3 + 16) = 0LL;
result = js_free_rt(a1, a3);
}
else
{
*(_DWORD *)(a3 + 4) = 1;
*(_DWORD *)(a3 + 48) = 0;
result = 3LL;
*(_QWORD *)(a3 + 56) = 3LL;
*(_DWORD *)(a3 + 64) = 0;
*(_QWORD *)(a3 + 72) = 3LL;
}
--a2[6];
}
return result;
}
|
map_delete_record:
CMP dword ptr [RDX + 0x4],0x0
JZ 0x00144b75
RET
LAB_00144b75:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDX + 0x20]
MOV RCX,qword ptr [RDX + 0x28]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX + 0x20],XMM0
CMP dword ptr [RSI],0x0
JZ 0x00144bab
MOV RDI,R15
MOV RSI,R14
CALL 0x001341d5
JMP 0x00144bbb
LAB_00144bab:
MOV RSI,qword ptr [R14 + 0x30]
MOV RDX,qword ptr [R14 + 0x38]
MOV RDI,R15
CALL 0x00118031
LAB_00144bbb:
MOV RSI,qword ptr [R14 + 0x40]
MOV RDX,qword ptr [R14 + 0x48]
MOV RDI,R15
CALL 0x00118031
DEC dword ptr [R14]
JZ 0x00144bef
MOV dword ptr [R14 + 0x4],0x1
AND dword ptr [R14 + 0x30],0x0
PUSH 0x3
POP RAX
MOV qword ptr [R14 + 0x38],RAX
AND dword ptr [R14 + 0x40],0x0
MOV qword ptr [R14 + 0x48],RAX
JMP 0x00144c11
LAB_00144bef:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOV RDI,R15
MOV RSI,R14
CALL 0x001170cb
LAB_00144c11:
DEC dword ptr [RBX + 0x18]
POP RBX
POP R14
POP R15
RET
|
void map_delete_record(int8 param_1,int *param_2,int *param_3)
{
long lVar1;
long *plVar2;
if (param_3[1] != 0) {
return;
}
lVar1 = *(long *)(param_3 + 8);
plVar2 = *(long **)(param_3 + 10);
*(long **)(lVar1 + 8) = plVar2;
*plVar2 = lVar1;
param_3[8] = 0;
param_3[9] = 0;
param_3[10] = 0;
param_3[0xb] = 0;
if (*param_2 == 0) {
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0xc),*(int8 *)(param_3 + 0xe));
}
else {
delete_map_weak_ref(param_1,param_3);
}
JS_FreeValueRT(param_1,*(int8 *)(param_3 + 0x10),*(int8 *)(param_3 + 0x12));
*param_3 = *param_3 + -1;
if (*param_3 == 0) {
lVar1 = *(long *)(param_3 + 4);
plVar2 = *(long **)(param_3 + 6);
*(long **)(lVar1 + 8) = plVar2;
*plVar2 = lVar1;
param_3[4] = 0;
param_3[5] = 0;
param_3[6] = 0;
param_3[7] = 0;
js_free_rt(param_1,param_3);
}
else {
param_3[1] = 1;
param_3[0xc] = 0;
param_3[0xe] = 3;
param_3[0xf] = 0;
param_3[0x10] = 0;
param_3[0x12] = 3;
param_3[0x13] = 0;
}
param_2[6] = param_2[6] + -1;
return;
}
|
|
57,650
|
map_delete_record
|
bluesky950520[P]quickjs/quickjs.c
|
static void map_delete_record(JSRuntime *rt, JSMapState *s, JSMapRecord *mr)
{
if (mr->empty)
return;
list_del(&mr->hash_link);
if (s->is_weak) {
delete_map_weak_ref(rt, mr);
} else {
JS_FreeValueRT(rt, mr->key);
}
JS_FreeValueRT(rt, mr->value);
if (--mr->ref_count == 0) {
list_del(&mr->link);
js_free_rt(rt, mr);
} else {
/* keep a zombie record for iterators */
mr->empty = TRUE;
mr->key = JS_UNDEFINED;
mr->value = JS_UNDEFINED;
}
s->record_count--;
}
|
O3
|
c
|
map_delete_record:
cmpl $0x0, 0x4(%rdx)
je 0x5241c
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x20(%rdx), %rax
movq 0x28(%rdx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdx)
cmpl $0x0, (%rsi)
je 0x52452
movq %r15, %rdi
movq %r14, %rsi
callq 0x3c9f3
jmp 0x52473
movq 0x38(%r14), %rdx
cmpl $-0x9, %edx
jb 0x52473
movq 0x30(%r14), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x52473
movq %r15, %rdi
callq 0x219cc
movq 0x48(%r14), %rdx
cmpl $-0x9, %edx
jb 0x52494
movq 0x40(%r14), %rsi
movl (%rsi), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x1, %eax
jg 0x52494
movq %r15, %rdi
callq 0x219cc
decl (%r14)
je 0x524ba
movl $0x1, 0x4(%r14)
xorl %eax, %eax
movl %eax, 0x30(%r14)
movl $0x3, %ecx
movq %rcx, 0x38(%r14)
movl %eax, 0x40(%r14)
movq %rcx, 0x48(%r14)
jmp 0x524f6
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
decq 0x28(%r15)
movq %r14, %rdi
callq *0x20(%r15)
movq 0x30(%r15), %rcx
movq 0x40(%r15), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%r15)
movq %r14, %rsi
callq *0x10(%r15)
decl 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
map_delete_record:
cmp dword ptr [rdx+4], 0
jz short loc_5241C
retn
loc_5241C:
push r15
push r14
push rbx
mov r14, rdx
mov rbx, rsi
mov r15, rdi
mov rax, [rdx+20h]
mov rcx, [rdx+28h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [rdx+20h], xmm0
cmp dword ptr [rsi], 0
jz short loc_52452
mov rdi, r15
mov rsi, r14
call delete_map_weak_ref
jmp short loc_52473
loc_52452:
mov rdx, [r14+38h]
cmp edx, 0FFFFFFF7h
jb short loc_52473
mov rsi, [r14+30h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_52473
mov rdi, r15
call js_free_value_rt
loc_52473:
mov rdx, [r14+48h]
cmp edx, 0FFFFFFF7h
jb short loc_52494
mov rsi, [r14+40h]
mov eax, [rsi]
lea ecx, [rax-1]
mov [rsi], ecx
cmp eax, 1
jg short loc_52494
mov rdi, r15
call js_free_value_rt
loc_52494:
dec dword ptr [r14]
jz short loc_524BA
mov dword ptr [r14+4], 1
xor eax, eax
mov [r14+30h], eax
mov ecx, 3
mov [r14+38h], rcx
mov [r14+40h], eax
mov [r14+48h], rcx
jmp short loc_524F6
loc_524BA:
mov rax, [r14+10h]
mov rcx, [r14+18h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
dec qword ptr [r15+28h]
mov rdi, r14
call qword ptr [r15+20h]
mov rcx, [r15+30h]
mov rdi, [r15+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [r15+30h], rcx
mov rsi, r14
call qword ptr [r15+10h]
loc_524F6:
dec dword ptr [rbx+18h]
pop rbx
pop r14
pop r15
retn
|
void map_delete_record(long long a1, _DWORD *a2, long long a3)
{
long long v6; // rax
_QWORD *v7; // rcx
long long v8; // rdx
_QWORD *v9; // rsi
int v10; // eax
long long v11; // rdx
_QWORD *v12; // rsi
int v13; // eax
long long v15; // rax
_QWORD *v16; // rcx
long long v17; // rax
long long v18; // rdi
if ( !*(_DWORD *)(a3 + 4) )
{
v6 = *(_QWORD *)(a3 + 32);
v7 = *(_QWORD **)(a3 + 40);
*(_QWORD *)(v6 + 8) = v7;
*v7 = v6;
*(_OWORD *)(a3 + 32) = 0LL;
if ( *a2 )
{
delete_map_weak_ref(a1, a3);
}
else
{
v8 = *(_QWORD *)(a3 + 56);
if ( (unsigned int)v8 >= 0xFFFFFFF7 )
{
v9 = *(_QWORD **)(a3 + 48);
v10 = (*(_DWORD *)v9)--;
if ( v10 <= 1 )
js_free_value_rt(a1, v9, v8);
}
}
v11 = *(_QWORD *)(a3 + 72);
if ( (unsigned int)v11 >= 0xFFFFFFF7 )
{
v12 = *(_QWORD **)(a3 + 64);
v13 = (*(_DWORD *)v12)--;
if ( v13 <= 1 )
js_free_value_rt(a1, v12, v11);
}
if ( (*(_DWORD *)a3)-- == 1 )
{
v15 = *(_QWORD *)(a3 + 16);
v16 = *(_QWORD **)(a3 + 24);
*(_QWORD *)(v15 + 8) = v16;
*v16 = v15;
*(_OWORD *)(a3 + 16) = 0LL;
--*(_QWORD *)(a1 + 40);
v17 = (*(long long ( **)(long long))(a1 + 32))(a3);
v18 = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 48) = *(_QWORD *)(a1 + 48) - v17 - 8;
(*(void ( **)(long long, long long))(a1 + 16))(v18, a3);
}
else
{
*(_DWORD *)(a3 + 4) = 1;
*(_DWORD *)(a3 + 48) = 0;
*(_QWORD *)(a3 + 56) = 3LL;
*(_DWORD *)(a3 + 64) = 0;
*(_QWORD *)(a3 + 72) = 3LL;
}
--a2[6];
}
}
|
map_delete_record:
CMP dword ptr [RDX + 0x4],0x0
JZ 0x0015241c
RET
LAB_0015241c:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV RBX,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDX + 0x20]
MOV RCX,qword ptr [RDX + 0x28]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX + 0x20],XMM0
CMP dword ptr [RSI],0x0
JZ 0x00152452
MOV RDI,R15
MOV RSI,R14
CALL 0x0013c9f3
JMP 0x00152473
LAB_00152452:
MOV RDX,qword ptr [R14 + 0x38]
CMP EDX,-0x9
JC 0x00152473
MOV RSI,qword ptr [R14 + 0x30]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00152473
MOV RDI,R15
CALL 0x001219cc
LAB_00152473:
MOV RDX,qword ptr [R14 + 0x48]
CMP EDX,-0x9
JC 0x00152494
MOV RSI,qword ptr [R14 + 0x40]
MOV EAX,dword ptr [RSI]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RSI],ECX
CMP EAX,0x1
JG 0x00152494
MOV RDI,R15
CALL 0x001219cc
LAB_00152494:
DEC dword ptr [R14]
JZ 0x001524ba
MOV dword ptr [R14 + 0x4],0x1
XOR EAX,EAX
MOV dword ptr [R14 + 0x30],EAX
MOV ECX,0x3
MOV qword ptr [R14 + 0x38],RCX
MOV dword ptr [R14 + 0x40],EAX
MOV qword ptr [R14 + 0x48],RCX
JMP 0x001524f6
LAB_001524ba:
MOV RAX,qword ptr [R14 + 0x10]
MOV RCX,qword ptr [R14 + 0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
DEC qword ptr [R15 + 0x28]
MOV RDI,R14
CALL qword ptr [R15 + 0x20]
MOV RCX,qword ptr [R15 + 0x30]
MOV RDI,qword ptr [R15 + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [R15 + 0x30],RCX
MOV RSI,R14
CALL qword ptr [R15 + 0x10]
LAB_001524f6:
DEC dword ptr [RBX + 0x18]
POP RBX
POP R14
POP R15
RET
|
void map_delete_record(long param_1,int *param_2,int *param_3)
{
int iVar1;
long *plVar2;
long lVar3;
if (param_3[1] != 0) {
return;
}
lVar3 = *(long *)(param_3 + 8);
plVar2 = *(long **)(param_3 + 10);
*(long **)(lVar3 + 8) = plVar2;
*plVar2 = lVar3;
param_3[8] = 0;
param_3[9] = 0;
param_3[10] = 0;
param_3[0xb] = 0;
if (*param_2 == 0) {
if (0xfffffff6 < (uint)*(int8 *)(param_3 + 0xe)) {
iVar1 = **(int **)(param_3 + 0xc);
**(int **)(param_3 + 0xc) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(param_1);
}
}
}
else {
delete_map_weak_ref(param_1,param_3);
}
if (0xfffffff6 < (uint)*(int8 *)(param_3 + 0x12)) {
iVar1 = **(int **)(param_3 + 0x10);
**(int **)(param_3 + 0x10) = iVar1 + -1;
if (iVar1 < 2) {
js_free_value_rt(param_1);
}
}
*param_3 = *param_3 + -1;
if (*param_3 == 0) {
lVar3 = *(long *)(param_3 + 4);
plVar2 = *(long **)(param_3 + 6);
*(long **)(lVar3 + 8) = plVar2;
*plVar2 = lVar3;
param_3[4] = 0;
param_3[5] = 0;
param_3[6] = 0;
param_3[7] = 0;
*(long *)(param_1 + 0x28) = *(long *)(param_1 + 0x28) + -1;
lVar3 = (**(code **)(param_1 + 0x20))(param_3);
*(long *)(param_1 + 0x30) = (*(long *)(param_1 + 0x30) - lVar3) + -8;
(**(code **)(param_1 + 0x10))(*(int8 *)(param_1 + 0x40),param_3);
}
else {
param_3[1] = 1;
param_3[0xc] = 0;
param_3[0xe] = 3;
param_3[0xf] = 0;
param_3[0x10] = 0;
param_3[0x12] = 3;
param_3[0x13] = 0;
}
param_2[6] = param_2[6] + -1;
return;
}
|
|
57,651
|
js_array_includes
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_includes(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, val;
int64_t len, n;
JSValue *arrp;
uint32_t count;
int res;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
res = TRUE;
if (len > 0) {
n = 0;
if (argc > 1) {
if (JS_ToInt64Clamp(ctx, &n, argv[1], 0, len, len))
goto exception;
}
if (js_get_fast_array(ctx, obj, &arrp, &count)) {
for (; n < count; n++) {
if (js_strict_eq2(ctx, js_dup(argv[0]), js_dup(arrp[n]),
JS_EQ_SAME_VALUE_ZERO)) {
goto done;
}
}
}
for (; n < len; n++) {
val = JS_GetPropertyInt64(ctx, obj, n);
if (JS_IsException(val))
goto exception;
if (js_strict_eq2(ctx, js_dup(argv[0]), val,
JS_EQ_SAME_VALUE_ZERO)) {
goto done;
}
}
}
res = FALSE;
done:
JS_FreeValue(ctx, obj);
return js_bool(res);
exception:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O0
|
c
|
js_array_includes:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movl %ecx, 0xbc(%rsp)
movq %r8, 0xb0(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x37770
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
leaq 0x88(%rsp), %rsi
callq 0x2df60
cmpl $0x0, %eax
je 0x507ce
jmp 0x50a63
movl $0x1, 0x70(%rsp)
cmpq $0x0, 0x88(%rsp)
jle 0x50a23
movq $0x0, 0x80(%rsp)
cmpl $0x1, 0xbc(%rsp)
jle 0x50843
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq 0x88(%rsp), %r9
movq 0x88(%rsp), %rax
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rcx
leaq 0x80(%rsp), %rsi
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x38b10
cmpl $0x0, %eax
je 0x50841
jmp 0x50a63
jmp 0x50843
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0x78(%rsp), %rcx
leaq 0x74(%rsp), %r8
callq 0x70740
cmpl $0x0, %eax
je 0x5092a
jmp 0x50875
movq 0x80(%rsp), %rax
movl 0x74(%rsp), %ecx
cmpq %rcx, %rax
jge 0x50928
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x216d0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x216d0
movq 0x18(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
movl $0x2, %r9d
callq 0x5a000
cmpl $0x0, %eax
je 0x5090d
jmp 0x50a2b
jmp 0x5090f
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x50875
jmp 0x5092a
jmp 0x5092c
movq 0x80(%rsp), %rax
cmpq 0x88(%rsp), %rax
jge 0x50a21
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rcx
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x314b0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x509aa
jmp 0x50a63
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x216d0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %r8
movl $0x2, %r9d
callq 0x5a000
cmpl $0x0, %eax
je 0x50a06
jmp 0x50a2b
jmp 0x50a08
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x5092c
jmp 0x50a23
movl $0x0, 0x70(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
movl 0x70(%rsp), %edi
callq 0x57250
movq %rax, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
jmp 0x50a97
movq 0xc0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nop
|
js_array_includes:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov [rsp+0E8h+var_2C], ecx
mov [rsp+0E8h+var_38], r8
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call JS_ToObject
mov [rsp+0E8h+var_88], rax
mov [rsp+0E8h+var_80], rdx
mov rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_80]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_28]
mov rdx, [rsp+0E8h+var_48]
mov rcx, [rsp+0E8h+var_40]
lea rsi, [rsp+0E8h+var_60]
call js_get_length64
cmp eax, 0
jz short loc_507CE
jmp loc_50A63
loc_507CE:
mov [rsp+0E8h+var_78], 1
cmp [rsp+0E8h+var_60], 0
jle loc_50A23
mov [rsp+0E8h+var_68], 0
cmp [rsp+0E8h+var_2C], 1
jle short loc_50843
mov rdi, [rsp+0E8h+var_28]
mov rcx, [rsp+0E8h+var_38]
mov r9, [rsp+0E8h+var_60]
mov rax, [rsp+0E8h+var_60]
mov rdx, [rcx+10h]
mov rcx, [rcx+18h]
lea rsi, [rsp+0E8h+var_68]
xor r8d, r8d
mov [rsp+0E8h+var_E8], rax
call JS_ToInt64Clamp
cmp eax, 0
jz short loc_50841
jmp loc_50A63
loc_50841:
jmp short $+2
loc_50843:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
lea rcx, [rsp+0E8h+var_70]
lea r8, [rsp+0E8h+var_74]
call js_get_fast_array
cmp eax, 0
jz loc_5092A
jmp short $+2
loc_50875:
mov rax, [rsp+0E8h+var_68]
mov ecx, [rsp+0E8h+var_74]
cmp rax, rcx
jge loc_50928
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_D0], rax
mov rax, [rsp+0E8h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov [rsp+0E8h+var_98], rax
mov [rsp+0E8h+var_90], rdx
mov rax, [rsp+0E8h+var_70]
mov rcx, [rsp+0E8h+var_68]
shl rcx, 4
add rax, rcx
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rdi, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_A8], rax
mov [rsp+0E8h+var_A0], rdx
mov rsi, [rsp+0E8h+var_98]
mov rdx, [rsp+0E8h+var_90]
mov rcx, [rsp+0E8h+var_A8]
mov r8, [rsp+0E8h+var_A0]
mov r9d, 2
call js_strict_eq2
cmp eax, 0
jz short loc_5090D
jmp loc_50A2B
loc_5090D:
jmp short $+2
loc_5090F:
mov rax, [rsp+0E8h+var_68]
add rax, 1
mov [rsp+0E8h+var_68], rax
jmp loc_50875
loc_50928:
jmp short $+2
loc_5092A:
jmp short $+2
loc_5092C:
mov rax, [rsp+0E8h+var_68]
cmp rax, [rsp+0E8h+var_60]
jge loc_50A21
mov rdi, [rsp+0E8h+var_28]
mov rcx, [rsp+0E8h+var_68]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_GetPropertyInt64
mov [rsp+0E8h+var_B8], rax
mov [rsp+0E8h+var_B0], rdx
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_509AA
jmp loc_50A63
loc_509AA:
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_D8], rax
mov rax, [rsp+0E8h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call js_dup
mov rdi, [rsp+0E8h+var_D8]
mov [rsp+0E8h+var_C8], rax
mov [rsp+0E8h+var_C0], rdx
mov rsi, [rsp+0E8h+var_C8]
mov rdx, [rsp+0E8h+var_C0]
mov rcx, [rsp+0E8h+var_58]
mov r8, [rsp+0E8h+var_50]
mov r9d, 2
call js_strict_eq2
cmp eax, 0
jz short loc_50A06
jmp short loc_50A2B
loc_50A06:
jmp short $+2
loc_50A08:
mov rax, [rsp+0E8h+var_68]
add rax, 1
mov [rsp+0E8h+var_68], rax
jmp loc_5092C
loc_50A21:
jmp short $+2
loc_50A23:
mov [rsp+0E8h+var_78], 0
loc_50A2B:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_FreeValue
mov edi, [rsp+0E8h+var_78]
call js_bool
mov [rsp+0E8h+var_10], rax
mov [rsp+0E8h+var_8], rdx
jmp short loc_50A97
loc_50A63:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_48]
mov rdx, [rsp+0E8h+var_40]
call JS_FreeValue
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
loc_50A97:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
|
long long js_array_includes(
long long a1,
_DWORD *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)
{
long long v14; // rdx
long long v15; // rdx
long long v16; // rdx
long long v17; // rdx
long long v18; // rdx
long long v19; // rdx
long long v21; // [rsp+10h] [rbp-D8h]
long long v22; // [rsp+18h] [rbp-D0h]
_DWORD *v23; // [rsp+20h] [rbp-C8h]
_DWORD *v24; // [rsp+40h] [rbp-A8h]
_DWORD *v25; // [rsp+50h] [rbp-98h]
long long v26; // [rsp+58h] [rbp-90h]
unsigned int v27; // [rsp+70h] [rbp-78h]
unsigned int v28; // [rsp+74h] [rbp-74h] BYREF
long long v29; // [rsp+78h] [rbp-70h] BYREF
long long v30; // [rsp+80h] [rbp-68h] BYREF
long long v31; // [rsp+88h] [rbp-60h] BYREF
long long PropertyInt64; // [rsp+90h] [rbp-58h]
long long v33; // [rsp+98h] [rbp-50h]
_DWORD *v34; // [rsp+A0h] [rbp-48h]
long long v35; // [rsp+A8h] [rbp-40h]
_DWORD **v36; // [rsp+B0h] [rbp-38h]
int v37; // [rsp+BCh] [rbp-2Ch]
long long v38; // [rsp+C0h] [rbp-28h]
_DWORD *v39; // [rsp+C8h] [rbp-20h]
long long v40; // [rsp+D0h] [rbp-18h]
long long v41; // [rsp+D8h] [rbp-10h]
long long v42; // [rsp+E0h] [rbp-8h]
v39 = a2;
v40 = a3;
v38 = a1;
v37 = a4;
v36 = (_DWORD **)a5;
v34 = JS_ToObject(a1, a2, a3, a7, a8, a9, a10, a11, a12, a13, a14, a4, a5, a6);
v35 = v14;
if ( (unsigned int)js_get_length64(a1, &v31, (int)v34, v14) )
goto LABEL_15;
v27 = 1;
if ( v31 > 0 )
{
v30 = 0LL;
if ( v37 <= 1 || !(unsigned int)JS_ToInt64Clamp(v38, &v30, v36[2], (unsigned int)v36[3], 0LL, v31, v31) )
{
if ( !(unsigned int)js_get_fast_array(v38, v34, v35, &v29, &v28) )
goto LABEL_9;
while ( v30 < v28 )
{
v22 = v38;
v25 = js_dup(*v36, (unsigned int)v36[1]);
v26 = v15;
v24 = js_dup(*(_DWORD **)(16 * v30 + v29), *(_QWORD *)(16 * v30 + v29 + 8));
if ( (unsigned int)js_strict_eq2(v22, v25, v26, v24, v16, 2LL) )
goto LABEL_14;
++v30;
}
LABEL_9:
while ( v30 < v31 )
{
PropertyInt64 = JS_GetPropertyInt64(v38, (long long)v34, v35, v30);
v33 = v17;
if ( JS_IsException_1(PropertyInt64, v17) )
goto LABEL_15;
v21 = v38;
v23 = js_dup(*v36, (unsigned int)v36[1]);
if ( (unsigned int)js_strict_eq2(v21, v23, v18, PropertyInt64, v33, 2LL) )
goto LABEL_14;
++v30;
}
goto LABEL_13;
}
LABEL_15:
JS_FreeValue(v38, (long long)v34, v35);
LODWORD(v41) = 0;
v42 = 6LL;
return v41;
}
LABEL_13:
v27 = 0;
LABEL_14:
JS_FreeValue(v38, (long long)v34, v35);
v41 = js_bool(v27);
v42 = v19;
return v41;
}
|
js_array_includes:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ECX
MOV qword ptr [RSP + 0xb0],R8
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x00137770
MOV qword ptr [RSP + 0x60],RAX
MOV qword ptr [RSP + 0x68],RDX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
LEA RSI,[RSP + 0x88]
CALL 0x0012df60
CMP EAX,0x0
JZ 0x001507ce
JMP 0x00150a63
LAB_001507ce:
MOV dword ptr [RSP + 0x70],0x1
CMP qword ptr [RSP + 0x88],0x0
JLE 0x00150a23
MOV qword ptr [RSP + 0x80],0x0
CMP dword ptr [RSP + 0xbc],0x1
JLE 0x00150843
MOV RDI,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0xb0]
MOV R9,qword ptr [RSP + 0x88]
MOV RAX,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RCX + 0x10]
MOV RCX,qword ptr [RCX + 0x18]
LEA RSI,[RSP + 0x80]
XOR R8D,R8D
MOV qword ptr [RSP],RAX
CALL 0x00138b10
CMP EAX,0x0
JZ 0x00150841
JMP 0x00150a63
LAB_00150841:
JMP 0x00150843
LAB_00150843:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
LEA RCX,[RSP + 0x78]
LEA R8,[RSP + 0x74]
CALL 0x00170740
CMP EAX,0x0
JZ 0x0015092a
JMP 0x00150875
LAB_00150875:
MOV RAX,qword ptr [RSP + 0x80]
MOV ECX,dword ptr [RSP + 0x74]
CMP RAX,RCX
JGE 0x00150928
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001216d0
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x80]
SHL RCX,0x4
ADD RAX,RCX
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001216d0
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RSI,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x58]
MOV RCX,qword ptr [RSP + 0x40]
MOV R8,qword ptr [RSP + 0x48]
MOV R9D,0x2
CALL 0x0015a000
CMP EAX,0x0
JZ 0x0015090d
JMP 0x00150a2b
LAB_0015090d:
JMP 0x0015090f
LAB_0015090f:
MOV RAX,qword ptr [RSP + 0x80]
ADD RAX,0x1
MOV qword ptr [RSP + 0x80],RAX
JMP 0x00150875
LAB_00150928:
JMP 0x0015092a
LAB_0015092a:
JMP 0x0015092c
LAB_0015092c:
MOV RAX,qword ptr [RSP + 0x80]
CMP RAX,qword ptr [RSP + 0x88]
JGE 0x00150a21
MOV RDI,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x001314b0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001509aa
JMP 0x00150a63
LAB_001509aa:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0xb0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x001216d0
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x90]
MOV R8,qword ptr [RSP + 0x98]
MOV R9D,0x2
CALL 0x0015a000
CMP EAX,0x0
JZ 0x00150a06
JMP 0x00150a2b
LAB_00150a06:
JMP 0x00150a08
LAB_00150a08:
MOV RAX,qword ptr [RSP + 0x80]
ADD RAX,0x1
MOV qword ptr [RSP + 0x80],RAX
JMP 0x0015092c
LAB_00150a21:
JMP 0x00150a23
LAB_00150a23:
MOV dword ptr [RSP + 0x70],0x0
LAB_00150a2b:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
MOV EDI,dword ptr [RSP + 0x70]
CALL 0x00157250
MOV qword ptr [RSP + 0xd8],RAX
MOV qword ptr [RSP + 0xe0],RDX
JMP 0x00150a97
LAB_00150a63:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
LAB_00150a97:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16]
js_array_includes(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int8 uVar1;
int iVar2;
int8 *puVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int4 local_78;
uint local_74;
long local_70;
long local_68;
long local_60;
int1 local_58 [16];
int1 local_48 [16];
int8 *local_38;
int local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
local_48 = JS_ToObject(param_1,param_2,param_3);
iVar2 = js_get_length64(local_28,&local_60,local_48._0_8_,local_48._8_8_);
if (iVar2 == 0) {
local_78 = 1;
if (0 < local_60) {
local_68 = 0;
if (1 < local_2c) {
iVar2 = JS_ToInt64Clamp(local_28,&local_68,local_38[2],local_38[3],0,local_60,local_60);
if (iVar2 != 0) goto LAB_00150a63;
}
iVar2 = js_get_fast_array(local_28,local_48._0_8_,local_48._8_8_,&local_70,&local_74);
if (iVar2 != 0) {
for (; uVar1 = local_28, local_68 < (long)(ulong)local_74; local_68 = local_68 + 1) {
auVar4 = js_dup(*local_38,local_38[1]);
puVar3 = (int8 *)(local_70 + local_68 * 0x10);
auVar5 = js_dup(*puVar3,puVar3[1]);
iVar2 = js_strict_eq2(uVar1,auVar4._0_8_,auVar4._8_8_,auVar5._0_8_,auVar5._8_8_,2);
if (iVar2 != 0) goto LAB_00150a2b;
}
}
while( true ) {
if (local_60 <= local_68) break;
auVar4 = JS_GetPropertyInt64(local_28,local_48._0_8_,local_48._8_8_,local_68);
local_58 = auVar4;
iVar2 = JS_IsException(auVar4._0_8_,auVar4._8_8_);
uVar1 = local_28;
if (iVar2 != 0) goto LAB_00150a63;
auVar4 = js_dup(*local_38,local_38[1]);
iVar2 = js_strict_eq2(uVar1,auVar4._0_8_,auVar4._8_8_,local_58._0_8_,local_58._8_8_,2);
if (iVar2 != 0) goto LAB_00150a2b;
local_68 = local_68 + 1;
}
}
local_78 = 0;
LAB_00150a2b:
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
auVar4 = js_bool(local_78);
local_8 = auVar4._8_8_;
local_10 = auVar4._0_4_;
uStack_c = auVar4._4_4_;
}
else {
LAB_00150a63:
JS_FreeValue(local_28,local_48._0_8_,local_48._8_8_);
local_10 = 0;
local_8 = 6;
}
auVar4._4_4_ = uStack_c;
auVar4._0_4_ = local_10;
auVar4._8_8_ = local_8;
return auVar4;
}
|
|
57,652
|
js_array_includes
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_array_includes(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue obj, val;
int64_t len, n;
JSValue *arrp;
uint32_t count;
int res;
obj = JS_ToObject(ctx, this_val);
if (js_get_length64(ctx, &len, obj))
goto exception;
res = TRUE;
if (len > 0) {
n = 0;
if (argc > 1) {
if (JS_ToInt64Clamp(ctx, &n, argv[1], 0, len, len))
goto exception;
}
if (js_get_fast_array(ctx, obj, &arrp, &count)) {
for (; n < count; n++) {
if (js_strict_eq2(ctx, js_dup(argv[0]), js_dup(arrp[n]),
JS_EQ_SAME_VALUE_ZERO)) {
goto done;
}
}
}
for (; n < len; n++) {
val = JS_GetPropertyInt64(ctx, obj, n);
if (JS_IsException(val))
goto exception;
if (js_strict_eq2(ctx, js_dup(argv[0]), val,
JS_EQ_SAME_VALUE_ZERO)) {
goto done;
}
}
}
res = FALSE;
done:
JS_FreeValue(ctx, obj);
return js_bool(res);
exception:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
|
O1
|
c
|
js_array_includes:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movl %ecx, %ebp
movq %rdi, %rbx
callq 0x26ddd
movq %rax, %r14
movq %rdx, %r15
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
callq 0x22adc
testl %eax, %eax
je 0x34608
xorl %r12d, %r12d
movl $0x6, %r13d
jmp 0x3478b
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
jle 0x34766
movq $0x0, 0x10(%rsp)
cmpl $0x2, %ebp
jl 0x34651
movq 0x10(%r13), %rdx
movq 0x18(%r13), %rcx
movq 0x28(%rsp), %r9
movq %r9, (%rsp)
xorl %r12d, %r12d
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x27858
testl %eax, %eax
jne 0x345fd
movq %r14, 0x18(%rsp)
movb $0x1, %al
cmpl $-0x1, %r15d
jne 0x34674
movq 0x18(%rsp), %rcx
cmpw $0x2, 0x6(%rcx)
jne 0x34674
testb $0x8, 0x5(%rcx)
jne 0x347bc
movq $0x0, 0x20(%rsp)
testb %al, %al
jne 0x346fe
movq 0x10(%rsp), %rbp
cmpq 0x20(%rsp), %rbp
jge 0x346f9
movq %rbp, %rax
shlq $0x4, %rax
leaq (%rax,%rcx), %r12
addq $0x8, %r12
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rsi, 0x18(%rsp)
cmpl $-0x9, %edx
jb 0x346b5
movq 0x18(%rsp), %rax
incl (%rax)
movq -0x8(%r12), %rcx
movq (%r12), %r8
movq %rcx, 0x18(%rsp)
cmpl $-0x9, %r8d
jb 0x346d0
movq 0x18(%rsp), %rax
incl (%rax)
movq %rbx, %rdi
movl $0x2, %r9d
callq 0x3a124
testl %eax, %eax
jne 0x347af
incq %rbp
addq $0x10, %r12
cmpq %rbp, 0x20(%rsp)
jne 0x3469c
movq 0x20(%rsp), %rbp
movq %rbp, 0x10(%rsp)
movq 0x10(%rsp), %rbp
cmpq 0x28(%rsp), %rbp
jge 0x3476b
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x241b4
movq %rdx, %r8
cmpl $0x6, %r8d
je 0x34770
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rsi, 0x18(%rsp)
cmpl $-0x9, %edx
jb 0x34740
movq 0x18(%rsp), %rcx
incl (%rcx)
movq %rbx, %rdi
movq %rax, %rcx
movl $0x2, %r9d
callq 0x3a124
testl %eax, %eax
jne 0x3477a
incq %rbp
cmpq %rbp, 0x28(%rsp)
jne 0x3470d
movq 0x28(%rsp), %rbp
jmp 0x34780
xorl %r12d, %r12d
jmp 0x34785
xorl %r12d, %r12d
jmp 0x34780
movq %rbp, 0x10(%rsp)
jmp 0x345fa
movl $0x1, %r12d
movq %rbp, 0x10(%rsp)
movl $0x1, %r13d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d8c6
movq %r12, %rax
movq %r13, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x10(%rsp)
movl $0x1, %r12d
jmp 0x34785
movl 0x40(%rcx), %eax
movq %rax, 0x20(%rsp)
movq 0x38(%rcx), %rcx
xorl %eax, %eax
jmp 0x3467d
|
js_array_includes:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r13, r8
mov ebp, ecx
mov rbx, rdi
call JS_ToObject
mov r14, rax
mov r15, rdx
lea rsi, [rsp+68h+var_38]
mov rdi, rbx
mov rdx, rax
mov rcx, r15
call js_get_length64
test eax, eax
jz short loc_34608
loc_345FA:
xor r12d, r12d
loc_345FD:
mov r13d, 6
jmp loc_3478B
loc_34608:
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_40], rax
test rax, rax
jle loc_34766
mov [rsp+68h+var_58], 0
cmp ebp, 2
jl short loc_34651
mov rdx, [r13+10h]
mov rcx, [r13+18h]
mov r9, [rsp+68h+var_40]
mov [rsp+68h+var_68], r9
xor r12d, r12d
lea rsi, [rsp+68h+var_58]
mov rdi, rbx
xor r8d, r8d
call JS_ToInt64Clamp
test eax, eax
jnz short loc_345FD
loc_34651:
mov [rsp+68h+var_50], r14
mov al, 1
cmp r15d, 0FFFFFFFFh
jnz short loc_34674
mov rcx, [rsp+68h+var_50]
cmp word ptr [rcx+6], 2
jnz short loc_34674
test byte ptr [rcx+5], 8
jnz loc_347BC
loc_34674:
mov [rsp+68h+var_48], 0
loc_3467D:
test al, al
jnz short loc_346FE
mov rbp, [rsp+68h+var_58]
cmp rbp, [rsp+68h+var_48]
jge short loc_346F9
mov rax, rbp
shl rax, 4
lea r12, [rax+rcx]
add r12, 8
loc_3469C:
mov rsi, [r13+0]
mov rdx, [r13+8]
mov [rsp+68h+var_50], rsi
cmp edx, 0FFFFFFF7h
jb short loc_346B5
mov rax, [rsp+68h+var_50]
inc dword ptr [rax]
loc_346B5:
mov rcx, [r12-8]
mov r8, [r12]
mov [rsp+68h+var_50], rcx
cmp r8d, 0FFFFFFF7h
jb short loc_346D0
mov rax, [rsp+68h+var_50]
inc dword ptr [rax]
loc_346D0:
mov rdi, rbx
mov r9d, 2
call js_strict_eq2
test eax, eax
jnz loc_347AF
inc rbp
add r12, 10h
cmp [rsp+68h+var_48], rbp
jnz short loc_3469C
mov rbp, [rsp+68h+var_48]
loc_346F9:
mov [rsp+68h+var_58], rbp
loc_346FE:
mov rbp, [rsp+68h+var_58]
cmp rbp, [rsp+68h+var_40]
jge short loc_3476B
xor r12d, r12d
loc_3470D:
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov rcx, rbp
call JS_GetPropertyInt64
mov r8, rdx
cmp r8d, 6
jz short loc_34770
mov rsi, [r13+0]
mov rdx, [r13+8]
mov [rsp+68h+var_50], rsi
cmp edx, 0FFFFFFF7h
jb short loc_34740
mov rcx, [rsp+68h+var_50]
inc dword ptr [rcx]
loc_34740:
mov rdi, rbx
mov rcx, rax
mov r9d, 2
call js_strict_eq2
test eax, eax
jnz short loc_3477A
inc rbp
cmp [rsp+68h+var_40], rbp
jnz short loc_3470D
mov rbp, [rsp+68h+var_40]
jmp short loc_34780
loc_34766:
xor r12d, r12d
jmp short loc_34785
loc_3476B:
xor r12d, r12d
jmp short loc_34780
loc_34770:
mov [rsp+68h+var_58], rbp
jmp loc_345FA
loc_3477A:
mov r12d, 1
loc_34780:
mov [rsp+68h+var_58], rbp
loc_34785:
mov r13d, 1
loc_3478B:
mov rdi, [rbx+18h]
mov rsi, r14
mov rdx, r15
call JS_FreeValueRT
mov rax, r12
mov rdx, r13
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_347AF:
mov [rsp+68h+var_58], rbp
mov r12d, 1
jmp short loc_34785
loc_347BC:
mov eax, [rcx+40h]
mov [rsp+68h+var_48], rax
mov rcx, [rcx+38h]
xor eax, eax
jmp loc_3467D
|
long long js_array_includes(
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 v15; // ebp
_DWORD *v16; // r14
long long v17; // rdx
long long v18; // r15
_DWORD *v19; // rcx
long long v20; // r12
char v21; // al
long long v22; // rbp
long long *v23; // r12
_DWORD *v24; // rsi
long long v25; // rdx
_DWORD *v26; // rcx
long long v27; // r8
unsigned long long v28; // rbp
unsigned long long PropertyInt64; // rax
long long v30; // rdx
long long v31; // r8
_DWORD *v32; // rsi
long long v33; // rdx
long long v35; // [rsp+10h] [rbp-58h] BYREF
_DWORD *v36; // [rsp+18h] [rbp-50h]
signed long long v37; // [rsp+20h] [rbp-48h]
long long v38; // [rsp+28h] [rbp-40h]
long long v39[7]; // [rsp+30h] [rbp-38h] BYREF
v15 = a4;
v16 = JS_ToObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v18 = v17;
if ( (unsigned int)js_get_length64(a1, v39, (int)v16, v17) )
{
LABEL_2:
v20 = 0LL;
goto LABEL_35;
}
v38 = v39[0];
if ( v39[0] <= 0 )
{
v20 = 0LL;
goto LABEL_35;
}
v35 = 0LL;
if ( v15 < 2
|| (v20 = 0LL,
!(unsigned int)JS_ToInt64Clamp(
a1,
(unsigned long long *)&v35,
*(_DWORD **)(a5 + 16),
*(_QWORD *)(a5 + 24),
0LL,
v38,
v38)) )
{
v36 = v16;
v21 = 1;
if ( (_DWORD)v18 == -1 && (v19 = v36, *((_WORD *)v36 + 3) == 2) && (*((_BYTE *)v36 + 5) & 8) != 0 )
{
v37 = (unsigned int)v36[16];
v19 = (_DWORD *)*((_QWORD *)v36 + 7);
v21 = 0;
}
else
{
v37 = 0LL;
}
if ( !v21 )
{
v22 = v35;
if ( v35 < v37 )
{
v23 = (long long *)&v19[4 * v35 + 2];
while ( 1 )
{
v24 = *(_DWORD **)a5;
v25 = *(_QWORD *)(a5 + 8);
v36 = *(_DWORD **)a5;
if ( (unsigned int)v25 >= 0xFFFFFFF7 )
++*v36;
v26 = (_DWORD *)*(v23 - 1);
v27 = *v23;
v36 = v26;
if ( (unsigned int)v27 >= 0xFFFFFFF7 )
++*v36;
if ( (unsigned int)js_strict_eq2(a1, v24, v25, v26, v27, 2LL) )
break;
++v22;
v23 += 2;
if ( v37 == v22 )
{
v22 = v37;
goto LABEL_21;
}
}
v35 = v22;
v20 = 1LL;
goto LABEL_35;
}
LABEL_21:
v35 = v22;
}
v28 = v35;
if ( v35 >= v38 )
{
v20 = 0LL;
}
else
{
v20 = 0LL;
while ( 1 )
{
PropertyInt64 = JS_GetPropertyInt64(a1, (long long)v16, v18, v28);
v31 = v30;
if ( (_DWORD)v30 == 6 )
{
v35 = v28;
goto LABEL_2;
}
v32 = *(_DWORD **)a5;
v33 = *(_QWORD *)(a5 + 8);
v36 = *(_DWORD **)a5;
if ( (unsigned int)v33 >= 0xFFFFFFF7 )
++*v36;
if ( (unsigned int)js_strict_eq2(a1, v32, v33, PropertyInt64, v31, 2LL) )
break;
if ( v38 == ++v28 )
{
v28 = v38;
goto LABEL_34;
}
}
v20 = 1LL;
}
LABEL_34:
v35 = v28;
}
LABEL_35:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v16, v18);
return v20;
}
|
js_array_includes:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R13,R8
MOV EBP,ECX
MOV RBX,RDI
CALL 0x00126ddd
MOV R14,RAX
MOV R15,RDX
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
MOV RDX,RAX
MOV RCX,R15
CALL 0x00122adc
TEST EAX,EAX
JZ 0x00134608
LAB_001345fa:
XOR R12D,R12D
LAB_001345fd:
MOV R13D,0x6
JMP 0x0013478b
LAB_00134608:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x28],RAX
TEST RAX,RAX
JLE 0x00134766
MOV qword ptr [RSP + 0x10],0x0
CMP EBP,0x2
JL 0x00134651
MOV RDX,qword ptr [R13 + 0x10]
MOV RCX,qword ptr [R13 + 0x18]
MOV R9,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],R9
XOR R12D,R12D
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
XOR R8D,R8D
CALL 0x00127858
TEST EAX,EAX
JNZ 0x001345fd
LAB_00134651:
MOV qword ptr [RSP + 0x18],R14
MOV AL,0x1
CMP R15D,-0x1
JNZ 0x00134674
MOV RCX,qword ptr [RSP + 0x18]
CMP word ptr [RCX + 0x6],0x2
JNZ 0x00134674
TEST byte ptr [RCX + 0x5],0x8
JNZ 0x001347bc
LAB_00134674:
MOV qword ptr [RSP + 0x20],0x0
LAB_0013467d:
TEST AL,AL
JNZ 0x001346fe
MOV RBP,qword ptr [RSP + 0x10]
CMP RBP,qword ptr [RSP + 0x20]
JGE 0x001346f9
MOV RAX,RBP
SHL RAX,0x4
LEA R12,[RAX + RCX*0x1]
ADD R12,0x8
LAB_0013469c:
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV qword ptr [RSP + 0x18],RSI
CMP EDX,-0x9
JC 0x001346b5
MOV RAX,qword ptr [RSP + 0x18]
INC dword ptr [RAX]
LAB_001346b5:
MOV RCX,qword ptr [R12 + -0x8]
MOV R8,qword ptr [R12]
MOV qword ptr [RSP + 0x18],RCX
CMP R8D,-0x9
JC 0x001346d0
MOV RAX,qword ptr [RSP + 0x18]
INC dword ptr [RAX]
LAB_001346d0:
MOV RDI,RBX
MOV R9D,0x2
CALL 0x0013a124
TEST EAX,EAX
JNZ 0x001347af
INC RBP
ADD R12,0x10
CMP qword ptr [RSP + 0x20],RBP
JNZ 0x0013469c
MOV RBP,qword ptr [RSP + 0x20]
LAB_001346f9:
MOV qword ptr [RSP + 0x10],RBP
LAB_001346fe:
MOV RBP,qword ptr [RSP + 0x10]
CMP RBP,qword ptr [RSP + 0x28]
JGE 0x0013476b
XOR R12D,R12D
LAB_0013470d:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV RCX,RBP
CALL 0x001241b4
MOV R8,RDX
CMP R8D,0x6
JZ 0x00134770
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV qword ptr [RSP + 0x18],RSI
CMP EDX,-0x9
JC 0x00134740
MOV RCX,qword ptr [RSP + 0x18]
INC dword ptr [RCX]
LAB_00134740:
MOV RDI,RBX
MOV RCX,RAX
MOV R9D,0x2
CALL 0x0013a124
TEST EAX,EAX
JNZ 0x0013477a
INC RBP
CMP qword ptr [RSP + 0x28],RBP
JNZ 0x0013470d
MOV RBP,qword ptr [RSP + 0x28]
JMP 0x00134780
LAB_00134766:
XOR R12D,R12D
JMP 0x00134785
LAB_0013476b:
XOR R12D,R12D
JMP 0x00134780
LAB_00134770:
MOV qword ptr [RSP + 0x10],RBP
JMP 0x001345fa
LAB_0013477a:
MOV R12D,0x1
LAB_00134780:
MOV qword ptr [RSP + 0x10],RBP
LAB_00134785:
MOV R13D,0x1
LAB_0013478b:
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
MOV RDX,R15
CALL 0x0011d8c6
MOV RAX,R12
MOV RDX,R13
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001347af:
MOV qword ptr [RSP + 0x10],RBP
MOV R12D,0x1
JMP 0x00134785
LAB_001347bc:
MOV EAX,dword ptr [RCX + 0x40]
MOV qword ptr [RSP + 0x20],RAX
MOV RCX,qword ptr [RCX + 0x38]
XOR EAX,EAX
JMP 0x0013467d
|
int1 [16]
js_array_includes(long param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5
)
{
bool bVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar6;
ulong uVar7;
int8 uVar8;
int8 uVar9;
int1 auVar10 [16];
ulong local_58;
int *local_50;
ulong local_48;
ulong local_40;
ulong local_38;
int *piVar5;
auVar10 = JS_ToObject();
piVar5 = auVar10._8_8_;
piVar3 = auVar10._0_8_;
piVar4 = piVar5;
iVar2 = js_get_length64(param_1,&local_38,piVar3);
uVar7 = local_58;
if (iVar2 == 0) {
local_40 = local_38;
if ((long)local_38 < 1) {
uVar8 = 0;
uVar6 = local_58;
}
else {
local_58 = 0;
if (1 < param_4) {
piVar4 = (int *)param_5[3];
iVar2 = JS_ToInt64Clamp(param_1,&local_58,param_5[2],piVar4,0,local_38,local_38);
uVar7 = local_58;
if (iVar2 != 0) goto LAB_001345fd;
}
bVar1 = true;
if (((auVar10._8_4_ == -1) && (piVar4 = piVar3, *(short *)((long)piVar3 + 6) == 2)) &&
((*(byte *)((long)piVar3 + 5) & 8) != 0)) {
local_48 = (ulong)(uint)piVar3[0x10];
piVar4 = *(int **)(piVar3 + 0xe);
bVar1 = false;
}
else {
local_48 = 0;
}
uVar7 = local_58;
local_50 = piVar3;
if ((!bVar1) && ((long)local_58 < (long)local_48)) {
piVar4 = piVar4 + local_58 * 4 + 2;
uVar6 = local_58;
do {
if (0xfffffff6 < (uint)param_5[1]) {
*(int *)*param_5 = *(int *)*param_5 + 1;
}
local_50 = *(int **)(piVar4 + -2);
if (0xfffffff6 < (uint)*(int8 *)piVar4) {
*local_50 = *local_50 + 1;
}
iVar2 = js_strict_eq2(param_1);
if (iVar2 != 0) {
uVar8 = 1;
goto LAB_00134785;
}
uVar6 = uVar6 + 1;
piVar4 = piVar4 + 4;
uVar7 = local_48;
} while (local_48 != uVar6);
}
local_58 = uVar7;
if ((long)local_58 < (long)local_40) {
uVar8 = 0;
uVar7 = local_58;
do {
auVar10 = JS_GetPropertyInt64(param_1,piVar3,piVar5,uVar7);
if (auVar10._8_4_ == 6) goto LAB_001345fd;
local_50 = (int *)*param_5;
uVar9 = param_5[1];
if (0xfffffff6 < (uint)uVar9) {
*local_50 = *local_50 + 1;
}
iVar2 = js_strict_eq2(param_1,local_50,uVar9,auVar10._0_8_,auVar10._8_8_,2);
if (iVar2 != 0) {
uVar8 = 1;
uVar6 = uVar7;
break;
}
uVar7 = uVar7 + 1;
uVar6 = local_40;
} while (local_40 != uVar7);
}
else {
uVar8 = 0;
uVar6 = local_58;
}
}
LAB_00134785:
local_58 = uVar6;
uVar9 = 1;
}
else {
LAB_001345fd:
local_58 = uVar7;
uVar8 = 0;
uVar9 = 6;
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),piVar3,piVar5);
auVar10._8_8_ = uVar9;
auVar10._0_8_ = uVar8;
return auVar10;
}
|
|
57,653
|
blst_p1_compress
|
corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/e1.c
|
void blst_p1_compress(unsigned char out[48], const POINTonE1 *in)
{
if (vec_is_zero(in->Z, sizeof(in->Z))) {
bytes_zero(out, 48);
out[0] = 0xc0; /* compressed and infinity bits */
} else {
limb_t sign = POINTonE1_Compress_BE(out, in);
out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));
}
}
|
O2
|
c
|
blst_p1_compress:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsi), %r15
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x510f5
testq %rax, %rax
je 0x51460
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x512c5
movb $-0x40, %al
jmp 0x514a0
leaq 0x2e881(%rip), %rsi # 0x7fce8
pushq $0x30
popq %rdx
movq %r15, %rdi
callq 0x52f34
testq %rax, %rax
jne 0x5148c
leaq -0xa8(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x50f03
movq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x513d2
shlb $0x4, %al
andb $0x20, %al
orb (%rbx), %al
orb $-0x80, %al
movb %al, (%rbx)
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
blst_p1_compress:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 98h
mov r14, rsi
mov rbx, rdi
lea r15, [rsi+60h]
push 30h ; '0'
pop rsi
mov rdi, r15
call vec_is_zero
test rax, rax
jz short loc_51460
push 30h ; '0'
pop rsi
mov rdi, rbx
call bytes_zero
mov al, 0C0h
jmp short loc_514A0
loc_51460:
lea rsi, BLS12_381_Rx
push 30h ; '0'
pop rdx
mov rdi, r15
call vec_is_equal
test rax, rax
jnz short loc_5148C
lea r15, [rbp+var_A8]
mov rdi, r15
mov rsi, r14
call POINTonE1_from_Jacobian
mov r14, r15
loc_5148C:
mov rdi, rbx
mov rsi, r14
call POINTonE1_affine_Compress_BE
shl al, 4
and al, 20h
or al, [rbx]
or al, 80h
loc_514A0:
mov [rbx], al
add rsp, 98h
pop rbx
pop r14
pop r15
pop rbp
retn
|
char blst_p1_compress(char *a1, long long a2)
{
_BYTE *v2; // r14
char result; // al
_BYTE v4[168]; // [rsp+8h] [rbp-A8h] BYREF
v2 = (_BYTE *)a2;
if ( vec_is_zero(a2 + 96, 0x30uLL) )
{
bytes_zero((long long)a1, 48LL);
result = -64;
}
else
{
if ( !vec_is_equal(a2 + 96, &BLS12_381_Rx, 48LL) )
{
POINTonE1_from_Jacobian((long long)v4, a2);
v2 = v4;
}
result = *a1 | (16 * POINTonE1_affine_Compress_BE((long long)a1, (long long)v2)) & 0x20 | 0x80;
}
*a1 = result;
return result;
}
|
blst_p1_compress:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x98
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSI + 0x60]
PUSH 0x30
POP RSI
MOV RDI,R15
CALL 0x001510f5
TEST RAX,RAX
JZ 0x00151460
PUSH 0x30
POP RSI
MOV RDI,RBX
CALL 0x001512c5
MOV AL,0xc0
JMP 0x001514a0
LAB_00151460:
LEA RSI,[0x17fce8]
PUSH 0x30
POP RDX
MOV RDI,R15
CALL 0x00152f34
TEST RAX,RAX
JNZ 0x0015148c
LEA R15,[RBP + -0xa8]
MOV RDI,R15
MOV RSI,R14
CALL 0x00150f03
MOV R14,R15
LAB_0015148c:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001513d2
SHL AL,0x4
AND AL,0x20
OR AL,byte ptr [RBX]
OR AL,0x80
LAB_001514a0:
MOV byte ptr [RBX],AL
ADD RSP,0x98
POP RBX
POP R14
POP R15
POP RBP
RET
|
void blst_p1_compress(byte *param_1,int1 *param_2)
{
long lVar1;
byte bVar2;
int1 *puVar3;
int1 local_b0 [144];
lVar1 = vec_is_zero(param_2 + 0x60,0x30);
if (lVar1 == 0) {
lVar1 = vec_is_equal(param_2 + 0x60,BLS12_381_Rx,0x30);
puVar3 = param_2;
if (lVar1 == 0) {
puVar3 = local_b0;
POINTonE1_from_Jacobian(puVar3,param_2);
}
bVar2 = POINTonE1_affine_Compress_BE(param_1,puVar3);
bVar2 = (bVar2 & 2) << 4 | *param_1 | 0x80;
}
else {
bytes_zero(param_1,0x30);
bVar2 = 0xc0;
}
*param_1 = bVar2;
return;
}
|
|
57,654
|
httplib::detail::to_utf8(int, char*)
|
hkr04[P]cpp-mcp/common/httplib.h
|
inline size_t to_utf8(int code, char *buff) {
if (code < 0x0080) {
buff[0] = static_cast<char>(code & 0x7F);
return 1;
} else if (code < 0x0800) {
buff[0] = static_cast<char>(0xC0 | ((code >> 6) & 0x1F));
buff[1] = static_cast<char>(0x80 | (code & 0x3F));
return 2;
} else if (code < 0xD800) {
buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
buff[2] = static_cast<char>(0x80 | (code & 0x3F));
return 3;
} else if (code < 0xE000) { // D800 - DFFF is invalid...
return 0;
} else if (code < 0x10000) {
buff[0] = static_cast<char>(0xE0 | ((code >> 12) & 0xF));
buff[1] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
buff[2] = static_cast<char>(0x80 | (code & 0x3F));
return 3;
} else if (code < 0x110000) {
buff[0] = static_cast<char>(0xF0 | ((code >> 18) & 0x7));
buff[1] = static_cast<char>(0x80 | ((code >> 12) & 0x3F));
buff[2] = static_cast<char>(0x80 | ((code >> 6) & 0x3F));
buff[3] = static_cast<char>(0x80 | (code & 0x3F));
return 4;
}
// NOTREACHED
return 0;
}
|
O2
|
c
|
httplib::detail::to_utf8(int, char*):
cmpl $0x7f, %edi
jg 0x27df7
andb $0x7f, %dil
movb %dil, (%rsi)
pushq $0x1
jmp 0x27e43
cmpl $0x7ff, %edi # imm = 0x7FF
ja 0x27e18
movl %edi, %eax
shrl $0x6, %eax
orb $-0x40, %al
movb %al, (%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x1(%rsi)
pushq $0x2
jmp 0x27e43
cmpl $0xd7ff, %edi # imm = 0xD7FF
ja 0x27e45
movl %edi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x2(%rsi)
pushq $0x3
popq %rax
retq
cmpl $0xe000, %edi # imm = 0xE000
jae 0x27e50
xorl %eax, %eax
retq
cmpl $0xffff, %edi # imm = 0xFFFF
jbe 0x27e20
cmpl $0x10ffff, %edi # imm = 0x10FFFF
ja 0x27e4d
movl %edi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movb %al, (%rsi)
movl %edi, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x1(%rsi)
movl %edi, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movb %al, 0x2(%rsi)
andb $0x3f, %dil
orb $-0x80, %dil
movb %dil, 0x3(%rsi)
pushq $0x4
jmp 0x27e43
|
_ZN7httplib6detail7to_utf8EiPc:
cmp edi, 7Fh
jg short loc_27DF7
and dil, 7Fh
mov [rsi], dil
push 1
jmp short loc_27E43
loc_27DF7:
cmp edi, 7FFh
ja short loc_27E18
mov eax, edi
shr eax, 6
or al, 0C0h
mov [rsi], al
and dil, 3Fh
or dil, 80h
mov [rsi+1], dil
push 2
jmp short loc_27E43
loc_27E18:
cmp edi, 0D7FFh
ja short loc_27E45
loc_27E20:
mov eax, edi
shr eax, 0Ch
or al, 0E0h
mov [rsi], al
mov eax, edi
shr eax, 6
and al, 3Fh
or al, 80h
mov [rsi+1], al
and dil, 3Fh
or dil, 80h
mov [rsi+2], dil
push 3
loc_27E43:
pop rax
retn
loc_27E45:
cmp edi, 0E000h
jnb short loc_27E50
loc_27E4D:
xor eax, eax
retn
loc_27E50:
cmp edi, 0FFFFh
jbe short loc_27E20
cmp edi, 10FFFFh
ja short loc_27E4D
mov eax, edi
shr eax, 12h
or al, 0F0h
mov [rsi], al
mov eax, edi
shr eax, 0Ch
and al, 3Fh
or al, 80h
mov [rsi+1], al
mov eax, edi
shr eax, 6
and al, 3Fh
or al, 80h
mov [rsi+2], al
and dil, 3Fh
or dil, 80h
mov [rsi+3], dil
push 4
jmp short loc_27E43
|
long long httplib::detail::to_utf8(httplib::detail *this, _BYTE *a2, char *a3)
{
if ( (int)this <= 127 )
{
*a2 = (unsigned __int8)this & 0x7F;
return 1LL;
}
if ( (unsigned int)this <= 0x7FF )
{
*a2 = ((unsigned int)this >> 6) | 0xC0;
a2[1] = (unsigned __int8)this & 0x3F | 0x80;
return 2LL;
}
if ( (unsigned int)this <= 0xD7FF )
{
LABEL_6:
*a2 = ((unsigned int)this >> 12) | 0xE0;
a2[1] = ((unsigned int)this >> 6) & 0x3F | 0x80;
a2[2] = (unsigned __int8)this & 0x3F | 0x80;
return 3LL;
}
if ( (unsigned int)this >= 0xE000 )
{
if ( (unsigned int)this <= 0xFFFF )
goto LABEL_6;
if ( (unsigned int)this <= 0x10FFFF )
{
*a2 = ((unsigned int)this >> 18) | 0xF0;
a2[1] = ((unsigned int)this >> 12) & 0x3F | 0x80;
a2[2] = ((unsigned int)this >> 6) & 0x3F | 0x80;
a2[3] = (unsigned __int8)this & 0x3F | 0x80;
return 4LL;
}
}
return 0LL;
}
|
to_utf8:
CMP EDI,0x7f
JG 0x00127df7
AND DIL,0x7f
MOV byte ptr [RSI],DIL
PUSH 0x1
JMP 0x00127e43
LAB_00127df7:
CMP EDI,0x7ff
JA 0x00127e18
MOV EAX,EDI
SHR EAX,0x6
OR AL,0xc0
MOV byte ptr [RSI],AL
AND DIL,0x3f
OR DIL,0x80
MOV byte ptr [RSI + 0x1],DIL
PUSH 0x2
JMP 0x00127e43
LAB_00127e18:
CMP EDI,0xd7ff
JA 0x00127e45
LAB_00127e20:
MOV EAX,EDI
SHR EAX,0xc
OR AL,0xe0
MOV byte ptr [RSI],AL
MOV EAX,EDI
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
MOV byte ptr [RSI + 0x1],AL
AND DIL,0x3f
OR DIL,0x80
MOV byte ptr [RSI + 0x2],DIL
PUSH 0x3
LAB_00127e43:
POP RAX
RET
LAB_00127e45:
CMP EDI,0xe000
JNC 0x00127e50
LAB_00127e4d:
XOR EAX,EAX
RET
LAB_00127e50:
CMP EDI,0xffff
JBE 0x00127e20
CMP EDI,0x10ffff
JA 0x00127e4d
MOV EAX,EDI
SHR EAX,0x12
OR AL,0xf0
MOV byte ptr [RSI],AL
MOV EAX,EDI
SHR EAX,0xc
AND AL,0x3f
OR AL,0x80
MOV byte ptr [RSI + 0x1],AL
MOV EAX,EDI
SHR EAX,0x6
AND AL,0x3f
OR AL,0x80
MOV byte ptr [RSI + 0x2],AL
AND DIL,0x3f
OR DIL,0x80
MOV byte ptr [RSI + 0x3],DIL
PUSH 0x4
JMP 0x00127e43
|
/* httplib::detail::to_utf8(int, char*) */
int8 httplib::detail::to_utf8(int param_1,char *param_2)
{
byte bVar1;
int8 uStack_8;
bVar1 = (byte)param_1;
if (param_1 < 0x80) {
*param_2 = bVar1 & 0x7f;
uStack_8 = 1;
}
else if ((uint)param_1 < 0x800) {
*param_2 = (byte)((uint)param_1 >> 6) | 0xc0;
param_2[1] = bVar1 & 0x3f | 0x80;
uStack_8 = 2;
}
else {
if (0xd7ff < (uint)param_1) {
if ((uint)param_1 < 0xe000) {
return 0;
}
if (0xffff < (uint)param_1) {
if (0x10ffff < (uint)param_1) {
return 0;
}
*param_2 = (byte)((uint)param_1 >> 0x12) | 0xf0;
param_2[1] = (byte)((uint)param_1 >> 0xc) & 0x3f | 0x80;
param_2[2] = (byte)((uint)param_1 >> 6) & 0x3f | 0x80;
param_2[3] = bVar1 & 0x3f | 0x80;
return 4;
}
}
*param_2 = (byte)((uint)param_1 >> 0xc) | 0xe0;
param_2[1] = (byte)((uint)param_1 >> 6) & 0x3f | 0x80;
param_2[2] = bVar1 & 0x3f | 0x80;
uStack_8 = 3;
}
return uStack_8;
}
|
|
57,655
|
el::LogMessage::LogMessage(el::Level, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, el::Logger*)
|
opengl-water/include/easylogging++.h
|
LogMessage(Level level, const std::string& file, base::type::LineNumber line, const std::string& func,
base::type::VerboseLevel verboseLevel, Logger* logger) :
m_level(level), m_file(file), m_line(line), m_func(func),
m_verboseLevel(verboseLevel), m_logger(logger), m_message(logger->stream().str()) {
}
|
O3
|
c
|
el::LogMessage::LogMessage(el::Level, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, el::Logger*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movq %r8, %r13
movq %rcx, %r12
movq %rdi, %r14
movl %esi, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x8(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rdi, -0x38(%rbp)
callq 0x270d2
movq %r12, 0x28(%r14)
leaq 0x30(%r14), %r12
leaq 0x40(%r14), %rbx
movq %rbx, 0x30(%r14)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x270d2
movq 0x10(%rbp), %rsi
movw %r15w, 0x50(%r14)
movq %rsi, 0x58(%r14)
addq $0x60, %r14
addq $0x58, %rsi
movq %r14, %rdi
callq 0x237a0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x346b7
movq (%rbx), %rsi
incq %rsi
callq 0x23140
jmp 0x346b7
movq %rax, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x346d3
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x23140
movq %r14, %rdi
callq 0x234d0
nop
|
_ZN2el10LogMessageC2ENS_5LevelERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmS9_tPNS_6LoggerE:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, r9d
mov r13, r8
mov r12, rcx
mov r14, rdi
mov [rdi], esi
add rdi, 8
lea rax, [r14+18h]
mov [rbp+var_30], rax
mov [r14+8], rax
mov rsi, [rdx]
mov rdx, [rdx+8]
add rdx, rsi
mov [rbp+var_38], rdi
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov [r14+28h], r12
lea r12, [r14+30h]
lea rbx, [r14+40h]
mov [r14+30h], rbx
mov rsi, [r13+0]
mov rdx, [r13+8]
add rdx, rsi
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rsi, [rbp+arg_0]
mov [r14+50h], r15w
mov [r14+58h], rsi
add r14, 60h ; '`'
add rsi, 58h ; 'X'
mov rdi, r14
call __ZNKRSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
mov rdi, [r12]; void *
cmp rdi, rbx
jz short loc_346B7
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_346B7
mov r14, rax
loc_346B7:
mov rax, [rbp+var_38]
mov rdi, [rax]; void *
cmp rdi, [rbp+var_30]
jz short loc_346D3
mov rax, [rbp+var_30]
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_346D3:
mov rdi, r14
call __Unwind_Resume
|
long long el::LogMessage::LogMessage(
long long a1,
int a2,
long long a3,
long long a4,
long long a5,
__int16 a6,
long long a7)
{
*(_DWORD *)a1 = a2;
*(_QWORD *)(a1 + 8) = a1 + 24;
std::string::_M_construct<char *>((_QWORD *)(a1 + 8), *(_BYTE **)a3, *(_QWORD *)a3 + *(_QWORD *)(a3 + 8));
*(_QWORD *)(a1 + 40) = a4;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char *>((_QWORD *)(a1 + 48), *(_BYTE **)a5, *(_QWORD *)a5 + *(_QWORD *)(a5 + 8));
*(_WORD *)(a1 + 80) = a6;
*(_QWORD *)(a1 + 88) = a7;
return std::stringbuf::str(a1 + 96, a7 + 88);
}
|
LogMessage:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,R9D
MOV R13,R8
MOV R12,RCX
MOV R14,RDI
MOV dword ptr [RDI],ESI
ADD RDI,0x8
LEA RAX,[R14 + 0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [R14 + 0x8],RAX
MOV RSI,qword ptr [RDX]
MOV RDX,qword ptr [RDX + 0x8]
ADD RDX,RSI
MOV qword ptr [RBP + -0x38],RDI
CALL 0x001270d2
MOV qword ptr [R14 + 0x28],R12
LEA R12,[R14 + 0x30]
LEA RBX,[R14 + 0x40]
MOV qword ptr [R14 + 0x30],RBX
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
ADD RDX,RSI
LAB_00134667:
MOV RDI,R12
CALL 0x001270d2
MOV RSI,qword ptr [RBP + 0x10]
MOV word ptr [R14 + 0x50],R15W
MOV qword ptr [R14 + 0x58],RSI
ADD R14,0x60
ADD RSI,0x58
LAB_00134684:
MOV RDI,R14
CALL 0x001237a0
LAB_0013468c:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* el::LogMessage::LogMessage(el::Level, std::__cxx11::string const&, unsigned long,
std::__cxx11::string const&, unsigned short, el::Logger*) */
void __thiscall
el::LogMessage::LogMessage
(LogMessage *this,int4 param_2,long *param_3,int8 param_4,long *param_5,
int2 param_6,int8 param_7)
{
*(int4 *)this = param_2;
*(LogMessage **)(this + 8) = this + 0x18;
std::__cxx11::string::_M_construct<char*>(this + 8,*param_3,param_3[1] + *param_3);
*(int8 *)(this + 0x28) = param_4;
*(LogMessage **)(this + 0x30) = this + 0x40;
/* try { // try from 00134667 to 0013466e has its CatchHandler @ 001346b4 */
std::__cxx11::string::_M_construct<char*>(this + 0x30,*param_5,param_5[1] + *param_5);
*(int2 *)(this + 0x50) = param_6;
*(int8 *)(this + 0x58) = param_7;
/* try { // try from 00134684 to 0013468b has its CatchHandler @ 0013469b */
std::__cxx11::stringbuf::str();
return;
}
|
|
57,656
|
mi_kpos
|
eloqsql/storage/myisam/mi_search.c
|
my_off_t _mi_kpos(uint nod_flag, uchar *after_key)
{
after_key-=nod_flag;
switch (nod_flag) {
#if SIZEOF_OFF_T > 4
case 7:
return mi_uint7korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 6:
return mi_uint6korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 5:
return mi_uint5korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH;
#else
case 7:
after_key++;
case 6:
after_key++;
case 5:
after_key++;
#endif
case 4:
return ((my_off_t) mi_uint4korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
case 3:
return ((my_off_t) mi_uint3korr(after_key))*MI_MIN_KEY_BLOCK_LENGTH;
case 2:
return (my_off_t) (mi_uint2korr(after_key)*MI_MIN_KEY_BLOCK_LENGTH);
case 1:
return (uint) (*after_key)*MI_MIN_KEY_BLOCK_LENGTH;
case 0: /* At leaf page */
default: /* Impossible */
return(HA_OFFSET_ERROR);
}
}
|
O0
|
c
|
mi_kpos:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0xbf0e9
movq -0x20(%rbp), %rax
leaq 0x9a501(%rip), %rcx # 0x1594fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0xc0530
shlq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rdi
callq 0xc0590
shlq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rdi
callq 0xc05e0
shlq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0xa, %rax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
shll $0xa, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
shll $0xa, %eax
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xbf0f1
jmp 0xbf0e9
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_mi_kpos:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_C], edi
mov [rbp+var_18], rsi
mov eax, [rbp+var_C]
mov ecx, eax
mov rax, [rbp+var_18]
sub rax, rcx
mov [rbp+var_18], rax
mov eax, [rbp+var_C]
mov [rbp+var_20], rax
sub rax, 7; switch 8 cases
ja def_BF002; jumptable 00000000000BF002 default case
mov rax, [rbp+var_20]
lea rcx, jpt_BF002
movsxd rax, ds:(jpt_BF002 - 1594FCh)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_BF004:
mov rdi, [rbp+var_18]; jumptable 00000000000BF002 case 7
call mi_uint7korr_0
shl rax, 0Ah
mov [rbp+var_8], rax
jmp loc_BF0F1
loc_BF01A:
mov rdi, [rbp+var_18]; jumptable 00000000000BF002 case 6
call mi_uint6korr_0
shl rax, 0Ah
mov [rbp+var_8], rax
jmp loc_BF0F1
loc_BF030:
mov rdi, [rbp+var_18]; jumptable 00000000000BF002 case 5
call mi_uint5korr_0
shl rax, 0Ah
mov [rbp+var_8], rax
jmp loc_BF0F1
loc_BF046:
mov rax, [rbp+var_18]; jumptable 00000000000BF002 case 4
movzx eax, byte ptr [rax+3]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 10h
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
shl ecx, 18h
or eax, ecx
mov eax, eax
shl rax, 0Ah
mov [rbp+var_8], rax
jmp short loc_BF0F1
loc_BF080:
mov rax, [rbp+var_18]; jumptable 00000000000BF002 case 3
movzx eax, byte ptr [rax+2]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 0Ah
mov [rbp+var_8], rax
jmp short loc_BF0F1
loc_BF0AD:
mov rax, [rbp+var_18]; jumptable 00000000000BF002 case 2
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
shl eax, 0Ah
cdqe
mov [rbp+var_8], rax
jmp short loc_BF0F1
loc_BF0D5:
mov rax, [rbp+var_18]; jumptable 00000000000BF002 case 1
movzx eax, byte ptr [rax]
shl eax, 0Ah
mov eax, eax
mov [rbp+var_8], rax
jmp short loc_BF0F1
loc_BF0E7:
jmp short $+2; jumptable 00000000000BF002 case 0
def_BF002:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh; jumptable 00000000000BF002 default case
loc_BF0F1:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
|
long long mi_kpos(unsigned int a1, long long a2)
{
unsigned __int8 *v3; // [rsp+8h] [rbp-18h]
long long v4; // [rsp+18h] [rbp-8h]
v3 = (unsigned __int8 *)(a2 - a1);
switch ( a1 )
{
case 1u:
v4 = *v3 << 10;
break;
case 2u:
v4 = _byteswap_ushort(*(_WORD *)v3) << 10;
break;
case 3u:
v4 = (unsigned long long)((*v3 << 16) | (v3[1] << 8) | (unsigned int)v3[2]) << 10;
break;
case 4u:
v4 = (unsigned long long)_byteswap_ulong(*(_DWORD *)v3) << 10;
break;
case 5u:
v4 = mi_uint5korr_0(v3) << 10;
break;
case 6u:
v4 = mi_uint6korr_0(v3) << 10;
break;
case 7u:
v4 = mi_uint7korr_0(v3) << 10;
break;
default:
v4 = -1LL;
break;
}
return v4;
}
|
_mi_kpos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0xc],EDI
MOV qword ptr [RBP + -0x18],RSI
MOV EAX,dword ptr [RBP + -0xc]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x20],RAX
SUB RAX,0x7
JA 0x001bf0e9
MOV RAX,qword ptr [RBP + -0x20]
LEA RCX,[0x2594fc]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_7:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001c0530
SHL RAX,0xa
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_6:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001c0590
SHL RAX,0xa
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_5:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x001c05e0
SHL RAX,0xa
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_4:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x3]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x10
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
SHL ECX,0x18
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0xa
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_3:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0xa
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_2:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
SHL EAX,0xa
CDQE
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_1:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
SHL EAX,0xa
MOV EAX,EAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001bf0f1
caseD_0:
JMP 0x001bf0e9
default:
MOV qword ptr [RBP + -0x8],-0x1
LAB_001bf0f1:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long _mi_kpos(uint param_1,long param_2)
{
byte *pbVar1;
long local_10;
pbVar1 = (byte *)(param_2 - (ulong)param_1);
switch(param_1) {
case 0:
default:
local_10 = -1;
break;
case 1:
local_10 = (ulong)*pbVar1 << 10;
break;
case 2:
local_10 = (long)(int)((uint)CONCAT11(*pbVar1,pbVar1[1]) << 10);
break;
case 3:
local_10 = (ulong)CONCAT12(*pbVar1,CONCAT11(pbVar1[1],pbVar1[2])) << 10;
break;
case 4:
local_10 = (ulong)CONCAT13(*pbVar1,CONCAT12(pbVar1[1],CONCAT11(pbVar1[2],pbVar1[3]))) << 10;
break;
case 5:
local_10 = mi_uint5korr(pbVar1);
local_10 = local_10 << 10;
break;
case 6:
local_10 = mi_uint6korr(pbVar1);
local_10 = local_10 << 10;
break;
case 7:
local_10 = mi_uint7korr(pbVar1);
local_10 = local_10 << 10;
}
return local_10;
}
|
|
57,657
|
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 0x47dfc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x47dfc
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x47dfa
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 0x47e31
jmp 0x47dfc
cmpq $0x0, -0x10(%rbp)
je 0x47e2d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x47e2d
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 0x47e31
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_47DFC
mov rax, [rbp+var_10]
cmp qword ptr [rax+8], 0
jz short loc_47DFC
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+8]
jbe short loc_47DFA
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_47E31
loc_47DFA:
jmp short $+2
loc_47DFC:
cmp [rbp+var_10], 0
jz short loc_47E2D
mov rax, [rbp+var_10]
mov rax, [rax+48h]
cmp qword ptr [rax+78h], 0
jz short loc_47E2D
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_47E31
loc_47E2D:
mov [rbp+var_1], 1
loc_47E31:
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 0x00147dfc
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00147dfc
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 0x00147dfa
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 0x00147e31
LAB_00147dfa:
JMP 0x00147dfc
LAB_00147dfc:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00147e2d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX + 0x78],0x0
JZ 0x00147e2d
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 0x00147e31
LAB_00147e2d:
MOV byte ptr [RBP + -0x1],0x1
LAB_00147e31:
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;
}
|
|
57,658
|
httplib::Response::set_content(char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
nickolajgrishuk[P]metricz-cpp/build_O3/_deps/httplib-src/httplib.h
|
inline void Response::set_content(const char *s, size_t n,
const std::string &content_type) {
body.assign(s, n);
auto rng = headers.equal_range("Content-Type");
headers.erase(rng.first, rng.second);
set_header("Content-Type", content_type);
}
|
O3
|
c
|
httplib::Response::set_content(char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %r14
addq $0x78, %rdi
movq 0x80(%r14), %rdx
xorl %esi, %esi
callq 0x8860
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x17231(%rip), %rsi # 0x2de50
leaq 0x17236(%rip), %rdx # 0x2de5c
movq %rsp, %rdi
callq 0x10898
addq $0x48, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x16d58
movq %rax, %r15
movq %rdx, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x16c51
callq 0x8520
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x16f34
movq %rsp, %rdi
movq %r13, (%rdi)
leaq 0x171e4(%rip), %rsi # 0x2de50
leaq 0x171e9(%rip), %rdx # 0x2de5c
callq 0x10898
movq (%rsp), %rdi
movb (%rdi), %cl
testb %cl, %cl
je 0x16c9c
leaq 0x1(%rdi), %rax
cmpb $0xa, %cl
je 0x16cd0
movzbl %cl, %ecx
cmpl $0xd, %ecx
je 0x16cd0
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x16c86
movq (%rbx), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x16cbe
incq %rax
cmpb $0xa, %cl
je 0x16cd0
movzbl %cl, %ecx
cmpl $0xd, %ecx
je 0x16cd0
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x16ca8
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x17002
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x16cda
callq 0x8520
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x16cec
jmp 0x16cff
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x16d02
callq 0x8520
jmp 0x16d02
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8980
|
_ZN7httplib8Response11set_contentEPKcmRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 20h
mov rbx, rcx
mov r8, rdx
mov rcx, rsi
mov r14, rdi
add rdi, 78h ; 'x'
mov rdx, [r14+80h]
xor esi, esi
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
lea r13, [rsp+48h+var_38]
mov [r13-10h], r13
lea rsi, aContentType; "Content-Type"
lea rdx, aContentType+0Ch; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
add r14, 48h ; 'H'
mov rsi, rsp
mov rdi, r14
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_EN7httplib6detail2ciESaIS8_EE11equal_rangeERS7_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::equal_range(std::string const&)
mov r15, rax
mov r12, rdx
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_16C51
call __ZdlPv; operator delete(void *)
loc_16C51:
mov rdi, r14
mov rsi, r15
mov rdx, r12
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_EN7httplib6detail2ciESaIS8_EE12_M_erase_auxESt23_Rb_tree_const_iteratorIS8_ESH_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::_M_erase_aux(std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>,std::_Rb_tree_const_iterator<std::pair<std::string const,std::string>>)
mov rdi, rsp
mov [rdi], r13
lea rsi, aContentType; "Content-Type"
lea rdx, aContentType+0Ch; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, [rsp+48h+var_48]
mov cl, [rdi]
test cl, cl
jz short loc_16C9C
lea rax, [rdi+1]
loc_16C86:
cmp cl, 0Ah
jz short loc_16CD0
movzx ecx, cl
cmp ecx, 0Dh
jz short loc_16CD0
mov cl, [rax]
inc rax
test cl, cl
jnz short loc_16C86
loc_16C9C:
mov rax, [rbx]
mov cl, [rax]
test cl, cl
jz short loc_16CBE
inc rax
loc_16CA8:
cmp cl, 0Ah
jz short loc_16CD0
movzx ecx, cl
cmp ecx, 0Dh
jz short loc_16CD0
mov cl, [rax]
inc rax
test cl, cl
jnz short loc_16CA8
loc_16CBE:
mov rsi, rsp
mov rdi, r14
mov rdx, rbx
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_S5_ESt10_Select1stIS8_EN7httplib6detail2ciESaIS8_EE16_M_emplace_equalIJRS7_SH_EEESt17_Rb_tree_iteratorIS8_EDpOT_; std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::_M_emplace_equal<std::string const&,std::string const&>(std::string const&,std::string const&)
mov rdi, [rsp+48h+var_48]; void *
loc_16CD0:
cmp rdi, r13
jz short loc_16CDA
call __ZdlPv; operator delete(void *)
loc_16CDA:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short loc_16CEC
jmp short loc_16CFF
loc_16CEC:
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_16D02
call __ZdlPv; operator delete(void *)
jmp short loc_16D02
loc_16CFF:
mov rbx, rax
loc_16D02:
mov rdi, rbx
call __Unwind_Resume
|
void httplib::Response::set_content(long long a1, long long a2, long long a3, char **a4)
{
long long v5; // r14
long long v6; // r15
long long v7; // rdx
long long v8; // r12
_BYTE *v9; // rdi
char v10; // cl
char *v11; // rax
char v12; // cl
char *v13; // rax
void *v14[2]; // [rsp+0h] [rbp-48h] BYREF
_BYTE v15[56]; // [rsp+10h] [rbp-38h] BYREF
std::string::_M_replace(a1 + 120, 0LL, *(_QWORD *)(a1 + 128), a2, a3);
v14[0] = v15;
std::string::_M_construct<char const*>((long long)v14, "Content-Type", (long long)"");
v5 = a1 + 72;
v6 = std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::equal_range(
a1 + 72,
v14);
v8 = v7;
if ( v14[0] != v15 )
operator delete(v14[0]);
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::_M_erase_aux(
v5,
v6,
v8);
v14[0] = v15;
std::string::_M_construct<char const*>((long long)v14, "Content-Type", (long long)"");
v9 = v14[0];
v10 = *(_BYTE *)v14[0];
if ( *(_BYTE *)v14[0] )
{
v11 = (char *)v14[0] + 1;
while ( v10 != 10 && v10 != 13 )
{
v10 = *v11++;
if ( !v10 )
goto LABEL_8;
}
}
else
{
LABEL_8:
v12 = **a4;
if ( v12 )
{
v13 = *a4 + 1;
while ( v12 != 10 && v12 != 13 )
{
v12 = *v13++;
if ( !v12 )
goto LABEL_13;
}
}
else
{
LABEL_13:
std::_Rb_tree<std::string,std::pair<std::string const,std::string>,std::_Select1st<std::pair<std::string const,std::string>>,httplib::detail::ci,std::allocator<std::pair<std::string const,std::string>>>::_M_emplace_equal<std::string const&,std::string const&>(
v5,
v14,
a4);
v9 = v14[0];
}
}
if ( v9 != v15 )
operator delete(v9);
}
|
set_content:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RCX
MOV R8,RDX
MOV RCX,RSI
MOV R14,RDI
ADD RDI,0x78
MOV RDX,qword ptr [R14 + 0x80]
XOR ESI,ESI
CALL 0x00108860
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
LAB_00116c18:
LEA RSI,[0x12de50]
LEA RDX,[0x12de5c]
MOV RDI,RSP
CALL 0x00110898
ADD R14,0x48
LAB_00116c32:
MOV RSI,RSP
MOV RDI,R14
CALL 0x00116d58
LAB_00116c3d:
MOV R15,RAX
MOV R12,RDX
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00116c51
CALL 0x00108520
LAB_00116c51:
MOV RDI,R14
MOV RSI,R15
MOV RDX,R12
CALL 0x00116f34
MOV RDI,RSP
MOV qword ptr [RDI],R13
LAB_00116c65:
LEA RSI,[0x12de50]
LEA RDX,[0x12de5c]
CALL 0x00110898
MOV RDI,qword ptr [RSP]
MOV CL,byte ptr [RDI]
TEST CL,CL
JZ 0x00116c9c
LEA RAX,[RDI + 0x1]
LAB_00116c86:
CMP CL,0xa
JZ 0x00116cd0
MOVZX ECX,CL
CMP ECX,0xd
JZ 0x00116cd0
MOV CL,byte ptr [RAX]
INC RAX
TEST CL,CL
JNZ 0x00116c86
LAB_00116c9c:
MOV RAX,qword ptr [RBX]
MOV CL,byte ptr [RAX]
TEST CL,CL
JZ 0x00116cbe
INC RAX
LAB_00116ca8:
CMP CL,0xa
JZ 0x00116cd0
MOVZX ECX,CL
CMP ECX,0xd
JZ 0x00116cd0
MOV CL,byte ptr [RAX]
INC RAX
TEST CL,CL
JNZ 0x00116ca8
LAB_00116cbe:
MOV RSI,RSP
MOV RDI,R14
MOV RDX,RBX
CALL 0x00117002
LAB_00116ccc:
MOV RDI,qword ptr [RSP]
LAB_00116cd0:
CMP RDI,R13
JZ 0x00116cda
CALL 0x00108520
LAB_00116cda:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* httplib::Response::set_content(char const*, unsigned long, std::__cxx11::string const&) */
void __thiscall
httplib::Response::set_content(Response *this,char *param_1,ulong param_2,string *param_3)
{
char cVar1;
char *pcVar2;
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,httplib::detail::ci,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*this_00;
int1 auVar3 [16];
char *local_48 [2];
char local_38 [16];
std::__cxx11::string::_M_replace((ulong)(this + 0x78),0,*(char **)(this + 0x80),(ulong)param_1);
local_48[0] = local_38;
/* try { // try from 00116c18 to 00116c2d has its CatchHandler @ 00116cff */
std::__cxx11::string::_M_construct<char_const*>(local_48,"Content-Type","");
this_00 = (_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,httplib::detail::ci,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
*)(this + 0x48);
/* try { // try from 00116c32 to 00116c3c has its CatchHandler @ 00116cec */
auVar3 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,httplib::detail::ci,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::equal_range(this_00,(string *)local_48);
if (local_48[0] != local_38) {
operator_delete(local_48[0]);
}
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,httplib::detail::ci,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::_M_erase_aux(this_00,auVar3._0_8_,auVar3._8_8_);
local_48[0] = local_38;
/* try { // try from 00116c65 to 00116c77 has its CatchHandler @ 00116cea */
std::__cxx11::string::_M_construct<char_const*>(local_48,"Content-Type","");
cVar1 = *local_48[0];
pcVar2 = local_48[0];
while (cVar1 != '\0') {
pcVar2 = pcVar2 + 1;
if ((cVar1 == '\n') || (cVar1 == '\r')) goto LAB_00116cd0;
cVar1 = *pcVar2;
}
pcVar2 = *(char **)param_3;
cVar1 = *pcVar2;
while (cVar1 != '\0') {
pcVar2 = pcVar2 + 1;
if ((cVar1 == '\n') || (cVar1 == '\r')) goto LAB_00116cd0;
cVar1 = *pcVar2;
}
/* try { // try from 00116cbe to 00116ccb has its CatchHandler @ 00116ce8 */
std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,std::__cxx11::string>,std::_Select1st<std::pair<std::__cxx11::string_const,std::__cxx11::string>>,httplib::detail::ci,std::allocator<std::pair<std::__cxx11::string_const,std::__cxx11::string>>>
::_M_emplace_equal<std::__cxx11::string_const&,std::__cxx11::string_const&>
(this_00,(string *)local_48,param_3);
LAB_00116cd0:
if (local_48[0] != local_38) {
operator_delete(local_48[0]);
}
return;
}
|
|
57,659
|
my_string_repertoire_8bit
|
eloqsql/strings/ctype.c
|
uint
my_string_repertoire_8bit(CHARSET_INFO *cs, const char *str, size_t length)
{
const char *strend;
if ((cs->state & MY_CS_NONASCII) && length > 0)
return MY_REPERTOIRE_UNICODE30;
for (strend= str + length; str < strend; str++)
{
if (((uchar) *str) > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
return MY_REPERTOIRE_ASCII;
}
|
O3
|
c
|
my_string_repertoire_8bit:
movl $0x3, %eax
testq %rdx, %rdx
je 0xd2027
movl $0x2000, %ecx # imm = 0x2000
andl 0xc(%rdi), %ecx
je 0xd2027
retq
testq %rdx, %rdx
jle 0xd2047
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
cmpb $0x0, (%rsi)
js 0xd2045
incq %rsi
cmpq %rdx, %rsi
jb 0xd2033
movl $0x1, %eax
popq %rbp
retq
movl $0x1, %eax
retq
|
my_string_repertoire_8bit:
mov eax, 3
test rdx, rdx
jz short loc_D2027
mov ecx, 2000h
and ecx, [rdi+0Ch]
jz short loc_D2027
retn
loc_D2027:
test rdx, rdx
jle short loc_D2047
push rbp
mov rbp, rsp
add rdx, rsi
loc_D2033:
cmp byte ptr [rsi], 0
js short loc_D2045
inc rsi
cmp rsi, rdx
jb short loc_D2033
mov eax, 1
loc_D2045:
pop rbp
retn
loc_D2047:
mov eax, 1
retn
|
long long my_string_repertoire_8bit(long long a1, char *a2, long long a3)
{
long long result; // rax
char *v4; // rdx
result = 3LL;
if ( !a3 || (*(_DWORD *)(a1 + 12) & 0x2000) == 0 )
{
if ( a3 <= 0 )
{
return 1LL;
}
else
{
v4 = &a2[a3];
while ( *a2 >= 0 )
{
if ( ++a2 >= v4 )
return 1LL;
}
}
}
return result;
}
|
my_string_repertoire_8bit:
MOV EAX,0x3
TEST RDX,RDX
JZ 0x001d2027
MOV ECX,0x2000
AND ECX,dword ptr [RDI + 0xc]
JZ 0x001d2027
RET
LAB_001d2027:
TEST RDX,RDX
JLE 0x001d2047
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_001d2033:
CMP byte ptr [RSI],0x0
JS 0x001d2045
INC RSI
CMP RSI,RDX
JC 0x001d2033
MOV EAX,0x1
LAB_001d2045:
POP RBP
RET
LAB_001d2047:
MOV EAX,0x1
RET
|
int8 my_string_repertoire_8bit(long param_1,char *param_2,long param_3)
{
char *pcVar1;
if ((param_3 != 0) && ((*(uint *)(param_1 + 0xc) & 0x2000) != 0)) {
return 3;
}
if (param_3 < 1) {
return 1;
}
pcVar1 = param_2 + param_3;
do {
if (*param_2 < '\0') {
return 3;
}
param_2 = param_2 + 1;
} while (param_2 < pcVar1);
return 1;
}
|
|
57,660
|
my_wc_mb_eucjpms
|
eloqsql/strings/ctype-eucjpms.c
|
static int
my_wc_mb_eucjpms(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int jp;
if ((int) wc < 0x80) /* ASCII [00-7F] */
{
if (s >= e)
return MY_CS_TOOSMALL;
*s= (uchar) wc;
return 1;
}
if (wc > 0xFFFF)
return MY_CS_ILUNI;
if ((jp= unicode_to_jisx0208_eucjpms[wc])) /* JIS-X-0208 MS */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, jp);
return 2;
}
if ((jp= unicode_to_jisx0212_eucjpms[wc])) /* JIS-X-0212 MS */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
s[0]= 0x8F;
MY_PUT_MB2(s + 1, jp);
return 3;
}
if (wc >= 0xFF61 && wc <= 0xFF9F) /* Half width Katakana */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
s[0]= 0x8E;
s[1]= (uchar) (wc - 0xFEC0);
return 2;
}
return MY_CS_ILUNI;
}
|
O0
|
c
|
my_wc_mb_eucjpms:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jge 0x3a89d
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3a885
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3a9c5
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3a9c5
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jbe 0x3a8b3
movl $0x0, -0x4(%rbp)
jmp 0x3a9c5
movq -0x18(%rbp), %rcx
leaq 0x1eb7c2(%rip), %rax # 0x226080
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x3a90f
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3a8e4
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3a9c5
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)
jmp 0x3a9c5
movq -0x18(%rbp), %rcx
leaq 0x20b766(%rip), %rax # 0x246080
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x3a970
movq -0x20(%rbp), %rax
addq $0x3, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3a940
movl $0xffffff99, -0x4(%rbp) # imm = 0xFFFFFF99
jmp 0x3a9c5
movq -0x20(%rbp), %rax
movb $-0x71, (%rax)
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x3a9c5
cmpq $0xff61, -0x18(%rbp) # imm = 0xFF61
jb 0x3a9be
cmpq $0xff9f, -0x18(%rbp) # imm = 0xFF9F
ja 0x3a9be
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3a99b
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3a9c5
movq -0x20(%rbp), %rax
movb $-0x72, (%rax)
movq -0x18(%rbp), %rax
subq $0xfec0, %rax # imm = 0xFEC0
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
jmp 0x3a9c5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
my_wc_mb_eucjpms:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_18]
cmp eax, 80h
jge short loc_3A89D
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3A885
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_3A9C5
loc_3A885:
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp loc_3A9C5
loc_3A89D:
cmp [rbp+var_18], 0FFFFh
jbe short loc_3A8B3
mov [rbp+var_4], 0
jmp loc_3A9C5
loc_3A8B3:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0208_eucjpms
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_3A90F
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3A8E4
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_3A9C5
loc_3A8E4:
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
jmp loc_3A9C5
loc_3A90F:
mov rcx, [rbp+var_18]
lea rax, unicode_to_jisx0212_eucjpms
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_2C], eax
cmp eax, 0
jz short loc_3A970
mov rax, [rbp+var_20]
add rax, 3
cmp rax, [rbp+var_28]
jbe short loc_3A940
mov [rbp+var_4], 0FFFFFF99h
jmp loc_3A9C5
loc_3A940:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Fh
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+2], cl
mov [rbp+var_4], 3
jmp short loc_3A9C5
loc_3A970:
cmp [rbp+var_18], 0FF61h
jb short loc_3A9BE
cmp [rbp+var_18], 0FF9Fh
ja short loc_3A9BE
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3A99B
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_3A9C5
loc_3A99B:
mov rax, [rbp+var_20]
mov byte ptr [rax], 8Eh
mov rax, [rbp+var_18]
sub rax, 0FEC0h
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
jmp short loc_3A9C5
loc_3A9BE:
mov [rbp+var_4], 0
loc_3A9C5:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_wc_mb_eucjpms(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
__int16 v5; // [rsp+0h] [rbp-2Ch]
__int16 v6; // [rsp+0h] [rbp-2Ch]
if ( (int)a2 >= 128 )
{
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_jisx0208_eucjpms[a2];
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = HIBYTE(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
v6 = unicode_to_jisx0212_eucjpms[a2];
if ( v6 )
{
if ( (unsigned long long)(a3 + 3) <= a4 )
{
*a3 = -113;
a3[1] = HIBYTE(v6);
a3[2] = v6;
return 3;
}
else
{
return (unsigned int)-103;
}
}
else if ( a2 < 0xFF61 || a2 > 0xFF9F )
{
return 0;
}
else if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = -114;
a3[1] = a2 + 64;
return 2;
}
else
{
return (unsigned int)-102;
}
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 < a4 )
{
*a3 = a2;
return 1;
}
else
{
return (unsigned int)-101;
}
}
|
my_wc_mb_eucjpms:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JGE 0x0013a89d
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013a885
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013a9c5
LAB_0013a885:
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 0x0013a9c5
LAB_0013a89d:
CMP qword ptr [RBP + -0x18],0xffff
JBE 0x0013a8b3
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013a9c5
LAB_0013a8b3:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x326080]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x0013a90f
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013a8e4
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013a9c5
LAB_0013a8e4:
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
JMP 0x0013a9c5
LAB_0013a90f:
MOV RCX,qword ptr [RBP + -0x18]
LEA RAX,[0x346080]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JZ 0x0013a970
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013a940
MOV dword ptr [RBP + -0x4],0xffffff99
JMP 0x0013a9c5
LAB_0013a940:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8f
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x2],CL
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0013a9c5
LAB_0013a970:
CMP qword ptr [RBP + -0x18],0xff61
JC 0x0013a9be
CMP qword ptr [RBP + -0x18],0xff9f
JA 0x0013a9be
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013a99b
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013a9c5
LAB_0013a99b:
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],0x8e
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0xfec0
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0013a9c5
LAB_0013a9be:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013a9c5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_eucjpms(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
short sVar1;
int4 local_c;
if ((int)param_2 < 0x80) {
if (param_3 < param_4) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
}
else if (param_2 < 0x10000) {
sVar1 = *(short *)(unicode_to_jisx0208_eucjpms + param_2 * 2);
if (sVar1 == 0) {
sVar1 = *(short *)(unicode_to_jisx0212_eucjpms + param_2 * 2);
if (sVar1 == 0) {
if ((param_2 < 0xff61) || (0xff9f < param_2)) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = -0x72;
param_3[1] = (char)param_2 + '@';
local_c = 2;
}
}
else if (param_4 < param_3 + 3) {
local_c = 0xffffff99;
}
else {
*param_3 = -0x71;
param_3[1] = (char)((ushort)sVar1 >> 8);
param_3[2] = (char)sVar1;
local_c = 3;
}
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((ushort)sVar1 >> 8);
param_3[1] = (char)sVar1;
local_c = 2;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
57,661
|
my_casedn_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_casedn_utf16(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
my_charset_conv_wc_mb wc_mb= cs->cset->wc_mb;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= mb_wc(cs, &wc, (uchar *) src, (uchar *) srcend)) > 0)
{
my_tolower_utf16(uni_plane, &wc);
if (res != wc_mb(cs, wc, (uchar *) dst, (uchar *) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
}
|
O0
|
c
|
my_casedn_utf16:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x59188
jmp 0x5918a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x50(%rbp), %rcx
movb %al, -0x61(%rbp)
jae 0x591bb
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x50(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x591c4
jmp 0x5921f
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5c670
movl -0x44(%rbp), %eax
movl %eax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x58(%rbp), %rcx
callq *%rax
movl %eax, %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
je 0x591f8
jmp 0x5921f
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x44(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x5918a
movq -0x18(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
my_casedn_utf16:
push rbp
mov rbp, rsp
sub rsp, 70h
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_8]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov [rbp+var_38], rax
mov rax, [rbp+var_8]
mov rax, [rax+0B8h]
mov rax, [rax+30h]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_58], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_60], rax
jmp short $+2
loc_59188:
jmp short $+2
loc_5918A:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_50]
mov [rbp+var_61], al
jnb short loc_591BB
mov rax, [rbp+var_38]
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_50]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_44], eax
cmp eax, 0
setnle al
mov [rbp+var_61], al
loc_591BB:
mov al, [rbp+var_61]
test al, 1
jnz short loc_591C4
jmp short loc_5921F
loc_591C4:
mov rdi, [rbp+var_60]
lea rsi, [rbp+var_30]
call my_tolower_utf16
mov eax, [rbp+var_44]
mov [rbp+var_68], eax
mov rax, [rbp+var_40]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_58]
call rax
mov ecx, eax
mov eax, [rbp+var_68]
cmp eax, ecx
jz short loc_591F8
jmp short loc_5921F
loc_591F8:
mov ecx, [rbp+var_44]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_44]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_5918A
loc_5921F:
mov rax, [rbp+var_18]
add rsp, 70h
pop rbp
retn
|
long long my_casedn_utf16(long long a1, unsigned long long a2, long long a3, long long a4, long long a5)
{
bool v6; // [rsp+Fh] [rbp-61h]
long long v7; // [rsp+10h] [rbp-60h]
long long v8; // [rsp+18h] [rbp-58h]
unsigned long long v9; // [rsp+20h] [rbp-50h]
int v10; // [rsp+2Ch] [rbp-44h]
unsigned int ( *v11)(long long, _QWORD, long long, long long); // [rsp+30h] [rbp-40h]
long long ( *v12)(long long, _QWORD *, unsigned long long, unsigned long long); // [rsp+38h] [rbp-38h]
_QWORD v13[2]; // [rsp+40h] [rbp-30h] BYREF
long long v14; // [rsp+50h] [rbp-20h]
long long v15; // [rsp+58h] [rbp-18h]
unsigned long long v16; // [rsp+60h] [rbp-10h]
long long v17; // [rsp+68h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13[1] = a5;
v12 = *(long long ( **)(long long, _QWORD *, unsigned long long, unsigned long long))(*(_QWORD *)(a1 + 184) + 40LL);
v11 = *(unsigned int ( **)(long long, _QWORD, long long, long long))(*(_QWORD *)(a1 + 184) + 48LL);
v9 = a3 + a2;
v8 = a5 + a4;
v7 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v6 = 0;
if ( v16 < v9 )
{
v10 = v12(v17, v13, v16, v9);
v6 = v10 > 0;
}
if ( !v6 )
break;
my_tolower_utf16(v7, v13);
if ( v10 != v11(v17, v13[0], v14, v8) )
break;
v16 += v10;
v14 += v10;
}
return v15;
}
|
my_casedn_utf16:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
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 + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00159188
LAB_00159188:
JMP 0x0015918a
LAB_0015918a:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x50]
MOV byte ptr [RBP + -0x61],AL
JNC 0x001591bb
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x61],AL
LAB_001591bb:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x001591c4
JMP 0x0015921f
LAB_001591c4:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[RBP + -0x30]
CALL 0x0015c670
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x68],EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x58]
CALL RAX
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x68]
CMP EAX,ECX
JZ 0x001591f8
JMP 0x0015921f
LAB_001591f8:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0015918a
LAB_0015921f:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x70
POP RBP
RET
|
long my_casedn_utf16(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
code *pcVar1;
code *pcVar2;
int8 uVar3;
bool bVar4;
int iVar5;
int local_4c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
pcVar2 = *(code **)(*(long *)(param_1 + 0xb8) + 0x30);
uVar3 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar4 = false;
if (local_18 < param_2 + param_3) {
local_4c = (*pcVar1)(local_10,&local_38,local_18,param_2 + param_3);
bVar4 = 0 < local_4c;
}
if (!bVar4) break;
my_tolower_utf16(uVar3,&local_38);
iVar5 = (*pcVar2)(local_10,local_38,local_28,param_4 + param_5);
if (local_4c != iVar5) {
return local_20;
}
local_18 = local_18 + (long)local_4c;
local_28 = local_28 + local_4c;
}
return local_20;
}
|
|
57,662
|
minja::Value::for_each(std::function<void (minja::Value&)> const&) const
|
llama.cpp/common/minja/minja.hpp
|
void for_each(const std::function<void(Value &)> & callback) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (array_) {
for (auto& item : *array_) {
callback(item);
}
} else if (object_) {
for (auto & item : *object_) {
Value key(item.first);
callback(key);
}
} else if (is_string()) {
for (char c : primitive_.get<std::string>()) {
auto val = Value(std::string(1, c));
callback(val);
}
} else {
throw std::runtime_error("Value is not iterable: " + dump());
}
}
|
O3
|
cpp
|
minja::Value::for_each(std::function<void (minja::Value&)> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rax
movb 0x40(%rdi), %dl
testq %rax, %rax
jne 0xa4c79
testq %rcx, %rcx
jne 0xa4c79
testb %dl, %dl
jne 0xa4c79
cmpq $0x0, 0x30(%r15)
je 0xa4ec2
testq %rcx, %rcx
je 0xa4ca8
movq (%rcx), %r14
movq 0x8(%rcx), %r15
cmpq %r15, %r14
je 0xa4ea1
cmpq $0x0, 0x10(%rbx)
je 0xa4eb3
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rbx)
addq $0x50, %r14
jmp 0xa4c85
testq %rax, %rax
je 0xa4d6b
movq (%rax), %r14
movq 0x8(%rax), %r13
cmpq %r13, %r14
je 0xa4ea1
leaq 0x88(%rsp), %r15
leaq 0x60(%rsp), %rbp
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x59f88
cmpq $0x0, 0x10(%rbx)
je 0xa4eb8
movq %rbx, %rdi
movq %r12, %rsi
callq *0x18(%rbx)
movq %r15, %rdi
xorl %esi, %esi
callq 0x60b38
movq %r15, %rdi
callq 0x60bd8
leaq 0x80(%rsp), %rdi
callq 0x56124
leaq 0x70(%rsp), %rdi
callq 0x56124
movq %rbp, %rdi
callq 0x56124
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xa4d59
movq 0x66254(%rip), %rax # 0x10af88
cmpb $0x0, (%rax)
je 0xa4d44
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa4d4e
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa4d59
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x60, %r14
cmpq %r13, %r14
jne 0xa4cd3
jmp 0xa4ea1
cmpb $0x3, %dl
jne 0xa4ef4
addq $0x40, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x6c468
movq (%r12), %rdi
movq 0x8(%r12), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0xa4e8a
xorl %r14d, %r14d
leaq 0x20(%rsp), %r12
leaq 0x48(%rsp), %r13
movq %rdi, %r15
movsbl (%rdi,%r14), %edx
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x1, %esi
movq %r12, %rdi
callq 0x1d820
movq %r13, %rdi
movq %r12, %rsi
callq 0x602f8
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xa4df0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1d160
cmpq $0x0, 0x10(%rbx)
je 0xa4ebd
movq %rbx, %rdi
movq %r13, %rsi
callq *0x18(%rbx)
leaq 0x88(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x60b38
movq %rbp, %rdi
callq 0x60bd8
leaq 0x80(%rsp), %rdi
callq 0x56124
leaq 0x70(%rsp), %rdi
callq 0x56124
leaq 0x60(%rsp), %rdi
callq 0x56124
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xa4e75
movq 0x66138(%rip), %rax # 0x10af88
cmpb $0x0, (%rax)
je 0xa4e60
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xa4e6a
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xa4e75
movq (%rdi), %rax
callq *0x18(%rax)
incq %r14
cmpq %r14, 0x40(%rsp)
movq %r15, %rdi
jne 0xa4daa
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xa4ea1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d160
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1dfa0
callq 0x1dfa0
callq 0x1dfa0
movl $0x10, %edi
callq 0x1d520
movq %rax, %r14
leaq 0x2da50(%rip), %rsi # 0xd2926
movq %rax, %rdi
callq 0x1d330
movq 0x660d3(%rip), %rsi # 0x10afb8
movq 0x66084(%rip), %rdx # 0x10af70
movq %r14, %rdi
callq 0x1d890
movl $0x10, %edi
callq 0x1d520
movq %rax, %r14
movq %rsp, %rdi
movq %r15, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x5a4a4
leaq 0x309cd(%rip), %rsi # 0xd58e7
leaq 0x48(%rsp), %rdi
movq %rsp, %rdx
callq 0x53e90
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0x1d380
xorl %ebp, %ebp
movq 0x66078(%rip), %rsi # 0x10afb8
movq 0x66029(%rip), %rdx # 0x10af70
movq %r14, %rdi
callq 0x1d890
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4f6d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x1d160
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4f88
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d160
testb %bpl, %bpl
jne 0xa4fb7
jmp 0xa5022
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa4fb7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa4fb7
jmp 0xa4fb4
movq %rax, %rbx
movq %r14, %rdi
callq 0x1dc90
jmp 0xa5022
movq %rax, %rbx
jmp 0xa4ff6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xa4ff6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa4ff6
jmp 0xa4fe9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5a540
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5022
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1d160
jmp 0xa5022
jmp 0xa5015
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x5a540
movq %rbx, %rdi
callq 0x1d8e0
|
_ZNK5minja5Value8for_eachERKSt8functionIFvRS0_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov rbx, rsi
mov r15, rdi
mov rcx, [rdi+10h]
mov rax, [rdi+20h]
mov dl, [rdi+40h]
test rax, rax
jnz short loc_A4C79
test rcx, rcx
jnz short loc_A4C79
test dl, dl
jnz short loc_A4C79
cmp qword ptr [r15+30h], 0
jz loc_A4EC2
loc_A4C79:
test rcx, rcx
jz short loc_A4CA8
mov r14, [rcx]
mov r15, [rcx+8]
loc_A4C85:
cmp r14, r15
jz loc_A4EA1
cmp qword ptr [rbx+10h], 0
jz loc_A4EB3
mov rdi, rbx
mov rsi, r14
call qword ptr [rbx+18h]
add r14, 50h ; 'P'
jmp short loc_A4C85
loc_A4CA8:
test rax, rax
jz loc_A4D6B
mov r14, [rax]
mov r13, [rax+8]
cmp r14, r13
jz loc_A4EA1
lea r15, [rsp+0C8h+var_40]
lea rbp, [rsp+0C8h+var_68]
lea r12, [rsp+0C8h+var_80]
loc_A4CD3:
mov rdi, r12
mov rsi, r14
call _ZN5minja5ValueC2ERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEE; minja::Value::Value(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
cmp qword ptr [rbx+10h], 0
jz loc_A4EB8
mov rdi, rbx
mov rsi, r12
call qword ptr [rbx+18h]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0C8h+var_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0C8h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbp
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rsp+0C8h+var_78]
test rdi, rdi
jz short loc_A4D59
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_A4D44
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A4D4E
loc_A4D44:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A4D4E:
cmp eax, 1
jnz short loc_A4D59
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A4D59:
add r14, 60h ; '`'
cmp r14, r13
jnz loc_A4CD3
jmp loc_A4EA1
loc_A4D6B:
cmp dl, 3
jnz loc_A4EF4
add r15, 40h ; '@'
mov r12, rsp
mov rdi, r12
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rdi, [r12]
mov rax, [r12+8]
mov [rsp+0C8h+var_88], rax
test rax, rax
jz loc_A4E8A
xor r14d, r14d
lea r12, [rsp+0C8h+var_A8]
lea r13, [rsp+0C8h+var_80]
loc_A4DAA:
mov r15, rdi
movsx edx, byte ptr [rdi+r14]
lea rax, [rsp+0C8h+var_98]
mov [rsp+0C8h+var_A8], rax
mov esi, 1
mov rdi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov rdi, r13
mov rsi, r12
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rsp+0C8h+var_A8]; void *
lea rax, [rsp+0C8h+var_98]
cmp rdi, rax
jz short loc_A4DF0
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4DF0:
cmp qword ptr [rbx+10h], 0
jz loc_A4EBD
mov rdi, rbx
mov rsi, r13
call qword ptr [rbx+18h]
lea rbp, [rsp+0C8h+var_40]
mov rdi, rbp
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+0C8h+var_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0C8h+var_58]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0C8h+var_68]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rsp+0C8h+var_78]
test rdi, rdi
jz short loc_A4E75
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_A4E60
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_A4E6A
loc_A4E60:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_A4E6A:
cmp eax, 1
jnz short loc_A4E75
mov rax, [rdi]
call qword ptr [rax+18h]
loc_A4E75:
inc r14
cmp [rsp+0C8h+var_88], r14
mov rdi, r15
jnz loc_A4DAA
mov rdi, [rsp+0C8h+var_C8]; void *
loc_A4E8A:
lea rax, [rsp+0C8h+var_B8]
cmp rdi, rax
jz short loc_A4EA1
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4EA1:
add rsp, 98h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A4EB3:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_A4EB8:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_A4EBD:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_A4EC2:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_A4EF4:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rsp
mov rsi, r15
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotIter; "Value is not iterable: "
lea rdi, [rsp+0C8h+var_80]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+0C8h+var_80]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
lea rax, [rsp+0C8h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4F6D
mov rsi, [rsp+0C8h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4F6D:
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4F88
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A4F88:
test bpl, bpl
jnz short loc_A4FB7
jmp loc_A5022
mov rbx, rax
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A4FB7
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4FB7
jmp short $+2
loc_A4FB4:
mov rbx, rax
loc_A4FB7:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_A5022
mov rbx, rax
jmp short loc_A4FF6
mov rbx, rax
mov rdi, [rsp+0C8h+var_A8]; void *
lea rax, [rsp+0C8h+var_98]
cmp rdi, rax
jz short loc_A4FF6
mov rsi, [rsp+0C8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4FF6
jmp short $+2
loc_A4FE9:
mov rbx, rax
lea rdi, [rsp+0C8h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_A4FF6:
lea rax, [rsp+0C8h+var_B8]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A5022
mov rsi, [rsp+0C8h+var_B8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A5022
jmp short $+2
loc_A5015:
mov rbx, rax
lea rdi, [rsp+0C8h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_A5022:
mov rdi, rbx
call __Unwind_Resume
|
void minja::Value::for_each(long long a1, long long a2, long long a3)
{
long long *v3; // rcx
unsigned __int8 **v4; // rax
long long v5; // r14
long long v6; // r15
unsigned __int8 *v7; // r14
unsigned __int8 *v8; // r13
long long v9; // rdi
signed __int32 v10; // eax
char *v11; // rdi
long long v12; // r14
char *v13; // r15
long long v14; // rdx
long long v15; // rdi
signed __int32 v16; // eax
std::runtime_error *exception; // r14
void *v18; // r14
void *v19; // [rsp+0h] [rbp-C8h] BYREF
long long v20; // [rsp+8h] [rbp-C0h]
long long v21; // [rsp+10h] [rbp-B8h] BYREF
void *v22; // [rsp+20h] [rbp-A8h] BYREF
_QWORD v23[2]; // [rsp+30h] [rbp-98h] BYREF
long long v24; // [rsp+40h] [rbp-88h]
__int128 v25; // [rsp+48h] [rbp-80h] BYREF
volatile signed __int32 *v26[2]; // [rsp+60h] [rbp-68h] BYREF
volatile signed __int32 *v27[2]; // [rsp+70h] [rbp-58h] BYREF
volatile signed __int32 *v28; // [rsp+80h] [rbp-48h] BYREF
char v29[64]; // [rsp+88h] [rbp-40h] BYREF
v3 = *(long long **)(a1 + 16);
v4 = *(unsigned __int8 ***)(a1 + 32);
LOBYTE(a3) = *(_BYTE *)(a1 + 64);
if ( !v4 && !v3 && !(_BYTE)a3 && !*(_QWORD *)(a1 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 )
{
v5 = *v3;
v6 = v3[1];
while ( v5 != v6 )
{
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, long long, long long))(a2 + 24))(a2, v5, a3);
v5 += 80LL;
}
}
else if ( v4 )
{
v7 = *v4;
v8 = v4[1];
if ( *v4 != v8 )
{
do
{
minja::Value::Value((long long)&v25, v7);
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, __int128 *))(a2 + 24))(a2, &v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v29);
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(v29);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v27);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v26);
v9 = *((_QWORD *)&v25 + 1);
if ( *((_QWORD *)&v25 + 1) )
{
if ( _libc_single_threaded )
{
v10 = *(_DWORD *)(*((_QWORD *)&v25 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v25 + 1) + 12LL) = v10 - 1;
}
else
{
v10 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v25 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v10 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v9 + 24LL))(v9, 0LL);
}
v7 += 96;
}
while ( v7 != v8 );
}
}
else
{
if ( (_BYTE)a3 != 3 )
{
v18 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)&v19, a1, 0xFFFFFFFF, 0);
std::operator+<char>(&v25, (long long)"Value is not iterable: ", (long long)&v19);
std::runtime_error::runtime_error(v18, &v25);
__cxa_throw(
v18,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
(long long)&v19,
a1 + 64);
v11 = (char *)v19;
v24 = v20;
if ( v20 )
{
v12 = 0LL;
do
{
v13 = v11;
v14 = (unsigned int)v11[v12];
v22 = v23;
std::string::_M_construct(&v22, 1LL, v14);
minja::Value::Value(&v25);
if ( v22 != v23 )
operator delete(v22, v23[0] + 1LL);
if ( !*(_QWORD *)(a2 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, __int128 *))(a2 + 24))(a2, &v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v29);
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(v29);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v28);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v27);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v26);
v15 = *((_QWORD *)&v25 + 1);
if ( *((_QWORD *)&v25 + 1) )
{
if ( _libc_single_threaded )
{
v16 = *(_DWORD *)(*((_QWORD *)&v25 + 1) + 12LL);
*(_DWORD *)(*((_QWORD *)&v25 + 1) + 12LL) = v16 - 1;
}
else
{
v16 = _InterlockedExchangeAdd((volatile signed __int32 *)(*((_QWORD *)&v25 + 1) + 12LL), 0xFFFFFFFF);
}
if ( v16 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v15 + 24LL))(v15, 0LL);
}
++v12;
v11 = v13;
}
while ( v24 != v12 );
v11 = (char *)v19;
}
if ( v11 != (char *)&v21 )
operator delete(v11, v21 + 1);
}
}
|
for_each:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV RBX,RSI
MOV R15,RDI
MOV RCX,qword ptr [RDI + 0x10]
MOV RAX,qword ptr [RDI + 0x20]
MOV DL,byte ptr [RDI + 0x40]
TEST RAX,RAX
JNZ 0x001a4c79
TEST RCX,RCX
JNZ 0x001a4c79
TEST DL,DL
JNZ 0x001a4c79
CMP qword ptr [R15 + 0x30],0x0
JZ 0x001a4ec2
LAB_001a4c79:
TEST RCX,RCX
JZ 0x001a4ca8
MOV R14,qword ptr [RCX]
MOV R15,qword ptr [RCX + 0x8]
LAB_001a4c85:
CMP R14,R15
JZ 0x001a4ea1
CMP qword ptr [RBX + 0x10],0x0
JZ 0x001a4eb3
MOV RDI,RBX
MOV RSI,R14
CALL qword ptr [RBX + 0x18]
ADD R14,0x50
JMP 0x001a4c85
LAB_001a4ca8:
TEST RAX,RAX
JZ 0x001a4d6b
MOV R14,qword ptr [RAX]
MOV R13,qword ptr [RAX + 0x8]
CMP R14,R13
JZ 0x001a4ea1
LEA R15,[RSP + 0x88]
LEA RBP,[RSP + 0x60]
LEA R12,[RSP + 0x48]
LAB_001a4cd3:
MOV RDI,R12
MOV RSI,R14
CALL 0x00159f88
CMP qword ptr [RBX + 0x10],0x0
JZ 0x001a4eb8
LAB_001a4ce9:
MOV RDI,RBX
MOV RSI,R12
CALL qword ptr [RBX + 0x18]
LAB_001a4cf2:
MOV RDI,R15
XOR ESI,ESI
CALL 0x00160b38
MOV RDI,R15
CALL 0x00160bd8
LEA RDI,[RSP + 0x80]
CALL 0x00156124
LEA RDI,[RSP + 0x70]
CALL 0x00156124
MOV RDI,RBP
CALL 0x00156124
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x001a4d59
MOV RAX,qword ptr [0x0020af88]
CMP byte ptr [RAX],0x0
JZ 0x001a4d44
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a4d4e
LAB_001a4d44:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a4d4e:
CMP EAX,0x1
JNZ 0x001a4d59
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a4d59:
ADD R14,0x60
CMP R14,R13
JNZ 0x001a4cd3
JMP 0x001a4ea1
LAB_001a4d6b:
CMP DL,0x3
JNZ 0x001a4ef4
ADD R15,0x40
MOV R12,RSP
MOV RDI,R12
MOV RSI,R15
CALL 0x0016c468
MOV RDI,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
MOV qword ptr [RSP + 0x40],RAX
TEST RAX,RAX
JZ 0x001a4e8a
XOR R14D,R14D
LEA R12,[RSP + 0x20]
LEA R13,[RSP + 0x48]
LAB_001a4daa:
MOV R15,RDI
MOVSX EDX,byte ptr [RDI + R14*0x1]
LEA RAX,[RSP + 0x30]
MOV qword ptr [RSP + 0x20],RAX
LAB_001a4dbc:
MOV ESI,0x1
MOV RDI,R12
CALL 0x0011d820
LAB_001a4dc9:
MOV RDI,R13
MOV RSI,R12
CALL 0x001602f8
MOV RDI,qword ptr [RSP + 0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x001a4df0
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011d160
LAB_001a4df0:
CMP qword ptr [RBX + 0x10],0x0
JZ 0x001a4ebd
LAB_001a4dfb:
MOV RDI,RBX
MOV RSI,R13
CALL qword ptr [RBX + 0x18]
LAB_001a4e04:
LEA RBP,[RSP + 0x88]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x00160b38
MOV RDI,RBP
CALL 0x00160bd8
LEA RDI,[RSP + 0x80]
CALL 0x00156124
LEA RDI,[RSP + 0x70]
CALL 0x00156124
LEA RDI,[RSP + 0x60]
CALL 0x00156124
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x001a4e75
MOV RAX,qword ptr [0x0020af88]
CMP byte ptr [RAX],0x0
JZ 0x001a4e60
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001a4e6a
LAB_001a4e60:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001a4e6a:
CMP EAX,0x1
JNZ 0x001a4e75
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001a4e75:
INC R14
CMP qword ptr [RSP + 0x40],R14
MOV RDI,R15
JNZ 0x001a4daa
MOV RDI,qword ptr [RSP]
LAB_001a4e8a:
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x001a4ea1
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011d160
LAB_001a4ea1:
ADD RSP,0x98
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a4eb3:
CALL 0x0011dfa0
LAB_001a4eb8:
CALL 0x0011dfa0
LAB_001a4ebd:
CALL 0x0011dfa0
LAB_001a4ec2:
MOV EDI,0x10
CALL 0x0011d520
MOV R14,RAX
LAB_001a4ecf:
LEA RSI,[0x1d2926]
MOV RDI,RAX
CALL 0x0011d330
LAB_001a4ede:
MOV RSI,qword ptr [0x0020afb8]
MOV RDX,qword ptr [0x0020af70]
MOV RDI,R14
CALL 0x0011d890
LAB_001a4ef4:
MOV EDI,0x10
CALL 0x0011d520
MOV R14,RAX
LAB_001a4f01:
MOV RDI,RSP
MOV RSI,R15
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0015a4a4
LAB_001a4f13:
LEA RSI,[0x1d58e7]
LEA RDI,[RSP + 0x48]
MOV RDX,RSP
CALL 0x00153e90
MOV BPL,0x1
LAB_001a4f2a:
LEA RSI,[RSP + 0x48]
MOV RDI,R14
CALL 0x0011d380
XOR EBP,EBP
MOV RSI,qword ptr [0x0020afb8]
MOV RDX,qword ptr [0x0020af70]
MOV RDI,R14
CALL 0x0011d890
|
/* minja::Value::for_each(std::function<void (minja::Value&)> const&) const */
void __thiscall minja::Value::for_each(Value *this,function *param_1)
{
int *piVar1;
long *plVar2;
long *plVar3;
long lVar4;
basic_json *pbVar5;
int iVar6;
runtime_error *prVar7;
long lVar8;
basic_json *pbVar9;
long *local_c8;
long local_c0;
long local_b8 [2];
long *local_a8 [2];
long local_98 [2];
long local_88;
Value local_80 [8];
long *local_78;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_68 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_48 [8];
data local_40 [16];
plVar2 = *(long **)(this + 0x10);
plVar3 = *(long **)(this + 0x20);
if ((((plVar3 == (long *)0x0) && (plVar2 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a4ecf to 001a4edd has its CatchHandler @ 001a4fb4 */
std::runtime_error::runtime_error(prVar7,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_0020afb8,PTR__runtime_error_0020af70);
}
if (plVar2 == (long *)0x0) {
if (plVar3 == (long *)0x0) {
if (this[0x40] != (Value)0x3) {
prVar7 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001a4f01 to 001a4f12 has its CatchHandler @ 001a4fb2 */
dump_abi_cxx11_((int)&local_c8,SUB81(this,0));
/* try { // try from 001a4f13 to 001a4f26 has its CatchHandler @ 001a4f92 */
std::operator+((char *)local_80,(string *)"Value is not iterable: ");
/* try { // try from 001a4f2a to 001a4f4e has its CatchHandler @ 001a4f4f */
std::runtime_error::runtime_error(prVar7,(string *)local_80);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar7,PTR_typeinfo_0020afb8,PTR__runtime_error_0020af70);
}
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
(&local_c8,this + 0x40);
local_88 = local_c0;
if (local_c0 != 0) {
lVar8 = 0;
do {
local_a8[0] = local_98;
/* try { // try from 001a4dbc to 001a4dc8 has its CatchHandler @ 001a4fc1 */
std::__cxx11::string::_M_construct((ulong)local_a8,'\x01');
/* try { // try from 001a4dc9 to 001a4dd3 has its CatchHandler @ 001a4fc6 */
Value(local_80,(string *)local_a8);
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (*(long *)(param_1 + 0x10) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 001a4ebd to 001a4ec1 has its CatchHandler @ 001a4fe9 */
std::__throw_bad_function_call();
}
/* try { // try from 001a4dfb to 001a4e03 has its CatchHandler @ 001a4fe7 */
(**(code **)(param_1 + 0x18))(param_1,local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_68);
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_0020af88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
lVar8 = lVar8 + 1;
} while (local_88 != lVar8);
}
if (local_c8 != local_b8) {
operator_delete(local_c8,local_b8[0] + 1);
}
}
else {
pbVar9 = (basic_json *)*plVar3;
pbVar5 = (basic_json *)plVar3[1];
if (pbVar9 != pbVar5) {
do {
Value(local_80,pbVar9);
if (*(long *)(param_1 + 0x10) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 001a4eb8 to 001a4ebc has its CatchHandler @ 001a5015 */
std::__throw_bad_function_call();
}
/* try { // try from 001a4ce9 to 001a4cf1 has its CatchHandler @ 001a5013 */
(**(code **)(param_1 + 0x18))(param_1,local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_68);
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_0020af88 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar6 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar6 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar6 + -1;
}
if (iVar6 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
pbVar9 = pbVar9 + 0x60;
} while (pbVar9 != pbVar5);
}
}
}
else {
lVar4 = plVar2[1];
for (lVar8 = *plVar2; lVar8 != lVar4; lVar8 = lVar8 + 0x50) {
if (*(long *)(param_1 + 0x10) == 0) {
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
(**(code **)(param_1 + 0x18))(param_1,lVar8);
}
}
return;
}
|
|
57,663
|
ps_fetch_float
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static
void ps_fetch_float(MYSQL_BIND *r_param, const MYSQL_FIELD * field, unsigned char **row)
{
switch(r_param->buffer_type)
{
case MYSQL_TYPE_FLOAT:
{
float *value= (float *)r_param->buffer;
float4get(*value, *row);
r_param->buffer_length= 4;
*r_param->error= 0;
}
break;
default:
{
float value;
memcpy(&value, *row, sizeof(float));
float4get(value, (char *)*row);
convert_from_float(r_param, field, value, sizeof(float));
}
break;
}
(*row)+= 4;
}
|
O0
|
c
|
ps_fetch_float:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x60(%rax), %eax
subl $0x4, %eax
jne 0x2f236
jmp 0x2f202
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x4, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, (%rax)
jmp 0x2f265
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movss -0x24(%rbp), %xmm0
movl $0x4, %edx
callq 0x30ab0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
ps_fetch_float:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov eax, [rax+60h]
sub eax, 4
jnz short loc_2F236
jmp short $+2
loc_2F202:
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
mov ecx, [rcx]
mov [rax], ecx
mov rax, [rbp+var_8]
mov qword ptr [rax+40h], 4
mov rax, [rbp+var_8]
mov rax, [rax+18h]
mov byte ptr [rax], 0
jmp short loc_2F265
loc_2F236:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax]
mov [rbp+var_24], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
movss xmm0, [rbp+var_24]
mov edx, 4
call convert_from_float
loc_2F265:
mov rax, [rbp+var_18]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
add rsp, 30h
pop rbp
retn
|
float ** ps_fetch_float(long long a1, long long a2, float **a3)
{
float **result; // rax
if ( *(_DWORD *)(a1 + 96) == 4 )
{
**(float **)(a1 + 16) = **a3;
*(_QWORD *)(a1 + 64) = 4LL;
**(_BYTE **)(a1 + 24) = 0;
}
else
{
convert_from_float(a1, a2, 4LL, **a3);
}
result = a3;
++*a3;
return result;
}
|
ps_fetch_float:
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 RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x60]
SUB EAX,0x4
JNZ 0x0012f236
JMP 0x0012f202
LAB_0012f202:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RAX],0x0
JMP 0x0012f265
LAB_0012f236:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOVSS XMM0,dword ptr [RBP + -0x24]
MOV EDX,0x4
CALL 0x00130ab0
LAB_0012f265:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
ADD RSP,0x30
POP RBP
RET
|
void ps_fetch_float(long param_1,int8 param_2,long *param_3)
{
if (*(int *)(param_1 + 0x60) == 4) {
**(int4 **)(param_1 + 0x10) = *(int4 *)*param_3;
*(int8 *)(param_1 + 0x40) = 4;
**(int1 **)(param_1 + 0x18) = 0;
}
else {
convert_from_float(*(int4 *)*param_3,param_1,param_2,4);
}
*param_3 = *param_3 + 4;
return;
}
|
|
57,664
|
aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend()
|
aimrt_mujoco_sim/_deps/aimrt-src/src/runtime/core/../core/logger/rotate_file_logger_backend.h
|
RotateFileLoggerBackend() = default;
|
O3
|
c
|
aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x530fd(%rip), %rax # 0xaed40
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x5bdce
leaq 0x118(%rbx), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movq %rbp, 0x108(%rbx)
movq $0x0, 0x110(%rbx)
movb $0x0, 0x118(%rbx)
leaq 0x128(%rbx), %r12
movq %r12, %rdi
callq 0x1fe80
movb $0x0, 0x328(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x330(%rbx)
movups %xmm0, 0x340(%rbx)
movups %xmm0, 0x350(%rbx)
movq $0x0, 0x360(%rbx)
leaq 0x368(%rbx), %r13
leaq 0x398(%rbx), %rax
movq %rax, 0x368(%rbx)
movq $0x1, 0x370(%rbx)
movups %xmm0, 0x378(%rbx)
movl $0x3f800000, 0x388(%rbx) # imm = 0x3F800000
leaq 0x3c0(%rbx), %rdi
leaq 0x3d0(%rbx), %rax
movups %xmm0, 0x390(%rbx)
movups %xmm0, 0x3a0(%rbx)
movups %xmm0, 0x3b0(%rbx)
movq %rax, 0x3c0(%rbx)
leaq 0x2b692(%rip), %rsi # 0x873bb
leaq 0x2b6ab(%rip), %rdx # 0x873db
callq 0x1e620
xorps %xmm0, %xmm0
movups %xmm0, 0x3e0(%rbx)
movq $0x0, 0x3f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x3a0(%rbx), %rdi
callq 0x5bb22
movq %r13, %rdi
callq 0x5bb90
movq %r12, %rdi
callq 0x1f9e0
jmp 0x5bd7d
movq %rax, %r15
movq 0x108(%rbx), %rdi
cmpq %rbp, %rdi
je 0x5bd95
movq (%rbp), %rsi
incq %rsi
callq 0x1f250
movq 0xe8(%rbx), %rax
testq %rax, %rax
je 0x5bdb5
addq $0xd8, %rbx
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x5bf7a
movq %r15, %rdi
callq 0x1ffd0
movq %rax, %rdi
callq 0x23e15
nop
|
_ZN5aimrt7runtime4core6logger23RotateFileLoggerBackendC2Ev:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
lea rax, _ZTVN5aimrt7runtime4core6logger23RotateFileLoggerBackendE; `vtable for'aimrt::runtime::core::logger::RotateFileLoggerBackend
add rax, 10h
mov [rdi], rax
lea r14, [rdi+8]
mov rdi, r14; this
call _ZN5aimrt7runtime4core6logger23RotateFileLoggerBackend7OptionsC2Ev; aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::Options(void)
lea rbp, [rbx+118h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+0F8h], xmm0
movups xmmword ptr [rbx+0E8h], xmm0
movups xmmword ptr [rbx+0D8h], xmm0
mov [rbx+108h], rbp
mov qword ptr [rbx+110h], 0
mov byte ptr [rbx+118h], 0
lea r12, [rbx+128h]
mov rdi, r12
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEEC1Ev; std::ofstream::basic_ofstream(void)
mov byte ptr [rbx+328h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx+330h], xmm0
movups xmmword ptr [rbx+340h], xmm0
movups xmmword ptr [rbx+350h], xmm0
mov qword ptr [rbx+360h], 0
lea r13, [rbx+368h]
lea rax, [rbx+398h]
mov [rbx+368h], rax
mov qword ptr [rbx+370h], 1
movups xmmword ptr [rbx+378h], xmm0
mov dword ptr [rbx+388h], 3F800000h
lea rdi, [rbx+3C0h]
lea rax, [rbx+3D0h]
movups xmmword ptr [rbx+390h], xmm0
movups xmmword ptr [rbx+3A0h], xmm0
movups xmmword ptr [rbx+3B0h], xmm0
mov [rbx+3C0h], rax
lea rsi, aCFLTNGRFV; "[%c.%f][%l][%t][%n][%g:%R @%F]%v"
lea rdx, aCFLTNGRFV+20h; ""
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
xorps xmm0, xmm0
movups xmmword ptr [rbx+3E0h], xmm0
mov qword ptr [rbx+3F0h], 0
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r15, rax
lea rdi, [rbx+3A0h]
call _ZNSt6vectorISt8functionIFvRKN5aimrt7runtime4core6logger14LogDataWrapperERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaISG_EED2Ev; std::vector<std::function<void ()(aimrt::runtime::core::logger::LogDataWrapper const&,std::string &)>>::~vector()
mov rdi, r13
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_bESaIS8_ENSt8__detail10_Select1stESt8equal_toIvEN5aimrt6common4util10StringHashENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,bool>,std::allocator<std::pair<std::string const,bool>>,std::__detail::_Select1st,std::equal_to<void>,aimrt::common::util::StringHash,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
mov rdi, r12
call __ZNSt14basic_ofstreamIcSt11char_traitsIcEED1Ev; std::ofstream::~ofstream()
jmp short loc_5BD7D
mov r15, rax
loc_5BD7D:
mov rdi, [rbx+108h]; void *
cmp rdi, rbp
jz short loc_5BD95
mov rsi, [rbp+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5BD95:
mov rax, [rbx+0E8h]
test rax, rax
jz short loc_5BDB5
add rbx, 0D8h
mov rdi, rbx
mov rsi, rbx
mov edx, 3
call rax
loc_5BDB5:
mov rdi, r14; this
call _ZN5aimrt7runtime4core6logger23RotateFileLoggerBackend7OptionsD2Ev; aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::~Options()
mov rdi, r15
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend(
aimrt::runtime::core::logger::RotateFileLoggerBackend *this)
{
long long result; // rax
*(_QWORD *)this = &`vtable for'aimrt::runtime::core::logger::RotateFileLoggerBackend + 2;
aimrt::runtime::core::logger::RotateFileLoggerBackend::Options::Options((aimrt::runtime::core::logger::RotateFileLoggerBackend *)((char *)this + 8));
*(_OWORD *)((char *)this + 248) = 0LL;
*(_OWORD *)((char *)this + 232) = 0LL;
*(_OWORD *)((char *)this + 216) = 0LL;
*((_QWORD *)this + 33) = (char *)this + 280;
*((_QWORD *)this + 34) = 0LL;
*((_BYTE *)this + 280) = 0;
std::ofstream::basic_ofstream((char *)this + 296);
*((_BYTE *)this + 808) = 0;
*((_OWORD *)this + 51) = 0LL;
*((_OWORD *)this + 52) = 0LL;
*((_OWORD *)this + 53) = 0LL;
*((_QWORD *)this + 108) = 0LL;
*((_QWORD *)this + 109) = (char *)this + 920;
*((_QWORD *)this + 110) = 1LL;
*(_OWORD *)((char *)this + 888) = 0LL;
*((_DWORD *)this + 226) = 1065353216;
*((_OWORD *)this + 57) = 0LL;
*((_OWORD *)this + 58) = 0LL;
*((_OWORD *)this + 59) = 0LL;
*((_QWORD *)this + 120) = (char *)this + 976;
result = std::string::_M_construct<char const*>((char *)this + 960, "[%c.%f][%l][%t][%n][%g:%R @%F]%v", "");
*((_OWORD *)this + 62) = 0LL;
*((_QWORD *)this + 126) = 0LL;
return result;
}
|
RotateFileLoggerBackend:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x1aed40]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
LEA R14,[RDI + 0x8]
MOV RDI,R14
CALL 0x0015bdce
LEA RBP,[RBX + 0x118]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xf8],XMM0
MOVUPS xmmword ptr [RBX + 0xe8],XMM0
MOVUPS xmmword ptr [RBX + 0xd8],XMM0
MOV qword ptr [RBX + 0x108],RBP
MOV qword ptr [RBX + 0x110],0x0
MOV byte ptr [RBX + 0x118],0x0
LEA R12,[RBX + 0x128]
LAB_0015bc95:
MOV RDI,R12
CALL 0x0011fe80
MOV byte ptr [RBX + 0x328],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x330],XMM0
MOVUPS xmmword ptr [RBX + 0x340],XMM0
MOVUPS xmmword ptr [RBX + 0x350],XMM0
MOV qword ptr [RBX + 0x360],0x0
LEA R13,[RBX + 0x368]
LEA RAX,[RBX + 0x398]
MOV qword ptr [RBX + 0x368],RAX
MOV qword ptr [RBX + 0x370],0x1
MOVUPS xmmword ptr [RBX + 0x378],XMM0
MOV dword ptr [RBX + 0x388],0x3f800000
LEA RDI,[RBX + 0x3c0]
LEA RAX,[RBX + 0x3d0]
MOVUPS xmmword ptr [RBX + 0x390],XMM0
MOVUPS xmmword ptr [RBX + 0x3a0],XMM0
MOVUPS xmmword ptr [RBX + 0x3b0],XMM0
MOV qword ptr [RBX + 0x3c0],RAX
LAB_0015bd22:
LEA RSI,[0x1873bb]
LEA RDX,[0x1873db]
CALL 0x0011e620
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x3e0],XMM0
MOV qword ptr [RBX + 0x3f0],0x0
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend() */
void __thiscall
aimrt::runtime::core::logger::RotateFileLoggerBackend::RotateFileLoggerBackend
(RotateFileLoggerBackend *this)
{
*(int ***)this = &PTR__RotateFileLoggerBackend_001aed50;
Options::Options((Options *)(this + 8));
*(int8 *)(this + 0xf8) = 0;
*(int8 *)(this + 0x100) = 0;
*(int8 *)(this + 0xe8) = 0;
*(int8 *)(this + 0xf0) = 0;
*(int8 *)(this + 0xd8) = 0;
*(int8 *)(this + 0xe0) = 0;
*(RotateFileLoggerBackend **)(this + 0x108) = this + 0x118;
*(int8 *)(this + 0x110) = 0;
this[0x118] = (RotateFileLoggerBackend)0x0;
/* try { // try from 0015bc95 to 0015bc9c has its CatchHandler @ 0015bd7a */
std::ofstream::ofstream((ofstream *)(this + 0x128));
this[0x328] = (RotateFileLoggerBackend)0x0;
*(int8 *)(this + 0x330) = 0;
*(int8 *)(this + 0x338) = 0;
*(int8 *)(this + 0x340) = 0;
*(int8 *)(this + 0x348) = 0;
*(int8 *)(this + 0x350) = 0;
*(int8 *)(this + 0x358) = 0;
*(int8 *)(this + 0x360) = 0;
*(RotateFileLoggerBackend **)(this + 0x368) = this + 0x398;
*(int8 *)(this + 0x370) = 1;
*(int8 *)(this + 0x378) = 0;
*(int8 *)(this + 0x380) = 0;
*(int4 *)(this + 0x388) = 0x3f800000;
*(int8 *)(this + 0x390) = 0;
*(int8 *)(this + 0x398) = 0;
*(int8 *)(this + 0x3a0) = 0;
*(int8 *)(this + 0x3a8) = 0;
*(int8 *)(this + 0x3b0) = 0;
*(int8 *)(this + 0x3b8) = 0;
*(RotateFileLoggerBackend **)(this + 0x3c0) = this + 0x3d0;
/* try { // try from 0015bd22 to 0015bd34 has its CatchHandler @ 0015bd59 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x3c0,&DAT_001873bb,&DAT_001873db);
*(int8 *)(this + 0x3e0) = 0;
*(int8 *)(this + 1000) = 0;
*(int8 *)(this + 0x3f0) = 0;
return;
}
|
|
57,665
|
pfs_get_thread_transaction_locker_v1
|
eloqsql/storage/perfschema/pfs.cc
|
PSI_transaction_locker*
pfs_get_thread_transaction_locker_v1(PSI_transaction_locker_state *state,
const void *xid,
ulonglong trxid,
int isolation_level,
my_bool read_only,
my_bool autocommit)
{
assert(state != NULL);
if (!flag_global_instrumentation)
return NULL;
if (!global_transaction_class.m_enabled)
return NULL;
uint flags;
if (flag_thread_instrumentation)
{
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (unlikely(pfs_thread == NULL))
return NULL;
if (!pfs_thread->m_enabled)
return NULL;
state->m_thread= reinterpret_cast<PSI_thread *> (pfs_thread);
flags= STATE_FLAG_THREAD;
if (global_transaction_class.m_timed)
flags|= STATE_FLAG_TIMED;
if (flag_events_transactions_current)
{
ulonglong event_id= pfs_thread->m_event_id++;
PFS_events_transactions *pfs= &pfs_thread->m_transaction_current;
pfs->m_thread_internal_id = pfs_thread->m_thread_internal_id;
pfs->m_event_id= event_id;
pfs->m_event_type= EVENT_TYPE_TRANSACTION;
pfs->m_end_event_id= 0;
pfs->m_class= &global_transaction_class;
pfs->m_timer_start= 0;
pfs->m_timer_end= 0;
if (xid != NULL)
pfs->m_xid= *(PSI_xid *)xid;
pfs->m_xa= false;
pfs->m_xa_state= TRANS_STATE_XA_NOTR;
pfs->m_trxid= trxid;
pfs->m_isolation_level= (enum_isolation_level)isolation_level;
pfs->m_read_only= read_only;
pfs->m_autocommit= autocommit;
pfs->m_savepoint_count= 0;
pfs->m_rollback_to_savepoint_count= 0;
pfs->m_release_savepoint_count= 0;
uint statements_count= pfs_thread->m_events_statements_count;
if (statements_count > 0)
{
PFS_events_statements *pfs_statement=
&pfs_thread->m_statement_stack[statements_count - 1];
pfs->m_nesting_event_id= pfs_statement->m_event.m_event_id;
pfs->m_nesting_event_type= pfs_statement->m_event.m_event_type;
}
else
{
pfs->m_nesting_event_id= 0;
/* pfs->m_nesting_event_type not used when m_nesting_event_id is 0 */
}
state->m_transaction= pfs;
flags|= STATE_FLAG_EVENT;
}
}
else
{
if (global_transaction_class.m_timed)
flags= STATE_FLAG_TIMED;
else
flags= 0;
}
state->m_class= &global_transaction_class;
state->m_flags= flags;
state->m_autocommit= autocommit;
state->m_read_only= read_only;
state->m_savepoint_count= 0;
state->m_rollback_to_savepoint_count= 0;
state->m_release_savepoint_count= 0;
return reinterpret_cast<PSI_transaction_locker*> (state);
}
|
O0
|
cpp
|
pfs_get_thread_transaction_locker_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x70(%rbp)
movl %ecx, %eax
movl -0x70(%rbp), %ecx
movl %eax, -0x6c(%rbp)
movq %rdx, %rax
movl -0x6c(%rbp), %edx
movq %rax, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rax, -0x60(%rbp)
movq %rdi, %r8
movq -0x60(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movb %cl, -0x25(%rbp)
movb %al, -0x26(%rbp)
leaq 0x3c1941(%rip), %rax # 0x40df80
testb $0x1, (%rax)
jne 0x4c651
movq $0x0, -0x8(%rbp)
jmp 0x4c901
leaq 0x3be0e8(%rip), %rax # 0x40a740
testb $0x1, 0x4(%rax)
jne 0x4c66b
movq $0x0, -0x8(%rbp)
jmp 0x4c901
leaq 0x3c194e(%rip), %rax # 0x40dfc0
testb $0x1, (%rax)
je 0x4c88a
callq 0x45700
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4c6a3
movq $0x0, -0x8(%rbp)
jmp 0x4c901
movq -0x38(%rbp), %rax
testb $0x1, 0x7e0(%rax)
jne 0x4c6bd
movq $0x0, -0x8(%rbp)
jmp 0x4c901
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x2, -0x2c(%rbp)
leaq 0x3be069(%rip), %rax # 0x40a740
testb $0x1, 0x5(%rax)
je 0x4c6e6
movl -0x2c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x2c(%rbp)
leaq 0x3c15d3(%rip), %rax # 0x40dcc0
testb $0x1, (%rax)
je 0x4c888
movq -0x38(%rbp), %rcx
movq 0x7f8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x7f8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
addq $0x14c8, %rax # imm = 0x14C8
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x850(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x48(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x48(%rbp), %rax
leaq 0x3bdfdf(%rip), %rcx # 0x40a740
movq %rcx, 0x30(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x40(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4c79d
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x80, %rdi
movl $0x98, %edx
callq 0x26280
movq -0x48(%rbp), %rax
movb $0x0, 0x78(%rax)
movq -0x48(%rbp), %rax
movl $0xffffffff, 0x118(%rax) # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x58(%rax)
movl -0x24(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x11c(%rax)
movb -0x25(%rbp), %cl
movq -0x48(%rbp), %rax
movb %cl, 0x120(%rax)
movb -0x26(%rbp), %cl
movq -0x48(%rbp), %rax
movb %cl, 0x121(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x128(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x130(%rax)
movq -0x48(%rbp), %rax
movq $0x0, 0x138(%rax)
movq -0x38(%rbp), %rax
movl 0x14b8(%rax), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
jbe 0x4c867
movq -0x38(%rbp), %rax
movq 0x14c0(%rax), %rax
movl -0x4c(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x590, %rcx, %rcx # imm = 0x590
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x58(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x28(%rax)
jmp 0x4c873
movq -0x48(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x2c(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4c8a9
leaq 0x3bdeaf(%rip), %rax # 0x40a740
testb $0x1, 0x5(%rax)
je 0x4c8a0
movl $0x1, -0x2c(%rbp)
jmp 0x4c8a7
movl $0x0, -0x2c(%rbp)
jmp 0x4c8a9
movq -0x10(%rbp), %rax
leaq 0x3bde8c(%rip), %rcx # 0x40a740
movq %rcx, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb -0x26(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x31(%rax)
movb -0x25(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
pfs_get_thread_transaction_locker_v1:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_70], r8d
mov eax, ecx
mov ecx, [rbp+var_70]
mov [rbp+var_6C], eax
mov rax, rdx
mov edx, [rbp+var_6C]
mov [rbp+var_68], rax
mov rax, rsi
mov rsi, [rbp+var_68]
mov [rbp+var_60], rax
mov r8, rdi
mov rdi, [rbp+var_60]
mov al, r9b
mov [rbp+var_10], r8
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_24], edx
mov [rbp+var_25], cl
mov [rbp+var_26], al
lea rax, flag_global_instrumentation
test byte ptr [rax], 1
jnz short loc_4C651
mov [rbp+var_8], 0
jmp loc_4C901
loc_4C651:
lea rax, global_transaction_class
test byte ptr [rax+4], 1
jnz short loc_4C66B
mov [rbp+var_8], 0
jmp loc_4C901
loc_4C66B:
lea rax, flag_thread_instrumentation
test byte ptr [rax], 1
jz loc_4C88A
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4C6A3
mov [rbp+var_8], 0
jmp loc_4C901
loc_4C6A3:
mov rax, [rbp+var_38]
test byte ptr [rax+7E0h], 1
jnz short loc_4C6BD
mov [rbp+var_8], 0
jmp loc_4C901
loc_4C6BD:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov [rbp+var_2C], 2
lea rax, global_transaction_class
test byte ptr [rax+5], 1
jz short loc_4C6E6
mov eax, [rbp+var_2C]
or eax, 1
mov [rbp+var_2C], eax
loc_4C6E6:
lea rax, flag_events_transactions_current
test byte ptr [rax], 1
jz loc_4C888
mov rcx, [rbp+var_38]
mov rax, [rcx+7F8h]
mov rdx, rax
add rdx, 1
mov [rcx+7F8h], rdx
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
add rax, 14C8h
mov [rbp+var_48], rax
mov rax, [rbp+var_38]
mov rcx, [rax+850h]
mov rax, [rbp+var_48]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_48]
mov [rax+8], rcx
mov rax, [rbp+var_48]
mov dword ptr [rax+18h], 1
mov rax, [rbp+var_48]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_48]
lea rcx, global_transaction_class
mov [rax+30h], rcx
mov rax, [rbp+var_48]
mov qword ptr [rax+38h], 0
mov rax, [rbp+var_48]
mov qword ptr [rax+40h], 0
cmp [rbp+var_18], 0
jz short loc_4C79D
mov rsi, [rbp+var_18]
mov rdi, [rbp+var_48]
add rdi, 80h
mov edx, 98h
call _memcpy
loc_4C79D:
mov rax, [rbp+var_48]
mov byte ptr [rax+78h], 0
mov rax, [rbp+var_48]
mov dword ptr [rax+118h], 0FFFFFFFFh
mov rcx, [rbp+var_20]
mov rax, [rbp+var_48]
mov [rax+58h], rcx
mov ecx, [rbp+var_24]
mov rax, [rbp+var_48]
mov [rax+11Ch], ecx
mov cl, [rbp+var_25]
mov rax, [rbp+var_48]
mov [rax+120h], cl
mov cl, [rbp+var_26]
mov rax, [rbp+var_48]
mov [rax+121h], cl
mov rax, [rbp+var_48]
mov qword ptr [rax+128h], 0
mov rax, [rbp+var_48]
mov qword ptr [rax+130h], 0
mov rax, [rbp+var_48]
mov qword ptr [rax+138h], 0
mov rax, [rbp+var_38]
mov eax, [rax+14B8h]
mov [rbp+var_4C], eax
cmp [rbp+var_4C], 0
jbe short loc_4C867
mov rax, [rbp+var_38]
mov rax, [rax+14C0h]
mov ecx, [rbp+var_4C]
sub ecx, 1
mov ecx, ecx
imul rcx, 590h
add rax, rcx
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov rcx, [rax+8]
mov rax, [rbp+var_48]
mov [rax+20h], rcx
mov rax, [rbp+var_58]
mov ecx, [rax+18h]
mov rax, [rbp+var_48]
mov [rax+28h], ecx
jmp short loc_4C873
loc_4C867:
mov rax, [rbp+var_48]
mov qword ptr [rax+20h], 0
loc_4C873:
mov rcx, [rbp+var_48]
mov rax, [rbp+var_10]
mov [rax+28h], rcx
mov eax, [rbp+var_2C]
or eax, 4
mov [rbp+var_2C], eax
loc_4C888:
jmp short loc_4C8A9
loc_4C88A:
lea rax, global_transaction_class
test byte ptr [rax+5], 1
jz short loc_4C8A0
mov [rbp+var_2C], 1
jmp short loc_4C8A7
loc_4C8A0:
mov [rbp+var_2C], 0
loc_4C8A7:
jmp short $+2
loc_4C8A9:
mov rax, [rbp+var_10]
lea rcx, global_transaction_class
mov [rax+8], rcx
mov ecx, [rbp+var_2C]
mov rax, [rbp+var_10]
mov [rax], ecx
mov cl, [rbp+var_26]
mov rax, [rbp+var_10]
mov [rax+31h], cl
mov cl, [rbp+var_25]
mov rax, [rbp+var_10]
mov [rax+30h], cl
mov rax, [rbp+var_10]
mov qword ptr [rax+40h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+48h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+50h], 0
mov rax, [rbp+var_10]
mov [rbp+var_8], rax
loc_4C901:
mov rax, [rbp+var_8]
add rsp, 70h
pop rbp
retn
|
long long pfs_get_thread_transaction_locker_v1(long long a1, long long a2, long long a3, int a4, char a5, char a6)
{
long long v6; // rax
long long v7; // rax
long long v8; // rcx
int v10; // [rsp+24h] [rbp-4Ch]
long long THR_PFS; // [rsp+38h] [rbp-38h]
int v12; // [rsp+44h] [rbp-2Ch]
if ( (flag_global_instrumentation & 1) == 0 )
return 0LL;
if ( (*((_BYTE *)&global_transaction_class + 4) & 1) != 0 )
{
if ( (flag_thread_instrumentation & 1) != 0 )
{
THR_PFS = my_thread_get_THR_PFS();
if ( !THR_PFS )
return 0LL;
if ( (*(_BYTE *)(THR_PFS + 2016) & 1) == 0 )
return 0LL;
*(_QWORD *)(a1 + 16) = THR_PFS;
v12 = 2;
if ( (*((_BYTE *)&global_transaction_class + 5) & 1) != 0 )
v12 = 3;
if ( (flag_events_transactions_current & 1) != 0 )
{
v6 = *(_QWORD *)(THR_PFS + 2040);
*(_QWORD *)(THR_PFS + 2040) = v6 + 1;
*(_QWORD *)(THR_PFS + 5320) = *(_QWORD *)(THR_PFS + 2128);
*(_QWORD *)(THR_PFS + 5328) = v6;
*(_DWORD *)(THR_PFS + 5344) = 1;
*(_QWORD *)(THR_PFS + 5336) = 0LL;
*(_QWORD *)(THR_PFS + 5368) = &global_transaction_class;
*(_QWORD *)(THR_PFS + 5376) = 0LL;
*(_QWORD *)(THR_PFS + 5384) = 0LL;
if ( a2 )
memcpy(THR_PFS + 5448, a2, 152LL);
*(_BYTE *)(THR_PFS + 5440) = 0;
*(_DWORD *)(THR_PFS + 5600) = -1;
*(_QWORD *)(THR_PFS + 5408) = a3;
*(_DWORD *)(THR_PFS + 5604) = a4;
*(_BYTE *)(THR_PFS + 5608) = a5;
*(_BYTE *)(THR_PFS + 5609) = a6;
*(_QWORD *)(THR_PFS + 5616) = 0LL;
*(_QWORD *)(THR_PFS + 5624) = 0LL;
*(_QWORD *)(THR_PFS + 5632) = 0LL;
v10 = *(_DWORD *)(THR_PFS + 5304);
if ( v10 )
{
v7 = *(_QWORD *)(THR_PFS + 5312);
v8 = 1424LL * (unsigned int)(v10 - 1);
*(_QWORD *)(THR_PFS + 5352) = *(_QWORD *)(v8 + v7 + 8);
*(_DWORD *)(THR_PFS + 5360) = *(_DWORD *)(v8 + v7 + 24);
}
else
{
*(_QWORD *)(THR_PFS + 5352) = 0LL;
}
*(_QWORD *)(a1 + 40) = THR_PFS + 5320;
v12 |= 4u;
}
}
else
{
v12 = (*((_BYTE *)&global_transaction_class + 5) & 1) != 0;
}
*(_QWORD *)(a1 + 8) = &global_transaction_class;
*(_DWORD *)a1 = v12;
*(_BYTE *)(a1 + 49) = a6;
*(_BYTE *)(a1 + 48) = a5;
*(_QWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
return a1;
}
return 0LL;
}
|
pfs_get_thread_transaction_locker_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV dword ptr [RBP + -0x70],R8D
MOV EAX,ECX
MOV ECX,dword ptr [RBP + -0x70]
MOV dword ptr [RBP + -0x6c],EAX
MOV RAX,RDX
MOV EDX,dword ptr [RBP + -0x6c]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,RSI
MOV RSI,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x60],RAX
MOV R8,RDI
MOV RDI,qword ptr [RBP + -0x60]
MOV AL,R9B
MOV qword ptr [RBP + -0x10],R8
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV dword ptr [RBP + -0x24],EDX
MOV byte ptr [RBP + -0x25],CL
MOV byte ptr [RBP + -0x26],AL
LEA RAX,[0x50df80]
TEST byte ptr [RAX],0x1
JNZ 0x0014c651
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014c901
LAB_0014c651:
LEA RAX,[0x50a740]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x0014c66b
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014c901
LAB_0014c66b:
LEA RAX,[0x50dfc0]
TEST byte ptr [RAX],0x1
JZ 0x0014c88a
CALL 0x00145700
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014c6a3
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014c901
LAB_0014c6a3:
MOV RAX,qword ptr [RBP + -0x38]
TEST byte ptr [RAX + 0x7e0],0x1
JNZ 0x0014c6bd
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014c901
LAB_0014c6bd:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV dword ptr [RBP + -0x2c],0x2
LEA RAX,[0x50a740]
TEST byte ptr [RAX + 0x5],0x1
JZ 0x0014c6e6
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
LAB_0014c6e6:
LEA RAX,[0x50dcc0]
TEST byte ptr [RAX],0x1
JZ 0x0014c888
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RCX + 0x7f8]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RCX + 0x7f8],RDX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x14c8
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RAX + 0x850]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x18],0x1
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0x50a740]
MOV qword ptr [RAX + 0x30],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x40],0x0
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0014c79d
MOV RSI,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x80
MOV EDX,0x98
CALL 0x00126280
LAB_0014c79d:
MOV RAX,qword ptr [RBP + -0x48]
MOV byte ptr [RAX + 0x78],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x118],0xffffffff
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x58],RCX
MOV ECX,dword ptr [RBP + -0x24]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x11c],ECX
MOV CL,byte ptr [RBP + -0x25]
MOV RAX,qword ptr [RBP + -0x48]
MOV byte ptr [RAX + 0x120],CL
MOV CL,byte ptr [RBP + -0x26]
MOV RAX,qword ptr [RBP + -0x48]
MOV byte ptr [RAX + 0x121],CL
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x128],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x130],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x138],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x14b8]
MOV dword ptr [RBP + -0x4c],EAX
CMP dword ptr [RBP + -0x4c],0x0
JBE 0x0014c867
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x14c0]
MOV ECX,dword ptr [RBP + -0x4c]
SUB ECX,0x1
MOV ECX,ECX
IMUL RCX,RCX,0x590
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x28],ECX
JMP 0x0014c873
LAB_0014c867:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x20],0x0
LAB_0014c873:
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
MOV EAX,dword ptr [RBP + -0x2c]
OR EAX,0x4
MOV dword ptr [RBP + -0x2c],EAX
LAB_0014c888:
JMP 0x0014c8a9
LAB_0014c88a:
LEA RAX,[0x50a740]
TEST byte ptr [RAX + 0x5],0x1
JZ 0x0014c8a0
MOV dword ptr [RBP + -0x2c],0x1
JMP 0x0014c8a7
LAB_0014c8a0:
MOV dword ptr [RBP + -0x2c],0x0
LAB_0014c8a7:
JMP 0x0014c8a9
LAB_0014c8a9:
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x50a740]
MOV qword ptr [RAX + 0x8],RCX
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV CL,byte ptr [RBP + -0x26]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x31],CL
MOV CL,byte ptr [RBP + -0x25]
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x50],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x8],RAX
LAB_0014c901:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x70
POP RBP
RET
|
uint * pfs_get_thread_transaction_locker_v1
(uint *param_1,void *param_2,int8 param_3,int4 param_4,
int1 param_5,int1 param_6)
{
long lVar1;
long lVar2;
uint local_34;
uint *local_10;
if ((flag_global_instrumentation & 1) == 0) {
local_10 = (uint *)0x0;
}
else if ((global_transaction_class[4] & 1) == 0) {
local_10 = (uint *)0x0;
}
else {
if ((flag_thread_instrumentation & 1) == 0) {
local_34 = (uint)((global_transaction_class[5] & 1) != 0);
}
else {
lVar1 = my_thread_get_THR_PFS();
if (lVar1 == 0) {
return (uint *)0x0;
}
if ((*(byte *)(lVar1 + 0x7e0) & 1) == 0) {
return (uint *)0x0;
}
*(long *)(param_1 + 4) = lVar1;
local_34 = 2;
if ((global_transaction_class[5] & 1) != 0) {
local_34 = 3;
}
if ((flag_events_transactions_current & 1) != 0) {
lVar2 = *(long *)(lVar1 + 0x7f8);
*(long *)(lVar1 + 0x7f8) = lVar2 + 1;
*(int8 *)(lVar1 + 0x14c8) = *(int8 *)(lVar1 + 0x850);
*(long *)(lVar1 + 0x14d0) = lVar2;
*(int4 *)(lVar1 + 0x14e0) = 1;
*(int8 *)(lVar1 + 0x14d8) = 0;
*(int1 **)(lVar1 + 0x14f8) = global_transaction_class;
*(int8 *)(lVar1 + 0x1500) = 0;
*(int8 *)(lVar1 + 0x1508) = 0;
if (param_2 != (void *)0x0) {
memcpy((void *)(lVar1 + 0x1548),param_2,0x98);
}
*(int1 *)(lVar1 + 0x1540) = 0;
*(int4 *)(lVar1 + 0x15e0) = 0xffffffff;
*(int8 *)(lVar1 + 0x1520) = param_3;
*(int4 *)(lVar1 + 0x15e4) = param_4;
*(int1 *)(lVar1 + 0x15e8) = param_5;
*(int1 *)(lVar1 + 0x15e9) = param_6;
*(int8 *)(lVar1 + 0x15f0) = 0;
*(int8 *)(lVar1 + 0x15f8) = 0;
*(int8 *)(lVar1 + 0x1600) = 0;
if (*(int *)(lVar1 + 0x14b8) == 0) {
*(int8 *)(lVar1 + 0x14e8) = 0;
}
else {
lVar2 = *(long *)(lVar1 + 0x14c0) + (ulong)(*(int *)(lVar1 + 0x14b8) - 1) * 0x590;
*(int8 *)(lVar1 + 0x14e8) = *(int8 *)(lVar2 + 8);
*(int4 *)(lVar1 + 0x14f0) = *(int4 *)(lVar2 + 0x18);
}
*(int8 **)(param_1 + 10) = (int8 *)(lVar1 + 0x14c8);
local_34 = local_34 | 4;
}
}
*(int1 **)(param_1 + 2) = global_transaction_class;
*param_1 = local_34;
*(int1 *)((long)param_1 + 0x31) = param_6;
*(int1 *)(param_1 + 0xc) = param_5;
param_1[0x10] = 0;
param_1[0x11] = 0;
param_1[0x12] = 0;
param_1[0x13] = 0;
param_1[0x14] = 0;
param_1[0x15] = 0;
local_10 = param_1;
}
return local_10;
}
|
|
57,666
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int)
|
hkr04[P]cpp-mcp/common/json.hpp
|
inline char* format_buffer(char* buf, int len, int decimal_exponent,
int min_exp, int max_exp)
{
JSON_ASSERT(min_exp < 0);
JSON_ASSERT(max_exp > 0);
const int k = len;
const int n = len + decimal_exponent;
// v = buf * 10^(n-k)
// k is the length of the buffer (number of decimal digits)
// n is the position of the decimal point relative to the start of the buffer.
if (k <= n && n <= max_exp)
{
// digits[000]
// len <= max_exp + 2
std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
// Make it look like a floating-point number (#362, #378)
buf[n + 0] = '.';
buf[n + 1] = '0';
return buf + (static_cast<size_t>(n) + 2);
}
if (0 < n && n <= max_exp)
{
// dig.its
// len <= max_digits10 + 1
JSON_ASSERT(k > n);
std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
buf[n] = '.';
return buf + (static_cast<size_t>(k) + 1U);
}
if (min_exp < n && n <= 0)
{
// 0.[000]digits
// len <= 2 + (-min_exp - 1) + max_digits10
std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
buf[0] = '0';
buf[1] = '.';
std::memset(buf + 2, '0', static_cast<size_t>(-n));
return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
}
if (k == 1)
{
// dE+123
// len <= 1 + 5
buf += 1;
}
else
{
// d.igitsE+123
// len <= max_digits10 + 1 + 5
std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
buf[1] = '.';
buf += 1 + static_cast<size_t>(k);
}
*buf++ = 'e';
return append_exponent(buf, n - 1);
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal (%rdx,%rsi), %r14d
testl %edx, %edx
sets %al
cmpl %r8d, %r14d
setg %dl
orb %al, %dl
je 0xa500
cmpl %r8d, %r14d
setg %al
testl %r14d, %r14d
setle %dl
orb %al, %dl
je 0xa529
testl %r14d, %r14d
setg %al
cmpl %ecx, %r14d
setle %cl
orb %al, %cl
jne 0xa565
negl %r14d
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movslq %esi, %r12
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x56b0
movw $0x2e30, (%rbx) # imm = 0x2E30
addq $0x2, %rbx
pushq $0x30
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5260
addq %r12, %r15
jmp 0xa556
movslq %esi, %rax
leaq (%rbx,%rax), %rdi
movslq %r14d, %r14
movq %r14, %rdx
subq %rax, %rdx
pushq $0x30
popq %rsi
callq 0x5260
leaq (%rbx,%r14), %r15
addq $0x2, %r15
movw $0x302e, -0x2(%r15) # imm = 0x302E
jmp 0xa556
movl %r14d, %ecx
leaq (%rbx,%rcx), %rax
leaq (%rbx,%rcx), %r14
incq %r14
movslq %esi, %r15
movq %r15, %rdx
subq %rcx, %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x56b0
movb $0x2e, -0x1(%r14)
addq %rbx, %r15
incq %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x1, %esi
je 0xa588
leaq 0x2(%rbx), %rdi
leaq 0x1(%rbx), %rax
movslq %esi, %r15
leaq -0x1(%r15), %rdx
movq %rax, %rsi
callq 0x56b0
movb $0x2e, 0x1(%rbx)
addq %r15, %rbx
movb $0x65, 0x1(%rbx)
addq $0x2, %rbx
decl %r14d
movq %rbx, %rdi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xaa17
|
_ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl13format_bufferEPciiii:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
lea r14d, [rdx+rsi]
test edx, edx
sets al
cmp r14d, r8d
setnle dl
or dl, al
jz short loc_A500
cmp r14d, r8d
setnle al
test r14d, r14d
setle dl
or dl, al
jz short loc_A529
test r14d, r14d
setnle al
cmp r14d, ecx
setle cl
or cl, al
jnz loc_A565
neg r14d
lea r15, [rbx+r14]
add r15, 2
movsxd r12, esi
mov rdi, r15
mov rsi, rbx
mov rdx, r12
call _memmove
mov word ptr [rbx], 2E30h
add rbx, 2
push 30h ; '0'
pop rsi
mov rdi, rbx
mov rdx, r14
call _memset
add r15, r12
jmp short loc_A556
loc_A500:
movsxd rax, esi
lea rdi, [rbx+rax]
movsxd r14, r14d
mov rdx, r14
sub rdx, rax
push 30h ; '0'
pop rsi
call _memset
lea r15, [rbx+r14]
add r15, 2
mov word ptr [r15-2], 302Eh
jmp short loc_A556
loc_A529:
mov ecx, r14d
lea rax, [rbx+rcx]
lea r14, [rbx+rcx]
inc r14
movsxd r15, esi
mov rdx, r15
sub rdx, rcx
mov rdi, r14
mov rsi, rax
call _memmove
mov byte ptr [r14-1], 2Eh ; '.'
add r15, rbx
inc r15
loc_A556:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_A565:
cmp esi, 1
jz short loc_A588
lea rdi, [rbx+2]
lea rax, [rbx+1]
movsxd r15, esi
lea rdx, [r15-1]
mov rsi, rax
call _memmove
mov byte ptr [rbx+1], 2Eh ; '.'
add rbx, r15
loc_A588:
mov byte ptr [rbx+1], 65h ; 'e'
add rbx, 2
dec r14d
mov rdi, rbx; this
mov esi, r14d; char *
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl15append_exponentEPci; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(char *,int)
|
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
char *a2,
int a3,
int a4,
int a5)
{
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *v5; // rbx
int v6; // r14d
long long v7; // r14
char *v8; // r15
long long v9; // rcx
char *v10; // r14
v5 = this;
v6 = a3 + (_DWORD)a2;
if ( a3 >= 0 && a3 + (int)a2 <= a5 )
{
memset((char *)this + (int)a2, 48LL, v6 - (long long)(int)a2);
v8 = (char *)this + v6 + 2;
*(_WORD *)((char *)this + v6) = 12334;
return v8;
}
LOBYTE(a3) = v6 > a5 || v6 <= 0;
if ( !(_BYTE)a3 )
{
v9 = (unsigned int)v6;
v10 = (char *)this + (unsigned int)v6 + 1;
memmove(v10, (char *)this + v9, (int)a2 - v9);
*(v10 - 1) = 46;
return (char *)this + (int)a2 + 1;
}
if ( v6 <= 0 && v6 > a4 )
{
v7 = (unsigned int)-v6;
memmove((char *)this + v7 + 2, this, (int)a2);
*(_WORD *)this = 11824;
memset((char *)this + 2, 48LL, v7);
return (char *)this + v7 + (int)a2 + 2;
}
if ( (_DWORD)a2 != 1 )
{
memmove((char *)this + 2, (char *)this + 1, (int)a2 - 1LL);
*((_BYTE *)this + 1) = 46;
v5 = (nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)((char *)this + (int)a2);
}
*((_BYTE *)v5 + 1) = 101;
return (char *)nlohmann::json_abi_v3_11_3::detail::dtoa_impl::append_exponent(
(nlohmann::json_abi_v3_11_3::detail::dtoa_impl *)((char *)v5 + 2),
(char *)(unsigned int)(v6 - 1),
a3);
}
|
format_buffer:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R14D,[RDX + RSI*0x1]
TEST EDX,EDX
SETS AL
CMP R14D,R8D
SETG DL
OR DL,AL
JZ 0x0010a500
CMP R14D,R8D
SETG AL
TEST R14D,R14D
SETLE DL
OR DL,AL
JZ 0x0010a529
TEST R14D,R14D
SETG AL
CMP R14D,ECX
SETLE CL
OR CL,AL
JNZ 0x0010a565
NEG R14D
LEA R15,[RBX + R14*0x1]
ADD R15,0x2
MOVSXD R12,ESI
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
CALL 0x001056b0
MOV word ptr [RBX],0x2e30
ADD RBX,0x2
PUSH 0x30
POP RSI
MOV RDI,RBX
MOV RDX,R14
CALL 0x00105260
ADD R15,R12
JMP 0x0010a556
LAB_0010a500:
MOVSXD RAX,ESI
LEA RDI,[RBX + RAX*0x1]
MOVSXD R14,R14D
MOV RDX,R14
SUB RDX,RAX
PUSH 0x30
POP RSI
CALL 0x00105260
LEA R15,[RBX + R14*0x1]
ADD R15,0x2
MOV word ptr [R15 + -0x2],0x302e
JMP 0x0010a556
LAB_0010a529:
MOV ECX,R14D
LEA RAX,[RBX + RCX*0x1]
LEA R14,[RBX + RCX*0x1]
INC R14
MOVSXD R15,ESI
MOV RDX,R15
SUB RDX,RCX
MOV RDI,R14
MOV RSI,RAX
CALL 0x001056b0
MOV byte ptr [R14 + -0x1],0x2e
ADD R15,RBX
INC R15
LAB_0010a556:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0010a565:
CMP ESI,0x1
JZ 0x0010a588
LEA RDI,[RBX + 0x2]
LEA RAX,[RBX + 0x1]
MOVSXD R15,ESI
LEA RDX,[R15 + -0x1]
MOV RSI,RAX
CALL 0x001056b0
MOV byte ptr [RBX + 0x1],0x2e
ADD RBX,R15
LAB_0010a588:
MOV byte ptr [RBX + 0x1],0x65
ADD RBX,0x2
DEC R14D
MOV RDI,RBX
MOV ESI,R14D
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x0010aa17
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer(char*, int, int, int, int) */
char * nlohmann::json_abi_v3_11_3::detail::dtoa_impl::format_buffer
(char *param_1,int param_2,int param_3,int param_4,int param_5)
{
char *pcVar1;
ulong uVar2;
uint uVar3;
char *pcVar4;
uVar3 = param_3 + param_2;
if (param_5 < (int)uVar3 || param_3 < 0) {
if ((int)uVar3 < 1 || param_5 < (int)uVar3) {
if ((int)uVar3 <= param_4 || 0 < (int)uVar3) {
if (param_2 != 1) {
memmove(param_1 + 2,param_1 + 1,(long)param_2 - 1);
param_1[1] = '.';
param_1 = param_1 + param_2;
}
param_1[1] = 'e';
pcVar1 = (char *)append_exponent(param_1 + 2,uVar3 - 1);
return pcVar1;
}
memmove(param_1 + (ulong)-uVar3 + 2,param_1,(long)param_2);
param_1[0] = '0';
param_1[1] = '.';
memset(param_1 + 2,0x30,(ulong)-uVar3);
pcVar4 = param_1 + (ulong)-uVar3 + 2 + param_2;
}
else {
uVar2 = (ulong)uVar3;
memmove(param_1 + uVar2 + 1,param_1 + uVar2,(long)param_2 - uVar2);
param_1[uVar2] = '.';
pcVar4 = param_1 + (long)param_2 + 1;
}
}
else {
memset(param_1 + param_2,0x30,(long)(int)uVar3 - (long)param_2);
pcVar1 = param_1 + (int)uVar3;
pcVar4 = pcVar1 + 2;
pcVar1[0] = '.';
pcVar1[1] = '0';
}
return pcVar4;
}
|
|
57,667
|
my_charpos_utf16
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_charpos_utf16(CHARSET_INFO *cs,
const char *b, const char *e, size_t pos)
{
const char *b0= b;
uint charlen;
for ( ; pos; b+= charlen, pos--)
{
if (!(charlen= my_ismbchar(cs, b, e)))
return (e + 2 - b0); /* Error, return pos outside the string */
}
return (size_t) (pos ? (e + 2 - b0) : (b - b0));
}
|
O3
|
c
|
my_charpos_utf16:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %r12
testq %rcx, %rcx
je 0xc5ce5
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r13
movq %rbx, %r12
movq 0xb8(%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
cmpl $0x1, %eax
jle 0xc5cde
movl %eax, %eax
addq %rax, %r12
decq %r15
jne 0xc5cb7
jmp 0xc5ce5
addq $0x2, %r14
movq %r14, %r12
subq %rbx, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_charpos_utf16:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r12, rsi
test rcx, rcx
jz short loc_C5CE5
mov r15, rcx
mov r14, rdx
mov r13, rdi
mov r12, rbx
loc_C5CB7:
mov rax, [r13+0B8h]
mov rdi, r13
mov rsi, r12
mov rdx, r14
call qword ptr [rax+0C0h]
cmp eax, 1
jle short loc_C5CDE
mov eax, eax
add r12, rax
dec r15
jnz short loc_C5CB7
jmp short loc_C5CE5
loc_C5CDE:
add r14, 2
mov r12, r14
loc_C5CE5:
sub r12, rbx
mov rax, r12
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_charpos_utf16(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // r12
long long v5; // r15
int v7; // eax
v4 = a2;
if ( a4 )
{
v5 = a4;
v4 = a2;
while ( 1 )
{
v7 = (*(long long ( **)(long long, long long, long long))(*(_QWORD *)(a1 + 184) + 192LL))(a1, v4, a3);
if ( v7 <= 1 )
break;
v4 += (unsigned int)v7;
if ( !--v5 )
return v4 - a2;
}
v4 = a3 + 2;
}
return v4 - a2;
}
|
my_charpos_utf16:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R12,RSI
TEST RCX,RCX
JZ 0x001c5ce5
MOV R15,RCX
MOV R14,RDX
MOV R13,RDI
MOV R12,RBX
LAB_001c5cb7:
MOV RAX,qword ptr [R13 + 0xb8]
MOV RDI,R13
MOV RSI,R12
MOV RDX,R14
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x1
JLE 0x001c5cde
MOV EAX,EAX
ADD R12,RAX
DEC R15
JNZ 0x001c5cb7
JMP 0x001c5ce5
LAB_001c5cde:
ADD R14,0x2
MOV R12,R14
LAB_001c5ce5:
SUB R12,RBX
MOV RAX,R12
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_charpos_utf16(long param_1,long param_2,long param_3,long param_4)
{
uint uVar1;
long lVar2;
lVar2 = param_2;
if (param_4 != 0) {
do {
uVar1 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xc0))(param_1,lVar2,param_3);
if ((int)uVar1 < 2) {
lVar2 = param_3 + 2;
break;
}
lVar2 = lVar2 + (ulong)uVar1;
param_4 = param_4 + -1;
} while (param_4 != 0);
}
return lVar2 - param_2;
}
|
|
57,668
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&)
|
monkey531[P]llama/common/chat.cpp
|
static common_chat_params common_chat_params_init_deepseek_r1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
std::string name = function["name"];
auto parameters = function["parameters"];
auto args_rule = builder.add_schema(name + "-args", parameters);
tool_rules.push_back(builder.add_rule(name + "-call",
"\"<｜tool▁call▁begin｜>function<｜tool▁sep｜>" + name + "\\n```json\\n\" " + args_rule + " \"```<｜tool▁call▁end｜>\""));
});
data.grammar_triggers.push_back({"<｜tool▁calls▁begin｜>", /* .at_start = */ false});
data.preserved_tokens = {
"<｜tool▁sep｜>",
"<｜tool▁call▁end｜>",
};
builder.add_rule("root", "\"<｜tool▁calls▁begin｜>\" (" + string_join(tool_rules, " | ") + ")" + (inputs.parallel_tool_calls ? "*" : "") + " space");
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_CHAT_FORMAT_DEEPSEEK_R1;
return data;
}
|
O0
|
cpp
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&):
subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movb $0x0, 0xff(%rsp)
callq 0x1fea30
movq 0x100(%rsp), %rdi
addq $0x20, %rdi
leaq 0x43c50(%rip), %rsi # 0x212fbc
callq 0x164bb0
movq 0x38(%rsp), %rdi
movb %al, 0x38(%rdi)
movq 0x100(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq %rdi, 0xb0(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0xa8(%rsp), %rsi
callq 0x1e4ae0
movq 0x40(%rsp), %rsi
leaq 0x4ab01(%rip), %rdx # 0x219eb8
leaq 0xd8(%rsp), %rdi
callq 0x19f670
jmp 0x1cf3c6
movq 0x38(%rsp), %rdi
addq $0x18, %rdi
leaq 0xd8(%rsp), %rsi
callq 0x5a960
leaq 0xd8(%rsp), %rdi
callq 0x5b578
leaq 0xb8(%rsp), %rdi
callq 0x1a4640
movq 0x108(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rdi
addq $0x10, %rdi
callq 0x117710
testb $0x1, %al
jne 0x1cf427
jmp 0x1cf437
leaq 0x58(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2750
jmp 0x1cf451
movq 0x100(%rsp), %rsi
addq $0x10, %rsi
leaq 0x58(%rsp), %rdi
callq 0xb3070
jmp 0x1cf44f
jmp 0x1cf451
movq 0x100(%rsp), %rax
movzbl 0x68(%rax), %eax
movl %eax, 0x14(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xa2750
movl 0x14(%rsp), %r8d
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %r9
movq %rsp, %rax
movl $0x1, (%rax)
andl $0x1, %r8d
leaq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rcx
callq 0x15f7a0
jmp 0x1cf4a6
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x107b70
jmp 0x1cf4ba
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
leaq 0x88(%rsp), %rsi
callq 0xab8f0
leaq 0x88(%rsp), %rdi
callq 0xa2710
leaq 0x68(%rsp), %rdi
callq 0x5b578
leaq 0x48(%rsp), %rdi
callq 0xa2710
leaq 0x58(%rsp), %rdi
callq 0xa2710
movq 0x38(%rsp), %rax
movl $0x5, (%rax)
movb $0x1, 0xff(%rsp)
testb $0x1, 0xff(%rsp)
jne 0x1cf5ae
jmp 0x1cf5a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x1a4640
jmp 0x1cf5bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1cf5bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x1cf58e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x5b578
leaq 0x48(%rsp), %rdi
callq 0xa2710
leaq 0x58(%rsp), %rdi
callq 0xa2710
jmp 0x1cf5bb
movq 0x38(%rsp), %rdi
callq 0x104060
movq 0x30(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
movq 0x38(%rsp), %rdi
callq 0x104060
movq 0xa0(%rsp), %rdi
callq 0x5abd0
nopw %cs:(%rax,%rax)
|
_ZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputs:
sub rsp, 118h
mov [rsp+118h+var_E0], rdi
mov rax, rdi
mov [rsp+118h+var_E8], rax
mov [rsp+118h+var_8], rdi
mov [rsp+118h+var_10], rsi
mov [rsp+118h+var_18], rdx
mov [rsp+118h+var_19], 0
call _ZN18common_chat_paramsC2Ev; common_chat_params::common_chat_params(void)
mov rdi, [rsp+118h+var_18]
add rdi, 20h ; ' '
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov rdi, [rsp+118h+var_E0]
mov [rdi+38h], al
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_70], rax
mov [rsp+118h+var_68], rdi
lea rdi, [rsp+118h+var_60]
mov [rsp+118h+var_D8], rdi
lea rsi, [rsp+118h+var_70]
call _ZNSt8functionIFvRK22common_grammar_builderEEC2IZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0vEEOT_; std::function<void ()(common_grammar_builder const&)>::function<common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0,void>(common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0 &&)
mov rsi, [rsp+118h+var_D8]
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+118h+var_40]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
jmp short $+2
loc_1CF3C6:
mov rdi, [rsp+118h+var_E0]
add rdi, 18h
lea rsi, [rsp+118h+var_40]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
lea rdi, [rsp+118h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_60]
call _ZNSt8functionIFvRK22common_grammar_builderEED2Ev; std::function<void ()(common_grammar_builder const&)>::~function()
mov rax, [rsp+118h+var_10]
mov [rsp+118h+var_F8], rax
mov rax, [rsp+118h+var_18]
mov [rsp+118h+var_F0], rax
mov rdi, [rsp+118h+var_18]
add rdi, 10h
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv; 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>::empty(void)
test al, 1
jnz short loc_1CF427
jmp short loc_1CF437
loc_1CF427:
lea rdi, [rsp+118h+var_C0]
xor eax, eax
mov esi, eax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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>::basic_json(decltype(nullptr))
jmp short loc_1CF451
loc_1CF437:
mov rsi, [rsp+118h+var_18]
add rsi, 10h
lea rdi, [rsp+118h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short $+2
loc_1CF44F:
jmp short $+2
loc_1CF451:
mov rax, [rsp+118h+var_18]
movzx eax, byte ptr [rax+68h]
mov [rsp+118h+var_104], eax
xor eax, eax
mov esi, eax
lea rdi, [rsp+118h+var_D0]
mov [rsp+118h+var_100], rdi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; 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>::basic_json(decltype(nullptr))
mov r8d, [rsp+118h+var_104]
mov rsi, [rsp+118h+var_F8]
mov rdx, [rsp+118h+var_F0]
mov r9, [rsp+118h+var_100]
mov rax, rsp
mov dword ptr [rax], 1
and r8d, 1
lea rdi, [rsp+118h+var_B0]
lea rcx, [rsp+118h+var_C0]
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
jmp short $+2
loc_1CF4A6:
lea rdi, [rsp+118h+var_90]
lea rsi, [rsp+118h+var_B0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
jmp short $+2
loc_1CF4BA:
mov rdi, [rsp+118h+var_E0]
add rdi, 8
lea rsi, [rsp+118h+var_90]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; 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::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
lea rdi, [rsp+118h+var_90]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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>::~basic_json()
lea rdi, [rsp+118h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rsp+118h+var_D0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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>::~basic_json()
lea rdi, [rsp+118h+var_C0]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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>::~basic_json()
mov rax, [rsp+118h+var_E0]
mov dword ptr [rax], 5
mov [rsp+118h+var_19], 1
test [rsp+118h+var_19], 1
jnz loc_1CF5AE
jmp loc_1CF5A4
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_B0]
call _ZNSt8functionIFvRK22common_grammar_builderEED2Ev; std::function<void ()(common_grammar_builder const&)>::~function()
jmp short loc_1CF5BB
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_1CF5BB
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
jmp short loc_1CF58E
mov rcx, rax
mov eax, edx
mov [rsp+arg_98], rcx
mov [rsp+arg_94], eax
lea rdi, [rsp+arg_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_1CF58E:
lea rdi, [rsp+arg_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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>::~basic_json()
lea rdi, [rsp+arg_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; 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>::~basic_json()
jmp short loc_1CF5BB
loc_1CF5A4:
mov rdi, [rsp+118h+var_E0]; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
loc_1CF5AE:
mov rax, [rsp+118h+var_E8]
add rsp, 118h
retn
loc_1CF5BB:
mov rdi, [rsp+arg_30]; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, [rsp+arg_98]
call __Unwind_Resume
|
const minja::chat_template * common_chat_params_init_deepseek_r1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
char v8; // [rsp+14h] [rbp-104h]
const common_chat_inputs *v9; // [rsp+20h] [rbp-F8h]
long long v10; // [rsp+28h] [rbp-F0h]
_BYTE v11[16]; // [rsp+48h] [rbp-D0h] BYREF
_BYTE v12[16]; // [rsp+58h] [rbp-C0h] BYREF
_BYTE v13[32]; // [rsp+68h] [rbp-B0h] BYREF
_BYTE v14[32]; // [rsp+88h] [rbp-90h] BYREF
_QWORD v15[2]; // [rsp+A8h] [rbp-70h] BYREF
_BYTE v16[32]; // [rsp+B8h] [rbp-60h] BYREF
_BYTE v17[40]; // [rsp+D8h] [rbp-40h] BYREF
long long v18; // [rsp+100h] [rbp-18h]
const common_chat_inputs *v19; // [rsp+108h] [rbp-10h]
const minja::chat_template *v20; // [rsp+110h] [rbp-8h]
v20 = a1;
v19 = a2;
v18 = a3;
v17[39] = 0;
common_chat_params::common_chat_params(a1);
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
v18 + 32,
(long long)"required",
v3,
v4,
v5,
v6);
v15[0] = v18;
v15[1] = a1;
std::function<void ()(common_grammar_builder const&)>::function<common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0,void>(
v16,
v15);
build_grammar[abi:cxx11]((long long)v17, (long long)v16, grammar_options);
std::string::operator=((char *)a1 + 24, v17);
std::string::~string(v17);
std::function<void ()(common_grammar_builder const&)>::~function((std::_Function_base *)v16);
v9 = v19;
v10 = v18;
if ( (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>::empty(v18 + 16) & 1) != 0 )
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json((long long)v12);
else
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>::basic_json(
(long long)v12,
v18 + 16);
v8 = *(_BYTE *)(v18 + 104);
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>::basic_json((long long)v11);
minja::chat_template::apply((long long)v13, v9, v10, (long long)v12, v8 & 1, v11, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(
v14,
(long long)v13);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
(long long)a1 + 8,
(long long)v14);
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>::~basic_json((long long)v14);
std::string::~string(v13);
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>::~basic_json((long long)v11);
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>::~basic_json((long long)v12);
*(_DWORD *)a1 = 5;
return a1;
}
| |||
57,669
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&)
|
monkey531[P]llama/common/chat.cpp
|
static common_chat_params common_chat_params_init_deepseek_r1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
std::string name = function["name"];
auto parameters = function["parameters"];
auto args_rule = builder.add_schema(name + "-args", parameters);
tool_rules.push_back(builder.add_rule(name + "-call",
"\"<｜tool▁call▁begin｜>function<｜tool▁sep｜>" + name + "\\n```json\\n\" " + args_rule + " \"```<｜tool▁call▁end｜>\""));
});
data.grammar_triggers.push_back({"<｜tool▁calls▁begin｜>", /* .at_start = */ false});
data.preserved_tokens = {
"<｜tool▁sep｜>",
"<｜tool▁call▁end｜>",
};
builder.add_rule("root", "\"<｜tool▁calls▁begin｜>\" (" + string_join(tool_rules, " | ") + ")" + (inputs.parallel_tool_calls ? "*" : "") + " space");
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_CHAT_FORMAT_DEEPSEEK_R1;
return data;
}
|
O3
|
cpp
|
common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x20(%rdx), %rdi
leaq 0x1dd6e(%rip), %rsi # 0xef625
callq 0xa58af
movb %al, 0x38(%rbx)
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0xc926(%rip), %rax # 0xde1f8
movq %rax, 0x18(%rsi)
leaq 0xcf63(%rip), %rax # 0xde840
movq %rax, 0x10(%rsi)
leaq 0x23c54(%rip), %rdx # 0xf553c
leaq 0x28(%rsp), %rdi
callq 0xbb910
leaq 0x18(%rbx), %rdi
leaq 0x28(%rsp), %r12
movq %r12, %rsi
callq 0x1aab0
movq (%r12), %rdi
leaq 0x38(%rsp), %r12
cmpq %r12, %rdi
je 0xd191e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xd1937
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movzbl 0x10(%r14), %eax
testl %eax, %eax
je 0xd1967
cmpl $0x2, %eax
je 0xd194a
cmpl $0x1, %eax
jne 0xd1957
movq 0x18(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0xd1967
leaq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5e1a6
jmp 0xd1975
movb $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movzbl 0x68(%r14), %r8d
leaq 0x48(%rsp), %r9
movb $0x0, (%r9)
movq $0x0, 0x8(%r9)
movl $0x1, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xa1fce
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x802b0
movb 0x8(%rbx), %al
leaq 0x58(%rsp), %rdi
movb (%rdi), %cl
movb %cl, 0x8(%rbx)
movb %al, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
callq 0x5e672
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd19f1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x48(%rsp), %rdi
callq 0x5e672
leaq 0x8(%rsp), %rdi
callq 0x5e672
movl $0x5, (%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0xd1a6f
jmp 0xd1a7f
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd1a3d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a8e0
jmp 0xd1a3d
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x5e672
leaq 0x8(%rsp), %rdi
callq 0x5e672
jmp 0xd1a6f
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0xd1a6f
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x7ee6e
movq %r14, %rdi
callq 0x1afb0
movq %rax, %rdi
callq 0x222a5
|
_ZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputs:
push r15
push r14
push r12
push rbx
sub rsp, 68h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
xor eax, eax
mov [rdi+8], al
mov [rdi+10h], rax
lea rcx, [rdi+28h]
mov [rdi+18h], rcx
mov [rdi+20h], rax
mov [rdi+28h], al
mov [rdi+38h], al
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+70h], xmm0
mov [rdi+80h], rax
lea rdi, [rdx+20h]
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov [rbx+38h], al
lea rsi, [rsp+88h+var_80]
mov [rsi], r14
mov [rsi+8], rbx
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+88h+var_60]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
lea rdi, [rbx+18h]
lea r12, [rsp+88h+var_60]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea r12, [rsp+88h+var_50]
cmp rdi, r12
jz short loc_D191E
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D191E:
mov rax, [rsp+88h+var_70]
test rax, rax
jz short loc_D1937
lea rdi, [rsp+88h+var_80]
mov rsi, rdi
mov edx, 3
call rax
loc_D1937:
movzx eax, byte ptr [r14+10h]
test eax, eax
jz short loc_D1967
cmp eax, 2
jz short loc_D194A
cmp eax, 1
jnz short loc_D1957
loc_D194A:
mov rax, [r14+18h]
mov rcx, [rax]
cmp rcx, [rax+8]
jz short loc_D1967
loc_D1957:
lea rsi, [r14+10h]
lea rdi, [rsp+88h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
jmp short loc_D1975
loc_D1967:
mov [rsp+88h+var_80], 0
mov [rsp+88h+var_78], 0
loc_D1975:
movzx r8d, byte ptr [r14+68h]
lea r9, [rsp+88h+var_40]
mov byte ptr [r9], 0
mov qword ptr [r9+8], 0
mov [rsp+88h+var_88], 1
lea rdi, [rsp+88h+var_60]
lea rcx, [rsp+88h+var_80]
mov rsi, r15
mov rdx, r14
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
lea rdi, [rsp+88h+var_30]
lea rsi, [rsp+88h+var_60]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
mov al, [rbx+8]
lea rdi, [rsp+88h+var_30]
mov cl, [rdi]
mov [rbx+8], cl
mov [rdi], al
mov rax, [rbx+10h]
mov rcx, [rdi+8]
mov [rbx+10h], rcx
mov [rdi+8], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r12
jz short loc_D19F1
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D19F1:
lea rdi, [rsp+88h+var_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+88h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov dword ptr [rbx], 5
add rsp, 68h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
jmp short loc_D1A6F
jmp short loc_D1A7F
mov r14, rax
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r12
jz short loc_D1A3D
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D1A3D
mov r14, rax
loc_D1A3D:
lea rdi, [rsp+88h+var_40]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
lea rdi, [rsp+88h+var_80]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_D1A6F
mov r14, rax
mov rax, [rsp+88h+var_70]
test rax, rax
jz short loc_D1A6F
lea rdi, [rsp+88h+var_80]
mov rsi, rdi
mov edx, 3
call rax
loc_D1A6F:
mov rdi, rbx; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, r14
call __Unwind_Resume
loc_D1A7F:
mov rdi, rax
call __clang_call_terminate
|
long long common_chat_params_init_deepseek_r1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
long long v4; // rcx
int v5; // r8d
int v6; // r9d
int v7; // eax
int v8; // r8d
char v9; // al
long long v10; // rax
long long result; // rax
long long v12; // [rsp+8h] [rbp-80h] BYREF
const minja::chat_template *v13; // [rsp+10h] [rbp-78h]
long long ( *v14)(); // [rsp+18h] [rbp-70h]
long long ( *v15)(); // [rsp+20h] [rbp-68h]
void *v16[2]; // [rsp+28h] [rbp-60h] BYREF
_QWORD v17[2]; // [rsp+38h] [rbp-50h] BYREF
_BYTE v18[8]; // [rsp+48h] [rbp-40h] BYREF
long long v19; // [rsp+50h] [rbp-38h]
char v20[8]; // [rsp+58h] [rbp-30h] BYREF
long long v21; // [rsp+60h] [rbp-28h]
*(_DWORD *)a1 = 0;
*((_BYTE *)a1 + 8) = 0;
*((_QWORD *)a1 + 2) = 0LL;
*((_QWORD *)a1 + 3) = (char *)a1 + 40;
*((_QWORD *)a1 + 4) = 0LL;
*((_BYTE *)a1 + 40) = 0;
*((_BYTE *)a1 + 56) = 0;
*((_OWORD *)a1 + 4) = 0LL;
*((_OWORD *)a1 + 5) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 7) = 0LL;
*((_QWORD *)a1 + 16) = 0LL;
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
a3 + 32,
(long long)"required");
v12 = a3;
v13 = a1;
v15 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke;
v14 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager;
build_grammar[abi:cxx11]((long long)v16, (long long)&v12, grammar_options, v4, v5, v6);
std::string::operator=((char *)a1 + 24, v16);
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
if ( v14 )
((void ( *)(long long *, long long *, long long))v14)(&v12, &v12, 3LL);
v7 = *(unsigned __int8 *)(a3 + 16);
if ( !*(_BYTE *)(a3 + 16) || (v7 == 2 || v7 == 1) && **(_QWORD **)(a3 + 24) == *(_QWORD *)(*(_QWORD *)(a3 + 24) + 8LL) )
{
LOBYTE(v12) = 0;
v13 = 0LL;
}
else
{
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>::basic_json(
(unsigned __int8 *)&v12,
(unsigned __int8 *)(a3 + 16));
}
v8 = *(unsigned __int8 *)(a3 + 104);
v18[0] = 0;
v19 = 0LL;
minja::chat_template::apply((long long)v16, a2, (unsigned __int8 *)a3, (unsigned __int8 *)&v12, v8, v18, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(v20);
v9 = *((_BYTE *)a1 + 8);
*((_BYTE *)a1 + 8) = v20[0];
v20[0] = v9;
v10 = *((_QWORD *)a1 + 2);
*((_QWORD *)a1 + 2) = v21;
v21 = v10;
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(v20);
if ( v16[0] != v17 )
operator delete(v16[0], v17[0] + 1LL);
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(v18);
result = 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(&v12);
*(_DWORD *)a1 = 5;
return result;
}
|
common_chat_params_init_deepseek_r1:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x8],AL
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RAX
MOV byte ptr [RDI + 0x28],AL
MOV byte ptr [RDI + 0x38],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x70],XMM0
MOV qword ptr [RDI + 0x80],RAX
LEA RDI,[RDX + 0x20]
LEA RSI,[0x1ef625]
CALL 0x001a58af
MOV byte ptr [RBX + 0x38],AL
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],R14
MOV qword ptr [RSI + 0x8],RBX
LEA RAX,[0x1de1f8]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1de840]
MOV qword ptr [RSI + 0x10],RAX
LAB_001d18e1:
LEA RDX,[0x1f553c]
LEA RDI,[RSP + 0x28]
CALL 0x001bb910
LEA RDI,[RBX + 0x18]
LEA R12,[RSP + 0x28]
MOV RSI,R12
CALL 0x0011aab0
MOV RDI,qword ptr [R12]
LEA R12,[RSP + 0x38]
CMP RDI,R12
JZ 0x001d191e
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8e0
LAB_001d191e:
MOV RAX,qword ptr [RSP + 0x18]
TEST RAX,RAX
JZ 0x001d1937
LAB_001d1928:
LEA RDI,[RSP + 0x8]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001d1937:
MOVZX EAX,byte ptr [R14 + 0x10]
TEST EAX,EAX
JZ 0x001d1967
CMP EAX,0x2
JZ 0x001d194a
CMP EAX,0x1
JNZ 0x001d1957
LAB_001d194a:
MOV RAX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
JZ 0x001d1967
LAB_001d1957:
LEA RSI,[R14 + 0x10]
LEA RDI,[RSP + 0x8]
CALL 0x0015e1a6
JMP 0x001d1975
LAB_001d1967:
MOV byte ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x0
LAB_001d1975:
MOVZX R8D,byte ptr [R14 + 0x68]
LEA R9,[RSP + 0x48]
MOV byte ptr [R9],0x0
MOV qword ptr [R9 + 0x8],0x0
LAB_001d198b:
MOV dword ptr [RSP],0x1
LEA RDI,[RSP + 0x28]
LEA RCX,[RSP + 0x8]
MOV RSI,R15
MOV RDX,R14
CALL 0x001a1fce
LAB_001d19a7:
LEA RDI,[RSP + 0x58]
LEA RSI,[RSP + 0x28]
CALL 0x001802b0
MOV AL,byte ptr [RBX + 0x8]
LEA RDI,[RSP + 0x58]
MOV CL,byte ptr [RDI]
MOV byte ptr [RBX + 0x8],CL
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015e672
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x001d19f1
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a8e0
LAB_001d19f1:
LEA RDI,[RSP + 0x48]
CALL 0x0015e672
LEA RDI,[RSP + 0x8]
CALL 0x0015e672
MOV dword ptr [RBX],0x5
ADD RSP,0x68
POP RBX
POP R12
POP R14
POP R15
RET
|
/* common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&) */
void common_chat_params_init_deepseek_r1(chat_template *param_1,common_chat_inputs *param_2)
{
char cVar1;
int8 uVar2;
chat_template cVar3;
ulong in_RDX;
ulong local_80;
chat_template *local_78;
code *local_70;
code *local_68;
long *local_60 [2];
long local_50 [2];
data local_40 [8];
int8 local_38;
chat_template local_30 [8];
int8 local_28;
*(int4 *)param_1 = 0;
param_1[8] = (chat_template)0x0;
*(int8 *)(param_1 + 0x10) = 0;
*(chat_template **)(param_1 + 0x18) = param_1 + 0x28;
*(int8 *)(param_1 + 0x20) = 0;
param_1[0x28] = (chat_template)0x0;
param_1[0x38] = (chat_template)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
*(int8 *)(param_1 + 0x80) = 0;
cVar3 = (chat_template)
_ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(in_RDX + 0x20,"required");
param_1[0x38] = cVar3;
local_68 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_invoke;
local_70 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_manager;
/* try { // try from 001d18e1 to 001d18f1 has its CatchHandler @ 001d1a53 */
local_80 = in_RDX;
local_78 = param_1;
build_grammar_abi_cxx11_((function *)local_60,(common_grammar_options *)&local_80);
std::__cxx11::string::operator=((string *)(param_1 + 0x18),(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_70 != (code *)0x0) {
/* try { // try from 001d1928 to 001d1936 has its CatchHandler @ 001d1a1c */
(*local_70)(&local_80,&local_80,3);
}
cVar1 = *(char *)(in_RDX + 0x10);
if ((cVar1 == '\0') ||
(((cVar1 == '\x02' || (cVar1 == '\x01')) &&
(**(long **)(in_RDX + 0x18) == (*(long **)(in_RDX + 0x18))[1])))) {
local_80 = local_80 & 0xffffffffffffff00;
local_78 = (chat_template *)0x0;
}
else {
/* try { // try from 001d1957 to 001d1964 has its CatchHandler @ 001d1a17 */
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>
::basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)&local_80,(basic_json *)(in_RDX + 0x10));
}
local_40[0] = (data)0x0;
local_38 = 0;
/* try { // try from 001d198b to 001d19a6 has its CatchHandler @ 001d1a3a */
minja::chat_template::apply
((basic_json *)local_60,(basic_json *)param_2,SUB81(in_RDX,0),(basic_json *)&local_80,
*(bool *)(in_RDX + 0x68));
/* try { // try from 001d19a7 to 001d19b5 has its CatchHandler @ 001d1a1e */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_30,local_60);
cVar3 = param_1[8];
param_1[8] = local_30[0];
uVar2 = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 0x10) = local_28;
local_30[0] = cVar3;
local_28 = uVar2;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)local_30);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_80);
*(int4 *)param_1 = 5;
return;
}
|
|
57,670
|
next_name
|
corpus-core[P]colibri-stateless/src/util/json_validate.c
|
static const char* next_name(const char* pos, const char** next, int* len) {
while (*pos && isspace(*pos)) pos++;
const char* start = pos;
while (*pos && isalnum(*pos)) pos++;
*next = pos;
*len = pos - start;
return start;
}
|
O0
|
c
|
next_name:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x22029
callq 0x5090
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x22032
jmp 0x22040
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x21ff4
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x2207b
callq 0x5090
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
testb $0x1, %al
jne 0x22084
jmp 0x22092
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x22048
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
next_name:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
loc_21FF4:
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_21], al
jz short loc_22029
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_8]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
setnz al
mov [rbp+var_21], al
loc_22029:
mov al, [rbp+var_21]
test al, 1
jnz short loc_22032
jmp short loc_22040
loc_22032:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_21FF4
loc_22040:
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_22048:
mov rax, [rbp+var_8]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_22], al
jz short loc_2207B
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_8]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_22], al
loc_2207B:
mov al, [rbp+var_22]
test al, 1
jnz short loc_22084
jmp short loc_22092
loc_22084:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
jmp short loc_22048
loc_22092:
mov rcx, [rbp+var_8]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_8]
mov rcx, [rbp+var_20]
sub rax, rcx
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], ecx
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
|
_BYTE * next_name(_BYTE *a1, _QWORD *a2, _DWORD *a3)
{
bool v4; // [rsp+Eh] [rbp-22h]
bool v5; // [rsp+Fh] [rbp-21h]
_BYTE *v6; // [rsp+10h] [rbp-20h]
while ( 1 )
{
v5 = 0;
if ( *a1 )
v5 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * (char)*a1) & 0x2000) != 0;
if ( !v5 )
break;
++a1;
}
v6 = a1;
while ( 1 )
{
v4 = 0;
if ( *a1 )
v4 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * (char)*a1) & 8) != 0;
if ( !v4 )
break;
++a1;
}
*a2 = a1;
*a3 = (_DWORD)a1 - (_DWORD)v6;
return v6;
}
|
next_name:
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
LAB_00121ff4:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x21],AL
JZ 0x00122029
CALL 0x00105090
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x21],AL
LAB_00122029:
MOV AL,byte ptr [RBP + -0x21]
TEST AL,0x1
JNZ 0x00122032
JMP 0x00122040
LAB_00122032:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00121ff4
LAB_00122040:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_00122048:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x22],AL
JZ 0x0012207b
CALL 0x00105090
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x22],AL
LAB_0012207b:
MOV AL,byte ptr [RBP + -0x22]
TEST AL,0x1
JNZ 0x00122084
JMP 0x00122092
LAB_00122084:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00122048
LAB_00122092:
MOV RCX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
char * next_name(char *param_1,int8 *param_2,int *param_3)
{
char *pcVar1;
ushort **ppuVar2;
bool bVar3;
char *local_10;
local_10 = param_1;
while( true ) {
pcVar1 = local_10;
bVar3 = false;
if (*local_10 != '\0') {
ppuVar2 = __ctype_b_loc();
bVar3 = ((*ppuVar2)[(int)*local_10] & 0x2000) != 0;
}
if (!bVar3) break;
local_10 = local_10 + 1;
}
while( true ) {
bVar3 = false;
if (*local_10 != '\0') {
ppuVar2 = __ctype_b_loc();
bVar3 = ((*ppuVar2)[(int)*local_10] & 8) != 0;
}
if (!bVar3) break;
local_10 = local_10 + 1;
}
*param_2 = local_10;
*param_3 = (int)local_10 - (int)pcVar1;
return pcVar1;
}
|
|
57,671
|
next_name
|
corpus-core[P]colibri-stateless/src/util/json_validate.c
|
static const char* next_name(const char* pos, const char** next, int* len) {
while (*pos && isspace(*pos)) pos++;
const char* start = pos;
while (*pos && isalnum(*pos)) pos++;
*next = pos;
*len = pos - start;
return start;
}
|
O1
|
c
|
next_name:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x18656
callq 0x5090
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x18656
movb 0x1(%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x1863f
movb (%r14), %bpl
movq %r14, %rax
testb %bpl, %bpl
je 0x18682
callq 0x5090
movq (%rax), %rcx
movq %r14, %rax
movsbq %bpl, %rdx
testb $0x8, (%rcx,%rdx,2)
je 0x18682
movb 0x1(%rax), %bpl
incq %rax
testb %bpl, %bpl
jne 0x1866c
movq %rax, (%r15)
subl %r14d, %eax
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
next_name:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov bpl, [rdi]
test bpl, bpl
jz short loc_18656
call ___ctype_b_loc
mov rax, [rax]
loc_1863F:
movsx rcx, bpl
test byte ptr [rax+rcx*2+1], 20h
jz short loc_18656
mov bpl, [r14+1]
inc r14
test bpl, bpl
jnz short loc_1863F
loc_18656:
mov bpl, [r14]
mov rax, r14
test bpl, bpl
jz short loc_18682
call ___ctype_b_loc
mov rcx, [rax]
mov rax, r14
loc_1866C:
movsx rdx, bpl
test byte ptr [rcx+rdx*2], 8
jz short loc_18682
mov bpl, [rax+1]
inc rax
test bpl, bpl
jnz short loc_1866C
loc_18682:
mov [r15], rax
sub eax, r14d
mov [rbx], eax
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
|
_BYTE * next_name(_BYTE *a1, _QWORD *a2, _DWORD *a3)
{
_BYTE *v4; // r14
char v5; // bp
long long v6; // rax
char v7; // bp
_BYTE *v8; // rax
long long v9; // rcx
v4 = a1;
v5 = *a1;
if ( *a1 )
{
v6 = *(_QWORD *)__ctype_b_loc(a1);
do
{
if ( (*(_BYTE *)(v6 + 2LL * v5 + 1) & 0x20) == 0 )
break;
v5 = *++v4;
}
while ( v5 );
}
v7 = *v4;
v8 = v4;
if ( *v4 )
{
v9 = *(_QWORD *)__ctype_b_loc(a1);
v8 = v4;
do
{
if ( (*(_BYTE *)(v9 + 2LL * v7) & 8) == 0 )
break;
v7 = *++v8;
}
while ( v7 );
}
*a2 = v8;
*a3 = (_DWORD)v8 - (_DWORD)v4;
return v4;
}
|
next_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV BPL,byte ptr [RDI]
TEST BPL,BPL
JZ 0x00118656
CALL 0x00105090
MOV RAX,qword ptr [RAX]
LAB_0011863f:
MOVSX RCX,BPL
TEST byte ptr [RAX + RCX*0x2 + 0x1],0x20
JZ 0x00118656
MOV BPL,byte ptr [R14 + 0x1]
INC R14
TEST BPL,BPL
JNZ 0x0011863f
LAB_00118656:
MOV BPL,byte ptr [R14]
MOV RAX,R14
TEST BPL,BPL
JZ 0x00118682
CALL 0x00105090
MOV RCX,qword ptr [RAX]
MOV RAX,R14
LAB_0011866c:
MOVSX RDX,BPL
TEST byte ptr [RCX + RDX*0x2],0x8
JZ 0x00118682
MOV BPL,byte ptr [RAX + 0x1]
INC RAX
TEST BPL,BPL
JNZ 0x0011866c
LAB_00118682:
MOV qword ptr [R15],RAX
SUB EAX,R14D
MOV dword ptr [RBX],EAX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
char * next_name(char *param_1,int8 *param_2,int *param_3)
{
ushort **ppuVar1;
char *pcVar2;
char cVar3;
cVar3 = *param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
do {
if ((*(byte *)((long)*ppuVar1 + (long)cVar3 * 2 + 1) & 0x20) == 0) break;
cVar3 = param_1[1];
param_1 = param_1 + 1;
} while (cVar3 != '\0');
}
cVar3 = *param_1;
pcVar2 = param_1;
if (cVar3 != '\0') {
ppuVar1 = __ctype_b_loc();
do {
if (((*ppuVar1)[cVar3] & 8) == 0) break;
cVar3 = pcVar2[1];
pcVar2 = pcVar2 + 1;
} while (cVar3 != '\0');
}
*param_2 = pcVar2;
*param_3 = (int)pcVar2 - (int)param_1;
return param_1;
}
|
|
57,672
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
{
STBI_FREE(g->out);
STBI_FREE(g->history);
STBI_FREE(g->background);
if (out) STBI_FREE(out);
if (delays && *delays) STBI_FREE(*delays);
return stbi__errpuc("outofmem", "Out of memory");
}
|
O0
|
c
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xb900
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xb900
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xb900
cmpq $0x0, 0x8(%rsp)
je 0x2cdce
movq 0x8(%rsp), %rdi
callq 0xb900
cmpq $0x0, (%rsp)
je 0x2cdeb
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x2cdeb
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xb900
leaq 0x151d6a(%rip), %rdi # 0x17eb5c
callq 0xddd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovneq %rax, %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
|
_ZL28stbi__load_gif_main_outofmemP9stbi__gifPhPPi:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov [rsp+18h+var_18], rdx
mov rax, [rsp+18h+var_8]
mov rdi, [rax+8]
call _free
mov rax, [rsp+18h+var_8]
mov rdi, [rax+18h]
call _free
mov rax, [rsp+18h+var_8]
mov rdi, [rax+10h]
call _free
cmp [rsp+18h+var_10], 0
jz short loc_2CDCE
mov rdi, [rsp+18h+var_10]
call _free
loc_2CDCE:
cmp [rsp+18h+var_18], 0
jz short loc_2CDEB
mov rax, [rsp+18h+var_18]
cmp qword ptr [rax], 0
jz short loc_2CDEB
mov rax, [rsp+18h+var_18]
mov rdi, [rax]
call _free
loc_2CDEB:
lea rdi, aOutofmem; "outofmem"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov ecx, eax
xor eax, eax
cmp ecx, 0
cmovnz rax, rax
add rsp, 18h
retn
|
long long stbi__load_gif_main_outofmem(_QWORD *a1, long long a2, _QWORD *a3)
{
free(a1[1]);
free(a1[3]);
free(a1[2]);
if ( a2 )
free(a2);
if ( a3 && *a3 )
free(*a3);
stbi__err("outofmem");
return 0LL;
}
|
stbi__load_gif_main_outofmem:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP],RDX
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x0010b900
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x0010b900
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0010b900
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0012cdce
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010b900
LAB_0012cdce:
CMP qword ptr [RSP],0x0
JZ 0x0012cdeb
MOV RAX,qword ptr [RSP]
CMP qword ptr [RAX],0x0
JZ 0x0012cdeb
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX]
CALL 0x0010b900
LAB_0012cdeb:
LEA RDI,[0x27eb5c]
CALL 0x0010ddd0
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x0
CMOVNZ RAX,RAX
ADD RSP,0x18
RET
|
/* stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**) */
int8 stbi__load_gif_main_outofmem(stbi__gif *param_1,uchar *param_2,int **param_3)
{
free(*(void **)(param_1 + 8));
free(*(void **)(param_1 + 0x18));
free(*(void **)(param_1 + 0x10));
if (param_2 != (uchar *)0x0) {
free(param_2);
}
if ((param_3 != (int **)0x0) && (*param_3 != (int *)0x0)) {
free(*param_3);
}
stbi__err("outofmem");
return 0;
}
|
|
57,673
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
{
STBI_FREE(g->out);
STBI_FREE(g->history);
STBI_FREE(g->background);
if (out) STBI_FREE(out);
if (delays && *delays) STBI_FREE(*delays);
return stbi__errpuc("outofmem", "Out of memory");
}
|
O1
|
c
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xa700
movq 0x18(%r15), %rdi
callq 0xa700
movq 0x10(%r15), %rdi
callq 0xa700
testq %r14, %r14
je 0x2e248
movq %r14, %rdi
callq 0xa700
testq %rbx, %rbx
je 0x2e25a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2e25a
callq 0xa700
leaq 0x8e586(%rip), %rax # 0xbc7e7
movq %rax, %fs:-0x20
popq %rbx
popq %r14
popq %r15
retq
|
_ZL28stbi__load_gif_main_outofmemP9stbi__gifPhPPi:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdi+8]
call _free
mov rdi, [r15+18h]
call _free
mov rdi, [r15+10h]
call _free
test r14, r14
jz short loc_2E248
mov rdi, r14
call _free
loc_2E248:
test rbx, rbx
jz short loc_2E25A
mov rdi, [rbx]
test rdi, rdi
jz short loc_2E25A
call _free
loc_2E25A:
lea rax, aOutofmem; "outofmem"
mov fs:0FFFFFFFFFFFFFFE0h, rax
pop rbx
pop r14
pop r15
retn
|
const char * stbi__load_gif_main_outofmem(_QWORD *a1, long long a2, _QWORD *a3)
{
const char *result; // rax
free(a1[1]);
free(a1[3]);
free(a1[2]);
if ( a2 )
free(a2);
if ( a3 && *a3 )
free(*a3);
result = "outofmem";
__writefsqword(0xFFFFFFE0, (unsigned long long)"outofmem");
return result;
}
| |||
57,674
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**)
|
7CodeWizard[P]stablediffusion/thirdparty/stb_image.h
|
static void *stbi__load_gif_main_outofmem(stbi__gif *g, stbi_uc *out, int **delays)
{
STBI_FREE(g->out);
STBI_FREE(g->history);
STBI_FREE(g->background);
if (out) STBI_FREE(out);
if (delays && *delays) STBI_FREE(*delays);
return stbi__errpuc("outofmem", "Out of memory");
}
|
O2
|
c
|
stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xa710
movq 0x18(%r15), %rdi
callq 0xa710
movq 0x10(%r15), %rdi
callq 0xa710
movq %r14, %rdi
callq 0xa710
testq %rbx, %rbx
je 0x199af
movq (%rbx), %rdi
callq 0xa710
leaq 0x7ed71(%rip), %rax # 0x98727
movq %rax, %fs:-0x20
popq %rbx
popq %r14
popq %r15
retq
|
_ZL28stbi__load_gif_main_outofmemP9stbi__gifPhPPi:
push r15
push r14
push rbx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdi+8]
call _free
mov rdi, [r15+18h]
call _free
mov rdi, [r15+10h]
call _free
mov rdi, r14
call _free
test rbx, rbx
jz short loc_199AF
mov rdi, [rbx]
call _free
loc_199AF:
lea rax, aOutofmem; "outofmem"
mov fs:0FFFFFFFFFFFFFFE0h, rax
pop rbx
pop r14
pop r15
retn
|
const char * stbi__load_gif_main_outofmem(_QWORD *a1, long long a2, _QWORD *a3)
{
const char *result; // rax
free(a1[1]);
free(a1[3]);
free(a1[2]);
free(a2);
if ( a3 )
free(*a3);
result = "outofmem";
__writefsqword(0xFFFFFFE0, (unsigned long long)"outofmem");
return result;
}
|
stbi__load_gif_main_outofmem:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x8]
CALL 0x0010a710
MOV RDI,qword ptr [R15 + 0x18]
CALL 0x0010a710
MOV RDI,qword ptr [R15 + 0x10]
CALL 0x0010a710
MOV RDI,R14
CALL 0x0010a710
TEST RBX,RBX
JZ 0x001199af
MOV RDI,qword ptr [RBX]
CALL 0x0010a710
LAB_001199af:
LEA RAX,[0x198727]
MOV qword ptr FS:[-0x20],RAX
POP RBX
POP R14
POP R15
RET
|
/* stbi__load_gif_main_outofmem(stbi__gif*, unsigned char*, int**) */
void stbi__load_gif_main_outofmem(stbi__gif *param_1,uchar *param_2,int **param_3)
{
long in_FS_OFFSET;
free(*(void **)(param_1 + 8));
free(*(void **)(param_1 + 0x18));
free(*(void **)(param_1 + 0x10));
free(param_2);
if (param_3 != (int **)0x0) {
free(*param_3);
}
*(char **)(in_FS_OFFSET + -0x20) = "outofmem";
return;
}
|
|
57,675
|
get_index_pos
|
bluesky950520[P]quickjs/libunicode.c
|
static int get_index_pos(uint32_t *pcode, uint32_t c,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, v;
int idx_min, idx_max, idx;
idx_min = 0;
v = get_le24(index_table);
code = v & ((1 << 21) - 1);
if (c < code) {
*pcode = 0;
return 0;
}
idx_max = index_table_len - 1;
code = get_le24(index_table + idx_max * 3);
if (c >= code)
return -1;
/* invariant: tab[idx_min] <= c < tab2[idx_max] */
while ((idx_max - idx_min) > 1) {
idx = (idx_max + idx_min) / 2;
v = get_le24(index_table + idx * 3);
code = v & ((1 << 21) - 1);
if (c < code) {
idx_max = idx;
} else {
idx_min = idx;
}
}
v = get_le24(index_table + idx_min * 3);
*pcode = v & ((1 << 21) - 1);
return (idx_min + 1) * UNICODE_INDEX_BLOCK_LEN + (v >> 21);
}
|
O1
|
c
|
get_index_pos:
movzwl (%rdx), %eax
movzbl 0x2(%rdx), %r8d
andl $0x1f, %r8d
shll $0x10, %r8d
orl %eax, %r8d
cmpl %esi, %r8d
jbe 0x9a578
movl $0x0, (%rdi)
xorl %eax, %eax
retq
leal -0x1(%rcx), %r8d
leaq (%r8,%r8,2), %rax
movzwl (%rdx,%rax), %r9d
movzbl 0x2(%rdx,%rax), %r10d
shll $0x10, %r10d
orl %r9d, %r10d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl %esi, %r10d
jbe 0x9a60d
xorl %eax, %eax
cmpl $0x3, %ecx
jl 0x9a5e7
xorl %eax, %eax
leal (%r8,%rax), %r9d
movl %r9d, %ecx
shrl $0x1f, %ecx
addl %r9d, %ecx
sarl %ecx
movslq %ecx, %r9
leaq (%r9,%r9,2), %r9
movzwl (%rdx,%r9), %r10d
movzbl 0x2(%rdx,%r9), %r9d
andl $0x1f, %r9d
shll $0x10, %r9d
orl %r10d, %r9d
cmpl %esi, %r9d
ja 0x9a5da
movl %ecx, %eax
jmp 0x9a5dd
movl %ecx, %r8d
movl %r8d, %ecx
subl %eax, %ecx
cmpl $0x1, %ecx
jg 0x9a5a5
cltq
leaq (%rax,%rax,2), %rcx
movzwl (%rdx,%rcx), %esi
movzbl 0x2(%rdx,%rcx), %ecx
movl %ecx, %edx
andl $0x1f, %edx
shll $0x10, %edx
orl %esi, %edx
movl %edx, (%rdi)
shll $0x5, %eax
shrl $0x5, %ecx
addl %ecx, %eax
addl $0x20, %eax
retq
|
get_index_pos:
movzx eax, word ptr [rdx]
movzx r8d, byte ptr [rdx+2]
and r8d, 1Fh
shl r8d, 10h
or r8d, eax
cmp r8d, esi
jbe short loc_9A578
mov dword ptr [rdi], 0
xor eax, eax
retn
loc_9A578:
lea r8d, [rcx-1]
lea rax, [r8+r8*2]
movzx r9d, word ptr [rdx+rax]
movzx r10d, byte ptr [rdx+rax+2]
shl r10d, 10h
or r10d, r9d
mov eax, 0FFFFFFFFh
cmp r10d, esi
jbe short locret_9A60D
xor eax, eax
cmp ecx, 3
jl short loc_9A5E7
xor eax, eax
loc_9A5A5:
lea r9d, [r8+rax]
mov ecx, r9d
shr ecx, 1Fh
add ecx, r9d
sar ecx, 1
movsxd r9, ecx
lea r9, [r9+r9*2]
movzx r10d, word ptr [rdx+r9]
movzx r9d, byte ptr [rdx+r9+2]
and r9d, 1Fh
shl r9d, 10h
or r9d, r10d
cmp r9d, esi
ja short loc_9A5DA
mov eax, ecx
jmp short loc_9A5DD
loc_9A5DA:
mov r8d, ecx
loc_9A5DD:
mov ecx, r8d
sub ecx, eax
cmp ecx, 1
jg short loc_9A5A5
loc_9A5E7:
cdqe
lea rcx, [rax+rax*2]
movzx esi, word ptr [rdx+rcx]
movzx ecx, byte ptr [rdx+rcx+2]
mov edx, ecx
and edx, 1Fh
shl edx, 10h
or edx, esi
mov [rdi], edx
shl eax, 5
shr ecx, 5
add eax, ecx
add eax, 20h ; ' '
locret_9A60D:
retn
|
long long get_index_pos(_DWORD *a1, unsigned int a2, unsigned __int16 *a3, int a4)
{
long long result; // rax
long long v5; // r8
int v6; // eax
long long v7; // rcx
int v8; // esi
if ( (*a3 | ((unsigned __int8)(a3[1] & 0x1F) << 16)) <= a2 )
{
v5 = (unsigned int)(a4 - 1);
result = 0xFFFFFFFFLL;
if ( (*(unsigned __int16 *)((char *)a3 + 3 * v5) | (*((unsigned __int8 *)a3 + 3 * v5 + 2) << 16)) > a2 )
{
v6 = 0;
if ( a4 >= 3 )
{
v6 = 0;
do
{
if ( (*(unsigned __int16 *)((char *)a3 + 3 * (((int)v5 + v6) / 2)) | ((unsigned __int8)(*((_BYTE *)a3
+ 3 * (((int)v5 + v6) / 2)
+ 2) & 0x1F) << 16)) > a2 )
LODWORD(v5) = ((int)v5 + v6) / 2;
else
v6 = ((int)v5 + v6) / 2;
}
while ( (int)v5 - v6 > 1 );
}
v7 = 3LL * v6;
v8 = *(unsigned __int16 *)((char *)a3 + v7);
LODWORD(v7) = *((unsigned __int8 *)a3 + v7 + 2);
*a1 = v8 | ((v7 & 0x1F) << 16);
return ((unsigned int)v7 >> 5) + 32 * v6 + 32;
}
}
else
{
*a1 = 0;
return 0LL;
}
return result;
}
|
get_index_pos:
MOVZX EAX,word ptr [RDX]
MOVZX R8D,byte ptr [RDX + 0x2]
AND R8D,0x1f
SHL R8D,0x10
OR R8D,EAX
CMP R8D,ESI
JBE 0x0019a578
MOV dword ptr [RDI],0x0
XOR EAX,EAX
RET
LAB_0019a578:
LEA R8D,[RCX + -0x1]
LEA RAX,[R8 + R8*0x2]
MOVZX R9D,word ptr [RDX + RAX*0x1]
MOVZX R10D,byte ptr [RDX + RAX*0x1 + 0x2]
SHL R10D,0x10
OR R10D,R9D
MOV EAX,0xffffffff
CMP R10D,ESI
JBE 0x0019a60d
XOR EAX,EAX
CMP ECX,0x3
JL 0x0019a5e7
XOR EAX,EAX
LAB_0019a5a5:
LEA R9D,[R8 + RAX*0x1]
MOV ECX,R9D
SHR ECX,0x1f
ADD ECX,R9D
SAR ECX,0x1
MOVSXD R9,ECX
LEA R9,[R9 + R9*0x2]
MOVZX R10D,word ptr [RDX + R9*0x1]
MOVZX R9D,byte ptr [RDX + R9*0x1 + 0x2]
AND R9D,0x1f
SHL R9D,0x10
OR R9D,R10D
CMP R9D,ESI
JA 0x0019a5da
MOV EAX,ECX
JMP 0x0019a5dd
LAB_0019a5da:
MOV R8D,ECX
LAB_0019a5dd:
MOV ECX,R8D
SUB ECX,EAX
CMP ECX,0x1
JG 0x0019a5a5
LAB_0019a5e7:
CDQE
LEA RCX,[RAX + RAX*0x2]
MOVZX ESI,word ptr [RDX + RCX*0x1]
MOVZX ECX,byte ptr [RDX + RCX*0x1 + 0x2]
MOV EDX,ECX
AND EDX,0x1f
SHL EDX,0x10
OR EDX,ESI
MOV dword ptr [RDI],EDX
SHL EAX,0x5
SHR ECX,0x5
ADD EAX,ECX
ADD EAX,0x20
LAB_0019a60d:
RET
|
int get_index_pos(uint *param_1,uint param_2,ushort *param_3,int param_4)
{
byte bVar1;
uint uVar2;
int iVar3;
uint uVar4;
ulong uVar5;
if ((((byte)param_3[1] & 0x1f) << 0x10 | (uint)*param_3) <= param_2) {
uVar5 = (ulong)(param_4 - 1);
iVar3 = -1;
if (param_2 < CONCAT12(*(int1 *)((long)param_3 + uVar5 * 3 + 2),
*(int2 *)((long)param_3 + uVar5 * 3))) {
uVar2 = 0;
if (2 < param_4) {
uVar2 = 0;
do {
uVar4 = (int)((int)uVar5 + uVar2) / 2;
if (param_2 < ((*(byte *)((long)param_3 + (long)(int)uVar4 * 3 + 2) & 0x1f) << 0x10 |
(uint)*(ushort *)((long)param_3 + (long)(int)uVar4 * 3))) {
uVar5 = (ulong)uVar4;
uVar4 = uVar2;
}
uVar2 = uVar4;
} while (1 < (int)((int)uVar5 - uVar2));
}
bVar1 = *(byte *)((long)param_3 + (long)(int)uVar2 * 3 + 2);
*param_1 = (bVar1 & 0x1f) << 0x10 | (uint)*(ushort *)((long)param_3 + (long)(int)uVar2 * 3);
iVar3 = uVar2 * 0x20 + (uint)(bVar1 >> 5) + 0x20;
}
return iVar3;
}
*param_1 = 0;
return 0;
}
|
|
57,676
|
get_index_pos
|
bluesky950520[P]quickjs/libunicode.c
|
static int get_index_pos(uint32_t *pcode, uint32_t c,
const uint8_t *index_table, int index_table_len)
{
uint32_t code, v;
int idx_min, idx_max, idx;
idx_min = 0;
v = get_le24(index_table);
code = v & ((1 << 21) - 1);
if (c < code) {
*pcode = 0;
return 0;
}
idx_max = index_table_len - 1;
code = get_le24(index_table + idx_max * 3);
if (c >= code)
return -1;
/* invariant: tab[idx_min] <= c < tab2[idx_max] */
while ((idx_max - idx_min) > 1) {
idx = (idx_max + idx_min) / 2;
v = get_le24(index_table + idx * 3);
code = v & ((1 << 21) - 1);
if (c < code) {
idx_max = idx;
} else {
idx_min = idx;
}
}
v = get_le24(index_table + idx_min * 3);
*pcode = v & ((1 << 21) - 1);
return (idx_min + 1) * UNICODE_INDEX_BLOCK_LEN + (v >> 21);
}
|
O2
|
c
|
get_index_pos:
movq %rdx, %r8
movzwl (%rdx), %eax
movzbl 0x2(%rdx), %edx
andl $0x1f, %edx
shll $0x10, %edx
orl %eax, %edx
cmpl %esi, %edx
jbe 0x80dc1
andl $0x0, (%rdi)
xorl %eax, %eax
retq
decl %ecx
leaq (%rcx,%rcx,2), %rax
movzwl (%r8,%rax), %edx
movzbl 0x2(%r8,%rax), %eax
shll $0x10, %eax
orl %edx, %eax
cmpl %esi, %eax
jbe 0x80e45
xorl %r9d, %r9d
pushq $0x2
popq %r10
movl %ecx, %eax
subl %r9d, %eax
cmpl $0x2, %eax
jl 0x80e19
leal (%rcx,%r9), %eax
cltd
idivl %r10d
cltq
leaq (%rax,%rax,2), %rdx
movzwl (%r8,%rdx), %r11d
movzbl 0x2(%r8,%rdx), %edx
andl $0x1f, %edx
shll $0x10, %edx
orl %r11d, %edx
cmpl %esi, %edx
cmovbel %eax, %r9d
cmoval %eax, %ecx
jmp 0x80de2
movslq %r9d, %rax
leaq (%rax,%rax,2), %rax
movzwl (%r8,%rax), %ecx
movzbl 0x2(%r8,%rax), %eax
movl %eax, %edx
andl $0x1f, %edx
shll $0x10, %edx
orl %ecx, %edx
movl %edx, (%rdi)
shll $0x5, %r9d
shrl $0x5, %eax
addl %r9d, %eax
addl $0x20, %eax
retq
pushq $-0x1
popq %rax
retq
|
get_index_pos:
mov r8, rdx
movzx eax, word ptr [rdx]
movzx edx, byte ptr [rdx+2]
and edx, 1Fh
shl edx, 10h
or edx, eax
cmp edx, esi
jbe short loc_80DC1
and dword ptr [rdi], 0
xor eax, eax
retn
loc_80DC1:
dec ecx
lea rax, [rcx+rcx*2]
movzx edx, word ptr [r8+rax]
movzx eax, byte ptr [r8+rax+2]
shl eax, 10h
or eax, edx
cmp eax, esi
jbe short loc_80E45
xor r9d, r9d
push 2
pop r10
loc_80DE2:
mov eax, ecx
sub eax, r9d
cmp eax, 2
jl short loc_80E19
lea eax, [rcx+r9]
cdq
idiv r10d
cdqe
lea rdx, [rax+rax*2]
movzx r11d, word ptr [r8+rdx]
movzx edx, byte ptr [r8+rdx+2]
and edx, 1Fh
shl edx, 10h
or edx, r11d
cmp edx, esi
cmovbe r9d, eax
cmova ecx, eax
jmp short loc_80DE2
loc_80E19:
movsxd rax, r9d
lea rax, [rax+rax*2]
movzx ecx, word ptr [r8+rax]
movzx eax, byte ptr [r8+rax+2]
mov edx, eax
and edx, 1Fh
shl edx, 10h
or edx, ecx
mov [rdi], edx
shl r9d, 5
shr eax, 5
add eax, r9d
add eax, 20h ; ' '
retn
loc_80E45:
push 0FFFFFFFFFFFFFFFFh
pop rax
retn
|
long long get_index_pos(_DWORD *a1, unsigned int a2, unsigned __int16 *a3, int a4)
{
long long v5; // rcx
int v6; // r9d
long long v7; // rax
int v8; // ecx
if ( (*a3 | ((unsigned __int8)(a3[1] & 0x1F) << 16)) <= a2 )
{
v5 = (unsigned int)(a4 - 1);
if ( (*(unsigned __int16 *)((char *)a3 + 3 * v5) | (*((unsigned __int8 *)a3 + 3 * v5 + 2) << 16)) <= a2 )
{
return -1LL;
}
else
{
v6 = 0;
while ( (int)v5 - v6 >= 2 )
{
if ( (*(unsigned __int16 *)((char *)a3 + 3 * (((int)v5 + v6) / 2)) | ((unsigned __int8)(*((_BYTE *)a3
+ 3
* (((int)v5 + v6)
/ 2)
+ 2) & 0x1F) << 16)) > a2 )
LODWORD(v5) = ((int)v5 + v6) / 2;
else
v6 = ((int)v5 + v6) / 2;
}
v7 = 3LL * v6;
v8 = *(unsigned __int16 *)((char *)a3 + v7);
LODWORD(v7) = *((unsigned __int8 *)a3 + v7 + 2);
*a1 = v8 | ((v7 & 0x1F) << 16);
return 32 * v6 + ((unsigned int)v7 >> 5) + 32;
}
}
else
{
*a1 = 0;
return 0LL;
}
}
|
get_index_pos:
MOV R8,RDX
MOVZX EAX,word ptr [RDX]
MOVZX EDX,byte ptr [RDX + 0x2]
AND EDX,0x1f
SHL EDX,0x10
OR EDX,EAX
CMP EDX,ESI
JBE 0x00180dc1
AND dword ptr [RDI],0x0
XOR EAX,EAX
RET
LAB_00180dc1:
DEC ECX
LEA RAX,[RCX + RCX*0x2]
MOVZX EDX,word ptr [R8 + RAX*0x1]
MOVZX EAX,byte ptr [R8 + RAX*0x1 + 0x2]
SHL EAX,0x10
OR EAX,EDX
CMP EAX,ESI
JBE 0x00180e45
XOR R9D,R9D
PUSH 0x2
POP R10
LAB_00180de2:
MOV EAX,ECX
SUB EAX,R9D
CMP EAX,0x2
JL 0x00180e19
LEA EAX,[RCX + R9*0x1]
CDQ
IDIV R10D
CDQE
LEA RDX,[RAX + RAX*0x2]
MOVZX R11D,word ptr [R8 + RDX*0x1]
MOVZX EDX,byte ptr [R8 + RDX*0x1 + 0x2]
AND EDX,0x1f
SHL EDX,0x10
OR EDX,R11D
CMP EDX,ESI
CMOVBE R9D,EAX
CMOVA ECX,EAX
JMP 0x00180de2
LAB_00180e19:
MOVSXD RAX,R9D
LEA RAX,[RAX + RAX*0x2]
MOVZX ECX,word ptr [R8 + RAX*0x1]
MOVZX EAX,byte ptr [R8 + RAX*0x1 + 0x2]
MOV EDX,EAX
AND EDX,0x1f
SHL EDX,0x10
OR EDX,ECX
MOV dword ptr [RDI],EDX
SHL R9D,0x5
SHR EAX,0x5
ADD EAX,R9D
ADD EAX,0x20
RET
LAB_00180e45:
PUSH -0x1
POP RAX
RET
|
ulong get_index_pos(uint *param_1,uint param_2,ushort *param_3,int param_4)
{
byte bVar1;
ulong uVar2;
long lVar3;
int iVar4;
ulong uVar5;
int iVar6;
if (param_2 < (((byte)param_3[1] & 0x1f) << 0x10 | (uint)*param_3)) {
*param_1 = 0;
return 0;
}
uVar5 = (ulong)(param_4 - 1);
if (param_2 < CONCAT12(*(int1 *)((long)param_3 + uVar5 * 3 + 2),
*(int2 *)((long)param_3 + uVar5 * 3))) {
iVar4 = 0;
while (iVar6 = iVar4, 1 < (int)uVar5 - iVar6) {
uVar2 = (long)((int)uVar5 + iVar6) / 2;
iVar4 = (int)uVar2;
lVar3 = (long)iVar4 * 3;
if (param_2 < ((*(byte *)((long)param_3 + lVar3 + 2) & 0x1f) << 0x10 |
(uint)*(ushort *)((long)param_3 + lVar3))) {
uVar5 = uVar2 & 0xffffffff;
iVar4 = iVar6;
}
}
bVar1 = *(byte *)((long)param_3 + (long)iVar6 * 3 + 2);
*param_1 = (bVar1 & 0x1f) << 0x10 | (uint)*(ushort *)((long)param_3 + (long)iVar6 * 3);
return (ulong)((uint)(bVar1 >> 5) + iVar6 * 0x20 + 0x20);
}
return 0xffffffffffffffff;
}
|
|
57,677
|
my_strntoull_8bit
|
eloqsql/strings/ctype-simple.c
|
ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
}
|
O3
|
c
|
my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x3c499
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x3c499
incq %r10
cmpq %r11, %r10
jb 0x3c486
cmpq %r11, %r10
je 0x3c581
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0x3c55e
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0x3c50d
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0x3c4fc
addb $-0x37, %r12b
jmp 0x3c50a
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0x3c54c
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0x3c54c
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0x3c524
movq %rdi, %r15
jmp 0x3c53b
jne 0x3c52d
movq %rax, %r15
cmpl %edx, %ebx
ja 0x3c53b
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x3c4d9
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0x3c560
movb $0x1, %al
cmpq %r10, %r11
je 0x3c581
testq %r8, %r8
je 0x3c56d
movq %r11, (%r8)
testb %al, %al
je 0x3c594
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0x3c5a2
movl $0x21, (%r9)
testq %r8, %r8
je 0x3c590
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0x3c5a2
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
my_strntoull_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_3C499
mov rax, [rdi+40h]
mov r10, rsi
loc_3C486:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_3C499
inc r10
cmp r10, r11
jb short loc_3C486
loc_3C499:
cmp r10, r11
jz loc_3C581
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_3C55E
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_3C4D9:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_3C50D
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_3C4FC
add r12b, 0C9h
jmp short loc_3C50A
loc_3C4FC:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_3C54C
add r12b, 0A9h
loc_3C50A:
mov ebx, r12d
loc_3C50D:
movzx ebx, bl
cmp ebx, ecx
jge short loc_3C54C
mov r12d, 1
cmp rdi, rax
jbe short loc_3C524
mov r15, rdi
jmp short loc_3C53B
loc_3C524:
jnz short loc_3C52D
mov r15, rax
cmp ebx, edx
ja short loc_3C53B
loc_3C52D:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_3C53B:
inc r14
cmp r14, r11
jnz short loc_3C4D9
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_3C54C:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_3C560
loc_3C55E:
mov al, 1
loc_3C560:
cmp r11, r10
jz short loc_3C581
test r8, r8
jz short loc_3C56D
mov [r8], r11
loc_3C56D:
test al, al
jz short loc_3C594
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_3C5A2
loc_3C581:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_3C590
mov [r8], rsi
loc_3C590:
xor eax, eax
jmp short loc_3C5A2
loc_3C594:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_3C5A2:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
|
my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x0013c499
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_0013c486:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x0013c499
INC R10
CMP R10,R11
JC 0x0013c486
LAB_0013c499:
CMP R10,R11
JZ 0x0013c581
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x0013c55e
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_0013c4d9:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x0013c50d
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x0013c4fc
ADD R12B,0xc9
JMP 0x0013c50a
LAB_0013c4fc:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x0013c54c
ADD R12B,0xa9
LAB_0013c50a:
MOV EBX,R12D
LAB_0013c50d:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x0013c54c
MOV R12D,0x1
CMP RDI,RAX
JBE 0x0013c524
MOV R15,RDI
JMP 0x0013c53b
LAB_0013c524:
JNZ 0x0013c52d
MOV R15,RAX
CMP EBX,EDX
JA 0x0013c53b
LAB_0013c52d:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_0013c53b:
INC R14
CMP R14,R11
JNZ 0x0013c4d9
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_0013c54c:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x0013c560
LAB_0013c55e:
MOV AL,0x1
LAB_0013c560:
CMP R11,R10
JZ 0x0013c581
TEST R8,R8
JZ 0x0013c56d
MOV qword ptr [R8],R11
LAB_0013c56d:
TEST AL,AL
JZ 0x0013c594
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x0013c5a2
LAB_0013c581:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x0013c590
MOV qword ptr [R8],RSI
LAB_0013c590:
XOR EAX,EAX
JMP 0x0013c5a2
LAB_0013c594:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_0013c5a2:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_0013c54c;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_0013c54c;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_0013c54c:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
|
|
57,678
|
Cache::printInfo(bool)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::printInfo(bool verbose) {
printf("---------- Cache Info -----------\n");
printf("Cache Size: %d bytes\n", this->policy.cacheSize);
printf("Block Size: %d bytes\n", this->policy.blockSize);
printf("Block Num: %d\n", this->policy.blockNum);
printf("Associativiy: %d\n", this->policy.associativity);
printf("Hit Latency: %d\n", this->policy.hitLatency);
printf("Miss Latency: %d\n", this->policy.missLatency);
if (verbose) {
for (int j = 0; j < this->blocks.size(); ++j) {
const Block &b = this->blocks[j];
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n", j, b.tag, b.id,
b.valid ? "valid" : "invalid",
b.modified ? "modified" : "unmodified", b.lastReference);
// printf("Data: ");
// for (uint8_t d : b.data)
// printf("%d ", d);
// printf("\n");
}
}
}
|
O1
|
cpp
|
Cache::printInfo(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xd4e(%rip), %rdi # 0x445f
callq 0x2170
movl 0x30(%rbx), %esi
leaq 0xb83(%rip), %rdi # 0x42a3
xorl %eax, %eax
callq 0x2040
movl 0x34(%rbx), %esi
leaq 0xb88(%rip), %rdi # 0x42b9
xorl %eax, %eax
callq 0x2040
movl 0x38(%rbx), %esi
leaq 0xb8d(%rip), %rdi # 0x42cf
xorl %eax, %eax
callq 0x2040
movl 0x3c(%rbx), %esi
leaq 0xb8b(%rip), %rdi # 0x42de
xorl %eax, %eax
callq 0x2040
movl 0x40(%rbx), %esi
leaq 0xb8c(%rip), %rdi # 0x42f0
xorl %eax, %eax
callq 0x2040
movl 0x44(%rbx), %esi
leaq 0xb8c(%rip), %rdi # 0x4301
xorl %eax, %eax
callq 0x2040
testl %ebp, %ebp
je 0x3813
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x3813
leaq 0xbb0(%rip), %r12 # 0x4349
leaq 0xb73(%rip), %r14 # 0x4313
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebp, %ebp
xorl %r15d, %r15d
movl 0x4(%rax,%rbp), %edx
movl 0x8(%rax,%rbp), %ecx
cmpb $0x0, (%rax,%rbp)
leaq 0xb7f(%rip), %r8 # 0x4341
leaq 0xb7a(%rip), %rsi # 0x4343
cmovneq %rsi, %r8
cmpb $0x0, 0x1(%rax,%rbp)
movq %r12, %r9
leaq 0xb6f(%rip), %rsi # 0x434b
cmovneq %rsi, %r9
movl 0x10(%rax,%rbp), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
incq %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r13, %rcx
addq $0x30, %rbp
cmpq %r15, %rcx
ja 0x37af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5Cache9printInfoEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, esi
mov rbx, rdi
lea rdi, aCacheInfo; "---------- Cache Info -----------"
call _puts
mov esi, [rbx+30h]
lea rdi, aCacheSizeDByte; "Cache Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+34h]
lea rdi, aBlockSizeDByte; "Block Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+38h]
lea rdi, aBlockNumD; "Block Num: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+3Ch]
lea rdi, aAssociativiyD; "Associativiy: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+40h]
lea rdi, aHitLatencyD; "Hit Latency: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+44h]
lea rdi, aMissLatencyD; "Miss Latency: %d\n"
xor eax, eax
call _printf
test ebp, ebp
jz loc_3813
mov rax, [rbx+48h]
cmp [rbx+50h], rax
jz loc_3813
lea r12, aUnmodified; "unmodified"
lea r14, aBlockDTag0xXId; "Block %d: tag 0x%x id %d %s %s (last re"...
mov r13, 0AAAAAAAAAAAAAAABh
xor ebp, ebp
xor r15d, r15d
loc_37AF:
mov edx, [rax+rbp+4]
mov ecx, [rax+rbp+8]
cmp byte ptr [rax+rbp], 0
lea r8, aInvalid; "invalid"
lea rsi, aInvalid+2; "valid"
cmovnz r8, rsi
cmp byte ptr [rax+rbp+1], 0
mov r9, r12
lea rsi, aUnmodified+2; "modified"
cmovnz r9, rsi
mov eax, [rax+rbp+10h]
mov [rsp+38h+var_38], eax
mov rdi, r14
mov esi, r15d
xor eax, eax
call _printf
inc r15
mov rax, [rbx+48h]
mov rcx, [rbx+50h]
sub rcx, rax
sar rcx, 4
imul rcx, r13
add rbp, 30h ; '0'
cmp rcx, r15
ja short loc_37AF
loc_3813:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long Cache::printInfo(Cache *this, int a2)
{
long long result; // rax
long long v3; // rbp
unsigned long long v4; // r15
const char *v5; // r8
const char *v6; // r9
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n", *((_DWORD *)this + 12));
printf("Block Size: %d bytes\n", *((_DWORD *)this + 13));
printf("Block Num: %d\n", *((_DWORD *)this + 14));
printf("Associativiy: %d\n", *((_DWORD *)this + 15));
printf("Hit Latency: %d\n", *((_DWORD *)this + 16));
result = printf("Miss Latency: %d\n", *((_DWORD *)this + 17));
if ( a2 )
{
result = *((_QWORD *)this + 9);
if ( *((_QWORD *)this + 10) != result )
{
v3 = 0LL;
v4 = 0LL;
do
{
v5 = "invalid";
if ( *(_BYTE *)(result + v3) )
v5 = "valid";
v6 = "unmodified";
if ( *(_BYTE *)(result + v3 + 1) )
v6 = "modified";
printf(
"Block %d: tag 0x%x id %d %s %s (last ref %d)\n",
v4++,
*(_DWORD *)(result + v3 + 4),
*(_DWORD *)(result + v3 + 8),
v5,
v6,
*(_DWORD *)(result + v3 + 16));
result = *((_QWORD *)this + 9);
v3 += 48LL;
}
while ( 0xAAAAAAAAAAAAAAABLL * ((*((_QWORD *)this + 10) - result) >> 4) > v4 );
}
}
return result;
}
|
printInfo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
LEA RDI,[0x10445f]
CALL 0x00102170
MOV ESI,dword ptr [RBX + 0x30]
LEA RDI,[0x1042a3]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x34]
LEA RDI,[0x1042b9]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x38]
LEA RDI,[0x1042cf]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x3c]
LEA RDI,[0x1042de]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x40]
LEA RDI,[0x1042f0]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x44]
LEA RDI,[0x104301]
XOR EAX,EAX
CALL 0x00102040
TEST EBP,EBP
JZ 0x00103813
MOV RAX,qword ptr [RBX + 0x48]
CMP qword ptr [RBX + 0x50],RAX
JZ 0x00103813
LEA R12,[0x104349]
LEA R14,[0x104313]
MOV R13,-0x5555555555555555
XOR EBP,EBP
XOR R15D,R15D
LAB_001037af:
MOV EDX,dword ptr [RAX + RBP*0x1 + 0x4]
MOV ECX,dword ptr [RAX + RBP*0x1 + 0x8]
CMP byte ptr [RAX + RBP*0x1],0x0
LEA R8,[0x104341]
LEA RSI,[0x104343]
CMOVNZ R8,RSI
CMP byte ptr [RAX + RBP*0x1 + 0x1],0x0
MOV R9,R12
LEA RSI,[0x10434b]
CMOVNZ R9,RSI
MOV EAX,dword ptr [RAX + RBP*0x1 + 0x10]
MOV dword ptr [RSP],EAX
MOV RDI,R14
MOV ESI,R15D
XOR EAX,EAX
CALL 0x00102040
INC R15
MOV RAX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [RBX + 0x50]
SUB RCX,RAX
SAR RCX,0x4
IMUL RCX,R13
ADD RBP,0x30
CMP RCX,R15
JA 0x001037af
LAB_00103813:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Cache::printInfo(bool) */
void __thiscall Cache::printInfo(Cache *this,bool param_1)
{
int8 in_RAX;
long lVar1;
ulong uVar2;
long lVar3;
int7 in_register_00000031;
char *pcVar4;
char *pcVar5;
ulong uVar6;
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n",(ulong)*(uint *)(this + 0x30));
printf("Block Size: %d bytes\n",(ulong)*(uint *)(this + 0x34));
printf("Block Num: %d\n",(ulong)*(uint *)(this + 0x38));
printf("Associativiy: %d\n",(ulong)*(uint *)(this + 0x3c));
printf("Hit Latency: %d\n",(ulong)*(uint *)(this + 0x40));
printf("Miss Latency: %d\n",(ulong)*(uint *)(this + 0x44));
if (((int)CONCAT71(in_register_00000031,param_1) != 0) &&
(lVar1 = *(long *)(this + 0x48), *(long *)(this + 0x50) != lVar1)) {
lVar3 = 0;
uVar6 = 0;
do {
pcVar4 = "invalid";
if (*(char *)(lVar1 + lVar3) != '\0') {
pcVar4 = "valid";
}
pcVar5 = "unmodified";
if (*(char *)(lVar1 + 1 + lVar3) != '\0') {
pcVar5 = "modified";
}
in_RAX = CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(lVar1 + 0x10 + lVar3));
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n",uVar6 & 0xffffffff,
(ulong)*(uint *)(lVar1 + 4 + lVar3),(ulong)*(uint *)(lVar1 + 8 + lVar3),pcVar4,pcVar5,
in_RAX);
uVar6 = uVar6 + 1;
lVar1 = *(long *)(this + 0x48);
uVar2 = (*(long *)(this + 0x50) - lVar1 >> 4) * -0x5555555555555555;
lVar3 = lVar3 + 0x30;
} while (uVar6 <= uVar2 && uVar2 - uVar6 != 0);
}
return;
}
|
|
57,679
|
Cache::printInfo(bool)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::printInfo(bool verbose) {
printf("---------- Cache Info -----------\n");
printf("Cache Size: %d bytes\n", this->policy.cacheSize);
printf("Block Size: %d bytes\n", this->policy.blockSize);
printf("Block Num: %d\n", this->policy.blockNum);
printf("Associativiy: %d\n", this->policy.associativity);
printf("Hit Latency: %d\n", this->policy.hitLatency);
printf("Miss Latency: %d\n", this->policy.missLatency);
if (verbose) {
for (int j = 0; j < this->blocks.size(); ++j) {
const Block &b = this->blocks[j];
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n", j, b.tag, b.id,
b.valid ? "valid" : "invalid",
b.modified ? "modified" : "unmodified", b.lastReference);
// printf("Data: ");
// for (uint8_t d : b.data)
// printf("%d ", d);
// printf("\n");
}
}
}
|
O2
|
cpp
|
Cache::printInfo(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xfd6(%rip), %rdi # 0x5441
callq 0x3190
movl 0x30(%rbx), %esi
leaq 0xe0b(%rip), %rdi # 0x5285
xorl %eax, %eax
callq 0x3040
movl 0x34(%rbx), %esi
leaq 0xe10(%rip), %rdi # 0x529b
xorl %eax, %eax
callq 0x3040
movl 0x38(%rbx), %esi
leaq 0xe15(%rip), %rdi # 0x52b1
xorl %eax, %eax
callq 0x3040
movl 0x3c(%rbx), %esi
leaq 0xe13(%rip), %rdi # 0x52c0
xorl %eax, %eax
callq 0x3040
movl 0x40(%rbx), %esi
leaq 0xe14(%rip), %rdi # 0x52d2
xorl %eax, %eax
callq 0x3040
movl 0x44(%rbx), %esi
leaq 0xe14(%rip), %rdi # 0x52e3
xorl %eax, %eax
callq 0x3040
testl %ebp, %ebp
je 0x4553
leaq 0xe4c(%rip), %r13 # 0x532d
leaq 0xe43(%rip), %r12 # 0x532b
leaq 0xe06(%rip), %r14 # 0x52f5
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rax
subq %rsi, %rax
cqto
pushq $0x30
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x4553
movl 0x4(%rsi,%rbp), %edx
movl 0x8(%rsi,%rbp), %ecx
cmpb $0x0, (%rsi,%rbp)
leaq 0xe04(%rip), %r8 # 0x5323
leaq 0xdff(%rip), %rax # 0x5325
cmovneq %rax, %r8
cmpb $0x0, 0x1(%rsi,%rbp)
movq %r12, %r9
cmovneq %r13, %r9
movl 0x10(%rsi,%rbp), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x3040
incq %r15
addq $0x30, %rbp
jmp 0x44f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5Cache9printInfoEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, esi
mov rbx, rdi
lea rdi, aCacheInfo; "---------- Cache Info -----------"
call _puts
mov esi, [rbx+30h]
lea rdi, aCacheSizeDByte; "Cache Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+34h]
lea rdi, aBlockSizeDByte; "Block Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+38h]
lea rdi, aBlockNumD; "Block Num: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+3Ch]
lea rdi, aAssociativiyD; "Associativiy: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+40h]
lea rdi, aHitLatencyD; "Hit Latency: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+44h]
lea rdi, aMissLatencyD; "Miss Latency: %d\n"
xor eax, eax
call _printf
test ebp, ebp
jz short loc_4553
lea r13, aUnmodified+2; "modified"
lea r12, aUnmodified; "unmodified"
lea r14, aBlockDTag0xXId; "Block %d: tag 0x%x id %d %s %s (last re"...
xor ebp, ebp
xor r15d, r15d
loc_44F4:
mov rsi, [rbx+48h]
mov rax, [rbx+50h]
sub rax, rsi
cqo
push 30h ; '0'
pop rcx
idiv rcx
cmp rax, r15
jbe short loc_4553
mov edx, [rsi+rbp+4]
mov ecx, [rsi+rbp+8]
cmp byte ptr [rsi+rbp], 0
lea r8, aInvalid; "invalid"
lea rax, aInvalid+2; "valid"
cmovnz r8, rax
cmp byte ptr [rsi+rbp+1], 0
mov r9, r12
cmovnz r9, r13
mov eax, [rsi+rbp+10h]
mov [rsp+38h+var_38], eax
mov rdi, r14
mov esi, r15d
xor eax, eax
call _printf
inc r15
add rbp, 30h ; '0'
jmp short loc_44F4
loc_4553:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
unsigned long long Cache::printInfo(Cache *this, int a2)
{
unsigned long long result; // rax
long long v3; // rbp
unsigned long long i; // r15
long long v5; // rsi
const char *v6; // r8
const char *v7; // r9
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n", *((_DWORD *)this + 12));
printf("Block Size: %d bytes\n", *((_DWORD *)this + 13));
printf("Block Num: %d\n", *((_DWORD *)this + 14));
printf("Associativiy: %d\n", *((_DWORD *)this + 15));
printf("Hit Latency: %d\n", *((_DWORD *)this + 16));
result = printf("Miss Latency: %d\n", *((_DWORD *)this + 17));
if ( a2 )
{
v3 = 0LL;
for ( i = 0LL; ; ++i )
{
v5 = *((_QWORD *)this + 9);
result = (*((_QWORD *)this + 10) - v5) / 48;
if ( result <= i )
break;
v6 = "invalid";
if ( *(_BYTE *)(v5 + v3) )
v6 = "valid";
v7 = "unmodified";
if ( *(_BYTE *)(v5 + v3 + 1) )
v7 = "modified";
printf(
"Block %d: tag 0x%x id %d %s %s (last ref %d)\n",
i,
*(_DWORD *)(v5 + v3 + 4),
*(_DWORD *)(v5 + v3 + 8),
v6,
v7,
*(_DWORD *)(v5 + v3 + 16));
v3 += 48LL;
}
}
return result;
}
|
printInfo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
LEA RDI,[0x105441]
CALL 0x00103190
MOV ESI,dword ptr [RBX + 0x30]
LEA RDI,[0x105285]
XOR EAX,EAX
CALL 0x00103040
MOV ESI,dword ptr [RBX + 0x34]
LEA RDI,[0x10529b]
XOR EAX,EAX
CALL 0x00103040
MOV ESI,dword ptr [RBX + 0x38]
LEA RDI,[0x1052b1]
XOR EAX,EAX
CALL 0x00103040
MOV ESI,dword ptr [RBX + 0x3c]
LEA RDI,[0x1052c0]
XOR EAX,EAX
CALL 0x00103040
MOV ESI,dword ptr [RBX + 0x40]
LEA RDI,[0x1052d2]
XOR EAX,EAX
CALL 0x00103040
MOV ESI,dword ptr [RBX + 0x44]
LEA RDI,[0x1052e3]
XOR EAX,EAX
CALL 0x00103040
TEST EBP,EBP
JZ 0x00104553
LEA R13,[0x10532d]
LEA R12,[0x10532b]
LEA R14,[0x1052f5]
XOR EBP,EBP
XOR R15D,R15D
LAB_001044f4:
MOV RSI,qword ptr [RBX + 0x48]
MOV RAX,qword ptr [RBX + 0x50]
SUB RAX,RSI
CQO
PUSH 0x30
POP RCX
IDIV RCX
CMP RAX,R15
JBE 0x00104553
MOV EDX,dword ptr [RSI + RBP*0x1 + 0x4]
MOV ECX,dword ptr [RSI + RBP*0x1 + 0x8]
CMP byte ptr [RSI + RBP*0x1],0x0
LEA R8,[0x105323]
LEA RAX,[0x105325]
CMOVNZ R8,RAX
CMP byte ptr [RSI + RBP*0x1 + 0x1],0x0
MOV R9,R12
CMOVNZ R9,R13
MOV EAX,dword ptr [RSI + RBP*0x1 + 0x10]
MOV dword ptr [RSP],EAX
MOV RDI,R14
MOV ESI,R15D
XOR EAX,EAX
CALL 0x00103040
INC R15
ADD RBP,0x30
JMP 0x001044f4
LAB_00104553:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Cache::printInfo(bool) */
void __thiscall Cache::printInfo(Cache *this,bool param_1)
{
long lVar1;
int8 in_RAX;
long lVar2;
int7 in_register_00000031;
char *pcVar3;
char *pcVar4;
ulong uVar5;
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n",(ulong)*(uint *)(this + 0x30));
printf("Block Size: %d bytes\n",(ulong)*(uint *)(this + 0x34));
printf("Block Num: %d\n",(ulong)*(uint *)(this + 0x38));
printf("Associativiy: %d\n",(ulong)*(uint *)(this + 0x3c));
printf("Hit Latency: %d\n",(ulong)*(uint *)(this + 0x40));
printf("Miss Latency: %d\n",(ulong)*(uint *)(this + 0x44));
if ((int)CONCAT71(in_register_00000031,param_1) != 0) {
lVar2 = 0;
uVar5 = 0;
while( true ) {
lVar1 = *(long *)(this + 0x48);
if ((ulong)((*(long *)(this + 0x50) - lVar1) / 0x30) <= uVar5) break;
pcVar3 = "invalid";
if (*(char *)(lVar1 + lVar2) != '\0') {
pcVar3 = "valid";
}
pcVar4 = "unmodified";
if (*(char *)(lVar1 + 1 + lVar2) != '\0') {
pcVar4 = "modified";
}
in_RAX = CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(lVar1 + 0x10 + lVar2));
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n",uVar5 & 0xffffffff,
(ulong)*(uint *)(lVar1 + 4 + lVar2),(ulong)*(uint *)(lVar1 + 8 + lVar2),pcVar3,pcVar4,
in_RAX);
uVar5 = uVar5 + 1;
lVar2 = lVar2 + 0x30;
}
}
return;
}
|
|
57,680
|
Cache::printInfo(bool)
|
EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/Cache.cpp
|
void Cache::printInfo(bool verbose) {
printf("---------- Cache Info -----------\n");
printf("Cache Size: %d bytes\n", this->policy.cacheSize);
printf("Block Size: %d bytes\n", this->policy.blockSize);
printf("Block Num: %d\n", this->policy.blockNum);
printf("Associativiy: %d\n", this->policy.associativity);
printf("Hit Latency: %d\n", this->policy.hitLatency);
printf("Miss Latency: %d\n", this->policy.missLatency);
if (verbose) {
for (int j = 0; j < this->blocks.size(); ++j) {
const Block &b = this->blocks[j];
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n", j, b.tag, b.id,
b.valid ? "valid" : "invalid",
b.modified ? "modified" : "unmodified", b.lastReference);
// printf("Data: ");
// for (uint8_t d : b.data)
// printf("%d ", d);
// printf("\n");
}
}
}
|
O3
|
cpp
|
Cache::printInfo(bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xdf8(%rip), %rdi # 0x445f
callq 0x2170
movl 0x30(%rbx), %esi
leaq 0xc2d(%rip), %rdi # 0x42a3
xorl %eax, %eax
callq 0x2040
movl 0x34(%rbx), %esi
leaq 0xc32(%rip), %rdi # 0x42b9
xorl %eax, %eax
callq 0x2040
movl 0x38(%rbx), %esi
leaq 0xc37(%rip), %rdi # 0x42cf
xorl %eax, %eax
callq 0x2040
movl 0x3c(%rbx), %esi
leaq 0xc35(%rip), %rdi # 0x42de
xorl %eax, %eax
callq 0x2040
movl 0x40(%rbx), %esi
leaq 0xc36(%rip), %rdi # 0x42f0
xorl %eax, %eax
callq 0x2040
movl 0x44(%rbx), %esi
leaq 0xc36(%rip), %rdi # 0x4301
xorl %eax, %eax
callq 0x2040
testl %ebp, %ebp
je 0x3769
movq 0x48(%rbx), %rax
cmpq %rax, 0x50(%rbx)
je 0x3769
leaq 0xc5a(%rip), %r12 # 0x4349
leaq 0xc1d(%rip), %r14 # 0x4313
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebp, %ebp
xorl %r15d, %r15d
movl 0x4(%rax,%rbp), %edx
movl 0x8(%rax,%rbp), %ecx
cmpb $0x0, (%rax,%rbp)
leaq 0xc29(%rip), %r8 # 0x4341
leaq 0xc24(%rip), %rsi # 0x4343
cmovneq %rsi, %r8
cmpb $0x0, 0x1(%rax,%rbp)
movq %r12, %r9
leaq 0xc19(%rip), %rsi # 0x434b
cmovneq %rsi, %r9
movl 0x10(%rax,%rbp), %eax
movl %eax, (%rsp)
movq %r14, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x2040
incq %r15
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r13, %rcx
addq $0x30, %rbp
cmpq %r15, %rcx
ja 0x3705
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZN5Cache9printInfoEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov ebp, esi
mov rbx, rdi
lea rdi, aCacheInfo; "---------- Cache Info -----------"
call _puts
mov esi, [rbx+30h]
lea rdi, aCacheSizeDByte; "Cache Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+34h]
lea rdi, aBlockSizeDByte; "Block Size: %d bytes\n"
xor eax, eax
call _printf
mov esi, [rbx+38h]
lea rdi, aBlockNumD; "Block Num: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+3Ch]
lea rdi, aAssociativiyD; "Associativiy: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+40h]
lea rdi, aHitLatencyD; "Hit Latency: %d\n"
xor eax, eax
call _printf
mov esi, [rbx+44h]
lea rdi, aMissLatencyD; "Miss Latency: %d\n"
xor eax, eax
call _printf
test ebp, ebp
jz loc_3769
mov rax, [rbx+48h]
cmp [rbx+50h], rax
jz loc_3769
lea r12, aUnmodified; "unmodified"
lea r14, aBlockDTag0xXId; "Block %d: tag 0x%x id %d %s %s (last re"...
mov r13, 0AAAAAAAAAAAAAAABh
xor ebp, ebp
xor r15d, r15d
loc_3705:
mov edx, [rax+rbp+4]
mov ecx, [rax+rbp+8]
cmp byte ptr [rax+rbp], 0
lea r8, aInvalid; "invalid"
lea rsi, aInvalid+2; "valid"
cmovnz r8, rsi
cmp byte ptr [rax+rbp+1], 0
mov r9, r12
lea rsi, aUnmodified+2; "modified"
cmovnz r9, rsi
mov eax, [rax+rbp+10h]
mov [rsp+38h+var_38], eax
mov rdi, r14
mov esi, r15d
xor eax, eax
call _printf
inc r15
mov rax, [rbx+48h]
mov rcx, [rbx+50h]
sub rcx, rax
sar rcx, 4
imul rcx, r13
add rbp, 30h ; '0'
cmp rcx, r15
ja short loc_3705
loc_3769:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long Cache::printInfo(Cache *this, int a2)
{
long long result; // rax
long long v3; // rbp
unsigned long long v4; // r15
const char *v5; // r8
const char *v6; // r9
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n", *((_DWORD *)this + 12));
printf("Block Size: %d bytes\n", *((_DWORD *)this + 13));
printf("Block Num: %d\n", *((_DWORD *)this + 14));
printf("Associativiy: %d\n", *((_DWORD *)this + 15));
printf("Hit Latency: %d\n", *((_DWORD *)this + 16));
result = printf("Miss Latency: %d\n", *((_DWORD *)this + 17));
if ( a2 )
{
result = *((_QWORD *)this + 9);
if ( *((_QWORD *)this + 10) != result )
{
v3 = 0LL;
v4 = 0LL;
do
{
v5 = "invalid";
if ( *(_BYTE *)(result + v3) )
v5 = "valid";
v6 = "unmodified";
if ( *(_BYTE *)(result + v3 + 1) )
v6 = "modified";
printf(
"Block %d: tag 0x%x id %d %s %s (last ref %d)\n",
v4++,
*(_DWORD *)(result + v3 + 4),
*(_DWORD *)(result + v3 + 8),
v5,
v6,
*(_DWORD *)(result + v3 + 16));
result = *((_QWORD *)this + 9);
v3 += 48LL;
}
while ( 0xAAAAAAAAAAAAAAABLL * ((*((_QWORD *)this + 10) - result) >> 4) > v4 );
}
}
return result;
}
|
printInfo:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
LEA RDI,[0x10445f]
CALL 0x00102170
MOV ESI,dword ptr [RBX + 0x30]
LEA RDI,[0x1042a3]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x34]
LEA RDI,[0x1042b9]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x38]
LEA RDI,[0x1042cf]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x3c]
LEA RDI,[0x1042de]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x40]
LEA RDI,[0x1042f0]
XOR EAX,EAX
CALL 0x00102040
MOV ESI,dword ptr [RBX + 0x44]
LEA RDI,[0x104301]
XOR EAX,EAX
CALL 0x00102040
TEST EBP,EBP
JZ 0x00103769
MOV RAX,qword ptr [RBX + 0x48]
CMP qword ptr [RBX + 0x50],RAX
JZ 0x00103769
LEA R12,[0x104349]
LEA R14,[0x104313]
MOV R13,-0x5555555555555555
XOR EBP,EBP
XOR R15D,R15D
LAB_00103705:
MOV EDX,dword ptr [RAX + RBP*0x1 + 0x4]
MOV ECX,dword ptr [RAX + RBP*0x1 + 0x8]
CMP byte ptr [RAX + RBP*0x1],0x0
LEA R8,[0x104341]
LEA RSI,[0x104343]
CMOVNZ R8,RSI
CMP byte ptr [RAX + RBP*0x1 + 0x1],0x0
MOV R9,R12
LEA RSI,[0x10434b]
CMOVNZ R9,RSI
MOV EAX,dword ptr [RAX + RBP*0x1 + 0x10]
MOV dword ptr [RSP],EAX
MOV RDI,R14
MOV ESI,R15D
XOR EAX,EAX
CALL 0x00102040
INC R15
MOV RAX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [RBX + 0x50]
SUB RCX,RAX
SAR RCX,0x4
IMUL RCX,R13
ADD RBP,0x30
CMP RCX,R15
JA 0x00103705
LAB_00103769:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* Cache::printInfo(bool) */
void __thiscall Cache::printInfo(Cache *this,bool param_1)
{
int8 in_RAX;
long lVar1;
ulong uVar2;
long lVar3;
int7 in_register_00000031;
char *pcVar4;
char *pcVar5;
ulong uVar6;
puts("---------- Cache Info -----------");
printf("Cache Size: %d bytes\n",(ulong)*(uint *)(this + 0x30));
printf("Block Size: %d bytes\n",(ulong)*(uint *)(this + 0x34));
printf("Block Num: %d\n",(ulong)*(uint *)(this + 0x38));
printf("Associativiy: %d\n",(ulong)*(uint *)(this + 0x3c));
printf("Hit Latency: %d\n",(ulong)*(uint *)(this + 0x40));
printf("Miss Latency: %d\n",(ulong)*(uint *)(this + 0x44));
if (((int)CONCAT71(in_register_00000031,param_1) != 0) &&
(lVar1 = *(long *)(this + 0x48), *(long *)(this + 0x50) != lVar1)) {
lVar3 = 0;
uVar6 = 0;
do {
pcVar4 = "invalid";
if (*(char *)(lVar1 + lVar3) != '\0') {
pcVar4 = "valid";
}
pcVar5 = "unmodified";
if (*(char *)(lVar1 + 1 + lVar3) != '\0') {
pcVar5 = "modified";
}
in_RAX = CONCAT44((int)((ulong)in_RAX >> 0x20),*(int4 *)(lVar1 + 0x10 + lVar3));
printf("Block %d: tag 0x%x id %d %s %s (last ref %d)\n",uVar6 & 0xffffffff,
(ulong)*(uint *)(lVar1 + 4 + lVar3),(ulong)*(uint *)(lVar1 + 8 + lVar3),pcVar4,pcVar5,
in_RAX);
uVar6 = uVar6 + 1;
lVar1 = *(long *)(this + 0x48);
uVar2 = (*(long *)(this + 0x50) - lVar1 >> 4) * -0x5555555555555555;
lVar3 = lVar3 + 0x30;
} while (uVar6 <= uVar2 && uVar2 - uVar6 != 0);
}
return;
}
|
|
57,681
|
blst_scalar_from_hexascii
|
corpus-core[P]colibri-stateless/build_O3/_deps/blst-src/src/exports.c
|
void blst_scalar_from_hexascii(pow256 ret, const char *hex)
{ bytes_from_hexascii(ret, sizeof(pow256), hex); }
|
O3
|
c
|
blst_scalar_from_hexascii:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x30, (%rsi)
jne 0x660f9
movzbl 0x1(%rbx), %eax
orl $0x20, %eax
cmpl $0x78, %eax
jne 0x660f9
addq $0x2, %rbx
xorl %r15d, %r15d
movsbl (%rbx,%r15), %edi
callq 0x6adbb
cmpb $0xf, %al
ja 0x66127
incq %r15
cmpq $0x40, %r15
jne 0x660fc
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movl $0x40, %r15d
jmp 0x66138
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
testq %r15, %r15
je 0x66168
decq %r15
xorl %eax, %eax
movl %eax, %r12d
shlb $0x4, %r12b
movsbl (%rbx), %edi
callq 0x6adbb
orb %r12b, %al
testb $0x1, %r15b
jne 0x6615f
movq %r15, %rcx
shrq %rcx
movb %al, (%r14,%rcx)
incq %rbx
addq $-0x1, %r15
jb 0x6613d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
blst_scalar_from_hexascii:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov rbx, rsi
mov r14, rdi
cmp byte ptr [rsi], 30h ; '0'
jnz short loc_660F9
movzx eax, byte ptr [rbx+1]
or eax, 20h
cmp eax, 78h ; 'x'
jnz short loc_660F9
add rbx, 2
loc_660F9:
xor r15d, r15d
loc_660FC:
movsx edi, byte ptr [rbx+r15]
call nibble_from_hex
cmp al, 0Fh
ja short loc_66127
inc r15
cmp r15, 40h ; '@'
jnz short loc_660FC
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
movups xmmword ptr [r14], xmm0
mov r15d, 40h ; '@'
jmp short loc_66138
loc_66127:
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
movups xmmword ptr [r14], xmm0
test r15, r15
jz short loc_66168
loc_66138:
dec r15
xor eax, eax
loc_6613D:
mov r12d, eax
shl r12b, 4
movsx edi, byte ptr [rbx]
call nibble_from_hex
or al, r12b
test r15b, 1
jnz short loc_6615F
mov rcx, r15
shr rcx, 1
mov [r14+rcx], al
loc_6615F:
inc rbx
add r15, 0FFFFFFFFFFFFFFFFh
jb short loc_6613D
loc_66168:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
|
unsigned __int8 blst_scalar_from_hexascii(_OWORD *a1, char *a2)
{
char *v2; // rbx
long long v3; // r15
unsigned __int8 result; // al
unsigned long long v5; // r15
v2 = a2;
if ( *a2 == 48 && ((unsigned __int8)a2[1] | 0x20) == 0x78 )
v2 = a2 + 2;
v3 = 0LL;
while ( 1 )
{
result = nibble_from_hex((unsigned int)v2[v3]);
if ( result > 0xFu )
break;
if ( ++v3 == 64 )
{
a1[1] = 0LL;
*a1 = 0LL;
v3 = 64LL;
goto LABEL_9;
}
}
a1[1] = 0LL;
*a1 = 0LL;
if ( !v3 )
return result;
LABEL_9:
v5 = v3 - 1;
result = 0;
do
{
result = (16 * result) | nibble_from_hex((unsigned int)*v2);
if ( (v5 & 1) == 0 )
*((_BYTE *)a1 + (v5 >> 1)) = result;
++v2;
}
while ( v5-- != 0 );
return result;
}
|
blst_scalar_from_hexascii:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CMP byte ptr [RSI],0x30
JNZ 0x001660f9
MOVZX EAX,byte ptr [RBX + 0x1]
OR EAX,0x20
CMP EAX,0x78
JNZ 0x001660f9
ADD RBX,0x2
LAB_001660f9:
XOR R15D,R15D
LAB_001660fc:
MOVSX EDI,byte ptr [RBX + R15*0x1]
CALL 0x0016adbb
CMP AL,0xf
JA 0x00166127
INC R15
CMP R15,0x40
JNZ 0x001660fc
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOVUPS xmmword ptr [R14],XMM0
MOV R15D,0x40
JMP 0x00166138
LAB_00166127:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOVUPS xmmword ptr [R14],XMM0
TEST R15,R15
JZ 0x00166168
LAB_00166138:
DEC R15
XOR EAX,EAX
LAB_0016613d:
MOV R12D,EAX
SHL R12B,0x4
MOVSX EDI,byte ptr [RBX]
CALL 0x0016adbb
OR AL,R12B
TEST R15B,0x1
JNZ 0x0016615f
MOV RCX,R15
SHR RCX,0x1
MOV byte ptr [R14 + RCX*0x1],AL
LAB_0016615f:
INC RBX
ADD R15,-0x1
JC 0x0016613d
LAB_00166168:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void blst_scalar_from_hexascii(int8 *param_1,char *param_2)
{
byte bVar1;
byte bVar2;
ulong uVar3;
if ((*param_2 == '0') && ((byte)(param_2[1] | 0x20U) == 0x78)) {
param_2 = param_2 + 2;
}
uVar3 = 0;
do {
bVar1 = nibble_from_hex((int)param_2[uVar3]);
if (0xf < bVar1) {
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
if (uVar3 == 0) {
return;
}
goto LAB_00166138;
}
uVar3 = uVar3 + 1;
} while (uVar3 != 0x40);
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
uVar3 = 0x40;
LAB_00166138:
bVar1 = 0;
do {
uVar3 = uVar3 - 1;
bVar2 = nibble_from_hex((int)*param_2);
bVar1 = bVar2 | bVar1 << 4;
if ((uVar3 & 1) == 0) {
*(byte *)((long)param_1 + (uVar3 >> 1)) = bVar1;
}
param_2 = param_2 + 1;
} while (uVar3 != 0);
return;
}
|
|
57,682
|
lex2str
|
eloqsql/strings/xml.c
|
static const char *lex2str(int lex)
{
switch(lex)
{
case MY_XML_EOF: return "END-OF-INPUT";
case MY_XML_STRING: return "STRING";
case MY_XML_IDENT: return "IDENT";
case MY_XML_CDATA: return "CDATA";
case MY_XML_EQ: return "'='";
case MY_XML_LT: return "'<'";
case MY_XML_GT: return "'>'";
case MY_XML_SLASH: return "'/'";
case MY_XML_COMMENT: return "COMMENT";
case MY_XML_TEXT: return "TEXT";
case MY_XML_QUESTION: return "'?'";
case MY_XML_EXCLAM: return "'!'";
}
return "unknown token";
}
|
O0
|
c
|
lex2str:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x33, %eax
ja 0x7e4c5
movq -0x18(%rbp), %rax
leaq 0x13f051(%rip), %rcx # 0x1bd468
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6585(%rip), %rax # 0x849ac
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x659c(%rip), %rax # 0x849d3
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6593(%rip), %rax # 0x849da
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6589(%rip), %rax # 0x849e0
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6582(%rip), %rax # 0x849e6
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6579(%rip), %rax # 0x849ea
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6570(%rip), %rax # 0x849ee
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6567(%rip), %rax # 0x849f2
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x655e(%rip), %rax # 0x849f6
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6559(%rip), %rax # 0x849fe
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6551(%rip), %rax # 0x84a03
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x6548(%rip), %rax # 0x84a07
movq %rax, -0x8(%rbp)
jmp 0x7e4d0
leaq 0x653f(%rip), %rax # 0x84a0b
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
lex2str:
push rbp
mov rbp, rsp
mov [rbp+var_C], edi
mov eax, [rbp+var_C]
add eax, 0FFFFFFDFh; switch 52 cases
mov ecx, eax
mov [rbp+var_18], rcx
sub eax, 33h
ja def_7E41E; jumptable 000000000007E41E default case, cases 34-46,48-59,64-66,70-72,74-82
mov rax, [rbp+var_18]
lea rcx, jpt_7E41E
movsxd rax, ds:(jpt_7E41E - 1BD468h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_7E420:
lea rax, aUnexpectedEndO+0Bh; jumptable 000000000007E41E case 69
mov [rbp+var_8], rax
jmp loc_7E4D0
loc_7E430:
lea rax, aString; jumptable 000000000007E41E case 83
mov [rbp+var_8], rax
jmp loc_7E4D0
loc_7E440:
lea rax, aIdent; jumptable 000000000007E41E case 73
mov [rbp+var_8], rax
jmp loc_7E4D0
loc_7E450:
lea rax, aCdata_0; jumptable 000000000007E41E case 68
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E45D:
lea rax, asc_849E6; jumptable 000000000007E41E case 61
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E46A:
lea rax, asc_849EA; jumptable 000000000007E41E case 60
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E477:
lea rax, asc_849EE; jumptable 000000000007E41E case 62
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E484:
lea rax, asc_849F2; jumptable 000000000007E41E case 47
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E491:
lea rax, aComment; jumptable 000000000007E41E case 67
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E49E:
lea rax, aText; jumptable 000000000007E41E case 84
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E4AB:
lea rax, asc_84A03; jumptable 000000000007E41E case 63
mov [rbp+var_8], rax
jmp short loc_7E4D0
loc_7E4B8:
lea rax, asc_84A07; jumptable 000000000007E41E case 33
mov [rbp+var_8], rax
jmp short loc_7E4D0
def_7E41E:
lea rax, aUnknownToken; jumptable 000000000007E41E default case, cases 34-46,48-59,64-66,70-72,74-82
mov [rbp+var_8], rax
loc_7E4D0:
mov rax, [rbp+var_8]
pop rbp
retn
|
char * lex2str(int a1)
{
char *v2; // [rsp+10h] [rbp-8h]
switch ( a1 )
{
case '!':
v2 = "'!'";
break;
case '/':
v2 = "'/'";
break;
case '<':
v2 = "'<'";
break;
case '=':
v2 = "'='";
break;
case '>':
v2 = "'>'";
break;
case '?':
v2 = "'?'";
break;
case 'C':
v2 = "COMMENT";
break;
case 'D':
v2 = "CDATA";
break;
case 'E':
v2 = "END-OF-INPUT";
break;
case 'I':
v2 = "IDENT";
break;
case 'S':
v2 = "STRING";
break;
case 'T':
v2 = "TEXT";
break;
default:
v2 = "unknown token";
break;
}
return v2;
}
|
lex2str:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0xc],EDI
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,-0x21
MOV ECX,EAX
MOV qword ptr [RBP + -0x18],RCX
SUB EAX,0x33
JA 0x0017e4c5
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x2bd468]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_45:
LEA RAX,[0x1849ac]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_53:
LEA RAX,[0x1849d3]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_49:
LEA RAX,[0x1849da]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_44:
LEA RAX,[0x1849e0]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_3d:
LEA RAX,[0x1849e6]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_3c:
LEA RAX,[0x1849ea]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_3e:
LEA RAX,[0x1849ee]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_2f:
LEA RAX,[0x1849f2]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_43:
LEA RAX,[0x1849f6]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_54:
LEA RAX,[0x1849fe]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_3f:
LEA RAX,[0x184a03]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_21:
LEA RAX,[0x184a07]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0017e4d0
caseD_22:
LEA RAX,[0x184a0b]
MOV qword ptr [RBP + -0x8],RAX
LAB_0017e4d0:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * lex2str(int4 param_1)
{
char *local_10;
switch(param_1) {
case 0x21:
local_10 = "\'!\'";
break;
default:
local_10 = "unknown token";
break;
case 0x2f:
local_10 = "\'/\'";
break;
case 0x3c:
local_10 = "\'<\'";
break;
case 0x3d:
local_10 = "\'=\'";
break;
case 0x3e:
local_10 = "\'>\'";
break;
case 0x3f:
local_10 = "\'?\'";
break;
case 0x43:
local_10 = "COMMENT";
break;
case 0x44:
local_10 = "CDATA";
break;
case 0x45:
local_10 = "END-OF-INPUT";
break;
case 0x49:
local_10 = "IDENT";
break;
case 0x53:
local_10 = "STRING";
break;
case 0x54:
local_10 = "TEXT";
}
return local_10;
}
|
|
57,683
|
lunasvg::isIntegralDigit(char, int)
|
dmazzella[P]pylunasvg/lunasvg/source/svgparserutils.h
|
constexpr bool IS_ALPHA(int cc) { return (cc >= 'a' && cc <= 'z') || (cc >= 'A' && cc <= 'Z'); }
|
O1
|
c
|
lunasvg::isIntegralDigit(char, int):
leal -0x30(%rdi), %eax
cmpl $0x9, %eax
ja 0x1cabe
cmpl %esi, %eax
setl %al
retq
movl %edi, %eax
andl $-0x21, %eax
addl $-0x41, %eax
cmpl $0x19, %eax
ja 0x1caef
cmpb $0x61, %dil
setge %cl
leal 0x57(%rsi), %eax
cmpl %edi, %eax
setg %dl
movb $0x1, %al
testb %dl, %cl
jne 0x1cabd
cmpb $0x41, %dil
jl 0x1caef
addl $0x37, %esi
cmpl %edi, %esi
setg %al
retq
xorl %eax, %eax
retq
|
_ZN7lunasvg15isIntegralDigitEci:
lea eax, [rdi-30h]
cmp eax, 9
ja short loc_1CABE
cmp eax, esi
setl al
locret_1CABD:
retn
loc_1CABE:
mov eax, edi
and eax, 0FFFFFFDFh
add eax, 0FFFFFFBFh
cmp eax, 19h
ja short loc_1CAEF
cmp dil, 61h ; 'a'
setnl cl
lea eax, [rsi+57h]
cmp eax, edi
setnle dl
mov al, 1
test cl, dl
jnz short locret_1CABD
cmp dil, 41h ; 'A'
jl short loc_1CAEF
add esi, 37h ; '7'
cmp esi, edi
setnle al
retn
loc_1CAEF:
xor eax, eax
retn
|
char lunasvg::isIntegralDigit(lunasvg *this, int a2)
{
char result; // al
if ( (unsigned int)((_DWORD)this - 48) <= 9 )
return (int)this - 48 < a2;
if ( ((unsigned int)this & 0xFFFFFFDF) - 65 > 0x19 )
return 0;
result = 1;
if ( a2 + 87 <= (int)this || (char)this < 97 )
{
if ( (char)this >= 65 )
return a2 + 55 > (int)this;
return 0;
}
return result;
}
|
isIntegralDigit:
LEA EAX,[RDI + -0x30]
CMP EAX,0x9
JA 0x0011cabe
CMP EAX,ESI
SETL AL
LAB_0011cabd:
RET
LAB_0011cabe:
MOV EAX,EDI
AND EAX,0xffffffdf
ADD EAX,-0x41
CMP EAX,0x19
JA 0x0011caef
CMP DIL,0x61
SETGE CL
LEA EAX,[RSI + 0x57]
CMP EAX,EDI
SETG DL
MOV AL,0x1
TEST CL,DL
JNZ 0x0011cabd
CMP DIL,0x41
JL 0x0011caef
ADD ESI,0x37
CMP ESI,EDI
SETG AL
RET
LAB_0011caef:
XOR EAX,EAX
RET
|
/* lunasvg::isIntegralDigit(char, int) */
ulong lunasvg::isIntegralDigit(char param_1,int param_2)
{
uint3 uVar1;
uint uVar2;
int3 in_register_00000039;
uint uVar3;
uVar3 = CONCAT31(in_register_00000039,param_1);
uVar2 = uVar3 - 0x30;
if (uVar2 < 10) {
return (ulong)CONCAT31((int3)(uVar2 >> 8),(int)uVar2 < param_2);
}
if ((uVar3 & 0xffffffdf) - 0x41 < 0x1a) {
uVar1 = (uint3)((uint)(param_2 + 0x57) >> 8);
if ('`' < param_1 && (int)uVar3 < param_2 + 0x57) {
return CONCAT71((uint7)uVar1,1);
}
if ('@' < param_1) {
return (ulong)CONCAT31(uVar1,(int)uVar3 < param_2 + 0x37);
}
}
return 0;
}
|
|
57,684
|
rlBegin
|
csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rlgl.h
|
void rlBegin(int mode)
{
// Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
// NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode)
{
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
{
// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
// that way, following QUADS drawing will keep aligned with index processing
// It implies adding some extra alignment vertex at the end of the draw,
// those vertex are not processed but they are considered as an additional offset
// for the next set of vertex to be drawn
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4);
else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4)));
else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
{
RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
RLGL.currentBatch->drawCounter++;
}
}
if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode;
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId;
}
}
|
O0
|
c
|
rlBegin:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x169646(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16963b(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0xb0eaf
movq 0x169619(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16960e(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jle 0xb0e18
movq 0x1695ed(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x1695e2(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0xb0cbe
movq 0x1695c2(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x1695b7(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, 0x4(%rax)
jge 0xb0c61
movq 0x16959a(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16958f(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %edx
movl %edx, -0x8(%rbp)
jmp 0xb0c91
movq 0x169570(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x169565(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x8(%rbp), %ecx
movq 0x16953d(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x169532(%rip), %rdx # 0x21a1d8
movl 0x18(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0xb0da7
movq 0x169513(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x169508(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, (%rax)
jne 0xb0d7c
movq 0x1694e8(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x1694dd(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x4, 0x4(%rax)
jge 0xb0d1b
movl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb0d52
movq 0x1694b6(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x1694ab(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl $0x4, %eax
subl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq 0x16947c(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x169471(%rip), %rdx # 0x21a1d8
movl 0x18(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0xb0da5
movq 0x169455(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16944a(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
jmp 0xb0da7
movq 0x16942a(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16941f(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
callq 0xb0ec0
testb $0x1, %al
jne 0xb0e16
movq 0x1693fc(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x1693f1(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
addl 0x169400(%rip), %eax # 0x21a200
movl %eax, 0x1693fa(%rip) # 0x21a200
movq 0x1693cb(%rip), %rax # 0x21a1d8
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0xb0e18
movq 0x1693b9(%rip), %rax # 0x21a1d8
cmpl $0x100, 0x18(%rax) # imm = 0x100
jl 0xb0e34
movq 0x1693a9(%rip), %rdi # 0x21a1d8
callq 0xb0fc0
movl -0x4(%rbp), %ecx
movq 0x16939a(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16938f(%rip), %rdx # 0x21a1d8
movl 0x18(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movq 0x169376(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16936b(%rip), %rcx # 0x21a1d8
movl 0x18(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movl 0x169c66(%rip), %ecx # 0x21aaf0
movq 0x169347(%rip), %rax # 0x21a1d8
movq 0x10(%rax), %rax
movq 0x16933c(%rip), %rdx # 0x21a1d8
movl 0x18(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
rlBegin:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax]
cmp eax, [rbp+var_4]
jz loc_B0EAF
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+4], 0
jle loc_B0E18
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
cmp dword ptr [rax], 1
jnz loc_B0CBE
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+4], 4
jge short loc_B0C61
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov edx, [rax+4]
mov [rbp+var_8], edx
jmp short loc_B0C91
loc_B0C61:
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax+4]
mov ecx, 4
cdq
idiv ecx
mov [rbp+var_8], edx
loc_B0C91:
mov ecx, [rbp+var_8]
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rdx, cs:RLGL
mov edx, [rdx+18h]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp loc_B0DA7
loc_B0CBE:
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
cmp dword ptr [rax], 4
jnz loc_B0D7C
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
cmp dword ptr [rax+4], 4
jge short loc_B0D1B
mov eax, 1
mov [rbp+var_C], eax
jmp short loc_B0D52
loc_B0D1B:
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax+4]
mov ecx, 4
cdq
idiv ecx
mov eax, 4
sub eax, edx
mov [rbp+var_C], eax
loc_B0D52:
mov ecx, [rbp+var_C]
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rdx, cs:RLGL
mov edx, [rdx+18h]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short loc_B0DA5
loc_B0D7C:
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov dword ptr [rax+8], 0
loc_B0DA5:
jmp short $+2
loc_B0DA7:
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov edi, [rax+8]
call rlCheckRenderBatchLimit
test al, 1
jnz short loc_B0E16
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov eax, [rax+8]
add eax, cs:dword_21A200
mov cs:dword_21A200, eax
mov rax, cs:RLGL
mov ecx, [rax+18h]
add ecx, 1
mov [rax+18h], ecx
loc_B0E16:
jmp short $+2
loc_B0E18:
mov rax, cs:RLGL
cmp dword ptr [rax+18h], 100h
jl short loc_B0E34
mov rdi, cs:RLGL
call rlDrawRenderBatch
loc_B0E34:
mov ecx, [rbp+var_4]
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rdx, cs:RLGL
mov edx, [rdx+18h]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov [rax], ecx
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rcx, cs:RLGL
mov ecx, [rcx+18h]
sub ecx, 1
movsxd rcx, ecx
shl rcx, 4
add rax, rcx
mov dword ptr [rax+4], 0
mov ecx, cs:dword_21AAF0
mov rax, cs:RLGL
mov rax, [rax+10h]
mov rdx, cs:RLGL
mov edx, [rdx+18h]
sub edx, 1
movsxd rdx, edx
shl rdx, 4
add rax, rdx
mov [rax+0Ch], ecx
loc_B0EAF:
add rsp, 10h
pop rbp
retn
|
long long rlBegin(int a1)
{
long long result; // rax
int v2; // [rsp+4h] [rbp-Ch]
int v3; // [rsp+8h] [rbp-8h]
result = *(unsigned int *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16));
if ( (_DWORD)result != a1 )
{
if ( *(int *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) > 0 )
{
if ( *(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16)) == 1 )
{
if ( *(int *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) >= 4 )
v3 = *(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) % 4;
else
v3 = *(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4);
*(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 8) = v3;
}
else if ( *(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16)) == 4 )
{
if ( *(int *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) >= 4 )
v2 = 4 - *(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) % 4;
else
v2 = 1;
*(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 8) = v2;
}
else
{
*(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 8) = 0;
}
if ( (rlCheckRenderBatchLimit(*(unsigned int *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1)
+ *(_QWORD *)(RLGL[0] + 16)
+ 8)) & 1) == 0 )
dword_21A200 += *(_DWORD *)(16LL * ((*(_DWORD *)(RLGL[0] + 24))++ - 1) + *(_QWORD *)(RLGL[0] + 16) + 8);
}
if ( *(int *)(RLGL[0] + 24) >= 256 )
rlDrawRenderBatch(RLGL[0]);
*(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16)) = a1;
*(_DWORD *)(16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16) + 4) = 0;
result = 16LL * (*(_DWORD *)(RLGL[0] + 24) - 1) + *(_QWORD *)(RLGL[0] + 16);
*(_DWORD *)(result + 12) = dword_21AAF0;
}
return result;
}
|
rlBegin:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0x4]
JZ 0x001b0eaf
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x4],0x0
JLE 0x001b0e18
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX],0x1
JNZ 0x001b0cbe
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x4],0x4
JGE 0x001b0c61
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EDX,dword ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x8],EDX
JMP 0x001b0c91
LAB_001b0c61:
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV ECX,0x4
CDQ
IDIV ECX
MOV dword ptr [RBP + -0x8],EDX
LAB_001b0c91:
MOV ECX,dword ptr [RBP + -0x8]
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [0x0031a1d8]
MOV EDX,dword ptr [RDX + 0x18]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x001b0da7
LAB_001b0cbe:
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX],0x4
JNZ 0x001b0d7c
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
CMP dword ptr [RAX + 0x4],0x4
JGE 0x001b0d1b
MOV EAX,0x1
MOV dword ptr [RBP + -0xc],EAX
JMP 0x001b0d52
LAB_001b0d1b:
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x4]
MOV ECX,0x4
CDQ
IDIV ECX
MOV EAX,0x4
SUB EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
LAB_001b0d52:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [0x0031a1d8]
MOV EDX,dword ptr [RDX + 0x18]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x001b0da5
LAB_001b0d7c:
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX + 0x8],0x0
LAB_001b0da5:
JMP 0x001b0da7
LAB_001b0da7:
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EDI,dword ptr [RAX + 0x8]
CALL 0x001b0ec0
TEST AL,0x1
JNZ 0x001b0e16
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
ADD EAX,dword ptr [0x0031a200]
MOV dword ptr [0x0031a200],EAX
MOV RAX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RAX + 0x18]
ADD ECX,0x1
MOV dword ptr [RAX + 0x18],ECX
LAB_001b0e16:
JMP 0x001b0e18
LAB_001b0e18:
MOV RAX,qword ptr [0x0031a1d8]
CMP dword ptr [RAX + 0x18],0x100
JL 0x001b0e34
MOV RDI,qword ptr [0x0031a1d8]
CALL 0x001b0fc0
LAB_001b0e34:
MOV ECX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [0x0031a1d8]
MOV EDX,dword ptr [RDX + 0x18]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RCX,qword ptr [0x0031a1d8]
MOV ECX,dword ptr [RCX + 0x18]
SUB ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x4
ADD RAX,RCX
MOV dword ptr [RAX + 0x4],0x0
MOV ECX,dword ptr [0x0031aaf0]
MOV RAX,qword ptr [0x0031a1d8]
MOV RAX,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [0x0031a1d8]
MOV EDX,dword ptr [RDX + 0x18]
SUB EDX,0x1
MOVSXD RDX,EDX
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0xc],ECX
LAB_001b0eaf:
ADD RSP,0x10
POP RBP
RET
|
void rlBegin(int param_1)
{
ulong uVar1;
int4 local_14;
int4 local_10;
if (*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10) != param_1) {
if (0 < *(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4)) {
if (*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10) == 1) {
if (*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4) < 4) {
local_10 = *(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4
);
}
else {
local_10 = *(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4
) % 4;
}
*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 8) = local_10;
}
else if (*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10) == 4) {
if (*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4) < 4) {
local_14 = 1;
}
else {
local_14 = 4 - *(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10
+ 4) % 4;
}
*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 8) = local_14;
}
else {
*(int4 *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 8) = 0;
}
uVar1 = rlCheckRenderBatchLimit
(*(int4 *)
(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 8));
if ((uVar1 & 1) == 0) {
DAT_0031a200 = *(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 +
8) + DAT_0031a200;
*(int *)(RLGL + 0x18) = *(int *)(RLGL + 0x18) + 1;
}
}
if (0xff < *(int *)(RLGL + 0x18)) {
rlDrawRenderBatch(RLGL);
}
*(int *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10) = param_1;
*(int4 *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 4) = 0;
*(int4 *)(*(long *)(RLGL + 0x10) + (long)(*(int *)(RLGL + 0x18) + -1) * 0x10 + 0xc) =
DAT_0031aaf0;
}
return;
}
|
|
57,685
|
rlBegin
|
csit-sgu[P]mit-game-2025-team-tyler/Libraries/raylib/src/rlgl.h
|
void rlBegin(int mode)
{
// Draw mode can be RL_LINES, RL_TRIANGLES and RL_QUADS
// NOTE: In all three cases, vertex are accumulated over default internal vertex buffer
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode != mode)
{
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount > 0)
{
// Make sure current RLGL.currentBatch->draws[i].vertexCount is aligned a multiple of 4,
// that way, following QUADS drawing will keep aligned with index processing
// It implies adding some extra alignment vertex at the end of the draw,
// those vertex are not processed but they are considered as an additional offset
// for the next set of vertex to be drawn
if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_LINES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount : RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4);
else if (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode == RL_TRIANGLES) RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = ((RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount < 4)? 1 : (4 - (RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount%4)));
else RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment = 0;
if (!rlCheckRenderBatchLimit(RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment))
{
RLGL.State.vertexCounter += RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexAlignment;
RLGL.currentBatch->drawCounter++;
}
}
if (RLGL.currentBatch->drawCounter >= RL_DEFAULT_BATCH_DRAWCALLS) rlDrawRenderBatch(RLGL.currentBatch);
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].mode = mode;
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].vertexCount = 0;
RLGL.currentBatch->draws[RLGL.currentBatch->drawCounter - 1].textureId = RLGL.State.defaultTextureId;
}
}
|
O3
|
c
|
rlBegin:
pushq %rbx
movl %edi, %ebx
movq 0xda0ad(%rip), %rdi # 0x13b118
movq 0x10(%rdi), %rcx
movslq 0x18(%rdi), %rax
movq %rax, %rdx
shlq $0x4, %rdx
movl -0x10(%rcx,%rdx), %esi
cmpl %ebx, %esi
je 0x61163
addq %rdx, %rcx
movl -0xc(%rcx), %edx
testl %edx, %edx
jle 0x61107
cmpl $0x4, %esi
je 0x610a3
xorl %eax, %eax
cmpl $0x1, %esi
jne 0x610ba
andl $0x3, %edx
movl %edx, %eax
jmp 0x610ba
movl %edx, %eax
andl $0x3, %eax
movl $0x4, %esi
subl %eax, %esi
cmpl $0x4, %edx
movl $0x1, %eax
cmovael %esi, %eax
movl %eax, -0x8(%rcx)
movq 0xda054(%rip), %rax # 0x13b118
movq 0x10(%rax), %rcx
movslq 0x18(%rax), %rax
shlq $0x4, %rax
movl -0x8(%rcx,%rax), %edi
callq 0x61165
movq 0xda038(%rip), %rdi # 0x13b118
testb %al, %al
je 0x610e9
movl 0x18(%rdi), %eax
jmp 0x61107
movq 0x10(%rdi), %rax
movslq 0x18(%rdi), %rcx
shlq $0x4, %rcx
movl -0x8(%rax,%rcx), %eax
addl %eax, 0xda041(%rip) # 0x13b140
movl 0x18(%rdi), %eax
incl %eax
movl %eax, 0x18(%rdi)
cmpl $0x100, %eax # imm = 0x100
jl 0x6111d
callq 0x611ec
movq 0xd9ffe(%rip), %rdi # 0x13b118
movl 0x18(%rdi), %eax
movq 0x10(%rdi), %rcx
cltq
shlq $0x4, %rax
movl %ebx, -0x10(%rcx,%rax)
movq 0xd9fe6(%rip), %rax # 0x13b118
movq 0x10(%rax), %rcx
movslq 0x18(%rax), %rax
shlq $0x4, %rax
movl $0x0, -0xc(%rcx,%rax)
movl 0xda8e4(%rip), %eax # 0x13ba30
movq 0xd9fc5(%rip), %rcx # 0x13b118
movq 0x10(%rcx), %rdx
movslq 0x18(%rcx), %rcx
shlq $0x4, %rcx
movl %eax, -0x4(%rdx,%rcx)
popq %rbx
retq
|
rlBegin:
push rbx
mov ebx, edi
mov rdi, cs:RLGL
mov rcx, [rdi+10h]
movsxd rax, dword ptr [rdi+18h]
mov rdx, rax
shl rdx, 4
mov esi, [rcx+rdx-10h]
cmp esi, ebx
jz loc_61163
add rcx, rdx
mov edx, [rcx-0Ch]
test edx, edx
jle short loc_61107
cmp esi, 4
jz short loc_610A3
xor eax, eax
cmp esi, 1
jnz short loc_610BA
and edx, 3
mov eax, edx
jmp short loc_610BA
loc_610A3:
mov eax, edx
and eax, 3
mov esi, 4
sub esi, eax
cmp edx, 4
mov eax, 1
cmovnb eax, esi
loc_610BA:
mov [rcx-8], eax
mov rax, cs:RLGL
mov rcx, [rax+10h]
movsxd rax, dword ptr [rax+18h]
shl rax, 4
mov edi, [rcx+rax-8]
call rlCheckRenderBatchLimit
mov rdi, cs:RLGL
test al, al
jz short loc_610E9
mov eax, [rdi+18h]
jmp short loc_61107
loc_610E9:
mov rax, [rdi+10h]
movsxd rcx, dword ptr [rdi+18h]
shl rcx, 4
mov eax, [rax+rcx-8]
add cs:dword_13B140, eax
mov eax, [rdi+18h]
inc eax
mov [rdi+18h], eax
loc_61107:
cmp eax, 100h
jl short loc_6111D
call rlDrawRenderBatch
mov rdi, cs:RLGL
mov eax, [rdi+18h]
loc_6111D:
mov rcx, [rdi+10h]
cdqe
shl rax, 4
mov [rcx+rax-10h], ebx
mov rax, cs:RLGL
mov rcx, [rax+10h]
movsxd rax, dword ptr [rax+18h]
shl rax, 4
mov dword ptr [rcx+rax-0Ch], 0
mov eax, cs:dword_13BA30
mov rcx, cs:RLGL
mov rdx, [rcx+10h]
movsxd rcx, dword ptr [rcx+18h]
shl rcx, 4
mov [rdx+rcx-4], eax
loc_61163:
pop rbx
retn
|
long long rlBegin(int a1)
{
long long v2; // rdi
long long v3; // rcx
long long result; // rax
int v5; // esi
long long v6; // rcx
int v7; // edx
int v8; // eax
char v9; // al
v2 = RLGL;
v3 = *(_QWORD *)(RLGL + 16);
result = *(int *)(RLGL + 24);
v5 = *(_DWORD *)(v3 + 16 * result - 16);
if ( v5 != a1 )
{
v6 = 16 * result + v3;
v7 = *(_DWORD *)(v6 - 12);
if ( v7 > 0 )
{
if ( v5 == 4 )
{
v8 = 1;
if ( (unsigned int)v7 >= 4 )
v8 = 4 - (*(_DWORD *)(v6 - 12) & 3);
}
else
{
v8 = 0;
if ( v5 == 1 )
v8 = *(_DWORD *)(v6 - 12) & 3;
}
*(_DWORD *)(v6 - 8) = v8;
v9 = rlCheckRenderBatchLimit(*(unsigned int *)(*(_QWORD *)(RLGL + 16) + 16LL * *(int *)(RLGL + 24) - 8));
v2 = RLGL;
if ( v9 )
{
LODWORD(result) = *(_DWORD *)(RLGL + 24);
}
else
{
dword_13B140 += *(_DWORD *)(*(_QWORD *)(RLGL + 16) + 16LL * *(int *)(RLGL + 24) - 8);
LODWORD(result) = *(_DWORD *)(RLGL + 24) + 1;
*(_DWORD *)(RLGL + 24) = result;
}
}
if ( (int)result >= 256 )
{
rlDrawRenderBatch();
v2 = RLGL;
LODWORD(result) = *(_DWORD *)(RLGL + 24);
}
*(_DWORD *)(*(_QWORD *)(v2 + 16) + 16LL * (int)result - 16) = a1;
*(_DWORD *)(*(_QWORD *)(RLGL + 16) + 16LL * *(int *)(RLGL + 24) - 12) = 0;
result = (unsigned int)dword_13BA30;
*(_DWORD *)(*(_QWORD *)(RLGL + 16) + 16LL * *(int *)(RLGL + 24) - 4) = dword_13BA30;
}
return result;
}
|
rlBegin:
PUSH RBX
MOV EBX,EDI
MOV RDI,qword ptr [0x0023b118]
MOV RCX,qword ptr [RDI + 0x10]
MOVSXD RAX,dword ptr [RDI + 0x18]
MOV RDX,RAX
SHL RDX,0x4
MOV ESI,dword ptr [RCX + RDX*0x1 + -0x10]
CMP ESI,EBX
JZ 0x00161163
ADD RCX,RDX
MOV EDX,dword ptr [RCX + -0xc]
TEST EDX,EDX
JLE 0x00161107
CMP ESI,0x4
JZ 0x001610a3
XOR EAX,EAX
CMP ESI,0x1
JNZ 0x001610ba
AND EDX,0x3
MOV EAX,EDX
JMP 0x001610ba
LAB_001610a3:
MOV EAX,EDX
AND EAX,0x3
MOV ESI,0x4
SUB ESI,EAX
CMP EDX,0x4
MOV EAX,0x1
CMOVNC EAX,ESI
LAB_001610ba:
MOV dword ptr [RCX + -0x8],EAX
MOV RAX,qword ptr [0x0023b118]
MOV RCX,qword ptr [RAX + 0x10]
MOVSXD RAX,dword ptr [RAX + 0x18]
SHL RAX,0x4
MOV EDI,dword ptr [RCX + RAX*0x1 + -0x8]
CALL 0x00161165
MOV RDI,qword ptr [0x0023b118]
TEST AL,AL
JZ 0x001610e9
MOV EAX,dword ptr [RDI + 0x18]
JMP 0x00161107
LAB_001610e9:
MOV RAX,qword ptr [RDI + 0x10]
MOVSXD RCX,dword ptr [RDI + 0x18]
SHL RCX,0x4
MOV EAX,dword ptr [RAX + RCX*0x1 + -0x8]
ADD dword ptr [0x0023b140],EAX
MOV EAX,dword ptr [RDI + 0x18]
INC EAX
MOV dword ptr [RDI + 0x18],EAX
LAB_00161107:
CMP EAX,0x100
JL 0x0016111d
CALL 0x001611ec
MOV RDI,qword ptr [0x0023b118]
MOV EAX,dword ptr [RDI + 0x18]
LAB_0016111d:
MOV RCX,qword ptr [RDI + 0x10]
CDQE
SHL RAX,0x4
MOV dword ptr [RCX + RAX*0x1 + -0x10],EBX
MOV RAX,qword ptr [0x0023b118]
MOV RCX,qword ptr [RAX + 0x10]
MOVSXD RAX,dword ptr [RAX + 0x18]
SHL RAX,0x4
MOV dword ptr [RCX + RAX*0x1 + -0xc],0x0
MOV EAX,dword ptr [0x0023ba30]
MOV RCX,qword ptr [0x0023b118]
MOV RDX,qword ptr [RCX + 0x10]
MOVSXD RCX,dword ptr [RCX + 0x18]
SHL RCX,0x4
MOV dword ptr [RDX + RCX*0x1 + -0x4],EAX
LAB_00161163:
POP RBX
RET
|
void rlBegin(int param_1)
{
int iVar1;
uint uVar2;
char cVar3;
uint uVar4;
int iVar5;
long lVar6;
long lVar7;
iVar5 = *(int *)(RLGL + 0x18);
iVar1 = *(int *)(*(long *)(RLGL + 0x10) + -0x10 + (long)iVar5 * 0x10);
if (iVar1 != param_1) {
lVar6 = *(long *)(RLGL + 0x10) + (long)iVar5 * 0x10;
uVar2 = *(uint *)(lVar6 + -0xc);
lVar7 = RLGL;
if (0 < (int)uVar2) {
if (iVar1 == 4) {
uVar4 = 1;
if (3 < uVar2) {
uVar4 = 4 - (uVar2 & 3);
}
}
else {
uVar4 = 0;
if (iVar1 == 1) {
uVar4 = uVar2 & 3;
}
}
*(uint *)(lVar6 + -8) = uVar4;
cVar3 = rlCheckRenderBatchLimit
(*(int4 *)
(*(long *)(RLGL + 0x10) + -8 + (long)*(int *)(RLGL + 0x18) * 0x10));
lVar7 = RLGL;
if (cVar3 == '\0') {
DAT_0023b140 = DAT_0023b140 +
*(int *)(*(long *)(RLGL + 0x10) + -8 + (long)*(int *)(RLGL + 0x18) * 0x10);
iVar5 = *(int *)(RLGL + 0x18) + 1;
*(int *)(RLGL + 0x18) = iVar5;
}
else {
iVar5 = *(int *)(RLGL + 0x18);
}
}
if (0xff < iVar5) {
rlDrawRenderBatch();
iVar5 = *(int *)(RLGL + 0x18);
lVar7 = RLGL;
}
*(int *)(*(long *)(lVar7 + 0x10) + -0x10 + (long)iVar5 * 0x10) = param_1;
*(int4 *)(*(long *)(RLGL + 0x10) + -0xc + (long)*(int *)(RLGL + 0x18) * 0x10) = 0;
*(int4 *)(*(long *)(RLGL + 0x10) + -4 + (long)*(int *)(RLGL + 0x18) * 0x10) = DAT_0023ba30
;
}
return;
}
|
|
57,686
|
call_handler
|
bluesky950520[P]quickjs/quickjs-libc.c
|
static int call_handler(JSContext *ctx, JSValue func)
{
int r;
JSValue ret, func1;
/* 'func' might be destroyed when calling itself (if it frees the
handler), so must take extra care */
func1 = JS_DupValue(ctx, func);
ret = JS_Call(ctx, func1, JS_UNDEFINED, 0, NULL);
JS_FreeValue(ctx, func1);
r = 0;
if (JS_IsException(ret)) {
JSRuntime *rt = JS_GetRuntime(ctx);
JSThreadState *ts = js_get_thread_state(rt);
ts->exc = JS_GetException(ctx);
r = -1;
}
JS_FreeValue(ctx, ret);
return r;
}
|
O1
|
c
|
call_handler:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1ca5a
movq %rax, %r13
movq %rdx, %rbp
movq $0x0, (%rsp)
xorl %r12d, %r12d
movl $0x3, %r8d
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x28490
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1d8b3
cmpl $0x6, %r15d
jne 0x1b09b
movq %rbx, %rdi
callq 0x1fd7e
xorl %edi, %edi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3a5f3
movq %rax, %r12
movq %rbx, %rdi
callq 0x2236b
movq %rax, 0x50(%r12)
movq %rdx, 0x58(%r12)
movl $0xffffffff, %r12d # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d8b3
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
call_handler:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
call JS_DupValue
mov r13, rax
mov rbp, rdx
mov [rsp+38h+var_38], 0
xor r12d, r12d
mov r8d, 3
mov rdi, rbx
mov rsi, rax
xor ecx, ecx
xor r9d, r9d
call JS_Call
mov r14, rax
mov r15, rdx
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
call JS_FreeValue
cmp r15d, 6
jnz short loc_1B09B
mov rdi, rbx
call JS_GetRuntime
xor edi, edi
mov rsi, rax
xor eax, eax
call js_std_cmd
mov r12, rax
mov rdi, rbx
call JS_GetException
mov [r12+50h], rax
mov [r12+58h], rdx
mov r12d, 0FFFFFFFFh
loc_1B09B:
mov rdi, rbx
mov rsi, r14
mov rdx, r15
call JS_FreeValue
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long call_handler(long long a1, long long a2, long long a3)
{
long long v3; // r13
long long v4; // rdx
long long v5; // rbp
unsigned int v6; // r12d
long long v7; // r14
long long v8; // rdx
long long v9; // r15
int Runtime; // eax
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // r12
long long v16; // rdx
v3 = JS_DupValue(a1, a2, a3);
v5 = v4;
v6 = 0;
v7 = JS_Call(a1, v3, v4, 0, 3, 0, 0LL);
v9 = v8;
JS_FreeValue(a1, v3, v5);
if ( (_DWORD)v9 == 6 )
{
Runtime = JS_GetRuntime(a1);
v15 = js_std_cmd(0, Runtime, v11, v12, v13, v14);
*(_QWORD *)(v15 + 80) = JS_GetException(a1);
*(_QWORD *)(v15 + 88) = v16;
v6 = -1;
}
JS_FreeValue(a1, v7, v9);
return v6;
}
|
call_handler:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0011ca5a
MOV R13,RAX
MOV RBP,RDX
MOV qword ptr [RSP],0x0
XOR R12D,R12D
MOV R8D,0x3
MOV RDI,RBX
MOV RSI,RAX
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00128490
MOV R14,RAX
MOV R15,RDX
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
CALL 0x0011d8b3
CMP R15D,0x6
JNZ 0x0011b09b
MOV RDI,RBX
CALL 0x0011fd7e
XOR EDI,EDI
MOV RSI,RAX
XOR EAX,EAX
CALL 0x0013a5f3
MOV R12,RAX
MOV RDI,RBX
CALL 0x0012236b
MOV qword ptr [R12 + 0x50],RAX
MOV qword ptr [R12 + 0x58],RDX
MOV R12D,0xffffffff
LAB_0011b09b:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
CALL 0x0011d8b3
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 call_handler(int8 param_1)
{
int8 uVar1;
long lVar2;
int1 auVar3 [16];
int1 auVar4 [16];
auVar3 = JS_DupValue();
uVar1 = 0;
auVar4 = JS_Call(param_1,auVar3._0_8_,auVar3._8_8_,0,3,0,0);
JS_FreeValue(param_1,auVar3._0_8_,auVar3._8_8_);
if (auVar4._8_4_ == 6) {
uVar1 = JS_GetRuntime(param_1);
lVar2 = js_std_cmd(0,uVar1);
auVar3 = JS_GetException(param_1);
*(int1 (*) [16])(lVar2 + 0x50) = auVar3;
uVar1 = 0xffffffff;
}
JS_FreeValue(param_1,auVar4._0_8_,auVar4._8_8_);
return uVar1;
}
|
|
57,687
|
ggml_soft_max_impl
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c
|
static struct ggml_tensor * ggml_soft_max_impl(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * mask,
float scale,
float max_bias,
bool inplace) {
GGML_ASSERT(ggml_is_contiguous(a));
if (mask) {
GGML_ASSERT(mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32);
GGML_ASSERT(ggml_is_contiguous(mask));
GGML_ASSERT(ggml_is_matrix(mask));
GGML_ASSERT(mask->ne[0] == a->ne[0]);
GGML_ASSERT(mask->ne[1] >= a->ne[1]);
}
if (max_bias > 0.0f) {
GGML_ASSERT(mask);
}
struct ggml_tensor * result = inplace ? ggml_view_tensor(ctx, a) : ggml_dup_tensor(ctx, a);
float params[] = { scale, max_bias };
ggml_set_op_params(result, params, sizeof(params));
result->op = GGML_OP_SOFT_MAX;
result->src[0] = a;
result->src[1] = mask;
return result;
}
|
O3
|
c
|
ggml_soft_max_impl:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movss %xmm1, (%rsp)
movss %xmm0, 0x4(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1a0b9
testb %al, %al
je 0x1d048
testq %rbx, %rbx
je 0x1cfb2
cmpl $0x2, (%rbx)
jae 0x1d083
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a0b9
testb %al, %al
je 0x1d09f
cmpq $0x1, 0x20(%rbx)
jne 0x1d029
cmpq $0x1, 0x28(%rbx)
jne 0x1d029
movq 0x10(%rbx), %rax
cmpq 0x10(%r14), %rax
jne 0x1d0bb
movq 0x18(%rbx), %rax
cmpq 0x18(%r14), %rax
jge 0x1cfc3
leaq 0x2f679(%rip), %rdi # 0x4c613
leaq 0x2f6c4(%rip), %rdx # 0x4c665
leaq 0x319b7(%rip), %rcx # 0x4e95f
movl $0xd55, %esi # imm = 0xD55
jmp 0x1d0f1
xorps %xmm0, %xmm0
movss (%rsp), %xmm1
ucomiss %xmm0, %xmm1
ja 0x1d0d7
testb %bpl, %bpl
je 0x1cfd5
movq %r15, %rdi
movq %r14, %rsi
callq 0x16260
jmp 0x1cfef
movl (%r14), %esi
leaq 0x10(%r14), %rcx
movq %r15, %rdi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a57f
testq %rax, %rax
je 0x1d067
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x54(%rax)
movss (%rsp), %xmm0
movss %xmm0, 0x58(%rax)
movl $0x2a, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f5e3(%rip), %rdi # 0x4c613
leaq 0x2f62e(%rip), %rdx # 0x4c665
leaq 0x318f4(%rip), %rcx # 0x4e932
movl $0xd53, %esi # imm = 0xD53
jmp 0x1d0f1
leaq 0x2f5c4(%rip), %rdi # 0x4c613
leaq 0x2f60f(%rip), %rdx # 0x4c665
leaq 0x2f9c7(%rip), %rcx # 0x4ca24
movl $0xd4e, %esi # imm = 0xD4E
jmp 0x1d0f1
leaq 0x316fb(%rip), %rdi # 0x4e769
leaq 0x2f5f0(%rip), %rdx # 0x4c665
leaq 0x3181a(%rip), %rcx # 0x4e896
movl $0x70, %esi
jmp 0x1d0f1
leaq 0x2f589(%rip), %rdi # 0x4c613
leaq 0x2f5d4(%rip), %rdx # 0x4c665
leaq 0x3185f(%rip), %rcx # 0x4e8f7
movl $0xd51, %esi # imm = 0xD51
jmp 0x1d0f1
leaq 0x2f56d(%rip), %rdi # 0x4c613
leaq 0x2f5b8(%rip), %rdx # 0x4c665
leaq 0x2fda2(%rip), %rcx # 0x4ce56
movl $0xd52, %esi # imm = 0xD52
jmp 0x1d0f1
leaq 0x2f551(%rip), %rdi # 0x4c613
leaq 0x2f59c(%rip), %rdx # 0x4c665
leaq 0x31877(%rip), %rcx # 0x4e947
movl $0xd54, %esi # imm = 0xD54
jmp 0x1d0f1
leaq 0x2f535(%rip), %rdi # 0x4c613
leaq 0x2f580(%rip), %rdx # 0x4c665
leaq 0x2fe47(%rip), %rcx # 0x4cf33
movl $0xd59, %esi # imm = 0xD59
xorl %eax, %eax
callq 0x17cd0
|
ggml_soft_max_impl:
push rbp
push r15
push r14
push rbx
push rax
mov ebp, ecx
movss [rsp+28h+var_28], xmm1
movss [rsp+28h+var_24], xmm0
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, rsi
xor esi, esi
call ggml_is_contiguous_n
test al, al
jz loc_1D048
test rbx, rbx
jz short loc_1CFB2
cmp dword ptr [rbx], 2
jnb loc_1D083
mov rdi, rbx
xor esi, esi
call ggml_is_contiguous_n
test al, al
jz loc_1D09F
cmp qword ptr [rbx+20h], 1
jnz loc_1D029
cmp qword ptr [rbx+28h], 1
jnz loc_1D029
mov rax, [rbx+10h]
cmp rax, [r14+10h]
jnz loc_1D0BB
mov rax, [rbx+18h]
cmp rax, [r14+18h]
jge short loc_1CFC3
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMaskNe1ANe1; "mask->ne[1] >= a->ne[1]"
mov esi, 0D55h
jmp loc_1D0F1
loc_1CFB2:
xorps xmm0, xmm0
movss xmm1, [rsp+28h+var_28]
ucomiss xmm1, xmm0
ja loc_1D0D7
loc_1CFC3:
test bpl, bpl
jz short loc_1CFD5
mov rdi, r15
mov rsi, r14
call _ggml_view_tensor
jmp short loc_1CFEF
loc_1CFD5:
mov esi, [r14]
lea rcx, [r14+10h]
mov rdi, r15
mov edx, 4
xor r8d, r8d
xor r9d, r9d
call ggml_new_tensor_impl
loc_1CFEF:
test rax, rax
jz short loc_1D067
movss xmm0, [rsp+28h+var_24]
movss dword ptr [rax+54h], xmm0
movss xmm0, [rsp+28h+var_28]
movss dword ptr [rax+58h], xmm0
mov dword ptr [rax+50h], 2Ah ; '*'
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_1D029:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsMatrixMa; "ggml_is_matrix(mask)"
mov esi, 0D53h
jmp loc_1D0F1
loc_1D048:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_3; "ggml_is_contiguous(a)"
mov esi, 0D4Eh
jmp loc_1D0F1
loc_1D067:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorNull; "tensor != NULL"
mov esi, 70h ; 'p'
jmp short loc_1D0F1
loc_1D083:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMaskTypeGgmlTy; "mask->type == GGML_TYPE_F16 || mask->ty"...
mov esi, 0D51h
jmp short loc_1D0F1
loc_1D09F:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_4; "ggml_is_contiguous(mask)"
mov esi, 0D52h
jmp short loc_1D0F1
loc_1D0BB:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMaskNe0ANe0; "mask->ne[0] == a->ne[0]"
mov esi, 0D54h
jmp short loc_1D0F1
loc_1D0D7:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aMask; "mask"
mov esi, 0D59h
loc_1D0F1:
xor eax, eax
call _ggml_abort
|
long long ggml_soft_max_impl(long long a1, long long a2, long long a3, char a4, double a5, float a6)
{
int v8; // r8d
int v9; // r9d
const char *v10; // rdi
const char *v11; // rcx
int v12; // esi
long long result; // rax
int v14; // [rsp+4h] [rbp-24h]
v14 = LODWORD(a5);
if ( !ggml_is_contiguous_n((unsigned int *)a2, 0) )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "ggml_is_contiguous(a)";
v12 = 3406;
goto LABEL_23;
}
if ( !a3 )
{
a5 = 0.0;
if ( a6 <= 0.0 )
goto LABEL_11;
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "mask";
v12 = 3417;
LABEL_23:
ggml_abort((_DWORD)v10, v12, (unsigned int)"GGML_ASSERT(%s) failed", (_DWORD)v11, v8, v9);
}
if ( *(_DWORD *)a3 >= 2u )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32";
v12 = 3409;
goto LABEL_23;
}
if ( !ggml_is_contiguous_n((unsigned int *)a3, 0) )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "ggml_is_contiguous(mask)";
v12 = 3410;
goto LABEL_23;
}
if ( *(_QWORD *)(a3 + 32) != 1LL || *(_QWORD *)(a3 + 40) != 1LL )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "ggml_is_matrix(mask)";
v12 = 3411;
goto LABEL_23;
}
if ( *(_QWORD *)(a3 + 16) != *(_QWORD *)(a2 + 16) )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "mask->ne[0] == a->ne[0]";
v12 = 3412;
goto LABEL_23;
}
if ( *(_QWORD *)(a3 + 24) < *(_QWORD *)(a2 + 24) )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
v11 = "mask->ne[1] >= a->ne[1]";
v12 = 3413;
goto LABEL_23;
}
LABEL_11:
if ( a4 )
result = ggml_view_tensor(a1, a2, a5);
else
result = ggml_new_tensor_impl(a1, *(_DWORD *)a2, 4u, (long long *)(a2 + 16), 0LL, 0LL, a5);
if ( !result )
{
v10 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h";
v11 = "tensor != NULL";
v12 = 112;
goto LABEL_23;
}
*(_DWORD *)(result + 84) = v14;
*(float *)(result + 88) = a6;
*(_DWORD *)(result + 80) = 42;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
|
ggml_soft_max_impl:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBP,ECX
MOVSS dword ptr [RSP],XMM1
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,RSI
XOR ESI,ESI
CALL 0x0011a0b9
TEST AL,AL
JZ 0x0011d048
TEST RBX,RBX
JZ 0x0011cfb2
CMP dword ptr [RBX],0x2
JNC 0x0011d083
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0011a0b9
TEST AL,AL
JZ 0x0011d09f
CMP qword ptr [RBX + 0x20],0x1
JNZ 0x0011d029
CMP qword ptr [RBX + 0x28],0x1
JNZ 0x0011d029
MOV RAX,qword ptr [RBX + 0x10]
CMP RAX,qword ptr [R14 + 0x10]
JNZ 0x0011d0bb
MOV RAX,qword ptr [RBX + 0x18]
CMP RAX,qword ptr [R14 + 0x18]
JGE 0x0011cfc3
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14e95f]
MOV ESI,0xd55
JMP 0x0011d0f1
LAB_0011cfb2:
XORPS XMM0,XMM0
MOVSS XMM1,dword ptr [RSP]
UCOMISS XMM1,XMM0
JA 0x0011d0d7
LAB_0011cfc3:
TEST BPL,BPL
JZ 0x0011cfd5
MOV RDI,R15
MOV RSI,R14
CALL 0x00116260
JMP 0x0011cfef
LAB_0011cfd5:
MOV ESI,dword ptr [R14]
LEA RCX,[R14 + 0x10]
MOV RDI,R15
MOV EDX,0x4
XOR R8D,R8D
XOR R9D,R9D
CALL 0x0011a57f
LAB_0011cfef:
TEST RAX,RAX
JZ 0x0011d067
MOVSS XMM0,dword ptr [RSP + 0x4]
MOVSS dword ptr [RAX + 0x54],XMM0
MOVSS XMM0,dword ptr [RSP]
MOVSS dword ptr [RAX + 0x58],XMM0
MOV dword ptr [RAX + 0x50],0x2a
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0011d029:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14e932]
MOV ESI,0xd53
JMP 0x0011d0f1
LAB_0011d048:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14ca24]
MOV ESI,0xd4e
JMP 0x0011d0f1
LAB_0011d067:
LEA RDI,[0x14e769]
LEA RDX,[0x14c665]
LEA RCX,[0x14e896]
MOV ESI,0x70
JMP 0x0011d0f1
LAB_0011d083:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14e8f7]
MOV ESI,0xd51
JMP 0x0011d0f1
LAB_0011d09f:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14ce56]
MOV ESI,0xd52
JMP 0x0011d0f1
LAB_0011d0bb:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14e947]
MOV ESI,0xd54
JMP 0x0011d0f1
LAB_0011d0d7:
LEA RDI,[0x14c613]
LEA RDX,[0x14c665]
LEA RCX,[0x14cf33]
MOV ESI,0xd59
LAB_0011d0f1:
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_soft_max_impl(int4 param_1,float param_2,int8 param_3,int4 *param_4,
uint *param_5,char param_6)
{
char cVar1;
long lVar2;
char *pcVar3;
int8 uVar4;
char *pcVar5;
cVar1 = ggml_is_contiguous_n(param_4,0);
if (cVar1 == '\0') {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "ggml_is_contiguous(a)";
uVar4 = 0xd4e;
goto LAB_0011d0f1;
}
if (param_5 == (uint *)0x0) {
if (0.0 < param_2) {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "mask";
uVar4 = 0xd59;
goto LAB_0011d0f1;
}
}
else {
if (1 < *param_5) {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "mask->type == GGML_TYPE_F16 || mask->type == GGML_TYPE_F32";
uVar4 = 0xd51;
goto LAB_0011d0f1;
}
cVar1 = ggml_is_contiguous_n(param_5,0);
if (cVar1 == '\0') {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "ggml_is_contiguous(mask)";
uVar4 = 0xd52;
goto LAB_0011d0f1;
}
if ((*(long *)(param_5 + 8) != 1) || (*(long *)(param_5 + 10) != 1)) {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "ggml_is_matrix(mask)";
uVar4 = 0xd53;
goto LAB_0011d0f1;
}
if (*(long *)(param_5 + 4) != *(long *)(param_4 + 4)) {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "mask->ne[0] == a->ne[0]";
uVar4 = 0xd54;
goto LAB_0011d0f1;
}
if (*(long *)(param_5 + 6) < *(long *)(param_4 + 6)) {
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml.c";
pcVar3 = "mask->ne[1] >= a->ne[1]";
uVar4 = 0xd55;
goto LAB_0011d0f1;
}
}
if (param_6 == '\0') {
lVar2 = ggml_new_tensor_impl(param_3,*param_4,4,param_4 + 4,0,0);
}
else {
lVar2 = ggml_view_tensor(param_3,param_4);
}
if (lVar2 != 0) {
*(int4 *)(lVar2 + 0x54) = param_1;
*(float *)(lVar2 + 0x58) = param_2;
*(int4 *)(lVar2 + 0x50) = 0x2a;
*(int4 **)(lVar2 + 0x98) = param_4;
*(uint **)(lVar2 + 0xa0) = param_5;
return;
}
pcVar5 = "/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-impl.h";
pcVar3 = "tensor != NULL";
uVar4 = 0x70;
LAB_0011d0f1:
/* WARNING: Subroutine does not return */
ggml_abort(pcVar5,uVar4,"GGML_ASSERT(%s) failed",pcVar3);
}
|
|
57,688
|
flux::parser::CallExpr::clone() const
|
kvthweatt[P]FluxLang/src/parser/ast.cpp
|
std::unique_ptr<Expr> CallExpr::clone() const {
std::vector<std::unique_ptr<Expr>> clonedArgs;
for (const auto& arg : arguments) {
clonedArgs.push_back(arg->clone());
}
return std::make_unique<CallExpr>(callee->clone(), paren, std::move(clonedArgs), range);
}
|
O0
|
cpp
|
flux::parser::CallExpr::clone() const:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1da60
movq -0x78(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1da80
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1dab0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1dae0
testb $0x1, %al
jne 0x1a3cd
jmp 0x1a443
leaq -0x38(%rbp), %rdi
callq 0x1db20
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1d600
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0x1a3f5
leaq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1db40
jmp 0x1a404
leaq -0x50(%rbp), %rdi
callq 0x1d6d0
leaq -0x38(%rbp), %rdi
callq 0x1db70
jmp 0x1a3ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1a4d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1d6d0
jmp 0x1a4d1
movq -0x78(%rbp), %rdi
addq $0x28, %rdi
callq 0x1d600
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0x1a462
movq -0x78(%rbp), %r8
movq %r8, %rdx
addq $0x30, %rdx
addq $0x8, %r8
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x28(%rbp), %rcx
callq 0x1db90
jmp 0x1a484
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1dc90
leaq -0x68(%rbp), %rdi
callq 0x1dce0
leaq -0x70(%rbp), %rdi
callq 0x1d6d0
leaq -0x28(%rbp), %rdi
callq 0x1dd40
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d6d0
leaq -0x28(%rbp), %rdi
callq 0x1dd40
movq -0x58(%rbp), %rdi
callq 0x75a0
nopw %cs:(%rax,%rax)
|
_ZNK4flux6parser8CallExpr5cloneEv:
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_88], rdi
mov rax, rdi
mov [rbp+var_80], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_78], rax
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EEC2Ev; std::vector<std::unique_ptr<flux::parser::Expr>>::vector(void)
mov rax, [rbp+var_78]
add rax, 90h
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
call _ZNKSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EE5beginEv; std::vector<std::unique_ptr<flux::parser::Expr>>::begin(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
call _ZNKSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EE3endEv; std::vector<std::unique_ptr<flux::parser::Expr>>::end(void)
mov [rbp+var_40], rax
loc_1A3BA:
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_40]
call _ZN9__gnu_cxxneIPKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEEbRKNS_17__normal_iteratorIT_T0_EESI_; __gnu_cxx::operator!=<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>(__gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>> const&,__gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>> const&)
test al, 1
jnz short loc_1A3CD
jmp short loc_1A443
loc_1A3CD:
lea rdi, [rbp+var_38]
call _ZNK9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEdeEv; __gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>::operator*(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_48]
call _ZNKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEptEv; std::unique_ptr<flux::parser::Expr>::operator->(void)
mov rsi, rax
mov rax, [rsi]
mov rax, [rax+18h]
lea rdi, [rbp+var_50]
call rax
jmp short $+2
loc_1A3F5:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_50]
call _ZNSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EE9push_backEOS6_; std::vector<std::unique_ptr<flux::parser::Expr>>::push_back(std::unique_ptr<flux::parser::Expr>&&)
jmp short $+2
loc_1A404:
lea rdi, [rbp+var_50]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
lea rdi, [rbp+var_38]
call _ZN9__gnu_cxx17__normal_iteratorIPKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS4_EESt6vectorIS7_SaIS7_EEEppEv; __gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>::operator++(void)
jmp short loc_1A3BA
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
jmp loc_1A4D1
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
lea rdi, [rbp+var_50]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
jmp loc_1A4D1
loc_1A443:
mov rdi, [rbp+var_78]
add rdi, 28h ; '('
call _ZNKSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEptEv; std::unique_ptr<flux::parser::Expr>::operator->(void)
mov rsi, rax
mov rax, [rsi]
mov rax, [rax+18h]
lea rdi, [rbp+var_70]
call rax
jmp short $+2
loc_1A462:
mov r8, [rbp+var_78]
mov rdx, r8
add rdx, 30h ; '0'
add r8, 8
lea rdi, [rbp+var_68]
lea rsi, [rbp+var_70]
lea rcx, [rbp+var_28]
call _ZSt11make_uniqueIN4flux6parser8CallExprEJSt10unique_ptrINS1_4ExprESt14default_deleteIS4_EERKNS0_5lexer5TokenESt6vectorIS7_SaIS7_EERKNS0_6common11SourceRangeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<flux::parser::CallExpr,std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,std::vector<std::unique_ptr<flux::parser::Expr>>,flux::common::SourceRange const&>(std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,std::vector<std::unique_ptr<flux::parser::Expr>>,flux::common::SourceRange const&)
jmp short $+2
loc_1A484:
mov rdi, [rbp+var_88]
lea rsi, [rbp+var_68]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EEC2INS1_8CallExprES3_IS7_EvEEOS_IT_T0_E; std::unique_ptr<flux::parser::Expr>::unique_ptr<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>,void>(std::unique_ptr&&<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>>)
lea rdi, [rbp+var_68]
call _ZNSt10unique_ptrIN4flux6parser8CallExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::CallExpr>::~unique_ptr()
lea rdi, [rbp+var_70]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EED2Ev; std::vector<std::unique_ptr<flux::parser::Expr>>::~vector()
mov rax, [rbp+var_80]
add rsp, 90h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_58], rcx
mov [rbp+var_5C], eax
lea rdi, [rbp+var_70]
call _ZNSt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS2_EED2Ev; std::unique_ptr<flux::parser::Expr>::~unique_ptr()
loc_1A4D1:
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10unique_ptrIN4flux6parser4ExprESt14default_deleteIS3_EESaIS6_EED2Ev; std::vector<std::unique_ptr<flux::parser::Expr>>::~vector()
mov rdi, [rbp+var_58]
call __Unwind_Resume
|
flux::parser::CallExpr * flux::parser::CallExpr::clone(flux::parser::CallExpr *this, long long a2)
{
long long v2; // rsi
long long v3; // rsi
_BYTE v6[8]; // [rsp+20h] [rbp-70h] BYREF
_BYTE v7[12]; // [rsp+28h] [rbp-68h] BYREF
_BYTE v8[8]; // [rsp+40h] [rbp-50h] BYREF
long long v9; // [rsp+48h] [rbp-48h]
long long v10; // [rsp+50h] [rbp-40h] BYREF
_QWORD v11[2]; // [rsp+58h] [rbp-38h] BYREF
_BYTE v12[24]; // [rsp+68h] [rbp-28h] BYREF
long long v13; // [rsp+80h] [rbp-10h]
flux::parser::CallExpr *v14; // [rsp+88h] [rbp-8h]
v14 = this;
v13 = a2;
std::vector<std::unique_ptr<flux::parser::Expr>>::vector(v12);
v11[1] = a2 + 144;
v11[0] = std::vector<std::unique_ptr<flux::parser::Expr>>::begin(a2 + 144);
v10 = std::vector<std::unique_ptr<flux::parser::Expr>>::end(a2 + 144);
while ( (__gnu_cxx::operator!=<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>(
v11,
&v10) & 1) != 0 )
{
v9 = __gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>::operator*(v11);
v2 = std::unique_ptr<flux::parser::Expr>::operator->(v9);
(*(void ( **)(_BYTE *))(*(_QWORD *)v2 + 24LL))(v8);
std::vector<std::unique_ptr<flux::parser::Expr>>::push_back(v12, v8);
std::unique_ptr<flux::parser::Expr>::~unique_ptr(v8);
__gnu_cxx::__normal_iterator<std::unique_ptr<flux::parser::Expr> const*,std::vector<std::unique_ptr<flux::parser::Expr>>>::operator++(v11);
}
v3 = std::unique_ptr<flux::parser::Expr>::operator->(a2 + 40);
(*(void ( **)(_BYTE *))(*(_QWORD *)v3 + 24LL))(v6);
std::make_unique<flux::parser::CallExpr,std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,std::vector<std::unique_ptr<flux::parser::Expr>>,flux::common::SourceRange const&>(
v7,
v6,
a2 + 48,
v12,
a2 + 8);
std::unique_ptr<flux::parser::Expr>::unique_ptr<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>,void>(
this,
v7);
std::unique_ptr<flux::parser::CallExpr>::~unique_ptr(v7);
std::unique_ptr<flux::parser::Expr>::~unique_ptr(v6);
std::vector<std::unique_ptr<flux::parser::Expr>>::~vector(v12);
return this;
}
|
clone:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x78],RAX
LEA RDI,[RBP + -0x28]
CALL 0x0011da60
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x90
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0011da80
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x0011dab0
MOV qword ptr [RBP + -0x40],RAX
LAB_0011a3ba:
LEA RDI,[RBP + -0x38]
LEA RSI,[RBP + -0x40]
CALL 0x0011dae0
TEST AL,0x1
JNZ 0x0011a3cd
JMP 0x0011a443
LAB_0011a3cd:
LEA RDI,[RBP + -0x38]
CALL 0x0011db20
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0011d600
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x18]
LAB_0011a3ed:
LEA RDI,[RBP + -0x50]
CALL RAX
JMP 0x0011a3f5
LAB_0011a3f5:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x50]
CALL 0x0011db40
JMP 0x0011a404
LAB_0011a404:
LEA RDI,[RBP + -0x50]
CALL 0x0011d6d0
LEA RDI,[RBP + -0x38]
CALL 0x0011db70
JMP 0x0011a3ba
LAB_0011a443:
MOV RDI,qword ptr [RBP + -0x78]
ADD RDI,0x28
CALL 0x0011d600
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x18]
LAB_0011a45a:
LEA RDI,[RBP + -0x70]
CALL RAX
JMP 0x0011a462
LAB_0011a462:
MOV R8,qword ptr [RBP + -0x78]
MOV RDX,R8
ADD RDX,0x30
ADD R8,0x8
LAB_0011a471:
LEA RDI,[RBP + -0x68]
LEA RSI,[RBP + -0x70]
LEA RCX,[RBP + -0x28]
CALL 0x0011db90
LAB_0011a482:
JMP 0x0011a484
LAB_0011a484:
MOV RDI,qword ptr [RBP + -0x88]
LEA RSI,[RBP + -0x68]
CALL 0x0011dc90
LEA RDI,[RBP + -0x68]
CALL 0x0011dce0
LEA RDI,[RBP + -0x70]
CALL 0x0011d6d0
LEA RDI,[RBP + -0x28]
CALL 0x0011dd40
MOV RAX,qword ptr [RBP + -0x80]
ADD RSP,0x90
POP RBP
RET
|
/* flux::parser::CallExpr::clone() const */
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *
flux::parser::CallExpr::clone(void)
{
bool bVar1;
long *plVar2;
long in_RSI;
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *in_RDI;
Token local_78 [8];
unique_ptr local_70 [24];
unique_ptr local_58 [8];
unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *local_50;
int8 local_48;
int8 local_40;
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
*local_38;
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
local_30 [40];
std::
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
::vector(local_30);
local_38 = (vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
*)(in_RSI + 0x90);
local_40 = std::
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
::begin(local_38);
local_48 = std::
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
::end(local_38);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_40,(__normal_iterator *)&local_48);
if (!bVar1) break;
local_50 = (unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *)
__gnu_cxx::
__normal_iterator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>const*,std::vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>>
::operator*((__normal_iterator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>const*,std::vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>>
*)&local_40);
plVar2 = (long *)std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
operator->(local_50);
/* try { // try from 0011a3ed to 0011a3f2 has its CatchHandler @ 0011a418 */
(**(code **)(*plVar2 + 0x18))(local_58);
/* try { // try from 0011a3f5 to 0011a401 has its CatchHandler @ 0011a429 */
std::
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
::push_back(local_30,local_58);
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::~unique_ptr
((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *)local_58);
__gnu_cxx::
__normal_iterator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>const*,std::vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>>
::operator++((__normal_iterator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>const*,std::vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>>
*)&local_40);
}
plVar2 = (long *)std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
operator->((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>
*)(in_RSI + 0x28));
/* try { // try from 0011a45a to 0011a45f has its CatchHandler @ 0011a418 */
(**(code **)(*plVar2 + 0x18))(local_78);
/* try { // try from 0011a471 to 0011a481 has its CatchHandler @ 0011a4bc */
std::
make_unique<flux::parser::CallExpr,std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,flux::lexer::Token_const&,std::vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>,flux::common::SourceRange_const&>
(local_70,local_78,(vector *)(in_RSI + 0x30),(SourceRange *)local_30);
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::
unique_ptr<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>,void>
(in_RDI,local_70);
std::unique_ptr<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>>::~unique_ptr
((unique_ptr<flux::parser::CallExpr,std::default_delete<flux::parser::CallExpr>> *)
local_70);
std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>::~unique_ptr
((unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>> *)local_78);
std::
vector<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>,std::allocator<std::unique_ptr<flux::parser::Expr,std::default_delete<flux::parser::Expr>>>>
::~vector(local_30);
return in_RDI;
}
|
|
57,689
|
maria_ftparser_call_initializer
|
eloqsql/storage/maria/ma_ft_parser.c
|
MYSQL_FTPARSER_PARAM *maria_ftparser_call_initializer(MARIA_HA *info,
uint keynr, uint paramnr)
{
uint32 ftparser_nr;
struct st_mysql_ftparser *parser;
if (!maria_ftparser_alloc_param(info))
return 0;
if (keynr == NO_SUCH_KEY)
{
ftparser_nr= 0;
parser= &ft_default_parser;
}
else
{
ftparser_nr= info->s->keyinfo[keynr].ftkey_nr;
parser= info->s->keyinfo[keynr].parser;
}
DBUG_ASSERT(paramnr < MAX_PARAM_NR);
ftparser_nr= ftparser_nr*MAX_PARAM_NR + paramnr;
if (! info->ftparser_param[ftparser_nr].mysql_add_word)
{
/* Note, that mysql_add_word is used here as a flag:
mysql_add_word == 0 - parser is not initialized
mysql_add_word != 0 - parser is initialized, or no
initialization needed. */
info->ftparser_param[ftparser_nr].mysql_add_word=
(int (*)(struct st_mysql_ftparser_param *, const char *,
int, MYSQL_FTPARSER_BOOLEAN_INFO *)) 1;
if (parser->init && parser->init(&info->ftparser_param[ftparser_nr]))
return 0;
}
return &info->ftparser_param[ftparser_nr];
}
|
O3
|
c
|
maria_ftparser_call_initializer:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x427fd
xorl %r12d, %r12d
testq %rax, %rax
je 0x428f5
cmpl $-0x1, %r15d
je 0x428a9
movq (%rbx), %rax
movq 0x570(%rax), %rax
movl %r15d, %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
movl 0xbc(%rax,%rcx), %r12d
movq 0xd0(%rax,%rcx), %rcx
addl %r12d, %r12d
jmp 0x428b0
leaq 0x341a50(%rip), %rcx # 0x384300
addl %r14d, %r12d
movq 0x368(%rbx), %rax
shlq $0x6, %r12
cmpq $0x0, 0x8(%rax,%r12)
je 0x428cb
addq %r12, %rax
jmp 0x428f7
addq %r12, %rax
addq $0x8, %rax
movq $0x1, (%rax)
movq 0x10(%rcx), %rcx
movq 0x368(%rbx), %rax
testq %rcx, %rcx
je 0x428c6
addq %r12, %rax
movq %rax, %rdi
callq *%rcx
testl %eax, %eax
je 0x42900
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x368(%rbx), %rax
jmp 0x428c6
|
maria_ftparser_call_initializer:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14d, edx
mov r15d, esi
mov rbx, rdi
call maria_ftparser_alloc_param
xor r12d, r12d
test rax, rax
jz short loc_428F5
cmp r15d, 0FFFFFFFFh
jz short loc_428A9
mov rax, [rbx]
mov rax, [rax+570h]
mov ecx, r15d
imul rcx, 118h
mov r12d, [rax+rcx+0BCh]
mov rcx, [rax+rcx+0D0h]
add r12d, r12d
jmp short loc_428B0
loc_428A9:
lea rcx, ft_default_parser
loc_428B0:
add r12d, r14d
mov rax, [rbx+368h]
shl r12, 6
cmp qword ptr [rax+r12+8], 0
jz short loc_428CB
loc_428C6:
add rax, r12
jmp short loc_428F7
loc_428CB:
add rax, r12
add rax, 8
mov qword ptr [rax], 1
mov rcx, [rcx+10h]
mov rax, [rbx+368h]
test rcx, rcx
jz short loc_428C6
add rax, r12
mov rdi, rax
call rcx
test eax, eax
jz short loc_42900
loc_428F5:
xor eax, eax
loc_428F7:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_42900:
mov rax, [rbx+368h]
jmp short loc_428C6
|
long long maria_ftparser_call_initializer(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // r12d
long long v5; // rax
long long v6; // rcx
int v7; // r12d
_QWORD *v8; // rcx
long long v9; // rax
unsigned long long v10; // r12
unsigned int ( *v12)(unsigned long long); // rcx
v4 = 0;
if ( !maria_ftparser_alloc_param(a1) )
return 0LL;
if ( a2 == -1 )
{
v8 = &ft_default_parser;
}
else
{
v5 = *(_QWORD *)(*a1 + 1392LL);
v6 = 280LL * a2;
v7 = *(_DWORD *)(v5 + v6 + 188);
v8 = *(_QWORD **)(v5 + v6 + 208);
v4 = 2 * v7;
}
v9 = a1[109];
v10 = (unsigned long long)(unsigned int)(a3 + v4) << 6;
if ( *(_QWORD *)(v9 + v10 + 8) )
return v10 + v9;
*(_QWORD *)(v10 + v9 + 8) = 1LL;
v12 = (unsigned int ( *)(unsigned long long))v8[2];
v9 = a1[109];
if ( !v12 )
return v10 + v9;
if ( !v12(v10 + v9) )
{
v9 = a1[109];
return v10 + v9;
}
return 0LL;
}
|
maria_ftparser_call_initializer:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14D,EDX
MOV R15D,ESI
MOV RBX,RDI
CALL 0x001427fd
XOR R12D,R12D
TEST RAX,RAX
JZ 0x001428f5
CMP R15D,-0x1
JZ 0x001428a9
MOV RAX,qword ptr [RBX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,R15D
IMUL RCX,RCX,0x118
MOV R12D,dword ptr [RAX + RCX*0x1 + 0xbc]
MOV RCX,qword ptr [RAX + RCX*0x1 + 0xd0]
ADD R12D,R12D
JMP 0x001428b0
LAB_001428a9:
LEA RCX,[0x484300]
LAB_001428b0:
ADD R12D,R14D
MOV RAX,qword ptr [RBX + 0x368]
SHL R12,0x6
CMP qword ptr [RAX + R12*0x1 + 0x8],0x0
JZ 0x001428cb
LAB_001428c6:
ADD RAX,R12
JMP 0x001428f7
LAB_001428cb:
ADD RAX,R12
ADD RAX,0x8
MOV qword ptr [RAX],0x1
MOV RCX,qword ptr [RCX + 0x10]
MOV RAX,qword ptr [RBX + 0x368]
TEST RCX,RCX
JZ 0x001428c6
ADD RAX,R12
MOV RDI,RAX
CALL RCX
TEST EAX,EAX
JZ 0x00142900
LAB_001428f5:
XOR EAX,EAX
LAB_001428f7:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00142900:
MOV RAX,qword ptr [RBX + 0x368]
JMP 0x001428c6
|
long maria_ftparser_call_initializer(long *param_1,uint param_2,int param_3)
{
int iVar1;
long lVar2;
int1 *puVar3;
long lVar4;
lVar2 = maria_ftparser_alloc_param();
iVar1 = 0;
if (lVar2 == 0) {
LAB_001428f5:
lVar2 = 0;
}
else {
if (param_2 == 0xffffffff) {
puVar3 = ft_default_parser;
}
else {
puVar3 = *(int1 **)(*(long *)(*param_1 + 0x570) + 0xd0 + (ulong)param_2 * 0x118);
iVar1 = *(int *)(*(long *)(*param_1 + 0x570) + 0xbc + (ulong)param_2 * 0x118) * 2;
}
lVar2 = param_1[0x6d];
lVar4 = (ulong)(uint)(iVar1 + param_3) * 0x40;
if (*(long *)(lVar2 + 8 + lVar4) == 0) {
*(int8 *)(lVar2 + lVar4 + 8) = 1;
lVar2 = param_1[0x6d];
if (*(code **)(puVar3 + 0x10) != (code *)0x0) {
iVar1 = (**(code **)(puVar3 + 0x10))(lVar2 + lVar4);
if (iVar1 != 0) goto LAB_001428f5;
lVar2 = param_1[0x6d];
}
}
lVar2 = lVar2 + lVar4;
}
return lVar2;
}
|
|
57,690
|
ma_mmap_pwrite
|
eloqsql/storage/maria/ma_dynrec.c
|
size_t _ma_mmap_pwrite(MARIA_HA *info, const uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("maria_write with mmap %d\n", info->dfile.file));
if (info->s->lock_key_trees)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(info->s->file_map + offset, Buffer, Count);
if (info->s->lock_key_trees)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
info->s->nonmmaped_inserts++;
if (info->s->lock_key_trees)
mysql_rwlock_unlock(&info->s->mmap_lock);
return my_pwrite(info->dfile.file, Buffer, Count, offset, MyFlags);
}
}
|
O3
|
c
|
ma_mmap_pwrite:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rax
cmpb $0x0, 0x7e3(%rax)
je 0x49d80
leaq 0xb78(%rax), %rdi
cmpq $0x0, 0xc08(%rax)
jne 0x49e3c
callq 0xaa9ec
movq (%r15), %rax
leaq (%r14,%rbx), %rcx
cmpq %rcx, 0xa00(%rax)
jae 0x49def
movq %r12, -0x30(%rbp)
incl 0xa08(%rax)
movq (%r15), %r12
cmpb $0x0, 0x7e3(%r12)
je 0x49dc8
movq 0xc08(%r12), %rdi
addq $0xb78, %r12 # imm = 0xB78
testq %rdi, %rdi
jne 0x49e52
movq %r12, %rdi
callq 0xaab1a
movl 0x480(%r15), %edi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq -0x30(%rbp), %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa6e22
addq 0x5f0(%rax), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2a0a0
movq (%r15), %rbx
cmpb $0x0, 0x7e3(%rbx)
je 0x49e2b
movq 0xc08(%rbx), %rdi
addq $0xb78, %rbx # imm = 0xB78
testq %rdi, %rdi
jne 0x49e67
movq %rbx, %rdi
callq 0xaab1a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x97f47(%rip), %rsi # 0xe1d8a
movl $0xbb, %edx
callq 0x306c4
jmp 0x49d80
leaq 0x3453ff(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x49dc0
leaq 0x3453ea(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x168(%rax)
jmp 0x49e23
|
_ma_mmap_pwrite:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12, r8
mov r14, rcx
mov rbx, rdx
mov r13, rsi
mov r15, rdi
mov rax, [rdi]
cmp byte ptr [rax+7E3h], 0
jz short loc_49D80
lea rdi, [rax+0B78h]
cmp qword ptr [rax+0C08h], 0
jnz loc_49E3C
call my_rw_rdlock
loc_49D80:
mov rax, [r15]
lea rcx, [r14+rbx]
cmp [rax+0A00h], rcx
jnb short loc_49DEF
mov [rbp+var_30], r12
inc dword ptr [rax+0A08h]
mov r12, [r15]
cmp byte ptr [r12+7E3h], 0
jz short loc_49DC8
mov rdi, [r12+0C08h]
add r12, 0B78h
test rdi, rdi
jnz loc_49E52
loc_49DC0:
mov rdi, r12
call my_rw_unlock
loc_49DC8:
mov edi, [r15+480h]
mov rsi, r13
mov rdx, rbx
mov rcx, r14
mov r8, [rbp+var_30]
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_pwrite
loc_49DEF:
add r14, [rax+5F0h]
mov rdi, r14
mov rsi, r13
mov rdx, rbx
call _memcpy
mov rbx, [r15]
cmp byte ptr [rbx+7E3h], 0
jz short loc_49E2B
mov rdi, [rbx+0C08h]
add rbx, 0B78h
test rdi, rdi
jnz short loc_49E67
loc_49E23:
mov rdi, rbx
call my_rw_unlock
loc_49E2B:
xor eax, eax
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_49E3C:
lea rsi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0BBh
call psi_rwlock_rdlock
jmp loc_49D80
loc_49E52:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp loc_49DC0
loc_49E67:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+168h]
jmp short loc_49E23
|
long long ma_mmap_pwrite(unsigned int *a1, long long a2, long long a3, long long a4, long long a5)
{
long long v9; // rax
long long v10; // rdi
long long v11; // rax
long long v12; // r12
long long v13; // rdi
long long v14; // r12
long long v16; // rbx
long long v17; // rdi
long long v18; // rbx
long long v19; // [rsp+0h] [rbp-30h]
v9 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v10 = v9 + 2936;
if ( *(_QWORD *)(v9 + 3080) )
psi_rwlock_rdlock(v10, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_dynrec.c", 0xBBu);
else
my_rw_rdlock(v10);
}
v11 = *(_QWORD *)a1;
if ( *(_QWORD *)(*(_QWORD *)a1 + 2560LL) >= (unsigned long long)(a4 + a3) )
{
memcpy(*(_QWORD *)(v11 + 1520) + a4, a2, a3);
v16 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v17 = *(_QWORD *)(v16 + 3080);
v18 = v16 + 2936;
if ( v17 )
((void ( *)(long long))PSI_server[45])(v17);
my_rw_unlock(v18);
}
return 0LL;
}
else
{
v19 = a5;
++*(_DWORD *)(v11 + 2568);
v12 = *(_QWORD *)a1;
if ( *(_BYTE *)(*(_QWORD *)a1 + 2019LL) )
{
v13 = *(_QWORD *)(v12 + 3080);
v14 = v12 + 2936;
if ( v13 )
((void ( *)(long long))PSI_server[45])(v13);
my_rw_unlock(v14);
}
return my_pwrite(a1[288], a2, a3, a4, v19);
}
}
|
_ma_mmap_pwrite:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12,R8
MOV R14,RCX
MOV RBX,RDX
MOV R13,RSI
MOV R15,RDI
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e3],0x0
JZ 0x00149d80
LEA RDI,[RAX + 0xb78]
CMP qword ptr [RAX + 0xc08],0x0
JNZ 0x00149e3c
CALL 0x001aa9ec
LAB_00149d80:
MOV RAX,qword ptr [R15]
LEA RCX,[R14 + RBX*0x1]
CMP qword ptr [RAX + 0xa00],RCX
JNC 0x00149def
MOV qword ptr [RBP + -0x30],R12
INC dword ptr [RAX + 0xa08]
MOV R12,qword ptr [R15]
CMP byte ptr [R12 + 0x7e3],0x0
JZ 0x00149dc8
MOV RDI,qword ptr [R12 + 0xc08]
ADD R12,0xb78
TEST RDI,RDI
JNZ 0x00149e52
LAB_00149dc0:
MOV RDI,R12
CALL 0x001aab1a
LAB_00149dc8:
MOV EDI,dword ptr [R15 + 0x480]
MOV RSI,R13
MOV RDX,RBX
MOV RCX,R14
MOV R8,qword ptr [RBP + -0x30]
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001a6e22
LAB_00149def:
ADD R14,qword ptr [RAX + 0x5f0]
MOV RDI,R14
MOV RSI,R13
MOV RDX,RBX
CALL 0x0012a0a0
MOV RBX,qword ptr [R15]
CMP byte ptr [RBX + 0x7e3],0x0
JZ 0x00149e2b
MOV RDI,qword ptr [RBX + 0xc08]
ADD RBX,0xb78
TEST RDI,RDI
JNZ 0x00149e67
LAB_00149e23:
MOV RDI,RBX
CALL 0x001aab1a
LAB_00149e2b:
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00149e3c:
LEA RSI,[0x1e1d8a]
MOV EDX,0xbb
CALL 0x001306c4
JMP 0x00149d80
LAB_00149e52:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00149dc0
LAB_00149e67:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x168]
JMP 0x00149e23
|
int8
_ma_mmap_pwrite(long *param_1,void *param_2,size_t param_3,long param_4,int8 param_5)
{
long lVar1;
int8 uVar2;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) == 0) {
my_rw_rdlock();
}
else {
psi_rwlock_rdlock(lVar1 + 0xb78,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_dynrec.c",0xbb);
}
}
lVar1 = *param_1;
if (*(ulong *)(lVar1 + 0xa00) < param_4 + param_3) {
*(int *)(lVar1 + 0xa08) = *(int *)(lVar1 + 0xa08) + 1;
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar1 + 0xb78);
}
uVar2 = my_pwrite((int)param_1[0x90],param_2,param_3,param_4,param_5);
return uVar2;
}
memcpy((void *)(param_4 + *(long *)(lVar1 + 0x5f0)),param_2,param_3);
lVar1 = *param_1;
if (*(char *)(lVar1 + 0x7e3) != '\0') {
if (*(long *)(lVar1 + 0xc08) != 0) {
(**(code **)(PSI_server + 0x168))();
}
my_rw_unlock(lVar1 + 0xb78);
}
return 0;
}
|
|
57,691
|
uf_endspace
|
eloqsql/storage/myisam/mi_packrec.c
|
static void uf_endspace(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff, uchar *to,
uchar *end)
{
uint spaces;
if ((spaces=get_bits(bit_buff,rec->space_length_bits))+to > end)
{
bit_buff->error=1;
return;
}
if (to+spaces != end)
decode_bytes(rec,bit_buff,to,end-spaces);
bfill((uchar*) end-spaces,spaces,' ');
}
|
O3
|
c
|
uf_endspace:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r15
movl 0x4(%rsi), %ecx
movl 0x1c(%rdi), %r13d
cmpl %r13d, %ecx
jae 0x841fa
subl %ecx, %r13d
leaq 0x5eb95(%rip), %rax # 0xe2d50
movl (%rax,%rcx,4), %r14d
andl (%r15), %r14d
movl %r13d, %ecx
shll %cl, %r14d
movq %rdi, -0x30(%rbp)
movq %r15, %rdi
movq %rdx, %r12
callq 0x832a9
movq -0x30(%rbp), %rdi
movq %r12, %rdx
movl $0x20, %eax
subl %r13d, %eax
movl %eax, 0x4(%r15)
movl (%r15), %eax
negl %r13d
movl %r13d, %ecx
shrl %cl, %eax
addl %r14d, %eax
jmp 0x84213
movl (%r15), %eax
subl %r13d, %ecx
movl %ecx, 0x4(%r15)
shrl %cl, %eax
movl 0x1c(%rdi), %ecx
leaq 0x5eb40(%rip), %rsi # 0xe2d50
andl (%rsi,%rcx,4), %eax
movl %eax, %r13d
leaq (%rdx,%r13), %rax
cmpq %rbx, %rax
jbe 0x84236
movl $0x1, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %r14
negq %r14
cmpq %rbx, %rax
je 0x8424d
leaq (%rbx,%r14), %rcx
movq %r15, %rsi
callq 0x83b9a
addq %r14, %rbx
movq %rbx, %rdi
movl $0x20, %esi
movq %r13, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x292c0
|
uf_endspace_0:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rcx
mov r15, rsi
mov ecx, [rsi+4]
mov r13d, [rdi+1Ch]
cmp ecx, r13d
jnb short loc_841FA
sub r13d, ecx
lea rax, mask_0
mov r14d, [rax+rcx*4]
and r14d, [r15]
mov ecx, r13d
shl r14d, cl
mov [rbp+var_30], rdi
mov rdi, r15
mov r12, rdx
call fill_buffer_0
mov rdi, [rbp+var_30]
mov rdx, r12
mov eax, 20h ; ' '
sub eax, r13d
mov [r15+4], eax
mov eax, [r15]
neg r13d
mov ecx, r13d
shr eax, cl
add eax, r14d
jmp short loc_84213
loc_841FA:
mov eax, [r15]
sub ecx, r13d
mov [r15+4], ecx
shr eax, cl
mov ecx, [rdi+1Ch]
lea rsi, mask_0
and eax, [rsi+rcx*4]
loc_84213:
mov r13d, eax
lea rax, [rdx+r13]
cmp rax, rbx
jbe short loc_84236
mov dword ptr [r15+28h], 1
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_84236:
mov r14, r13
neg r14
cmp rax, rbx
jz short loc_8424D
lea rcx, [rbx+r14]
mov rsi, r15
call decode_bytes_0
loc_8424D:
add rbx, r14
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r13
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _memset
|
unsigned long long uf_endspace_0(long long a1, unsigned int *a2, _BYTE *a3, unsigned long long a4)
{
long long v5; // rcx
unsigned int v6; // r13d
int v7; // r13d
int v8; // r14d
_BYTE *v9; // r12
unsigned int v10; // eax
unsigned int v11; // eax
unsigned int v12; // ecx
long long v13; // r13
unsigned long long result; // rax
v5 = a2[1];
v6 = *(_DWORD *)(a1 + 28);
if ( (unsigned int)v5 >= v6 )
{
v11 = *a2;
v12 = v5 - v6;
a2[1] = v12;
v10 = mask_0[*(unsigned int *)(a1 + 28)] & (v11 >> v12);
}
else
{
v7 = v6 - v5;
v8 = (*a2 & mask_0[v5]) << v7;
v9 = a3;
fill_buffer_0((long long)a2);
a3 = v9;
a2[1] = 32 - v7;
v10 = v8 + (*a2 >> -(char)v7);
}
v13 = v10;
result = (unsigned long long)&a3[v10];
if ( result <= a4 )
{
if ( result != a4 )
decode_bytes_0(a1, (long long)a2, a3, (_BYTE *)(a4 - v13));
return memset(a4 - v13, 32LL, v13);
}
else
{
a2[10] = 1;
}
return result;
}
|
uf_endspace:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RCX
MOV R15,RSI
MOV ECX,dword ptr [RSI + 0x4]
MOV R13D,dword ptr [RDI + 0x1c]
CMP ECX,R13D
JNC 0x001841fa
SUB R13D,ECX
LEA RAX,[0x1e2d50]
MOV R14D,dword ptr [RAX + RCX*0x4]
AND R14D,dword ptr [R15]
MOV ECX,R13D
SHL R14D,CL
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,R15
MOV R12,RDX
CALL 0x001832a9
MOV RDI,qword ptr [RBP + -0x30]
MOV RDX,R12
MOV EAX,0x20
SUB EAX,R13D
MOV dword ptr [R15 + 0x4],EAX
MOV EAX,dword ptr [R15]
NEG R13D
MOV ECX,R13D
SHR EAX,CL
ADD EAX,R14D
JMP 0x00184213
LAB_001841fa:
MOV EAX,dword ptr [R15]
SUB ECX,R13D
MOV dword ptr [R15 + 0x4],ECX
SHR EAX,CL
MOV ECX,dword ptr [RDI + 0x1c]
LEA RSI,[0x1e2d50]
AND EAX,dword ptr [RSI + RCX*0x4]
LAB_00184213:
MOV R13D,EAX
LEA RAX,[RDX + R13*0x1]
CMP RAX,RBX
JBE 0x00184236
MOV dword ptr [R15 + 0x28],0x1
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00184236:
MOV R14,R13
NEG R14
CMP RAX,RBX
JZ 0x0018424d
LEA RCX,[RBX + R14*0x1]
MOV RSI,R15
CALL 0x00183b9a
LAB_0018424d:
ADD RBX,R14
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R13
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001292c0
|
void uf_endspace(long param_1,uint *param_2,long param_3,ulong param_4)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
byte bVar5;
ulong __n;
uVar4 = param_2[1];
uVar1 = *(uint *)(param_1 + 0x1c);
if (uVar4 < uVar1) {
uVar2 = (&mask)[uVar4];
uVar3 = *param_2;
bVar5 = (byte)(uVar1 - uVar4);
fill_buffer(param_2);
param_2[1] = 0x20 - (uVar1 - uVar4);
uVar4 = (*param_2 >> (-bVar5 & 0x1f)) + ((uVar2 & uVar3) << (bVar5 & 0x1f));
}
else {
param_2[1] = uVar4 - uVar1;
uVar4 = *param_2 >> ((byte)(uVar4 - uVar1) & 0x1f) & (&mask)[*(uint *)(param_1 + 0x1c)];
}
__n = (ulong)uVar4;
if (param_4 < param_3 + __n) {
param_2[10] = 1;
return;
}
if (param_3 + __n != param_4) {
decode_bytes(param_1,param_2,param_3,param_4 + -__n);
}
memset((void *)(param_4 + -__n),0x20,__n);
return;
}
|
|
57,692
|
JS_NewTypedArray
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValue *argv,
JSTypedArrayEnum type)
{
if (type < JS_TYPED_ARRAY_UINT8C || type > JS_TYPED_ARRAY_FLOAT64)
return JS_ThrowRangeError(ctx, "invalid typed array type");
return js_typed_array_constructor(ctx, JS_UNDEFINED, argc, argv,
JS_CLASS_UINT8C_ARRAY + type);
}
|
O1
|
c
|
JS_NewTypedArray:
pushq %rbx
cmpl $0xc, %ecx
jb 0x3901b
leaq 0x65e36(%rip), %rsi # 0x9ee41
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x20add
movl $0x6, %edx
jmp 0x39033
movq %rdx, %r8
addl $0x15, %ecx
movl $0x3, %edx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x39038
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_3901B
lea rsi, aInvalidTypedAr; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
mov edx, 6
jmp short loc_39033
loc_3901B:
mov r8, rdx
add ecx, 15h
mov edx, 3
xor esi, esi
mov r9d, ecx
call js_typed_array_constructor
mov rbx, rax
loc_39033:
mov rax, rbx
pop rbx
retn
|
long long JS_NewTypedArray(
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; // rbx
char v16; // [rsp+0h] [rbp-8h]
if ( (unsigned int)a12 < 0xC )
return js_typed_array_constructor(a1, 0LL, 3LL, (unsigned int)(a12 + 21), a11, (unsigned int)(a12 + 21));
v14 = 0LL;
JS_ThrowRangeError(a1, (long long)"invalid typed array type", a11, a12, a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v16);
return v14;
}
|
JS_NewTypedArray:
PUSH RBX
CMP ECX,0xc
JC 0x0013901b
LEA RSI,[0x19ee41]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00120add
MOV EDX,0x6
JMP 0x00139033
LAB_0013901b:
MOV R8,RDX
ADD ECX,0x15
MOV EDX,0x3
XOR ESI,ESI
MOV R9D,ECX
CALL 0x00139038
MOV RBX,RAX
LAB_00139033:
MOV RAX,RBX
POP RBX
RET
|
int8 JS_NewTypedArray(int8 param_1,int8 param_2,int8 param_3,uint param_4)
{
int8 uVar1;
if (param_4 < 0xc) {
uVar1 = js_typed_array_constructor(param_1,0,3,param_4 + 0x15,param_3,param_4 + 0x15);
}
else {
uVar1 = 0;
JS_ThrowRangeError(param_1,"invalid typed array type");
}
return uVar1;
}
|
|
57,693
|
JS_NewTypedArray
|
bluesky950520[P]quickjs/quickjs.c
|
JSValue JS_NewTypedArray(JSContext *ctx, int argc, JSValue *argv,
JSTypedArrayEnum type)
{
if (type < JS_TYPED_ARRAY_UINT8C || type > JS_TYPED_ARRAY_FLOAT64)
return JS_ThrowRangeError(ctx, "invalid typed array type");
return js_typed_array_constructor(ctx, JS_UNDEFINED, argc, argv,
JS_CLASS_UINT8C_ARRAY + type);
}
|
O2
|
c
|
JS_NewTypedArray:
pushq %rbx
cmpl $0xc, %ecx
jb 0x3214a
leaq 0x53c55(%rip), %rsi # 0x85d91
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1acb3
pushq $0x6
popq %rdx
jmp 0x32160
movq %rdx, %r8
addl $0x15, %ecx
pushq $0x3
popq %rdx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x32165
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_3214A
lea rsi, aInvalidTypedAr_0; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
push 6
pop rdx
jmp short loc_32160
loc_3214A:
mov r8, rdx
add ecx, 15h
push 3
pop rdx
xor esi, esi
mov r9d, ecx
call js_typed_array_constructor
mov rbx, rax
loc_32160:
mov rax, rbx
pop rbx
retn
|
long long JS_NewTypedArray(
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; // rbx
char v16; // [rsp+0h] [rbp-8h]
if ( (unsigned int)a12 < 0xC )
return js_typed_array_constructor(a1, 0LL, 3LL, (unsigned int)(a12 + 21), a11, (unsigned int)(a12 + 21));
v14 = 0LL;
JS_ThrowRangeError(a1, (long long)"invalid typed array type", a11, a12, a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v16);
return v14;
}
|
JS_NewTypedArray:
PUSH RBX
CMP ECX,0xc
JC 0x0013214a
LEA RSI,[0x185d91]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0011acb3
PUSH 0x6
POP RDX
JMP 0x00132160
LAB_0013214a:
MOV R8,RDX
ADD ECX,0x15
PUSH 0x3
POP RDX
XOR ESI,ESI
MOV R9D,ECX
CALL 0x00132165
MOV RBX,RAX
LAB_00132160:
MOV RAX,RBX
POP RBX
RET
|
int8 JS_NewTypedArray(int8 param_1,int8 param_2,int8 param_3,uint param_4)
{
int8 uVar1;
if (param_4 < 0xc) {
uVar1 = js_typed_array_constructor(param_1,0,3,param_4 + 0x15,param_3,param_4 + 0x15);
}
else {
uVar1 = 0;
JS_ThrowRangeError(param_1,"invalid typed array type");
}
return uVar1;
}
|
|
57,694
|
pagecache_collect_changed_blocks_with_lsn
|
eloqsql/storage/maria/ma_pagecache.c
|
my_bool pagecache_collect_changed_blocks_with_lsn(PAGECACHE *pagecache,
LEX_STRING *str,
LSN *min_rec_lsn)
{
my_bool error= 0;
size_t stored_list_size= 0;
uint file_hash;
char *ptr;
LSN minimum_rec_lsn= LSN_MAX;
DBUG_ENTER("pagecache_collect_changed_blocks_with_LSN");
DBUG_ASSERT(NULL == str->str);
/*
We lock the entire cache but will be quick, just reading/writing a few MBs
of memory at most.
*/
pagecache_pthread_mutex_lock(&pagecache->cache_lock);
for (;;)
{
struct st_file_in_flush *other_flusher;
for (file_hash= 0;
(other_flusher= (struct st_file_in_flush *)
my_hash_element(&pagecache->files_in_flush, file_hash)) != NULL &&
!other_flusher->first_in_switch;
file_hash++)
{}
if (other_flusher == NULL)
break;
/*
other_flusher.first_in_switch is true: some thread is flushing a file
and has removed dirty blocks from changed_blocks[] while they were still
dirty (they were being evicted (=>flushed) by yet another thread, which
may not have flushed the block yet so it may still be dirty).
If Checkpoint proceeds now, it will not see the page. If there is a
crash right after writing the checkpoint record, before the page is
flushed, at recovery the page will be wrongly ignored because it won't
be in the dirty pages list in the checkpoint record. So wait.
*/
{
struct st_my_thread_var *thread= my_thread_var;
wqueue_add_to_queue(&other_flusher->flush_queue, thread);
do
{
DBUG_PRINT("wait",
("suspend thread %s %ld", thread->name,
(ulong) thread->id));
pagecache_pthread_cond_wait(&thread->suspend,
&pagecache->cache_lock);
}
while (thread->next);
}
}
/* Count how many dirty pages are interesting */
for (file_hash= 0; file_hash < pagecache->changed_blocks_hash_size; file_hash++)
{
PAGECACHE_BLOCK_LINK *block;
for (block= pagecache->changed_blocks[file_hash] ;
block;
block= block->next_changed)
{
/*
Q: is there something subtle with block->hash_link: can it be NULL?
does it have to be == hash_link->block... ?
*/
DBUG_ASSERT(block->hash_link != NULL);
DBUG_ASSERT(block->status & PCBLOCK_CHANGED);
/*
Note that we don't store bitmap pages, or pages from non-transactional
(like temporary) tables. Don't checkpoint during Recovery which uses
PAGECACHE_PLAIN_PAGE.
*/
if (block->type != PAGECACHE_LSN_PAGE)
continue; /* no need to store it */
stored_list_size++;
}
}
compile_time_assert(sizeof(pagecache->blocks) <= 8);
str->length= 8 + /* number of dirty pages */
(2 + /* table id */
1 + /* data or index file */
5 + /* pageno */
LSN_STORE_SIZE /* rec_lsn */
) * stored_list_size;
if (NULL == (str->str= my_malloc(PSI_INSTRUMENT_ME, str->length, MYF(MY_WME))))
goto err;
ptr= str->str;
int8store(ptr, (ulonglong)stored_list_size);
ptr+= 8;
DBUG_PRINT("info", ("found %zu dirty pages", stored_list_size));
if (stored_list_size == 0)
goto end;
for (file_hash= 0; file_hash < pagecache->changed_blocks_hash_size; file_hash++)
{
PAGECACHE_BLOCK_LINK *block;
for (block= pagecache->changed_blocks[file_hash] ;
block;
block= block->next_changed)
{
uint16 table_id;
MARIA_SHARE *share;
if (block->type != PAGECACHE_LSN_PAGE)
continue; /* no need to store it in the checkpoint record */
share= (MARIA_SHARE *)(block->hash_link->file.callback_data);
table_id= share->id;
int2store(ptr, table_id);
ptr+= 2;
ptr[0]= (share->kfile.file == block->hash_link->file.file);
ptr++;
DBUG_ASSERT(block->hash_link->pageno < ((1ULL) << 40));
page_store(ptr, block->hash_link->pageno);
ptr+= PAGE_STORE_SIZE;
lsn_store(ptr, block->rec_lsn);
ptr+= LSN_STORE_SIZE;
if (block->rec_lsn != LSN_MAX)
{
DBUG_ASSERT(LSN_VALID(block->rec_lsn));
if (cmp_translog_addr(block->rec_lsn, minimum_rec_lsn) < 0)
minimum_rec_lsn= block->rec_lsn;
} /* otherwise, some trn->rec_lsn should hold the correct info */
}
}
end:
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
*min_rec_lsn= minimum_rec_lsn;
DBUG_RETURN(error);
err:
error= 1;
goto end;
}
|
O0
|
c
|
pagecache_collect_changed_blocks_with_lsn:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
movq %rax, -0x40(%rbp)
jmp 0x41723
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
leaq 0x11a2ef(%rip), %rsi # 0x15ba24
movl $0x14c2, %edx # imm = 0x14C2
callq 0x3db90
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0xe34c0
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x91(%rbp)
je 0x41783
movq -0x48(%rbp), %rax
cmpb $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x4178f
jmp 0x4179c
jmp 0x41791
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x41746
cmpq $0x0, -0x48(%rbp)
jne 0x417a5
jmp 0x417fa
callq 0xfe880
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x50(%rbp), %rsi
callq 0x1086c0
jmp 0x417c1
jmp 0x417c3
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc8, %rsi
leaq 0x11a247(%rip), %rdx # 0x15ba24
movl $0x14e1, %ecx # imm = 0x14E1
callq 0x41b10
movq -0x50(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x417bf
jmp 0x4173f
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x41866
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x41859
jmp 0x4182d
jmp 0x4182f
jmp 0x41831
jmp 0x41833
movq -0x58(%rbp), %rax
cmpl $0x2, 0x7c(%rax)
je 0x4183f
jmp 0x4184b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x41824
jmp 0x4185b
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x41801
jmp 0x41868
jmp 0x4186a
imulq $0xf, -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
xorl %edi, %edi
movl $0x10, %edx
callq 0xfc020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x418a5
jmp 0x41afd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rcx
movq -0x60(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
jmp 0x418d1
cmpq $0x0, -0x28(%rbp)
jne 0x418dd
jmp 0x41ad6
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x41ad4
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movl -0x2c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x41ac4
movq -0x68(%rbp), %rax
cmpl $0x2, 0x7c(%rax)
je 0x41925
jmp 0x41ab3
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x58(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movw 0x620(%rax), %ax
movw %ax, -0x6a(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movw -0x6a(%rbp), %cx
movq -0x80(%rbp), %rax
movw %cx, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x78(%rbp), %rax
movl 0x760(%rax), %eax
movq -0x68(%rbp), %rcx
movq 0x20(%rcx), %rcx
cmpl 0x28(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x41996
jmp 0x41998
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rax
movl %eax, %ecx
movq -0x88(%rbp), %rax
movl %ecx, (%rax)
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x60(%rax), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x88(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x38(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x38(%rbp)
jmp 0x419e4
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
sarq $0x20, %rax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, (%rax)
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
sarq $0x20, %rax
shrl $0x8, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
sarq $0x20, %rax
shrl $0x10, %eax
movb %al, %cl
movq -0x38(%rbp), %rax
movb %cl, 0x2(%rax)
jmp 0x41a33
movq -0x38(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x90(%rbp)
movq -0x68(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x88(%rcx), %rax
movl %eax, %ecx
movq -0x90(%rbp), %rax
movl %ecx, (%rax)
jmp 0x41a64
movq -0x38(%rbp), %rax
addq $0x7, %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movabsq $0xffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFF
cmpq %rcx, 0x88(%rax)
je 0x41ab1
jmp 0x41a89
jmp 0x41a8b
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
subq -0x40(%rbp), %rax
cmpq $0x0, %rax
jge 0x41aaf
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x41ab1
jmp 0x41ab3
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
jmp 0x4190b
jmp 0x41ac6
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x418e4
jmp 0x41ad6
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x3dc00
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb -0x19(%rbp), %al
addq $0xa0, %rsp
popq %rbp
retq
movb $0x1, -0x19(%rbp)
jmp 0x41ad6
nopw %cs:(%rax,%rax)
|
pagecache_collect_changed_blocks_with_lsn:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_19], 0
mov [rbp+var_28], 0
mov rax, 0FFFFFFFFFFFFFFh
mov [rbp+var_40], rax
jmp short $+2
loc_41723:
mov rdi, [rbp+var_8]
add rdi, 0C8h
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 14C2h
call inline_mysql_mutex_lock_0
loc_4173F:
mov [rbp+var_2C], 0
loc_41746:
mov rdi, [rbp+var_8]
add rdi, 1B0h
mov eax, [rbp+var_2C]
mov esi, eax
call my_hash_element
mov rcx, rax
mov [rbp+var_48], rcx
xor eax, eax
cmp rcx, 0
mov [rbp+var_91], al
jz short loc_41783
mov rax, [rbp+var_48]
cmp byte ptr [rax+10h], 0
setnz al
xor al, 0FFh
mov [rbp+var_91], al
loc_41783:
mov al, [rbp+var_91]
test al, 1
jnz short loc_4178F
jmp short loc_4179C
loc_4178F:
jmp short $+2
loc_41791:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_41746
loc_4179C:
cmp [rbp+var_48], 0
jnz short loc_417A5
jmp short loc_417FA
loc_417A5:
call _my_thread_var
mov [rbp+var_50], rax
mov rdi, [rbp+var_48]
add rdi, 8
mov rsi, [rbp+var_50]
call wqueue_add_to_queue
loc_417BF:
jmp short $+2
loc_417C1:
jmp short $+2
loc_417C3:
mov rdi, [rbp+var_50]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C8h
lea rdx, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 14E1h
call inline_mysql_cond_wait_0
mov rax, [rbp+var_50]
cmp qword ptr [rax+88h], 0
jnz short loc_417BF
jmp loc_4173F
loc_417FA:
mov [rbp+var_2C], 0
loc_41801:
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_8]
cmp rax, [rcx+28h]
jnb short loc_41866
mov rax, [rbp+var_8]
mov rax, [rax+128h]
mov ecx, [rbp+var_2C]
mov rax, [rax+rcx*8]
mov [rbp+var_58], rax
loc_41824:
cmp [rbp+var_58], 0
jz short loc_41859
jmp short $+2
loc_4182D:
jmp short $+2
loc_4182F:
jmp short $+2
loc_41831:
jmp short $+2
loc_41833:
mov rax, [rbp+var_58]
cmp dword ptr [rax+7Ch], 2
jz short loc_4183F
jmp short loc_4184B
loc_4183F:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
loc_4184B:
mov rax, [rbp+var_58]
mov rax, [rax+10h]
mov [rbp+var_58], rax
jmp short loc_41824
loc_41859:
jmp short $+2
loc_4185B:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp short loc_41801
loc_41866:
jmp short $+2
loc_41868:
jmp short $+2
loc_4186A:
imul rcx, [rbp+var_28], 0Fh
add rcx, 8
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
mov rsi, [rax+8]
xor edi, edi
mov edx, 10h
call my_malloc
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax], rcx
xor eax, eax
cmp rax, rcx
jnz short loc_418A5
jmp loc_41AFD
loc_418A5:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_60], rax
mov rcx, [rbp+var_28]
mov rax, [rbp+var_60]
mov [rax], rcx
mov rax, [rbp+var_38]
add rax, 8
mov [rbp+var_38], rax
jmp short $+2
loc_418D1:
cmp [rbp+var_28], 0
jnz short loc_418DD
jmp loc_41AD6
loc_418DD:
mov [rbp+var_2C], 0
loc_418E4:
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_8]
cmp rax, [rcx+28h]
jnb loc_41AD4
mov rax, [rbp+var_8]
mov rax, [rax+128h]
mov ecx, [rbp+var_2C]
mov rax, [rax+rcx*8]
mov [rbp+var_68], rax
loc_4190B:
cmp [rbp+var_68], 0
jz loc_41AC4
mov rax, [rbp+var_68]
cmp dword ptr [rax+7Ch], 2
jz short loc_41925
jmp loc_41AB3
loc_41925:
mov rax, [rbp+var_68]
mov rax, [rax+20h]
mov rax, [rax+58h]
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov ax, [rax+620h]
mov [rbp+var_6A], ax
mov rax, [rbp+var_38]
mov [rbp+var_80], rax
mov cx, [rbp+var_6A]
mov rax, [rbp+var_80]
mov [rax], cx
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_78]
mov eax, [rax+760h]
mov rcx, [rbp+var_68]
mov rcx, [rcx+20h]
cmp eax, [rcx+28h]
setz al
and al, 1
movzx eax, al
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
jmp short $+2
loc_41996:
jmp short $+2
loc_41998:
mov rax, [rbp+var_38]
mov [rbp+var_88], rax
mov rax, [rbp+var_68]
mov rax, [rax+20h]
mov rax, [rax+60h]
mov ecx, eax
mov rax, [rbp+var_88]
mov [rax], ecx
mov rax, [rbp+var_68]
mov rax, [rax+20h]
mov rax, [rax+60h]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_88]
mov [rax+4], cl
mov rax, [rbp+var_38]
add rax, 5
mov [rbp+var_38], rax
jmp short $+2
loc_419E4:
mov rax, [rbp+var_68]
mov rax, [rax+88h]
sar rax, 20h
mov cl, al
mov rax, [rbp+var_38]
mov [rax], cl
mov rax, [rbp+var_68]
mov rax, [rax+88h]
sar rax, 20h
shr eax, 8
mov cl, al
mov rax, [rbp+var_38]
mov [rax+1], cl
mov rax, [rbp+var_68]
mov rax, [rax+88h]
sar rax, 20h
shr eax, 10h
mov cl, al
mov rax, [rbp+var_38]
mov [rax+2], cl
jmp short $+2
loc_41A33:
mov rax, [rbp+var_38]
add rax, 3
mov [rbp+var_90], rax
mov rcx, [rbp+var_68]
mov rax, 0FFFFFFFFh
and rax, [rcx+88h]
mov ecx, eax
mov rax, [rbp+var_90]
mov [rax], ecx
jmp short $+2
loc_41A64:
mov rax, [rbp+var_38]
add rax, 7
mov [rbp+var_38], rax
mov rax, [rbp+var_68]
mov rcx, 0FFFFFFFFFFFFFFh
cmp [rax+88h], rcx
jz short loc_41AB1
jmp short $+2
loc_41A89:
jmp short $+2
loc_41A8B:
mov rax, [rbp+var_68]
mov rax, [rax+88h]
sub rax, [rbp+var_40]
cmp rax, 0
jge short loc_41AAF
mov rax, [rbp+var_68]
mov rax, [rax+88h]
mov [rbp+var_40], rax
loc_41AAF:
jmp short $+2
loc_41AB1:
jmp short $+2
loc_41AB3:
mov rax, [rbp+var_68]
mov rax, [rax+10h]
mov [rbp+var_68], rax
jmp loc_4190B
loc_41AC4:
jmp short $+2
loc_41AC6:
mov eax, [rbp+var_2C]
add eax, 1
mov [rbp+var_2C], eax
jmp loc_418E4
loc_41AD4:
jmp short $+2
loc_41AD6:
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_unlock_0
mov rcx, [rbp+var_40]
mov rax, [rbp+var_18]
mov [rax], rcx
mov al, [rbp+var_19]
add rsp, 0A0h
pop rbp
retn
loc_41AFD:
mov [rbp+var_19], 1
jmp short loc_41AD6
|
char pagecache_collect_changed_blocks_with_lsn(long long a1, long long *a2, long long *a3)
{
long long v3; // rax
char v5; // [rsp+Fh] [rbp-91h]
long long v6; // [rsp+28h] [rbp-78h]
long long n; // [rsp+38h] [rbp-68h]
_QWORD *v8; // [rsp+40h] [rbp-60h]
long long k; // [rsp+48h] [rbp-58h]
long long v10; // [rsp+50h] [rbp-50h]
long long v11; // [rsp+58h] [rbp-48h]
long long v12; // [rsp+60h] [rbp-40h]
_WORD *v13; // [rsp+68h] [rbp-38h]
_WORD *v14; // [rsp+68h] [rbp-38h]
unsigned int i; // [rsp+74h] [rbp-2Ch]
unsigned int j; // [rsp+74h] [rbp-2Ch]
unsigned int m; // [rsp+74h] [rbp-2Ch]
long long v18; // [rsp+78h] [rbp-28h]
char v19; // [rsp+87h] [rbp-19h]
v19 = 0;
v18 = 0LL;
v12 = 0xFFFFFFFFFFFFFFLL;
inline_mysql_mutex_lock_0(
a1 + 200,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x14C2u);
while ( 1 )
{
for ( i = 0; ; ++i )
{
v11 = my_hash_element(a1 + 432, i);
v5 = 0;
if ( v11 )
v5 = ~(*(_BYTE *)(v11 + 16) != 0);
if ( (v5 & 1) == 0 )
break;
}
if ( !v11 )
break;
v10 = my_thread_var();
wqueue_add_to_queue(v11 + 8, v10);
do
inline_mysql_cond_wait_0(
v10 + 8,
a1 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
5345LL);
while ( *(_QWORD *)(v10 + 136) );
}
for ( j = 0; (unsigned long long)j < *(_QWORD *)(a1 + 40); ++j )
{
for ( k = *(_QWORD *)(*(_QWORD *)(a1 + 296) + 8LL * j); k; k = *(_QWORD *)(k + 16) )
{
if ( *(_DWORD *)(k + 124) == 2 )
++v18;
}
}
a2[1] = 15 * v18 + 8;
v3 = my_malloc(0LL, a2[1], 16LL);
*a2 = v3;
if ( v3 )
{
v8 = (_QWORD *)*a2;
*v8 = v18;
v13 = v8 + 1;
if ( v18 )
{
for ( m = 0; (unsigned long long)m < *(_QWORD *)(a1 + 40); ++m )
{
for ( n = *(_QWORD *)(*(_QWORD *)(a1 + 296) + 8LL * m); n; n = *(_QWORD *)(n + 16) )
{
if ( *(_DWORD *)(n + 124) == 2 )
{
v6 = *(_QWORD *)(*(_QWORD *)(n + 32) + 88LL);
*v13 = *(_WORD *)(v6 + 1568);
v14 = v13 + 1;
*(_BYTE *)v14 = *(_DWORD *)(v6 + 1888) == *(_DWORD *)(*(_QWORD *)(n + 32) + 40LL);
*(_DWORD *)((char *)v14 + 1) = *(_QWORD *)(*(_QWORD *)(n + 32) + 96LL);
*((_BYTE *)v14 + 5) = BYTE4(*(_QWORD *)(*(_QWORD *)(n + 32) + 96LL));
v14 += 3;
*v14 = WORD2(*(_QWORD *)(n + 136));
*((_BYTE *)v14 + 2) = BYTE6(*(_QWORD *)(n + 136));
*(_DWORD *)((char *)v14 + 3) = *(_QWORD *)(n + 136);
v13 = (_WORD *)((char *)v14 + 7);
if ( *(_QWORD *)(n + 136) != 0xFFFFFFFFFFFFFFLL && *(_QWORD *)(n + 136) - v12 < 0 )
v12 = *(_QWORD *)(n + 136);
}
}
}
}
}
else
{
v19 = 1;
}
inline_mysql_mutex_unlock_0(a1 + 200);
*a3 = v12;
return v19;
}
|
pagecache_collect_changed_blocks_with_lsn:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RBP + -0x19],0x0
MOV qword ptr [RBP + -0x28],0x0
MOV RAX,0xffffffffffffff
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00141723
LAB_00141723:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
LEA RSI,[0x25ba24]
MOV EDX,0x14c2
CALL 0x0013db90
LAB_0014173f:
MOV dword ptr [RBP + -0x2c],0x0
LAB_00141746:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x1b0
MOV EAX,dword ptr [RBP + -0x2c]
MOV ESI,EAX
CALL 0x001e34c0
MOV RCX,RAX
MOV qword ptr [RBP + -0x48],RCX
XOR EAX,EAX
CMP RCX,0x0
MOV byte ptr [RBP + -0x91],AL
JZ 0x00141783
MOV RAX,qword ptr [RBP + -0x48]
CMP byte ptr [RAX + 0x10],0x0
SETNZ AL
XOR AL,0xff
MOV byte ptr [RBP + -0x91],AL
LAB_00141783:
MOV AL,byte ptr [RBP + -0x91]
TEST AL,0x1
JNZ 0x0014178f
JMP 0x0014179c
LAB_0014178f:
JMP 0x00141791
LAB_00141791:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00141746
LAB_0014179c:
CMP qword ptr [RBP + -0x48],0x0
JNZ 0x001417a5
JMP 0x001417fa
LAB_001417a5:
CALL 0x001fe880
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x48]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x50]
CALL 0x002086c0
LAB_001417bf:
JMP 0x001417c1
LAB_001417c1:
JMP 0x001417c3
LAB_001417c3:
MOV RDI,qword ptr [RBP + -0x50]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc8
LEA RDX,[0x25ba24]
MOV ECX,0x14e1
CALL 0x00141b10
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RAX + 0x88],0x0
JNZ 0x001417bf
JMP 0x0014173f
LAB_001417fa:
MOV dword ptr [RBP + -0x2c],0x0
LAB_00141801:
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x28]
JNC 0x00141866
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x128]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x58],RAX
LAB_00141824:
CMP qword ptr [RBP + -0x58],0x0
JZ 0x00141859
JMP 0x0014182d
LAB_0014182d:
JMP 0x0014182f
LAB_0014182f:
JMP 0x00141831
LAB_00141831:
JMP 0x00141833
LAB_00141833:
MOV RAX,qword ptr [RBP + -0x58]
CMP dword ptr [RAX + 0x7c],0x2
JZ 0x0014183f
JMP 0x0014184b
LAB_0014183f:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
LAB_0014184b:
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00141824
LAB_00141859:
JMP 0x0014185b
LAB_0014185b:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x00141801
LAB_00141866:
JMP 0x00141868
LAB_00141868:
JMP 0x0014186a
LAB_0014186a:
IMUL RCX,qword ptr [RBP + -0x28],0xf
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
XOR EDI,EDI
MOV EDX,0x10
CALL 0x001fc020
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
XOR EAX,EAX
CMP RAX,RCX
JNZ 0x001418a5
JMP 0x00141afd
LAB_001418a5:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x60],RAX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x8
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001418d1
LAB_001418d1:
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001418dd
JMP 0x00141ad6
LAB_001418dd:
MOV dword ptr [RBP + -0x2c],0x0
LAB_001418e4:
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RCX + 0x28]
JNC 0x00141ad4
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x128]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x68],RAX
LAB_0014190b:
CMP qword ptr [RBP + -0x68],0x0
JZ 0x00141ac4
MOV RAX,qword ptr [RBP + -0x68]
CMP dword ptr [RAX + 0x7c],0x2
JZ 0x00141925
JMP 0x00141ab3
LAB_00141925:
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV AX,word ptr [RAX + 0x620]
MOV word ptr [RBP + -0x6a],AX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x80],RAX
MOV CX,word ptr [RBP + -0x6a]
MOV RAX,qword ptr [RBP + -0x80]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV EAX,dword ptr [RAX + 0x760]
MOV RCX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RCX + 0x20]
CMP EAX,dword ptr [RCX + 0x28]
SETZ AL
AND AL,0x1
MOVZX EAX,AL
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00141996
LAB_00141996:
JMP 0x00141998
LAB_00141998:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x60]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x88]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x5
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001419e4
LAB_001419e4:
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x88]
SAR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x88]
SAR RAX,0x20
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],CL
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x88]
SAR RAX,0x20
SHR EAX,0x10
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x2],CL
JMP 0x00141a33
LAB_00141a33:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x3
MOV qword ptr [RBP + -0x90],RAX
MOV RCX,qword ptr [RBP + -0x68]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x88]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x90]
MOV dword ptr [RAX],ECX
JMP 0x00141a64
LAB_00141a64:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x7
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,0xffffffffffffff
CMP qword ptr [RAX + 0x88],RCX
JZ 0x00141ab1
JMP 0x00141a89
LAB_00141a89:
JMP 0x00141a8b
LAB_00141a8b:
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x88]
SUB RAX,qword ptr [RBP + -0x40]
CMP RAX,0x0
JGE 0x00141aaf
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x88]
MOV qword ptr [RBP + -0x40],RAX
LAB_00141aaf:
JMP 0x00141ab1
LAB_00141ab1:
JMP 0x00141ab3
LAB_00141ab3:
MOV RAX,qword ptr [RBP + -0x68]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x0014190b
LAB_00141ac4:
JMP 0x00141ac6
LAB_00141ac6:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001418e4
LAB_00141ad4:
JMP 0x00141ad6
LAB_00141ad6:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x0013dc00
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV AL,byte ptr [RBP + -0x19]
ADD RSP,0xa0
POP RBP
RET
LAB_00141afd:
MOV byte ptr [RBP + -0x19],0x1
JMP 0x00141ad6
|
int1 pagecache_collect_changed_blocks_with_lsn(long param_1,long *param_2,long *param_3)
{
long lVar1;
long lVar2;
bool bVar3;
long local_70;
long local_60;
long local_48;
long *local_40;
uint local_34;
long local_30;
int1 local_21;
local_21 = 0;
local_30 = 0;
local_48 = 0xffffffffffffff;
inline_mysql_mutex_lock
(param_1 + 200,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",
0x14c2);
while( true ) {
local_34 = 0;
while( true ) {
lVar1 = my_hash_element(param_1 + 0x1b0,local_34);
bVar3 = false;
if (lVar1 != 0) {
bVar3 = *(char *)(lVar1 + 0x10) == '\0';
}
if (!bVar3) break;
local_34 = local_34 + 1;
}
if (lVar1 == 0) break;
lVar2 = _my_thread_var();
wqueue_add_to_queue(lVar1 + 8,lVar2);
do {
inline_mysql_cond_wait
(lVar2 + 8,param_1 + 200,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_pagecache.c",0x14e1);
} while (*(long *)(lVar2 + 0x88) != 0);
}
for (local_34 = 0; (ulong)local_34 < *(ulong *)(param_1 + 0x28); local_34 = local_34 + 1) {
for (local_60 = *(long *)(*(long *)(param_1 + 0x128) + (ulong)local_34 * 8); local_60 != 0;
local_60 = *(long *)(local_60 + 0x10)) {
if (*(int *)(local_60 + 0x7c) == 2) {
local_30 = local_30 + 1;
}
}
}
param_2[1] = local_30 * 0xf + 8;
lVar1 = my_malloc(0,param_2[1],0x10);
*param_2 = lVar1;
if (lVar1 == 0) {
local_21 = 1;
}
else {
param_2 = (long *)*param_2;
*param_2 = local_30;
local_40 = param_2 + 1;
if (local_30 != 0) {
for (local_34 = 0; (ulong)local_34 < *(ulong *)(param_1 + 0x28); local_34 = local_34 + 1) {
for (local_70 = *(long *)(*(long *)(param_1 + 0x128) + (ulong)local_34 * 8); local_70 != 0;
local_70 = *(long *)(local_70 + 0x10)) {
if (*(int *)(local_70 + 0x7c) == 2) {
lVar1 = *(long *)(*(long *)(local_70 + 0x20) + 0x58);
*(int2 *)local_40 = *(int2 *)(lVar1 + 0x620);
*(bool *)((long)local_40 + 2) =
*(int *)(lVar1 + 0x760) == *(int *)(*(long *)(local_70 + 0x20) + 0x28);
*(int *)((long)local_40 + 3) = (int)*(int8 *)(*(long *)(local_70 + 0x20) + 0x60);
*(char *)((long)local_40 + 7) =
(char)((ulong)*(int8 *)(*(long *)(local_70 + 0x20) + 0x60) >> 0x20);
*(char *)(local_40 + 1) = (char)((ulong)*(int8 *)(local_70 + 0x88) >> 0x20);
*(char *)((long)local_40 + 9) = (char)((ulong)*(int8 *)(local_70 + 0x88) >> 0x28);
*(char *)((long)local_40 + 10) = (char)((ulong)*(int8 *)(local_70 + 0x88) >> 0x30)
;
*(int *)((long)local_40 + 0xb) = (int)*(int8 *)(local_70 + 0x88);
local_40 = (long *)((long)local_40 + 0xf);
if ((*(long *)(local_70 + 0x88) != 0xffffffffffffff) &&
(*(long *)(local_70 + 0x88) - local_48 < 0)) {
local_48 = *(long *)(local_70 + 0x88);
}
}
}
}
}
}
inline_mysql_mutex_unlock(param_1 + 200);
*param_3 = local_48;
return local_21;
}
|
|
57,695
|
my_get_err_msg
|
eloqsql/mysys/my_error.c
|
const char *my_get_err_msg(uint nr)
{
const char *format;
struct my_err_head *meh_p;
/* Search for the range this error is in. */
for (meh_p= my_errmsgs_list; meh_p; meh_p= meh_p->meh_next)
if (nr <= meh_p->meh_last)
break;
/*
If we found the range this error number is in, get the format string.
If the string is empty, or a NULL pointer, or if we're out of return,
we return NULL.
*/
if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
!*format)
return NULL;
return format;
}
|
O0
|
c
|
my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq 0x1d01e6(%rip), %rax # 0x2bf9c8
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xef80a
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x14(%rcx), %eax
ja 0xef7fb
jmp 0xef80a
jmp 0xef7fd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xef7e6
cmpq $0x0, -0x20(%rbp)
je 0xef840
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jb 0xef840
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rdx
subl 0x10(%rdx), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0xef848
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0xef848
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xef85f
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xef869
movq $0x0, -0x8(%rbp)
jmp 0xef871
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
my_get_err_msg:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_C], edi
mov rax, cs:my_errmsgs_list
mov [rbp+var_20], rax
loc_EF7E6:
cmp [rbp+var_20], 0
jz short loc_EF80A
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
cmp eax, [rcx+14h]
ja short loc_EF7FB
jmp short loc_EF80A
loc_EF7FB:
jmp short $+2
loc_EF7FD:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_EF7E6
loc_EF80A:
cmp [rbp+var_20], 0
jz short loc_EF840
mov eax, [rbp+var_C]
mov rcx, [rbp+var_20]
cmp eax, [rcx+10h]
jb short loc_EF840
mov rax, [rbp+var_20]
mov rax, [rax+8]
mov edi, [rbp+var_C]
call rax
mov ecx, [rbp+var_C]
mov rdx, [rbp+var_20]
sub ecx, [rdx+10h]
mov ecx, ecx
mov rax, [rax+rcx*8]
mov [rbp+var_28], rax
jmp short loc_EF848
loc_EF840:
xor eax, eax
mov [rbp+var_28], rax
jmp short $+2
loc_EF848:
mov rax, [rbp+var_28]
mov [rbp+var_18], rax
cmp rax, 0
jz short loc_EF85F
mov rax, [rbp+var_18]
cmp byte ptr [rax], 0
jnz short loc_EF869
loc_EF85F:
mov [rbp+var_8], 0
jmp short loc_EF871
loc_EF869:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
loc_EF871:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
|
_BYTE * my_get_err_msg(unsigned int a1)
{
_BYTE *v2; // [rsp+8h] [rbp-28h]
long long *i; // [rsp+10h] [rbp-20h]
for ( i = my_errmsgs_list; i && a1 > *((_DWORD *)i + 5); i = (long long *)*i )
;
if ( i && a1 >= *((_DWORD *)i + 4) )
v2 = *(_BYTE **)(((long long ( *)(_QWORD))i[1])(a1) + 8LL * (a1 - *((_DWORD *)i + 4)));
else
v2 = 0LL;
if ( v2 && *v2 )
return v2;
else
return 0LL;
}
|
my_get_err_msg:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0xc],EDI
MOV RAX,qword ptr [0x003bf9c8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001ef7e6:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001ef80a
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x14]
JA 0x001ef7fb
JMP 0x001ef80a
LAB_001ef7fb:
JMP 0x001ef7fd
LAB_001ef7fd:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001ef7e6
LAB_001ef80a:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001ef840
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x20]
CMP EAX,dword ptr [RCX + 0x10]
JC 0x001ef840
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x8]
MOV EDI,dword ptr [RBP + -0xc]
CALL RAX
MOV ECX,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
SUB ECX,dword ptr [RDX + 0x10]
MOV ECX,ECX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001ef848
LAB_001ef840:
XOR EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001ef848
LAB_001ef848:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JZ 0x001ef85f
MOV RAX,qword ptr [RBP + -0x18]
CMP byte ptr [RAX],0x0
JNZ 0x001ef869
LAB_001ef85f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001ef871
LAB_001ef869:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
LAB_001ef871:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
long lVar1;
char *local_30;
int8 *local_28;
char *local_10;
for (local_28 = (int8 *)my_errmsgs_list;
(local_28 != (int8 *)0x0 && (*(uint *)((long)local_28 + 0x14) < param_1));
local_28 = (int8 *)*local_28) {
}
if ((local_28 == (int8 *)0x0) || (param_1 < *(uint *)(local_28 + 2))) {
local_30 = (char *)0x0;
}
else {
lVar1 = (*(code *)local_28[1])(param_1);
local_30 = *(char **)(lVar1 + (ulong)(param_1 - *(int *)(local_28 + 2)) * 8);
}
if ((local_30 == (char *)0x0) || (*local_30 == '\0')) {
local_10 = (char *)0x0;
}
else {
local_10 = local_30;
}
return local_10;
}
|
|
57,696
|
mysql_stmt_store_result_start
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
int STDCALL
mysql_stmt_store_result_start(int *ret, MYSQL_STMT *stmt)
{
MK_ASYNC_START_BODY(
mysql_stmt_store_result,
stmt->mysql,
{
WIN_SET_NONBLOCKING(stmt->mysql)
parms.stmt= stmt;
},
1,
r_int,
/* If stmt->mysql==NULL then we will not block so can call directly. */
if (!stmt->mysql)
{
*ret= mysql_stmt_store_result(stmt);
return 0;
})
}
|
O0
|
c
|
mysql_stmt_store_result_start:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3d418
movq -0x18(%rbp), %rdi
callq 0x2ae50
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x3d529
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movb $0x1, 0x14(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
leaq 0xf2(%rip), %rsi # 0x3d540
leaq -0x30(%rbp), %rdx
callq 0x3f490
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, 0x15(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0x3d486
movq -0x28(%rbp), %rax
movb $0x1, 0x15(%rax)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3d529
cmpl $0x0, -0x1c(%rbp)
jge 0x3d515
jmp 0x3d492
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x22a26(%rip), %rax # 0x5fee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x29c(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x97, %rdi
leaq 0x22a04(%rip), %rax # 0x5fef0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13210
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x296(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0x3d522
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
mysql_stmt_store_result_start:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_3D418
mov rdi, [rbp+var_18]
call mysql_stmt_store_result
mov ecx, eax
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 0
jmp loc_3D529
loc_3D418:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 1
mov rdi, [rbp+var_28]
add rdi, 38h ; '8'
lea rsi, mysql_stmt_store_result_start_internal
lea rdx, [rbp+var_30]
call my_context_spawn
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 0
mov rax, [rbp+var_28]
mov byte ptr [rax+14h], 0
cmp [rbp+var_1C], 0
jle short loc_3D486
mov rax, [rbp+var_28]
mov byte ptr [rax+15h], 1
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_4], eax
jmp loc_3D529
loc_3D486:
cmp [rbp+var_1C], 0
jge loc_3D515
jmp short $+2
loc_3D492:
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 7D8h
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+29Ch], 0
mov rax, [rbp+var_18]
mov rdi, [rax+38h]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_18]
mov rax, [rax+38h]
mov byte ptr [rax+296h], 0
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_3D522
loc_3D515:
mov rax, [rbp+var_28]
mov ecx, [rax+8]
mov rax, [rbp+var_10]
mov [rax], ecx
loc_3D522:
mov [rbp+var_4], 0
loc_3D529:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long mysql_stmt_store_result_start(_DWORD *a1, long long a2)
{
long long v3; // [rsp+0h] [rbp-30h] BYREF
unsigned int *v4; // [rsp+8h] [rbp-28h]
int v5; // [rsp+14h] [rbp-1Ch]
long long v6; // [rsp+18h] [rbp-18h]
_DWORD *v7; // [rsp+20h] [rbp-10h]
v7 = a1;
v6 = a2;
if ( *(_QWORD *)(a2 + 56) )
{
v4 = *(unsigned int **)(*(_QWORD *)(*(_QWORD *)(v6 + 56) + 1152LL) + 40LL);
v3 = v6;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_stmt_store_result_start_internal, &v3);
*((_BYTE *)v4 + 21) = 0;
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
if ( v5 >= 0 )
{
*v7 = v4[2];
}
else
{
*(_DWORD *)(*(_QWORD *)(v6 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(v6 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(v6 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(v6 + 56) + 662LL) = 0;
*v7 = 1;
}
return 0;
}
else
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
}
else
{
*v7 = mysql_stmt_store_result(v6);
return 0;
}
}
|
mysql_stmt_store_result_start:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x0013d418
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012ae50
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013d529
LAB_0013d418:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x1
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x38
LEA RSI,[0x13d540]
LEA RDX,[RBP + -0x30]
CALL 0x0013f490
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x0
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x14],0x0
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x0013d486
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x15],0x1
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013d529
LAB_0013d486:
CMP dword ptr [RBP + -0x1c],0x0
JGE 0x0013d515
JMP 0x0013d492
LAB_0013d492:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RAX,[0x15fee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x29c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x97
LEA RAX,[0x15fef0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x296],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x0013d522
LAB_0013d515:
MOV RAX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
LAB_0013d522:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013d529:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_stmt_store_result_start(int4 *param_1,long param_2)
{
int4 uVar1;
long local_38;
int4 *local_30;
int local_24;
long local_20;
int4 *local_18;
int4 local_c;
local_20 = param_2;
local_18 = param_1;
if (*(long *)(param_2 + 0x38) == 0) {
uVar1 = mysql_stmt_store_result(param_2);
*local_18 = uVar1;
local_c = 0;
}
else {
local_30 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
*(int1 *)(local_30 + 5) = 1;
local_38 = param_2;
local_24 = my_context_spawn(local_30 + 0xe,mysql_stmt_store_result_start_internal,&local_38);
*(int1 *)((long)local_30 + 0x15) = 0;
*(int1 *)(local_30 + 5) = 0;
if (local_24 < 1) {
if (local_24 < 0) {
*(int4 *)(*(long *)(local_20 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(local_20 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0015ff30,
0x1ff);
*(int1 *)(*(long *)(local_20 + 0x38) + 0x296) = 0;
*local_18 = 1;
}
else {
*local_18 = local_30[2];
}
local_c = 0;
}
else {
*(int1 *)((long)local_30 + 0x15) = 1;
local_c = *local_30;
}
}
return local_c;
}
|
|
57,697
|
mysql_stmt_attr_get
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, void *value)
{
switch (attr_type) {
case STMT_ATTR_STATE:
*(enum mysql_stmt_state *)value= stmt->state;
break;
case STMT_ATTR_UPDATE_MAX_LENGTH:
*(my_bool *)value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
*(unsigned long *)value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
*(unsigned long *)value= stmt->prefetch_rows;
break;
case STMT_ATTR_PREBIND_PARAMS:
*(unsigned int *)value= stmt->prebind_params;
break;
case STMT_ATTR_ARRAY_SIZE:
*(unsigned int *)value= stmt->array_size;
break;
case STMT_ATTR_ROW_SIZE:
*(size_t *)value= stmt->row_size;
break;
case STMT_ATTR_CB_USER_DATA:
*((void **)value) = stmt->user_data;
break;
default:
return(1);
}
return(0);
}
|
O0
|
c
|
mysql_stmt_attr_get:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x280f8
jmp 0x2807b
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x2810a
jmp 0x28089
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x2811b
jmp 0x28097
movl -0x24(%rbp), %eax
subl $0xc8, %eax
je 0x2812f
jmp 0x280a7
movl -0x24(%rbp), %eax
subl $0xc9, %eax
je 0x28141
jmp 0x280b7
movl -0x24(%rbp), %eax
subl $0xca, %eax
je 0x28153
jmp 0x280c7
movl -0x24(%rbp), %eax
subl $0xcb, %eax
je 0x280e6
jmp 0x280d3
movl -0x24(%rbp), %eax
subl $0xcc, %eax
je 0x28167
jmp 0x2817b
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movb 0x313(%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movq 0x318(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movl 0x378(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movl 0x368(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movq 0x370(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28181
movq -0x10(%rbp), %rax
movq 0x380(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x28181
movb $0x1, -0x1(%rbp)
jmp 0x28185
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
|
mysql_stmt_attr_get:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov eax, [rbp+var_14]
mov [rbp+var_24], eax
test eax, eax
jz short loc_280F8
jmp short $+2
loc_2807B:
mov eax, [rbp+var_24]
sub eax, 1
jz loc_2810A
jmp short $+2
loc_28089:
mov eax, [rbp+var_24]
sub eax, 2
jz loc_2811B
jmp short $+2
loc_28097:
mov eax, [rbp+var_24]
sub eax, 0C8h
jz loc_2812F
jmp short $+2
loc_280A7:
mov eax, [rbp+var_24]
sub eax, 0C9h
jz loc_28141
jmp short $+2
loc_280B7:
mov eax, [rbp+var_24]
sub eax, 0CAh
jz loc_28153
jmp short $+2
loc_280C7:
mov eax, [rbp+var_24]
sub eax, 0CBh
jz short loc_280E6
jmp short $+2
loc_280D3:
mov eax, [rbp+var_24]
sub eax, 0CCh
jz loc_28167
jmp loc_2817B
loc_280E6:
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp loc_28181
loc_280F8:
mov rax, [rbp+var_10]
mov cl, [rax+313h]
mov rax, [rbp+var_20]
mov [rax], cl
jmp short loc_28181
loc_2810A:
mov rax, [rbp+var_10]
mov rcx, [rax+48h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28181
loc_2811B:
mov rax, [rbp+var_10]
mov rcx, [rax+318h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28181
loc_2812F:
mov rax, [rbp+var_10]
mov ecx, [rax+378h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_28181
loc_28141:
mov rax, [rbp+var_10]
mov ecx, [rax+368h]
mov rax, [rbp+var_20]
mov [rax], ecx
jmp short loc_28181
loc_28153:
mov rax, [rbp+var_10]
mov rcx, [rax+370h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28181
loc_28167:
mov rax, [rbp+var_10]
mov rcx, [rax+380h]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_28181
loc_2817B:
mov [rbp+var_1], 1
jmp short loc_28185
loc_28181:
mov [rbp+var_1], 0
loc_28185:
mov al, [rbp+var_1]
pop rbp
retn
|
char mysql_stmt_attr_get(long long a1, int a2, _BYTE *a3)
{
switch ( a2 )
{
case 0:
*a3 = *(_BYTE *)(a1 + 787);
return 0;
case 1:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 72);
return 0;
case 2:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 792);
return 0;
case 200:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 888);
return 0;
case 201:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 872);
return 0;
case 202:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 880);
return 0;
case 203:
*(_DWORD *)a3 = *(_DWORD *)(a1 + 80);
return 0;
case 204:
*(_QWORD *)a3 = *(_QWORD *)(a1 + 896);
return 0;
}
return 1;
}
|
mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x24],EAX
TEST EAX,EAX
JZ 0x001280f8
JMP 0x0012807b
LAB_0012807b:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x1
JZ 0x0012810a
JMP 0x00128089
LAB_00128089:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x2
JZ 0x0012811b
JMP 0x00128097
LAB_00128097:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc8
JZ 0x0012812f
JMP 0x001280a7
LAB_001280a7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xc9
JZ 0x00128141
JMP 0x001280b7
LAB_001280b7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xca
JZ 0x00128153
JMP 0x001280c7
LAB_001280c7:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcb
JZ 0x001280e6
JMP 0x001280d3
LAB_001280d3:
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0xcc
JZ 0x00128167
JMP 0x0012817b
LAB_001280e6:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128181
LAB_001280f8:
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x313]
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
JMP 0x00128181
LAB_0012810a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128181
LAB_0012811b:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x318]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128181
LAB_0012812f:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x378]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128181
LAB_00128141:
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x368]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],ECX
JMP 0x00128181
LAB_00128153:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x370]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128181
LAB_00128167:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x380]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x00128181
LAB_0012817b:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00128185
LAB_00128181:
MOV byte ptr [RBP + -0x1],0x0
LAB_00128185:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
if (param_2 == 0) {
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
}
else if (param_2 == 1) {
*param_3 = *(int8 *)(param_1 + 0x48);
}
else if (param_2 == 2) {
*param_3 = *(int8 *)(param_1 + 0x318);
}
else if (param_2 == 200) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x378);
}
else if (param_2 == 0xc9) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x368);
}
else if (param_2 == 0xca) {
*param_3 = *(int8 *)(param_1 + 0x370);
}
else if (param_2 == 0xcb) {
*(int4 *)param_3 = *(int4 *)(param_1 + 0x50);
}
else {
if (param_2 != 0xcc) {
return 1;
}
*param_3 = *(int8 *)(param_1 + 0x380);
}
return 0;
}
|
|
57,698
|
mysql_stmt_attr_get
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
my_bool STDCALL mysql_stmt_attr_get(MYSQL_STMT *stmt, enum enum_stmt_attr_type attr_type, void *value)
{
switch (attr_type) {
case STMT_ATTR_STATE:
*(enum mysql_stmt_state *)value= stmt->state;
break;
case STMT_ATTR_UPDATE_MAX_LENGTH:
*(my_bool *)value= stmt->update_max_length;
break;
case STMT_ATTR_CURSOR_TYPE:
*(unsigned long *)value= stmt->flags;
break;
case STMT_ATTR_PREFETCH_ROWS:
*(unsigned long *)value= stmt->prefetch_rows;
break;
case STMT_ATTR_PREBIND_PARAMS:
*(unsigned int *)value= stmt->prebind_params;
break;
case STMT_ATTR_ARRAY_SIZE:
*(unsigned int *)value= stmt->array_size;
break;
case STMT_ATTR_ROW_SIZE:
*(size_t *)value= stmt->row_size;
break;
case STMT_ATTR_CB_USER_DATA:
*((void **)value) = stmt->user_data;
break;
default:
return(1);
}
return(0);
}
|
O3
|
c
|
mysql_stmt_attr_get:
pushq %rbp
movq %rsp, %rbp
movb $0x1, %al
cmpl $0xc7, %esi
jle 0x1f93d
addl $0xffffff38, %esi # imm = 0xFFFFFF38
cmpl $0x4, %esi
ja 0x1f988
leaq 0x186c0(%rip), %rax # 0x37fec
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl 0x378(%rdi), %eax
jmp 0x1f984
testl %esi, %esi
je 0x1f954
cmpl $0x1, %esi
je 0x1f970
cmpl $0x2, %esi
jne 0x1f988
movq 0x318(%rdi), %rax
jmp 0x1f974
movb 0x313(%rdi), %al
movb %al, (%rdx)
jmp 0x1f986
movq 0x380(%rdi), %rax
jmp 0x1f974
movq 0x370(%rdi), %rax
jmp 0x1f974
movq 0x48(%rdi), %rax
movq %rax, (%rdx)
jmp 0x1f986
movl 0x50(%rdi), %eax
jmp 0x1f984
movl 0x368(%rdi), %eax
movl %eax, (%rdx)
xorl %eax, %eax
popq %rbp
retq
|
mysql_stmt_attr_get:
push rbp
mov rbp, rsp
mov al, 1
cmp esi, 0C7h
jle short loc_1F93D
add esi, 0FFFFFF38h; switch 5 cases
cmp esi, 4
ja short def_1F933; jumptable 000000000001F933 default case
lea rax, jpt_1F933
movsxd rcx, ds:(jpt_1F933 - 37FECh)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_1F935:
mov eax, [rdi+378h]; jumptable 000000000001F933 case 200
jmp short loc_1F984
loc_1F93D:
test esi, esi
jz short loc_1F954
cmp esi, 1
jz short loc_1F970
cmp esi, 2
jnz short def_1F933; jumptable 000000000001F933 default case
mov rax, [rdi+318h]
jmp short loc_1F974
loc_1F954:
mov al, [rdi+313h]
mov [rdx], al
jmp short loc_1F986
loc_1F95E:
mov rax, [rdi+380h]; jumptable 000000000001F933 case 204
jmp short loc_1F974
loc_1F967:
mov rax, [rdi+370h]; jumptable 000000000001F933 case 202
jmp short loc_1F974
loc_1F970:
mov rax, [rdi+48h]
loc_1F974:
mov [rdx], rax
jmp short loc_1F986
loc_1F979:
mov eax, [rdi+50h]; jumptable 000000000001F933 case 203
jmp short loc_1F984
loc_1F97E:
mov eax, [rdi+368h]; jumptable 000000000001F933 case 201
loc_1F984:
mov [rdx], eax
loc_1F986:
xor eax, eax
def_1F933:
pop rbp; jumptable 000000000001F933 default case
retn
|
char mysql_stmt_attr_get(long long a1, int a2, _DWORD *a3)
{
char result; // al
int v4; // eax
long long v5; // rax
result = 1;
if ( a2 > 199 )
{
switch ( a2 )
{
case 200:
v4 = *(_DWORD *)(a1 + 888);
goto LABEL_15;
case 201:
v4 = *(_DWORD *)(a1 + 872);
goto LABEL_15;
case 202:
v5 = *(_QWORD *)(a1 + 880);
goto LABEL_12;
case 203:
v4 = *(_DWORD *)(a1 + 80);
LABEL_15:
*a3 = v4;
return 0;
case 204:
v5 = *(_QWORD *)(a1 + 896);
goto LABEL_12;
default:
return result;
}
}
if ( a2 )
{
if ( a2 == 1 )
{
v5 = *(_QWORD *)(a1 + 72);
}
else
{
if ( a2 != 2 )
return result;
v5 = *(_QWORD *)(a1 + 792);
}
LABEL_12:
*(_QWORD *)a3 = v5;
}
else
{
*(_BYTE *)a3 = *(_BYTE *)(a1 + 787);
}
return 0;
}
|
mysql_stmt_attr_get:
PUSH RBP
MOV RBP,RSP
MOV AL,0x1
CMP ESI,0xc7
JLE 0x0011f93d
ADD ESI,0xffffff38
CMP ESI,0x4
JA 0x0011f988
LEA RAX,[0x137fec]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_c8:
MOV EAX,dword ptr [RDI + 0x378]
JMP 0x0011f984
LAB_0011f93d:
TEST ESI,ESI
JZ 0x0011f954
CMP ESI,0x1
JZ 0x0011f970
CMP ESI,0x2
JNZ 0x0011f988
MOV RAX,qword ptr [RDI + 0x318]
JMP 0x0011f974
LAB_0011f954:
MOV AL,byte ptr [RDI + 0x313]
MOV byte ptr [RDX],AL
JMP 0x0011f986
caseD_cc:
MOV RAX,qword ptr [RDI + 0x380]
JMP 0x0011f974
caseD_ca:
MOV RAX,qword ptr [RDI + 0x370]
JMP 0x0011f974
LAB_0011f970:
MOV RAX,qword ptr [RDI + 0x48]
LAB_0011f974:
MOV qword ptr [RDX],RAX
JMP 0x0011f986
caseD_cb:
MOV EAX,dword ptr [RDI + 0x50]
JMP 0x0011f984
caseD_c9:
MOV EAX,dword ptr [RDI + 0x368]
LAB_0011f984:
MOV dword ptr [RDX],EAX
LAB_0011f986:
XOR EAX,EAX
default:
POP RBP
RET
|
int8 mysql_stmt_attr_get(long param_1,int param_2,int8 *param_3)
{
int4 uVar1;
int8 uVar2;
uVar2 = 1;
if (param_2 < 200) {
if (param_2 != 0) {
if (param_2 == 1) {
uVar2 = *(int8 *)(param_1 + 0x48);
}
else {
if (param_2 != 2) {
return 1;
}
uVar2 = *(int8 *)(param_1 + 0x318);
}
goto LAB_0011f974;
}
*(int1 *)param_3 = *(int1 *)(param_1 + 0x313);
goto LAB_0011f986;
}
switch(param_2) {
case 200:
uVar1 = *(int4 *)(param_1 + 0x378);
break;
case 0xc9:
uVar1 = *(int4 *)(param_1 + 0x368);
break;
case 0xca:
uVar2 = *(int8 *)(param_1 + 0x370);
goto LAB_0011f974;
case 0xcb:
uVar1 = *(int4 *)(param_1 + 0x50);
break;
case 0xcc:
uVar2 = *(int8 *)(param_1 + 0x380);
LAB_0011f974:
*param_3 = uVar2;
goto LAB_0011f986;
default:
goto switchD_0011f933_default;
}
*(int4 *)param_3 = uVar1;
LAB_0011f986:
uVar2 = 0;
switchD_0011f933_default:
return uVar2;
}
|
|
57,699
|
my_context_continue
|
eloqsql/libmariadb/libmariadb/ma_context.c
|
int
my_context_continue(struct my_context *c)
{
int ret;
__asm__ __volatile__
(
"movq (%[save]), %%rax\n\t"
"movq %%rsp, (%[save])\n\t"
"movq %%rax, %%rsp\n\t"
"movq 8(%[save]), %%rax\n\t"
"movq %%rbp, 8(%[save])\n\t"
"movq %%rax, %%rbp\n\t"
"movq 24(%[save]), %%rax\n\t"
"movq %%r12, 24(%[save])\n\t"
"movq %%rax, %%r12\n\t"
"movq 32(%[save]), %%rax\n\t"
"movq %%r13, 32(%[save])\n\t"
"movq %%rax, %%r13\n\t"
"movq 40(%[save]), %%rax\n\t"
"movq %%r14, 40(%[save])\n\t"
"movq %%rax, %%r14\n\t"
"movq 48(%[save]), %%rax\n\t"
"movq %%r15, 48(%[save])\n\t"
"movq %%rax, %%r15\n\t"
"leaq 1f(%%rip), %%rax\n\t"
"leaq 2f(%%rip), %%rcx\n\t"
"movq %%rax, 56(%[save])\n\t"
"movq 64(%[save]), %%rax\n\t"
"movq %%rcx, 64(%[save])\n\t"
"movq 16(%[save]), %%rcx\n\t"
"movq %%rbx, 16(%[save])\n\t"
"movq %%rcx, %%rbx\n\t"
"jmpq *%%rax\n"
/*
Come here when operation is done.
Be sure to use the same callee-save register for %[save] here and in
my_context_spawn(), so we preserve the value correctly at this point.
*/
"1:\n\t"
"movq (%[save]), %%rsp\n\t"
"movq 8(%[save]), %%rbp\n\t"
/* %rbx is preserved from my_context_spawn() in this case. */
"movq 24(%[save]), %%r12\n\t"
"movq 32(%[save]), %%r13\n\t"
"movq 40(%[save]), %%r14\n\t"
"movq 48(%[save]), %%r15\n\t"
"xorl %[ret], %[ret]\n\t"
"jmp 3f\n"
/* Come here when operation is suspended. */
"2:\n\t"
"movl $1, %[ret]\n"
"3:\n"
: [ret] "=a" (ret)
: /* Need this in callee-save register to preserve in function call. */
[save] "b" (&c->save[0])
: "rcx", "rdx", "rsi", "rdi", "r8", "r9", "r10", "r11", "memory", "cc"
);
return ret;
}
|
O0
|
c
|
my_context_continue:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rbx
movq (%rbx), %rax
movq %rsp, (%rbx)
movq %rax, %rsp
movq 0x8(%rbx), %rax
movq %rbp, 0x8(%rbx)
movq %rax, %rbp
movq 0x18(%rbx), %rax
movq %r12, 0x18(%rbx)
movq %rax, %r12
movq 0x20(%rbx), %rax
movq %r13, 0x20(%rbx)
movq %rax, %r13
movq 0x28(%rbx), %rax
movq %r14, 0x28(%rbx)
movq %rax, %r14
movq 0x30(%rbx), %rax
movq %r15, 0x30(%rbx)
movq %rax, %r15
leaq 0x20(%rip), %rax # 0x64724
leaq 0x34(%rip), %rcx # 0x6473f
movq %rax, 0x38(%rbx)
movq 0x40(%rbx), %rax
movq %rcx, 0x40(%rbx)
movq 0x10(%rbx), %rcx
movq %rbx, 0x10(%rbx)
movq %rcx, %rbx
jmpq *%rax
movq (%rbx), %rsp
movq 0x8(%rbx), %rbp
movq 0x18(%rbx), %r12
movq 0x20(%rbx), %r13
movq 0x28(%rbx), %r14
movq 0x30(%rbx), %r15
xorl %eax, %eax
jmp 0x64744
movl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbx
popq %rbp
retq
nopl (%rax)
|
my_context_continue:
push rbp
mov rbp, rsp
push rbx
mov [rbp+var_10], rdi
mov rbx, [rbp+var_10]
mov rax, [rbx]
mov [rbx], rsp
mov rsp, rax
mov rax, [rbx+8]
mov [rbx+8], rbp
mov rbp, rax
mov rax, [rbx+18h]
mov [rbx+18h], r12
mov r12, rax
mov rax, [rbx+20h]
mov [rbx+20h], r13
mov r13, rax
mov rax, [rbx+28h]
mov [rbx+28h], r14
mov r14, rax
mov rax, [rbx+30h]
mov [rbx+30h], r15
mov r15, rax
lea rax, sub_64724
lea rcx, loc_6473F
mov [rbx+38h], rax
mov rax, [rbx+40h]
mov [rbx+40h], rcx
mov rcx, [rbx+10h]
mov [rbx+10h], rbx
mov rbx, rcx
jmp rax
|
long long my_context_continue(_QWORD *a1)
{
long long v1; // r12
long long v2; // r13
long long v3; // r14
long long v4; // r15
long long (*v5)(void); // rax
long long v7; // [rsp+8h] [rbp-8h] BYREF
long long savedregs; // [rsp+10h] [rbp+0h] BYREF
*a1 = &v7;
a1[1] = &savedregs;
a1[3] = v1;
a1[4] = v2;
a1[5] = v3;
a1[6] = v4;
a1[7] = sub_64724;
v5 = (long long (*)(void))a1[8];
a1[8] = &loc_6473F;
a1[2] = a1;
return v5();
}
|
my_context_continue:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV qword ptr [RBP + -0x10],RDI
MOV RBX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBX]
MOV qword ptr [RBX],RSP
MOV RSP,RAX
MOV RAX,qword ptr [RBX + 0x8]
MOV qword ptr [RBX + 0x8],RBP
MOV RBP,RAX
MOV RAX,qword ptr [RBX + 0x18]
MOV qword ptr [RBX + 0x18],R12
MOV R12,RAX
MOV RAX,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x20],R13
MOV R13,RAX
MOV RAX,qword ptr [RBX + 0x28]
MOV qword ptr [RBX + 0x28],R14
MOV R14,RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [RBX + 0x30],R15
MOV R15,RAX
LEA RAX,[0x164724]
LEA RCX,[0x16473f]
MOV qword ptr [RBX + 0x38],RAX
MOV RAX,qword ptr [RBX + 0x40]
MOV qword ptr [RBX + 0x40],RCX
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RBX + 0x10],RBX
MOV RBX,RCX
JMP RAX
|
void my_context_continue(long param_1)
{
code *UNRECOVERED_JUMPTABLE;
int8 unaff_R12;
int8 unaff_R13;
int8 unaff_R14;
int8 unaff_R15;
*(int1 **)param_1 = &stack0xfffffffffffffff0;
*(int1 **)(param_1 + 8) = &stack0xfffffffffffffff8;
*(int8 *)(param_1 + 0x18) = unaff_R12;
*(int8 *)(param_1 + 0x20) = unaff_R13;
*(int8 *)(param_1 + 0x28) = unaff_R14;
*(int8 *)(param_1 + 0x30) = unaff_R15;
*(int1 **)(param_1 + 0x38) = &LAB_00164724;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x40);
*(int1 **)(param_1 + 0x40) = &LAB_0016473f;
*(long *)(param_1 + 0x10) = param_1;
/* WARNING: Could not recover jumptable at 0x00164722. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)();
return;
}
|
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.