Dataset Viewer
Auto-converted to Parquet
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.

Downloads last month
117

Collection including LLM4Binary/decompile-eval