Decompile-Bench
Collection
Train: 2 million binary-source function pairs (condensed from 100 million). Test: HumanEval, MBPP, 60K from GitHub repos released after 2025.
•
3 items
•
Updated
•
3
Dataset Viewer
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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
0 |
mi_cmp_dynamic_unique
|
eloqsql/storage/myisam/mi_dynrec.c
|
int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
const uchar *record, my_off_t pos)
{
uchar *rec_buff,*old_record;
int error;
DBUG_ENTER("_mi_cmp_dynamic_unique");
if (!(old_record=my_alloca(info->s->base.reclength)))
DBUG_RETURN(1);
/* Don't let the compare destroy blobs that may be in use */
rec_buff=info->rec_buff;
if (info->s->base.blobs)
info->rec_buff=0;
error=_mi_read_dynamic_record(info,pos,old_record);
if (!error)
error=mi_unique_comp(def, record, old_record, def->null_are_equal);
if (info->s->base.blobs)
{
my_free(mi_get_rec_buff_ptr(info, info->rec_buff));
info->rec_buff=rec_buff;
}
my_afree(old_record);
DBUG_RETURN(error);
}
|
O0
|
c
|
mi_cmp_dynamic_unique:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x140(%rax), %rsi
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %edx
callq 0xf99f0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xab559
jmp 0xab54d
movl $0x1, -0x4(%rbp)
jmp 0xab63e
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xab587
movq -0x10(%rbp), %rax
movq $0x0, 0x120(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xab110
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0xab5bd
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rax
movsbl 0x3(%rax), %ecx
callq 0xc47a0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x188(%rax)
je 0xab62f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x318(%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xab608
movq -0x10(%rbp), %rax
cmpq $0x0, 0x120(%rax)
je 0xab608
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
addq $-0x18, %rax
movq %rax, -0x48(%rbp)
jmp 0xab617
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xf9d70
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x38(%rbp), %rdi
callq 0xf9d70
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
_mi_cmp_dynamic_unique:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rsi, [rax+140h]
xor edi, edi
xor eax, eax
mov edx, eax
call my_malloc
mov [rbp+var_38], rax
cmp rax, 0
jnz short loc_AB559
jmp short $+2
loc_AB54D:
mov [rbp+var_4], 1
jmp loc_AB63E
loc_AB559:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz short loc_AB587
mov rax, [rbp+var_10]
mov qword ptr [rax+120h], 0
loc_AB587:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _mi_read_dynamic_record
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jnz short loc_AB5BD
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_38]
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax+3]
call mi_unique_comp
mov [rbp+var_3C], eax
loc_AB5BD:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp dword ptr [rax+188h], 0
jz short loc_AB62F
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+318h]
and rax, 1
cmp rax, 0
jz short loc_AB608
mov rax, [rbp+var_10]
cmp qword ptr [rax+120h], 0
jz short loc_AB608
mov rax, [rbp+var_10]
mov rax, [rax+120h]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_48], rax
jmp short loc_AB617
loc_AB608:
mov rax, [rbp+var_10]
mov rax, [rax+120h]
mov [rbp+var_48], rax
loc_AB617:
mov rdi, [rbp+var_48]
call my_free
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+120h], rcx
loc_AB62F:
mov rdi, [rbp+var_38]
call my_free
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_AB63E:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
|
long long mi_cmp_dynamic_unique(char *a1, long long a2, long long a3, const char *a4)
{
unsigned int dynamic_record; // [rsp+14h] [rbp-3Ch]
const char *v6; // [rsp+18h] [rbp-38h]
long long v7; // [rsp+20h] [rbp-30h]
v6 = (const char *)my_malloc(0LL, *(_QWORD *)(*(_QWORD *)a1 + 320LL), 0LL);
if ( v6 )
{
v7 = *((_QWORD *)a1 + 36);
if ( *(_DWORD *)(*(_QWORD *)a1 + 392LL) )
*((_QWORD *)a1 + 36) = 0LL;
dynamic_record = mi_read_dynamic_record(a1, a4, v6);
if ( !dynamic_record )
dynamic_record = mi_unique_comp(a2, a3, v6, (unsigned int)*(char *)(a2 + 3));
if ( *(_DWORD *)(*(_QWORD *)a1 + 392LL) )
{
if ( (*(_QWORD *)(*(_QWORD *)a1 + 792LL) & 1LL) != 0 && *((_QWORD *)a1 + 36) )
my_free(*((_QWORD *)a1 + 36) - 24LL);
else
my_free(*((_QWORD *)a1 + 36));
*((_QWORD *)a1 + 36) = v7;
}
my_free(v6);
return dynamic_record;
}
else
{
return 1;
}
}
|
_mi_cmp_dynamic_unique:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x140]
XOR EDI,EDI
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001f99f0
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x001ab559
JMP 0x001ab54d
LAB_001ab54d:
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001ab63e
LAB_001ab559:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001ab587
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x120],0x0
LAB_001ab587:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001ab110
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x001ab5bd
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX + 0x3]
CALL 0x001c47a0
MOV dword ptr [RBP + -0x3c],EAX
LAB_001ab5bd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x188],0x0
JZ 0x001ab62f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x318]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001ab608
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x120],0x0
JZ 0x001ab608
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
ADD RAX,-0x18
MOV qword ptr [RBP + -0x48],RAX
JMP 0x001ab617
LAB_001ab608:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x120]
MOV qword ptr [RBP + -0x48],RAX
LAB_001ab617:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001f9d70
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x120],RCX
LAB_001ab62f:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x001f9d70
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_001ab63e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int _mi_cmp_dynamic_unique(long *param_1,long param_2,int8 param_3,int8 param_4)
{
long lVar1;
long lVar2;
long local_50;
int local_44;
int local_c;
lVar2 = my_malloc(0,*(int8 *)(*param_1 + 0x140),0);
if (lVar2 == 0) {
local_c = 1;
}
else {
lVar1 = param_1[0x24];
if (*(int *)(*param_1 + 0x188) != 0) {
param_1[0x24] = 0;
}
local_44 = _mi_read_dynamic_record(param_1,param_4,lVar2);
if (local_44 == 0) {
local_44 = mi_unique_comp(param_2,param_3,lVar2,(int)*(char *)(param_2 + 3));
}
if (*(int *)(*param_1 + 0x188) != 0) {
if (((*(ulong *)(*param_1 + 0x318) & 1) == 0) || (param_1[0x24] == 0)) {
local_50 = param_1[0x24];
}
else {
local_50 = param_1[0x24] + -0x18;
}
my_free(local_50);
param_1[0x24] = lVar1;
}
my_free(lVar2);
local_c = local_44;
}
return local_c;
}
|
|
1 |
pcmp
|
eloqsql/strings/ctype-simple.c
|
static int pcmp(const void * f, const void * s)
{
const uni_idx *F= (const uni_idx*) f;
const uni_idx *S= (const uni_idx*) s;
int res;
if (!(res=((S->nchars)-(F->nchars))))
res=((F->uidx.from)-(S->uidx.to));
return res;
}
|
O3
|
c
|
pcmp:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
subl (%rdi), %eax
jne 0xbd5bd
movzwl 0x8(%rdi), %eax
movzwl 0xa(%rsi), %ecx
subl %ecx, %eax
popq %rbp
retq
nop
|
pcmp:
push rbp
mov rbp, rsp
mov eax, [rsi]
sub eax, [rdi]
jnz short loc_BD5BD
movzx eax, word ptr [rdi+8]
movzx ecx, word ptr [rsi+0Ah]
sub eax, ecx
loc_BD5BD:
pop rbp
retn
|
long long pcmp(long long a1, long long a2)
{
long long result; // rax
result = (unsigned int)(*(_DWORD *)a2 - *(_DWORD *)a1);
if ( *(_DWORD *)a2 == *(_DWORD *)a1 )
return *(unsigned __int16 *)(a1 + 8) - (unsigned int)*(unsigned __int16 *)(a2 + 10);
return result;
}
|
pcmp:
PUSH RBP
MOV RBP,RSP
MOV EAX,dword ptr [RSI]
SUB EAX,dword ptr [RDI]
JNZ 0x001bd5bd
MOVZX EAX,word ptr [RDI + 0x8]
MOVZX ECX,word ptr [RSI + 0xa]
SUB EAX,ECX
LAB_001bd5bd:
POP RBP
RET
|
int pcmp(int *param_1,int *param_2)
{
int iVar1;
iVar1 = *param_2 - *param_1;
if (iVar1 == 0) {
iVar1 = (uint)*(ushort *)(param_1 + 2) - (uint)*(ushort *)((long)param_2 + 10);
}
return iVar1;
}
|
|
2 |
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 0x38407
leaq 0x65342(%rip), %rsi # 0x9d739
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1fec9
movl $0x6, %edx
jmp 0x3841f
movq %rdx, %r8
addl $0x15, %ecx
movl $0x3, %edx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x38424
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_38407
lea rsi, aInvalidTypedAr; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
mov edx, 6
jmp short loc_3841F
loc_38407:
mov r8, rdx
add ecx, 15h
mov edx, 3
xor esi, esi
mov r9d, ecx
call js_typed_array_constructor
mov rbx, rax
loc_3841F:
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 0x00138407
LEA RSI,[0x19d739]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0011fec9
MOV EDX,0x6
JMP 0x0013841f
LAB_00138407:
MOV R8,RDX
ADD ECX,0x15
MOV EDX,0x3
XOR ESI,ESI
MOV R9D,ECX
CALL 0x00138424
MOV RBX,RAX
LAB_0013841f:
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;
}
|
|
3 |
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 0x315ce
leaq 0x530d9(%rip), %rsi # 0x84699
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1a137
pushq $0x6
popq %rdx
jmp 0x315e4
movq %rdx, %r8
addl $0x15, %ecx
pushq $0x3
popq %rdx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x315e9
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_315CE
lea rsi, aInvalidTypedAr_0; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
push 6
pop rdx
jmp short loc_315E4
loc_315CE:
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_315E4:
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 0x001315ce
LEA RSI,[0x184699]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0011a137
PUSH 0x6
POP RDX
JMP 0x001315e4
LAB_001315ce:
MOV R8,RDX
ADD ECX,0x15
PUSH 0x3
POP RDX
XOR ESI,ESI
MOV R9D,ECX
CALL 0x001315e9
MOV RBX,RAX
LAB_001315e4:
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;
}
|
|
4 |
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);
}
|
O3
|
c
|
JS_NewTypedArray:
pushq %rbx
cmpl $0xc, %ecx
jb 0x396bb
leaq 0x6705e(%rip), %rsi # 0xa0709
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x205f0
movl $0x6, %edx
jmp 0x396d3
movq %rdx, %r8
addl $0x15, %ecx
movl $0x3, %edx
xorl %esi, %esi
movl %ecx, %r9d
callq 0x396d8
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
|
JS_NewTypedArray:
push rbx
cmp ecx, 0Ch
jb short loc_396BB
lea rsi, aInvalidTypedAr; "invalid typed array type"
xor ebx, ebx
xor eax, eax
call JS_ThrowRangeError
mov edx, 6
jmp short loc_396D3
loc_396BB:
mov r8, rdx
add ecx, 15h
mov edx, 3
xor esi, esi
mov r9d, ecx
call js_typed_array_constructor
mov rbx, rax
loc_396D3:
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 0x001396bb
LEA RSI,[0x1a0709]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x001205f0
MOV EDX,0x6
JMP 0x001396d3
LAB_001396bb:
MOV R8,RDX
ADD ECX,0x15
MOV EDX,0x3
XOR ESI,ESI
MOV R9D,ECX
CALL 0x001396d8
MOV RBX,RAX
LAB_001396d3:
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;
}
|
|
5 |
my_parse_charset_xml
|
eloqsql/strings/ctype.c
|
my_bool
my_parse_charset_xml(MY_CHARSET_LOADER *loader, const char *buf, size_t len)
{
MY_XML_PARSER p;
struct my_cs_file_info info;
my_bool rc;
my_charset_file_init(&info);
my_xml_parser_create(&p);
my_xml_set_enter_handler(&p,cs_enter);
my_xml_set_value_handler(&p,cs_value);
my_xml_set_leave_handler(&p,cs_leave);
info.loader= loader;
my_xml_set_user_data(&p, (void *) &info);
rc= (my_xml_parse(&p,buf,len) == MY_XML_OK) ? FALSE : TRUE;
my_xml_parser_free(&p);
my_charset_file_free(&info);
if (rc != MY_XML_OK)
{
const char *errstr= my_xml_error_string(&p);
if (sizeof(loader->error) > 32 + strlen(errstr))
{
/* We cannot use my_snprintf() here. See previous comment. */
sprintf(loader->error, "at line %d pos %d: %s",
my_xml_error_lineno(&p)+1,
(int) my_xml_error_pos(&p),
my_xml_error_string(&p));
}
}
return rc;
}
|
O3
|
c
|
my_parse_charset_xml:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x928, %rsp # imm = 0x928
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq -0x260(%rbp), %r15
movl $0xc8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x261c0
xorps %xmm0, %xmm0
movups %xmm0, -0x58(%r15)
movups %xmm0, -0x4f(%r15)
leaq -0x190(%rbp), %r13
movq %r13, %rdi
callq 0x7ac44
leaq 0x10e(%rip), %rsi # 0x73b61
movq %r13, %rdi
callq 0x7acb9
leaq 0x1ec(%rip), %rsi # 0x73c4e
movq %r13, %rdi
callq 0x7acac
leaq 0x9e5(%rip), %rsi # 0x74456
movq %r13, %rdi
callq 0x7acc6
movq %rbx, -0x948(%rbp)
movq %rbx, 0xc8(%r15)
leaq -0x940(%rbp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7acd3
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x7a1a4
movl %eax, %r14d
movq %r13, %rdi
callq 0x7ac80
movq -0x58(%r15), %rdi
movq 0x7a8(%rbx), %rax
callq *0x98(%rax)
testl %r14d, %r14d
je 0x73b35
leaq -0x190(%rbp), %rdi
callq 0x7ace0
movq %rax, %rdi
callq 0x26150
addq $0x20, %rax
cmpq $0x7f, %rax
ja 0x73b35
leaq -0x190(%rbp), %rbx
movq %rbx, %rdi
callq 0x7ad1d
leal 0x1(%rax), %r15d
movq %rbx, %rdi
callq 0x7acea
movq %rax, %r12
movq %rbx, %rdi
callq 0x7ace0
movq %rax, (%rsp)
leaq 0xb5da(%rip), %rcx # 0x7f0f1
movl $0x80, %edx
movq -0x948(%rbp), %rdi
movl $0x1, %esi
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x26200
testl %r14d, %r14d
setne %al
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x73b5c
addq $0x928, %rsp # imm = 0x928
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x263a0
|
my_parse_charset_xml:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 928h
mov r14, rdx
mov r12, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea r15, [rbp+var_260]
mov edx, 0C8h
mov rdi, r15
xor esi, esi
call _memset
xorps xmm0, xmm0
movups xmmword ptr [r15-58h], xmm0
movups xmmword ptr [r15-4Fh], xmm0
lea r13, [rbp+var_190]
mov rdi, r13
call my_xml_parser_create
lea rsi, cs_enter
mov rdi, r13
call my_xml_set_enter_handler
lea rsi, cs_value
mov rdi, r13
call my_xml_set_value_handler
lea rsi, cs_leave
mov rdi, r13
call my_xml_set_leave_handler
mov [rbp+var_948], rbx
mov [r15+0C8h], rbx
lea rbx, [rbp+var_940]
mov rdi, r13
mov rsi, rbx
call my_xml_set_user_data
mov rdi, r13
mov rsi, r12
mov rdx, r14
call my_xml_parse
mov r14d, eax
mov rdi, r13
call my_xml_parser_free
mov rdi, [r15-58h]
mov rax, [rbx+7A8h]
call qword ptr [rax+98h]
test r14d, r14d
jz short loc_73B35
lea rdi, [rbp+var_190]
call my_xml_error_string
mov rdi, rax
call _strlen
add rax, 20h ; ' '
cmp rax, 7Fh
ja short loc_73B35
lea rbx, [rbp+var_190]
mov rdi, rbx
call my_xml_error_lineno
lea r15d, [rax+1]
mov rdi, rbx
call my_xml_error_pos
mov r12, rax
mov rdi, rbx
call my_xml_error_string
mov [rsp+950h+var_950], rax
lea rcx, aAtLineDPosDS; "at line %d pos %d: %s"
mov edx, 80h
mov rdi, [rbp+var_948]
mov esi, 1
mov r8d, r15d
mov r9d, r12d
xor eax, eax
call ___sprintf_chk
loc_73B35:
test r14d, r14d
setnz al
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_73B5C
add rsp, 928h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_73B5C:
call ___stack_chk_fail
|
bool my_parse_charset_xml(long long a1, long long a2, long long a3)
{
int v4; // r14d
long long v5; // rax
int v6; // r15d
int v7; // r12d
const char *v8; // rax
_QWORD v10[220]; // [rsp+10h] [rbp-940h] BYREF
_BYTE v11[200]; // [rsp+6F0h] [rbp-260h] BYREF
long long v12; // [rsp+7B8h] [rbp-198h]
_BYTE v13[352]; // [rsp+7C0h] [rbp-190h] BYREF
unsigned long long v14; // [rsp+920h] [rbp-30h]
v14 = __readfsqword(0x28u);
memset(v11, 0LL, sizeof(v11));
memset(&v10[209], 0, 25);
my_xml_parser_create(v13);
my_xml_set_enter_handler(v13, cs_enter);
my_xml_set_value_handler(v13, cs_value);
my_xml_set_leave_handler(v13, cs_leave);
v12 = a1;
my_xml_set_user_data(v13, v10);
v4 = my_xml_parse(v13, a2, a3);
my_xml_parser_free(v13);
(*(void ( **)(_QWORD))(v12 + 152))(v10[209]);
if ( v4 )
{
v5 = my_xml_error_string(v13);
if ( (unsigned long long)(strlen(v5) + 32) <= 0x7F )
{
v6 = my_xml_error_lineno(v13) + 1;
v7 = my_xml_error_pos(v13);
v8 = (const char *)my_xml_error_string(v13);
__sprintf_chk(a1, 1LL, 128LL, "at line %d pos %d: %s", v6, v7, v8);
}
}
return v4 != 0;
}
|
my_parse_charset_xml:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x928
MOV R14,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RBP + -0x260]
MOV EDX,0xc8
MOV RDI,R15
XOR ESI,ESI
CALL 0x001261c0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R15 + -0x58],XMM0
MOVUPS xmmword ptr [R15 + -0x4f],XMM0
LEA R13,[RBP + -0x190]
MOV RDI,R13
CALL 0x0017ac44
LEA RSI,[0x173b61]
MOV RDI,R13
CALL 0x0017acb9
LEA RSI,[0x173c4e]
MOV RDI,R13
CALL 0x0017acac
LEA RSI,[0x174456]
MOV RDI,R13
CALL 0x0017acc6
MOV qword ptr [RBP + -0x948],RBX
MOV qword ptr [R15 + 0xc8],RBX
LEA RBX,[RBP + -0x940]
MOV RDI,R13
MOV RSI,RBX
CALL 0x0017acd3
MOV RDI,R13
MOV RSI,R12
MOV RDX,R14
CALL 0x0017a1a4
MOV R14D,EAX
MOV RDI,R13
CALL 0x0017ac80
MOV RDI,qword ptr [R15 + -0x58]
MOV RAX,qword ptr [RBX + 0x7a8]
CALL qword ptr [RAX + 0x98]
TEST R14D,R14D
JZ 0x00173b35
LEA RDI,[RBP + -0x190]
CALL 0x0017ace0
MOV RDI,RAX
CALL 0x00126150
ADD RAX,0x20
CMP RAX,0x7f
JA 0x00173b35
LEA RBX,[RBP + -0x190]
MOV RDI,RBX
CALL 0x0017ad1d
LEA R15D,[RAX + 0x1]
MOV RDI,RBX
CALL 0x0017acea
MOV R12,RAX
MOV RDI,RBX
CALL 0x0017ace0
MOV qword ptr [RSP],RAX
LEA RCX,[0x17f0f1]
MOV EDX,0x80
MOV RDI,qword ptr [RBP + -0x948]
MOV ESI,0x1
MOV R8D,R15D
MOV R9D,R12D
XOR EAX,EAX
CALL 0x00126200
LAB_00173b35:
TEST R14D,R14D
SETNZ AL
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00173b5c
ADD RSP,0x928
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00173b5c:
CALL 0x001263a0
|
bool my_parse_charset_xml(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int iVar2;
int4 uVar3;
char *__s;
size_t sVar4;
int8 uVar5;
long in_FS_OFFSET;
int1 local_948 [1672];
int8 local_2c0;
int1 uStack_2b8;
int7 uStack_2b7;
int1 uStack_2b0;
int8 uStack_2af;
int1 local_268 [200];
long local_1a0;
int1 local_198 [352];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
memset(local_268,0,200);
local_2c0 = 0;
uStack_2b8 = 0;
uStack_2b7 = 0;
uStack_2b0 = 0;
uStack_2af = 0;
my_xml_parser_create(local_198);
my_xml_set_enter_handler(local_198,cs_enter);
my_xml_set_value_handler(local_198,cs_value);
my_xml_set_leave_handler(local_198,cs_leave);
local_1a0 = param_1;
my_xml_set_user_data(local_198,local_948);
iVar1 = my_xml_parse(local_198,param_2,param_3);
my_xml_parser_free(local_198);
(**(code **)(local_1a0 + 0x98))(local_2c0);
if (iVar1 != 0) {
__s = (char *)my_xml_error_string(local_198);
sVar4 = strlen(__s);
if (sVar4 + 0x20 < 0x80) {
iVar2 = my_xml_error_lineno(local_198);
uVar3 = my_xml_error_pos(local_198);
uVar5 = my_xml_error_string(local_198);
__sprintf_chk(param_1,1,0x80,"at line %d pos %d: %s",iVar2 + 1,uVar3,uVar5);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar1 != 0;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
6 |
dump_header_page
|
eloqsql/storage/maria/ma_loghandler.c
|
static void dump_header_page(uchar *buff)
{
LOGHANDLER_FILE_INFO desc;
char strbuff[21];
struct tm tmp_tm;
time_t header_time;
translog_interpret_file_header(&desc, buff);
header_time= desc.timestamp/1000000ULL;
localtime_r(&header_time, &tmp_tm);
printf(" This can be header page:\n"
" Timestamp: %04d.%02d.%02d %02d.%02d.%02d (%s)\n"
" Aria log version: %lu\n"
" Server version: %lu\n"
" Server id %lu\n"
" Page size %lu\n",
tmp_tm.tm_year+1900, tmp_tm.tm_mon+1, tmp_tm.tm_mday,
tmp_tm.tm_hour, tmp_tm.tm_min, tmp_tm.tm_sec,
llstr(desc.timestamp, strbuff),
desc.maria_version,
desc.mysql_version,
desc.server_id,
desc.page_size);
if (desc.page_size != TRANSLOG_PAGE_SIZE)
printf(" WARNING: page size is not equal compiled in one %lu!!!\n",
(ulong) TRANSLOG_PAGE_SIZE);
printf(" File number %lu\n"
" Max lsn: " LSN_FMT "\n",
desc.file_number,
LSN_IN_PARTS(desc.max_lsn));
}
|
O0
|
c
|
dump_header_page:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x2f760
movq -0x78(%rbp), %rax
movl $0xf4240, %ecx # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, -0xc0(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x2a130
movl -0xa4(%rbp), %eax
addl $0x76c, %eax # imm = 0x76C
movl %eax, -0xd4(%rbp)
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd0(%rbp)
movl -0xac(%rbp), %eax
movl %eax, -0xcc(%rbp)
movl -0xb0(%rbp), %eax
movl %eax, -0xc8(%rbp)
movl -0xb4(%rbp), %eax
movl %eax, -0xc4(%rbp)
movl -0xb8(%rbp), %r15d
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1537b0
movl -0xd4(%rbp), %esi
movl -0xd0(%rbp), %edx
movl -0xcc(%rbp), %ecx
movl -0xc8(%rbp), %r8d
movl -0xc4(%rbp), %r9d
movq %rax, %r14
movq -0x70(%rbp), %rbx
movq -0x68(%rbp), %r11
movq -0x60(%rbp), %r10
movq -0x58(%rbp), %rax
leaq 0x1230b1(%rip), %rdi # 0x15b319
movl %r15d, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movb $0x0, %al
callq 0x2a060
cmpq $0x2000, -0x58(%rbp) # imm = 0x2000
je 0x382a9
leaq 0x123121(%rip), %rdi # 0x15b3be
movl $0x2000, %esi # imm = 0x2000
movb $0x0, %al
callq 0x2a060
movq -0x80(%rbp), %rax
movq -0x50(%rbp), %rsi
movq %rax, %rcx
shrq $0x20, %rcx
movl %ecx, %edx
movl %eax, %ecx
leaq 0x123139(%rip), %rdi # 0x15b3fc
xorl %eax, %eax
callq 0x2a060
movq %fs:0x28, %rax
movq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jne 0x382ea
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2a270
nop
|
dump_header_page:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 0F8h
mov rax, fs:28h
mov [rbp+var_20], rax
mov [rbp+var_48], rdi
mov rsi, [rbp+var_48]
lea rdi, [rbp+var_80]
call translog_interpret_file_header
mov rax, [rbp+var_78]
mov ecx, 0F4240h
xor edx, edx
div rcx
mov [rbp+var_C0], rax
lea rdi, [rbp+var_C0]
lea rsi, [rbp+var_B8]
call _localtime_r
mov eax, [rbp+var_A4]
add eax, 76Ch
mov [rbp+var_D4], eax
mov eax, [rbp+var_A8]
add eax, 1
mov [rbp+var_D0], eax
mov eax, [rbp+var_AC]
mov [rbp+var_CC], eax
mov eax, [rbp+var_B0]
mov [rbp+var_C8], eax
mov eax, [rbp+var_B4]
mov [rbp+var_C4], eax
mov r15d, [rbp+var_B8]
mov rdi, [rbp+var_78]
lea rsi, [rbp+var_40]
call llstr
mov esi, [rbp+var_D4]
mov edx, [rbp+var_D0]
mov ecx, [rbp+var_CC]
mov r8d, [rbp+var_C8]
mov r9d, [rbp+var_C4]
mov r14, rax
mov rbx, [rbp+var_70]
mov r11, [rbp+var_68]
mov r10, [rbp+var_60]
mov rax, [rbp+var_58]
lea rdi, aThisCanBeHeade; " This can be header page:\n Timesta"...
mov [rsp+110h+var_110], r15d
mov [rsp+110h+var_108], r14
mov [rsp+110h+var_100], rbx
mov [rsp+110h+var_F8], r11
mov [rsp+110h+var_F0], r10
mov [rsp+110h+var_E8], rax
mov al, 0
call _printf
cmp [rbp+var_58], 2000h
jz short loc_382A9
lea rdi, aWarningPageSiz; " WARNING: page size is not equal c"...
mov esi, 2000h
mov al, 0
call _printf
loc_382A9:
mov rax, [rbp+var_80]
mov rsi, [rbp+var_50]
mov rcx, rax
shr rcx, 20h
mov edx, ecx
mov ecx, eax
lea rdi, aFileNumberLuMa; " File number %lu\n Max lsn: (%u,0"...
xor eax, eax
call _printf
mov rax, fs:28h
mov rcx, [rbp+var_20]
cmp rax, rcx
jnz short loc_382EA
add rsp, 0F8h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_382EA:
call ___stack_chk_fail
|
unsigned long long dump_header_page(long long a1)
{
int v1; // r15d
const char *v2; // rax
int v4; // [rsp+3Ch] [rbp-D4h]
int v5; // [rsp+40h] [rbp-D0h]
int v6; // [rsp+44h] [rbp-CCh]
int v7; // [rsp+48h] [rbp-C8h]
int v8; // [rsp+4Ch] [rbp-C4h]
unsigned long long v9; // [rsp+50h] [rbp-C0h] BYREF
_DWORD v10[14]; // [rsp+58h] [rbp-B8h] BYREF
unsigned long long v11; // [rsp+90h] [rbp-80h] BYREF
unsigned long long v12; // [rsp+98h] [rbp-78h]
long long v13; // [rsp+A0h] [rbp-70h]
long long v14; // [rsp+A8h] [rbp-68h]
long long v15; // [rsp+B0h] [rbp-60h]
long long v16; // [rsp+B8h] [rbp-58h]
long long v17; // [rsp+C0h] [rbp-50h]
long long v18; // [rsp+C8h] [rbp-48h]
_BYTE v19[32]; // [rsp+D0h] [rbp-40h] BYREF
unsigned long long v20; // [rsp+F0h] [rbp-20h]
v20 = __readfsqword(0x28u);
v18 = a1;
translog_interpret_file_header(&v11, a1);
v9 = v12 / 0xF4240;
localtime_r(&v9, v10, v12 % 0xF4240);
v4 = v10[5] + 1900;
v5 = v10[4] + 1;
v6 = v10[3];
v7 = v10[2];
v8 = v10[1];
v1 = v10[0];
v2 = (const char *)llstr(v12, v19);
printf(
" This can be header page:\n"
" Timestamp: %04d.%02d.%02d %02d.%02d.%02d (%s)\n"
" Aria log version: %lu\n"
" Server version: %lu\n"
" Server id %lu\n"
" Page size %lu\n",
v4,
v5,
v6,
v7,
v8,
v1,
v2,
v13,
v14,
v15,
v16);
if ( v16 != 0x2000 )
printf(" WARNING: page size is not equal compiled in one %lu!!!\n", 0x2000LL);
printf(" File number %lu\n Max lsn: (%u,0x%x)\n", v17, HIDWORD(v11), v11);
return __readfsqword(0x28u);
}
|
dump_header_page:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0xf8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV qword ptr [RBP + -0x48],RDI
MOV RSI,qword ptr [RBP + -0x48]
LEA RDI,[RBP + -0x80]
CALL 0x0012f760
MOV RAX,qword ptr [RBP + -0x78]
MOV ECX,0xf4240
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xc0],RAX
LEA RDI,[RBP + -0xc0]
LEA RSI,[RBP + -0xb8]
CALL 0x0012a130
MOV EAX,dword ptr [RBP + -0xa4]
ADD EAX,0x76c
MOV dword ptr [RBP + -0xd4],EAX
MOV EAX,dword ptr [RBP + -0xa8]
ADD EAX,0x1
MOV dword ptr [RBP + -0xd0],EAX
MOV EAX,dword ptr [RBP + -0xac]
MOV dword ptr [RBP + -0xcc],EAX
MOV EAX,dword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0xc8],EAX
MOV EAX,dword ptr [RBP + -0xb4]
MOV dword ptr [RBP + -0xc4],EAX
MOV R15D,dword ptr [RBP + -0xb8]
MOV RDI,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x40]
CALL 0x002537b0
MOV ESI,dword ptr [RBP + -0xd4]
MOV EDX,dword ptr [RBP + -0xd0]
MOV ECX,dword ptr [RBP + -0xcc]
MOV R8D,dword ptr [RBP + -0xc8]
MOV R9D,dword ptr [RBP + -0xc4]
MOV R14,RAX
MOV RBX,qword ptr [RBP + -0x70]
MOV R11,qword ptr [RBP + -0x68]
MOV R10,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x58]
LEA RDI,[0x25b319]
MOV dword ptr [RSP],R15D
MOV qword ptr [RSP + 0x8],R14
MOV qword ptr [RSP + 0x10],RBX
MOV qword ptr [RSP + 0x18],R11
MOV qword ptr [RSP + 0x20],R10
MOV qword ptr [RSP + 0x28],RAX
MOV AL,0x0
CALL 0x0012a060
CMP qword ptr [RBP + -0x58],0x2000
JZ 0x001382a9
LEA RDI,[0x25b3be]
MOV ESI,0x2000
MOV AL,0x0
CALL 0x0012a060
LAB_001382a9:
MOV RAX,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x50]
MOV RCX,RAX
SHR RCX,0x20
MOV EDX,ECX
MOV ECX,EAX
LEA RDI,[0x25b3fc]
XOR EAX,EAX
CALL 0x0012a060
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x20]
CMP RAX,RCX
JNZ 0x001382ea
ADD RSP,0xf8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001382ea:
CALL 0x0012a270
|
void dump_header_page(int8 param_1)
{
int8 uVar1;
long in_FS_OFFSET;
ulong local_c8;
tm local_c0;
ulong local_88;
ulong local_80;
int8 local_78;
int8 local_70;
int8 local_68;
long local_60;
int8 local_58;
int8 local_50;
int1 local_48 [32];
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
local_50 = param_1;
translog_interpret_file_header(&local_88,param_1);
local_c8 = local_80 / 1000000;
localtime_r((time_t *)&local_c8,&local_c0);
uVar1 = llstr(local_80,local_48);
printf(" This can be header page:\n Timestamp: %04d.%02d.%02d %02d.%02d.%02d (%s)\n Aria log version: %lu\n Server version: %lu\n Server id %lu\n Page size %lu\n"
,(ulong)(local_c0.tm_year + 0x76c),(ulong)(local_c0.tm_mon + 1),
(ulong)(uint)local_c0.tm_mday,(ulong)(uint)local_c0.tm_hour,(ulong)(uint)local_c0.tm_min,
local_c0.tm_sec,uVar1,local_78,local_70,local_68,local_60);
if (local_60 != 0x2000) {
printf(" WARNING: page size is not equal compiled in one %lu!!!\n",0x2000);
}
printf(" File number %lu\n Max lsn: (%u,0x%x)\n",local_58,local_88 >> 0x20,
local_88 & 0xffffffff);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
7 |
LefDefParser::lefwStartArrayFloorplan(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp
|
int
lefwStartArrayFloorplan(const char *name)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_ARRAY_START &&
lefwState != LEFW_ARRAY)
return LEFW_BAD_ORDER;
if (lefwIsArrayFloorp)
return LEFW_BAD_ORDER;
if (!name || name == 0 || *name == 0)
return LEFW_BAD_DATA;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " FLOORPLAN %s\n", name);
else
fprintf(lefwFile, " FLOORPLAN %s\n", name);
lefwLines++;
lefwHasArrayReq = 1;
lefwIsArrayFloorp = 1;
return LEFW_OK;
}
|
O0
|
cpp
|
LefDefParser::lefwStartArrayFloorplan(char const*):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x9c310(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x28f53
movl $0x1, 0x14(%rsp)
jmp 0x29034
leaq 0x9c546(%rip), %rax # 0xc54a0
cmpl $0x2, (%rax)
je 0x28f78
leaq 0x9c53a(%rip), %rax # 0xc54a0
cmpl $0x13, (%rax)
je 0x28f78
movl $0x2, 0x14(%rsp)
jmp 0x29034
leaq 0x9c549(%rip), %rax # 0xc54c8
cmpl $0x0, (%rax)
je 0x28f91
movl $0x2, 0x14(%rsp)
jmp 0x29034
cmpq $0x0, 0x8(%rsp)
je 0x28fae
cmpq $0x0, 0x8(%rsp)
je 0x28fae
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x28fb8
movl $0x3, 0x14(%rsp)
jmp 0x29034
cmpl $0x0, 0x9c57d(%rip) # 0xc553c
je 0x28fe0
leaq 0x9c288(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x6ad22(%rip), %rsi # 0x93cf9
movb $0x0, %al
callq 0x8bf50
jmp 0x28ffd
leaq 0x9c269(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x6ad03(%rip), %rsi # 0x93cf9
movb $0x0, %al
callq 0x2370
leaq 0x9c498(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x9c48c(%rip), %rax # 0xc549c
movl %ecx, (%rax)
leaq 0x9c4ab(%rip), %rax # 0xc54c4
movl $0x1, (%rax)
leaq 0x9c4a2(%rip), %rax # 0xc54c8
movl $0x1, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
|
_ZN12LefDefParser23lefwStartArrayFloorplanEPKc:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_28F53
mov [rsp+18h+var_4], 1
jmp loc_29034
loc_28F53:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 2
jz short loc_28F78
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 13h
jz short loc_28F78
mov [rsp+18h+var_4], 2
jmp loc_29034
loc_28F78:
lea rax, _ZN12LefDefParser17lefwIsArrayFloorpE; LefDefParser::lefwIsArrayFloorp
cmp dword ptr [rax], 0
jz short loc_28F91
mov [rsp+18h+var_4], 2
jmp loc_29034
loc_28F91:
cmp [rsp+18h+var_10], 0
jz short loc_28FAE
cmp [rsp+18h+var_10], 0
jz short loc_28FAE
mov rax, [rsp+18h+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_28FB8
loc_28FAE:
mov [rsp+18h+var_4], 3
jmp short loc_29034
loc_28FB8:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_28FE0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aFloorplanS; " FLOORPLAN %s\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_28FFD
loc_28FE0:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_10]
lea rsi, aFloorplanS; " FLOORPLAN %s\n"
mov al, 0
call _fprintf
loc_28FFD:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser15lefwHasArrayReqE; LefDefParser::lefwHasArrayReq
mov dword ptr [rax], 1
lea rax, _ZN12LefDefParser17lefwIsArrayFloorpE; LefDefParser::lefwIsArrayFloorp
mov dword ptr [rax], 1
mov [rsp+18h+var_4], 0
loc_29034:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
|
long long LefDefParser::lefwStartArrayFloorplan(
LefDefParser *this,
const char *a2,
long long a3,
int a4,
int a5,
int a6)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 2 || LefDefParser::lefwState == 19 )
{
if ( LefDefParser::lefwIsArrayFloorp )
{
return 2;
}
else if ( this && *(_BYTE *)this )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" FLOORPLAN %s\n", (_DWORD)this, a4, a5, a6);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " FLOORPLAN %s\n", (const char *)this);
++LefDefParser::lefwLines;
LefDefParser::lefwHasArrayReq = 1;
LefDefParser::lefwIsArrayFloorp = 1;
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
|
lefwStartArrayFloorplan:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x00128f53
MOV dword ptr [RSP + 0x14],0x1
JMP 0x00129034
LAB_00128f53:
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x2
JZ 0x00128f78
LEA RAX,[0x1c54a0]
CMP dword ptr [RAX],0x13
JZ 0x00128f78
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00129034
LAB_00128f78:
LEA RAX,[0x1c54c8]
CMP dword ptr [RAX],0x0
JZ 0x00128f91
MOV dword ptr [RSP + 0x14],0x2
JMP 0x00129034
LAB_00128f91:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00128fae
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00128fae
MOV RAX,qword ptr [RSP + 0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x00128fb8
LAB_00128fae:
MOV dword ptr [RSP + 0x14],0x3
JMP 0x00129034
LAB_00128fb8:
CMP dword ptr [0x001c553c],0x0
JZ 0x00128fe0
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x193cf9]
MOV AL,0x0
CALL 0x0018bf50
JMP 0x00128ffd
LAB_00128fe0:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x8]
LEA RSI,[0x193cf9]
MOV AL,0x0
CALL 0x00102370
LAB_00128ffd:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1c54c4]
MOV dword ptr [RAX],0x1
LEA RAX,[0x1c54c8]
MOV dword ptr [RAX],0x1
MOV dword ptr [RSP + 0x14],0x0
LAB_00129034:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwStartArrayFloorplan(char const*) */
int4 LefDefParser::lefwStartArrayFloorplan(char *param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 2) || (lefwState == 0x13)) {
if (lefwIsArrayFloorp == 0) {
if (((param_1 == (char *)0x0) || (param_1 == (char *)0x0)) || (*param_1 == '\0')) {
local_4 = 3;
}
else {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," FLOORPLAN %s\n",param_1);
}
else {
encPrint(lefwFile," FLOORPLAN %s\n",param_1);
}
lefwLines = lefwLines + 1;
lefwHasArrayReq = 1;
lefwIsArrayFloorp = 1;
local_4 = 0;
}
}
else {
local_4 = 2;
}
}
else {
local_4 = 2;
}
return local_4;
}
|
|
8 |
my_mb_wc_latin1
|
eloqsql/strings/ctype-latin1.c
|
static
int my_mb_wc_latin1(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *wc,
const uchar *str,
const uchar *end __attribute__((unused)))
{
if (str >= end)
return MY_CS_TOOSMALL;
/*
There are no unassigned characters in latin1.
Every code point in latin1 is mapped to some Unicode code point.
We can always return 1, no needs to check the value of cs_to_uni[*str].
*/
*wc= cs_to_uni[*str];
DBUG_ASSERT(wc[0] || !str[0]);
return 1;
}
|
O0
|
c
|
my_mb_wc_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 0x53ec7
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x53eed
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x103399(%rip), %rax # 0x157270
movzwl (%rax,%rcx,2), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x53ee6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_mb_wc_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_53EC7
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_53EED
loc_53EC7:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, cs_to_uni
movzx eax, word ptr [rax+rcx*2]
mov ecx, eax
mov rax, [rbp+var_18]
mov [rax], rcx
jmp short $+2
loc_53EE6:
mov [rbp+var_4], 1
loc_53EED:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_latin1(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
if ( (unsigned long long)a3 < a4 )
{
*a2 = cs_to_uni[*a3];
return 1;
}
else
{
return (unsigned int)-101;
}
}
|
my_mb_wc_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 0x00153ec7
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x00153eed
LAB_00153ec7:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x257270]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
JMP 0x00153ee6
LAB_00153ee6:
MOV dword ptr [RBP + -0x4],0x1
LAB_00153eed:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_latin1(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
int4 local_c;
if (param_3 < param_4) {
*param_2 = (ulong)*(ushort *)(cs_to_uni + (ulong)*param_3 * 2);
local_c = 1;
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
|
|
9 |
hexlo
|
eloqsql/strings/ctype-utf8.c
|
static int hexlo(int x)
{
static const char hex_lo_digit[256]=
{
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* !"#$%&'()*+,-./ */
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1, /* 0123456789:;<=>? */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* @ABCDEFGHIJKLMNO */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* PQRSTUVWXYZ[\]^_ */
-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* `abcdefghijklmno */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* pqrstuvwxyz{|}~. */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, /* ................ */
};
return hex_lo_digit[(unsigned int) x];
}
|
O0
|
c
|
hexlo:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x14c0dd(%rip), %rax # 0x1bb380
movsbl (%rax,%rcx), %eax
popq %rbp
retq
nopl (%rax)
|
hexlo:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
mov ecx, eax
lea rax, hexlo_hex_lo_digit
movsx eax, byte ptr [rax+rcx]
pop rbp
retn
|
long long hexlo(int a1)
{
return (unsigned int)hexlo_hex_lo_digit[a1];
}
|
hexlo:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
MOV ECX,EAX
LEA RAX,[0x2bb380]
MOVSX EAX,byte ptr [RAX + RCX*0x1]
POP RBP
RET
|
int hexlo(uint param_1)
{
return (int)(char)hexlo_hex_lo_digit[param_1];
}
|
|
10 |
ma_close
|
eloqsql/libmariadb/libmariadb/ma_io.c
|
int ma_close(MA_FILE *file)
{
int rc;
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
rc= fclose((FILE *)file->ptr);
free(file);
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
rc= rio_plugin->methods->mclose(file);
break;
#endif
default:
return -1;
}
return rc;
}
|
O0
|
c
|
ma_close:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3799c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x379fd
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x379b6
jmp 0x379ac
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x379d1
jmp 0x379ee
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13420
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13520
jmp 0x379f7
leaq 0x2b4b8(%rip), %rax # 0x62e90
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
jmp 0x379f7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x379fd
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ma_close:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0
jnz short loc_3799C
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_379FD
loc_3799C:
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_18], eax
sub eax, 1
jz short loc_379B6
jmp short $+2
loc_379AC:
mov eax, [rbp+var_18]
sub eax, 2
jz short loc_379D1
jmp short loc_379EE
loc_379B6:
mov rax, [rbp+var_10]
mov rdi, [rax+8]
call _fclose
mov [rbp+var_14], eax
mov rdi, [rbp+var_10]
call _free
jmp short loc_379F7
loc_379D1:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+8]
mov rdi, [rbp+var_10]
call rax
mov [rbp+var_14], eax
jmp short loc_379F7
loc_379EE:
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_379FD
loc_379F7:
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_379FD:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long ma_close(long long a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
if ( a1 )
{
if ( *(_DWORD *)a1 == 1 )
{
v2 = fclose(*(_QWORD *)(a1 + 8));
free(a1);
}
else
{
if ( *(_DWORD *)a1 != 2 )
return (unsigned int)-1;
return (unsigned int)(*(long long ( **)(long long))(*(_QWORD *)(rio_plugin + 88LL) + 8LL))(a1);
}
return v2;
}
return (unsigned int)-1;
}
|
ma_close:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x0013799c
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001379fd
LAB_0013799c:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
SUB EAX,0x1
JZ 0x001379b6
JMP 0x001379ac
LAB_001379ac:
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x2
JZ 0x001379d1
JMP 0x001379ee
LAB_001379b6:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00113420
MOV dword ptr [RBP + -0x14],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00113520
JMP 0x001379f7
LAB_001379d1:
LEA RAX,[0x162e90]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x8]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001379f7
LAB_001379ee:
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001379fd
LAB_001379f7:
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_001379fd:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int ma_close(int *param_1)
{
int local_1c;
int local_c;
if (param_1 == (int *)0x0) {
local_c = -1;
}
else {
if (*param_1 == 1) {
local_1c = fclose(*(FILE **)(param_1 + 2));
free(param_1);
}
else {
if (*param_1 != 2) {
return -1;
}
local_1c = (**(code **)(*(long *)(rio_plugin + 0x58) + 8))(param_1);
}
local_c = local_1c;
}
return local_c;
}
|
|
11 |
ma_mark_file_changed
|
eloqsql/storage/maria/ma_locking.c
|
int _ma_mark_file_changed(register MARIA_SHARE *share)
{
if (!share->base.born_transactional)
{
if (!_MA_ALREADY_MARKED_FILE_CHANGED)
return _ma_mark_file_changed_now(share);
}
else
{
/*
For transactional tables, the table is marked changed when the first page
is written. Here we just mark the state to be updated so that caller
can do 'analyze table' and find that is has changed before any pages
are written.
*/
if (! test_all_bits(share->state.changed,
(STATE_CHANGED | STATE_NOT_ANALYZED |
STATE_NOT_OPTIMIZED_KEYS)))
{
mysql_mutex_lock(&share->intern_lock);
share->state.changed|=(STATE_CHANGED | STATE_NOT_ANALYZED |
STATE_NOT_OPTIMIZED_KEYS);
mysql_mutex_unlock(&share->intern_lock);
}
}
return 0;
}
|
O3
|
c
|
ma_mark_file_changed:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x44c(%rdi)
movl 0x170(%rdi), %eax
je 0x4424b
notl %eax
testb $0x19, %al
je 0x44258
leaq 0x8f0(%rbx), %r14
cmpq $0x0, 0x930(%rbx)
jne 0x4426b
movq %r14, %rdi
callq 0x2b230
orb $0x19, 0x170(%rbx)
movq 0x930(%rbx), %rdi
testq %rdi, %rdi
jne 0x44281
movq %r14, %rdi
callq 0x2b1f0
jmp 0x44258
testb $0x1, %al
je 0x4425f
cmpb $0x0, 0x7df(%rbx)
je 0x4425f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x44293
leaq 0xbe0c9(%rip), %rsi # 0x10233b
movq %r14, %rdi
movl $0x19c, %edx # imm = 0x19C
callq 0x324c0
jmp 0x4422e
leaq 0x374980(%rip), %rax # 0x3b8c08
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x44241
|
_ma_mark_file_changed:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
cmp byte ptr [rdi+44Ch], 0
mov eax, [rdi+170h]
jz short loc_4424B
not eax
test al, 19h
jz short loc_44258
lea r14, [rbx+8F0h]
cmp qword ptr [rbx+930h], 0
jnz short loc_4426B
mov rdi, r14
call _pthread_mutex_lock
loc_4422E:
or byte ptr [rbx+170h], 19h
mov rdi, [rbx+930h]
test rdi, rdi
jnz short loc_44281
loc_44241:
mov rdi, r14
call _pthread_mutex_unlock
jmp short loc_44258
loc_4424B:
test al, 1
jz short loc_4425F
cmp byte ptr [rbx+7DFh], 0
jz short loc_4425F
loc_44258:
xor eax, eax
pop rbx
pop r14
pop rbp
retn
loc_4425F:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _ma_mark_file_changed_now
loc_4426B:
lea rsi, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r14
mov edx, 19Ch
call psi_mutex_lock
jmp short loc_4422E
loc_44281:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_44241
|
long long ma_mark_file_changed(long long a1)
{
int v1; // eax
v1 = *(_DWORD *)(a1 + 368);
if ( *(_BYTE *)(a1 + 1100) )
{
if ( (~(_BYTE)v1 & 0x19) != 0 )
{
if ( *(_QWORD *)(a1 + 2352) )
psi_mutex_lock(
a1 + 2288,
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_locking.c",
0x19Cu);
else
pthread_mutex_lock(a1 + 2288);
*(_BYTE *)(a1 + 368) |= 0x19u;
if ( *(_QWORD *)(a1 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(a1 + 2288);
}
return 0LL;
}
if ( (v1 & 1) != 0 && *(_BYTE *)(a1 + 2015) )
return 0LL;
return ma_mark_file_changed_now(a1);
}
|
_ma_mark_file_changed:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CMP byte ptr [RDI + 0x44c],0x0
MOV EAX,dword ptr [RDI + 0x170]
JZ 0x0014424b
NOT EAX
TEST AL,0x19
JZ 0x00144258
LEA R14,[RBX + 0x8f0]
CMP qword ptr [RBX + 0x930],0x0
JNZ 0x0014426b
MOV RDI,R14
CALL 0x0012b230
LAB_0014422e:
OR byte ptr [RBX + 0x170],0x19
MOV RDI,qword ptr [RBX + 0x930]
TEST RDI,RDI
JNZ 0x00144281
LAB_00144241:
MOV RDI,R14
CALL 0x0012b1f0
JMP 0x00144258
LAB_0014424b:
TEST AL,0x1
JZ 0x0014425f
CMP byte ptr [RBX + 0x7df],0x0
JZ 0x0014425f
LAB_00144258:
XOR EAX,EAX
POP RBX
POP R14
POP RBP
RET
LAB_0014425f:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00144293
LAB_0014426b:
LEA RSI,[0x20233b]
MOV RDI,R14
MOV EDX,0x19c
CALL 0x001324c0
JMP 0x0014422e
LAB_00144281:
LEA RAX,[0x4b8c08]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00144241
|
int8 _ma_mark_file_changed(long param_1)
{
pthread_mutex_t *__mutex;
int8 uVar1;
if (*(char *)(param_1 + 0x44c) == '\0') {
if (((*(uint *)(param_1 + 0x170) & 1) == 0) || (*(char *)(param_1 + 0x7df) == '\0')) {
uVar1 = _ma_mark_file_changed_now(param_1);
return uVar1;
}
}
else if ((~*(uint *)(param_1 + 0x170) & 0x19) != 0) {
__mutex = (pthread_mutex_t *)(param_1 + 0x8f0);
if (*(long *)(param_1 + 0x930) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_locking.c",
0x19c);
}
*(byte *)(param_1 + 0x170) = *(byte *)(param_1 + 0x170) | 0x19;
if (*(long *)(param_1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
}
return 0;
}
|
|
12 |
minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value evaluate(const std::shared_ptr<Context> & context) const {
try {
return do_evaluate(context);
} catch (const std::exception & e) {
std::ostringstream out;
out << e.what();
if (location.source) out << error_location_suffix(*location.source, location.pos);
throw std::runtime_error(out.str());
}
}
|
O2
|
cpp
|
minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
callq *(%rax)
movq %rbx, %rax
addq $0x1a0, %rsp # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x626cb
movq %rbx, %rdi
callq 0x23380
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x23bb0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x238c0
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x62659
pushq $0x10
popq %rdi
callq 0x23460
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x23dd0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x23e50
xorl %ebp, %ebp
movq 0x999a6(%rip), %rsi # 0xfbff0
movq 0x99907(%rip), %rdx # 0xfbf58
movq %r14, %rdi
callq 0x23f20
movq 0x18(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x5768a
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x237f0
leaq 0x8(%rsp), %rdi
callq 0x241d8
jmp 0x62617
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241d8
jmp 0x626b7
jmp 0x626b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x241d8
testb %bpl, %bpl
jne 0x626aa
jmp 0x626b7
movq %rax, %rbx
movq %r14, %rdi
callq 0x236b0
jmp 0x626b7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x231f0
jmp 0x626c6
movq %rax, %rbx
callq 0x23e70
movq %rbx, %rdi
callq 0x23fa0
movq %rax, %rdi
callq 0x27215
nop
|
_ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r14
push rbx
sub rsp, 1A0h
mov r14, rsi
mov rbx, rdi
mov rax, [rsi]
call qword ptr [rax]
mov rax, rbx
add rsp, 1A0h
pop rbx
pop r14
pop rbp
retn
mov rbx, rax
cmp edx, 1
jnz loc_626CB
mov rdi, rbx; void *
call ___cxa_begin_catch
mov rbx, rax
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+10h]
lea rdi, [rsp+arg_20]
mov rsi, rax
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov rsi, [r14+8]
test rsi, rsi
jnz short loc_62659
loc_62617:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, [rsp+arg_28]
lea rdi, [rsp+arg_0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov bpl, 1
lea rsi, [rsp+arg_0]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_62659:
mov rdx, [r14+18h]
lea rdi, [rsp+arg_0]
call _ZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEm; minja::error_location_suffix(std::string const&,ulong)
lea rdi, [rsp+arg_20]
lea rsi, [rsp+arg_0]
call __ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE; std::operator<<<char>(std::ostream &,std::string const&)
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_62617
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_626B7
jmp short loc_626B4
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_626AA
jmp short loc_626B7
mov rbx, rax
loc_626AA:
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_626B7
loc_626B4:
mov rbx, rax
loc_626B7:
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
jmp short loc_626C6
mov rbx, rax
loc_626C6:
call ___cxa_end_catch
loc_626CB:
mov rdi, rbx
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
|
long long minja::Expression::evaluate(long long a1, void (***a2)(void))
{
(**a2)();
return a1;
}
|
evaluate:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1a0
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
LAB_001625c6:
CALL qword ptr [RAX]
LAB_001625c8:
MOV RAX,RBX
ADD RSP,0x1a0
POP RBX
POP R14
POP RBP
RET
|
/* minja::Expression::evaluate(std::shared_ptr<minja::Context> const&) const */
Expression * __thiscall minja::Expression::evaluate(Expression *this,shared_ptr *param_1)
{
/* try { // try from 001625c6 to 001625c7 has its CatchHandler @ 001625d7 */
(*(code *)**(int8 **)param_1)();
return this;
}
|
|
13 |
string_process_escapes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
llama.cpp/common/common.cpp
|
void string_process_escapes(std::string & input) {
std::size_t input_len = input.length();
std::size_t output_idx = 0;
for (std::size_t input_idx = 0; input_idx < input_len; ++input_idx) {
if (input[input_idx] == '\\' && input_idx + 1 < input_len) {
switch (input[++input_idx]) {
case 'n': input[output_idx++] = '\n'; break;
case 'r': input[output_idx++] = '\r'; break;
case 't': input[output_idx++] = '\t'; break;
case '\'': input[output_idx++] = '\''; break;
case '\"': input[output_idx++] = '\"'; break;
case '\\': input[output_idx++] = '\\'; break;
case 'x':
// Handle \x12, etc
if (input_idx + 2 < input_len) {
const char x[3] = { input[input_idx + 1], input[input_idx + 2], 0 };
char *err_p = nullptr;
const long val = std::strtol(x, &err_p, 16);
if (err_p == x + 2) {
input_idx += 2;
input[output_idx++] = char(val);
break;
}
}
// fall through
default: input[output_idx++] = '\\';
input[output_idx++] = input[input_idx]; break;
}
} else {
input[output_idx++] = input[input_idx];
}
}
input.resize(output_idx);
}
|
O3
|
cpp
|
string_process_escapes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0xf6d2b
leaq 0xf(%rsp), %r12
xorl %r14d, %r14d
leaq 0xd(%rsp), %rdi
leaq 0x10(%rsp), %rsi
xorl %ecx, %ecx
movq (%rbx), %rax
movb (%rax,%rcx), %dl
cmpb $0x5c, %dl
jne 0xf6c4a
leaq 0x1(%rcx), %rbp
cmpq %r13, %rbp
jae 0xf6c4a
movzbl (%rax,%rbp), %edx
cmpl $0x6d, %edx
jle 0xf6c64
cmpl $0x73, %edx
jg 0xf6c85
cmpl $0x6e, %edx
je 0xf6cf4
cmpl $0x72, %edx
jne 0xf6cd4
movb $0xd, (%rax,%r14)
jmp 0xf6d07
movb %dl, (%rax,%r14)
incq %r14
movq %rcx, %rbp
incq %rbp
movq %rbp, %rcx
cmpq %r13, %rbp
jb 0xf6c0c
jmp 0xf6d2e
cmpl $0x22, %edx
je 0xf6ced
cmpl $0x27, %edx
je 0xf6d02
cmpl $0x5c, %edx
jne 0xf6cd4
movb $0x5c, (%rax,%r14)
jmp 0xf6d07
cmpl $0x74, %edx
je 0xf6cfb
cmpl $0x78, %edx
jne 0xf6cd4
leaq 0x3(%rcx), %r15
cmpq %r13, %r15
jae 0xf6cd4
movb 0x2(%rax,%rcx), %dl
movb %dl, 0xd(%rsp)
movb 0x3(%rax,%rcx), %al
movb %al, 0xe(%rsp)
movb $0x0, 0xf(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x10, %edx
callq 0x20e30
cmpq %r12, 0x10(%rsp)
je 0xf6d0f
movq (%rbx), %rax
leaq 0xd(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movb $0x5c, (%rax,%r14)
movq (%rbx), %rax
movb (%rax,%rbp), %cl
movb %cl, 0x1(%rax,%r14)
addq $0x2, %r14
jmp 0xf6c54
movb $0x22, (%rax,%r14)
jmp 0xf6d07
movb $0xa, (%rax,%r14)
jmp 0xf6d07
movb $0x9, (%rax,%r14)
jmp 0xf6d07
movb $0x27, (%rax,%r14)
incq %r14
jmp 0xf6c54
movq (%rbx), %rcx
movb %al, (%rcx,%r14)
incq %r14
movq %r15, %rbp
leaq 0xd(%rsp), %rdi
leaq 0x10(%rsp), %rsi
jmp 0xf6c54
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x20b30
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_Z22string_process_escapesRNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
mov r13, [rdi+8]
test r13, r13
jz loc_F6D2B
lea r12, [rsp+48h+var_39]
xor r14d, r14d
lea rdi, [rsp+48h+var_3B]
lea rsi, [rsp+48h+var_38]
xor ecx, ecx
loc_F6C0C:
mov rax, [rbx]
mov dl, [rax+rcx]
cmp dl, 5Ch ; '\'
jnz short loc_F6C4A
lea rbp, [rcx+1]
cmp rbp, r13
jnb short loc_F6C4A
movzx edx, byte ptr [rax+rbp]
cmp edx, 6Dh ; 'm'
jle short loc_F6C64
cmp edx, 73h ; 's'
jg short loc_F6C85
cmp edx, 6Eh ; 'n'
jz loc_F6CF4
cmp edx, 72h ; 'r'
jnz loc_F6CD4
mov byte ptr [rax+r14], 0Dh
jmp loc_F6D07
loc_F6C4A:
mov [rax+r14], dl
inc r14
mov rbp, rcx
loc_F6C54:
inc rbp
mov rcx, rbp
cmp rbp, r13
jb short loc_F6C0C
jmp loc_F6D2E
loc_F6C64:
cmp edx, 22h ; '"'
jz loc_F6CED
cmp edx, 27h ; '''
jz loc_F6D02
cmp edx, 5Ch ; '\'
jnz short loc_F6CD4
mov byte ptr [rax+r14], 5Ch ; '\'
jmp loc_F6D07
loc_F6C85:
cmp edx, 74h ; 't'
jz short loc_F6CFB
cmp edx, 78h ; 'x'
jnz short loc_F6CD4
lea r15, [rcx+3]
cmp r15, r13
jnb short loc_F6CD4
mov dl, [rax+rcx+2]
mov [rsp+48h+var_3B], dl
mov al, [rax+rcx+3]
mov [rsp+48h+var_3A], al
mov [rsp+48h+var_39], 0
mov [rsp+48h+var_38], 0
mov edx, 10h
call _strtol
cmp [rsp+48h+var_38], r12
jz short loc_F6D0F
mov rax, [rbx]
lea rdi, [rsp+48h+var_3B]
lea rsi, [rsp+48h+var_38]
loc_F6CD4:
mov byte ptr [rax+r14], 5Ch ; '\'
mov rax, [rbx]
mov cl, [rax+rbp]
mov [rax+r14+1], cl
add r14, 2
jmp loc_F6C54
loc_F6CED:
mov byte ptr [rax+r14], 22h ; '"'
jmp short loc_F6D07
loc_F6CF4:
mov byte ptr [rax+r14], 0Ah
jmp short loc_F6D07
loc_F6CFB:
mov byte ptr [rax+r14], 9
jmp short loc_F6D07
loc_F6D02:
mov byte ptr [rax+r14], 27h ; '''
loc_F6D07:
inc r14
jmp loc_F6C54
loc_F6D0F:
mov rcx, [rbx]
mov [rcx+r14], al
inc r14
mov rbp, r15
lea rdi, [rsp+48h+var_3B]
lea rsi, [rsp+48h+var_38]
jmp loc_F6C54
loc_F6D2B:
xor r14d, r14d
loc_F6D2E:
mov rdi, rbx
mov rsi, r14
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long string_process_escapes(long long *a1)
{
unsigned long long v1; // r13
long long v2; // r14
long long v3; // rcx
long long v4; // rax
char v5; // dl
long long v6; // rbp
unsigned int v7; // edx
long long v8; // r15
char v9; // al
_BYTE v11[2]; // [rsp+Dh] [rbp-3Bh] BYREF
char v12; // [rsp+Fh] [rbp-39h] BYREF
char *v13; // [rsp+10h] [rbp-38h] BYREF
v1 = a1[1];
if ( v1 )
{
v2 = 0LL;
v3 = 0LL;
while ( 1 )
{
v4 = *a1;
v5 = *(_BYTE *)(*a1 + v3);
if ( v5 == 92 && (v6 = v3 + 1, v3 + 1 < v1) )
{
v7 = *(unsigned __int8 *)(v4 + v6);
if ( v7 <= 0x6D )
{
switch ( v7 )
{
case '"':
*(_BYTE *)(v4 + v2) = 34;
goto LABEL_27;
case '\'':
*(_BYTE *)(v4 + v2) = 39;
goto LABEL_27;
case '\\':
*(_BYTE *)(v4 + v2) = 92;
goto LABEL_27;
}
}
else if ( *(unsigned __int8 *)(v4 + v6) > 0x73u )
{
if ( v7 == 116 )
{
*(_BYTE *)(v4 + v2) = 9;
goto LABEL_27;
}
if ( v7 == 120 )
{
v8 = v3 + 3;
if ( v3 + 3 < v1 )
{
v11[0] = *(_BYTE *)(v4 + v3 + 2);
v11[1] = *(_BYTE *)(v4 + v3 + 3);
v12 = 0;
v13 = 0LL;
v9 = strtol(v11, &v13, 16LL);
if ( v13 == &v12 )
{
*(_BYTE *)(*a1 + v2++) = v9;
v6 = v8;
goto LABEL_11;
}
v4 = *a1;
}
}
}
else
{
if ( v7 == 110 )
{
*(_BYTE *)(v4 + v2) = 10;
goto LABEL_27;
}
if ( v7 == 114 )
{
*(_BYTE *)(v4 + v2) = 13;
LABEL_27:
++v2;
goto LABEL_11;
}
}
*(_BYTE *)(v4 + v2) = 92;
*(_BYTE *)(*a1 + v2 + 1) = *(_BYTE *)(*a1 + v6);
v2 += 2LL;
}
else
{
*(_BYTE *)(v4 + v2++) = v5;
v6 = v3;
}
LABEL_11:
v3 = v6 + 1;
if ( v6 + 1 >= v1 )
return std::string::resize(a1, v2, 0LL);
}
}
v2 = 0LL;
return std::string::resize(a1, v2, 0LL);
}
|
string_process_escapes:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV R13,qword ptr [RDI + 0x8]
TEST R13,R13
JZ 0x001f6d2b
LEA R12,[RSP + 0xf]
XOR R14D,R14D
LEA RDI,[RSP + 0xd]
LEA RSI,[RSP + 0x10]
XOR ECX,ECX
LAB_001f6c0c:
MOV RAX,qword ptr [RBX]
MOV DL,byte ptr [RAX + RCX*0x1]
CMP DL,0x5c
JNZ 0x001f6c4a
LEA RBP,[RCX + 0x1]
CMP RBP,R13
JNC 0x001f6c4a
MOVZX EDX,byte ptr [RAX + RBP*0x1]
CMP EDX,0x6d
JLE 0x001f6c64
CMP EDX,0x73
JG 0x001f6c85
CMP EDX,0x6e
JZ 0x001f6cf4
CMP EDX,0x72
JNZ 0x001f6cd4
MOV byte ptr [RAX + R14*0x1],0xd
JMP 0x001f6d07
LAB_001f6c4a:
MOV byte ptr [RAX + R14*0x1],DL
INC R14
MOV RBP,RCX
LAB_001f6c54:
INC RBP
MOV RCX,RBP
CMP RBP,R13
JC 0x001f6c0c
JMP 0x001f6d2e
LAB_001f6c64:
CMP EDX,0x22
JZ 0x001f6ced
CMP EDX,0x27
JZ 0x001f6d02
CMP EDX,0x5c
JNZ 0x001f6cd4
MOV byte ptr [RAX + R14*0x1],0x5c
JMP 0x001f6d07
LAB_001f6c85:
CMP EDX,0x74
JZ 0x001f6cfb
CMP EDX,0x78
JNZ 0x001f6cd4
LEA R15,[RCX + 0x3]
CMP R15,R13
JNC 0x001f6cd4
MOV DL,byte ptr [RAX + RCX*0x1 + 0x2]
MOV byte ptr [RSP + 0xd],DL
MOV AL,byte ptr [RAX + RCX*0x1 + 0x3]
MOV byte ptr [RSP + 0xe],AL
MOV byte ptr [RSP + 0xf],0x0
MOV qword ptr [RSP + 0x10],0x0
MOV EDX,0x10
CALL 0x00120e30
CMP qword ptr [RSP + 0x10],R12
JZ 0x001f6d0f
MOV RAX,qword ptr [RBX]
LEA RDI,[RSP + 0xd]
LEA RSI,[RSP + 0x10]
LAB_001f6cd4:
MOV byte ptr [RAX + R14*0x1],0x5c
MOV RAX,qword ptr [RBX]
MOV CL,byte ptr [RAX + RBP*0x1]
MOV byte ptr [RAX + R14*0x1 + 0x1],CL
ADD R14,0x2
JMP 0x001f6c54
LAB_001f6ced:
MOV byte ptr [RAX + R14*0x1],0x22
JMP 0x001f6d07
LAB_001f6cf4:
MOV byte ptr [RAX + R14*0x1],0xa
JMP 0x001f6d07
LAB_001f6cfb:
MOV byte ptr [RAX + R14*0x1],0x9
JMP 0x001f6d07
LAB_001f6d02:
MOV byte ptr [RAX + R14*0x1],0x27
LAB_001f6d07:
INC R14
JMP 0x001f6c54
LAB_001f6d0f:
MOV RCX,qword ptr [RBX]
MOV byte ptr [RCX + R14*0x1],AL
INC R14
MOV RBP,R15
LEA RDI,[RSP + 0xd]
LEA RSI,[RSP + 0x10]
JMP 0x001f6c54
LAB_001f6d2b:
XOR R14D,R14D
LAB_001f6d2e:
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00120b30
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_process_escapes(std::__cxx11::string&) */
void string_process_escapes(string *param_1)
{
ulong uVar1;
byte bVar2;
ulong uVar3;
long lVar4;
ulong uVar5;
long lVar6;
char local_3b;
int1 local_3a;
char local_39;
char *local_38;
uVar3 = *(ulong *)(param_1 + 8);
if (uVar3 == 0) {
lVar6 = 0;
}
else {
lVar6 = 0;
uVar5 = 0;
do {
lVar4 = *(long *)param_1;
if ((*(char *)(lVar4 + uVar5) == '\\') && (uVar1 = uVar5 + 1, uVar1 < uVar3)) {
bVar2 = *(byte *)(lVar4 + uVar1);
if (bVar2 < 0x6e) {
if (bVar2 == 0x22) {
*(int1 *)(lVar4 + lVar6) = 0x22;
}
else if (bVar2 == 0x27) {
*(int1 *)(lVar4 + lVar6) = 0x27;
}
else {
if (bVar2 != 0x5c) goto LAB_001f6cd4;
*(int1 *)(lVar4 + lVar6) = 0x5c;
}
}
else if (bVar2 < 0x74) {
if (bVar2 == 0x6e) {
*(int1 *)(lVar4 + lVar6) = 10;
}
else {
if (bVar2 != 0x72) goto LAB_001f6cd4;
*(int1 *)(lVar4 + lVar6) = 0xd;
}
}
else {
if (bVar2 != 0x74) {
if ((bVar2 == 0x78) && (uVar5 + 3 < uVar3)) {
local_3b = *(char *)(lVar4 + 2 + uVar5);
local_3a = *(int1 *)(lVar4 + 3 + uVar5);
local_39 = '\0';
local_38 = (char *)0x0;
lVar4 = strtol(&local_3b,&local_38,0x10);
if (local_38 == &local_39) {
*(char *)(*(long *)param_1 + lVar6) = (char)lVar4;
lVar6 = lVar6 + 1;
uVar5 = uVar5 + 3;
goto LAB_001f6c54;
}
lVar4 = *(long *)param_1;
}
LAB_001f6cd4:
*(int1 *)(lVar4 + lVar6) = 0x5c;
*(int1 *)(*(long *)param_1 + 1 + lVar6) =
*(int1 *)(*(long *)param_1 + uVar1);
lVar6 = lVar6 + 2;
uVar5 = uVar1;
goto LAB_001f6c54;
}
*(int1 *)(lVar4 + lVar6) = 9;
}
lVar6 = lVar6 + 1;
uVar5 = uVar1;
}
else {
*(char *)(lVar4 + lVar6) = *(char *)(lVar4 + uVar5);
lVar6 = lVar6 + 1;
}
LAB_001f6c54:
uVar5 = uVar5 + 1;
} while (uVar5 < uVar3);
}
std::__cxx11::string::resize((ulong)param_1,(char)lVar6);
return;
}
|
|
14 |
ftxui::StackedContainer::Render()
|
Andrewchistyakov[P]flashcards_lyc/build_O0/_deps/ftxui-src/src/ftxui/component/container.cpp
|
Element Render() final {
Elements elements;
for (auto& child : children_) {
elements.push_back(child->Render());
}
// Reverse the order of the elements.
std::reverse(elements.begin(), elements.end());
return dbox(std::move(elements));
}
|
O0
|
cpp
|
ftxui::StackedContainer::Render():
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x24340
movq -0x98(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x514d0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x51500
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x51530
testb $0x1, %al
jne 0x56ce4
jmp 0x56d5a
leaq -0x38(%rbp), %rdi
callq 0x51570
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x23bd0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0x56d0c
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24410
jmp 0x56d1b
leaq -0x58(%rbp), %rdi
callq 0x23cb0
leaq -0x38(%rbp), %rdi
callq 0x51590
jmp 0x56cd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x56df6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x23cb0
jmp 0x56df6
leaq -0x28(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x24830
movq -0xb0(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x24670
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x57100
jmp 0x56d8d
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x3e4b0
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x7f910
jmp 0x56db9
leaq -0x90(%rbp), %rdi
callq 0x23cd0
leaq -0x28(%rbp), %rdi
callq 0x23cd0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x23cd0
leaq -0x28(%rbp), %rdi
callq 0x23cd0
movq -0x60(%rbp), %rdi
callq 0xda90
nopl (%rax,%rax)
|
_ZN5ftxui16StackedContainer6RenderEv:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_A8], rdi
mov rax, rdi
mov [rbp+var_A0], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EEC2Ev; std::vector<std::shared_ptr<ftxui::Node>>::vector(void)
mov rax, [rbp+var_98]
add rax, 8
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui13ComponentBaseEESaIS3_EE5beginEv; std::vector<std::shared_ptr<ftxui::ComponentBase>>::begin(void)
mov [rbp+var_38], rax
mov rdi, [rbp+var_30]
call _ZNSt6vectorISt10shared_ptrIN5ftxui13ComponentBaseEESaIS3_EE3endEv; std::vector<std::shared_ptr<ftxui::ComponentBase>>::end(void)
mov [rbp+var_40], rax
loc_56CD1:
lea rdi, [rbp+var_38]
lea rsi, [rbp+var_40]
call _ZN9__gnu_cxxneIPSt10shared_ptrIN5ftxui13ComponentBaseEESt6vectorIS4_SaIS4_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator!=<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>(__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>> const&,__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>> const&)
test al, 1
jnz short loc_56CE4
jmp short loc_56D5A
loc_56CE4:
lea rdi, [rbp+var_38]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt10shared_ptrIN5ftxui13ComponentBaseEESt6vectorIS4_SaIS4_EEEdeEv; __gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>::operator*(void)
mov [rbp+var_48], rax
mov rdi, [rbp+var_48]
call _ZNKSt19__shared_ptr_accessIN5ftxui13ComponentBaseELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, rax
mov rax, [rsi]
mov rax, [rax+10h]
lea rdi, [rbp+var_58]
call rax
jmp short $+2
loc_56D0C:
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_58]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE9push_backEOS3_; std::vector<std::shared_ptr<ftxui::Node>>::push_back(std::shared_ptr<ftxui::Node>&&)
jmp short $+2
loc_56D1B:
lea rdi, [rbp+var_58]
call _ZNSt10shared_ptrIN5ftxui4NodeEED2Ev; std::shared_ptr<ftxui::Node>::~shared_ptr()
lea rdi, [rbp+var_38]
call _ZN9__gnu_cxx17__normal_iteratorIPSt10shared_ptrIN5ftxui13ComponentBaseEESt6vectorIS4_SaIS4_EEEppEv; __gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>::operator++(void)
jmp short loc_56CD1
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
jmp loc_56DF6
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_58]
call _ZNSt10shared_ptrIN5ftxui4NodeEED2Ev; std::shared_ptr<ftxui::Node>::~shared_ptr()
jmp loc_56DF6
loc_56D5A:
lea rdi, [rbp+var_28]
mov [rbp+var_B0], rdi
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE5beginEv; std::vector<std::shared_ptr<ftxui::Node>>::begin(void)
mov rdi, [rbp+var_B0]
mov [rbp+var_70], rax
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE3endEv; std::vector<std::shared_ptr<ftxui::Node>>::end(void)
mov [rbp+var_78], rax
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_78]
call _ZSt7reverseIN9__gnu_cxx17__normal_iteratorIPSt10shared_ptrIN5ftxui4NodeEESt6vectorIS5_SaIS5_EEEEEvT_SB_; std::reverse<__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::Node> *,std::vector<std::shared_ptr<ftxui::Node>>>>(__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::Node> *,std::vector<std::shared_ptr<ftxui::Node>>>,__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::Node> *,std::vector<std::shared_ptr<ftxui::Node>>>)
jmp short $+2
loc_56D8D:
lea rdi, [rbp+var_90]
mov [rbp+var_B8], rdi
lea rsi, [rbp+var_28]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EEC2EOS5_; std::vector<std::shared_ptr<ftxui::Node>>::vector(std::vector<std::shared_ptr<ftxui::Node>>&&)
mov rdi, [rbp+var_A8]
mov rsi, [rbp+var_B8]
call _ZN5ftxui4dboxESt6vectorISt10shared_ptrINS_4NodeEESaIS3_EE; ftxui::dbox(std::vector<std::shared_ptr<ftxui::Node>>)
jmp short $+2
loc_56DB9:
lea rdi, [rbp+var_90]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rax, [rbp+var_A0]
add rsp, 0C0h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_60], rcx
mov [rbp+var_64], eax
lea rdi, [rbp+var_90]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
loc_56DF6:
lea rdi, [rbp+var_28]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, [rbp+var_60]
call __Unwind_Resume
|
ftxui::StackedContainer * ftxui::StackedContainer::Render(ftxui::StackedContainer *this, long long a2)
{
long long v2; // rsi
long long v4[3]; // [rsp+30h] [rbp-90h] BYREF
long long v5; // [rsp+48h] [rbp-78h]
long long v6; // [rsp+50h] [rbp-70h]
_BYTE v7[16]; // [rsp+68h] [rbp-58h] BYREF
long long v8; // [rsp+78h] [rbp-48h]
long long v9; // [rsp+80h] [rbp-40h] BYREF
_QWORD v10[2]; // [rsp+88h] [rbp-38h] BYREF
long long v11[5]; // [rsp+98h] [rbp-28h] BYREF
v11[4] = (long long)this;
v11[3] = a2;
std::vector<std::shared_ptr<ftxui::Node>>::vector((long long)v11);
v10[1] = a2 + 8;
v10[0] = std::vector<std::shared_ptr<ftxui::ComponentBase>>::begin(a2 + 8);
v9 = std::vector<std::shared_ptr<ftxui::ComponentBase>>::end(a2 + 8);
while ( __gnu_cxx::operator!=<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>(
(long long)v10,
(long long)&v9) )
{
v8 = __gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>::operator*((long long)v10);
v2 = std::__shared_ptr_access<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v8);
(*(void ( **)(_BYTE *))(*(_QWORD *)v2 + 16LL))(v7);
std::vector<std::shared_ptr<ftxui::Node>>::push_back((long long)v11, (long long)v7);
std::shared_ptr<ftxui::Node>::~shared_ptr((long long)v7);
__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::ComponentBase> *,std::vector<std::shared_ptr<ftxui::ComponentBase>>>::operator++(v10);
}
v6 = std::vector<std::shared_ptr<ftxui::Node>>::begin((long long)v11);
v5 = std::vector<std::shared_ptr<ftxui::Node>>::end((long long)v11);
std::reverse<__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::Node> *,std::vector<std::shared_ptr<ftxui::Node>>>>(
v6,
v5);
std::vector<std::shared_ptr<ftxui::Node>>::vector((long long)v4, (long long)v11);
ftxui::dbox(this, v4);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(v4);
std::vector<std::shared_ptr<ftxui::Node>>::~vector(v11);
return this;
}
|
Render:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0xa8],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0xa0],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
LEA RDI,[RBP + -0x28]
CALL 0x00124340
MOV RAX,qword ptr [RBP + -0x98]
ADD RAX,0x8
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001514d0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00151500
MOV qword ptr [RBP + -0x40],RAX
LAB_00156cd1:
LEA RDI,[RBP + -0x38]
LEA RSI,[RBP + -0x40]
CALL 0x00151530
TEST AL,0x1
JNZ 0x00156ce4
JMP 0x00156d5a
LAB_00156ce4:
LEA RDI,[RBP + -0x38]
CALL 0x00151570
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x00123bd0
MOV RSI,RAX
MOV RAX,qword ptr [RSI]
MOV RAX,qword ptr [RAX + 0x10]
LAB_00156d04:
LEA RDI,[RBP + -0x58]
CALL RAX
JMP 0x00156d0c
LAB_00156d0c:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x58]
CALL 0x00124410
JMP 0x00156d1b
LAB_00156d1b:
LEA RDI,[RBP + -0x58]
CALL 0x00123cb0
LEA RDI,[RBP + -0x38]
CALL 0x00151590
JMP 0x00156cd1
LAB_00156d5a:
LEA RDI,[RBP + -0x28]
MOV qword ptr [RBP + -0xb0],RDI
CALL 0x00124830
MOV RDI,qword ptr [RBP + -0xb0]
MOV qword ptr [RBP + -0x70],RAX
CALL 0x00124670
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x78]
LAB_00156d86:
CALL 0x00157100
JMP 0x00156d8d
LAB_00156d8d:
LEA RDI,[RBP + -0x90]
MOV qword ptr [RBP + -0xb8],RDI
LEA RSI,[RBP + -0x28]
CALL 0x0013e4b0
MOV RDI,qword ptr [RBP + -0xa8]
MOV RSI,qword ptr [RBP + -0xb8]
LAB_00156db2:
CALL 0x0017f910
LAB_00156db7:
JMP 0x00156db9
LAB_00156db9:
LEA RDI,[RBP + -0x90]
CALL 0x00123cd0
LEA RDI,[RBP + -0x28]
CALL 0x00123cd0
MOV RAX,qword ptr [RBP + -0xa0]
ADD RSP,0xc0
POP RBP
RET
|
/* ftxui::StackedContainer::Render() */
ftxui * ftxui::StackedContainer::Render(void)
{
bool bVar1;
long *plVar2;
long in_RSI;
ftxui *in_RDI;
vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> local_98 [24];
int8 local_80;
int8 local_78;
shared_ptr<ftxui::Node> local_60 [16];
__shared_ptr_access<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2,false,false> *local_50;
int8 local_48;
int8 local_40;
vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
*local_38;
vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> local_30 [40];
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::vector
(local_30);
local_38 = (vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
*)(in_RSI + 8);
local_40 = std::
vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
::begin(local_38);
local_48 = std::
vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
::end(local_38);
while( true ) {
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_40,(__normal_iterator *)&local_48);
if (!bVar1) break;
local_50 = (__shared_ptr_access<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2,false,false> *)
__gnu_cxx::
__normal_iterator<std::shared_ptr<ftxui::ComponentBase>*,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>>
::operator*((__normal_iterator<std::shared_ptr<ftxui::ComponentBase>*,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>>
*)&local_40);
plVar2 = (long *)std::
__shared_ptr_access<ftxui::ComponentBase,(__gnu_cxx::_Lock_policy)2,false,false>
::operator->(local_50);
/* try { // try from 00156d04 to 00156d09 has its CatchHandler @ 00156d2f */
(**(code **)(*plVar2 + 0x10))(local_60);
/* try { // try from 00156d0c to 00156d18 has its CatchHandler @ 00156d40 */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::
push_back(local_30,local_60);
std::shared_ptr<ftxui::Node>::~shared_ptr(local_60);
__gnu_cxx::
__normal_iterator<std::shared_ptr<ftxui::ComponentBase>*,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>>
::operator++((__normal_iterator<std::shared_ptr<ftxui::ComponentBase>*,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>>
*)&local_40);
}
local_78 = std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>
::begin(local_30);
local_80 = std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>
::end(local_30);
/* try { // try from 00156d86 to 00156d8a has its CatchHandler @ 00156d2f */
std::
reverse<__gnu_cxx::__normal_iterator<std::shared_ptr<ftxui::Node>*,std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>>>
(local_78,local_80);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::vector
(local_98,(vector *)local_30);
/* try { // try from 00156db2 to 00156db6 has its CatchHandler @ 00156dde */
dbox(in_RDI,local_98);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
(local_98);
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::~vector
(local_30);
return in_RDI;
}
|
|
15 |
translog_scanner_set_last_page
|
eloqsql/storage/maria/ma_loghandler.c
|
static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)
{
my_bool page_ok;
if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))
{
/* It is last file => we can easy find last page address by horizon */
uint pagegrest= LSN_OFFSET(scanner->horizon) % TRANSLOG_PAGE_SIZE;
scanner->last_file_page= (scanner->horizon -
(pagegrest ? pagegrest : TRANSLOG_PAGE_SIZE));
return (0);
}
scanner->last_file_page= scanner->page_addr;
return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0));
}
|
O0
|
c
|
translog_scanner_set_last_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x2008(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
jne 0x32ae0
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x2008(%rcx), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2008(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x32ab9
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x32ac3
movl $0x2000, %eax # imm = 0x2000
movl %eax, -0x24(%rbp)
jmp 0x32ac3
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %eax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x32b0f
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x10(%rbp), %rdi
addq $0x2010, %rdi # imm = 0x2010
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
callq 0x2fad0
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
translog_scanner_set_last_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+2000h]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+2008h]
sar rcx, 20h
cmp eax, ecx
jnz short loc_32AE0
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx+2008h]
and rax, 1FFFh
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+2008h]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_32AB9
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
jmp short loc_32AC3
loc_32AB9:
mov eax, 2000h
mov [rbp+var_24], eax
jmp short $+2
loc_32AC3:
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov eax, eax
sub rcx, rax
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov [rbp+var_1], 0
jmp short loc_32B0F
loc_32AE0:
mov rax, [rbp+var_10]
mov rcx, [rax+2000h]
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov rdi, [rbp+var_10]
add rdi, 2010h
lea rsi, [rbp+var_11]
xor edx, edx
call translog_get_last_page_addr
mov [rbp+var_1], al
loc_32B0F:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
char translog_scanner_set_last_page(_QWORD *a1)
{
unsigned int v2; // [rsp+Ch] [rbp-24h]
bool v3; // [rsp+1Fh] [rbp-11h] BYREF
_QWORD *v4; // [rsp+20h] [rbp-10h]
v4 = a1;
if ( HIDWORD(a1[1024]) == HIDWORD(a1[1025]) )
{
if ( (v4[1025] & 0x1FFF) != 0 )
v2 = v4[1025] & 0x1FFF;
else
v2 = 0x2000;
v4[1026] = v4[1025] - v2;
return 0;
}
else
{
v4[1026] = v4[1024];
return translog_get_last_page_addr(v4 + 1026, &v3, 0);
}
}
|
translog_scanner_set_last_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2000]
SAR RAX,0x20
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x2008]
SAR RCX,0x20
CMP EAX,ECX
JNZ 0x00132ae0
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x2008]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2008]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00132ab9
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00132ac3
LAB_00132ab9:
MOV EAX,0x2000
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00132ac3
LAB_00132ac3:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EAX,EAX
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00132b0f
LAB_00132ae0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x2000]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2010
LEA RSI,[RBP + -0x11]
XOR EDX,EDX
CALL 0x0012fad0
MOV byte ptr [RBP + -0x1],AL
LAB_00132b0f:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_scanner_set_last_page(long param_1)
{
uint local_2c;
int1 local_19;
long local_18;
int1 local_9;
if ((int)((ulong)*(int8 *)(param_1 + 0x2000) >> 0x20) ==
(int)((ulong)*(int8 *)(param_1 + 0x2008) >> 0x20)) {
local_2c = (uint)*(ulong *)(param_1 + 0x2008) & 0x1fff;
if ((*(ulong *)(param_1 + 0x2008) & 0x1fff) == 0) {
local_2c = 0x2000;
}
*(ulong *)(param_1 + 0x2010) = *(long *)(param_1 + 0x2008) - (ulong)local_2c;
local_9 = 0;
}
else {
*(int8 *)(param_1 + 0x2010) = *(int8 *)(param_1 + 0x2000);
local_18 = param_1;
local_9 = translog_get_last_page_addr(param_1 + 0x2010,&local_19,0);
}
return local_9;
}
|
|
16 |
usage
|
eloqsql/client/mysql_plugin.c
|
static void usage(void)
{
PRINT_VERSION;
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. "
"All rights reserved.\n");
puts("Enable or disable plugins.");
printf("\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n",
my_progname);
my_print_help(my_long_options);
puts("\n");
}
|
O0
|
c
|
usage:
pushq %rbp
movq %rsp, %rbp
jmp 0x26a56
leaq 0x36a723(%rip), %rax # 0x391180
movq (%rax), %rsi
leaq 0x5b981(%rip), %rdi # 0x823e8
leaq 0x5b991(%rip), %rdx # 0x823ff
leaq 0x5b990(%rip), %rcx # 0x82405
movb $0x0, %al
callq 0x25050
leaq 0x5ba45(%rip), %rdi # 0x824c8
callq 0x255a0
leaq 0x5ba87(%rip), %rdi # 0x82516
callq 0x255a0
leaq 0x36a6e5(%rip), %rax # 0x391180
movq (%rax), %rsi
leaq 0x5ba8c(%rip), %rdi # 0x82531
movb $0x0, %al
callq 0x25050
leaq 0x1b255d(%rip), %rdi # 0x1d9010
callq 0x2bc40
leaq 0x6091a(%rip), %rdi # 0x873d9
callq 0x255a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
usage:
push rbp
mov rbp, rsp
jmp short $+2
loc_26A56:
lea rax, my_progname
mov rsi, [rax]
lea rdi, aSVerSDistribS; "%s Ver %s Distrib %s\n"
lea rdx, a100; "1.0.0"
lea rcx, a10610Mariadb; "10.6.10-MariaDB"
mov al, 0
call _printf
lea rdi, aCopyrightC2011; "Copyright (c) 2011, 2015, Oracle and/or"...
call _puts
lea rdi, aEnableOrDisabl; "Enable or disable plugins."
call _puts
lea rax, my_progname
mov rsi, [rax]
lea rdi, aUsageSOptionsP; "\nUsage: %s [options] <plugin> ENABLE|D"...
mov al, 0
call _printf
lea rdi, my_long_options
call my_print_help
lea rdi, asc_873D6+3; "\n"
call _puts
pop rbp
retn
|
long long usage()
{
printf("%s Ver %s Distrib %s\n", my_progname, "1.0.0", "10.6.10-MariaDB");
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.\n");
puts("Enable or disable plugins.");
printf("\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n", my_progname);
my_print_help(&my_long_options);
return puts("\n");
}
|
usage:
PUSH RBP
MOV RBP,RSP
JMP 0x00126a56
LAB_00126a56:
LEA RAX,[0x491180]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x1823e8]
LEA RDX,[0x1823ff]
LEA RCX,[0x182405]
MOV AL,0x0
CALL 0x00125050
LEA RDI,[0x1824c8]
CALL 0x001255a0
LEA RDI,[0x182516]
CALL 0x001255a0
LEA RAX,[0x491180]
MOV RSI,qword ptr [RAX]
LEA RDI,[0x182531]
MOV AL,0x0
CALL 0x00125050
LEA RDI,[0x2d9010]
CALL 0x0012bc40
LEA RDI,[0x1873d9]
CALL 0x001255a0
POP RBP
RET
|
void usage(void)
{
printf("%s Ver %s Distrib %s\n",my_progname,&DAT_001823ff,"10.6.10-MariaDB");
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.\n");
puts("Enable or disable plugins.");
printf("\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n",my_progname);
my_print_help(my_long_options);
puts("\n");
return;
}
|
|
17 |
usage
|
eloqsql/client/mysql_plugin.c
|
static void usage(void)
{
PRINT_VERSION;
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. "
"All rights reserved.\n");
puts("Enable or disable plugins.");
printf("\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n",
my_progname);
my_print_help(my_long_options);
puts("\n");
}
|
O3
|
c
|
usage:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x346e81(%rip), %rbx # 0x36d590
movq (%rbx), %rdx
leaq 0x3ac63(%rip), %rsi # 0x6137c
leaq 0x3ac73(%rip), %rcx # 0x61393
leaq 0x3ac72(%rip), %r8 # 0x61399
movl $0x1, %edi
xorl %eax, %eax
callq 0x24030
leaq 0x3ad22(%rip), %rdi # 0x6145c
callq 0x245f0
leaq 0x3ad64(%rip), %rdi # 0x614aa
callq 0x245f0
movq (%rbx), %rdx
leaq 0x3ad70(%rip), %rsi # 0x614c5
movl $0x1, %edi
xorl %eax, %eax
callq 0x24030
leaq 0x2cf8a8(%rip), %rdi # 0x2f6010
callq 0x29731
leaq 0x3fbc1(%rip), %rdi # 0x66335
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x245f0
|
usage:
push rbp
mov rbp, rsp
push rbx
push rax
lea rbx, my_progname
mov rdx, [rbx]
lea rsi, aSVerSDistribS; "%s Ver %s Distrib %s\n"
lea rcx, a100; "1.0.0"
lea r8, a10610Mariadb; "10.6.10-MariaDB"
mov edi, 1
xor eax, eax
call ___printf_chk
lea rdi, aCopyrightC2011; "Copyright (c) 2011, 2015, Oracle and/or"...
call _puts
lea rdi, aEnableOrDisabl; "Enable or disable plugins."
call _puts
mov rdx, [rbx]
lea rsi, aUsageSOptionsP; "\nUsage: %s [options] <plugin> ENABLE|D"...
mov edi, 1
xor eax, eax
call ___printf_chk
lea rdi, my_long_options
call my_print_help
lea rdi, asc_66332+3; "\n"
add rsp, 8
pop rbx
pop rbp
jmp _puts
|
long long usage()
{
__printf_chk(1LL, "%s Ver %s Distrib %s\n", my_progname, "1.0.0", "10.6.10-MariaDB");
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.\n");
puts("Enable or disable plugins.");
__printf_chk(1LL, "\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n", my_progname);
my_print_help(&my_long_options);
return puts("\n");
}
|
usage:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
LEA RBX,[0x46d590]
MOV RDX,qword ptr [RBX]
LEA RSI,[0x16137c]
LEA RCX,[0x161393]
LEA R8,[0x161399]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00124030
LEA RDI,[0x16145c]
CALL 0x001245f0
LEA RDI,[0x1614aa]
CALL 0x001245f0
MOV RDX,qword ptr [RBX]
LEA RSI,[0x1614c5]
MOV EDI,0x1
XOR EAX,EAX
CALL 0x00124030
LEA RDI,[0x3f6010]
CALL 0x00129731
LEA RDI,[0x166335]
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001245f0
|
void usage(void)
{
__printf_chk(1,"%s Ver %s Distrib %s\n",my_progname,&DAT_00161393,"10.6.10-MariaDB");
puts("Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.\n");
puts("Enable or disable plugins.");
__printf_chk(1,"\nUsage: %s [options] <plugin> ENABLE|DISABLE\n\nOptions:\n",my_progname);
my_print_help(my_long_options);
puts("\n");
return;
}
|
|
18 |
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/minja.hpp
|
Value do_evaluate(const std::shared_ptr<Context> & context) const override {
if (!left) throw std::runtime_error("BinaryOpExpr.left is null");
if (!right) throw std::runtime_error("BinaryOpExpr.right is null");
auto l = left->evaluate(context);
auto do_eval = [&](const Value & l) -> Value {
if (op == Op::Is || op == Op::IsNot) {
auto t = dynamic_cast<VariableExpr*>(right.get());
if (!t) throw std::runtime_error("Right side of 'is' operator must be a variable");
auto eval = [&]() {
const auto & name = t->get_name();
if (name == "none") return l.is_null();
if (name == "boolean") return l.is_boolean();
if (name == "integer") return l.is_number_integer();
if (name == "float") return l.is_number_float();
if (name == "number") return l.is_number();
if (name == "string") return l.is_string();
if (name == "mapping") return l.is_object();
if (name == "iterable") return l.is_iterable();
if (name == "sequence") return l.is_array();
if (name == "defined") return !l.is_null();
throw std::runtime_error("Unknown type for 'is' operator: " + name);
};
auto value = eval();
return Value(op == Op::Is ? value : !value);
}
if (op == Op::And) {
if (!l.to_bool()) return Value(false);
return right->evaluate(context).to_bool();
} else if (op == Op::Or) {
if (l.to_bool()) return l;
return right->evaluate(context);
}
auto r = right->evaluate(context);
switch (op) {
case Op::StrConcat: return l.to_str() + r.to_str();
case Op::Add: return l + r;
case Op::Sub: return l - r;
case Op::Mul: return l * r;
case Op::Div: return l / r;
case Op::MulMul: return std::pow(l.get<double>(), r.get<double>());
case Op::DivDiv: return l.get<int64_t>() / r.get<int64_t>();
case Op::Mod: return l.get<int64_t>() % r.get<int64_t>();
case Op::Eq: return l == r;
case Op::Ne: return l != r;
case Op::Lt: return l < r;
case Op::Gt: return l > r;
case Op::Le: return l <= r;
case Op::Ge: return l >= r;
case Op::In: return (r.is_array() || r.is_object()) && r.contains(l);
case Op::NotIn: return !(r.is_array() && r.contains(l));
default: break;
}
throw std::runtime_error("Unknown binary operator");
};
if (l.is_callable()) {
return Value::callable([l, do_eval](const std::shared_ptr<Context> & context, ArgumentsValue & args) {
auto ll = l.call(context, args);
return do_eval(ll); //args[0].second);
});
} else {
return do_eval(l);
}
}
|
O2
|
cpp
|
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x70b1d
cmpq $0x0, 0x30(%r15)
je 0x70b39
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x63f0a
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
cmpq $0x0, 0x30(%r12)
je 0x70aef
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x69b70
movups 0x8(%rsp), %xmm0
leaq 0x88(%rsp), %rsi
movups %xmm0, 0x50(%rsi)
leaq 0x18(%rsp), %rdi
callq 0x70c40
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x70bf4
leaq 0x18(%rsp), %rdi
callq 0x49072
leaq 0x88(%rsp), %rdi
callq 0x6419a
jmp 0x70b01
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x70c88
leaq 0x38(%rsp), %rdi
callq 0x6419a
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x44e01(%rip), %rsi # 0xb5930
movq %rax, %rdi
callq 0x23330
jmp 0x70b53
pushq $0x10
popq %rdi
callq 0x23470
movq %rax, %r14
leaq 0x44dff(%rip), %rsi # 0xb594a
movq %rax, %rdi
callq 0x23330
movq 0x8e48e(%rip), %rsi # 0xfefe8
movq 0x8e3e7(%rip), %rdx # 0xfef48
movq %r14, %rdi
callq 0x23f00
jmp 0x70b9b
jmp 0x70b6d
movq %rax, %rbx
movq %r14, %rdi
callq 0x236a0
jmp 0x70ba8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x49072
jmp 0x70b8c
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x6419a
jmp 0x70b9e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6419a
movq %rbx, %rdi
callq 0x23f80
|
_ZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 0E8h
mov r15, rsi
mov rsi, [rsi+20h]
test rsi, rsi
jz loc_70B1D
cmp qword ptr [r15+30h], 0
jz loc_70B39
mov r14, rdx
mov rbx, rdi
lea r12, [rsp+108h+var_D0]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov qword ptr [rsp+108h+var_100], r15
mov qword ptr [rsp+108h+var_100+8], r14
cmp qword ptr [r12+30h], 0
jz short loc_70AEF
lea rdi, [rsp+108h+var_80]; this
lea rsi, [rsp+108h+var_D0]; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
movups xmm0, [rsp+108h+var_100]
lea rsi, [rsp+108h+var_80]
movups xmmword ptr [rsi+50h], xmm0
lea rdi, [rsp+108h+var_F0]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEC2IZNKS0_12BinaryOpExpr11do_evaluateES6_EUlS6_S8_E_vEEOT_; std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1} &&)
lea rsi, [rsp+108h+var_F0]
mov rdi, rbx
call _ZN5minja5Value8callableERKSt8functionIFS0_RKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueEEE; minja::Value::callable(std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)> const&)
lea rdi, [rsp+108h+var_F0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+108h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_70B01
loc_70AEF:
lea rsi, [rsp+108h+var_100]
lea rdx, [rsp+108h+var_D0]
mov rdi, rbx; this
call _ZZNK5minja12BinaryOpExpr11do_evaluateERKSt10shared_ptrINS_7ContextEEENKUlRKNS_5ValueEE_clES8_; minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(minja::Value const&)#1}::operator()(minja::Value const&)
loc_70B01:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, rbx
add rsp, 0E8h
pop rbx
pop r12
pop r14
pop r15
retn
loc_70B1D:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprLe; "BinaryOpExpr.left is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_70B53
loc_70B39:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aBinaryopexprRi; "BinaryOpExpr.right is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_70B53:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_70B9B
jmp short $+2
loc_70B6D:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_70BA8
mov rbx, rax
lea rdi, [rsp+108h+var_F0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_70B8C
mov rbx, rax
loc_70B8C:
lea rdi, [rsp+108h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_70B9E
loc_70B9B:
mov rbx, rax
loc_70B9E:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_70BA8:
mov rdi, rbx
call __Unwind_Resume
|
minja::Value * minja::BinaryOpExpr::do_evaluate(minja::Value *this, long long a2, long long a3)
{
void (***v4)(void); // rsi
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
std::runtime_error *exception; // r14
__int128 v12; // [rsp+8h] [rbp-100h]
_BYTE v13[32]; // [rsp+18h] [rbp-F0h] BYREF
_BYTE v14[48]; // [rsp+38h] [rbp-D0h] BYREF
long long v15; // [rsp+68h] [rbp-A0h]
_BYTE v16[80]; // [rsp+88h] [rbp-80h] BYREF
__int128 v17; // [rsp+D8h] [rbp-30h]
v4 = *(void (****)(void))(a2 + 32);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.left is null");
goto LABEL_9;
}
if ( !*(_QWORD *)(a2 + 48) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "BinaryOpExpr.right is null");
LABEL_9:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v14, v4);
*(_QWORD *)&v12 = a2;
*((_QWORD *)&v12 + 1) = a3;
if ( v15 )
{
minja::Value::Value((minja::Value *)v16, (const minja::Value *)v14);
v17 = v12;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1},void>(v13);
minja::Value::callable((_DWORD)this, (unsigned int)v13, v6, v7, v8, v9);
std::_Function_base::~_Function_base((std::_Function_base *)v13);
minja::Value::~Value((minja::Value *)v16);
}
else
{
minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&)const::{lambda(minja::Value const&)#1}::operator()(this);
}
minja::Value::~Value((minja::Value *)v14);
return this;
}
|
do_evaluate:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R15,RSI
MOV RSI,qword ptr [RSI + 0x20]
TEST RSI,RSI
JZ 0x00170b1d
CMP qword ptr [R15 + 0x30],0x0
JZ 0x00170b39
MOV R14,RDX
MOV RBX,RDI
LEA R12,[RSP + 0x38]
MOV RDI,R12
CALL 0x00163f0a
MOV qword ptr [RSP + 0x8],R15
MOV qword ptr [RSP + 0x10],R14
CMP qword ptr [R12 + 0x30],0x0
JZ 0x00170aef
LAB_00170a9c:
LEA RDI,[RSP + 0x88]
LEA RSI,[RSP + 0x38]
CALL 0x00169b70
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x88]
MOVUPS xmmword ptr [RSI + 0x50],XMM0
LAB_00170abf:
LEA RDI,[RSP + 0x18]
CALL 0x00170c40
LAB_00170ac9:
LEA RSI,[RSP + 0x18]
MOV RDI,RBX
CALL 0x00170bf4
LEA RDI,[RSP + 0x18]
CALL 0x00149072
LEA RDI,[RSP + 0x88]
CALL 0x0016419a
JMP 0x00170b01
LAB_00170aef:
LEA RSI,[RSP + 0x8]
LEA RDX,[RSP + 0x38]
MOV RDI,RBX
CALL 0x00170c88
LAB_00170b01:
LEA RDI,[RSP + 0x38]
CALL 0x0016419a
MOV RAX,RBX
ADD RSP,0xe8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_00170b1d:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_00170b28:
LEA RSI,[0x1b5930]
MOV RDI,RAX
CALL 0x00123330
LAB_00170b37:
JMP 0x00170b53
LAB_00170b39:
PUSH 0x10
POP RDI
CALL 0x00123470
MOV R14,RAX
LAB_00170b44:
LEA RSI,[0x1b594a]
MOV RDI,RAX
CALL 0x00123330
LAB_00170b53:
MOV RSI,qword ptr [0x001fefe8]
MOV RDX,qword ptr [0x001fef48]
MOV RDI,R14
CALL 0x00123f00
|
/* minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
shared_ptr * minja::BinaryOpExpr::do_evaluate(shared_ptr *param_1)
{
runtime_error *this;
int8 in_RDX;
long in_RSI;
long local_100;
int8 uStack_f8;
_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ local_f0 [32];
Expression local_d0 [48];
long local_a0;
Value local_80 [80];
long local_30;
int8 uStack_28;
if (*(shared_ptr **)(in_RSI + 0x20) == (shared_ptr *)0x0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00170b28 to 00170b36 has its CatchHandler @ 00170b6d */
std::runtime_error::runtime_error(this,"BinaryOpExpr.left is null");
}
else {
if (*(long *)(in_RSI + 0x30) != 0) {
Expression::evaluate(local_d0,*(shared_ptr **)(in_RSI + 0x20));
if (local_a0 == 0) {
/* try { // try from 00170aef to 00170b00 has its CatchHandler @ 00170b69 */
const::{lambda(minja::Value_const&)#1}::operator()
((_lambda_minja__Value_const___1_ *)param_1,(Value *)&local_100);
}
else {
/* try { // try from 00170a9c to 00170aad has its CatchHandler @ 00170b9b */
local_100 = in_RSI;
uStack_f8 = in_RDX;
Value::Value(local_80,(Value *)local_d0);
local_30 = local_100;
uStack_28 = uStack_f8;
/* try { // try from 00170abf to 00170ac8 has its CatchHandler @ 00170b89 */
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
function<minja::BinaryOpExpr::do_evaluate(std::shared_ptr<minja::Context>const&)const::_lambda(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)_1_,void>
(local_f0);
/* try { // try from 00170ac9 to 00170ad5 has its CatchHandler @ 00170b7a */
Value::callable(param_1);
std::_Function_base::~_Function_base((_Function_base *)local_f0);
Value::~Value(local_80);
}
Value::~Value((Value *)local_d0);
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00170b44 to 00170b52 has its CatchHandler @ 00170b6b */
std::runtime_error::runtime_error(this,"BinaryOpExpr.right is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fefe8,PTR__runtime_error_001fef48);
}
|
|
19 |
int10_to_str
|
eloqsql/strings/int2str.c
|
char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O0
|
c
|
int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movl %edx, -0x64(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpl $0x0, -0x64(%rbp)
jge 0x798c6
cmpq $0x0, -0x58(%rbp)
jge 0x798c4
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x80(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x798c6
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movb $0x0, (%rax)
movq -0x80(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rax
imulq $0xa, -0x78(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, -0x1(%rax)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x79962
movq -0x58(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
imulq $0xa, -0x78(%rbp), %rcx
subq %rcx, %rax
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x70(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x70(%rbp)
movb %cl, -0x1(%rax)
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x79919
jmp 0x79964
movq -0x70(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x70(%rbp)
movb (%rax), %al
movq -0x60(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x60(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x79990
jmp 0x79964
movq -0x60(%rbp), %rax
decq %rax
movq %rax, -0x88(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x799c0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
callq 0x24300
nopw %cs:(%rax,%rax)
nop
|
int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 90h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_64], edx
mov rax, [rbp+var_58]
mov [rbp+var_80], rax
cmp [rbp+var_64], 0
jge short loc_798C6
cmp [rbp+var_58], 0
jge short loc_798C4
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Dh ; '-'
xor eax, eax
sub rax, [rbp+var_80]
mov [rbp+var_80], rax
loc_798C4:
jmp short $+2
loc_798C6:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_70], rax
mov rax, [rbp+var_70]
mov byte ptr [rax], 0
mov rax, [rbp+var_80]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_80]
imul rcx, [rbp+var_78], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_70]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_70], rdx
mov [rax-1], cl
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
loc_79919:
cmp [rbp+var_58], 0
jz short loc_79962
mov rax, [rbp+var_58]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_78], rax
mov rax, [rbp+var_58]
imul rcx, [rbp+var_78], 0Ah
sub rax, rcx
movsx eax, al
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_70]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_70], rdx
mov [rax-1], cl
mov rax, [rbp+var_78]
mov [rbp+var_58], rax
jmp short loc_79919
loc_79962:
jmp short $+2
loc_79964:
mov rax, [rbp+var_70]
mov rcx, rax
add rcx, 1
mov [rbp+var_70], rcx
mov al, [rax]
mov rcx, [rbp+var_60]
mov rdx, rcx
add rdx, 1
mov [rbp+var_60], rdx
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_79990
jmp short loc_79964
loc_79990:
mov rax, [rbp+var_60]
dec rax
mov [rbp+var_88], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_799C0
mov rax, [rbp+var_88]
add rsp, 90h
pop rbp
retn
loc_799C0:
call ___stack_chk_fail
|
_BYTE * int10_to_str(long long a1, _BYTE *a2, int a3)
{
_BYTE *v3; // rax
_BYTE *v4; // rax
_BYTE *v5; // rcx
unsigned long long v7; // [rsp+10h] [rbp-80h]
_BYTE *v8; // [rsp+20h] [rbp-70h]
_BYTE *v9; // [rsp+30h] [rbp-60h]
signed long long i; // [rsp+38h] [rbp-58h]
_BYTE v11[9]; // [rsp+7Fh] [rbp-11h] BYREF
unsigned long long v12; // [rsp+88h] [rbp-8h]
v12 = __readfsqword(0x28u);
v9 = a2;
v7 = a1;
if ( a3 < 0 && a1 < 0 )
{
v9 = a2 + 1;
*a2 = 45;
v7 = -a1;
}
v11[1] = 0;
v8 = v11;
v11[0] = v7 % 0xA + 48;
for ( i = v7 / 0xA; i; i /= 10LL )
{
v3 = v8--;
*(v3 - 1) = i % 10 + 48;
}
do
{
v4 = v8++;
LOBYTE(v4) = *v4;
v5 = v9++;
*v5 = (_BYTE)v4;
}
while ( (_BYTE)v4 );
return v9 - 1;
}
|
int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV dword ptr [RBP + -0x64],EDX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
CMP dword ptr [RBP + -0x64],0x0
JGE 0x001798c6
CMP qword ptr [RBP + -0x58],0x0
JGE 0x001798c4
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2d
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x80],RAX
LAB_001798c4:
JMP 0x001798c6
LAB_001798c6:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x80]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x80]
IMUL RCX,qword ptr [RBP + -0x78],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x70],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
LAB_00179919:
CMP qword ptr [RBP + -0x58],0x0
JZ 0x00179962
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x58]
IMUL RCX,qword ptr [RBP + -0x78],0xa
SUB RAX,RCX
MOVSX EAX,AL
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x70]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x70],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00179919
LAB_00179962:
JMP 0x00179964
LAB_00179964:
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x70],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x60],RDX
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00179990
JMP 0x00179964
LAB_00179990:
MOV RAX,qword ptr [RBP + -0x60]
DEC RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001799c0
MOV RAX,qword ptr [RBP + -0x88]
ADD RSP,0x90
POP RBP
RET
LAB_001799c0:
CALL 0x00124300
|
char * int10_to_str(ulong param_1,char *param_2,int param_3)
{
char cVar1;
char *pcVar2;
long in_FS_OFFSET;
ulong local_88;
char *local_78;
char *local_68;
ulong local_60;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_88 = param_1;
local_68 = param_2;
if ((param_3 < 0) && ((long)param_1 < 0)) {
local_68 = param_2 + 1;
*param_2 = '-';
local_88 = -param_1;
}
local_1a[2] = 0;
local_1a[1] = (char)local_88 + (char)(local_88 / 10) * -10 + '0';
local_78 = local_1a + 1;
local_60 = local_88 / 10;
while (pcVar2 = local_68, local_60 != 0) {
local_78[-1] = (char)local_60 + (char)((long)local_60 / 10) * -10 + '0';
local_78 = local_78 + -1;
local_60 = (long)local_60 / 10;
}
do {
local_68 = pcVar2;
cVar1 = *local_78;
*local_68 = cVar1;
local_78 = local_78 + 1;
pcVar2 = local_68 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_68;
}
|
|
20 |
ma_init_alloc_root
|
eloqsql/libmariadb/libmariadb/ma_alloc.c
|
void ma_init_alloc_root(MA_MEM_ROOT *mem_root, size_t block_size, size_t pre_alloc_size)
{
mem_root->free= mem_root->used= mem_root->pre_alloc= 0;
mem_root->min_malloc=32;
mem_root->block_size= (block_size-MALLOC_OVERHEAD-sizeof(MA_USED_MEM)+8);
mem_root->error_handler=0;
mem_root->block_num= 4;
mem_root->first_block_usage= 0;
#if !(defined(HAVE_purify) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
if ((mem_root->free = mem_root->pre_alloc=
(MA_USED_MEM*) malloc(pre_alloc_size+ ALIGN_SIZE(sizeof(MA_USED_MEM)))))
{
mem_root->free->size=pre_alloc_size+ALIGN_SIZE(sizeof(MA_USED_MEM));
mem_root->free->left=pre_alloc_size;
mem_root->free->next=0;
}
}
#endif
}
|
O0
|
c
|
ma_init_alloc_root:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x20, 0x18(%rax)
movq -0x10(%rbp), %rcx
subq $0x8, %rcx
subq $0x18, %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x28ab8
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x135c0
movq -0x8(%rbp), %rcx
movq %rax, 0x10(%rcx)
movq -0x8(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x28ab6
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, (%rax)
jmp 0x28ab8
addq $0x20, %rsp
popq %rbp
retq
nop
|
ma_init_alloc_root:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov qword ptr [rax+10h], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+8], 0
mov rax, [rbp+var_8]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov qword ptr [rax+18h], 20h ; ' '
mov rcx, [rbp+var_10]
sub rcx, 8
sub rcx, 18h
add rcx, 8
mov rax, [rbp+var_8]
mov [rax+20h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+28h], 4
mov rax, [rbp+var_8]
mov dword ptr [rax+2Ch], 0
cmp [rbp+var_18], 0
jz short loc_28AB8
mov rdi, [rbp+var_18]
add rdi, 18h
call _malloc
mov rcx, [rbp+var_8]
mov [rcx+10h], rax
mov rcx, [rbp+var_8]
mov [rcx], rax
cmp rax, 0
jz short loc_28AB6
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+10h], rcx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rax+8], rcx
mov rax, [rbp+var_8]
mov rax, [rax]
mov qword ptr [rax], 0
loc_28AB6:
jmp short $+2
loc_28AB8:
add rsp, 20h
pop rbp
retn
|
long long ma_init_alloc_root(long long *a1, long long a2, long long a3)
{
long long result; // rax
a1[2] = 0LL;
a1[1] = 0LL;
*a1 = 0LL;
a1[3] = 32LL;
a1[4] = a2 - 32 + 8;
a1[6] = 0LL;
*((_DWORD *)a1 + 10) = 4;
result = (long long)a1;
*((_DWORD *)a1 + 11) = 0;
if ( a3 )
{
result = malloc(a3 + 24);
a1[2] = result;
*a1 = result;
if ( result )
{
*(_QWORD *)(*a1 + 16) = a3 + 24;
*(_QWORD *)(*a1 + 8) = a3;
result = *a1;
*(_QWORD *)*a1 = 0LL;
}
}
return result;
}
|
ma_init_alloc_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
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 qword ptr [RAX + 0x10],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x8],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x18],0x20
MOV RCX,qword ptr [RBP + -0x10]
SUB RCX,0x8
SUB RCX,0x18
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x20],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x28],0x4
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x2c],0x0
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00128ab8
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0x18
CALL 0x001135c0
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX + 0x10],RAX
MOV RCX,qword ptr [RBP + -0x8]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x00128ab6
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],0x0
LAB_00128ab6:
JMP 0x00128ab8
LAB_00128ab8:
ADD RSP,0x20
POP RBP
RET
|
void ma_init_alloc_root(long *param_1,long param_2,long param_3)
{
void *pvVar1;
param_1[2] = 0;
param_1[1] = 0;
*param_1 = 0;
param_1[3] = 0x20;
param_1[4] = param_2 + -0x18;
param_1[6] = 0;
*(int4 *)(param_1 + 5) = 4;
*(int4 *)((long)param_1 + 0x2c) = 0;
if (param_3 != 0) {
pvVar1 = malloc(param_3 + 0x18);
param_1[2] = (long)pvVar1;
*param_1 = (long)pvVar1;
if (pvVar1 != (void *)0x0) {
*(long *)(*param_1 + 0x10) = param_3 + 0x18;
*(long *)(*param_1 + 8) = param_3;
*(int8 *)*param_1 = 0;
}
}
return;
}
|
|
21 |
my_coll_parser_scan_rule
|
eloqsql/strings/ctype-uca.c
|
static int
my_coll_parser_scan_rule(MY_COLL_RULE_PARSER *p)
{
if (!my_coll_parser_scan_term(p, MY_COLL_LEXEM_RESET) ||
!my_coll_parser_scan_reset_sequence(p))
return 0;
/* Scan the first required shift command */
if (!my_coll_parser_scan_shift(p))
return my_coll_parser_expected_error(p, MY_COLL_LEXEM_SHIFT);
/* Scan the first shift sequence */
if (!my_coll_parser_scan_shift_sequence(p))
return 0;
/* Scan subsequent shift rules */
while (my_coll_parser_scan_shift(p))
{
if (!my_coll_parser_scan_shift_sequence(p))
return 0;
}
return 1;
}
|
O0
|
c
|
my_coll_parser_scan_rule:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x9eb80
cmpl $0x0, %eax
je 0x9eafd
movq -0x10(%rbp), %rdi
callq 0x9ede0
cmpl $0x0, %eax
jne 0x9eb06
movl $0x0, -0x4(%rbp)
jmp 0x9eb6e
movq -0x10(%rbp), %rdi
callq 0x9ee90
cmpl $0x0, %eax
jne 0x9eb27
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x9eef0
movl %eax, -0x4(%rbp)
jmp 0x9eb6e
movq -0x10(%rbp), %rdi
callq 0x9ef40
cmpl $0x0, %eax
jne 0x9eb3e
movl $0x0, -0x4(%rbp)
jmp 0x9eb6e
jmp 0x9eb40
movq -0x10(%rbp), %rdi
callq 0x9ee90
cmpl $0x0, %eax
je 0x9eb67
movq -0x10(%rbp), %rdi
callq 0x9ef40
cmpl $0x0, %eax
jne 0x9eb65
movl $0x0, -0x4(%rbp)
jmp 0x9eb6e
jmp 0x9eb40
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
my_coll_parser_scan_rule:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
mov esi, 4
call my_coll_parser_scan_term
cmp eax, 0
jz short loc_9EAFD
mov rdi, [rbp+var_10]
call my_coll_parser_scan_reset_sequence
cmp eax, 0
jnz short loc_9EB06
loc_9EAFD:
mov [rbp+var_4], 0
jmp short loc_9EB6E
loc_9EB06:
mov rdi, [rbp+var_10]
call my_coll_parser_scan_shift
cmp eax, 0
jnz short loc_9EB27
mov rdi, [rbp+var_10]
mov esi, 1
call my_coll_parser_expected_error
mov [rbp+var_4], eax
jmp short loc_9EB6E
loc_9EB27:
mov rdi, [rbp+var_10]
call my_coll_parser_scan_shift_sequence
cmp eax, 0
jnz short loc_9EB3E
mov [rbp+var_4], 0
jmp short loc_9EB6E
loc_9EB3E:
jmp short $+2
loc_9EB40:
mov rdi, [rbp+var_10]
call my_coll_parser_scan_shift
cmp eax, 0
jz short loc_9EB67
mov rdi, [rbp+var_10]
call my_coll_parser_scan_shift_sequence
cmp eax, 0
jnz short loc_9EB65
mov [rbp+var_4], 0
jmp short loc_9EB6E
loc_9EB65:
jmp short loc_9EB40
loc_9EB67:
mov [rbp+var_4], 1
loc_9EB6E:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
|
long long my_coll_parser_scan_rule(long long a1)
{
if ( (unsigned int)my_coll_parser_scan_term(a1, 4LL) && (unsigned int)my_coll_parser_scan_reset_sequence(a1) )
{
if ( (unsigned int)my_coll_parser_scan_shift(a1) )
{
if ( (unsigned int)my_coll_parser_scan_shift_sequence(a1) )
{
while ( (unsigned int)my_coll_parser_scan_shift(a1) )
{
if ( !(unsigned int)my_coll_parser_scan_shift_sequence(a1) )
return 0;
}
return 1;
}
else
{
return 0;
}
}
else
{
return (unsigned int)my_coll_parser_expected_error(a1, 1LL);
}
}
else
{
return 0;
}
}
|
my_coll_parser_scan_rule:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x4
CALL 0x0019eb80
CMP EAX,0x0
JZ 0x0019eafd
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ede0
CMP EAX,0x0
JNZ 0x0019eb06
LAB_0019eafd:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019eb6e
LAB_0019eb06:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ee90
CMP EAX,0x0
JNZ 0x0019eb27
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x0019eef0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0019eb6e
LAB_0019eb27:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ef40
CMP EAX,0x0
JNZ 0x0019eb3e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019eb6e
LAB_0019eb3e:
JMP 0x0019eb40
LAB_0019eb40:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ee90
CMP EAX,0x0
JZ 0x0019eb67
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0019ef40
CMP EAX,0x0
JNZ 0x0019eb65
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0019eb6e
LAB_0019eb65:
JMP 0x0019eb40
LAB_0019eb67:
MOV dword ptr [RBP + -0x4],0x1
LAB_0019eb6e:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 my_coll_parser_scan_rule(int8 param_1)
{
int iVar1;
int4 local_c;
iVar1 = my_coll_parser_scan_term(param_1,4);
if ((iVar1 == 0) || (iVar1 = my_coll_parser_scan_reset_sequence(param_1), iVar1 == 0)) {
local_c = 0;
}
else {
iVar1 = my_coll_parser_scan_shift(param_1);
if (iVar1 == 0) {
local_c = my_coll_parser_expected_error(param_1,1);
}
else {
iVar1 = my_coll_parser_scan_shift_sequence(param_1);
if (iVar1 == 0) {
local_c = 0;
}
else {
do {
iVar1 = my_coll_parser_scan_shift(param_1);
if (iVar1 == 0) {
return 1;
}
iVar1 = my_coll_parser_scan_shift_sequence(param_1);
} while (iVar1 != 0);
local_c = 0;
}
}
}
return local_c;
}
|
|
22 |
ggml_compute_forward_diag_mask_f32
|
monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c
|
static void ggml_compute_forward_diag_mask_f32(
const struct ggml_compute_params * params,
struct ggml_tensor * dst,
const float value) {
const struct ggml_tensor * src0 = dst->src[0];
const int ith = params->ith;
const int nth = params->nth;
const int n_past = ((int32_t *) dst->op_params)[0];
const bool inplace = src0->data == dst->data;
GGML_ASSERT(n_past >= 0);
if (!inplace) {
if (ith == 0) {
// memcpy needs to be synchronized across threads to avoid race conditions.
// => do it in INIT phase
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
GGML_ASSERT(ggml_is_contiguous(dst) && ggml_is_contiguous(src0));
memcpy(
((char *) dst->data),
((char *) src0->data),
ggml_nbytes(dst));
}
ggml_barrier(params->threadpool);
}
// TODO: handle transposed/permuted matrices
const int n = ggml_nrows(src0);
const int nc = src0->ne[0];
const int nr = src0->ne[1];
const int nz = n/nr;
GGML_ASSERT( dst->nb[0] == sizeof(float));
GGML_ASSERT(src0->nb[0] == sizeof(float));
for (int k = 0; k < nz; k++) {
for (int j = ith; j < nr; j += nth) {
for (int i = n_past; i < nc; i++) {
if (i > n_past + j) {
*(float *)((char *) dst->data + k*dst->nb[2] + j*dst->nb[1] + i*dst->nb[0]) = value;
}
}
}
}
}
|
O0
|
c
|
ggml_compute_forward_diag_mask_f32:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
vmovss %xmm0, 0x54(%rsp)
movq 0x58(%rsp), %rax
movq 0x98(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x44(%rsp)
movq 0x60(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movl 0x54(%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movq 0xf8(%rax), %rax
movq 0x58(%rsp), %rcx
cmpq 0xf8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, 0x3b(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0x30b11
leaq 0x81063(%rip), %rdi # 0xb1b5a
movl $0x224b, %esi # imm = 0x224B
leaq 0x810ae(%rip), %rdx # 0xb1bb1
leaq 0x81d0e(%rip), %rcx # 0xb2818
movb $0x0, %al
callq 0xd030
testb $0x1, 0x3b(%rsp)
jne 0x30bf7
cmpl $0x0, 0x44(%rsp)
jne 0x30be9
movq 0x58(%rsp), %rdi
callq 0xc9e0
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0xc9e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x30b6e
leaq 0x81006(%rip), %rdi # 0xb1b5a
movl $0x2251, %esi # imm = 0x2251
leaq 0x81051(%rip), %rdx # 0xb1bb1
leaq 0x8147b(%rip), %rcx # 0xb1fe2
movb $0x0, %al
callq 0xd030
movq 0x58(%rsp), %rdi
callq 0xc210
testb $0x1, %al
jne 0x30b7e
jmp 0x30b8c
movq 0x48(%rsp), %rdi
callq 0xc210
testb $0x1, %al
jne 0x30bad
leaq 0x80fc7(%rip), %rdi # 0xb1b5a
movl $0x2252, %esi # imm = 0x2252
leaq 0x81012(%rip), %rdx # 0xb1bb1
leaq 0x81480(%rip), %rcx # 0xb2026
movb $0x0, %al
callq 0xd030
movq 0x58(%rsp), %rax
movq 0xf8(%rax), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rax
movq 0xf8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0xc0b0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0xc7d0
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xc050
movq 0x48(%rsp), %rdi
callq 0xcae0
movl %eax, 0x34(%rsp)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movl %eax, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rax
movl %eax, 0x2c(%rsp)
movl 0x34(%rsp), %eax
cltd
idivl 0x2c(%rsp)
movl %eax, 0x28(%rsp)
movq 0x58(%rsp), %rax
cmpq $0x4, 0x30(%rax)
je 0x30c59
leaq 0x80f1b(%rip), %rdi # 0xb1b5a
movl $0x2262, %esi # imm = 0x2262
leaq 0x80f66(%rip), %rdx # 0xb1bb1
leaq 0x81865(%rip), %rcx # 0xb24b7
movb $0x0, %al
callq 0xd030
movq 0x48(%rsp), %rax
cmpq $0x4, 0x30(%rax)
je 0x30c86
leaq 0x80eee(%rip), %rdi # 0xb1b5a
movl $0x2263, %esi # imm = 0x2263
leaq 0x80f39(%rip), %rdx # 0xb1bb1
leaq 0x81854(%rip), %rcx # 0xb24d3
movb $0x0, %al
callq 0xd030
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x30d52
movl 0x44(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x30d40
movl 0x3c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x30d2d
movl 0x1c(%rsp), %eax
movl 0x3c(%rsp), %ecx
addl 0x20(%rsp), %ecx
cmpl %ecx, %eax
jle 0x30d1e
vmovss 0x54(%rsp), %xmm0
movq 0x58(%rsp), %rax
movq 0xf8(%rax), %rax
movslq 0x24(%rsp), %rcx
movq 0x58(%rsp), %rdx
imulq 0x40(%rdx), %rcx
addq %rcx, %rax
movslq 0x20(%rsp), %rcx
movq 0x58(%rsp), %rdx
imulq 0x38(%rdx), %rcx
addq %rcx, %rax
movslq 0x1c(%rsp), %rcx
movq 0x58(%rsp), %rdx
imulq 0x30(%rdx), %rcx
vmovss %xmm0, (%rax,%rcx)
jmp 0x30d20
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x30cba
jmp 0x30d2f
movl 0x40(%rsp), %eax
addl 0x20(%rsp), %eax
movl %eax, 0x20(%rsp)
jmp 0x30ca4
jmp 0x30d42
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x30c8e
addq $0x68, %rsp
retq
nopw (%rax,%rax)
|
ggml_compute_forward_diag_mask_f32:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov [rsp+68h+var_10], rsi
vmovss [rsp+68h+var_14], xmm0
mov rax, [rsp+68h+var_10]
mov rax, [rax+98h]
mov [rsp+68h+var_20], rax
mov rax, [rsp+68h+var_8]
mov eax, [rax]
mov [rsp+68h+var_24], eax
mov rax, [rsp+68h+var_8]
mov eax, [rax+4]
mov [rsp+68h+var_28], eax
mov rax, [rsp+68h+var_10]
mov eax, [rax+54h]
mov [rsp+68h+var_2C], eax
mov rax, [rsp+68h+var_20]
mov rax, [rax+0F8h]
mov rcx, [rsp+68h+var_10]
cmp rax, [rcx+0F8h]
setz al
and al, 1
mov [rsp+68h+var_2D], al
cmp [rsp+68h+var_2C], 0
jge short loc_30B11
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 224Bh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNPast0; "n_past >= 0"
mov al, 0
call _ggml_abort
loc_30B11:
test [rsp+68h+var_2D], 1
jnz loc_30BF7
cmp [rsp+68h+var_24], 0
jnz loc_30BE9
mov rdi, [rsp+68h+var_10]
call _ggml_nelements
mov [rsp+68h+var_58], rax
mov rdi, [rsp+68h+var_20]
call _ggml_nelements
mov rcx, rax
mov rax, [rsp+68h+var_58]
cmp rax, rcx
jz short loc_30B6E
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2251h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlNelementsD; "ggml_nelements(dst) == ggml_nelements(s"...
mov al, 0
call _ggml_abort
loc_30B6E:
mov rdi, [rsp+68h+var_10]
call _ggml_is_contiguous
test al, 1
jnz short loc_30B7E
jmp short loc_30B8C
loc_30B7E:
mov rdi, [rsp+68h+var_20]
call _ggml_is_contiguous
test al, 1
jnz short loc_30BAD
loc_30B8C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2252h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aGgmlIsContiguo_0; "ggml_is_contiguous(dst) && ggml_is_cont"...
mov al, 0
call _ggml_abort
loc_30BAD:
mov rax, [rsp+68h+var_10]
mov rax, [rax+0F8h]
mov [rsp+68h+var_68], rax
mov rax, [rsp+68h+var_20]
mov rax, [rax+0F8h]
mov [rsp+68h+var_60], rax
mov rdi, [rsp+68h+var_10]
call _ggml_nbytes
mov rdi, [rsp+68h+var_68]
mov rsi, [rsp+68h+var_60]
mov rdx, rax
call _memcpy
loc_30BE9:
mov rax, [rsp+68h+var_8]
mov rdi, [rax+18h]
call _ggml_barrier
loc_30BF7:
mov rdi, [rsp+68h+var_20]
call _ggml_nrows
mov [rsp+68h+var_34], eax
mov rax, [rsp+68h+var_20]
mov rax, [rax+10h]
mov [rsp+68h+var_38], eax
mov rax, [rsp+68h+var_20]
mov rax, [rax+18h]
mov [rsp+68h+var_3C], eax
mov eax, [rsp+68h+var_34]
cdq
idiv [rsp+68h+var_3C]
mov [rsp+68h+var_40], eax
mov rax, [rsp+68h+var_10]
cmp qword ptr [rax+30h], 4
jz short loc_30C59
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2262h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDstNb0SizeofFl; "dst->nb[0] == sizeof(float)"
mov al, 0
call _ggml_abort
loc_30C59:
mov rax, [rsp+68h+var_20]
cmp qword ptr [rax+30h], 4
jz short loc_30C86
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov esi, 2263h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aSrc0Nb0SizeofF; "src0->nb[0] == sizeof(float)"
mov al, 0
call _ggml_abort
loc_30C86:
mov [rsp+68h+var_44], 0
loc_30C8E:
mov eax, [rsp+68h+var_44]
cmp eax, [rsp+68h+var_40]
jge loc_30D52
mov eax, [rsp+68h+var_24]
mov [rsp+68h+var_48], eax
loc_30CA4:
mov eax, [rsp+68h+var_48]
cmp eax, [rsp+68h+var_3C]
jge loc_30D40
mov eax, [rsp+68h+var_2C]
mov [rsp+68h+var_4C], eax
loc_30CBA:
mov eax, [rsp+68h+var_4C]
cmp eax, [rsp+68h+var_38]
jge short loc_30D2D
mov eax, [rsp+68h+var_4C]
mov ecx, [rsp+68h+var_2C]
add ecx, [rsp+68h+var_48]
cmp eax, ecx
jle short loc_30D1E
vmovss xmm0, [rsp+68h+var_14]
mov rax, [rsp+68h+var_10]
mov rax, [rax+0F8h]
movsxd rcx, [rsp+68h+var_44]
mov rdx, [rsp+68h+var_10]
imul rcx, [rdx+40h]
add rax, rcx
movsxd rcx, [rsp+68h+var_48]
mov rdx, [rsp+68h+var_10]
imul rcx, [rdx+38h]
add rax, rcx
movsxd rcx, [rsp+68h+var_4C]
mov rdx, [rsp+68h+var_10]
imul rcx, [rdx+30h]
vmovss dword ptr [rax+rcx], xmm0
loc_30D1E:
jmp short $+2
loc_30D20:
mov eax, [rsp+68h+var_4C]
add eax, 1
mov [rsp+68h+var_4C], eax
jmp short loc_30CBA
loc_30D2D:
jmp short $+2
loc_30D2F:
mov eax, [rsp+68h+var_28]
add eax, [rsp+68h+var_48]
mov [rsp+68h+var_48], eax
jmp loc_30CA4
loc_30D40:
jmp short $+2
loc_30D42:
mov eax, [rsp+68h+var_44]
add eax, 1
mov [rsp+68h+var_44], eax
jmp loc_30C8E
loc_30D52:
add rsp, 68h
retn
|
long long ggml_compute_forward_diag_mask_f32(int *a1, long long a2, __m128 _XMM0)
{
long long v3; // rax
long long result; // rax
long long v8; // [rsp+0h] [rbp-68h]
long long v9; // [rsp+8h] [rbp-60h]
long long v10; // [rsp+10h] [rbp-58h]
int k; // [rsp+1Ch] [rbp-4Ch]
int j; // [rsp+20h] [rbp-48h]
int i; // [rsp+24h] [rbp-44h]
int v14; // [rsp+2Ch] [rbp-3Ch]
int v15; // [rsp+30h] [rbp-38h]
int v16; // [rsp+34h] [rbp-34h]
bool v17; // [rsp+3Bh] [rbp-2Dh]
int v18; // [rsp+3Ch] [rbp-2Ch]
int v19; // [rsp+40h] [rbp-28h]
int v20; // [rsp+44h] [rbp-24h]
_QWORD *v21; // [rsp+48h] [rbp-20h]
__asm { vmovss [rsp+68h+var_14], xmm0 }
v21 = *(_QWORD **)(a2 + 152);
v20 = *a1;
v19 = a1[1];
v18 = *(_DWORD *)(a2 + 84);
v17 = v21[31] == *(_QWORD *)(a2 + 248);
if ( v18 < 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
8779LL,
"GGML_ASSERT(%s) failed",
"n_past >= 0");
if ( !v17 )
{
if ( !v20 )
{
v10 = ggml_nelements(a2);
if ( v10 != ggml_nelements(v21) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
8785LL,
"GGML_ASSERT(%s) failed",
"ggml_nelements(dst) == ggml_nelements(src0)");
if ( (ggml_is_contiguous(a2) & 1) == 0 || (ggml_is_contiguous(v21) & 1) == 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
8786LL,
"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(dst) && ggml_is_contiguous(src0)");
v8 = *(_QWORD *)(a2 + 248);
v9 = v21[31];
v3 = ggml_nbytes(a2);
memcpy(v8, v9, v3);
}
ggml_barrier(*((_QWORD *)a1 + 3));
}
v16 = ggml_nrows(v21);
v15 = v21[2];
v14 = v21[3];
if ( *(_QWORD *)(a2 + 48) != 4LL )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
8802LL,
"GGML_ASSERT(%s) failed",
"dst->nb[0] == sizeof(float)");
if ( v21[6] != 4LL )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c",
8803LL,
"GGML_ASSERT(%s) failed",
"src0->nb[0] == sizeof(float)");
for ( i = 0; ; ++i )
{
result = (unsigned int)i;
if ( i >= v16 / v14 )
break;
for ( j = v20; j < v14; j += v19 )
{
for ( k = v18; k < v15; ++k )
{
if ( k > j + v18 )
{
__asm { vmovss xmm0, [rsp+68h+var_14] }
_RAX = *(_QWORD *)(a2 + 56) * j + *(_QWORD *)(a2 + 64) * i + *(_QWORD *)(a2 + 248);
_RCX = *(_QWORD *)(a2 + 48) * k;
__asm { vmovss dword ptr [rax+rcx], xmm0 }
}
}
}
}
return result;
}
|
ggml_compute_forward_diag_mask_f32:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV qword ptr [RSP + 0x58],RSI
VMOVSS dword ptr [RSP + 0x54],XMM0
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x98]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RSP + 0x44],EAX
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x40],EAX
MOV RAX,qword ptr [RSP + 0x58]
MOV EAX,dword ptr [RAX + 0x54]
MOV dword ptr [RSP + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0xf8]
MOV RCX,qword ptr [RSP + 0x58]
CMP RAX,qword ptr [RCX + 0xf8]
SETZ AL
AND AL,0x1
MOV byte ptr [RSP + 0x3b],AL
CMP dword ptr [RSP + 0x3c],0x0
JGE 0x00130b11
LEA RDI,[0x1b1b5a]
MOV ESI,0x224b
LEA RDX,[0x1b1bb1]
LEA RCX,[0x1b2818]
MOV AL,0x0
CALL 0x0010d030
LAB_00130b11:
TEST byte ptr [RSP + 0x3b],0x1
JNZ 0x00130bf7
CMP dword ptr [RSP + 0x44],0x0
JNZ 0x00130be9
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010c9e0
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0010c9e0
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP RAX,RCX
JZ 0x00130b6e
LEA RDI,[0x1b1b5a]
MOV ESI,0x2251
LEA RDX,[0x1b1bb1]
LEA RCX,[0x1b1fe2]
MOV AL,0x0
CALL 0x0010d030
LAB_00130b6e:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010c210
TEST AL,0x1
JNZ 0x00130b7e
JMP 0x00130b8c
LAB_00130b7e:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0010c210
TEST AL,0x1
JNZ 0x00130bad
LAB_00130b8c:
LEA RDI,[0x1b1b5a]
MOV ESI,0x2252
LEA RDX,[0x1b1bb1]
LEA RCX,[0x1b2026]
MOV AL,0x0
CALL 0x0010d030
LAB_00130bad:
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0xf8]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0xf8]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x0010c0b0
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,RAX
CALL 0x0010c7d0
LAB_00130be9:
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x0010c050
LAB_00130bf7:
MOV RDI,qword ptr [RSP + 0x48]
CALL 0x0010cae0
MOV dword ptr [RSP + 0x34],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x10]
MOV dword ptr [RSP + 0x30],EAX
MOV RAX,qword ptr [RSP + 0x48]
MOV RAX,qword ptr [RAX + 0x18]
MOV dword ptr [RSP + 0x2c],EAX
MOV EAX,dword ptr [RSP + 0x34]
CDQ
IDIV dword ptr [RSP + 0x2c]
MOV dword ptr [RSP + 0x28],EAX
MOV RAX,qword ptr [RSP + 0x58]
CMP qword ptr [RAX + 0x30],0x4
JZ 0x00130c59
LEA RDI,[0x1b1b5a]
MOV ESI,0x2262
LEA RDX,[0x1b1bb1]
LEA RCX,[0x1b24b7]
MOV AL,0x0
CALL 0x0010d030
LAB_00130c59:
MOV RAX,qword ptr [RSP + 0x48]
CMP qword ptr [RAX + 0x30],0x4
JZ 0x00130c86
LEA RDI,[0x1b1b5a]
MOV ESI,0x2263
LEA RDX,[0x1b1bb1]
LEA RCX,[0x1b24d3]
MOV AL,0x0
CALL 0x0010d030
LAB_00130c86:
MOV dword ptr [RSP + 0x24],0x0
LAB_00130c8e:
MOV EAX,dword ptr [RSP + 0x24]
CMP EAX,dword ptr [RSP + 0x28]
JGE 0x00130d52
MOV EAX,dword ptr [RSP + 0x44]
MOV dword ptr [RSP + 0x20],EAX
LAB_00130ca4:
MOV EAX,dword ptr [RSP + 0x20]
CMP EAX,dword ptr [RSP + 0x2c]
JGE 0x00130d40
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x1c],EAX
LAB_00130cba:
MOV EAX,dword ptr [RSP + 0x1c]
CMP EAX,dword ptr [RSP + 0x30]
JGE 0x00130d2d
MOV EAX,dword ptr [RSP + 0x1c]
MOV ECX,dword ptr [RSP + 0x3c]
ADD ECX,dword ptr [RSP + 0x20]
CMP EAX,ECX
JLE 0x00130d1e
VMOVSS XMM0,dword ptr [RSP + 0x54]
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RSP + 0x24]
MOV RDX,qword ptr [RSP + 0x58]
IMUL RCX,qword ptr [RDX + 0x40]
ADD RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x58]
IMUL RCX,qword ptr [RDX + 0x38]
ADD RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x1c]
MOV RDX,qword ptr [RSP + 0x58]
IMUL RCX,qword ptr [RDX + 0x30]
VMOVSS dword ptr [RAX + RCX*0x1],XMM0
LAB_00130d1e:
JMP 0x00130d20
LAB_00130d20:
MOV EAX,dword ptr [RSP + 0x1c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x1c],EAX
JMP 0x00130cba
LAB_00130d2d:
JMP 0x00130d2f
LAB_00130d2f:
MOV EAX,dword ptr [RSP + 0x40]
ADD EAX,dword ptr [RSP + 0x20]
MOV dword ptr [RSP + 0x20],EAX
JMP 0x00130ca4
LAB_00130d40:
JMP 0x00130d42
LAB_00130d42:
MOV EAX,dword ptr [RSP + 0x24]
ADD EAX,0x1
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00130c8e
LAB_00130d52:
ADD RSP,0x68
RET
|
void ggml_compute_forward_diag_mask_f32(int4 param_1,int *param_2,long param_3)
{
int iVar1;
int iVar2;
int iVar3;
long lVar4;
void *__dest;
void *__src;
int8 uVar5;
int iVar6;
int iVar7;
long lVar8;
long lVar9;
ulong uVar10;
size_t __n;
int local_4c;
int local_48;
int local_44;
lVar4 = *(long *)(param_3 + 0x98);
iVar1 = *param_2;
iVar2 = param_2[1];
iVar3 = *(int *)(param_3 + 0x54);
if (iVar3 < 0) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x224b,"GGML_ASSERT(%s) failed","n_past >= 0");
}
if (*(long *)(lVar4 + 0xf8) != *(long *)(param_3 + 0xf8)) {
if (iVar1 == 0) {
lVar8 = ggml_nelements(param_3);
lVar9 = ggml_nelements(lVar4);
if (lVar8 != lVar9) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2251,"GGML_ASSERT(%s) failed","ggml_nelements(dst) == ggml_nelements(src0)");
}
uVar10 = ggml_is_contiguous(param_3);
if (((uVar10 & 1) == 0) || (uVar10 = ggml_is_contiguous(lVar4), (uVar10 & 1) == 0)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2252,"GGML_ASSERT(%s) failed",
"ggml_is_contiguous(dst) && ggml_is_contiguous(src0)");
}
__dest = *(void **)(param_3 + 0xf8);
__src = *(void **)(lVar4 + 0xf8);
__n = ggml_nbytes(param_3);
memcpy(__dest,__src,__n);
}
ggml_barrier(*(int8 *)(param_2 + 6));
}
iVar6 = ggml_nrows(lVar4);
uVar5 = *(int8 *)(lVar4 + 0x10);
iVar7 = (int)*(int8 *)(lVar4 + 0x18);
if (*(long *)(param_3 + 0x30) != 4) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2262,"GGML_ASSERT(%s) failed","dst->nb[0] == sizeof(float)");
}
if (*(long *)(lVar4 + 0x30) == 4) {
for (local_44 = 0; local_48 = iVar1, local_44 < iVar6 / iVar7; local_44 = local_44 + 1) {
for (; local_4c = iVar3, local_48 < iVar7; local_48 = iVar2 + local_48) {
for (; local_4c < (int)uVar5; local_4c = local_4c + 1) {
if (iVar3 + local_48 < local_4c) {
*(int4 *)
(*(long *)(param_3 + 0xf8) + (long)local_44 * *(long *)(param_3 + 0x40) +
(long)local_48 * *(long *)(param_3 + 0x38) +
(long)local_4c * *(long *)(param_3 + 0x30)) = param_1;
}
}
}
}
return;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/ggml/src/ggml-cpu/ggml-cpu.c"
,0x2263,"GGML_ASSERT(%s) failed","src0->nb[0] == sizeof(float)");
}
|
|
23 |
ggml_numa_init
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
void ggml_numa_init(void) {
if (g_state.numa.n_nodes > 0) {
fprintf(stderr, "ggml_numa_init: NUMA already initialized\n");
return;
}
#ifdef __linux__
struct stat st;
char path[256];
int rv;
// enumerate nodes
while (g_state.numa.n_nodes < GGML_NUMA_MAX_NODES) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u", g_state.numa.n_nodes);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.n_nodes;
}
// enumerate CPUs
while (g_state.numa.total_cpus < GGML_NUMA_MAX_CPUS) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%u", g_state.numa.total_cpus);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.total_cpus;
}
GGML_PRINT_DEBUG("found %u numa nodes, %u CPUs\n", g_state.numa.n_nodes, g_state.numa.total_cpus);
if (g_state.numa.n_nodes < 1 || g_state.numa.total_cpus < 1) {
g_state.numa.n_nodes = 0;
return;
}
for (uint32_t n = 0; n < g_state.numa.n_nodes; ++n) {
struct ggml_numa_node * node = &g_state.numa.nodes[n];
GGML_PRINT_DEBUG("CPUs on node %u:", n);
node->n_cpus = 0;
for (uint32_t c = 0; c < g_state.numa.total_cpus; ++c) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u/cpu%u", n, c);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) == 0) {
node->cpus[node->n_cpus++] = c;
GGML_PRINT_DEBUG(" %u", c);
}
}
GGML_PRINT_DEBUG("\n");
}
if (ggml_is_numa()) {
FILE *fptr = fopen("/proc/sys/kernel/numa_balancing", "r");
if (fptr != NULL) {
char buf[42];
if (fgets(buf, sizeof(buf), fptr) && strncmp(buf, "0\n", sizeof(buf)) != 0) {
GGML_PRINT("WARNING: /proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
}
fclose(fptr);
}
}
#else
// TODO
#endif
}
|
O0
|
c
|
ggml_numa_init:
subq $0x1e8, %rsp # imm = 0x1E8
cmpl $0x0, 0x1455a2(%rip) # 0x25ffa0
jbe 0x11aa1d
movq 0xbd5a1(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x6ecca(%rip), %rsi # 0x1896db
movb $0x0, %al
callq 0xbae0
jmp 0x11ad63
jmp 0x11aa1f
cmpl $0x8, 0x14557a(%rip) # 0x25ffa0
jae 0x11aad4
leaq 0x50(%rsp), %rdi
movl 0x145569(%rip), %ecx # 0x25ffa0
movl $0x100, %esi # imm = 0x100
leaq 0x6ecc2(%rip), %rdx # 0x189705
movb $0x0, %al
callq 0xbbf0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jle 0x11aa61
movl 0x4c(%rsp), %eax
cmpq $0x100, %rax # imm = 0x100
jb 0x11aaa5
movq 0xbd4c0(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xbd531(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x65199(%rip), %rsi # 0x17fc1a
leaq 0x6ebe6(%rip), %rdx # 0x18966e
movl $0x763, %ecx # imm = 0x763
leaq 0x6ec91(%rip), %r8 # 0x189725
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x11aaa7
leaq 0x50(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0xb6b0
cmpl $0x0, %eax
je 0x11aac0
jmp 0x11aad4
movl 0x1454da(%rip), %eax # 0x25ffa0
addl $0x1, %eax
movl %eax, 0x1454d1(%rip) # 0x25ffa0
jmp 0x11aa1f
jmp 0x11aad6
cmpl $0x200, 0x1454c4(%rip) # imm = 0x200
jae 0x11ab8e
leaq 0x50(%rsp), %rdi
movl 0x1454b3(%rip), %ecx # 0x25ffa4
movl $0x100, %esi # imm = 0x100
leaq 0x6ec4e(%rip), %rdx # 0x18974b
movb $0x0, %al
callq 0xbbf0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jle 0x11ab1b
movl 0x4c(%rsp), %eax
cmpq $0x100, %rax # imm = 0x100
jb 0x11ab5f
movq 0xbd406(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xbd477(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x650df(%rip), %rsi # 0x17fc1a
leaq 0x6eb2c(%rip), %rdx # 0x18966e
movl $0x76b, %ecx # imm = 0x76B
leaq 0x6ebd7(%rip), %r8 # 0x189725
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x11ab61
leaq 0x50(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0xb6b0
cmpl $0x0, %eax
je 0x11ab7a
jmp 0x11ab8e
movl 0x145424(%rip), %eax # 0x25ffa4
addl $0x1, %eax
movl %eax, 0x14541b(%rip) # 0x25ffa4
jmp 0x11aad6
cmpl $0x1, 0x14540b(%rip) # 0x25ffa0
jb 0x11aba0
cmpl $0x1, 0x145406(%rip) # 0x25ffa4
jae 0x11abaf
movl $0x0, 0x1453f6(%rip) # 0x25ffa0
jmp 0x11ad63
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x1453df(%rip), %eax # 0x25ffa0
jae 0x11aced
movl 0x48(%rsp), %eax
movl %eax, %ecx
leaq 0x13fbac(%rip), %rax # 0x25a780
addq $0x1800, %rax # imm = 0x1800
imulq $0x804, %rcx, %rcx # imm = 0x804
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl $0x0, 0x800(%rax)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x14539a(%rip), %eax # 0x25ffa4
jae 0x11acdb
leaq 0x50(%rsp), %rdi
movl 0x48(%rsp), %ecx
movl 0x3c(%rsp), %r8d
movl $0x100, %esi # imm = 0x100
leaq 0x6eb3f(%rip), %rdx # 0x189769
movb $0x0, %al
callq 0xbbf0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jle 0x11ac48
movl 0x4c(%rsp), %eax
cmpq $0x100, %rax # imm = 0x100
jb 0x11ac8c
movq 0xbd2d9(%rip), %rax # 0x1d7f28
movq (%rax), %rdi
callq 0xb8e0
movq 0xbd34a(%rip), %rax # 0x1d7fa8
movq (%rax), %rdi
leaq 0x64fb2(%rip), %rsi # 0x17fc1a
leaq 0x6e9ff(%rip), %rdx # 0x18966e
movl $0x77d, %ecx # imm = 0x77D
leaq 0x6eaaa(%rip), %r8 # 0x189725
movb $0x0, %al
callq 0xbae0
callq 0x11a4f0
callq 0xb3a0
jmp 0x11ac8e
leaq 0x50(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0xb6b0
cmpl $0x0, %eax
jne 0x11acc9
movl 0x3c(%rsp), %edx
movq 0x40(%rsp), %rax
movq 0x40(%rsp), %rsi
movl 0x800(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x800(%rsi)
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
jmp 0x11accb
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x11ac00
jmp 0x11acdd
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x11abb7
callq 0x11ad70
testb $0x1, %al
jne 0x11acf8
jmp 0x11ad63
leaq 0x6ea90(%rip), %rdi # 0x18978f
leaq 0x69db9(%rip), %rsi # 0x184abf
callq 0xb8f0
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x11ad61
movq %rsp, %rdi
movq 0x30(%rsp), %rdx
movl $0x2a, %esi
callq 0xbbc0
cmpq $0x0, %rax
je 0x11ad57
movq %rsp, %rdi
leaq 0x63abd(%rip), %rsi # 0x17e7f7
movl $0x2a, %edx
callq 0xb310
cmpl $0x0, %eax
je 0x11ad57
leaq 0x6ea5f(%rip), %rdi # 0x1897af
movb $0x0, %al
callq 0xb0a0
movq 0x30(%rsp), %rdi
callq 0xb770
jmp 0x11ad63
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopl (%rax,%rax)
|
ggml_numa_init:
sub rsp, 1E8h
cmp cs:dword_25FFA0, 0
jbe short loc_11AA1D
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlNumaInitNu; "ggml_numa_init: NUMA already initialize"...
mov al, 0
call _fprintf
jmp loc_11AD63
loc_11AA1D:
jmp short $+2
loc_11AA1F:
cmp cs:dword_25FFA0, 8
jnb loc_11AAD4
lea rdi, [rsp+1E8h+var_198]
mov ecx, cs:dword_25FFA0
mov esi, 100h
lea rdx, aSysDevicesSyst_0; "/sys/devices/system/node/node%u"
mov al, 0
call _snprintf
mov [rsp+1E8h+var_19C], eax
cmp [rsp+1E8h+var_19C], 0
jle short loc_11AA61
mov eax, [rsp+1E8h+var_19C]
cmp rax, 100h
jb short loc_11AAA5
loc_11AA61:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 763h
lea r8, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_11AAA5:
jmp short $+2
loc_11AAA7:
lea rdi, [rsp+1E8h+var_198]
lea rsi, [rsp+1E8h+var_90]
call _stat
cmp eax, 0
jz short loc_11AAC0
jmp short loc_11AAD4
loc_11AAC0:
mov eax, cs:dword_25FFA0
add eax, 1
mov cs:dword_25FFA0, eax
jmp loc_11AA1F
loc_11AAD4:
jmp short $+2
loc_11AAD6:
cmp cs:dword_25FFA4, 200h
jnb loc_11AB8E
lea rdi, [rsp+1E8h+var_198]
mov ecx, cs:dword_25FFA4
mov esi, 100h
lea rdx, aSysDevicesSyst_1; "/sys/devices/system/cpu/cpu%u"
mov al, 0
call _snprintf
mov [rsp+1E8h+var_19C], eax
cmp [rsp+1E8h+var_19C], 0
jle short loc_11AB1B
mov eax, [rsp+1E8h+var_19C]
cmp rax, 100h
jb short loc_11AB5F
loc_11AB1B:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 76Bh
lea r8, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_11AB5F:
jmp short $+2
loc_11AB61:
lea rdi, [rsp+1E8h+var_198]
lea rsi, [rsp+1E8h+var_90]
call _stat
cmp eax, 0
jz short loc_11AB7A
jmp short loc_11AB8E
loc_11AB7A:
mov eax, cs:dword_25FFA4
add eax, 1
mov cs:dword_25FFA4, eax
jmp loc_11AAD6
loc_11AB8E:
cmp cs:dword_25FFA0, 1
jb short loc_11ABA0
cmp cs:dword_25FFA4, 1
jnb short loc_11ABAF
loc_11ABA0:
mov cs:dword_25FFA0, 0
jmp loc_11AD63
loc_11ABAF:
mov [rsp+1E8h+var_1A0], 0
loc_11ABB7:
mov eax, [rsp+1E8h+var_1A0]
cmp eax, cs:dword_25FFA0
jnb loc_11ACED
mov eax, [rsp+1E8h+var_1A0]
mov ecx, eax
lea rax, g_state
add rax, 1800h
imul rcx, 804h
add rax, rcx
mov [rsp+1E8h+var_1A8], rax
mov rax, [rsp+1E8h+var_1A8]
mov dword ptr [rax+800h], 0
mov [rsp+1E8h+var_1AC], 0
loc_11AC00:
mov eax, [rsp+1E8h+var_1AC]
cmp eax, cs:dword_25FFA4
jnb loc_11ACDB
lea rdi, [rsp+1E8h+var_198]
mov ecx, [rsp+1E8h+var_1A0]
mov r8d, [rsp+1E8h+var_1AC]
mov esi, 100h
lea rdx, aSysDevicesSyst_2; "/sys/devices/system/node/node%u/cpu%u"
mov al, 0
call _snprintf
mov [rsp+1E8h+var_19C], eax
cmp [rsp+1E8h+var_19C], 0
jle short loc_11AC48
mov eax, [rsp+1E8h+var_19C]
cmp rax, 100h
jb short loc_11AC8C
loc_11AC48:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
mov ecx, 77Dh
lea r8, aRv0UnsignedRvS; "rv > 0 && (unsigned)rv < sizeof(path)"
mov al, 0
call _fprintf
call ggml_print_backtrace
call _abort
loc_11AC8C:
jmp short $+2
loc_11AC8E:
lea rdi, [rsp+1E8h+var_198]
lea rsi, [rsp+1E8h+var_90]
call _stat
cmp eax, 0
jnz short loc_11ACC9
mov edx, [rsp+1E8h+var_1AC]
mov rax, [rsp+1E8h+var_1A8]
mov rsi, [rsp+1E8h+var_1A8]
mov ecx, [rsi+800h]
mov edi, ecx
add edi, 1
mov [rsi+800h], edi
mov ecx, ecx
mov [rax+rcx*4], edx
loc_11ACC9:
jmp short $+2
loc_11ACCB:
mov eax, [rsp+1E8h+var_1AC]
add eax, 1
mov [rsp+1E8h+var_1AC], eax
jmp loc_11AC00
loc_11ACDB:
jmp short $+2
loc_11ACDD:
mov eax, [rsp+1E8h+var_1A0]
add eax, 1
mov [rsp+1E8h+var_1A0], eax
jmp loc_11ABB7
loc_11ACED:
call ggml_is_numa
test al, 1
jnz short loc_11ACF8
jmp short loc_11AD63
loc_11ACF8:
lea rdi, aProcSysKernelN; "/proc/sys/kernel/numa_balancing"
lea rsi, aInvalidStringC_12+4Ch; "r"
call _fopen
mov [rsp+1E8h+var_1B8], rax
cmp [rsp+1E8h+var_1B8], 0
jz short loc_11AD61
mov rdi, rsp
mov rdx, [rsp+1E8h+var_1B8]
mov esi, 2Ah ; '*'
call _fgets
cmp rax, 0
jz short loc_11AD57
mov rdi, rsp
lea rsi, aErrorTheSample+2Dh; "0\n"
mov edx, 2Ah ; '*'
call _strncmp
cmp eax, 0
jz short loc_11AD57
lea rdi, aWarningProcSys; "WARNING: /proc/sys/kernel/numa_balancin"...
mov al, 0
call _printf
loc_11AD57:
mov rdi, [rsp+1E8h+var_1B8]
call _fclose
loc_11AD61:
jmp short $+2
loc_11AD63:
add rsp, 1E8h
retn
|
void ggml_numa_init()
{
long long v0; // rdi
long long v1; // rdi
long long v2; // rdi
unsigned int v3; // edx
char *v4; // rax
int v5; // ecx
_BYTE v6[48]; // [rsp+0h] [rbp-1E8h] BYREF
long long v7; // [rsp+30h] [rbp-1B8h]
unsigned int j; // [rsp+3Ch] [rbp-1ACh]
char *v9; // [rsp+40h] [rbp-1A8h]
unsigned int i; // [rsp+48h] [rbp-1A0h]
int v11; // [rsp+4Ch] [rbp-19Ch]
_BYTE v12[264]; // [rsp+50h] [rbp-198h] BYREF
_BYTE v13[144]; // [rsp+158h] [rbp-90h] BYREF
if ( dword_25FFA0 )
{
fprintf(stderr, "ggml_numa_init: NUMA already initialized\n");
}
else
{
while ( (unsigned int)dword_25FFA0 < 8 )
{
v11 = snprintf(v12, 256LL, "/sys/devices/system/node/node%u", dword_25FFA0);
if ( v11 <= 0 || (unsigned int)v11 >= 0x100uLL )
{
fflush(stdout);
v0 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
1891,
"rv > 0 && (unsigned)rv < sizeof(path)");
ggml_print_backtrace();
abort(v0);
}
if ( (unsigned int)stat(v12, v13) )
break;
++dword_25FFA0;
}
while ( (unsigned int)dword_25FFA4 < 0x200 )
{
v11 = snprintf(v12, 256LL, "/sys/devices/system/cpu/cpu%u", dword_25FFA4);
if ( v11 <= 0 || (unsigned int)v11 >= 0x100uLL )
{
fflush(stdout);
v1 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
1899,
"rv > 0 && (unsigned)rv < sizeof(path)");
ggml_print_backtrace();
abort(v1);
}
if ( (unsigned int)stat(v12, v13) )
break;
++dword_25FFA4;
}
if ( dword_25FFA0 && dword_25FFA4 )
{
for ( i = 0; i < dword_25FFA0; ++i )
{
v9 = (char *)&g_state + 2052 * i + 6144;
*((_DWORD *)v9 + 512) = 0;
for ( j = 0; j < dword_25FFA4; ++j )
{
v11 = snprintf(v12, 256LL, "/sys/devices/system/node/node%u/cpu%u", i, j);
if ( v11 <= 0 || (unsigned int)v11 >= 0x100uLL )
{
fflush(stdout);
v2 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
1917,
"rv > 0 && (unsigned)rv < sizeof(path)");
ggml_print_backtrace();
abort(v2);
}
if ( !(unsigned int)stat(v12, v13) )
{
v3 = j;
v4 = v9;
v5 = *((_DWORD *)v9 + 512);
*((_DWORD *)v9 + 512) = v5 + 1;
*(_DWORD *)&v4[4 * v5] = v3;
}
}
}
if ( (ggml_is_numa() & 1) != 0 )
{
v7 = fopen("/proc/sys/kernel/numa_balancing", "r");
if ( v7 )
{
if ( fgets(v6, 42LL, v7) && (unsigned int)strncmp(v6, "0\n", 42LL) )
printf("WARNING: /proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
fclose(v7);
}
}
}
else
{
dword_25FFA0 = 0;
}
}
}
| |||
24 |
ggml_numa_init
|
7CodeWizard[P]stablediffusion/ggml/src/ggml.c
|
void ggml_numa_init(void) {
if (g_state.numa.n_nodes > 0) {
fprintf(stderr, "ggml_numa_init: NUMA already initialized\n");
return;
}
#ifdef __linux__
struct stat st;
char path[256];
int rv;
// enumerate nodes
while (g_state.numa.n_nodes < GGML_NUMA_MAX_NODES) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u", g_state.numa.n_nodes);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.n_nodes;
}
// enumerate CPUs
while (g_state.numa.total_cpus < GGML_NUMA_MAX_CPUS) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/cpu/cpu%u", g_state.numa.total_cpus);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) != 0) { break; }
++g_state.numa.total_cpus;
}
GGML_PRINT_DEBUG("found %u numa nodes, %u CPUs\n", g_state.numa.n_nodes, g_state.numa.total_cpus);
if (g_state.numa.n_nodes < 1 || g_state.numa.total_cpus < 1) {
g_state.numa.n_nodes = 0;
return;
}
for (uint32_t n = 0; n < g_state.numa.n_nodes; ++n) {
struct ggml_numa_node * node = &g_state.numa.nodes[n];
GGML_PRINT_DEBUG("CPUs on node %u:", n);
node->n_cpus = 0;
for (uint32_t c = 0; c < g_state.numa.total_cpus; ++c) {
rv = snprintf(path, sizeof(path), "/sys/devices/system/node/node%u/cpu%u", n, c);
GGML_ASSERT(rv > 0 && (unsigned)rv < sizeof(path));
if (stat(path, &st) == 0) {
node->cpus[node->n_cpus++] = c;
GGML_PRINT_DEBUG(" %u", c);
}
}
GGML_PRINT_DEBUG("\n");
}
if (ggml_is_numa()) {
FILE *fptr = fopen("/proc/sys/kernel/numa_balancing", "r");
if (fptr != NULL) {
char buf[42];
if (fgets(buf, sizeof(buf), fptr) && strncmp(buf, "0\n", sizeof(buf)) != 0) {
GGML_PRINT("WARNING: /proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance\n");
}
fclose(fptr);
}
}
#else
// TODO
#endif
}
|
O1
|
c
|
ggml_numa_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
cmpl $0x0, 0xf04f7(%rip) # 0x17e270
jne 0x8df9c
movl 0xf04eb(%rip), %ecx # 0x17e270
cmpl $0x7, %ecx
ja 0x8dddf
leaq 0x37dac(%rip), %rbx # 0xc5b3d
leaq 0xc0(%rsp), %r14
leaq 0x30(%rsp), %r15
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa9d0
decl %eax
cmpl $0xff, %eax
jae 0x8dfa8
movq %r14, %rdi
movq %r15, %rsi
callq 0xa540
testl %eax, %eax
jne 0x8dddf
movl 0xf049e(%rip), %ecx # 0x17e270
incl %ecx
movl %ecx, 0xf0496(%rip) # 0x17e270
cmpl $0x8, %ecx
jb 0x8dd9e
movl 0xf048f(%rip), %ecx # 0x17e274
cmpl $0x1ff, %ecx # imm = 0x1FF
ja 0x8de45
leaq 0x37d8f(%rip), %rbx # 0xc5b83
leaq 0xc0(%rsp), %r14
leaq 0x30(%rsp), %r15
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xa9d0
decl %eax
cmpl $0xff, %eax
jae 0x8dfad
movq %r14, %rdi
movq %r15, %rsi
callq 0xa540
testl %eax, %eax
jne 0x8de45
movl 0xf043f(%rip), %ecx # 0x17e274
incl %ecx
movl %ecx, 0xf0437(%rip) # 0x17e274
cmpl $0x200, %ecx # imm = 0x200
jb 0x8de01
cmpl $0x0, 0xf0424(%rip) # 0x17e270
je 0x8df80
cmpl $0x0, 0xf041b(%rip) # 0x17e274
je 0x8df80
cmpl $0x0, 0xf040a(%rip) # 0x17e270
je 0x8df8a
leaq 0x37d2e(%rip), %rbx # 0xc5ba1
leaq 0xc0(%rsp), %r14
leaq 0x30(%rsp), %r15
xorl %r12d, %r12d
movq %r12, %rax
shlq $0xb, %rax
leaq (%rax,%r12,4), %rax
leaq 0xeabbb(%rip), %rcx # 0x178a50
movl $0x0, 0x2000(%rcx,%rax)
cmpl $0x0, 0xf03cd(%rip) # 0x17e274
je 0x8df11
leaq 0xeaba0(%rip), %rcx # 0x178a50
leaq (%rcx,%rax), %r13
addq $0x1800, %r13 # imm = 0x1800
xorl %ebp, %ebp
movl $0x100, %esi # imm = 0x100
movq %r14, %rdi
movq %rbx, %rdx
movl %r12d, %ecx
movl %ebp, %r8d
xorl %eax, %eax
callq 0xa9d0
decl %eax
cmpl $0xff, %eax
jae 0x8dfa3
movq %r14, %rdi
movq %r15, %rsi
callq 0xa540
testl %eax, %eax
jne 0x8df07
movl 0x800(%r13), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x800(%r13)
movl %ebp, (%r13,%rax,4)
incl %ebp
cmpl 0xf0365(%rip), %ebp # 0x17e274
jb 0x8debd
incq %r12
movl 0xf0356(%rip), %eax # 0x17e270
cmpq %rax, %r12
jb 0x8de83
cmpl $0x1, %eax
jbe 0x8df8a
leaq 0x37c98(%rip), %rdi # 0xc5bc7
leaq 0x34ab9(%rip), %rsi # 0xc29ef
callq 0xa6f0
testq %rax, %rax
je 0x8df8a
movq %rax, %rbx
movq %rsp, %rdi
movl $0x2a, %esi
movq %rax, %rdx
callq 0xa9a0
testq %rax, %rax
je 0x8df76
movl $0xa30, %eax # imm = 0xA30
xorl (%rsp), %eax
movzbl 0x2(%rsp), %ecx
orw %ax, %cx
je 0x8df76
leaq 0x3a748(%rip), %rdi # 0xc86b9
callq 0xa940
movq %rbx, %rdi
callq 0xa5c0
jmp 0x8df8a
movl $0x0, 0xf02e6(%rip) # 0x17e270
addq $0x1c8, %rsp # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xc0af
jmp 0x8df8a
callq 0xc155
callq 0xc0cb
callq 0xc110
|
ggml_numa_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 1C8h
cmp cs:dword_17E270, 0
jnz loc_8DF9C
mov ecx, cs:dword_17E270
cmp ecx, 7
ja short loc_8DDDF
lea rbx, aSysDevicesSyst_0; "/sys/devices/system/node/node%u"
lea r14, [rsp+1F8h+var_138]
lea r15, [rsp+1F8h+var_1C8]
loc_8DD9E:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
xor eax, eax
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_8DFA8
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_8DDDF
mov ecx, cs:dword_17E270
inc ecx
mov cs:dword_17E270, ecx
cmp ecx, 8
jb short loc_8DD9E
loc_8DDDF:
mov ecx, cs:dword_17E274
cmp ecx, 1FFh
ja short loc_8DE45
lea rbx, aSysDevicesSyst_1; "/sys/devices/system/cpu/cpu%u"
lea r14, [rsp+1F8h+var_138]
lea r15, [rsp+1F8h+var_1C8]
loc_8DE01:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
xor eax, eax
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_8DFAD
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_8DE45
mov ecx, cs:dword_17E274
inc ecx
mov cs:dword_17E274, ecx
cmp ecx, 200h
jb short loc_8DE01
loc_8DE45:
cmp cs:dword_17E270, 0
jz loc_8DF80
cmp cs:dword_17E274, 0
jz loc_8DF80
cmp cs:dword_17E270, 0
jz loc_8DF8A
lea rbx, aSysDevicesSyst_2; "/sys/devices/system/node/node%u/cpu%u"
lea r14, [rsp+1F8h+var_138]
lea r15, [rsp+1F8h+var_1C8]
xor r12d, r12d
loc_8DE83:
mov rax, r12
shl rax, 0Bh
lea rax, [rax+r12*4]
lea rcx, g_state
mov dword ptr [rcx+rax+2000h], 0
cmp cs:dword_17E274, 0
jz short loc_8DF11
lea rcx, g_state
lea r13, [rcx+rax]
add r13, 1800h
xor ebp, ebp
loc_8DEBD:
mov esi, 100h
mov rdi, r14
mov rdx, rbx
mov ecx, r12d
mov r8d, ebp
xor eax, eax
call _snprintf
dec eax
cmp eax, 0FFh
jnb loc_8DFA3
mov rdi, r14
mov rsi, r15
call _stat
test eax, eax
jnz short loc_8DF07
mov eax, [r13+800h]
lea ecx, [rax+1]
mov [r13+800h], ecx
mov [r13+rax*4+0], ebp
loc_8DF07:
inc ebp
cmp ebp, cs:dword_17E274
jb short loc_8DEBD
loc_8DF11:
inc r12
mov eax, cs:dword_17E270
cmp r12, rax
jb loc_8DE83
cmp eax, 1
jbe short loc_8DF8A
lea rdi, aProcSysKernelN; "/proc/sys/kernel/numa_balancing"
lea rsi, aInvalidStringC_22+4Ch; "r"
call _fopen
test rax, rax
jz short loc_8DF8A
mov rbx, rax
mov rdi, rsp
mov esi, 2Ah ; '*'
mov rdx, rax
call _fgets
test rax, rax
jz short loc_8DF76
mov eax, 0A30h
xor eax, [rsp+1F8h+var_1F8]
movzx ecx, byte ptr [rsp+1F8h+var_1F8+2]
or cx, ax
jz short loc_8DF76
lea rdi, aWarningProcSys; "WARNING: /proc/sys/kernel/numa_balancin"...
call _puts
loc_8DF76:
mov rdi, rbx
call _fclose
jmp short loc_8DF8A
loc_8DF80:
mov cs:dword_17E270, 0
loc_8DF8A:
add rsp, 1C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8DF9C:
call ggml_numa_init_cold_1
jmp short loc_8DF8A
loc_8DFA3:
call ggml_numa_init_cold_4
loc_8DFA8:
call ggml_numa_init_cold_2
loc_8DFAD:
call ggml_numa_init_cold_3
|
long long ggml_numa_init()
{
unsigned int i; // ecx
long long result; // rax
unsigned int v2; // ecx
unsigned long long v3; // r12
unsigned int v4; // ebp
long long v5; // rax
long long v6; // rbx
unsigned __int16 v7; // [rsp+0h] [rbp-1F8h] BYREF
unsigned __int8 v8; // [rsp+2h] [rbp-1F6h]
_BYTE v9[144]; // [rsp+30h] [rbp-1C8h] BYREF
_BYTE v10[312]; // [rsp+C0h] [rbp-138h] BYREF
if ( dword_17E270 )
return ggml_numa_init_cold_1();
for ( i = 0; i < 8; dword_17E270 = i )
{
if ( (unsigned int)snprintf(v10, 256LL, "/sys/devices/system/node/node%u", i) - 1 >= 0xFF )
ggml_numa_init_cold_2();
result = stat(v10, v9);
if ( (_DWORD)result )
break;
i = dword_17E270 + 1;
}
v2 = dword_17E274;
if ( (unsigned int)dword_17E274 <= 0x1FF )
{
do
{
if ( (unsigned int)snprintf(v10, 256LL, "/sys/devices/system/cpu/cpu%u", v2) - 1 >= 0xFF )
ggml_numa_init_cold_3();
result = stat(v10, v9);
if ( (_DWORD)result )
break;
v2 = dword_17E274 + 1;
dword_17E274 = v2;
}
while ( v2 < 0x200 );
}
if ( dword_17E270 && dword_17E274 )
{
if ( dword_17E270 )
{
v3 = 0LL;
do
{
g_state[513 * v3 + 2048] = 0;
if ( dword_17E274 )
{
v4 = 0;
do
{
if ( (unsigned int)snprintf(v10, 256LL, "/sys/devices/system/node/node%u/cpu%u", v3, v4) - 1 >= 0xFF )
ggml_numa_init_cold_4();
if ( !(unsigned int)stat(v10, v9) )
{
v5 = g_state[513 * v3 + 2048];
g_state[513 * v3 + 2048] = v5 + 1;
g_state[513 * v3 + 1536 + v5] = v4;
}
++v4;
}
while ( v4 < dword_17E274 );
}
++v3;
result = (unsigned int)dword_17E270;
}
while ( v3 < (unsigned int)dword_17E270 );
if ( (unsigned int)dword_17E270 > 1 )
{
result = fopen("/proc/sys/kernel/numa_balancing", "r");
if ( result )
{
v6 = result;
if ( fgets(&v7, 42LL, result) )
{
if ( v7 ^ 0xA30 | v8 )
puts("WARNING: /proc/sys/kernel/numa_balancing is enabled, this has been observed to impair performance");
}
return fclose(v6);
}
}
}
}
else
{
dword_17E270 = 0;
}
return result;
}
|
End of preview. Expand
in Data Studio
This is the evaluation benchmark of LLM4Decompile project.
About
- Decompile-Bench-Eval includes manually crafted binaries from the well-established HumanEval and MBPP, alongside the compiled GitHub repositories released after 2025 to mitigate data leakage issues.
- C and C++ Support: These datasets include both C and C++ source code, whereas earlier models (LLM4Decompile-V1.5, V2) and the HumanEval-Decompile dataset were limited to C only.
Columns
It contains three splits, huameval, mbpp, and github2025. We also provide a json verison for the data. They contains the following columns:
{
"index":"index of the function",
"func_name":"demangled name for he function",
"func_dep":"function dependecies (includes, help functions), or the path to the source code",
"func":"source code",
"test":"unit tests for the function, empty for github data",
"opt":"optimization, O0, O1, O2, O3",
"language":"language, c or cpp",
"asm":"assembly",
"ida_asm":"assembly from ida pro",
"ida_pseudo":"decompiled results (pseudo code) from ida pro",
"ghidra_asm":"assembly from ghidra",
"ghidra_pseudo":"decompiled results (pseudo code) from ghidra"
}
Others
For more details, please check LLM4Decompile project.
- Downloads last month
- 154
Size of downloaded dataset files:
731 MB
Size of the auto-converted Parquet files:
230 MB
Number of rows:
75,610