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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
24,400 | my_uca_charcmp | eloqsql/strings/ctype-uca.c | static int my_uca_charcmp(CHARSET_INFO *cs, my_wc_t wc1, my_wc_t wc2)
{
uint num_level= cs->levels_for_order;
int ret;
uint i;
for (i= 0; i != num_level; i++)
{
ret= my_uca_charcmp_onelevel(cs, wc1, wc2, i);
if (ret) {
return ret;
}
}
return 0;
} | O3 | c | my_uca_charcmp:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movzbl 0xb2(%rdi), %eax
testq %rax, %rax
je 0x3b690
movq 0x60(%rdi), %r12
movl %esi, %edi
movq %rsi, %r8
shrq $0x8, %r8
movl $0xffffff, %r9d # imm = 0xFFFFFF
movq %r8, -0x78(%rbp)
andq %r9, %r8
movl $0xff, %ecx
movq %rsi, %r10
andq %rcx, %r10
movl %edx, %r11d
movq %rdx, %rbx
shrq $0x8, %rbx
movq %rbx, -0x70(%rbp)
andq %rbx, %r9
andq %rdx, %rcx
movq %rcx, -0x80(%rbp)
cmpq %rdx, %rsi
movl $0x0, %esi
setne %sil
imulq $0x38, %rax, %rdx
xorl %r13d, %r13d
movq %rdi, -0x68(%rbp)
movq %r9, -0x60(%rbp)
movq %r8, -0x58(%rbp)
movq %r10, -0x50(%rbp)
movq %r11, -0x48(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdx, -0x38(%rbp)
movq (%r12,%r13), %rax
cmpq %rdi, %rax
jb 0x3b56f
movq 0x10(%r12,%r13), %rcx
movq (%rcx,%r8,8), %rcx
testq %rcx, %rcx
je 0x3b56f
movq 0x8(%r12,%r13), %rdx
movzbl (%rdx,%r8), %edx
imull %r10d, %edx
leaq (%rcx,%rdx,2), %r14
movq -0x38(%rbp), %rdx
jmp 0x3b572
xorl %r14d, %r14d
movl %esi, %ebx
cmpq %r11, %rax
jb 0x3b67f
movq 0x10(%r12,%r13), %rax
movq (%rax,%r9,8), %rax
movl %esi, %ebx
testq %rax, %rax
je 0x3b67f
movl %esi, %ebx
testq %r14, %r14
je 0x3b67f
movq 0x8(%r12,%r13), %rcx
movzbl (%rcx,%r9), %edx
imull -0x80(%rbp), %edx
leaq (%rax,%rdx,2), %r15
movzwl (%r14), %eax
movl $0x1, %ebx
cmpw (%r15), %ax
jne 0x3b692
movq -0x78(%rbp), %rax
movzbl (%rcx,%rax), %esi
movq -0x70(%rbp), %rax
movzbl (%rcx,%rax), %eax
cmpb %al, %sil
jbe 0x3b616
movq %rax, -0x40(%rbp)
leal (%rax,%rax), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x242d0
movl -0x2c(%rbp), %esi
movq -0x48(%rbp), %r11
movq -0x50(%rbp), %r10
movq -0x58(%rbp), %r8
movq -0x60(%rbp), %r9
movq -0x68(%rbp), %rdi
testl %eax, %eax
movq -0x38(%rbp), %rdx
jne 0x3b692
movq -0x40(%rbp), %rax
movzwl (%r14,%rax,2), %ebx
jmp 0x3b67f
leal (%rsi,%rsi), %edx
cmpb %al, %sil
jae 0x3b657
movq %rsi, -0x40(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x242d0
testl %eax, %eax
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %r9
movq -0x58(%rbp), %r8
movq -0x50(%rbp), %r10
movq -0x48(%rbp), %r11
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
jne 0x3b692
movq -0x40(%rbp), %rax
movzwl (%r15,%rax,2), %ebx
jmp 0x3b67f
movq %r14, %rdi
movq %r15, %rsi
callq 0x24130
movl %eax, %ebx
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %r9
movq -0x58(%rbp), %r8
movq -0x50(%rbp), %r10
movq -0x48(%rbp), %r11
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
testl %ebx, %ebx
jne 0x3b692
addq $0x38, %r13
cmpq %r13, %rdx
jne 0x3b540
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_uca_charcmp:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
movzx eax, byte ptr [rdi+0B2h]
test rax, rax
jz loc_3B690
mov r12, [rdi+60h]
mov edi, esi
mov r8, rsi
shr r8, 8
mov r9d, 0FFFFFFh
mov [rbp+var_78], r8
and r8, r9
mov ecx, 0FFh
mov r10, rsi
and r10, rcx
mov r11d, edx
mov rbx, rdx
shr rbx, 8
mov [rbp+var_70], rbx
and r9, rbx
and rcx, rdx
mov [rbp+var_80], rcx
cmp rsi, rdx
mov esi, 0
setnz sil
imul rdx, rax, 38h ; '8'
xor r13d, r13d
mov [rbp+var_68], rdi
mov [rbp+var_60], r9
mov [rbp+var_58], r8
mov [rbp+var_50], r10
mov [rbp+var_48], r11
mov [rbp+var_2C], esi
mov [rbp+var_38], rdx
loc_3B540:
mov rax, [r12+r13]
cmp rax, rdi
jb short loc_3B56F
mov rcx, [r12+r13+10h]
mov rcx, [rcx+r8*8]
test rcx, rcx
jz short loc_3B56F
mov rdx, [r12+r13+8]
movzx edx, byte ptr [rdx+r8]
imul edx, r10d
lea r14, [rcx+rdx*2]
mov rdx, [rbp+var_38]
jmp short loc_3B572
loc_3B56F:
xor r14d, r14d
loc_3B572:
mov ebx, esi
cmp rax, r11
jb loc_3B67F
mov rax, [r12+r13+10h]
mov rax, [rax+r9*8]
mov ebx, esi
test rax, rax
jz loc_3B67F
mov ebx, esi
test r14, r14
jz loc_3B67F
mov rcx, [r12+r13+8]
movzx edx, byte ptr [rcx+r9]
imul edx, dword ptr [rbp+var_80]
lea r15, [rax+rdx*2]
movzx eax, word ptr [r14]
mov ebx, 1
cmp ax, [r15]
jnz loc_3B692
mov rax, [rbp+var_78]
movzx esi, byte ptr [rcx+rax]
mov rax, [rbp+var_70]
movzx eax, byte ptr [rcx+rax]
cmp sil, al
jbe short loc_3B616
mov [rbp+var_40], rax
lea edx, [rax+rax]
mov rdi, r14
mov rsi, r15
call _bcmp
mov esi, [rbp+var_2C]
mov r11, [rbp+var_48]
mov r10, [rbp+var_50]
mov r8, [rbp+var_58]
mov r9, [rbp+var_60]
mov rdi, [rbp+var_68]
test eax, eax
mov rdx, [rbp+var_38]
jnz loc_3B692
mov rax, [rbp+var_40]
movzx ebx, word ptr [r14+rax*2]
jmp short loc_3B67F
loc_3B616:
lea edx, [rsi+rsi]
cmp sil, al
jnb short loc_3B657
mov [rbp+var_40], rsi
mov rdi, r14
mov rsi, r15
call _bcmp
test eax, eax
mov rdi, [rbp+var_68]
mov r9, [rbp+var_60]
mov r8, [rbp+var_58]
mov r10, [rbp+var_50]
mov r11, [rbp+var_48]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_38]
jnz short loc_3B692
mov rax, [rbp+var_40]
movzx ebx, word ptr [r15+rax*2]
jmp short loc_3B67F
loc_3B657:
mov rdi, r14
mov rsi, r15
call _memcmp
mov ebx, eax
mov rdi, [rbp+var_68]
mov r9, [rbp+var_60]
mov r8, [rbp+var_58]
mov r10, [rbp+var_50]
mov r11, [rbp+var_48]
mov esi, [rbp+var_2C]
mov rdx, [rbp+var_38]
loc_3B67F:
test ebx, ebx
jnz short loc_3B692
add r13, 38h ; '8'
cmp rdx, r13
jnz loc_3B540
loc_3B690:
xor ebx, ebx
loc_3B692:
mov eax, ebx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_uca_charcmp(long long a1, unsigned long long a2, unsigned long long a3)
{
long long v3; // rax
long long v4; // r12
unsigned long long v5; // rdi
long long v6; // r8
int v7; // r10d
unsigned long long v8; // r11
long long v9; // r9
BOOL v10; // esi
long long v11; // rdx
long long v12; // r13
unsigned long long v13; // rax
long long v14; // rcx
_WORD *v15; // r14
unsigned int v16; // ebx
long long v17; // rax
long long v18; // rcx
_WORD *v19; // r15
int v20; // esi
int v21; // eax
int v22; // eax
long long v23; // rdx
int v24; // eax
int v26; // [rsp+0h] [rbp-80h]
unsigned long long v27; // [rsp+8h] [rbp-78h]
unsigned long long v28; // [rsp+10h] [rbp-70h]
unsigned long long v29; // [rsp+18h] [rbp-68h]
long long v30; // [rsp+20h] [rbp-60h]
long long v31; // [rsp+28h] [rbp-58h]
int v32; // [rsp+30h] [rbp-50h]
unsigned long long v33; // [rsp+38h] [rbp-48h]
long long v34; // [rsp+40h] [rbp-40h]
long long v35; // [rsp+40h] [rbp-40h]
long long v36; // [rsp+48h] [rbp-38h]
BOOL v37; // [rsp+54h] [rbp-2Ch]
v3 = *(unsigned __int8 *)(a1 + 178);
if ( *(_BYTE *)(a1 + 178) )
{
v4 = *(_QWORD *)(a1 + 96);
v5 = (unsigned int)a2;
v27 = a2 >> 8;
v6 = (unsigned int)a2 >> 8;
v7 = (unsigned __int8)a2;
v8 = (unsigned int)a3;
v28 = a3 >> 8;
v9 = (unsigned int)a3 >> 8;
v26 = (unsigned __int8)a3;
v10 = a2 != a3;
v11 = 56 * v3;
v12 = 0LL;
v29 = v5;
v30 = v9;
v31 = v6;
v32 = v7;
v33 = v8;
v37 = v10;
v36 = 56 * v3;
while ( 1 )
{
v13 = *(_QWORD *)(v4 + v12);
if ( v13 >= v5 && (v14 = *(_QWORD *)(*(_QWORD *)(v4 + v12 + 16) + 8 * v6)) != 0 )
{
v15 = (_WORD *)(v14 + 2LL * v7 * (unsigned int)*(unsigned __int8 *)(*(_QWORD *)(v4 + v12 + 8) + v6));
v11 = v36;
}
else
{
v15 = 0LL;
}
v16 = v10;
if ( v13 >= v8 )
{
v17 = *(_QWORD *)(*(_QWORD *)(v4 + v12 + 16) + 8 * v9);
v16 = v10;
if ( v17 )
{
v16 = v10;
if ( v15 )
{
v18 = *(_QWORD *)(v4 + v12 + 8);
v19 = (_WORD *)(v17 + 2LL * v26 * (unsigned int)*(unsigned __int8 *)(v18 + v9));
v16 = 1;
if ( *v15 != *v19 )
return v16;
v20 = *(unsigned __int8 *)(v18 + v27);
v21 = *(unsigned __int8 *)(v18 + v28);
if ( (unsigned __int8)v20 <= (unsigned __int8)v21 )
{
v23 = (unsigned int)(2 * v20);
if ( (unsigned __int8)v20 >= (unsigned __int8)v21 )
{
v16 = memcmp(v15, v19, v23);
v5 = v29;
v9 = v30;
v6 = v31;
v7 = v32;
v8 = v33;
v10 = v37;
v11 = v36;
}
else
{
v35 = *(unsigned __int8 *)(v18 + v27);
v24 = bcmp(v15, v19, v23);
v5 = v29;
v9 = v30;
v6 = v31;
v7 = v32;
v8 = v33;
v10 = v37;
v11 = v36;
if ( v24 )
return v16;
v16 = (unsigned __int16)v19[v35];
}
}
else
{
v34 = *(unsigned __int8 *)(v18 + v28);
v22 = bcmp(v15, v19, (unsigned int)(2 * v21));
v10 = v37;
v8 = v33;
v7 = v32;
v6 = v31;
v9 = v30;
v5 = v29;
v11 = v36;
if ( v22 )
return v16;
v16 = (unsigned __int16)v15[v34];
}
}
}
}
if ( v16 )
break;
v12 += 56LL;
if ( v11 == v12 )
return 0;
}
}
else
{
return 0;
}
return v16;
}
| my_uca_charcmp:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOVZX EAX,byte ptr [RDI + 0xb2]
TEST RAX,RAX
JZ 0x0013b690
MOV R12,qword ptr [RDI + 0x60]
MOV EDI,ESI
MOV R8,RSI
SHR R8,0x8
MOV R9D,0xffffff
MOV qword ptr [RBP + -0x78],R8
AND R8,R9
MOV ECX,0xff
MOV R10,RSI
AND R10,RCX
MOV R11D,EDX
MOV RBX,RDX
SHR RBX,0x8
MOV qword ptr [RBP + -0x70],RBX
AND R9,RBX
AND RCX,RDX
MOV qword ptr [RBP + -0x80],RCX
CMP RSI,RDX
MOV ESI,0x0
SETNZ SIL
IMUL RDX,RAX,0x38
XOR R13D,R13D
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x60],R9
MOV qword ptr [RBP + -0x58],R8
MOV qword ptr [RBP + -0x50],R10
MOV qword ptr [RBP + -0x48],R11
MOV dword ptr [RBP + -0x2c],ESI
MOV qword ptr [RBP + -0x38],RDX
LAB_0013b540:
MOV RAX,qword ptr [R12 + R13*0x1]
CMP RAX,RDI
JC 0x0013b56f
MOV RCX,qword ptr [R12 + R13*0x1 + 0x10]
MOV RCX,qword ptr [RCX + R8*0x8]
TEST RCX,RCX
JZ 0x0013b56f
MOV RDX,qword ptr [R12 + R13*0x1 + 0x8]
MOVZX EDX,byte ptr [RDX + R8*0x1]
IMUL EDX,R10D
LEA R14,[RCX + RDX*0x2]
MOV RDX,qword ptr [RBP + -0x38]
JMP 0x0013b572
LAB_0013b56f:
XOR R14D,R14D
LAB_0013b572:
MOV EBX,ESI
CMP RAX,R11
JC 0x0013b67f
MOV RAX,qword ptr [R12 + R13*0x1 + 0x10]
MOV RAX,qword ptr [RAX + R9*0x8]
MOV EBX,ESI
TEST RAX,RAX
JZ 0x0013b67f
MOV EBX,ESI
TEST R14,R14
JZ 0x0013b67f
MOV RCX,qword ptr [R12 + R13*0x1 + 0x8]
MOVZX EDX,byte ptr [RCX + R9*0x1]
IMUL EDX,dword ptr [RBP + -0x80]
LEA R15,[RAX + RDX*0x2]
MOVZX EAX,word ptr [R14]
MOV EBX,0x1
CMP AX,word ptr [R15]
JNZ 0x0013b692
MOV RAX,qword ptr [RBP + -0x78]
MOVZX ESI,byte ptr [RCX + RAX*0x1]
MOV RAX,qword ptr [RBP + -0x70]
MOVZX EAX,byte ptr [RCX + RAX*0x1]
CMP SIL,AL
JBE 0x0013b616
MOV qword ptr [RBP + -0x40],RAX
LEA EDX,[RAX + RAX*0x1]
MOV RDI,R14
MOV RSI,R15
CALL 0x001242d0
MOV ESI,dword ptr [RBP + -0x2c]
MOV R11,qword ptr [RBP + -0x48]
MOV R10,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RBP + -0x68]
TEST EAX,EAX
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0013b692
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EBX,word ptr [R14 + RAX*0x2]
JMP 0x0013b67f
LAB_0013b616:
LEA EDX,[RSI + RSI*0x1]
CMP SIL,AL
JNC 0x0013b657
MOV qword ptr [RBP + -0x40],RSI
MOV RDI,R14
MOV RSI,R15
CALL 0x001242d0
TEST EAX,EAX
MOV RDI,qword ptr [RBP + -0x68]
MOV R9,qword ptr [RBP + -0x60]
MOV R8,qword ptr [RBP + -0x58]
MOV R10,qword ptr [RBP + -0x50]
MOV R11,qword ptr [RBP + -0x48]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0013b692
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EBX,word ptr [R15 + RAX*0x2]
JMP 0x0013b67f
LAB_0013b657:
MOV RDI,R14
MOV RSI,R15
CALL 0x00124130
MOV EBX,EAX
MOV RDI,qword ptr [RBP + -0x68]
MOV R9,qword ptr [RBP + -0x60]
MOV R8,qword ptr [RBP + -0x58]
MOV R10,qword ptr [RBP + -0x50]
MOV R11,qword ptr [RBP + -0x48]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x38]
LAB_0013b67f:
TEST EBX,EBX
JNZ 0x0013b692
ADD R13,0x38
CMP RDX,R13
JNZ 0x0013b540
LAB_0013b690:
XOR EBX,EBX
LAB_0013b692:
MOV EAX,EBX
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint my_uca_charcmp(long param_1,ulong param_2,ulong param_3)
{
short *__s2;
byte bVar1;
byte bVar2;
byte bVar3;
long lVar4;
long lVar5;
long lVar6;
int iVar7;
uint uVar8;
ulong uVar9;
ulong uVar10;
long lVar11;
short *__s1;
uint local_88;
bVar1 = *(byte *)(param_1 + 0xb2);
if ((ulong)bVar1 != 0) {
lVar4 = *(long *)(param_1 + 0x60);
uVar9 = param_2 >> 8 & 0xffffff;
uVar10 = param_3 >> 8 & 0xffffff;
local_88 = (uint)param_3 & 0xff;
lVar11 = 0;
do {
uVar8 = (uint)(param_2 != param_3);
if ((*(ulong *)(lVar4 + lVar11) < (param_2 & 0xffffffff)) ||
(lVar5 = *(long *)(*(long *)(lVar4 + 0x10 + lVar11) + uVar9 * 8), lVar5 == 0)) {
__s1 = (short *)0x0;
}
else {
__s1 = (short *)(lVar5 + (ulong)((uint)*(byte *)(*(long *)(lVar4 + 8 + lVar11) + uVar9) *
((uint)param_2 & 0xff)) * 2);
}
if ((((param_3 & 0xffffffff) <= *(ulong *)(lVar4 + lVar11)) &&
(lVar5 = *(long *)(*(long *)(lVar4 + 0x10 + lVar11) + uVar10 * 8), lVar5 != 0)) &&
(__s1 != (short *)0x0)) {
lVar6 = *(long *)(lVar4 + 8 + lVar11);
__s2 = (short *)(lVar5 + (ulong)(*(byte *)(lVar6 + uVar10) * local_88) * 2);
if (*__s1 != *__s2) {
return 1;
}
bVar2 = *(byte *)(lVar6 + (param_2 >> 8));
bVar3 = *(byte *)(lVar6 + (param_3 >> 8));
if (bVar3 < bVar2) {
iVar7 = bcmp(__s1,__s2,(ulong)((uint)bVar3 + (uint)bVar3));
if (iVar7 != 0) {
return 1;
}
uVar8 = (uint)(ushort)__s1[bVar3];
}
else if (bVar2 < bVar3) {
iVar7 = bcmp(__s1,__s2,(ulong)((uint)bVar2 + (uint)bVar2));
if (iVar7 != 0) {
return 1;
}
uVar8 = (uint)(ushort)__s2[bVar2];
}
else {
uVar8 = memcmp(__s1,__s2,(ulong)((uint)bVar2 + (uint)bVar2));
}
}
if (uVar8 != 0) {
return uVar8;
}
lVar11 = lVar11 + 0x38;
} while ((ulong)bVar1 * 0x38 != lVar11);
}
return 0;
}
| |
24,401 | js_object_getPrototypeOf | bluesky950520[P]quickjs/quickjs.c | static JSValue js_object_getPrototypeOf(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue val;
val = argv[0];
if (JS_VALUE_GET_TAG(val) != JS_TAG_OBJECT) {
/* ES6 feature non compatible with ES5.1: primitive types are
accepted */
if (magic || JS_VALUE_GET_TAG(val) == JS_TAG_NULL ||
JS_VALUE_GET_TAG(val) == JS_TAG_UNDEFINED)
return JS_ThrowTypeErrorNotAnObject(ctx);
}
return JS_GetPrototype(ctx, val);
} | O3 | c | js_object_getPrototypeOf:
pushq %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
cmpl $-0x1, %edx
je 0x7159b
testl %r9d, %r9d
sete %al
movl %edx, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
setne %cl
testb %cl, %al
jne 0x7159b
leaq 0x2f362(%rip), %rsi # 0xa08ed
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2214f
movl $0x6, %edx
jmp 0x715a3
callq 0x2246a
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
| js_object_getPrototypeOf:
push rbx
mov rsi, [r8]
mov rdx, [r8+8]
cmp edx, 0FFFFFFFFh
jz short loc_7159B
test r9d, r9d
setz al
mov ecx, edx
and ecx, 0FFFFFFFEh
cmp ecx, 2
setnz cl
test al, cl
jnz short loc_7159B
lea rsi, aOperandPrototy+20h; "not an object"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
jmp short loc_715A3
loc_7159B:
call JS_GetPrototype
mov rbx, rax
loc_715A3:
mov rax, rbx
pop rbx
retn
| unsigned long long js_object_getPrototypeOf(
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; // rdx
long long v15; // rcx
long long v16; // rbx
char v18; // [rsp+0h] [rbp-8h]
v14 = a13[1];
if ( (_DWORD)v14 == -1 )
return JS_GetPrototype(a1, *a13, v14);
v15 = a13[1] & 0xFFFFFFFELL;
LOBYTE(v15) = (_DWORD)v15 != 2;
if ( ((unsigned __int8)v15 & ((_DWORD)a14 == 0)) != 0 )
return JS_GetPrototype(a1, *a13, v14);
v16 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", v14, v15, (long long)a13, a14, a2, a3, a4, a5, a6, a7, a8, a9, v18);
return v16;
}
| js_object_getPrototypeOf:
PUSH RBX
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,-0x1
JZ 0x0017159b
TEST R9D,R9D
SETZ AL
MOV ECX,EDX
AND ECX,0xfffffffe
CMP ECX,0x2
SETNZ CL
TEST AL,CL
JNZ 0x0017159b
LEA RSI,[0x1a08ed]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x0012214f
MOV EDX,0x6
JMP 0x001715a3
LAB_0017159b:
CALL 0x0012246a
MOV RBX,RAX
LAB_001715a3:
MOV RAX,RBX
POP RBX
RET
|
int8 js_object_getPrototypeOf(int8 param_1)
{
int8 uVar1;
int8 *in_R8;
int in_R9D;
if (((uint)in_R8[1] == 0xffffffff) || (in_R9D == 0 && ((uint)in_R8[1] & 0xfffffffe) != 2)) {
uVar1 = JS_GetPrototype(param_1,*in_R8);
}
else {
uVar1 = 0;
JS_ThrowTypeError(param_1,"not an object");
}
return uVar1;
}
| |
24,402 | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | std::vector<std::string> string_split(const std::string & str, const std::string & delimiter) {
std::vector<std::string> parts;
size_t start = 0;
size_t end = str.find(delimiter);
while (end != std::string::npos) {
parts.push_back(str.substr(start, end - start));
start = end + delimiter.length();
end = str.find(delimiter, start);
}
parts.push_back(str.substr(start));
return parts;
} | O3 | cpp | string_split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x1bf20
cmpq $-0x1, %rax
je 0x7230e
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1b900
movq %rbx, %rdi
movq %r13, %rsi
callq 0x557d6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x722ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x1bf20
movq %rax, %r12
cmpq $-0x1, %rax
jne 0x722b2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x1b900
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x557d6
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7234d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x72381
jmp 0x7236f
movq %rax, %r14
jmp 0x72393
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x72393
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1b8b0
movq %rbx, %rdi
callq 0x2171e
movq %r14, %rdi
callq 0x1bf70
| _Z12string_splitRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES6_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebp, ebp
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_7230E
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_722B2:
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_722ED
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_722ED:
mov rsi, [r15]
mov rcx, [r15+8]
mov rbp, r12
add rbp, rcx
mov rdi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r12, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_722B2
loc_7230E:
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, rbp
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7234D
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7234D:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
jmp short loc_72381
jmp short $+2
loc_7236F:
mov r14, rax
jmp short loc_72393
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_72381:
cmp rdi, rax
jz short loc_72393
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_72393:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long string_split(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // r12
long long v7; // rcx
void *v9[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v10[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
v5 = std::string::find(a2, *a3, 0LL, a3[1]);
if ( v5 != -1 )
{
v6 = v5;
v4 = 0LL;
do
{
std::string::substr(v9, a2, v4, v6 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
v7 = a3[1];
v4 = v7 + v6;
v6 = std::string::find(a2, *a3, v7 + v6, v7);
}
while ( v6 != -1 );
}
std::string::substr(v9, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, (long long)v9);
if ( v9[0] != v10 )
operator delete(v9[0], v10[0] + 1LL);
return a1;
}
| string_split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBP,EBP
MOV RDI,R14
XOR EDX,EDX
CALL 0x0011bf20
CMP RAX,-0x1
JZ 0x0017230e
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_001722b2:
MOV RCX,R12
SUB RCX,RBP
LAB_001722b8:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x0011b900
LAB_001722c6:
MOV RDI,RBX
MOV RSI,R13
CALL 0x001557d6
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001722ed
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8b0
LAB_001722ed:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x0011bf20
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x001722b2
LAB_0017230e:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x0011b900
LAB_00172325:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x001557d6
LAB_00172332:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017234d
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011b8b0
LAB_0017234d:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* string_split(std::__cxx11::string const&, std::__cxx11::string const&) */
string * string_split(string *param_1,string *param_2)
{
long lVar1;
ulong *in_RDX;
long *local_50 [2];
long local_40 [2];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,0);
if (lVar1 != -1) {
do {
/* try { // try from 001722b8 to 001722c5 has its CatchHandler @ 0017236f */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 001722c6 to 001722d0 has its CatchHandler @ 00172374 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = std::__cxx11::string::find((char *)param_2,*in_RDX,lVar1 + in_RDX[1]);
} while (lVar1 != -1);
}
/* try { // try from 0017230e to 00172324 has its CatchHandler @ 0017236d */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_2);
/* try { // try from 00172325 to 00172331 has its CatchHandler @ 0017235f */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)param_1,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return param_1;
}
| |
24,403 | coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l>>) | AlayaLite/build_O3/_deps/libcoro-src/src/io_scheduler.cpp | auto io_scheduler::process_events_execute(std::chrono::milliseconds timeout) -> void
{
auto event_count = epoll_wait(m_epoll_fd, m_events.data(), m_max_events, timeout.count());
if (event_count > 0)
{
for (std::size_t i = 0; i < static_cast<std::size_t>(event_count); ++i)
{
epoll_event& event = m_events[i];
void* handle_ptr = event.data.ptr;
if (handle_ptr == m_timer_ptr)
{
// Process all events that have timed out.
process_timeout_execute();
}
else if (handle_ptr == m_schedule_ptr)
{
// Process scheduled coroutines.
process_scheduled_execute_inline();
}
else if (handle_ptr == m_shutdown_ptr) [[unlikely]]
{
// Nothing to do , just needed to wake-up and smell the flowers
}
else
{
// Individual poll task wake-up.
process_event_execute(static_cast<detail::poll_info*>(handle_ptr), event_to_poll_status(event.events));
}
}
}
// Its important to not resume any handles until the full set is accounted for. If a timeout
// and an event for the same handle happen in the same epoll_wait() call then inline processing
// will destruct the poll_info object before the second event is handled. This is also possible
// with thread pool processing, but probably has an extremely low chance of occuring due to
// the thread switch required. If m_max_events == 1 this would be unnecessary.
if (!m_handles_to_resume.empty())
{
if (m_opts.execution_strategy == execution_strategy_t::process_tasks_inline)
{
for (auto& handle : m_handles_to_resume)
{
handle.resume();
}
}
else
{
m_thread_pool->resume(m_handles_to_resume);
}
m_handles_to_resume.clear();
}
} | O3 | cpp | coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l>>):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rcx
movq %rdi, %rbx
movl 0xa8(%rdi), %edi
leaq 0x178(%rbx), %r14
movq %r14, %rsi
movl $0x10, %edx
callq 0x3100
testl %eax, %eax
jg 0x65fb
movq 0x238(%rbx), %r14
movq 0x240(%rbx), %r15
cmpq %r15, %r14
je 0x65f5
cmpl $0x1, 0xa0(%rbx)
jne 0x65cb
movq (%r14), %rdi
callq *(%rdi)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x65bb
jmp 0x65de
leaq 0x238(%rbx), %rsi
movq 0xd0(%rbx), %rdi
callq 0x7398
movq 0x238(%rbx), %rax
cmpq %rax, 0x240(%rbx)
je 0x65f5
movq %rax, 0x240(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x34a6
jmp 0x659f
| _ZN4coro12io_scheduler22process_events_executeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE:
push r15
push r14
push rbx
mov rcx, rsi
mov rbx, rdi
mov edi, [rdi+0A8h]
lea r14, [rbx+178h]
mov rsi, r14
mov edx, 10h
call _epoll_wait
test eax, eax
jg short loc_65FB
loc_659F:
mov r14, [rbx+238h]
mov r15, [rbx+240h]
cmp r14, r15
jz short loc_65F5
cmp dword ptr [rbx+0A0h], 1
jnz short loc_65CB
loc_65BB:
mov rdi, [r14]
call qword ptr [rdi]
add r14, 8
cmp r14, r15
jnz short loc_65BB
jmp short loc_65DE
loc_65CB:
lea rsi, [rbx+238h]
mov rdi, [rbx+0D0h]
call _ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_
loc_65DE:
mov rax, [rbx+238h]
cmp [rbx+240h], rax
jz short loc_65F5
mov [rbx+240h], rax
loc_65F5:
pop rbx
pop r14
pop r15
retn
loc_65FB:
mov edi, eax
mov rsi, rbx
mov rdx, r14
call _ZN4coro12io_scheduler22process_events_executeENSt6chrono8durationIlSt5ratioILl1ELl1000EEEE_cold_1; coro::io_scheduler::process_events_execute(std::chrono::duration<long,std::ratio<1l,1000l>>) [clone]
jmp short loc_659F
| long long coro::io_scheduler::process_events_execute(long long a1, long long a2)
{
long long result; // rax
void (***v3)(void); // r14
void (***v4)(void); // r15
result = epoll_wait(*(unsigned int *)(a1 + 168), a1 + 376, 16LL, a2);
if ( (int)result > 0 )
result = coro::io_scheduler::process_events_execute(result, (coro::io_scheduler *)a1, a1 + 376);
v3 = *(void (****)(void))(a1 + 568);
v4 = *(void (****)(void))(a1 + 576);
if ( v3 != v4 )
{
if ( *(_DWORD *)(a1 + 160) == 1 )
{
do
(**v3++)();
while ( v3 != v4 );
}
else
{
ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_(
*(_QWORD *)(a1 + 208),
a1 + 568);
}
result = *(_QWORD *)(a1 + 568);
if ( *(_QWORD *)(a1 + 576) != result )
*(_QWORD *)(a1 + 576) = result;
}
return result;
}
| process_events_execute:
PUSH R15
PUSH R14
PUSH RBX
MOV RCX,RSI
MOV RBX,RDI
MOV EDI,dword ptr [RDI + 0xa8]
LEA R14,[RBX + 0x178]
MOV RSI,R14
MOV EDX,0x10
CALL 0x00103100
TEST EAX,EAX
JG 0x001065fb
LAB_0010659f:
MOV R14,qword ptr [RBX + 0x238]
MOV R15,qword ptr [RBX + 0x240]
CMP R14,R15
JZ 0x001065f5
CMP dword ptr [RBX + 0xa0],0x1
JNZ 0x001065cb
LAB_001065bb:
MOV RDI,qword ptr [R14]
CALL qword ptr [RDI]
ADD R14,0x8
CMP R14,R15
JNZ 0x001065bb
JMP 0x001065de
LAB_001065cb:
LEA RSI,[RBX + 0x238]
MOV RDI,qword ptr [RBX + 0xd0]
CALL 0x00107398
LAB_001065de:
MOV RAX,qword ptr [RBX + 0x238]
CMP qword ptr [RBX + 0x240],RAX
JZ 0x001065f5
MOV qword ptr [RBX + 0x240],RAX
LAB_001065f5:
POP RBX
POP R14
POP R15
RET
LAB_001065fb:
MOV EDI,EAX
MOV RSI,RBX
MOV RDX,R14
CALL 0x001034a6
JMP 0x0010659f
|
/* coro::io_scheduler::process_events_execute(std::chrono::duration<long, std::ratio<1l, 1000l> >)
*/
void __thiscall coro::io_scheduler::process_events_execute(io_scheduler *this,int param_2)
{
int8 *puVar1;
int iVar2;
int8 *puVar3;
iVar2 = epoll_wait(*(int *)(this + 0xa8),(epoll_event *)(this + 0x178),0x10,param_2);
if (0 < iVar2) {
process_events_execute(iVar2,this,(epoll_event *)(this + 0x178));
}
puVar3 = *(int8 **)(this + 0x238);
puVar1 = *(int8 **)(this + 0x240);
if (puVar3 != puVar1) {
if (*(int *)(this + 0xa0) == 1) {
do {
(**(code **)*puVar3)();
puVar3 = puVar3 + 1;
} while (puVar3 != puVar1);
}
else {
_ZN4coro11thread_pool6resumeITkNS_8concepts8range_ofINSt7__n486116coroutine_handleIvEEEESt6vectorIS6_SaIS6_EEEEmRKT_
(*(int8 *)(this + 0xd0),this + 0x238);
}
if (*(long *)(this + 0x240) != *(long *)(this + 0x238)) {
*(long *)(this + 0x240) = *(long *)(this + 0x238);
}
}
return;
}
| |
24,404 | my_hrtime | eloqsql/mysys/my_getsystime.c | my_hrtime_t my_hrtime()
{
my_hrtime_t hrtime;
#if defined(_WIN32)
ulonglong newtime;
GetSystemTimePreciseAsFileTime((FILETIME*)&newtime);
hrtime.val= (newtime - OFFSET_TO_EPOC)/10;
#elif defined(HAVE_CLOCK_GETTIME)
struct timespec tp;
clock_gettime(CLOCK_REALTIME, &tp);
hrtime.val= tp.tv_sec*1000000ULL+tp.tv_nsec/1000ULL;
#else
struct timeval t;
/* The following loop is here because gettimeofday may fail */
while (gettimeofday(&t, NULL) != 0) {}
hrtime.val= t.tv_sec*1000000ULL + t.tv_usec;
#endif
DBUG_EXECUTE_IF("system_time_plus_one_hour", hrtime.val += 3600*1000000ULL;);
DBUG_EXECUTE_IF("system_time_minus_one_hour", hrtime.val -= 3600*1000000ULL;);
return hrtime;
} | O3 | c | my_hrtime:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x18(%rbp), %rbx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x24290
imulq $0xf4240, (%rbx), %rcx # imm = 0xF4240
movq 0x8(%rbx), %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rdx # imm = 0x20C49BA5E353F7CF
mulq %rdx
shrq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
| my_hrtime:
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
lea rbx, [rbp+var_18]
xor edi, edi
mov rsi, rbx
call _clock_gettime
imul rcx, [rbx], 0F4240h
mov rax, [rbx+8]
shr rax, 3
mov rdx, 20C49BA5E353F7CFh
mul rdx
shr rdx, 4
add rcx, rdx
mov rax, rcx
add rsp, 18h
pop rbx
pop rbp
retn
| unsigned long long my_hrtime()
{
long long v1; // [rsp+8h] [rbp-18h] BYREF
unsigned long long v2; // [rsp+10h] [rbp-10h]
clock_gettime(0LL, &v1);
return v2 / 0x3E8 + 1000000 * v1;
}
| my_hrtime:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
LEA RBX,[RBP + -0x18]
XOR EDI,EDI
MOV RSI,RBX
CALL 0x00124290
IMUL RCX,qword ptr [RBX],0xf4240
MOV RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV RDX,0x20c49ba5e353f7cf
MUL RDX
SHR RDX,0x4
ADD RCX,RDX
MOV RAX,RCX
ADD RSP,0x18
POP RBX
POP RBP
RET
|
long my_hrtime(void)
{
timespec local_20;
clock_gettime(0,&local_20);
return local_20.tv_sec * 1000000 + (ulong)local_20.tv_nsec / 1000;
}
| |
24,405 | my_free | eloqsql/mysys/my_malloc.c | void my_free(void *ptr)
{
my_memory_header *mh;
size_t old_size;
my_bool old_flags;
DBUG_ENTER("my_free");
DBUG_PRINT("my",("ptr: %p", ptr));
if (ptr == NULL)
DBUG_VOID_RETURN;
mh= USER_TO_HEADER(ptr);
old_size= mh->m_size & ~1;
old_flags= mh->m_size & 1;
PSI_CALL_memory_free(mh->m_key, old_size, mh->m_owner);
update_malloc_size(- (longlong) old_size - HEADER_SIZE, old_flags);
#ifndef SAFEMALLOC
/*
Trash memory if not safemalloc. We don't have to do this if safemalloc
is used as safemalloc will also do trashing
*/
TRASH_FREE(ptr, old_size);
#endif
sf_free(mh);
DBUG_VOID_RETURN;
} | O0 | c | my_free:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2f35e
cmpq $0x0, -0x8(%rbp)
jne 0x2f369
jmp 0x2f367
jmp 0x2f3e3
movq -0x8(%rbp), %rax
addq $-0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $-0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x1, %rax
movb %al, -0x19(%rbp)
leaq 0x19e68d(%rip), %rax # 0x1cda28
movq (%rax), %rax
movq 0x3f8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %edi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
callq *%rax
movq 0x19e7d8(%rip), %rax # 0x1cdb98
xorl %ecx, %ecx
movl %ecx, %edi
subq -0x18(%rbp), %rdi
subq $0x18, %rdi
movsbl -0x19(%rbp), %esi
callq *%rax
jmp 0x2f3d4
jmp 0x2f3d6
jmp 0x2f3d8
movq -0x10(%rbp), %rdi
callq 0x24350
jmp 0x2f3e3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| my_free:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
jmp short $+2
loc_2F35E:
cmp [rbp+var_8], 0
jnz short loc_2F369
jmp short $+2
loc_2F367:
jmp short loc_2F3E3
loc_2F369:
mov rax, [rbp+var_8]
add rax, 0FFFFFFFFFFFFFFE8h
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
and rax, 0FFFFFFFFFFFFFFFEh
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
and rax, 1
mov [rbp+var_19], al
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+3F8h]
mov rcx, [rbp+var_10]
mov edi, [rcx+10h]
mov rsi, [rbp+var_18]
mov rcx, [rbp+var_10]
mov rdx, [rcx]
call rax
mov rax, cs:update_malloc_size
xor ecx, ecx
mov edi, ecx
sub rdi, [rbp+var_18]
sub rdi, 18h
movsx esi, [rbp+var_19]
call rax ; dummy
jmp short $+2
loc_2F3D4:
jmp short $+2
loc_2F3D6:
jmp short $+2
loc_2F3D8:
mov rdi, [rbp+var_10]
call _free
jmp short $+2
loc_2F3E3:
add rsp, 20h
pop rbp
retn
| long long my_free(long long a1)
{
long long result; // rax
char v2; // [rsp+7h] [rbp-19h]
unsigned long long v3; // [rsp+8h] [rbp-18h]
if ( a1 )
{
v3 = *(_QWORD *)(a1 - 24 + 8) & 0xFFFFFFFFFFFFFFFELL;
v2 = *(_BYTE *)(a1 - 24 + 8) & 1;
(*((void ( **)(_QWORD, unsigned long long, _QWORD))PSI_server[0] + 127))(
*(unsigned int *)(a1 - 24 + 16),
v3,
*(_QWORD *)(a1 - 24));
((void ( *)(long long, char))update_malloc_size[0])(-(long long)v3 - 24, v2);
return free(a1 - 24);
}
return result;
}
| my_free:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
JMP 0x0012f35e
LAB_0012f35e:
CMP qword ptr [RBP + -0x8],0x0
JNZ 0x0012f369
JMP 0x0012f367
LAB_0012f367:
JMP 0x0012f3e3
LAB_0012f369:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,-0x18
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,-0x2
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
AND RAX,0x1
MOV byte ptr [RBP + -0x19],AL
LEA RAX,[0x2cda28]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x3f8]
MOV RCX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RCX + 0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RCX]
CALL RAX
MOV RAX,qword ptr [0x002cdb98]
XOR ECX,ECX
MOV EDI,ECX
SUB RDI,qword ptr [RBP + -0x18]
SUB RDI,0x18
MOVSX ESI,byte ptr [RBP + -0x19]
CALL RAX
JMP 0x0012f3d4
LAB_0012f3d4:
JMP 0x0012f3d6
LAB_0012f3d6:
JMP 0x0012f3d8
LAB_0012f3d8:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00124350
JMP 0x0012f3e3
LAB_0012f3e3:
ADD RSP,0x20
POP RBP
RET
|
void my_free(long param_1)
{
int8 uVar1;
ulong uVar2;
if (param_1 != 0) {
uVar2 = *(ulong *)(param_1 + -0x10) & 0xfffffffffffffffe;
uVar1 = *(int8 *)(param_1 + -0x10);
(**(code **)(PSI_server + 0x3f8))
(*(int4 *)(param_1 + -8),uVar2,*(int8 *)(param_1 + -0x18));
(*(code *)update_malloc_size)(-0x18 - uVar2,(byte)uVar1 & 1);
free((int8 *)(param_1 + -0x18));
}
return;
}
| |
24,406 | my_free | eloqsql/mysys/my_malloc.c | void my_free(void *ptr)
{
my_memory_header *mh;
size_t old_size;
my_bool old_flags;
DBUG_ENTER("my_free");
DBUG_PRINT("my",("ptr: %p", ptr));
if (ptr == NULL)
DBUG_VOID_RETURN;
mh= USER_TO_HEADER(ptr);
old_size= mh->m_size & ~1;
old_flags= mh->m_size & 1;
PSI_CALL_memory_free(mh->m_key, old_size, mh->m_owner);
update_malloc_size(- (longlong) old_size - HEADER_SIZE, old_flags);
#ifndef SAFEMALLOC
/*
Trash memory if not safemalloc. We don't have to do this if safemalloc
is used as safemalloc will also do trashing
*/
TRASH_FREE(ptr, old_size);
#endif
sf_free(mh);
DBUG_VOID_RETURN;
} | O3 | c | my_free:
testq %rdi, %rdi
je 0x2b35b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x18(%rdi), %rbx
movq -0x18(%rdi), %rdx
movq -0x10(%rdi), %r14
movq %r14, %r15
andq $-0x2, %r15
leaq 0x2c34fd(%rip), %rax # 0x2ee820
movq (%rax), %rax
movl -0x8(%rdi), %edi
movq %r15, %rsi
callq *0x3f8(%rax)
movq $-0x18, %rdi
subq %r15, %rdi
andl $0x1, %r14d
movl %r14d, %esi
callq *0x2c364f(%rip) # 0x2ee998
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x243a0
retq
| my_free:
test rdi, rdi
jz short locret_2B35B
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
lea rbx, [rdi-18h]
mov rdx, [rdi-18h]
mov r14, [rdi-10h]
mov r15, r14
and r15, 0FFFFFFFFFFFFFFFEh
lea rax, PSI_server
mov rax, [rax]
mov edi, [rdi-8]
mov rsi, r15
call qword ptr [rax+3F8h]
mov rdi, 0FFFFFFFFFFFFFFE8h
sub rdi, r15
and r14d, 1
mov esi, r14d
call cs:update_malloc_size
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _free
locret_2B35B:
retn
| long long my_free(long long a1)
{
long long result; // rax
if ( a1 )
{
(*((void ( **)(_QWORD, unsigned long long, _QWORD))PSI_server[0] + 127))(
*(unsigned int *)(a1 - 8),
*(_QWORD *)(a1 - 16) & 0xFFFFFFFFFFFFFFFELL,
*(_QWORD *)(a1 - 24));
update_malloc_size[0]();
return free(a1 - 24);
}
return result;
}
| my_free:
TEST RDI,RDI
JZ 0x0012b35b
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
LEA RBX,[RDI + -0x18]
MOV RDX,qword ptr [RDI + -0x18]
MOV R14,qword ptr [RDI + -0x10]
MOV R15,R14
AND R15,-0x2
LEA RAX,[0x3ee820]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RDI + -0x8]
MOV RSI,R15
CALL qword ptr [RAX + 0x3f8]
MOV RDI,-0x18
SUB RDI,R15
AND R14D,0x1
MOV ESI,R14D
CALL qword ptr [0x003ee998]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001243a0
LAB_0012b35b:
RET
|
void my_free(long param_1)
{
ulong uVar1;
ulong uVar2;
if (param_1 != 0) {
uVar1 = *(ulong *)(param_1 + -0x10);
uVar2 = uVar1 & 0xfffffffffffffffe;
(**(code **)(PSI_server + 0x3f8))
(*(int4 *)(param_1 + -8),uVar2,*(int8 *)(param_1 + -0x18));
(*(code *)update_malloc_size)(-0x18 - uVar2,(uint)uVar1 & 1);
free((void *)(param_1 + -0x18));
return;
}
return;
}
| |
24,407 | ma_log_rt_split | eloqsql/storage/maria/ma_rt_split.c | static my_bool _ma_log_rt_split(MARIA_PAGE *page,
const uchar *key_with_nod_flag,
uint full_length,
const uchar *log_internal_copy,
uint log_internal_copy_length,
const uchar *log_key_copy,
uint length_diff)
{
MARIA_HA *info= page->info;
MARIA_SHARE *share= info->s;
LSN lsn;
uchar log_data[FILEID_STORE_SIZE + PAGE_STORE_SIZE + 1 + 2 + 1 + 2 + 2 + 7],
*log_pos;
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 6];
uint translog_parts, extra_length= 0;
my_off_t page_pos;
DBUG_ENTER("_ma_log_rt_split");
DBUG_PRINT("enter", ("page: %p", page));
DBUG_ASSERT(share->now_transactional);
page_pos= page->pos / share->block_size;
page_store(log_data + FILEID_STORE_SIZE, page_pos);
log_pos= log_data+ FILEID_STORE_SIZE + PAGE_STORE_SIZE;
log_pos[0]= KEY_OP_DEL_SUFFIX;
log_pos++;
DBUG_ASSERT((int)length_diff > 0);
int2store(log_pos, length_diff);
log_pos+= 2;
log_pos[0]= KEY_OP_MULTI_COPY;
log_pos++;
int2store(log_pos, full_length);
log_pos+= 2;
int2store(log_pos, log_internal_copy_length);
log_pos+= 2;
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data) - 7;
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= log_internal_copy;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= log_internal_copy_length;
translog_parts= 2;
if (log_key_copy != NULL) /* need to store key into record */
{
log_array[TRANSLOG_INTERNAL_PARTS + 2].str= log_key_copy;
log_array[TRANSLOG_INTERNAL_PARTS + 2].length= 1 + 2 + 1 + 2;
log_array[TRANSLOG_INTERNAL_PARTS + 3].str= key_with_nod_flag;
log_array[TRANSLOG_INTERNAL_PARTS + 3].length= full_length;
extra_length= 1 + 2 + 1 + 2 + full_length;
translog_parts+= 2;
}
_ma_log_key_changes(page,
log_array + TRANSLOG_INTERNAL_PARTS + translog_parts,
log_pos, &extra_length, &translog_parts);
/* Remember new page length for future log entires for same page */
page->org_size= page->size;
if (translog_write_record(&lsn, LOGREC_REDO_INDEX,
info->trn, info,
(translog_size_t) ((log_pos - log_data) +
log_internal_copy_length +
extra_length),
TRANSLOG_INTERNAL_PARTS + translog_parts,
log_array, log_data, NULL))
DBUG_RETURN(1);
DBUG_RETURN(0);
} | O0 | c | ma_log_rt_split:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movl 0x10(%rbp), %eax
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl %edx, -0x3c(%rbp)
movq %rcx, -0x48(%rbp)
movl %r8d, -0x4c(%rbp)
movq %r9, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0x108(%rbp)
jmp 0x89e64
jmp 0x89e66
jmp 0x89e68
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x68(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x110(%rbp)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x118(%rbp)
movq -0x110(%rbp), %rax
movl %eax, %ecx
movq -0x118(%rbp), %rax
movl %ecx, (%rax)
movq -0x110(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x118(%rbp), %rax
movb %cl, 0x4(%rax)
leaq -0x20(%rbp), %rax
addq $0x2, %rax
addq $0x5, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb $0x7, (%rax)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x89ee3
jmp 0x89ee5
movq -0x78(%rbp), %rax
movq %rax, -0x120(%rbp)
movl 0x10(%rbp), %eax
movw %ax, %cx
movq -0x120(%rbp), %rax
movw %cx, (%rax)
movq -0x78(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb $0x9, (%rax)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x128(%rbp)
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0x128(%rbp), %rax
movw %cx, (%rax)
movq -0x78(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x130(%rbp)
movl -0x4c(%rbp), %eax
movw %ax, %cx
movq -0x130(%rbp), %rax
movw %cx, (%rax)
movq -0x78(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x78(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq $0xf, -0xd8(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0xc8(%rbp)
movl $0x2, -0x104(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x89fef
movq -0x58(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x6, -0xb8(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl -0x3c(%rbp), %eax
movq %rax, -0xa8(%rbp)
movl -0x3c(%rbp), %eax
addl $0x6, %eax
movl %eax, -0x108(%rbp)
movl -0x104(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x104(%rbp)
movq -0x30(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x60(%rbp), %rcx
movq -0x78(%rbp), %rax
leaq -0x20(%rbp), %rsi
subq %rsi, %rax
movl -0x4c(%rbp), %esi
addq %rsi, %rax
movl -0x108(%rbp), %esi
addq %rsi, %rax
movl %eax, %r8d
movl -0x104(%rbp), %r9d
addl $0x2, %r9d
leaq -0x100(%rbp), %r10
leaq -0x20(%rbp), %rax
leaq -0x70(%rbp), %rdi
movl $0xc, %esi
xorl %r11d, %r11d
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x33840
cmpb $0x0, %al
je 0x8a06b
jmp 0x8a065
movb $0x1, -0x21(%rbp)
jmp 0x8a071
jmp 0x8a06d
movb $0x0, -0x21(%rbp)
movb -0x21(%rbp), %al
movb %al, -0x131(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x8a09b
movb -0x131(%rbp), %al
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
callq 0x2a250
| _ma_log_rt_split:
push rbp
mov rbp, rsp
sub rsp, 150h
mov eax, [rbp+arg_0]
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_30], rdi
mov [rbp+var_38], rsi
mov [rbp+var_3C], edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], r8d
mov [rbp+var_58], r9
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov rax, [rax]
mov [rbp+var_68], rax
mov [rbp+var_108], 0
jmp short $+2
loc_89E64:
jmp short $+2
loc_89E66:
jmp short $+2
loc_89E68:
mov rax, [rbp+var_30]
mov rax, [rax+18h]
mov rcx, [rbp+var_68]
mov ecx, [rcx+7BCh]
xor edx, edx
div rcx
mov [rbp+var_110], rax
lea rax, [rbp+var_20]
add rax, 2
mov [rbp+var_118], rax
mov rax, [rbp+var_110]
mov ecx, eax
mov rax, [rbp+var_118]
mov [rax], ecx
mov rax, [rbp+var_110]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_118]
mov [rax+4], cl
lea rax, [rbp+var_20]
add rax, 2
add rax, 5
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov byte ptr [rax], 7
mov rax, [rbp+var_78]
add rax, 1
mov [rbp+var_78], rax
jmp short $+2
loc_89EE3:
jmp short $+2
loc_89EE5:
mov rax, [rbp+var_78]
mov [rbp+var_120], rax
mov eax, [rbp+arg_0]
mov cx, ax
mov rax, [rbp+var_120]
mov [rax], cx
mov rax, [rbp+var_78]
add rax, 2
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov byte ptr [rax], 9
mov rax, [rbp+var_78]
add rax, 1
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_128], rax
mov eax, [rbp+var_3C]
mov cx, ax
mov rax, [rbp+var_128]
mov [rax], cx
mov rax, [rbp+var_78]
add rax, 2
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_130], rax
mov eax, [rbp+var_4C]
mov cx, ax
mov rax, [rbp+var_130]
mov [rax], cx
mov rax, [rbp+var_78]
add rax, 2
mov [rbp+var_78], rax
lea rax, [rbp+var_20]
mov [rbp+var_E0], rax
mov [rbp+var_D8], 0Fh
mov rax, [rbp+var_48]
mov [rbp+var_D0], rax
mov eax, [rbp+var_4C]
mov [rbp+var_C8], rax
mov [rbp+var_104], 2
cmp [rbp+var_58], 0
jz short loc_89FEF
mov rax, [rbp+var_58]
mov [rbp+var_C0], rax
mov [rbp+var_B8], 6
mov rax, [rbp+var_38]
mov [rbp+var_B0], rax
mov eax, [rbp+var_3C]
mov [rbp+var_A8], rax
mov eax, [rbp+var_3C]
add eax, 6
mov [rbp+var_108], eax
mov eax, [rbp+var_104]
add eax, 2
mov [rbp+var_104], eax
loc_89FEF:
mov rax, [rbp+var_30]
mov ecx, [rax+20h]
mov rax, [rbp+var_30]
mov [rax+24h], ecx
mov rax, [rbp+var_60]
mov rdx, [rax+8]
mov rcx, [rbp+var_60]
mov rax, [rbp+var_78]
lea rsi, [rbp+var_20]
sub rax, rsi
mov esi, [rbp+var_4C]
add rax, rsi
mov esi, [rbp+var_108]
add rax, rsi
mov r8d, eax
mov r9d, [rbp+var_104]
add r9d, 2
lea r10, [rbp+var_100]
lea rax, [rbp+var_20]
lea rdi, [rbp+var_70]
mov esi, 0Ch
xor r11d, r11d
mov [rsp+150h+var_150], r10
mov [rsp+150h+var_148], rax
mov [rsp+150h+var_140], 0
call translog_write_record
cmp al, 0
jz short loc_8A06B
jmp short $+2
loc_8A065:
mov [rbp+var_21], 1
jmp short loc_8A071
loc_8A06B:
jmp short $+2
loc_8A06D:
mov [rbp+var_21], 0
loc_8A071:
mov al, [rbp+var_21]
mov [rbp+var_131], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_8A09B
mov al, [rbp+var_131]
add rsp, 150h
pop rbp
retn
loc_8A09B:
call ___stack_chk_fail
| bool ma_log_rt_split(
long long a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6,
__int16 a7)
{
unsigned long long v8; // [rsp+40h] [rbp-110h]
unsigned int v9; // [rsp+48h] [rbp-108h]
int v10; // [rsp+4Ch] [rbp-104h]
_QWORD v11[17]; // [rsp+50h] [rbp-100h] BYREF
_BYTE *v12; // [rsp+D8h] [rbp-78h]
_BYTE v13[8]; // [rsp+E0h] [rbp-70h] BYREF
long long v14; // [rsp+E8h] [rbp-68h]
long long *v15; // [rsp+F0h] [rbp-60h]
long long v16; // [rsp+F8h] [rbp-58h]
unsigned int v17; // [rsp+104h] [rbp-4Ch]
long long v18; // [rsp+108h] [rbp-48h]
unsigned int v19; // [rsp+114h] [rbp-3Ch]
long long v20; // [rsp+118h] [rbp-38h]
long long v21; // [rsp+120h] [rbp-30h]
__int16 v22; // [rsp+130h] [rbp-20h] BYREF
int v23; // [rsp+132h] [rbp-1Eh]
char v24; // [rsp+136h] [rbp-1Ah]
char v25; // [rsp+137h] [rbp-19h]
__int16 v26; // [rsp+138h] [rbp-18h]
char v27; // [rsp+13Ah] [rbp-16h]
__int16 v28; // [rsp+13Bh] [rbp-15h]
__int16 v29; // [rsp+13Dh] [rbp-13h]
_BYTE v30[17]; // [rsp+13Fh] [rbp-11h] BYREF
long long savedregs; // [rsp+150h] [rbp+0h] BYREF
*(_QWORD *)&v30[9] = __readfsqword(0x28u);
v21 = a1;
v20 = a2;
v19 = a3;
v18 = a4;
v17 = a5;
v16 = a6;
v15 = *(long long **)a1;
v14 = *v15;
v9 = 0;
v8 = *(_QWORD *)(a1 + 24) / (unsigned long long)*(unsigned int *)(v14 + 1980);
v23 = v8;
v24 = BYTE4(v8);
v25 = 7;
v26 = a7;
v27 = 9;
v28 = a3;
v29 = a5;
v12 = v30;
v11[4] = &v22;
v11[5] = 15LL;
v11[6] = a4;
v11[7] = a5;
v10 = 2;
if ( a6 )
{
v11[8] = v16;
v11[9] = 6LL;
v11[10] = v20;
v11[11] = v19;
v9 = v19 + 6;
v10 = 4;
}
*(_DWORD *)(v21 + 36) = *(_DWORD *)(v21 + 32);
return translog_write_record(
(long long)v13,
0xCu,
v15[1],
v15,
v9 + v17 + (_DWORD)v12 - ((unsigned int)&savedregs - 32),
v10 + 2,
v11,
&v22,
0LL) != 0;
}
| _ma_log_rt_split:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x150
MOV EAX,dword ptr [RBP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x38],RSI
MOV dword ptr [RBP + -0x3c],EDX
MOV qword ptr [RBP + -0x48],RCX
MOV dword ptr [RBP + -0x4c],R8D
MOV qword ptr [RBP + -0x58],R9
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV dword ptr [RBP + -0x108],0x0
JMP 0x00189e64
LAB_00189e64:
JMP 0x00189e66
LAB_00189e66:
JMP 0x00189e68
LAB_00189e68:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RCX + 0x7bc]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x110],RAX
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
MOV qword ptr [RBP + -0x118],RAX
MOV RAX,qword ptr [RBP + -0x110]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x118]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x110]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x118]
MOV byte ptr [RAX + 0x4],CL
LEA RAX,[RBP + -0x20]
ADD RAX,0x2
ADD RAX,0x5
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x7
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0x78],RAX
JMP 0x00189ee3
LAB_00189ee3:
JMP 0x00189ee5
LAB_00189ee5:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x120],RAX
MOV EAX,dword ptr [RBP + 0x10]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x120]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x2
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x9
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x1
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x128],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x128]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x2
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x130],RAX
MOV EAX,dword ptr [RBP + -0x4c]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x130]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x78]
ADD RAX,0x2
MOV qword ptr [RBP + -0x78],RAX
LEA RAX,[RBP + -0x20]
MOV qword ptr [RBP + -0xe0],RAX
MOV qword ptr [RBP + -0xd8],0xf
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0xd0],RAX
MOV EAX,dword ptr [RBP + -0x4c]
MOV qword ptr [RBP + -0xc8],RAX
MOV dword ptr [RBP + -0x104],0x2
CMP qword ptr [RBP + -0x58],0x0
JZ 0x00189fef
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0xc0],RAX
MOV qword ptr [RBP + -0xb8],0x6
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xb0],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV qword ptr [RBP + -0xa8],RAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x6
MOV dword ptr [RBP + -0x108],EAX
MOV EAX,dword ptr [RBP + -0x104]
ADD EAX,0x2
MOV dword ptr [RBP + -0x104],EAX
LAB_00189fef:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x24],ECX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x78]
LEA RSI,[RBP + -0x20]
SUB RAX,RSI
MOV ESI,dword ptr [RBP + -0x4c]
ADD RAX,RSI
MOV ESI,dword ptr [RBP + -0x108]
ADD RAX,RSI
MOV R8D,EAX
MOV R9D,dword ptr [RBP + -0x104]
ADD R9D,0x2
LEA R10,[RBP + -0x100]
LEA RAX,[RBP + -0x20]
LEA RDI,[RBP + -0x70]
MOV ESI,0xc
XOR R11D,R11D
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],0x0
CALL 0x00133840
CMP AL,0x0
JZ 0x0018a06b
JMP 0x0018a065
LAB_0018a065:
MOV byte ptr [RBP + -0x21],0x1
JMP 0x0018a071
LAB_0018a06b:
JMP 0x0018a06d
LAB_0018a06d:
MOV byte ptr [RBP + -0x21],0x0
LAB_0018a071:
MOV AL,byte ptr [RBP + -0x21]
MOV byte ptr [RBP + -0x131],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0018a09b
MOV AL,byte ptr [RBP + -0x131]
ADD RSP,0x150
POP RBP
RET
LAB_0018a09b:
CALL 0x0012a250
|
int8
_ma_log_rt_split(long *param_1,int8 param_2,uint param_3,int8 param_4,uint param_5,
long param_6,int2 param_7)
{
char cVar1;
ulong uVar2;
long in_FS_OFFSET;
int local_110;
int local_10c;
int1 local_108 [32];
int1 *local_e8;
int8 local_e0;
int8 local_d8;
ulong local_d0;
long local_c8;
int8 local_c0;
int8 local_b8;
ulong local_b0;
int1 *local_80;
int1 local_78 [8];
long local_70;
long *local_68;
long local_60;
uint local_54;
int8 local_50;
uint local_44;
int8 local_40;
long *local_38;
int1 local_29;
int1 local_28 [2];
int4 local_26;
int1 local_22;
int1 local_21;
int2 local_20;
int1 local_1e;
int2 local_1d;
int2 local_1b;
int1 auStack_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_68 = (long *)*param_1;
local_70 = *local_68;
local_110 = 0;
uVar2 = (ulong)param_1[3] / (ulong)*(uint *)(local_70 + 0x7bc);
local_26 = (int4)uVar2;
local_22 = (int1)(uVar2 >> 0x20);
local_21 = 7;
local_20 = param_7;
local_1e = 9;
local_1d = (int2)param_3;
local_1b = (int2)param_5;
local_80 = auStack_19;
local_e8 = local_28;
local_e0 = 0xf;
local_d0 = (ulong)param_5;
local_10c = 2;
if (param_6 != 0) {
local_c0 = 6;
local_b0 = (ulong)param_3;
local_110 = param_3 + 6;
local_10c = 4;
local_c8 = param_6;
local_b8 = param_2;
}
*(int *)((long)param_1 + 0x24) = (int)param_1[4];
local_d8 = param_4;
local_60 = param_6;
local_54 = param_5;
local_50 = param_4;
local_44 = param_3;
local_40 = param_2;
local_38 = param_1;
cVar1 = translog_write_record
(local_78,0xc,local_68[1],local_68,
((int)local_80 - (int)local_28) + param_5 + local_110,local_10c + 2,local_108,
local_28,0);
local_29 = cVar1 != '\0';
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),local_29);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,408 | intx::uint<256u> intx::operator<<<256u>(intx::uint<256u> const&, intx::uint<256u> const&) | corpus-core[P]colibri-stateless/build_O0/_deps/intx-src/include/intx/intx.hpp | inline constexpr uint<N> operator<<(const uint<N>& x, const uint<N>& shift) noexcept
{
uint64_t high_words_fold = 0;
for (size_t i = 1; i < uint<N>::num_words; ++i)
high_words_fold |= shift[i];
if (INTX_UNLIKELY(high_words_fold != 0))
return 0;
return x << shift[0];
} | O0 | cpp | intx::uint<256u> intx::operator<<<256u>(intx::uint<256u> const&, intx::uint<256u> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
cmpq $0x4, -0x20(%rbp)
jae 0x670f5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x61430
movq (%rax), %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x670c8
cmpq $0x0, -0x18(%rbp)
je 0x67109
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x61cc0
jmp 0x6712e
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x61430
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq (%rax), %rdx
callq 0x64ac0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN4intxlsILj256EEENS_4uintIXT_EEERKS2_S4_:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_30], rdi
mov [rbp+var_28], rdi
mov [rbp+var_8], rsi
mov [rbp+var_10], rdx
mov [rbp+var_18], 0
mov [rbp+var_20], 1
loc_670C8:
cmp [rbp+var_20], 4
jnb short loc_670F5
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call _ZNK4intx4uintILj256EEixEm; intx::uint<256u>::operator[](ulong)
mov rax, [rax]
or rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_670C8
loc_670F5:
cmp [rbp+var_18], 0
jz short loc_67109
mov rdi, [rbp+var_30]
xor esi, esi
call _ZN4intx4uintILj256EEC2IJiEvEEDpT_; intx::uint<256u>::uint<int,void>(int)
jmp short loc_6712E
loc_67109:
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call _ZNK4intx4uintILj256EEixEm; intx::uint<256u>::operator[](ulong)
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rdx, [rax]
call _ZN4intxlsERKNS_4uintILj256EEEm; intx::operator<<(intx::uint<256u> const&,ulong)
loc_6712E:
mov rax, [rbp+var_28]
add rsp, 40h
pop rbp
retn
| _QWORD * intx::operator<<<256u>(_QWORD *a1, long long a2, long long a3)
{
unsigned long long *v3; // rax
unsigned long long i; // [rsp+20h] [rbp-20h]
long long v6; // [rsp+28h] [rbp-18h]
v6 = 0LL;
for ( i = 1LL; i < 4; ++i )
v6 |= *(_QWORD *)intx::uint<256u>::operator[](a3, i);
if ( v6 )
{
intx::uint<256u>::uint<int,void>(a1, 0);
}
else
{
v3 = (unsigned long long *)intx::uint<256u>::operator[](a3, 0LL);
intx::operator<<(a1, a2, *v3);
}
return a1;
}
| operator<<:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x30],RDI
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x8],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x18],0x0
MOV qword ptr [RBP + -0x20],0x1
LAB_001670c8:
CMP qword ptr [RBP + -0x20],0x4
JNC 0x001670f5
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00161430
MOV RAX,qword ptr [RAX]
OR RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001670c8
LAB_001670f5:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00167109
MOV RDI,qword ptr [RBP + -0x30]
XOR ESI,ESI
CALL 0x00161cc0
JMP 0x0016712e
LAB_00167109:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x00161430
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RAX]
CALL 0x00164ac0
LAB_0016712e:
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x40
POP RBP
RET
|
/* intx::uint<256u> intx::TEMPNAMEPLACEHOLDERVALUE(intx::uint<256u> const&, intx::uint<256u> const&)
*/
intx * __thiscall intx::operator<<(intx *this,uint *param_1,uint *param_2)
{
ulong *puVar1;
int8 local_28;
int8 local_20;
local_20 = 0;
for (local_28 = 1; local_28 < 4; local_28 = local_28 + 1) {
puVar1 = (ulong *)uint<256u>::operator[]((uint<256u> *)param_2,local_28);
local_20 = *puVar1 | local_20;
}
if (local_20 == 0) {
puVar1 = (ulong *)uint<256u>::operator[]((uint<256u> *)param_2,0);
operator<<(this,param_1,*puVar1);
}
else {
uint<256u>::uint<int,void>((uint<256u> *)this,0);
}
return this;
}
| |
24,409 | uf_blob | eloqsql/storage/myisam/mi_packrec.c | static void uf_blob(MI_COLUMNDEF *rec, MI_BIT_BUFF *bit_buff,
uchar *to, uchar *end)
{
if (get_bit(bit_buff))
bzero((uchar*) to,(end-to));
else
{
ulong length=get_bits(bit_buff,rec->space_length_bits);
uint pack_length=(uint) (end-to)-portable_sizeof_char_ptr;
if (bit_buff->blob_pos+length > bit_buff->blob_end)
{
bit_buff->error=1;
bzero((uchar*) to,(end-to));
return;
}
decode_bytes(rec,bit_buff,bit_buff->blob_pos,bit_buff->blob_pos+length);
_mi_store_blob_length((uchar*) to,pack_length,length);
memcpy(to+pack_length, &bit_buff->blob_pos, sizeof(char*));
bit_buff->blob_pos+=length;
}
} | O0 | c | uf_blob:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbd427
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rdx)
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xbd44b
jmp 0xbd466
movq -0x10(%rbp), %rdi
callq 0xbbca0
movq -0x10(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbd466
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x2a2a0
jmp 0xbd565
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jb 0xbd4a9
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %esi
movq -0x10(%rbp), %rdx
movl 0x4(%rdx), %ecx
subl %esi, %ecx
movl %ecx, 0x4(%rdx)
shrl %cl, %eax
movq -0x8(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, %edx
leaq 0x20963f(%rip), %rcx # 0x2c6ae0
andl (%rcx,%rdx,4), %eax
movl %eax, -0x30(%rbp)
jmp 0xbd4bc
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0xba450
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
subl $0x8, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jbe 0xbd50f
movq -0x10(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
xorl %esi, %esi
callq 0x2a2a0
jmp 0xbd565
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq -0x28(%rbp), %rcx
callq 0xbc3b0
movq -0x18(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x28(%rbp), %rax
movl %eax, %edx
callq 0xab070
movq -0x18(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq %rdx, (%rax,%rcx)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| uf_blob_0:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+4], 0
jz short loc_BD427
mov rax, [rbp+var_10]
mov eax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
add ecx, 0FFFFFFFFh
mov [rdx+4], ecx
mov edx, 1
shl edx, cl
mov ecx, edx
and eax, ecx
cmp eax, 0
jnz short loc_BD44B
jmp short loc_BD466
loc_BD427:
mov rdi, [rbp+var_10]
call fill_buffer_0
mov rax, [rbp+var_10]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_10]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_BD466
loc_BD44B:
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
xor esi, esi
call _memset
jmp loc_BD565
loc_BD466:
mov rax, [rbp+var_10]
mov eax, [rax+4]
mov rcx, [rbp+var_8]
cmp eax, [rcx+1Ch]
jb short loc_BD4A9
mov rax, [rbp+var_10]
mov eax, [rax]
mov rcx, [rbp+var_8]
mov esi, [rcx+1Ch]
mov rdx, [rbp+var_10]
mov ecx, [rdx+4]
sub ecx, esi
mov [rdx+4], ecx
shr eax, cl
mov rcx, [rbp+var_8]
mov ecx, [rcx+1Ch]
mov edx, ecx
lea rcx, mask_0
and eax, [rcx+rdx*4]
mov [rbp+var_30], eax
jmp short loc_BD4BC
loc_BD4A9:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov esi, [rax+1Ch]
call fill_and_get_bits_0
mov [rbp+var_30], eax
loc_BD4BC:
mov eax, [rbp+var_30]
mov eax, eax
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_18]
sub rax, rcx
sub eax, 8
mov [rbp+var_2C], eax
mov rax, [rbp+var_10]
mov rax, [rax+18h]
add rax, [rbp+var_28]
mov rcx, [rbp+var_10]
cmp rax, [rcx+20h]
jbe short loc_BD50F
mov rax, [rbp+var_10]
mov dword ptr [rax+28h], 1
mov rdi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_18]
sub rdx, rax
xor esi, esi
call _memset
jmp short loc_BD565
loc_BD50F:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
mov rax, [rbp+var_10]
mov rcx, [rax+18h]
add rcx, [rbp+var_28]
call decode_bytes_0
mov rdi, [rbp+var_18]
mov esi, [rbp+var_2C]
mov rax, [rbp+var_28]
mov edx, eax
call _mi_store_blob_length
mov rax, [rbp+var_18]
mov ecx, [rbp+var_2C]
mov rdx, [rbp+var_10]
mov rdx, [rdx+18h]
mov [rax+rcx], rdx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_10]
add rcx, [rax+18h]
mov [rax+18h], rcx
loc_BD565:
add rsp, 30h
pop rbp
retn
| long long uf_blob_0(long long a1, long long a2, _BYTE *a3, long long a4)
{
int v4; // eax
int v5; // ecx
long long result; // rax
unsigned int v7; // eax
int v8; // ecx
unsigned int bits_0; // [rsp+0h] [rbp-30h]
unsigned int v10; // [rsp+4h] [rbp-2Ch]
if ( *(_DWORD *)(a2 + 4) )
{
v4 = *(_DWORD *)a2;
v5 = *(_DWORD *)(a2 + 4) - 1;
*(_DWORD *)(a2 + 4) = v5;
if ( ((1 << v5) & v4) == 0 )
goto LABEL_6;
return memset(a3, 0LL, a4 - (_QWORD)a3);
}
fill_buffer_0(a2);
*(_DWORD *)(a2 + 4) = 31;
if ( *(int *)a2 < 0 )
return memset(a3, 0LL, a4 - (_QWORD)a3);
LABEL_6:
if ( *(_DWORD *)(a2 + 4) < *(_DWORD *)(a1 + 28) )
{
bits_0 = fill_and_get_bits_0((_DWORD *)a2, *(_DWORD *)(a1 + 28));
}
else
{
v7 = *(_DWORD *)a2;
v8 = *(_DWORD *)(a2 + 4) - *(_DWORD *)(a1 + 28);
*(_DWORD *)(a2 + 4) = v8;
bits_0 = mask_0[*(unsigned int *)(a1 + 28)] & (v7 >> v8);
}
v10 = a4 - (_DWORD)a3 - 8;
if ( (unsigned long long)bits_0 + *(_QWORD *)(a2 + 24) <= *(_QWORD *)(a2 + 32) )
{
decode_bytes_0(a1, a2, *(_BYTE **)(a2 + 24), (_BYTE *)(bits_0 + *(_QWORD *)(a2 + 24)));
mi_store_blob_length(a3, v10, bits_0);
*(_QWORD *)&a3[v10] = *(_QWORD *)(a2 + 24);
result = a2;
*(_QWORD *)(a2 + 24) += bits_0;
}
else
{
*(_DWORD *)(a2 + 40) = 1;
return memset(a3, 0LL, a4 - (_QWORD)a3);
}
return result;
}
| uf_blob:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bd427
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
ADD ECX,-0x1
MOV dword ptr [RDX + 0x4],ECX
MOV EDX,0x1
SHL EDX,CL
MOV ECX,EDX
AND EAX,ECX
CMP EAX,0x0
JNZ 0x001bd44b
JMP 0x001bd466
LAB_001bd427:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001bbca0
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bd466
LAB_001bd44b:
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
XOR ESI,ESI
CALL 0x0012a2a0
JMP 0x001bd565
LAB_001bd466:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x4]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x1c]
JC 0x001bd4a9
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RCX + 0x1c]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x4]
SUB ECX,ESI
MOV dword ptr [RDX + 0x4],ECX
SHR EAX,CL
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x1c]
MOV EDX,ECX
LEA RCX,[0x3c6ae0]
AND EAX,dword ptr [RCX + RDX*0x4]
MOV dword ptr [RBP + -0x30],EAX
JMP 0x001bd4bc
LAB_001bd4a9:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RAX + 0x1c]
CALL 0x001ba450
MOV dword ptr [RBP + -0x30],EAX
LAB_001bd4bc:
MOV EAX,dword ptr [RBP + -0x30]
MOV EAX,EAX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
SUB EAX,0x8
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x18]
ADD RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x20]
JBE 0x001bd50f
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x28],0x1
MOV RDI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x18]
SUB RDX,RAX
XOR ESI,ESI
CALL 0x0012a2a0
JMP 0x001bd565
LAB_001bd50f:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x18]
ADD RCX,qword ptr [RBP + -0x28]
CALL 0x001bc3b0
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,EAX
CALL 0x001ab070
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x2c]
MOV RDX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + RCX*0x1],RDX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_001bd565:
ADD RSP,0x30
POP RBP
RET
|
void uf_blob(long param_1,uint *param_2,void *param_3,long param_4)
{
uint uVar1;
ulong uVar2;
uint local_38;
if (param_2[1] == 0) {
fill_buffer(param_2);
param_2[1] = 0x1f;
uVar1 = *param_2 & 0x80000000;
}
else {
uVar1 = param_2[1];
param_2[1] = uVar1 - 1;
uVar1 = *param_2 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 == 0) {
if (param_2[1] < *(uint *)(param_1 + 0x1c)) {
local_38 = fill_and_get_bits(param_2);
}
else {
uVar1 = param_2[1] - *(int *)(param_1 + 0x1c);
param_2[1] = uVar1;
local_38 = *param_2 >> ((byte)uVar1 & 0x1f) &
*(uint *)(mask + (ulong)*(uint *)(param_1 + 0x1c) * 4);
}
uVar2 = (ulong)local_38;
uVar1 = ((int)param_4 - (int)param_3) - 8;
if (*(ulong *)(param_2 + 8) < *(long *)(param_2 + 6) + uVar2) {
param_2[10] = 1;
memset(param_3,0,param_4 - (long)param_3);
}
else {
decode_bytes(param_1,param_2,*(int8 *)(param_2 + 6),*(long *)(param_2 + 6) + uVar2);
_mi_store_blob_length(param_3,uVar1,uVar2);
*(int8 *)((long)param_3 + (ulong)uVar1) = *(int8 *)(param_2 + 6);
*(ulong *)(param_2 + 6) = uVar2 + *(long *)(param_2 + 6);
}
}
else {
memset(param_3,0,param_4 - (long)param_3);
}
return;
}
| |
24,410 | minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&) | monkey531[P]llama/common/minja.hpp | CallExpr(const Location & location, std::shared_ptr<Expression> && obj, ArgumentsExpression && a)
: Expression(location), object(std::move(obj)), args(std::move(a)) {} | O2 | cpp | minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::ArgumentsExpression&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
callq 0x627e6
leaq 0x8c0be(%rip), %rax # 0xfa8d0
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x6b6bc
| _ZN5minja8CallExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEEONS_19ArgumentsExpressionE:
push r15
push r14
push rbx
mov rbx, rcx
mov r14, rdx
mov r15, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja8CallExprE; `vtable for'minja::CallExpr
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
add r15, 30h ; '0'
mov rdi, r15
mov rsi, rbx
pop rbx
pop r14
pop r15
jmp _ZN5minja19ArgumentsExpressionC2EOS0_; minja::ArgumentsExpression::ArgumentsExpression(minja::ArgumentsExpression&&)
| long long minja::CallExpr::CallExpr(long long a1, _QWORD *a2, __int128 *a3, long long a4)
{
__int128 v6; // xmm0
minja::Expression::Expression((_QWORD *)a1, a2);
*(_QWORD *)a1 = &`vtable for'minja::CallExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v6 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v6;
*(_QWORD *)a3 = 0LL;
return minja::ArgumentsExpression::ArgumentsExpression(a1 + 48, a4);
}
| CallExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RCX
MOV R14,RDX
MOV R15,RDI
CALL 0x001627e6
LEA RAX,[0x1fa8d0]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
ADD R15,0x30
MOV RDI,R15
MOV RSI,RBX
POP RBX
POP R14
POP R15
JMP 0x0016b6bc
|
/* minja::CallExpr::CallExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::ArgumentsExpression&&) */
void __thiscall
minja::CallExpr::CallExpr
(CallExpr *this,Location *param_1,shared_ptr *param_2,ArgumentsExpression *param_3)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_001fa8e0;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
ArgumentsExpression::ArgumentsExpression((ArgumentsExpression *)(this + 0x30),param_3);
return;
}
| |
24,411 | my_numchars_mb | eloqsql/strings/ctype-mb.c | size_t my_numchars_mb(CHARSET_INFO *cs __attribute__((unused)),
const char *pos, const char *end)
{
register size_t count= 0;
while (pos < end)
{
uint mb_len;
pos+= (mb_len= my_ismbchar(cs,pos,end)) ? mb_len : 1;
count++;
}
return count;
} | O0 | c | my_numchars_mb:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5502f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x544f0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x55007
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x55011
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x55011
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x54fdc
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_numchars_mb:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], 0
loc_54FDC:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_18]
jnb short loc_5502F
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call my_ismbchar_0
mov [rbp+var_24], eax
cmp eax, 0
jz short loc_55007
mov eax, [rbp+var_24]
mov [rbp+var_28], eax
jmp short loc_55011
loc_55007:
mov eax, 1
mov [rbp+var_28], eax
jmp short $+2
loc_55011:
mov ecx, [rbp+var_28]
mov rax, [rbp+var_10]
mov ecx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_54FDC
loc_5502F:
mov rax, [rbp+var_20]
add rsp, 30h
pop rbp
retn
| long long my_numchars_mb(long long a1, unsigned long long a2, unsigned long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-28h]
unsigned int v5; // [rsp+Ch] [rbp-24h]
long long v6; // [rsp+10h] [rbp-20h]
v6 = 0LL;
while ( a2 < a3 )
{
v5 = my_ismbchar_0(a1, a2, a3);
if ( v5 )
v4 = v5;
else
v4 = 1;
a2 += v4;
++v6;
}
return v6;
}
| my_numchars_mb:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],0x0
LAB_00154fdc:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x0015502f
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001544f0
MOV dword ptr [RBP + -0x24],EAX
CMP EAX,0x0
JZ 0x00155007
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00155011
LAB_00155007:
MOV EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00155011
LAB_00155011:
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00154fdc
LAB_0015502f:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x30
POP RBP
RET
|
long my_numchars_mb(int8 param_1,ulong param_2,ulong param_3)
{
int4 local_30;
int8 local_28;
int8 local_18;
local_28 = 0;
for (local_18 = param_2; local_18 < param_3; local_18 = local_18 + local_30) {
local_30 = my_ismbchar(param_1,local_18,param_3);
if (local_30 == 0) {
local_30 = 1;
}
local_28 = local_28 + 1;
}
return local_28;
}
| |
24,412 | ftxui::operator|(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/util.cpp | Decorator operator|(Decorator a, Decorator b) {
return compose(std::move(a), //
std::move(b));
} | O3 | cpp | ftxui::operator|(std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x18(%rsi), %r12
movq %r12, 0x38(%rsp)
movq 0x10(%rsi), %r14
testq %r14, %r14
je 0x257ce
movups (%rsi), %xmm1
addq $0x10, %rsi
movaps %xmm1, 0x20(%rsp)
movq %r14, 0x30(%rsp)
movups %xmm0, (%rsi)
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rdx), %r13
movq %r13, 0x18(%rsp)
movq 0x10(%rdx), %r15
testq %r15, %r15
je 0x25803
movups (%rdx), %xmm0
addq $0x10, %rdx
movaps %xmm0, (%rsp)
movq %r15, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %r12, 0x58(%rsp)
testq %r14, %r14
je 0x25831
leaq 0x30(%rsp), %rax
movaps -0x10(%rax), %xmm1
movaps %xmm1, 0x40(%rsp)
movq %r14, 0x50(%rsp)
movups %xmm0, (%rax)
leaq 0x60(%rsp), %rbp
movaps %xmm0, (%rbp)
movq $0x0, 0x10(%rbp)
movq %r13, 0x18(%rbp)
testq %r15, %r15
je 0x25863
leaq 0x10(%rsp), %rax
movaps -0x10(%rax), %xmm0
movups %xmm0, (%rbp)
movq %r15, 0x70(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movl $0x40, %edi
callq 0xb3e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r12, 0x18(%rax)
testq %r14, %r14
je 0x25897
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %r13, 0x38(%rax)
testq %r15, %r15
je 0x258c1
movq %rax, %rcx
addq $0x20, %rcx
movups (%rbp), %xmm0
movups %xmm0, (%rcx)
movq %r15, 0x30(%rax)
movq %rax, (%rbx)
leaq 0x535(%rip), %rax # 0x25e00
movq %rax, 0x18(%rbx)
leaq 0x5d2(%rip), %rax # 0x25ea8
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x25dc2
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x25913
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2592c
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xb780
jmp 0x25936
movq %rax, %rdi
callq 0x1049a
| _ZN5ftxuiorESt8functionIFSt10shared_ptrINS_4NodeEES3_EES5_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rbx, rdi
xorps xmm0, xmm0
movaps [rsp+0B8h+var_98], xmm0
mov [rsp+0B8h+var_88], 0
mov r12, [rsi+18h]
mov [rsp+0B8h+var_80], r12
mov r14, [rsi+10h]
test r14, r14
jz short loc_257CE
movups xmm1, xmmword ptr [rsi]
add rsi, 10h
movaps [rsp+0B8h+var_98], xmm1
mov [rsp+0B8h+var_88], r14
movups xmmword ptr [rsi], xmm0
loc_257CE:
movaps [rsp+0B8h+var_B8], xmm0
mov [rsp+0B8h+var_A8], 0
mov r13, [rdx+18h]
mov [rsp+0B8h+var_A0], r13
mov r15, [rdx+10h]
test r15, r15
jz short loc_25803
movups xmm0, xmmword ptr [rdx]
add rdx, 10h
movaps [rsp+0B8h+var_B8], xmm0
mov [rsp+0B8h+var_A8], r15
xorps xmm0, xmm0
movups xmmword ptr [rdx], xmm0
loc_25803:
movaps [rsp+0B8h+var_78], xmm0
mov [rsp+0B8h+var_68], 0
mov [rsp+0B8h+var_60], r12
test r14, r14
jz short loc_25831
lea rax, [rsp+0B8h+var_88]
movaps xmm1, xmmword ptr [rax-10h]
movaps [rsp+0B8h+var_78], xmm1
mov [rsp+0B8h+var_68], r14
movups xmmword ptr [rax], xmm0
loc_25831:
lea rbp, [rsp+0B8h+var_58]
movaps xmmword ptr [rbp+0], xmm0
mov qword ptr [rbp+10h], 0
mov [rbp+18h], r13
test r15, r15
jz short loc_25863
lea rax, [rsp+0B8h+var_A8]
movaps xmm0, xmmword ptr [rax-10h]
movups xmmword ptr [rbp+0], xmm0
mov [rsp+0B8h+var_48], r15
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
loc_25863:
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
mov edi, 40h ; '@'; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [rax+18h], r12
test r14, r14
jz short loc_25897
movaps xmm0, [rsp+0B8h+var_78]
movups xmmword ptr [rax], xmm0
mov [rax+10h], r14
loc_25897:
xorps xmm0, xmm0
movups xmmword ptr [rax+20h], xmm0
mov qword ptr [rax+30h], 0
mov [rax+38h], r13
test r15, r15
jz short loc_258C1
mov rcx, rax
add rcx, 20h ; ' '
movups xmm0, xmmword ptr [rbp+0]
movups xmmword ptr [rcx], xmm0
mov [rax+30h], r15
loc_258C1:
mov [rbx], rax
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEES3_EZNS1_12_GLOBAL__N_17composeESt8functionIS4_ES7_E3$_0E9_M_invokeERKSt9_Any_dataOS3_; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>),ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0>::_M_invoke(std::_Any_data const&,std::shared_ptr<ftxui::Node>&&)
mov [rbx+18h], rax
lea rax, _ZNSt17_Function_handlerIFSt10shared_ptrIN5ftxui4NodeEES3_EZNS1_12_GLOBAL__N_17composeESt8functionIS4_ES7_E3$_0E10_M_managerERSt9_Any_dataRKSA_St18_Manager_operation; std::_Function_handler<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>),ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rbx+10h], rax
mov rax, rbx
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_38]
call _ZZN5ftxui12_GLOBAL__N_17composeESt8functionIFSt10shared_ptrINS_4NodeEES4_EES6_EN3$_0D2Ev; ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0::~$_0()
mov rax, [rsp+arg_8]
test rax, rax
jz short loc_25913
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_25913:
mov rax, [rsp+arg_28]
test rax, rax
jz short loc_2592C
lea rdi, [rsp+arg_18]
mov rsi, rdi
mov edx, 3
call rax
loc_2592C:
mov rdi, rbx
call __Unwind_Resume
jmp short $+2
loc_25936:
mov rdi, rax
call __clang_call_terminate
| long long ftxui::operator|(long long a1, __int128 *a2, __int128 *a3)
{
__int128 v3; // xmm0
long long v4; // r12
long long v5; // r14
long long v6; // r13
long long v7; // r15
long long v8; // rax
__int128 v10; // [rsp+0h] [rbp-B8h]
__int128 v11; // [rsp+20h] [rbp-98h]
__int128 v12; // [rsp+40h] [rbp-78h]
__int128 v13; // [rsp+60h] [rbp-58h]
v3 = 0LL;
v11 = 0LL;
v4 = *((_QWORD *)a2 + 3);
v5 = *((_QWORD *)a2 + 2);
if ( v5 )
{
v11 = *a2;
a2[1] = 0LL;
}
v10 = 0LL;
v6 = *((_QWORD *)a3 + 3);
v7 = *((_QWORD *)a3 + 2);
if ( v7 )
{
v10 = *a3;
v3 = 0LL;
a3[1] = 0LL;
}
v12 = v3;
if ( v5 )
v12 = v11;
v13 = v3;
if ( v7 )
{
v13 = v10;
v3 = 0LL;
}
*(_OWORD *)(a1 + 16) = v3;
*(_OWORD *)a1 = v3;
v8 = operator new(0x40uLL);
*(_OWORD *)v8 = 0LL;
*(_QWORD *)(v8 + 16) = 0LL;
*(_QWORD *)(v8 + 24) = v4;
if ( v5 )
{
*(_OWORD *)v8 = v12;
*(_QWORD *)(v8 + 16) = v5;
}
*(_OWORD *)(v8 + 32) = 0LL;
*(_QWORD *)(v8 + 48) = 0LL;
*(_QWORD *)(v8 + 56) = v6;
if ( v7 )
{
*(_OWORD *)(v8 + 32) = v13;
*(_QWORD *)(v8 + 48) = v7;
}
*(_QWORD *)a1 = v8;
*(_QWORD *)(a1 + 24) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>),ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0>::_M_invoke;
*(_QWORD *)(a1 + 16) = std::_Function_handler<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>),ftxui::`anonymous namespace'::compose(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)::$_0>::_M_manager;
return a1;
}
| operator|:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x30],0x0
MOV R12,qword ptr [RSI + 0x18]
MOV qword ptr [RSP + 0x38],R12
MOV R14,qword ptr [RSI + 0x10]
TEST R14,R14
JZ 0x001257ce
MOVUPS XMM1,xmmword ptr [RSI]
ADD RSI,0x10
MOVAPS xmmword ptr [RSP + 0x20],XMM1
MOV qword ptr [RSP + 0x30],R14
MOVUPS xmmword ptr [RSI],XMM0
LAB_001257ce:
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
MOV R13,qword ptr [RDX + 0x18]
MOV qword ptr [RSP + 0x18],R13
MOV R15,qword ptr [RDX + 0x10]
TEST R15,R15
JZ 0x00125803
MOVUPS XMM0,xmmword ptr [RDX]
ADD RDX,0x10
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDX],XMM0
LAB_00125803:
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [RSP + 0x58],R12
TEST R14,R14
JZ 0x00125831
LEA RAX,[RSP + 0x30]
MOVAPS XMM1,xmmword ptr [RAX + -0x10]
MOVAPS xmmword ptr [RSP + 0x40],XMM1
MOV qword ptr [RSP + 0x50],R14
MOVUPS xmmword ptr [RAX],XMM0
LAB_00125831:
LEA RBP,[RSP + 0x60]
MOVAPS xmmword ptr [RBP],XMM0
MOV qword ptr [RBP + 0x10],0x0
MOV qword ptr [RBP + 0x18],R13
TEST R15,R15
JZ 0x00125863
LEA RAX,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [RAX + -0x10]
MOVUPS xmmword ptr [RBP],XMM0
MOV qword ptr [RSP + 0x70],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
LAB_00125863:
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_0012586a:
MOV EDI,0x40
CALL 0x0010b3e0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [RAX + 0x18],R12
TEST R14,R14
JZ 0x00125897
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],R14
LAB_00125897:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x20],XMM0
MOV qword ptr [RAX + 0x30],0x0
MOV qword ptr [RAX + 0x38],R13
TEST R15,R15
JZ 0x001258c1
MOV RCX,RAX
ADD RCX,0x20
MOVUPS XMM0,xmmword ptr [RBP]
MOVUPS xmmword ptr [RCX],XMM0
MOV qword ptr [RAX + 0x30],R15
LAB_001258c1:
MOV qword ptr [RBX],RAX
LEA RAX,[0x125e00]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x125ea8]
MOV qword ptr [RBX + 0x10],RAX
MOV RAX,RBX
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::TEMPNAMEPLACEHOLDERVALUE(std::function<std::shared_ptr<ftxui::Node>
(std::shared_ptr<ftxui::Node>)>, std::function<std::shared_ptr<ftxui::Node>
(std::shared_ptr<ftxui::Node>)>) */
ftxui * __thiscall ftxui::operator|(ftxui *this,int8 *param_2,int8 *param_3)
{
int8 uVar1;
long lVar2;
int8 uVar3;
long lVar4;
int8 *puVar5;
int8 local_b8;
int8 uStack_b0;
int8 local_98;
int8 uStack_90;
int8 local_78;
int8 uStack_70;
int8 local_58;
int8 uStack_50;
local_98 = 0;
uStack_90 = 0;
uVar1 = param_2[3];
lVar2 = param_2[2];
if (lVar2 != 0) {
local_98 = *param_2;
uStack_90 = param_2[1];
param_2[2] = 0;
param_2[3] = 0;
}
local_b8 = 0;
uStack_b0 = 0;
uVar3 = param_3[3];
lVar4 = param_3[2];
if (lVar4 != 0) {
local_b8 = *param_3;
uStack_b0 = param_3[1];
param_3[2] = 0;
param_3[3] = 0;
}
local_78 = 0;
uStack_70 = 0;
if (lVar2 != 0) {
local_78 = local_98;
uStack_70 = uStack_90;
}
local_58 = 0;
uStack_50 = 0;
if (lVar4 != 0) {
local_58 = local_b8;
uStack_50 = uStack_b0;
}
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0012586a to 00125873 has its CatchHandler @ 001258ef */
puVar5 = (int8 *)operator_new(0x40);
*puVar5 = 0;
puVar5[1] = 0;
puVar5[2] = 0;
puVar5[3] = uVar1;
if (lVar2 != 0) {
*puVar5 = local_78;
puVar5[1] = uStack_70;
puVar5[2] = lVar2;
}
puVar5[4] = 0;
puVar5[5] = 0;
puVar5[6] = 0;
puVar5[7] = uVar3;
if (lVar4 != 0) {
puVar5[4] = local_58;
puVar5[5] = uStack_50;
puVar5[6] = lVar4;
}
*(int8 **)this = puVar5;
*(code **)(this + 0x18) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>),ftxui::(anonymous_namespace)::compose(std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>)::$_0>
::_M_invoke;
*(code **)(this + 0x10) =
std::
_Function_handler<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>),ftxui::(anonymous_namespace)::compose(std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>,std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>)::$_0>
::_M_manager;
return this;
}
| |
24,413 | merkle_proof | corpus-core[P]colibri-stateless/src/util/ssz_merkle.c | static bool merkle_proof(merkle_proof_data_t* proof, gindex_t start, gindex_t end, bytes32_t out) {
bytes32_t tmp = {0};
bytes_t start_data = merkle_get_data(proof, start);
if (start_data.len != 32) return false;
memcpy(out, start_data.data, 32);
while (start > end) {
log_debug_full("%l: %x", start, bytes(out, 32));
/*
fprintf(stderr, "s: %llu ", start);
print_hex(stderr, bytes(out, 32), " : ", "\n");
*/
gindex_t witness = start & 1 ? start - 1 : start + 1;
bytes_t witness_data = merkle_get_data(proof, witness);
if (witness_data.data == NULL) {
// how do we find the start for calculating this witness?
for (int i = 0; i < proof->leafes_len && witness_data.data == NULL; i++) {
gindex_t path = proof->leafes_gindex[i];
for (; path > 1; path >>= 1) {
if (path == witness && merkle_proof(proof, proof->leafes_gindex[i], witness, tmp)) {
witness_data = bytes(tmp, 32);
break;
}
}
}
if (witness_data.data == NULL) return false;
}
if (start & 1)
sha256_merkle(witness_data, bytes(out, 32), out);
else
sha256_merkle(bytes(out, 32), witness_data, out);
start >>= 1;
}
return true;
} | O0 | c | merkle_proof:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x231c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa3750
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
cmpl $0x20, -0x60(%rbp)
je 0xa28fe
movb $0x0, -0x1(%rbp)
jmp 0xa2bd4
movq -0x28(%rbp), %rax
movq -0x58(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xa2bd0
jmp 0xa2934
movb $0x0, %al
callq 0xa7590
cmpl $0x5, %eax
jb 0xa29bb
leaq -0x78(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x231c0
movq -0x18(%rbp), %rdx
movl $0x20, -0x88(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x88(%rbp), %ecx
movq -0x80(%rbp), %r8
leaq -0x78(%rbp), %rdi
leaq 0x4521f(%rip), %rsi # 0xe7b9a
movb $0x0, %al
callq 0x9ebf0
movq 0x9663f(%rip), %rax # 0x138fc8
movq (%rax), %rdi
movq -0x70(%rbp), %r9
leaq 0x39b30(%rip), %rsi # 0xdc4c7
leaq 0x451e5(%rip), %rdx # 0xe7b83
leaq 0x451fc(%rip), %rcx # 0xe7ba1
movl $0x1e5, %r8d # imm = 0x1E5
movb $0x0, %al
callq 0x23160
leaq -0x78(%rbp), %rdi
callq 0x9e240
jmp 0xa29bd
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xa29dc
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0xa29eb
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xa3750
movl %eax, -0xa0(%rbp)
movq %rdx, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0xa2b40
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %ecx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpl 0x38(%rdx), %ecx
movb %al, -0xe9(%rbp)
jae 0xa2a56
cmpq $0x0, -0x98(%rbp)
sete %al
movb %al, -0xe9(%rbp)
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0xa2a65
jmp 0xa2b2b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x1, -0xb0(%rbp)
jbe 0xa2b15
movq -0xb0(%rbp), %rax
cmpq -0x90(%rbp), %rax
jne 0xa2afd
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x90(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq 0xa28b0
testb $0x1, %al
jne 0xa2aca
jmp 0xa2afd
movl $0x20, -0xc0(%rbp)
leaq -0x50(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xa2b15
jmp 0xa2aff
movq -0xb0(%rbp), %rax
shrq %rax
movq %rax, -0xb0(%rbp)
jmp 0xa2a7f
jmp 0xa2b17
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0xa2a2e
cmpq $0x0, -0x98(%rbp)
jne 0xa2b3e
movb $0x0, -0x1(%rbp)
jmp 0xa2bd4
jmp 0xa2b40
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xa2b88
movl $0x20, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x28(%rbp), %r8
movl -0xa0(%rbp), %edi
movq -0x98(%rbp), %rsi
movl -0xd0(%rbp), %edx
movq -0xc8(%rbp), %rcx
callq 0xa49e0
jmp 0xa2bc0
movl $0x20, -0xe0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x28(%rbp), %r8
movl -0xe0(%rbp), %edi
movq -0xd8(%rbp), %rsi
movl -0xa0(%rbp), %edx
movq -0x98(%rbp), %rcx
callq 0xa49e0
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x18(%rbp)
jmp 0xa2924
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| merkle_proof:
push rbp
mov rbp, rsp
sub rsp, 0F0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call merkle_get_data
mov [rbp+var_60], eax
mov [rbp+var_58], rdx
cmp [rbp+var_60], 20h ; ' '
jz short loc_A28FE
mov [rbp+var_1], 0
jmp loc_A2BD4
loc_A28FE:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_58]
mov rdx, [rcx]
mov [rax], rdx
mov rdx, [rcx+8]
mov [rax+8], rdx
mov rdx, [rcx+10h]
mov [rax+10h], rdx
mov rcx, [rcx+18h]
mov [rax+18h], rcx
loc_A2924:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jbe loc_A2BD0
jmp short $+2
loc_A2934:
mov al, 0
call c4_get_log_level
cmp eax, 5
jb short loc_A29BB
lea rdi, [rbp+var_78]
xor esi, esi
mov edx, 18h
call _memset
mov rdx, [rbp+var_18]
mov [rbp+var_88], 20h ; ' '
mov rax, [rbp+var_28]
mov [rbp+var_80], rax
mov ecx, [rbp+var_88]
mov r8, [rbp+var_80]
lea rdi, [rbp+var_78]
lea rsi, aLX; "%l: %x"
mov al, 0
call bprintf
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov r9, [rbp+var_70]
lea rsi, aS0m32mSD0mS; "%s\x1B[0m\x1B[32m %s:%d\x1B[0m %s\n"
lea rdx, a33mdebug; "\x1B[33mDEBUG"
lea rcx, aMerkleProof; "merkle_proof"
mov r8d, 1E5h
mov al, 0
call _fprintf
lea rdi, [rbp+var_78]
call buffer_free
loc_A29BB:
jmp short $+2
loc_A29BD:
mov rax, [rbp+var_18]
and rax, 1
cmp rax, 0
jz short loc_A29DC
mov rax, [rbp+var_18]
sub rax, 1
mov [rbp+var_E8], rax
jmp short loc_A29EB
loc_A29DC:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_E8], rax
loc_A29EB:
mov rax, [rbp+var_E8]
mov [rbp+var_90], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_90]
call merkle_get_data
mov dword ptr [rbp+var_A0], eax
mov [rbp+var_98], rdx
cmp [rbp+var_98], 0
jnz loc_A2B40
mov [rbp+var_A4], 0
loc_A2A2E:
mov ecx, [rbp+var_A4]
mov rdx, [rbp+var_10]
xor eax, eax
cmp ecx, [rdx+38h]
mov [rbp+var_E9], al
jnb short loc_A2A56
cmp [rbp+var_98], 0
setz al
mov [rbp+var_E9], al
loc_A2A56:
mov al, [rbp+var_E9]
test al, 1
jnz short loc_A2A65
jmp loc_A2B2B
loc_A2A65:
mov rax, [rbp+var_10]
mov rax, [rax+30h]
movsxd rcx, [rbp+var_A4]
mov rax, [rax+rcx*8]
mov [rbp+var_B0], rax
loc_A2A7F:
cmp [rbp+var_B0], 1
jbe loc_A2B15
mov rax, [rbp+var_B0]
cmp rax, [rbp+var_90]
jnz short loc_A2AFD
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
mov rax, [rax+30h]
movsxd rcx, [rbp+var_A4]
mov rsi, [rax+rcx*8]
mov rdx, [rbp+var_90]
lea rcx, [rbp+var_50]
call merkle_proof
test al, 1
jnz short loc_A2ACA
jmp short loc_A2AFD
loc_A2ACA:
mov dword ptr [rbp+var_C0], 20h ; ' '
lea rax, [rbp+var_50]
mov [rbp+var_B8], rax
mov rax, [rbp+var_C0]
mov [rbp+var_A0], rax
mov rax, [rbp+var_B8]
mov [rbp+var_98], rax
jmp short loc_A2B15
loc_A2AFD:
jmp short $+2
loc_A2AFF:
mov rax, [rbp+var_B0]
shr rax, 1
mov [rbp+var_B0], rax
jmp loc_A2A7F
loc_A2B15:
jmp short $+2
loc_A2B17:
mov eax, [rbp+var_A4]
add eax, 1
mov [rbp+var_A4], eax
jmp loc_A2A2E
loc_A2B2B:
cmp [rbp+var_98], 0
jnz short loc_A2B3E
mov [rbp+var_1], 0
jmp loc_A2BD4
loc_A2B3E:
jmp short $+2
loc_A2B40:
mov rax, [rbp+var_18]
and rax, 1
cmp rax, 0
jz short loc_A2B88
mov [rbp+var_D0], 20h ; ' '
mov rax, [rbp+var_28]
mov [rbp+var_C8], rax
mov r8, [rbp+var_28]
mov edi, dword ptr [rbp+var_A0]
mov rsi, [rbp+var_98]
mov edx, [rbp+var_D0]
mov rcx, [rbp+var_C8]
call sha256_merkle
jmp short loc_A2BC0
loc_A2B88:
mov [rbp+var_E0], 20h ; ' '
mov rax, [rbp+var_28]
mov [rbp+var_D8], rax
mov r8, [rbp+var_28]
mov edi, [rbp+var_E0]
mov rsi, [rbp+var_D8]
mov edx, dword ptr [rbp+var_A0]
mov rcx, [rbp+var_98]
call sha256_merkle
loc_A2BC0:
mov rax, [rbp+var_18]
shr rax, 1
mov [rbp+var_18], rax
jmp loc_A2924
loc_A2BD0:
mov [rbp+var_1], 1
loc_A2BD4:
mov al, [rbp+var_1]
and al, 1
add rsp, 0F0h
pop rbp
retn
| char merkle_proof(
long long a1,
unsigned long long a2,
unsigned long long a3,
_QWORD *a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
double a9,
double a10,
__m128 a11,
__m128 a12)
{
_QWORD *v12; // rdx
_QWORD *v13; // rax
_QWORD *v14; // rcx
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
_BYTE *v18; // rdx
char v20; // [rsp+0h] [rbp-F0h]
bool v21; // [rsp+7h] [rbp-E9h]
unsigned long long v22; // [rsp+8h] [rbp-E8h]
unsigned long long j; // [rsp+40h] [rbp-B0h]
unsigned int i; // [rsp+4Ch] [rbp-A4h]
unsigned int v25; // [rsp+50h] [rbp-A0h]
_BYTE *v26; // [rsp+58h] [rbp-98h]
unsigned int v27; // [rsp+78h] [rbp-78h] BYREF
const char *v28; // [rsp+80h] [rbp-70h]
int data; // [rsp+90h] [rbp-60h]
_QWORD *v30; // [rsp+98h] [rbp-58h]
_BYTE v31[40]; // [rsp+A0h] [rbp-50h] BYREF
_QWORD *v32; // [rsp+C8h] [rbp-28h]
unsigned long long v33; // [rsp+D0h] [rbp-20h]
unsigned long long v34; // [rsp+D8h] [rbp-18h]
long long v35; // [rsp+E0h] [rbp-10h]
v35 = a1;
v34 = a2;
v33 = a3;
v32 = a4;
memset(v31, 0LL, 32LL);
data = merkle_get_data(v35, v34);
v30 = v12;
if ( data != 32 )
return 0;
v13 = v32;
v14 = v30;
*v32 = *v30;
v13[1] = v14[1];
v13[2] = v14[2];
v13[3] = v14[3];
while ( v34 > v33 )
{
if ( (unsigned int)c4_get_log_level() >= 5 )
{
memset(&v27, 0LL, 24LL);
bprintf(&v27, (long long)"%l: %x", v34, 32LL, (long long)v32, v15, a5, a6, a7, a8, v16, v17, a11, a12, v20);
fprintf(stderr, "%s\x1B[0m\x1B[32m %s:%d\x1B[0m %s\n", "\x1B[33mDEBUG", "merkle_proof", 485, v28);
buffer_free((long long)&v27);
}
if ( (v34 & 1) != 0 )
v22 = v34 - 1;
else
v22 = v34 + 1;
v25 = merkle_get_data(v35, v22);
v26 = v18;
if ( !v18 )
{
for ( i = 0; ; ++i )
{
v21 = 0;
if ( i < *(_DWORD *)(v35 + 56) )
v21 = v26 == 0LL;
if ( !v21 )
break;
for ( j = *(_QWORD *)(*(_QWORD *)(v35 + 48) + 8LL * (int)i); j > 1; j >>= 1 )
{
if ( j == v22 && (merkle_proof(v35, *(_QWORD *)(*(_QWORD *)(v35 + 48) + 8LL * (int)i), v22, v31) & 1) != 0 )
{
v25 = 32;
v26 = v31;
break;
}
}
}
if ( !v26 )
return 0;
}
if ( (v34 & 1) != 0 )
sha256_merkle(v25, v26, 32LL, v32, v32);
else
sha256_merkle(32LL, v32, v25, v26, v32);
v34 >>= 1;
}
return 1;
}
| merkle_proof:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xf0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x001231c0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001a3750
MOV dword ptr [RBP + -0x60],EAX
MOV qword ptr [RBP + -0x58],RDX
CMP dword ptr [RBP + -0x60],0x20
JZ 0x001a28fe
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001a2bd4
LAB_001a28fe:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x58]
MOV RDX,qword ptr [RCX]
MOV qword ptr [RAX],RDX
MOV RDX,qword ptr [RCX + 0x8]
MOV qword ptr [RAX + 0x8],RDX
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RAX + 0x10],RDX
MOV RCX,qword ptr [RCX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_001a2924:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x001a2bd0
JMP 0x001a2934
LAB_001a2934:
MOV AL,0x0
CALL 0x001a7590
CMP EAX,0x5
JC 0x001a29bb
LEA RDI,[RBP + -0x78]
XOR ESI,ESI
MOV EDX,0x18
CALL 0x001231c0
MOV RDX,qword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x88],0x20
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x80],RAX
MOV ECX,dword ptr [RBP + -0x88]
MOV R8,qword ptr [RBP + -0x80]
LEA RDI,[RBP + -0x78]
LEA RSI,[0x1e7b9a]
MOV AL,0x0
CALL 0x0019ebf0
MOV RAX,qword ptr [0x00238fc8]
MOV RDI,qword ptr [RAX]
MOV R9,qword ptr [RBP + -0x70]
LEA RSI,[0x1dc4c7]
LEA RDX,[0x1e7b83]
LEA RCX,[0x1e7ba1]
MOV R8D,0x1e5
MOV AL,0x0
CALL 0x00123160
LEA RDI,[RBP + -0x78]
CALL 0x0019e240
LAB_001a29bb:
JMP 0x001a29bd
LAB_001a29bd:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001a29dc
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x1
MOV qword ptr [RBP + -0xe8],RAX
JMP 0x001a29eb
LAB_001a29dc:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0xe8],RAX
LAB_001a29eb:
MOV RAX,qword ptr [RBP + -0xe8]
MOV qword ptr [RBP + -0x90],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x90]
CALL 0x001a3750
MOV dword ptr [RBP + -0xa0],EAX
MOV qword ptr [RBP + -0x98],RDX
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x001a2b40
MOV dword ptr [RBP + -0xa4],0x0
LAB_001a2a2e:
MOV ECX,dword ptr [RBP + -0xa4]
MOV RDX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP ECX,dword ptr [RDX + 0x38]
MOV byte ptr [RBP + -0xe9],AL
JNC 0x001a2a56
CMP qword ptr [RBP + -0x98],0x0
SETZ AL
MOV byte ptr [RBP + -0xe9],AL
LAB_001a2a56:
MOV AL,byte ptr [RBP + -0xe9]
TEST AL,0x1
JNZ 0x001a2a65
JMP 0x001a2b2b
LAB_001a2a65:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOVSXD RCX,dword ptr [RBP + -0xa4]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0xb0],RAX
LAB_001a2a7f:
CMP qword ptr [RBP + -0xb0],0x1
JBE 0x001a2b15
MOV RAX,qword ptr [RBP + -0xb0]
CMP RAX,qword ptr [RBP + -0x90]
JNZ 0x001a2afd
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x30]
MOVSXD RCX,dword ptr [RBP + -0xa4]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV RDX,qword ptr [RBP + -0x90]
LEA RCX,[RBP + -0x50]
CALL 0x001a28b0
TEST AL,0x1
JNZ 0x001a2aca
JMP 0x001a2afd
LAB_001a2aca:
MOV dword ptr [RBP + -0xc0],0x20
LEA RAX,[RBP + -0x50]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001a2b15
LAB_001a2afd:
JMP 0x001a2aff
LAB_001a2aff:
MOV RAX,qword ptr [RBP + -0xb0]
SHR RAX,0x1
MOV qword ptr [RBP + -0xb0],RAX
JMP 0x001a2a7f
LAB_001a2b15:
JMP 0x001a2b17
LAB_001a2b17:
MOV EAX,dword ptr [RBP + -0xa4]
ADD EAX,0x1
MOV dword ptr [RBP + -0xa4],EAX
JMP 0x001a2a2e
LAB_001a2b2b:
CMP qword ptr [RBP + -0x98],0x0
JNZ 0x001a2b3e
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001a2bd4
LAB_001a2b3e:
JMP 0x001a2b40
LAB_001a2b40:
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x1
CMP RAX,0x0
JZ 0x001a2b88
MOV dword ptr [RBP + -0xd0],0x20
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xc8],RAX
MOV R8,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RBP + -0xa0]
MOV RSI,qword ptr [RBP + -0x98]
MOV EDX,dword ptr [RBP + -0xd0]
MOV RCX,qword ptr [RBP + -0xc8]
CALL 0x001a49e0
JMP 0x001a2bc0
LAB_001a2b88:
MOV dword ptr [RBP + -0xe0],0x20
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xd8],RAX
MOV R8,qword ptr [RBP + -0x28]
MOV EDI,dword ptr [RBP + -0xe0]
MOV RSI,qword ptr [RBP + -0xd8]
MOV EDX,dword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x98]
CALL 0x001a49e0
LAB_001a2bc0:
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001a2924
LAB_001a2bd0:
MOV byte ptr [RBP + -0x1],0x1
LAB_001a2bd4:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0xf0
POP RBP
RET
|
int1 merkle_proof(long param_1,ulong param_2,ulong param_3,int8 *param_4)
{
uint uVar1;
int4 uVar2;
ulong uVar3;
int1 *extraout_RDX;
int1 auVar4 [16];
ulong local_f0;
ulong local_b8;
uint local_ac;
int1 *local_a0;
int1 local_80 [8];
int8 local_78;
int4 local_68;
int8 *local_60;
int1 local_58 [40];
int8 *local_30;
ulong local_28;
ulong local_20;
long local_18;
int1 local_9;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
memset(local_58,0,0x20);
auVar4 = merkle_get_data(local_18);
local_60 = auVar4._8_8_;
if (auVar4._0_4_ == 0x20) {
*local_30 = *local_60;
local_30[1] = local_60[1];
local_30[2] = local_60[2];
local_30[3] = local_60[3];
local_68 = 0x20;
for (; local_28 < local_20; local_20 = local_20 >> 1) {
uVar1 = c4_get_log_level();
if (4 < uVar1) {
memset(local_80,0,0x18);
bprintf(local_80,&DAT_001e7b9a,local_20,0x20,local_30);
fprintf(*(FILE **)PTR_stderr_00238fc8,"%s\x1b[0m\x1b[32m %s:%d\x1b[0m %s\n",&DAT_001e7b83,
"merkle_proof",0x1e5,local_78);
buffer_free(local_80);
}
if ((local_20 & 1) == 0) {
local_f0 = local_20 + 1;
}
else {
local_f0 = local_20 - 1;
}
uVar2 = merkle_get_data(local_18,local_f0);
local_a0 = extraout_RDX;
if (extraout_RDX == (int1 *)0x0) {
for (local_ac = 0; local_ac < *(uint *)(local_18 + 0x38) && local_a0 == (int1 *)0x0;
local_ac = local_ac + 1) {
for (local_b8 = *(ulong *)(*(long *)(local_18 + 0x30) + (long)(int)local_ac * 8);
1 < local_b8; local_b8 = local_b8 >> 1) {
if ((local_b8 == local_f0) &&
(uVar3 = merkle_proof(local_18,*(int8 *)
(*(long *)(local_18 + 0x30) + (long)(int)local_ac * 8
),local_f0,local_58), (uVar3 & 1) != 0)) {
local_a0 = local_58;
uVar2 = 0x20;
break;
}
}
}
if (local_a0 == (int1 *)0x0) {
return 0;
}
}
if ((local_20 & 1) == 0) {
sha256_merkle(0x20,local_30,uVar2,local_a0,local_30);
}
else {
sha256_merkle(uVar2,local_a0,0x20,local_30,local_30);
}
}
local_9 = 1;
}
else {
local_9 = 0;
}
return local_9;
}
| |
24,414 | merkle_proof | corpus-core[P]colibri-stateless/src/util/ssz_merkle.c | static bool merkle_proof(merkle_proof_data_t* proof, gindex_t start, gindex_t end, bytes32_t out) {
bytes32_t tmp = {0};
bytes_t start_data = merkle_get_data(proof, start);
if (start_data.len != 32) return false;
memcpy(out, start_data.data, 32);
while (start > end) {
log_debug_full("%l: %x", start, bytes(out, 32));
/*
fprintf(stderr, "s: %llu ", start);
print_hex(stderr, bytes(out, 32), " : ", "\n");
*/
gindex_t witness = start & 1 ? start - 1 : start + 1;
bytes_t witness_data = merkle_get_data(proof, witness);
if (witness_data.data == NULL) {
// how do we find the start for calculating this witness?
for (int i = 0; i < proof->leafes_len && witness_data.data == NULL; i++) {
gindex_t path = proof->leafes_gindex[i];
for (; path > 1; path >>= 1) {
if (path == witness && merkle_proof(proof, proof->leafes_gindex[i], witness, tmp)) {
witness_data = bytes(tmp, 32);
break;
}
}
}
if (witness_data.data == NULL) return false;
}
if (start & 1)
sha256_merkle(witness_data, bytes(out, 32), out);
else
sha256_merkle(bytes(out, 32), witness_data, out);
start >>= 1;
}
return true;
} | O2 | c | merkle_proof:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
callq 0x4e181
cmpl $0x20, %eax
jne 0x4db57
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x40(%rsp), %rbp
movq %rbx, 0x10(%rsp)
movq %r14, 0x8(%rsp)
cmpq %r14, %r15
setbe %al
jbe 0x4db61
movl %eax, 0x4(%rsp)
xorl %eax, %eax
callq 0x504ab
cmpl $0x5, %eax
jae 0x4daec
movq %r15, %rax
andl $0x1, %r15d
negq %r15
orq $0x1, %r15
movq %rax, 0x18(%rsp)
addq %rax, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x4e181
movl %eax, %r13d
testq %rdx, %rdx
je 0x4da4f
movq %rdx, %rcx
jmp 0x4daba
xorl %r14d, %r14d
xorl %ecx, %ecx
testq %rcx, %rcx
jne 0x4daa7
movl 0x38(%r12), %eax
cmpq %rax, %r14
jae 0x4daa7
movq 0x30(%r12), %rax
movq (%rax,%r14,8), %rbx
cmpq $0x2, %rbx
jb 0x4da97
cmpq %r15, %rbx
jne 0x4da92
movq 0x30(%r12), %rax
movq (%rax,%r14,8), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x4d9af
testb %al, %al
jne 0x4da9b
shrq %rbx
jmp 0x4da6c
xorl %ecx, %ecx
jmp 0x4daa2
pushq $0x20
popq %r13
movq %rbp, %rcx
incq %r14
jmp 0x4da54
testq %rcx, %rcx
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
je 0x4db67
movq 0x18(%rsp), %r15
testb $0x1, %r15b
jne 0x4dad0
pushq $0x20
popq %rdi
movq %rbx, %rsi
movl %r13d, %edx
jmp 0x4dadc
movl %r13d, %edi
movq %rcx, %rsi
pushq $0x20
popq %rdx
movq %rbx, %rcx
movq %rbx, %r8
callq 0x4ec30
shrq %r15
jmp 0x4da01
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
andq $0x0, 0x30(%rsp)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
leaq 0x319e9(%rip), %rsi # 0x7f4f2
movq %r15, %rdx
pushq $0x20
popq %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x4b737
movq 0x6e4a8(%rip), %rax # 0xbbfc8
movq (%rax), %rdi
movq 0x28(%rsp), %r9
leaq 0x26910(%rip), %rsi # 0x7443f
leaq 0x319a5(%rip), %rdx # 0x7f4db
leaq 0x319bc(%rip), %rcx # 0x7f4f9
movl $0x1e5, %r8d # imm = 0x1E5
xorl %eax, %eax
callq 0x22140
movq %r13, %rdi
callq 0x4b16d
jmp 0x4da21
movl $0x0, 0x4(%rsp)
jmp 0x4db67
movb $0x1, %al
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| merkle_proof:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, rcx
mov r14, rdx
mov r15, rsi
mov r12, rdi
xorps xmm0, xmm0
movaps [rsp+98h+var_48], xmm0
movaps [rsp+98h+var_58], xmm0
call merkle_get_data
cmp eax, 20h ; ' '
jnz loc_4DB57
movups xmm0, xmmword ptr [rdx]
movups xmm1, xmmword ptr [rdx+10h]
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
lea rbp, [rsp+98h+var_58]
mov [rsp+98h+var_88], rbx
mov [rsp+98h+var_90], r14
loc_4DA01:
cmp r15, r14
setbe al
jbe loc_4DB61
mov [rsp+98h+var_94], eax
xor eax, eax
call c4_get_log_level
cmp eax, 5
jnb loc_4DAEC
loc_4DA21:
mov rax, r15
and r15d, 1
neg r15
or r15, 1
mov [rsp+98h+var_80], rax
add r15, rax
mov rdi, r12
mov rsi, r15
call merkle_get_data
mov r13d, eax
test rdx, rdx
jz short loc_4DA4F
mov rcx, rdx
jmp short loc_4DABA
loc_4DA4F:
xor r14d, r14d
xor ecx, ecx
loc_4DA54:
test rcx, rcx
jnz short loc_4DAA7
mov eax, [r12+38h]
cmp r14, rax
jnb short loc_4DAA7
mov rax, [r12+30h]
mov rbx, [rax+r14*8]
loc_4DA6C:
cmp rbx, 2
jb short loc_4DA97
cmp rbx, r15
jnz short loc_4DA92
mov rax, [r12+30h]
mov rsi, [rax+r14*8]
mov rdi, r12
mov rdx, r15
mov rcx, rbp
call merkle_proof
test al, al
jnz short loc_4DA9B
loc_4DA92:
shr rbx, 1
jmp short loc_4DA6C
loc_4DA97:
xor ecx, ecx
jmp short loc_4DAA2
loc_4DA9B:
push 20h ; ' '
pop r13
mov rcx, rbp
loc_4DAA2:
inc r14
jmp short loc_4DA54
loc_4DAA7:
test rcx, rcx
mov rbx, [rsp+98h+var_88]
mov r14, [rsp+98h+var_90]
jz loc_4DB67
loc_4DABA:
mov r15, [rsp+98h+var_80]
test r15b, 1
jnz short loc_4DAD0
push 20h ; ' '
pop rdi
mov rsi, rbx
mov edx, r13d
jmp short loc_4DADC
loc_4DAD0:
mov edi, r13d
mov rsi, rcx
push 20h ; ' '
pop rdx
mov rcx, rbx
loc_4DADC:
mov r8, rbx
call sha256_merkle
shr r15, 1
jmp loc_4DA01
loc_4DAEC:
xorps xmm0, xmm0
movaps [rsp+98h+var_78], xmm0
and [rsp+98h+var_68], 0
lea r13, [rsp+98h+var_78]
mov rdi, r13
lea rsi, aLX; "%l: %x"
mov rdx, r15
push 20h ; ' '
pop rcx
mov r8, rbx
xor eax, eax
call bprintf
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov r9, qword ptr [rsp+98h+var_78+8]
lea rsi, aS0m32mSD0mS; "%s\x1B[0m\x1B[32m %s:%d\x1B[0m %s\n"
lea rdx, a33mdebug; "\x1B[33mDEBUG"
lea rcx, aMerkleProof; "merkle_proof"
mov r8d, 1E5h
xor eax, eax
call _fprintf
mov rdi, r13
call buffer_free
jmp loc_4DA21
loc_4DB57:
mov [rsp+98h+var_94], 0
jmp short loc_4DB67
loc_4DB61:
mov al, 1
mov [rsp+98h+var_94], eax
loc_4DB67:
mov eax, [rsp+98h+var_94]
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long merkle_proof(long long a1, _OWORD *a2, unsigned long long a3, _OWORD *a4)
{
unsigned long long v6; // r15
long long v7; // r12
long long v8; // rax
__int128 *v9; // rdx
long long v10; // rcx
__int128 v11; // xmm0
long long v12; // r9
unsigned long long v13; // r15
_OWORD *v14; // rdx
unsigned int data; // r13d
_OWORD *v16; // rcx
unsigned long long v17; // r14
unsigned long long i; // rbx
long long v19; // rdx
unsigned int v21; // [rsp+4h] [rbp-94h]
unsigned long long v22; // [rsp+8h] [rbp-90h]
_OWORD *v23; // [rsp+10h] [rbp-88h]
unsigned long long v24; // [rsp+18h] [rbp-80h]
__int128 v25; // [rsp+20h] [rbp-78h] BYREF
long long v26; // [rsp+30h] [rbp-68h]
_OWORD v27[5]; // [rsp+40h] [rbp-58h] BYREF
v6 = (unsigned long long)a2;
v7 = a1;
memset(v27, 0, 32);
LODWORD(v8) = ((long long (*)(void))merkle_get_data)();
if ( (_DWORD)v8 == 32 )
{
v11 = *v9;
a4[1] = v9[1];
*a4 = v11;
v23 = a4;
v22 = a3;
while ( v6 > a3 )
{
LOBYTE(v8) = 0;
v21 = v8;
if ( (unsigned int)c4_get_log_level(a1, a2, v9, v10) >= 5 )
{
v25 = 0LL;
v26 = 0LL;
bprintf((unsigned int *)&v25, "%l: %x", v6, 32LL, (long long)a4, v12);
fprintf(
stderr,
"%s\x1B[0m\x1B[32m %s:%d\x1B[0m %s\n",
"\x1B[33mDEBUG",
"merkle_proof",
485,
*((const char **)&v25 + 1));
buffer_free((long long)&v25);
}
v24 = v6;
v13 = v6 + (-(long long)(v6 & 1) | 1);
data = merkle_get_data(v7, v13);
if ( v14 )
{
v16 = v14;
}
else
{
v17 = 0LL;
v16 = 0LL;
while ( !v16 && v17 < *(unsigned int *)(v7 + 56) )
{
for ( i = *(_QWORD *)(*(_QWORD *)(v7 + 48) + 8 * v17); ; i >>= 1 )
{
if ( i < 2 )
{
v16 = 0LL;
goto LABEL_18;
}
if ( i == v13 && (unsigned __int8)merkle_proof(v7, *(_QWORD *)(*(_QWORD *)(v7 + 48) + 8 * v17), v13, v27) )
break;
}
data = 32;
v16 = v27;
LABEL_18:
++v17;
}
a4 = v23;
a3 = v22;
if ( !v16 )
return v21;
}
if ( (v24 & 1) != 0 )
{
a1 = data;
a2 = v16;
v19 = 32LL;
v16 = a4;
}
else
{
a1 = 32LL;
a2 = a4;
v19 = data;
}
v8 = sha256_merkle(a1, a2, v19, v16, a4);
v6 = v24 >> 1;
}
LOBYTE(v8) = 1;
return (unsigned int)v8;
}
else
{
return 0;
}
}
| merkle_proof:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,RCX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
CALL 0x0014e181
CMP EAX,0x20
JNZ 0x0014db57
MOVUPS XMM0,xmmword ptr [RDX]
MOVUPS XMM1,xmmword ptr [RDX + 0x10]
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
LEA RBP,[RSP + 0x40]
MOV qword ptr [RSP + 0x10],RBX
MOV qword ptr [RSP + 0x8],R14
LAB_0014da01:
CMP R15,R14
SETBE AL
JBE 0x0014db61
MOV dword ptr [RSP + 0x4],EAX
XOR EAX,EAX
CALL 0x001504ab
CMP EAX,0x5
JNC 0x0014daec
LAB_0014da21:
MOV RAX,R15
AND R15D,0x1
NEG R15
OR R15,0x1
MOV qword ptr [RSP + 0x18],RAX
ADD R15,RAX
MOV RDI,R12
MOV RSI,R15
CALL 0x0014e181
MOV R13D,EAX
TEST RDX,RDX
JZ 0x0014da4f
MOV RCX,RDX
JMP 0x0014daba
LAB_0014da4f:
XOR R14D,R14D
XOR ECX,ECX
LAB_0014da54:
TEST RCX,RCX
JNZ 0x0014daa7
MOV EAX,dword ptr [R12 + 0x38]
CMP R14,RAX
JNC 0x0014daa7
MOV RAX,qword ptr [R12 + 0x30]
MOV RBX,qword ptr [RAX + R14*0x8]
LAB_0014da6c:
CMP RBX,0x2
JC 0x0014da97
CMP RBX,R15
JNZ 0x0014da92
MOV RAX,qword ptr [R12 + 0x30]
MOV RSI,qword ptr [RAX + R14*0x8]
MOV RDI,R12
MOV RDX,R15
MOV RCX,RBP
CALL 0x0014d9af
TEST AL,AL
JNZ 0x0014da9b
LAB_0014da92:
SHR RBX,0x1
JMP 0x0014da6c
LAB_0014da97:
XOR ECX,ECX
JMP 0x0014daa2
LAB_0014da9b:
PUSH 0x20
POP R13
MOV RCX,RBP
LAB_0014daa2:
INC R14
JMP 0x0014da54
LAB_0014daa7:
TEST RCX,RCX
MOV RBX,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x8]
JZ 0x0014db67
LAB_0014daba:
MOV R15,qword ptr [RSP + 0x18]
TEST R15B,0x1
JNZ 0x0014dad0
PUSH 0x20
POP RDI
MOV RSI,RBX
MOV EDX,R13D
JMP 0x0014dadc
LAB_0014dad0:
MOV EDI,R13D
MOV RSI,RCX
PUSH 0x20
POP RDX
MOV RCX,RBX
LAB_0014dadc:
MOV R8,RBX
CALL 0x0014ec30
SHR R15,0x1
JMP 0x0014da01
LAB_0014daec:
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
AND qword ptr [RSP + 0x30],0x0
LEA R13,[RSP + 0x20]
MOV RDI,R13
LEA RSI,[0x17f4f2]
MOV RDX,R15
PUSH 0x20
POP RCX
MOV R8,RBX
XOR EAX,EAX
CALL 0x0014b737
MOV RAX,qword ptr [0x001bbfc8]
MOV RDI,qword ptr [RAX]
MOV R9,qword ptr [RSP + 0x28]
LEA RSI,[0x17443f]
LEA RDX,[0x17f4db]
LEA RCX,[0x17f4f9]
MOV R8D,0x1e5
XOR EAX,EAX
CALL 0x00122140
MOV RDI,R13
CALL 0x0014b16d
JMP 0x0014da21
LAB_0014db57:
MOV dword ptr [RSP + 0x4],0x0
JMP 0x0014db67
LAB_0014db61:
MOV AL,0x1
MOV dword ptr [RSP + 0x4],EAX
LAB_0014db67:
MOV EAX,dword ptr [RSP + 0x4]
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int4 merkle_proof(long param_1,ulong param_2,ulong param_3,int8 *param_4)
{
int4 uVar1;
int4 uVar2;
int8 uVar3;
char cVar4;
uint uVar5;
int4 uVar6;
int7 uVar8;
int8 uVar7;
int8 *puVar9;
int8 *puVar10;
int4 uVar11;
int4 *puVar12;
int8 *extraout_RDX;
ulong uVar13;
ulong uVar14;
ulong uVar15;
int1 auVar16 [16];
int4 local_94;
int8 local_78;
int8 uStack_70;
int8 local_68;
int8 local_58;
int8 uStack_50;
int8 local_48;
int8 uStack_40;
local_48 = 0;
uStack_40 = 0;
local_58 = 0;
uStack_50 = 0;
auVar16 = merkle_get_data();
puVar12 = auVar16._8_8_;
uVar7 = auVar16._0_8_;
if (auVar16._0_4_ == 0x20) {
uVar6 = *puVar12;
uVar11 = puVar12[1];
uVar1 = puVar12[2];
uVar2 = puVar12[3];
uVar3 = *(int8 *)(puVar12 + 6);
param_4[2] = *(int8 *)(puVar12 + 4);
param_4[3] = uVar3;
*(int4 *)param_4 = uVar6;
*(int4 *)((long)param_4 + 4) = uVar11;
*(int4 *)(param_4 + 1) = uVar1;
*(int4 *)((long)param_4 + 0xc) = uVar2;
while( true ) {
uVar8 = (int7)((ulong)uVar7 >> 8);
if (param_2 <= param_3) break;
uVar5 = c4_get_log_level();
if (4 < uVar5) {
local_78 = 0;
uStack_70 = 0;
local_68 = 0;
bprintf(&local_78,&DAT_0017f4f2,param_2,0x20,param_4);
fprintf(*(FILE **)PTR_stderr_001bbfc8,"%s\x1b[0m\x1b[32m %s:%d\x1b[0m %s\n",&DAT_0017f4db,
"merkle_proof",0x1e5,uStack_70);
buffer_free(&local_78);
}
uVar15 = (-(ulong)((uint)param_2 & 1) | 1) + param_2;
uVar6 = merkle_get_data(param_1,uVar15);
puVar9 = extraout_RDX;
if (extraout_RDX == (int8 *)0x0) {
puVar9 = (int8 *)0x0;
for (uVar14 = 0; (puVar9 == (int8 *)0x0 && (uVar14 < *(uint *)(param_1 + 0x38)));
uVar14 = uVar14 + 1) {
for (uVar13 = *(ulong *)(*(long *)(param_1 + 0x30) + uVar14 * 8); 1 < uVar13;
uVar13 = uVar13 >> 1) {
if ((uVar13 == uVar15) &&
(cVar4 = merkle_proof(param_1,*(int8 *)(*(long *)(param_1 + 0x30) + uVar14 * 8)
,uVar15), cVar4 != '\0')) {
uVar6 = 0x20;
puVar9 = &local_58;
goto LAB_0014daa2;
}
}
puVar9 = (int8 *)0x0;
LAB_0014daa2:
}
if (puVar9 == (int8 *)0x0) {
return (int)CONCAT71(uVar8,param_2 <= param_3);
}
}
if ((param_2 & 1) == 0) {
puVar10 = puVar9;
puVar9 = param_4;
uVar11 = uVar6;
uVar6 = 0x20;
}
else {
uVar11 = 0x20;
puVar10 = param_4;
}
uVar7 = sha256_merkle(uVar6,puVar9,uVar11,puVar10,param_4);
param_2 = param_2 >> 1;
}
local_94 = (int4)CONCAT71(uVar8,1);
}
else {
local_94 = 0;
}
return local_94;
}
| |
24,415 | httplib::ThreadPool::worker::operator()() | nickolajgrishuk[P]metricz-cpp/build_O0/_deps/httplib-src/httplib.h | void operator()() {
for (;;) {
std::function<void()> fn;
{
std::unique_lock<std::mutex> lock(pool_.mutex_);
pool_.cond_.wait(
lock, [&] { return !pool_.jobs_.empty() || pool_.shutdown_; });
if (pool_.shutdown_ && pool_.jobs_.empty()) { break; }
fn = std::move(pool_.jobs_.front());
pool_.jobs_.pop_front();
}
assert(true == static_cast<bool>(fn));
fn();
}
} | O0 | c | httplib::ThreadPool::worker::operator()():
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10a90
movq -0x60(%rbp), %rax
movq (%rax), %rsi
addq $0x70, %rsi
leaq -0x38(%rbp), %rdi
callq 0x10ad0
jmp 0x10953
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x40, %rdi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x10b10
jmp 0x10971
movq -0x60(%rbp), %rax
movq (%rax), %rax
testb $0x1, 0x38(%rax)
je 0x109c8
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x10b60
testb $0x1, %al
jne 0x10994
jmp 0x109c8
movl $0x2, -0x54(%rbp)
jmp 0x109fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10a70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10c30
jmp 0x10a70
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x10b80
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x10bb0
movq -0x60(%rbp), %rax
movq (%rax), %rdi
addq $0x20, %rdi
callq 0x10c00
movl $0x0, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10c30
movl -0x54(%rbp), %eax
testl %eax, %eax
jne 0x10a57
jmp 0x10a0d
leaq -0x28(%rbp), %rdi
callq 0x10c70
andb $0x1, %al
movzbl %al, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x10a26
jmp 0x10a45
leaq 0x6525b(%rip), %rdi # 0x75c88
leaq 0x65162(%rip), %rsi # 0x75b96
movl $0x259, %edx # imm = 0x259
leaq 0x65266(%rip), %rcx # 0x75ca6
callq 0xa230
leaq -0x28(%rbp), %rdi
callq 0x10ca0
jmp 0x10a50
movl $0x0, -0x54(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10ce0
movl -0x54(%rbp), %eax
testl %eax, %eax
je 0x10a6b
jmp 0x10a69
jmp 0x10a7b
jmp 0x10934
leaq -0x28(%rbp), %rdi
callq 0x10ce0
jmp 0x10a81
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xa850
nopw (%rax,%rax)
| _ZN7httplib10ThreadPool6workerclEv:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_60], rax
loc_10934:
lea rdi, [rbp+var_28]
call _ZNSt8functionIFvvEEC2Ev; std::function<void ()(void)>::function(void)
mov rax, [rbp+var_60]
mov rsi, [rax]
add rsi, 70h ; 'p'
lea rdi, [rbp+var_38]
call _ZNSt11unique_lockISt5mutexEC2ERS0_; std::unique_lock<std::mutex>::unique_lock(std::mutex&)
jmp short $+2
loc_10953:
mov rax, [rbp+var_60]
mov rdi, [rax]
add rdi, 40h ; '@'
mov [rbp+var_50], rax
mov rdx, [rbp+var_50]
lea rsi, [rbp+var_38]
call _ZNSt18condition_variable4waitIZN7httplib10ThreadPool6workerclEvEUlvE_EEvRSt11unique_lockISt5mutexET_; std::condition_variable::wait<httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1}>(std::unique_lock<std::mutex> &,httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1})
jmp short $+2
loc_10971:
mov rax, [rbp+var_60]
mov rax, [rax]
test byte ptr [rax+38h], 1
jz short loc_109C8
mov rax, [rbp+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNKSt7__cxx114listISt8functionIFvvEESaIS3_EE5emptyEv; std::list<std::function<void ()(void)>>::empty(void)
test al, 1
jnz short loc_10994
jmp short loc_109C8
loc_10994:
mov [rbp+var_54], 2
jmp short loc_109FB
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
jmp loc_10A70
mov rcx, rax
mov eax, edx
mov [rbp+var_40], rcx
mov [rbp+var_44], eax
lea rdi, [rbp+var_38]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
jmp loc_10A70
loc_109C8:
mov rax, [rbp+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE5frontEv; std::list<std::function<void ()(void)>>::front(void)
mov rsi, rax
lea rdi, [rbp+var_28]
call _ZNSt8functionIFvvEEaSEOS1_; std::function<void ()(void)>::operator=(std::function<void ()(void)>&&)
mov rax, [rbp+var_60]
mov rdi, [rax]
add rdi, 20h ; ' '
call _ZNSt7__cxx114listISt8functionIFvvEESaIS3_EE9pop_frontEv; std::list<std::function<void ()(void)>>::pop_front(void)
mov [rbp+var_54], 0
loc_109FB:
lea rdi, [rbp+var_38]
call _ZNSt11unique_lockISt5mutexED2Ev; std::unique_lock<std::mutex>::~unique_lock()
mov eax, [rbp+var_54]
test eax, eax
jnz short loc_10A57
jmp short $+2
loc_10A0D:
lea rdi, [rbp+var_28]
call _ZNKSt8functionIFvvEEcvbEv; std::function<void ()(void)>::operator bool(void)
and al, 1
movzx ecx, al
mov eax, 1
cmp eax, ecx
jnz short loc_10A26
jmp short loc_10A45
loc_10A26:
lea rdi, aTrueStaticCast; "true == static_cast<bool>(fn)"
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
mov edx, 259h
lea rcx, aVoidHttplibThr; "void httplib::ThreadPool::worker::opera"...
call ___assert_fail
loc_10A45:
lea rdi, [rbp+var_28]
call _ZNKSt8functionIFvvEEclEv; std::function<void ()(void)>::operator()(void)
jmp short $+2
loc_10A50:
mov [rbp+var_54], 0
loc_10A57:
lea rdi, [rbp+var_28]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
mov eax, [rbp+var_54]
test eax, eax
jz short loc_10A6B
jmp short $+2
loc_10A69:
jmp short loc_10A7B
loc_10A6B:
jmp loc_10934
loc_10A70:
lea rdi, [rbp+var_28]
call _ZNSt8functionIFvvEED2Ev; std::function<void ()(void)>::~function()
jmp short loc_10A81
loc_10A7B:
add rsp, 60h
pop rbp
retn
loc_10A81:
mov rdi, [rbp+var_40]
call __Unwind_Resume
| long long httplib::ThreadPool::worker::operator()(long long a1)
{
long long v1; // rax
long long result; // rax
unsigned int v3; // [rsp+Ch] [rbp-54h]
_BYTE v4[16]; // [rsp+28h] [rbp-38h] BYREF
_BYTE v5[32]; // [rsp+38h] [rbp-28h] BYREF
long long v6; // [rsp+58h] [rbp-8h]
v6 = a1;
do
{
std::function<void ()(void)>::function(v5);
std::unique_lock<std::mutex>::unique_lock(v4, *(_QWORD *)a1 + 112LL);
std::condition_variable::wait<httplib::ThreadPool::worker::operator()(void)::{lambda(void)#1}>(
*(_QWORD *)a1 + 64LL,
v4,
a1);
if ( (*(_BYTE *)(*(_QWORD *)a1 + 56LL) & 1) != 0
&& (std::list<std::function<void ()(void)>>::empty(*(_QWORD *)a1 + 32LL) & 1) != 0 )
{
v3 = 2;
}
else
{
v1 = std::list<std::function<void ()(void)>>::front(*(_QWORD *)a1 + 32LL);
std::function<void ()(void)>::operator=(v5, v1);
std::list<std::function<void ()(void)>>::pop_front(*(_QWORD *)a1 + 32LL);
v3 = 0;
}
std::unique_lock<std::mutex>::~unique_lock(v4);
if ( !v3 )
{
if ( (std::function<void ()(void)>::operator bool(v5) & 1) != 1 )
__assert_fail(
"true == static_cast<bool>(fn)",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O0/_deps/httplib-src/httplib.h",
601LL,
"void httplib::ThreadPool::worker::operator()()");
std::function<void ()(void)>::operator()(v5);
v3 = 0;
}
std::function<void ()(void)>::~function(v5);
result = v3;
}
while ( !v3 );
return result;
}
| operator():
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x60],RAX
LAB_00110934:
LEA RDI,[RBP + -0x28]
CALL 0x00110a90
MOV RAX,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RAX]
ADD RSI,0x70
LAB_00110948:
LEA RDI,[RBP + -0x38]
CALL 0x00110ad0
JMP 0x00110953
LAB_00110953:
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX]
ADD RDI,0x40
MOV qword ptr [RBP + -0x50],RAX
MOV RDX,qword ptr [RBP + -0x50]
LAB_00110966:
LEA RSI,[RBP + -0x38]
CALL 0x00110b10
JMP 0x00110971
LAB_00110971:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX]
TEST byte ptr [RAX + 0x38],0x1
JZ 0x001109c8
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x00110b60
TEST AL,0x1
JNZ 0x00110994
JMP 0x001109c8
LAB_00110994:
MOV dword ptr [RBP + -0x54],0x2
JMP 0x001109fb
LAB_001109c8:
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x00110b80
MOV RSI,RAX
LEA RDI,[RBP + -0x28]
CALL 0x00110bb0
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,qword ptr [RAX]
ADD RDI,0x20
CALL 0x00110c00
MOV dword ptr [RBP + -0x54],0x0
LAB_001109fb:
LEA RDI,[RBP + -0x38]
CALL 0x00110c30
MOV EAX,dword ptr [RBP + -0x54]
TEST EAX,EAX
JNZ 0x00110a57
JMP 0x00110a0d
LAB_00110a0d:
LEA RDI,[RBP + -0x28]
CALL 0x00110c70
AND AL,0x1
MOVZX ECX,AL
MOV EAX,0x1
CMP EAX,ECX
JNZ 0x00110a26
JMP 0x00110a45
LAB_00110a26:
LEA RDI,[0x175c88]
LEA RSI,[0x175b96]
MOV EDX,0x259
LEA RCX,[0x175ca6]
CALL 0x0010a230
LAB_00110a45:
LEA RDI,[RBP + -0x28]
CALL 0x00110ca0
LAB_00110a4e:
JMP 0x00110a50
LAB_00110a50:
MOV dword ptr [RBP + -0x54],0x0
LAB_00110a57:
LEA RDI,[RBP + -0x28]
CALL 0x00110ce0
MOV EAX,dword ptr [RBP + -0x54]
TEST EAX,EAX
JZ 0x00110a6b
JMP 0x00110a69
LAB_00110a69:
JMP 0x00110a7b
LAB_00110a6b:
JMP 0x00110934
LAB_00110a7b:
ADD RSP,0x60
POP RBP
RET
|
/* httplib::ThreadPool::worker::TEMPNAMEPLACEHOLDERVALUE() */
void __thiscall httplib::ThreadPool::worker::operator()(worker *this)
{
bool bVar1;
ulong uVar2;
function *pfVar3;
unique_lock<std::mutex> local_40 [16];
function<void()> local_30 [32];
worker *local_10;
local_10 = this;
do {
std::function<void()>::function(local_30);
/* try { // try from 00110948 to 00110950 has its CatchHandler @ 0011099d */
std::unique_lock<std::mutex>::unique_lock(local_40,(mutex *)(*(long *)this + 0x70));
/* try { // try from 00110966 to 0011096e has its CatchHandler @ 001109ae */
std::condition_variable::operator()((condition_variable *)(*(long *)this + 0x40),local_40,this);
if (((*(byte *)(*(long *)this + 0x38) & 1) == 0) ||
(uVar2 = std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::
empty((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20)), (uVar2 & 1) == 0)) {
pfVar3 = (function *)
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::
front((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20));
std::function<void()>::operator=(local_30,pfVar3);
std::__cxx11::list<std::function<void()>,std::allocator<std::function<void()>>>::pop_front
((list<std::function<void()>,std::allocator<std::function<void()>>> *)
(*(long *)this + 0x20));
bVar1 = false;
}
else {
bVar1 = true;
}
std::unique_lock<std::mutex>::~unique_lock(local_40);
if (!bVar1) {
bVar1 = std::function::operator_cast_to_bool((function *)local_30);
if (!bVar1) {
/* WARNING: Subroutine does not return */
__assert_fail("true == static_cast<bool>(fn)",
"/workspace/llm4binary/github/2025_star3/nickolajgrishuk[P]metricz-cpp/build_O0/_deps/httplib-src/httplib.h"
,0x259,"void httplib::ThreadPool::worker::operator()()");
}
/* try { // try from 00110a45 to 00110a4d has its CatchHandler @ 0011099d */
std::function<void()>::operator()(local_30);
bVar1 = false;
}
std::function<void()>::~function(local_30);
} while (!bVar1);
return;
}
| |
24,416 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O0 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x982ae
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x982b6
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x360b0
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x98050
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x982f3
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x982f5
jmp 0x982f7
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x98309
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9830b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x927d0
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x98382
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x98382
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x362e0
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_982AE
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_982B6
loc_982AE:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_982B6:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_982F3
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_982F3:
jmp short $+2
loc_982F5:
jmp short $+2
loc_982F7:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_98309
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_98309:
jmp short $+2
loc_9830B:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse_nopad
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_98382
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_98382
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_38]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_98382:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v10],
(unsigned long long)&a2[v13],
(int)v13 - (int)v10,
a7,
0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
memset(&a2[v11], 0LL, a3 - v11);
return a3;
}
return v11;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001982ae
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x001982b6
LAB_001982ae:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_001982b6:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001360b0
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00198050
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x001982f3
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_001982f3:
JMP 0x001982f5
LAB_001982f5:
JMP 0x001982f7
LAB_001982f7:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x00198309
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_00198309:
JMP 0x0019830b
LAB_0019830b:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x001927d0
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x00198382
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x00198382
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x001362e0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_00198382:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
memset((void *)((long)param_2 + local_40),0,param_3 - local_40);
local_40 = param_3;
}
return local_40;
}
| |
24,417 | nglog::LogMessage::SendToSink() | ng-log[P]ng-log/src/logging.cc | EXCLUSIVE_LOCKS_REQUIRED(log_mutex) {
if (data_->sink_ != nullptr) {
RAW_DCHECK(data_->num_chars_to_log_ > 0 &&
data_->message_text_[data_->num_chars_to_log_ - 1] == '\n',
"");
data_->sink_->send(
data_->severity_, data_->fullname_, data_->basename_, data_->line_,
time_, data_->message_text_ + data_->num_prefix_chars_,
(data_->num_chars_to_log_ - data_->num_prefix_chars_ - 1));
}
} | O1 | cpp | nglog::LogMessage::SendToSink():
movq 0x8(%rdi), %rax
cmpq $0x0, 0x76b0(%rax)
je 0xb923
pushq %rbx
movq %rdi, %rbx
movq 0x76c0(%rax), %rcx
testq %rcx, %rcx
je 0xb8a1
cmpb $0xa, 0x3(%rcx,%rax)
je 0xb8ce
leaq 0x1805a(%rip), %rsi # 0x23902
leaq 0x1809a(%rip), %rcx # 0x23949
leaq 0x180a7(%rip), %r8 # 0x2395d
leaq 0x185b9(%rip), %r9 # 0x23e76
movl $0x3, %edi
movl $0x76b, %edx # imm = 0x76B
xorl %eax, %eax
callq 0x2040c
movq 0x8(%rbx), %rax
movq 0x76b0(%rax), %rdi
movq 0x76d8(%rax), %rdx
movq 0x76d0(%rax), %rcx
movl 0x7698(%rax), %esi
movl 0x769c(%rax), %r8d
addq $0x10, %rbx
movq 0x76b8(%rax), %r10
leaq (%rax,%r10), %r11
addq $0x4, %r11
notq %r10
addq 0x76c0(%rax), %r10
movq (%rdi), %rax
movq %rbx, %r9
pushq %r10
pushq %r11
callq *0x10(%rax)
addq $0x10, %rsp
popq %rbx
retq
| _ZN5nglog10LogMessage10SendToSinkEv:
mov rax, [rdi+8]
cmp qword ptr [rax+76B0h], 0
jz locret_B923
push rbx
mov rbx, rdi
mov rcx, [rax+76C0h]
test rcx, rcx
jz short loc_B8A1
cmp byte ptr [rcx+rax+3], 0Ah
jz short loc_B8CE
loc_B8A1:
lea rsi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aCheckSFailedS; "Check %s failed: %s"
lea r8, aDataNumCharsTo; "data_->num_chars_to_log_ > 0 && data_->"...
lea r9, asc_23E74+2; ""
mov edi, 3
mov edx, 76Bh
xor eax, eax
call _ZN5nglog6RawLogENS_11LogSeverityEPKciS2_z; nglog::RawLog(nglog::LogSeverity,char const*,int,char const*,...)
loc_B8CE:
mov rax, [rbx+8]
mov rdi, [rax+76B0h]
mov rdx, [rax+76D8h]
mov rcx, [rax+76D0h]
mov esi, [rax+7698h]
mov r8d, [rax+769Ch]
add rbx, 10h
mov r10, [rax+76B8h]
lea r11, [rax+r10]
add r11, 4
not r10
add r10, [rax+76C0h]
mov rax, [rdi]
mov r9, rbx
push r10
push r11
call qword ptr [rax+10h]
add rsp, 10h
pop rbx
locret_B923:
retn
| long long nglog::LogMessage::SendToSink(nglog::LogMessage *this)
{
char v1; // bl
long long result; // rax
long long v3; // rcx
long long v4; // rax
result = *((_QWORD *)this + 1);
if ( *(_QWORD *)(result + 30384) )
{
v3 = *(_QWORD *)(result + 30400);
if ( !v3 || *(_BYTE *)(v3 + result + 3) != 10 )
nglog::RawLog(
3,
(unsigned int)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",
1899,
(unsigned int)"Check %s failed: %s",
(unsigned int)"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == '\\n'",
(unsigned int)"",
v1);
v4 = *((_QWORD *)this + 1);
return (*(long long ( **)(_QWORD, _QWORD, _QWORD, _QWORD, _QWORD, char *, long long, _QWORD))(**(_QWORD **)(v4 + 30384) + 16LL))(
*(_QWORD *)(v4 + 30384),
*(unsigned int *)(v4 + 30360),
*(_QWORD *)(v4 + 30424),
*(_QWORD *)(v4 + 30416),
*(unsigned int *)(v4 + 30364),
(char *)this + 16,
v4 + *(_QWORD *)(v4 + 30392) + 4,
*(_QWORD *)(v4 + 30400) + ~*(_QWORD *)(v4 + 30392));
}
return result;
}
| SendToSink:
MOV RAX,qword ptr [RDI + 0x8]
CMP qword ptr [RAX + 0x76b0],0x0
JZ 0x0010b923
PUSH RBX
MOV RBX,RDI
MOV RCX,qword ptr [RAX + 0x76c0]
TEST RCX,RCX
JZ 0x0010b8a1
CMP byte ptr [RCX + RAX*0x1 + 0x3],0xa
JZ 0x0010b8ce
LAB_0010b8a1:
LEA RSI,[0x123902]
LEA RCX,[0x123949]
LEA R8,[0x12395d]
LEA R9,[0x123e76]
MOV EDI,0x3
MOV EDX,0x76b
XOR EAX,EAX
CALL 0x0012040c
LAB_0010b8ce:
MOV RAX,qword ptr [RBX + 0x8]
MOV RDI,qword ptr [RAX + 0x76b0]
MOV RDX,qword ptr [RAX + 0x76d8]
MOV RCX,qword ptr [RAX + 0x76d0]
MOV ESI,dword ptr [RAX + 0x7698]
MOV R8D,dword ptr [RAX + 0x769c]
ADD RBX,0x10
MOV R10,qword ptr [RAX + 0x76b8]
LEA R11,[RAX + R10*0x1]
ADD R11,0x4
NOT R10
ADD R10,qword ptr [RAX + 0x76c0]
MOV RAX,qword ptr [RDI]
MOV R9,RBX
PUSH R10
PUSH R11
CALL qword ptr [RAX + 0x10]
ADD RSP,0x10
POP RBX
LAB_0010b923:
RET
|
/* nglog::LogMessage::SendToSink() */
void __thiscall nglog::LogMessage::SendToSink(LogMessage *this)
{
long lVar1;
lVar1 = *(long *)(this + 8);
if (*(long *)(lVar1 + 0x76b0) != 0) {
if ((*(long *)(lVar1 + 0x76c0) == 0) ||
(*(char *)(*(long *)(lVar1 + 0x76c0) + 3 + lVar1) != '\n')) {
RawLog(3,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/logging.cc",0x76b,
"Check %s failed: %s",
"data_->num_chars_to_log_ > 0 && data_->message_text_[data_->num_chars_to_log_ - 1] == \'\\n\'"
,&DAT_00123e76);
}
lVar1 = *(long *)(this + 8);
(**(code **)(**(long **)(lVar1 + 0x76b0) + 0x10))
(*(long **)(lVar1 + 0x76b0),*(int4 *)(lVar1 + 0x7698),
*(int8 *)(lVar1 + 0x76d8),*(int8 *)(lVar1 + 0x76d0),
*(int4 *)(lVar1 + 0x769c),this + 0x10,lVar1 + *(ulong *)(lVar1 + 0x76b8) + 4,
~*(ulong *)(lVar1 + 0x76b8) + *(long *)(lVar1 + 0x76c0));
}
return;
}
| |
24,418 | ma_get_buffer_offset | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static void *ma_get_buffer_offset(MYSQL_STMT *stmt, enum enum_field_types type,
void *buffer, unsigned long row_nr)
{
if (stmt->param_callback)
return buffer;
if (stmt->array_size)
{
int len;
if (stmt->row_size)
return (void *)((char *)buffer + stmt->row_size * row_nr);
len= mysql_ps_fetch_functions[type].pack_len;
if (len > 0)
return (void *)((char *)buffer + len * row_nr);
return ((void **)buffer)[row_nr];
}
return buffer;
} | O0 | c | ma_get_buffer_offset:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x390(%rax)
je 0x4183e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x418c5
movq -0x10(%rbp), %rax
cmpl $0x0, 0x368(%rax)
je 0x418bd
movq -0x10(%rbp), %rax
cmpq $0x0, 0x370(%rax)
je 0x41876
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x370(%rcx), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x418c5
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0x3fb9e(%rip), %rax # 0x81420
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x418ab
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x418c5
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x418c5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| ma_get_buffer_offset:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+390h], 0
jz short loc_4183E
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_418C5
loc_4183E:
mov rax, [rbp+var_10]
cmp dword ptr [rax+368h], 0
jz short loc_418BD
mov rax, [rbp+var_10]
cmp qword ptr [rax+370h], 0
jz short loc_41876
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov rcx, [rcx+370h]
imul rcx, [rbp+var_28]
add rax, rcx
mov [rbp+var_8], rax
jmp short loc_418C5
loc_41876:
mov eax, [rbp+var_14]
mov ecx, eax
lea rax, mysql_ps_fetch_functions
imul rcx, 18h
add rax, rcx
mov eax, [rax+8]
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jle short loc_418AB
mov rax, [rbp+var_20]
movsxd rcx, [rbp+var_2C]
imul rcx, [rbp+var_28]
add rax, rcx
mov [rbp+var_8], rax
jmp short loc_418C5
loc_418AB:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_28]
mov rax, [rax+rcx*8]
mov [rbp+var_8], rax
jmp short loc_418C5
loc_418BD:
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_418C5:
mov rax, [rbp+var_8]
pop rbp
retn
| long long ma_get_buffer_offset(long long a1, int a2, long long a3, long long a4)
{
int v5; // [rsp+0h] [rbp-2Ch]
if ( *(_QWORD *)(a1 + 912) )
return a3;
if ( !*(_DWORD *)(a1 + 872) )
return a3;
if ( *(_QWORD *)(a1 + 880) )
return a4 * *(_QWORD *)(a1 + 880) + a3;
v5 = mysql_ps_fetch_functions[6 * a2 + 2];
if ( v5 <= 0 )
return *(_QWORD *)(a3 + 8 * a4);
else
return a4 * v5 + a3;
}
| ma_get_buffer_offset:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x390],0x0
JZ 0x0014183e
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001418c5
LAB_0014183e:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x368],0x0
JZ 0x001418bd
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x370],0x0
JZ 0x00141876
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x370]
IMUL RCX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001418c5
LAB_00141876:
MOV EAX,dword ptr [RBP + -0x14]
MOV ECX,EAX
LEA RAX,[0x181420]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001418ab
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,dword ptr [RBP + -0x2c]
IMUL RCX,qword ptr [RBP + -0x28]
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001418c5
LAB_001418ab:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001418c5
LAB_001418bd:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001418c5:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long ma_get_buffer_offset(long param_1,uint param_2,long param_3,long param_4)
{
long local_10;
local_10 = param_3;
if ((*(long *)(param_1 + 0x390) == 0) && (*(int *)(param_1 + 0x368) != 0)) {
if (*(long *)(param_1 + 0x370) == 0) {
if ((int)(&DAT_00181428)[(ulong)param_2 * 6] < 1) {
local_10 = *(long *)(param_3 + param_4 * 8);
}
else {
local_10 = param_3 + (int)(&DAT_00181428)[(ulong)param_2 * 6] * param_4;
}
}
else {
local_10 = param_3 + *(long *)(param_1 + 0x370) * param_4;
}
}
return local_10;
}
| |
24,419 | void testing::internal::PrintWithFallback<unsigned long>(unsigned long const&, std::ostream*) | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/gtest-printers.h | void PrintWithFallback(const T& value, ::std::ostream* os) {
using Printer = typename FindFirstPrinter<
T, void, ContainerPrinter, FunctionPointerPrinter, PointerPrinter,
ProtobufPrinter,
#ifdef GTEST_HAS_ABSL
ConvertibleToAbslStringifyPrinter,
#endif // GTEST_HAS_ABSL
internal_stream_operator_without_lexical_name_lookup::StreamPrinter,
ConvertibleToIntegerPrinter, ConvertibleToStringViewPrinter,
RawBytesPrinter, FallbackPrinter>::type;
Printer::PrintValue(value, os);
} | O0 | c | void testing::internal::PrintWithFallback<unsigned long>(unsigned long const&, std::ostream*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1efc0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN7testing8internal17PrintWithFallbackImEEvRKT_PSo:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_8]
mov rsi, [rsp+18h+var_10]
call _ZN7testing8internal52internal_stream_operator_without_lexical_name_lookup13StreamPrinter10PrintValueImvEEDTcvvlsdefp0_fp_ERKT_PSo
add rsp, 18h
retn
| long long testing::internal::PrintWithFallback<unsigned long>(long long a1, long long a2)
{
return testing::internal::internal_stream_operator_without_lexical_name_lookup::StreamPrinter::PrintValue<unsigned long,void>(
a1,
a2);
}
| PrintWithFallback<unsigned_long>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x0011efc0
ADD RSP,0x18
RET
|
/* void testing::internal::PrintWithFallback<unsigned long>(unsigned long const&, std::ostream*) */
void testing::internal::PrintWithFallback<unsigned_long>(ulong *param_1,ostream *param_2)
{
((void)((*{parm#2})<<{parm#1}))testing::internal::
internal_stream_operator_without_lexical_name_lookup::StreamPrinter::
PrintValue<unsigned_long,void>(param_1,param_2);
return;
}
| |
24,420 | my_wc_mb_cp932 | eloqsql/strings/ctype-cp932.c | static int
my_wc_mb_cp932(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if ((int) wc < 0x80) /* ASCII: [U+0000..U+007F] -> [00-7F] */
{
/*
This branch is for performance purposes on ASCII range,
to avoid using unicode_to_cp932[]: about 10% improvement.
*/
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= (uchar) wc;
return 1;
}
if (wc > 0xFFFF ||
!(code= unicode_to_cp932[wc])) /* Bad Unicode code point */
return MY_CS_ILUNI;
if (code <= 0xFF)
{
/* JIS-X-0201 HALF WIDTH KATAKANA [U+FF61..U+FF9F] -> [A1..DF] */
if (s >= e)
return MY_CS_TOOSMALL;
s[0]= code;
return 1;
}
if (s + 2 > e)
return MY_CS_TOOSMALL2;
MY_PUT_MB2(s, code); /* JIS-X-0208(MS) */
return 2;
} | O3 | c | my_wc_mb_cp932:
pushq %rbp
movq %rsp, %rbp
cmpl $0x7f, %esi
jg 0x4fa84
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x4fad2
movb %sil, (%rdx)
movl $0x1, %eax
jmp 0x4fad2
xorl %eax, %eax
cmpq $0xffff, %rsi # imm = 0xFFFF
ja 0x4fad2
leaq 0x6862a(%rip), %rdi # 0xb80c0
movzwl (%rdi,%rsi,2), %esi
testw %si, %si
je 0x4fad2
movzwl %si, %eax
cmpl $0xff, %eax
ja 0x4fab8
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x4fad2
movb %sil, (%rdx)
jmp 0x4fa7d
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x4fad2
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
popq %rbp
retq
| my_wc_mb_cp932:
push rbp
mov rbp, rsp
cmp esi, 7Fh
jg short loc_4FA84
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_4FAD2
mov [rdx], sil
loc_4FA7D:
mov eax, 1
jmp short loc_4FAD2
loc_4FA84:
xor eax, eax
cmp rsi, 0FFFFh
ja short loc_4FAD2
lea rdi, unicode_to_cp932
movzx esi, word ptr [rdi+rsi*2]
test si, si
jz short loc_4FAD2
movzx eax, si
cmp eax, 0FFh
ja short loc_4FAB8
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_4FAD2
mov [rdx], sil
jmp short loc_4FA7D
loc_4FAB8:
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_4FAD2
rol si, 8
mov [rdx], si
mov eax, 2
loc_4FAD2:
pop rbp
retn
| long long my_wc_mb_cp932(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
long long result; // rax
unsigned __int16 v5; // si
if ( (int)a2 <= 127 )
{
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
*a3 = a2;
return 1LL;
}
result = 0LL;
if ( a2 <= 0xFFFF )
{
v5 = unicode_to_cp932[a2];
if ( v5 )
{
if ( v5 > 0xFFu )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*(_WORD *)a3 = __ROL2__(v5, 8);
return 2LL;
}
}
else
{
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
*a3 = v5;
return 1LL;
}
}
}
}
return result;
}
| my_wc_mb_cp932:
PUSH RBP
MOV RBP,RSP
CMP ESI,0x7f
JG 0x0014fa84
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0014fad2
MOV byte ptr [RDX],SIL
LAB_0014fa7d:
MOV EAX,0x1
JMP 0x0014fad2
LAB_0014fa84:
XOR EAX,EAX
CMP RSI,0xffff
JA 0x0014fad2
LEA RDI,[0x1b80c0]
MOVZX ESI,word ptr [RDI + RSI*0x2]
TEST SI,SI
JZ 0x0014fad2
MOVZX EAX,SI
CMP EAX,0xff
JA 0x0014fab8
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0014fad2
MOV byte ptr [RDX],SIL
JMP 0x0014fa7d
LAB_0014fab8:
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x0014fad2
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
LAB_0014fad2:
POP RBP
RET
|
int8 my_wc_mb_cp932(int8 param_1,ulong param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
if ((int)param_2 < 0x80) {
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)param_2;
}
else {
if (0xffff < param_2) {
return 0;
}
uVar1 = *(ushort *)(unicode_to_cp932 + param_2 * 2);
if (uVar1 == 0) {
return 0;
}
if (0xff < uVar1) {
if (param_4 < param_3 + 1) {
return 0xffffff9a;
}
*param_3 = uVar1 << 8 | uVar1 >> 8;
return 2;
}
if (param_4 <= param_3) {
return 0xffffff9b;
}
*(char *)param_3 = (char)uVar1;
}
return 1;
}
| |
24,421 | link_to_file_list | eloqsql/mysys/mf_keycache.c | static void link_to_file_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block, int file,
my_bool unlink_block)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
DBUG_ASSERT(block->hash_link->file == file);
if (unlink_block)
unlink_changed(block);
link_changed(block, &keycache->file_blocks[FILE_HASH(file, keycache)]);
if (block->status & BLOCK_CHANGED)
{
block->status&= ~BLOCK_CHANGED;
keycache->blocks_changed--;
keycache->global_blocks_changed--;
}
} | O0 | c | link_to_file_list:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb %al, -0x15(%rbp)
jmp 0xe667a
jmp 0xe667c
jmp 0xe667e
jmp 0xe6680
jmp 0xe6682
cmpb $0x0, -0x15(%rbp)
je 0xe6691
movq -0x10(%rbp), %rdi
callq 0xe6840
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0xe6aa0
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xe66ff
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x138(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| link_to_file_list_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, cl
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_15], al
jmp short $+2
loc_E667A:
jmp short $+2
loc_E667C:
jmp short $+2
loc_E667E:
jmp short $+2
loc_E6680:
jmp short $+2
loc_E6682:
cmp [rbp+var_15], 0
jz short loc_E6691
mov rdi, [rbp+var_10]
call unlink_changed_0
loc_E6691:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax+130h]
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
mov ecx, [rcx+3Ch]
sub ecx, 1
and eax, ecx
mov eax, eax
shl rax, 3
add rsi, rax
call link_changed_0
mov rax, [rbp+var_10]
mov eax, [rax+50h]
and eax, 20h
cmp eax, 0
jz short loc_E66FF
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
and ecx, 0FFFFFFDFh
mov [rax+50h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+60h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+138h]
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rax+138h], rcx
loc_E66FF:
add rsp, 20h
pop rbp
retn
| long long link_to_file_list_0(long long a1, long long a2, unsigned int a3, char a4)
{
long long result; // rax
if ( a4 )
unlink_changed_0(a2);
link_changed_0(a2, 8LL * ((*(_DWORD *)(a1 + 60) - 1) & a3) + *(_QWORD *)(a1 + 304));
result = *(_DWORD *)(a2 + 80) & 0x20;
if ( (_DWORD)result )
{
*(_DWORD *)(a2 + 80) &= ~0x20u;
--*(_QWORD *)(a1 + 96);
result = a1;
--*(_QWORD *)(a1 + 312);
}
return result;
}
| link_to_file_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,CL
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV byte ptr [RBP + -0x15],AL
JMP 0x001e667a
LAB_001e667a:
JMP 0x001e667c
LAB_001e667c:
JMP 0x001e667e
LAB_001e667e:
JMP 0x001e6680
LAB_001e6680:
JMP 0x001e6682
LAB_001e6682:
CMP byte ptr [RBP + -0x15],0x0
JZ 0x001e6691
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e6840
LAB_001e6691:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x130]
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3c]
SUB ECX,0x1
AND EAX,ECX
MOV EAX,EAX
SHL RAX,0x3
ADD RSI,RAX
CALL 0x001e6aa0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x50]
AND EAX,0x20
CMP EAX,0x0
JZ 0x001e66ff
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
AND ECX,0xffffffdf
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x60]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x138]
ADD RCX,-0x1
MOV qword ptr [RAX + 0x138],RCX
LAB_001e66ff:
ADD RSP,0x20
POP RBP
RET
|
void link_to_file_list(long param_1,long param_2,uint param_3,char param_4)
{
if (param_4 != '\0') {
unlink_changed(param_2);
}
link_changed(param_2,*(long *)(param_1 + 0x130) +
(ulong)(param_3 & *(int *)(param_1 + 0x3c) - 1U) * 8);
if ((*(uint *)(param_2 + 0x50) & 0x20) != 0) {
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) & 0xffffffdf;
*(long *)(param_1 + 0x60) = *(long *)(param_1 + 0x60) + -1;
*(long *)(param_1 + 0x138) = *(long *)(param_1 + 0x138) + -1;
}
return;
}
| |
24,422 | my_strxfrm_flag_normalize | eloqsql/strings/ctype-simple.c | uint my_strxfrm_flag_normalize(uint flags, uint maximum)
{
DBUG_ASSERT(maximum >= 1 && maximum <= MY_STRXFRM_NLEVELS);
/* If levels are omitted, then 1-maximum is assumed*/
if (!(flags & MY_STRXFRM_LEVEL_ALL))
{
static uint def_level_flags[]= {0, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F };
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
flags= def_level_flags[maximum] | flag_pad;
}
else
{
uint i;
uint flag_lev= flags & MY_STRXFRM_LEVEL_ALL;
uint flag_dsc= (flags >> MY_STRXFRM_DESC_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_rev= (flags >> MY_STRXFRM_REVERSE_SHIFT) & MY_STRXFRM_LEVEL_ALL;
uint flag_pad= flags &
(MY_STRXFRM_PAD_WITH_SPACE | MY_STRXFRM_PAD_TO_MAXLEN);
/*
If any level number is greater than the maximum,
it is treated as the maximum.
*/
for (maximum--, flags= 0, i= 0; i < MY_STRXFRM_NLEVELS; i++)
{
uint src_bit= 1 << i;
if (flag_lev & src_bit)
{
uint dst_bit= 1 << MY_MIN(i, maximum);
flags|= dst_bit;
flags|= (flag_dsc & dst_bit) << MY_STRXFRM_DESC_SHIFT;
flags|= (flag_rev & dst_bit) << MY_STRXFRM_REVERSE_SHIFT;
}
}
flags|= flag_pad;
}
return flags;
} | O0 | c | my_strxfrm_flag_normalize:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
jmp 0x7aa8c
movl -0x4(%rbp), %eax
andl $0x3f, %eax
cmpl $0x0, %eax
jne 0x7aabc
movl -0x4(%rbp), %eax
andl $0xc0, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x23fc32(%rip), %rax # 0x2ba6e0
movl (%rax,%rcx,4), %eax
orl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ab7d
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0x3f, %eax
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
andl $0xc0, %eax
movl %eax, -0x20(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x6, -0x10(%rbp)
jae 0x7ab74
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
andl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0x7ab67
movl -0x10(%rbp), %eax
cmpl -0x8(%rbp), %eax
jae 0x7ab2d
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x7ab33
movl -0x8(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
andl -0x28(%rbp), %eax
shll $0x8, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %eax
andl -0x28(%rbp), %eax
shll $0x10, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ab69
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7aaff
movl -0x20(%rbp), %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strxfrm_flag_normalize:
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
jmp short $+2
loc_7AA8C:
mov eax, [rbp+var_4]
and eax, 3Fh
cmp eax, 0
jnz short loc_7AABC
mov eax, [rbp+var_4]
and eax, 0C0h
mov [rbp+var_C], eax
mov eax, [rbp+var_8]
mov ecx, eax
lea rax, my_strxfrm_flag_normalize_def_level_flags
mov eax, [rax+rcx*4]
or eax, [rbp+var_C]
mov [rbp+var_4], eax
jmp loc_7AB7D
loc_7AABC:
mov eax, [rbp+var_4]
and eax, 3Fh
mov [rbp+var_14], eax
mov eax, [rbp+var_4]
shr eax, 8
and eax, 3Fh
mov [rbp+var_18], eax
mov eax, [rbp+var_4]
shr eax, 10h
and eax, 3Fh
mov [rbp+var_1C], eax
mov eax, [rbp+var_4]
and eax, 0C0h
mov [rbp+var_20], eax
mov eax, [rbp+var_8]
add eax, 0FFFFFFFFh
mov [rbp+var_8], eax
mov [rbp+var_4], 0
mov [rbp+var_10], 0
loc_7AAFF:
cmp [rbp+var_10], 6
jnb short loc_7AB74
mov ecx, [rbp+var_10]
mov eax, 1
shl eax, cl
mov [rbp+var_24], eax
mov eax, [rbp+var_14]
and eax, [rbp+var_24]
cmp eax, 0
jz short loc_7AB67
mov eax, [rbp+var_10]
cmp eax, [rbp+var_8]
jnb short loc_7AB2D
mov eax, [rbp+var_10]
mov [rbp+var_2C], eax
jmp short loc_7AB33
loc_7AB2D:
mov eax, [rbp+var_8]
mov [rbp+var_2C], eax
loc_7AB33:
mov ecx, [rbp+var_2C]
mov eax, 1
shl eax, cl
mov [rbp+var_28], eax
mov eax, [rbp+var_28]
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_18]
and eax, [rbp+var_28]
shl eax, 8
or eax, [rbp+var_4]
mov [rbp+var_4], eax
mov eax, [rbp+var_1C]
and eax, [rbp+var_28]
shl eax, 10h
or eax, [rbp+var_4]
mov [rbp+var_4], eax
loc_7AB67:
jmp short $+2
loc_7AB69:
mov eax, [rbp+var_10]
add eax, 1
mov [rbp+var_10], eax
jmp short loc_7AAFF
loc_7AB74:
mov eax, [rbp+var_20]
or eax, [rbp+var_4]
mov [rbp+var_4], eax
loc_7AB7D:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_strxfrm_flag_normalize(unsigned int a1, int a2)
{
char v3; // [rsp+0h] [rbp-2Ch]
unsigned int i; // [rsp+1Ch] [rbp-10h]
int v6; // [rsp+28h] [rbp-4h]
if ( (a1 & 0x3F) != 0 )
{
v6 = 0;
for ( i = 0; i < 6; ++i )
{
if ( ((1 << i) & a1 & 0x3F) != 0 )
{
if ( i >= a2 - 1 )
v3 = a2 - 1;
else
v3 = i;
v6 |= (1 << v3) | (((1 << v3) & (a1 >> 8) & 0x3F) << 8) | (((1 << v3) & HIWORD(a1) & 0x3F) << 16);
}
}
return v6 | a1 & 0xC0;
}
else
{
return a1 & 0xC0 | my_strxfrm_flag_normalize_def_level_flags[a2];
}
}
| my_strxfrm_flag_normalize:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
JMP 0x0017aa8c
LAB_0017aa8c:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x3f
CMP EAX,0x0
JNZ 0x0017aabc
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xc0
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV ECX,EAX
LEA RAX,[0x3ba6e0]
MOV EAX,dword ptr [RAX + RCX*0x4]
OR EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0017ab7d
LAB_0017aabc:
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0x3f
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x8
AND EAX,0x3f
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x4]
SHR EAX,0x10
AND EAX,0x3f
MOV dword ptr [RBP + -0x1c],EAX
MOV EAX,dword ptr [RBP + -0x4]
AND EAX,0xc0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x8]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x8],EAX
MOV dword ptr [RBP + -0x4],0x0
MOV dword ptr [RBP + -0x10],0x0
LAB_0017aaff:
CMP dword ptr [RBP + -0x10],0x6
JNC 0x0017ab74
MOV ECX,dword ptr [RBP + -0x10]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x14]
AND EAX,dword ptr [RBP + -0x24]
CMP EAX,0x0
JZ 0x0017ab67
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RBP + -0x8]
JNC 0x0017ab2d
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x0017ab33
LAB_0017ab2d:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x2c],EAX
LAB_0017ab33:
MOV ECX,dword ptr [RBP + -0x2c]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x28],EAX
MOV EAX,dword ptr [RBP + -0x28]
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,dword ptr [RBP + -0x28]
SHL EAX,0x8
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
MOV EAX,dword ptr [RBP + -0x1c]
AND EAX,dword ptr [RBP + -0x28]
SHL EAX,0x10
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017ab67:
JMP 0x0017ab69
LAB_0017ab69:
MOV EAX,dword ptr [RBP + -0x10]
ADD EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
JMP 0x0017aaff
LAB_0017ab74:
MOV EAX,dword ptr [RBP + -0x20]
OR EAX,dword ptr [RBP + -0x4]
MOV dword ptr [RBP + -0x4],EAX
LAB_0017ab7d:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint my_strxfrm_flag_normalize(uint param_1,uint param_2)
{
uint uVar1;
uint local_34;
uint local_18;
uint local_c;
if ((param_1 & 0x3f) == 0) {
local_c = *(uint *)(my_strxfrm_flag_normalize_def_level_flags + (ulong)param_2 * 4) |
param_1 & 0xc0;
}
else {
local_c = 0;
for (local_18 = 0; local_18 < 6; local_18 = local_18 + 1) {
if ((param_1 & 0x3f & 1 << ((byte)local_18 & 0x1f)) != 0) {
local_34 = param_2 - 1;
if (local_18 < param_2 - 1) {
local_34 = local_18;
}
uVar1 = 1 << ((byte)local_34 & 0x1f);
local_c = (param_1 >> 0x10 & 0x3f & uVar1) << 0x10 |
(param_1 >> 8 & 0x3f & uVar1) << 8 | uVar1 | local_c;
}
}
local_c = param_1 & 0xc0 | local_c;
}
return local_c;
}
| |
24,423 | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned int>(char*, unsigned int, int) | AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR20 auto format_decimal(Char* out, UInt value, int size)
-> format_decimal_result<Char*> {
FMT_ASSERT(size >= count_digits(value), "invalid digit count");
out += size;
Char* end = out;
while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead
// of for every digit. The idea comes from the talk by Alexandrescu
// "Three Optimization Tips for C++". See speed-test for a comparison.
out -= 2;
copy2(out, digits2(static_cast<size_t>(value % 100)));
value /= 100;
}
if (value < 10) {
*--out = static_cast<Char>('0' + value);
return {out, end};
}
out -= 2;
copy2(out, digits2(static_cast<size_t>(value)));
return {out, end};
} | O0 | c | fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned int>(char*, unsigned int, int):
subq $0x68, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %edi
callq 0x55620
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
setge %al
andb $0x1, %al
movb %al, 0x27(%rsp)
leaq 0x27(%rsp), %rdi
leaq 0xc21c0(%rip), %rsi # 0x11769f
callq 0x55610
movl 0x28(%rsp), %ecx
movq 0x30(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x64, 0x2c(%rsp)
jb 0x55569
movq 0x30(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
movl %eax, %edi
callq 0x55660
movq 0x8(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movl 0x2c(%rsp), %eax
movl $0x64, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, 0x2c(%rsp)
jmp 0x55502
cmpl $0xa, 0x2c(%rsp)
jae 0x555a3
movl 0x2c(%rsp), %eax
addl $0x30, %eax
movb %al, %cl
movq 0x30(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, 0x30(%rsp)
movb %cl, -0x1(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x555f7
movq 0x30(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movl 0x2c(%rsp), %eax
movl %eax, %edi
callq 0x55660
movq (%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
movw (%rcx), %cx
movw %cx, (%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN3fmt3v106detail14format_decimalIcjEENS1_21format_decimal_resultIPT_EES5_T0_i:
sub rsp, 68h
mov [rsp+68h+var_3C+4], rdi
mov dword ptr [rsp+68h+var_3C], esi
mov [rsp+68h+var_40], edx
mov eax, [rsp+68h+var_40]
mov [rsp+68h+var_54], eax
mov edi, dword ptr [rsp+68h+var_3C]; this
call _ZN3fmt3v106detail12count_digitsEj; fmt::v10::detail::count_digits(uint)
mov ecx, eax
mov eax, [rsp+68h+var_54]
cmp eax, ecx
setnl al
and al, 1
mov [rsp+68h+var_41], al
lea rdi, [rsp+68h+var_41]
lea rsi, aInvalidDigitCo; "invalid digit count"
call _ZN3fmt3v106detail13ignore_unusedIJbA20_cEEEvDpRKT_; fmt::v10::detail::ignore_unused<bool,char [20]>(bool,char [20] const&)
mov ecx, [rsp+68h+var_40]
mov rax, [rsp+68h+var_3C+4]
movsxd rcx, ecx
add rax, rcx
mov [rsp+68h+var_3C+4], rax
mov rax, [rsp+68h+var_3C+4]
mov [rsp+68h+var_50], rax
loc_55502:
cmp dword ptr [rsp+68h+var_3C], 64h ; 'd'
jb short loc_55569
mov rax, [rsp+68h+var_3C+4]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+68h+var_3C+4], rax
mov rax, [rsp+68h+var_3C+4]
mov [rsp+68h+var_60], rax
mov eax, dword ptr [rsp+68h+var_3C]
mov ecx, 64h ; 'd'
xor edx, edx
div ecx
mov eax, edx
mov edi, eax; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+68h+var_60]
mov [rsp+68h+var_8], rcx
mov [rsp+68h+var_10], rax
mov rax, [rsp+68h+var_8]
mov rcx, [rsp+68h+var_10]
mov cx, [rcx]
mov [rax], cx
mov eax, dword ptr [rsp+68h+var_3C]
mov ecx, 64h ; 'd'
xor edx, edx
div ecx
mov dword ptr [rsp+68h+var_3C], eax
jmp short loc_55502
loc_55569:
cmp dword ptr [rsp+68h+var_3C], 0Ah
jnb short loc_555A3
mov eax, dword ptr [rsp+68h+var_3C]
add eax, 30h ; '0'
mov cl, al
mov rax, [rsp+68h+var_3C+4]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rsp+68h+var_3C+4], rdx
mov [rax-1], cl
mov rax, [rsp+68h+var_3C+4]
mov [rsp+68h+var_30], rax
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_28], rax
jmp short loc_555F7
loc_555A3:
mov rax, [rsp+68h+var_3C+4]
add rax, 0FFFFFFFFFFFFFFFEh
mov [rsp+68h+var_3C+4], rax
mov rax, [rsp+68h+var_3C+4]
mov [rsp+68h+var_68], rax
mov eax, dword ptr [rsp+68h+var_3C]
mov edi, eax; this
call _ZN3fmt3v106detail7digits2Em; fmt::v10::detail::digits2(ulong)
mov rcx, [rsp+68h+var_68]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_20], rax
mov rax, [rsp+68h+var_18]
mov rcx, [rsp+68h+var_20]
mov cx, [rcx]
mov [rax], cx
mov rax, [rsp+68h+var_3C+4]
mov [rsp+68h+var_30], rax
mov rax, [rsp+68h+var_50]
mov [rsp+68h+var_28], rax
loc_555F7:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long fmt::v10::detail::format_decimal<char,unsigned int>(long long a1, unsigned int a2, int a3)
{
_WORD *v3; // rax
long long v4; // rax
_WORD *v5; // rax
_WORD *v7; // [rsp+0h] [rbp-68h]
_WORD *v8; // [rsp+8h] [rbp-60h]
bool v9; // [rsp+27h] [rbp-41h] BYREF
int v10; // [rsp+28h] [rbp-40h]
_DWORD v11[3]; // [rsp+2Ch] [rbp-3Ch]
_WORD *v12; // [rsp+48h] [rbp-20h]
_WORD *v13; // [rsp+50h] [rbp-18h]
_WORD *v14; // [rsp+58h] [rbp-10h]
_WORD *v15; // [rsp+60h] [rbp-8h]
*(_QWORD *)&v11[1] = a1;
v11[0] = a2;
v10 = a3;
v9 = a3 >= (int)fmt::v10::detail::count_digits((fmt::v10::detail *)a2, a2);
fmt::v10::detail::ignore_unused<bool,char [20]>(&v9, "invalid digit count");
*(_QWORD *)&v11[1] += v10;
while ( v11[0] >= 0x64u )
{
*(_QWORD *)&v11[1] -= 2LL;
v8 = *(_WORD **)&v11[1];
v3 = (_WORD *)fmt::v10::detail::digits2(
(fmt::v10::detail *)(v11[0] % 0x64u),
(unsigned long long)"invalid digit count");
v15 = v8;
v14 = v3;
*v8 = *v3;
v11[0] /= 0x64u;
}
if ( v11[0] >= 0xAu )
{
*(_QWORD *)&v11[1] -= 2LL;
v7 = *(_WORD **)&v11[1];
v5 = (_WORD *)fmt::v10::detail::digits2((fmt::v10::detail *)v11[0], (unsigned long long)"invalid digit count");
v13 = v7;
v12 = v5;
*v7 = *v5;
}
else
{
v4 = (*(_QWORD *)&v11[1])--;
*(_BYTE *)(v4 - 1) = LOBYTE(v11[0]) + 48;
}
return *(_QWORD *)&v11[1];
}
| format_decimal<char,unsigned_int>:
SUB RSP,0x68
MOV qword ptr [RSP + 0x30],RDI
MOV dword ptr [RSP + 0x2c],ESI
MOV dword ptr [RSP + 0x28],EDX
MOV EAX,dword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x14],EAX
MOV EDI,dword ptr [RSP + 0x2c]
CALL 0x00155620
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x14]
CMP EAX,ECX
SETGE AL
AND AL,0x1
MOV byte ptr [RSP + 0x27],AL
LEA RDI,[RSP + 0x27]
LEA RSI,[0x21769f]
CALL 0x00155610
MOV ECX,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x30]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x18],RAX
LAB_00155502:
CMP dword ptr [RSP + 0x2c],0x64
JC 0x00155569
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x8],RAX
MOV EAX,dword ptr [RSP + 0x2c]
MOV ECX,0x64
XOR EDX,EDX
DIV ECX
MOV EAX,EDX
MOV EDI,EAX
CALL 0x00155660
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x60],RCX
MOV qword ptr [RSP + 0x58],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RSP + 0x58]
MOV CX,word ptr [RCX]
MOV word ptr [RAX],CX
MOV EAX,dword ptr [RSP + 0x2c]
MOV ECX,0x64
XOR EDX,EDX
DIV ECX
MOV dword ptr [RSP + 0x2c],EAX
JMP 0x00155502
LAB_00155569:
CMP dword ptr [RSP + 0x2c],0xa
JNC 0x001555a3
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x30]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RSP + 0x30],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001555f7
LAB_001555a3:
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,-0x2
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP],RAX
MOV EAX,dword ptr [RSP + 0x2c]
MOV EDI,EAX
CALL 0x00155660
MOV RCX,qword ptr [RSP]
MOV qword ptr [RSP + 0x50],RCX
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RSP + 0x48]
MOV CX,word ptr [RCX]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
LAB_001555f7:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
/* fmt::v10::detail::format_decimal_result<char*> fmt::v10::detail::format_decimal<char, unsigned
int>(char*, unsigned int, int) */
int1 [16]
fmt::v10::detail::format_decimal<char,unsigned_int>(char *param_1,uint param_2,int param_3)
{
int1 auVar1 [16];
int iVar2;
char *pcVar3;
char *pcVar4;
int2 *puVar5;
bool local_41;
int local_40;
uint local_3c;
char *local_38;
char *local_30;
int2 *local_10;
char *local_8;
local_40 = param_3;
local_3c = param_2;
local_38 = param_1;
iVar2 = count_digits(param_2);
local_41 = iVar2 <= param_3;
ignore_unused<bool,char[20]>(&local_41,"invalid digit count");
pcVar3 = local_38 + local_40;
local_38 = pcVar3;
for (; 99 < local_3c; local_3c = local_3c / 100) {
pcVar4 = local_38 + -2;
local_38 = pcVar4;
local_10 = (int2 *)digits2((ulong)local_3c % 100);
*(int2 *)pcVar4 = *local_10;
local_8 = pcVar4;
}
if (local_3c < 10) {
local_30 = local_38 + -1;
local_38[-1] = (char)local_3c + '0';
}
else {
pcVar4 = local_38 + -2;
local_38 = pcVar4;
puVar5 = (int2 *)digits2((ulong)local_3c);
*(int2 *)pcVar4 = *puVar5;
local_30 = local_38;
}
auVar1._8_8_ = pcVar3;
auVar1._0_8_ = local_30;
return auVar1;
}
| |
24,424 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | zkingston[P]unknot/build_O1/_deps/json-src/include/nlohmann/detail/string_concat.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O1 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [29], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0xf490
movq %rax, %r12
movq (%r14), %rdi
callq 0xf490
addq %rax, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xffe0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10310
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x10310
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x38aeb
movq (%r13), %rsi
incq %rsi
callq 0xfa70
movq %r14, %rdi
callq 0x101c0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_:
push r15
push r14
push r13
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rdi+10h]
mov [rdi], r13
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
mov r12, rax
mov rdi, [r14]
call _strlen
add r12, rax
mov rdi, rbx
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rax, rbx
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r13
jz short loc_38AEB
mov rsi, [r13+0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_38AEB:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // r12
long long v5; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
v5 = strlen(*a3);
std::string::reserve(a1, v5 + v4);
std::string::append(a1, a2);
std::string::append(a1, *a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[29],char_const*>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R13,[RDI + 0x10]
MOV qword ptr [RDI],R13
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0010f490
MOV R12,RAX
MOV RDI,qword ptr [R14]
CALL 0x0010f490
ADD R12,RAX
LAB_00138aa6:
MOV RDI,RBX
MOV RSI,R12
CALL 0x0010ffe0
MOV RDI,RBX
MOV RSI,R15
CALL 0x00110310
MOV RSI,qword ptr [R14]
MOV RDI,RBX
CALL 0x00110310
LAB_00138ac7:
MOV RAX,RBX
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [29], char const*>(char const (&) [29], char const*&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(detail *this,char *param_1,char **param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
strlen(*param_2);
/* try { // try from 00138aa6 to 00138ac6 has its CatchHandler @ 00138ad4 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::append((char *)this);
return this;
}
| |
24,425 | testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int) | AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
SetUpTearDownSuiteFuncType test_suite_fp =
GetNotDefaultOrNull(&T::TearDownTestSuite, &Test::TearDownTestSuite);
GTEST_CHECK_(!test_case_fp || !test_suite_fp)
<< "Test can not provide both TearDownTestSuite and TearDownTestCase,"
" please make sure there is only one present at"
<< filename << ":" << line_num;
return test_case_fp != nullptr ? test_case_fp : test_suite_fp;
#else
(void)(filename);
(void)(line_num);
return &T::TearDownTestSuite;
#endif
} | O3 | c | testing::internal::SuiteApiResolver<testing::Test>::GetTearDownCaseOrSuite(char const*, int):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x52725
testb %al, %al
jne 0x2b91f
leaq 0x53f89(%rip), %rdx # 0x7f7f8
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x216, %ecx # imm = 0x216
callq 0x5830c
movq 0x8874e(%rip), %rdi # 0xb3fd8
leaq 0x53fe3(%rip), %rsi # 0x7f874
movl $0x32, %edx
callq 0x11b90
movq 0x88736(%rip), %r15 # 0xb3fd8
leaq 0x54069(%rip), %rsi # 0x7f912
movl $0x6f, %edx
movq %r15, %rdi
callq 0x11b90
testq %r14, %r14
je 0x2b8d7
movq %r14, %rdi
callq 0x114d0
movq 0x8870e(%rip), %rdi # 0xb3fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x11b90
jmp 0x2b8ef
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x11d40
movq 0x886e2(%rip), %rdi # 0xb3fd8
leaq 0x5c124(%rip), %rsi # 0x87a21
movl $0x1, %edx
callq 0x11b90
movq 0x886ca(%rip), %rdi # 0xb3fd8
movl %ebx, %esi
callq 0x113b0
leaq 0xc(%rsp), %rdi
callq 0x5844e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x5844e
movq %rbx, %rdi
callq 0x11760
| _ZN7testing8internal16SuiteApiResolverIN5alaya10WorkerTestEE22GetTearDownCaseOrSuiteEPKci:
push r15
push r14
push rbx
sub rsp, 10h
mov ebx, esi
mov r14, rdi
mov edi, (offset dword_0+1); this
call _ZN7testing8internal6IsTrueEb; testing::internal::IsTrue(bool)
test al, al
jnz loc_2B91F
lea rdx, aWorkspaceLlm4b_5; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+28h+var_1C]
mov esi, 3
mov ecx, 216h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aConditionTestC; "Condition !test_case_fp || !test_suite_"...
mov edx, 32h ; '2'
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r15, cs:_ZSt4cerr_ptr
lea rsi, aTestCanNotProv_0; "Test can not provide both TearDownTestS"...
mov edx, 6Fh ; 'o'
mov rdi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r14, r14
jz short loc_2B8D7
mov rdi, r14
call _strlen
mov rdi, cs:_ZSt4cerr_ptr
mov rsi, r14
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_2B8EF
loc_2B8D7:
mov rax, [r15]
mov rax, [rax-18h]
lea rdi, [r15+rax]
mov esi, [r15+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_2B8EF:
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aTrace+6; ":"
mov edx, 1
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov rdi, cs:_ZSt4cerr_ptr
mov esi, ebx
call __ZNSolsEi; std::ostream::operator<<(int)
lea rdi, [rsp+28h+var_1C]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_2B91F:
xor eax, eax
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::SuiteApiResolver<alaya::WorkerTest>::GetTearDownCaseOrSuite(long long a1, BOOL a2)
{
long long v2; // rax
_BYTE v4[28]; // [rsp+Ch] [rbp-1Ch] BYREF
if ( !(unsigned __int8)testing::internal::IsTrue((testing::internal *)((char *)&dword_0 + 1), a2) )
{
testing::internal::GTestLog::GTestLog(
v4,
3LL,
"/workspace/llm4binary/github2025/AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h",
534LL);
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"Condition !test_case_fp || !test_suite_fp failed. ",
50LL);
std::__ostream_insert<char,std::char_traits<char>>(
&std::cerr,
"Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at",
111LL);
if ( a1 )
{
v2 = strlen(a1);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, a1, v2);
}
else
{
std::ios::clear(
(char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL),
*(_DWORD *)((char *)&std::cerr + *(_QWORD *)(std::cerr - 24LL) + 32) | 1u);
}
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, ":", 1LL);
std::ostream::operator<<(&std::cerr, a2);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)v4);
}
return 0LL;
}
| GetTearDownCaseOrSuite:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBX,ESI
MOV R14,RDI
MOV EDI,0x1
CALL 0x00152725
TEST AL,AL
JNZ 0x0012b91f
LEA RDX,[0x17f7f8]
LEA RDI,[RSP + 0xc]
MOV ESI,0x3
MOV ECX,0x216
CALL 0x0015830c
LAB_0012b883:
MOV RDI,qword ptr [0x001b3fd8]
LEA RSI,[0x17f874]
MOV EDX,0x32
CALL 0x00111b90
MOV R15,qword ptr [0x001b3fd8]
LEA RSI,[0x17f912]
MOV EDX,0x6f
MOV RDI,R15
CALL 0x00111b90
TEST R14,R14
JZ 0x0012b8d7
MOV RDI,R14
CALL 0x001114d0
MOV RDI,qword ptr [0x001b3fd8]
MOV RSI,R14
MOV RDX,RAX
CALL 0x00111b90
JMP 0x0012b8ef
LAB_0012b8d7:
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[R15 + RAX*0x1]
MOV ESI,dword ptr [R15 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00111d40
LAB_0012b8ef:
MOV RDI,qword ptr [0x001b3fd8]
LEA RSI,[0x187a21]
MOV EDX,0x1
CALL 0x00111b90
MOV RDI,qword ptr [0x001b3fd8]
MOV ESI,EBX
CALL 0x001113b0
LAB_0012b915:
LEA RDI,[RSP + 0xc]
CALL 0x0015844e
LAB_0012b91f:
XOR EAX,EAX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* testing::internal::SuiteApiResolver<alaya::WorkerTest>::GetTearDownCaseOrSuite(char const*, int)
*/
int8
testing::internal::SuiteApiResolver<alaya::WorkerTest>::GetTearDownCaseOrSuite
(char *param_1,int param_2)
{
int *puVar1;
char cVar2;
size_t sVar3;
GTestLog local_1c [4];
cVar2 = IsTrue(true);
if (cVar2 == '\0') {
GTestLog::GTestLog(local_1c,3,
"/workspace/llm4binary/github2025/AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h"
,0x216);
/* try { // try from 0012b883 to 0012b914 has its CatchHandler @ 0012b92b */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001b3fd8,"Condition !test_case_fp || !test_suite_fp failed. ",
0x32);
puVar1 = PTR_cerr_001b3fd8;
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_001b3fd8,
"Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at"
,0x6f);
if (param_1 == (char *)0x0) {
std::ios::clear(puVar1 + *(long *)(*(long *)puVar1 + -0x18),
*(uint *)(puVar1 + *(long *)(*(long *)puVar1 + -0x18) + 0x20) | 1);
}
else {
sVar3 = strlen(param_1);
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001b3fd8,param_1,sVar3)
;
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)PTR_cerr_001b3fd8,":",1);
std::ostream::operator<<((ostream *)PTR_cerr_001b3fd8,param_2);
GTestLog::~GTestLog(local_1c);
}
return 0;
}
| |
24,426 | translog_get_file_max_lsn_stored | eloqsql/storage/maria/ma_loghandler.c | LSN translog_get_file_max_lsn_stored(uint32 file)
{
uint32 limit= FILENO_IMPOSSIBLE;
DBUG_ENTER("translog_get_file_max_lsn_stored");
DBUG_PRINT("enter", ("file: %lu", (ulong)file));
DBUG_ASSERT(translog_status == TRANSLOG_OK ||
translog_status == TRANSLOG_READONLY);
mysql_mutex_lock(&log_descriptor.unfinished_files_lock);
/* find file with minimum file number "in progress" */
if (log_descriptor.unfinished_files.elements > 0)
{
struct st_file_counter *fc_ptr;
fc_ptr= dynamic_element(&log_descriptor.unfinished_files,
0, struct st_file_counter *);
limit= fc_ptr->file; /* minimal file number "in progress" */
}
mysql_mutex_unlock(&log_descriptor.unfinished_files_lock);
/*
if there is no "in progress file" then unfinished file is in progress
for sure
*/
if (limit == FILENO_IMPOSSIBLE)
{
TRANSLOG_ADDRESS horizon= translog_get_horizon();
limit= LSN_FILE_NO(horizon);
}
if (file >= limit)
{
DBUG_PRINT("info", ("The file in in progress"));
DBUG_RETURN(LSN_IMPOSSIBLE);
}
{
LOGHANDLER_FILE_INFO info;
File fd;
fd= open_logfile_by_number_no_cache(file);
if(fd < 0)
{
DBUG_PRINT("error", ("Can't open file"));
DBUG_RETURN(LSN_ERROR);
}
if (translog_read_file_header(&info, fd))
{
DBUG_PRINT("error", ("Can't read file header"));
info.max_lsn= LSN_ERROR;
}
if (mysql_file_close(fd, MYF(MY_WME)))
{
DBUG_PRINT("error", ("Can't close file"));
info.max_lsn= LSN_ERROR;
}
DBUG_PRINT("info", ("Max lsn: " LSN_FMT, LSN_IN_PARTS(info.max_lsn)));
DBUG_RETURN(info.max_lsn);
}
} | O0 | c | translog_get_file_max_lsn_stored:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
jmp 0x4fc14
jmp 0x4fc16
jmp 0x4fc18
leaq 0x4297a1(%rip), %rdi # 0x4793c0
addq $0x800e08, %rdi # imm = 0x800E08
leaq 0x1020aa(%rip), %rsi # 0x151cd7
movl $0x5b7, %edx # imm = 0x5B7
callq 0x4fd20
cmpl $0x0, 0xc2a5da(%rip) # 0xc7a218
jbe 0x4fc54
movq 0xc2a5c9(%rip), %rax # 0xc7a210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
leaq 0x429765(%rip), %rdi # 0x4793c0
addq $0x800e08, %rdi # imm = 0x800E08
callq 0x4fd90
cmpl $0x0, -0x10(%rbp)
jne 0x4fc81
callq 0x54bc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
sarq $0x20, %rax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jb 0x4fc99
jmp 0x4fc8b
jmp 0x4fc8d
jmp 0x4fc8f
movq $0x0, -0x8(%rbp)
jmp 0x4fd0e
movl -0xc(%rbp), %edi
callq 0x4fdf0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jge 0x4fcba
jmp 0x4fcac
jmp 0x4fcae
jmp 0x4fcb0
movq $0x1, -0x8(%rbp)
jmp 0x4fd0e
movl -0x5c(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x4f9f0
cmpb $0x0, %al
je 0x4fcd6
jmp 0x4fccc
jmp 0x4fcce
movq $0x1, -0x58(%rbp)
movl -0x5c(%rbp), %edx
leaq 0x101ff7(%rip), %rdi # 0x151cd7
movl $0x5e4, %esi # imm = 0x5E4
movl $0x10, %ecx
callq 0x4fec0
cmpl $0x0, %eax
je 0x4fd00
jmp 0x4fcf6
jmp 0x4fcf8
movq $0x1, -0x58(%rbp)
jmp 0x4fd02
jmp 0x4fd04
jmp 0x4fd06
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| translog_get_file_max_lsn_stored:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_C], edi
mov [rbp+var_10], 0
jmp short $+2
loc_4FC14:
jmp short $+2
loc_4FC16:
jmp short $+2
loc_4FC18:
lea rdi, log_descriptor
add rdi, 800E08h
lea rsi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 5B7h
call inline_mysql_mutex_lock_8
cmp cs:dword_C7A218, 0
jbe short loc_4FC54
mov rax, cs:qword_C7A210
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov eax, [rax]
mov [rbp+var_10], eax
loc_4FC54:
lea rdi, log_descriptor
add rdi, 800E08h
call inline_mysql_mutex_unlock_8
cmp [rbp+var_10], 0
jnz short loc_4FC81
call translog_get_horizon
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
sar rax, 20h
mov [rbp+var_10], eax
loc_4FC81:
mov eax, [rbp+var_C]
cmp eax, [rbp+var_10]
jb short loc_4FC99
jmp short $+2
loc_4FC8B:
jmp short $+2
loc_4FC8D:
jmp short $+2
loc_4FC8F:
mov [rbp+var_8], 0
jmp short loc_4FD0E
loc_4FC99:
mov edi, [rbp+var_C]
call open_logfile_by_number_no_cache
mov [rbp+var_5C], eax
cmp [rbp+var_5C], 0
jge short loc_4FCBA
jmp short $+2
loc_4FCAC:
jmp short $+2
loc_4FCAE:
jmp short $+2
loc_4FCB0:
mov [rbp+var_8], 1
jmp short loc_4FD0E
loc_4FCBA:
mov esi, [rbp+var_5C]
lea rdi, [rbp+var_58]
call translog_read_file_header
cmp al, 0
jz short loc_4FCD6
jmp short $+2
loc_4FCCC:
jmp short $+2
loc_4FCCE:
mov [rbp+var_58], 1
loc_4FCD6:
mov edx, [rbp+var_5C]
lea rdi, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 5E4h
mov ecx, 10h
call inline_mysql_file_close_2
cmp eax, 0
jz short loc_4FD00
jmp short $+2
loc_4FCF6:
jmp short $+2
loc_4FCF8:
mov [rbp+var_58], 1
loc_4FD00:
jmp short $+2
loc_4FD02:
jmp short $+2
loc_4FD04:
jmp short $+2
loc_4FD06:
mov rax, [rbp+var_58]
mov [rbp+var_8], rax
loc_4FD0E:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| unsigned long long translog_get_file_max_lsn_stored(unsigned int a1)
{
int v2; // [rsp+4h] [rbp-5Ch]
unsigned long long v3[7]; // [rsp+8h] [rbp-58h] BYREF
long long horizon; // [rsp+40h] [rbp-20h]
long long v5; // [rsp+48h] [rbp-18h]
unsigned int v6; // [rsp+50h] [rbp-10h]
unsigned int v7; // [rsp+54h] [rbp-Ch]
v7 = a1;
v6 = 0;
inline_mysql_mutex_lock_8(
&log_descriptor + 1049025,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
1463LL);
if ( dword_C7A218 )
{
v5 = qword_C7A210;
v6 = *(_DWORD *)qword_C7A210;
}
inline_mysql_mutex_unlock_8(&log_descriptor + 1049025);
if ( !v6 )
{
horizon = translog_get_horizon();
v6 = HIDWORD(horizon);
}
if ( v7 >= v6 )
return 0LL;
v2 = open_logfile_by_number_no_cache(v7);
if ( v2 < 0 )
return 1LL;
if ( translog_read_file_header(v3, v2) )
v3[0] = 1LL;
if ( (unsigned int)inline_mysql_file_close_2(
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
1508LL,
(unsigned int)v2,
16LL) )
v3[0] = 1LL;
return v3[0];
}
| translog_get_file_max_lsn_stored:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV dword ptr [RBP + -0xc],EDI
MOV dword ptr [RBP + -0x10],0x0
JMP 0x0014fc14
LAB_0014fc14:
JMP 0x0014fc16
LAB_0014fc16:
JMP 0x0014fc18
LAB_0014fc18:
LEA RDI,[0x5793c0]
ADD RDI,0x800e08
LEA RSI,[0x251cd7]
MOV EDX,0x5b7
CALL 0x0014fd20
CMP dword ptr [0x00d7a218],0x0
JBE 0x0014fc54
MOV RAX,qword ptr [0x00d7a210]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x10],EAX
LAB_0014fc54:
LEA RDI,[0x5793c0]
ADD RDI,0x800e08
CALL 0x0014fd90
CMP dword ptr [RBP + -0x10],0x0
JNZ 0x0014fc81
CALL 0x00154bc0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
SAR RAX,0x20
MOV dword ptr [RBP + -0x10],EAX
LAB_0014fc81:
MOV EAX,dword ptr [RBP + -0xc]
CMP EAX,dword ptr [RBP + -0x10]
JC 0x0014fc99
JMP 0x0014fc8b
LAB_0014fc8b:
JMP 0x0014fc8d
LAB_0014fc8d:
JMP 0x0014fc8f
LAB_0014fc8f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x0014fd0e
LAB_0014fc99:
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x0014fdf0
MOV dword ptr [RBP + -0x5c],EAX
CMP dword ptr [RBP + -0x5c],0x0
JGE 0x0014fcba
JMP 0x0014fcac
LAB_0014fcac:
JMP 0x0014fcae
LAB_0014fcae:
JMP 0x0014fcb0
LAB_0014fcb0:
MOV qword ptr [RBP + -0x8],0x1
JMP 0x0014fd0e
LAB_0014fcba:
MOV ESI,dword ptr [RBP + -0x5c]
LEA RDI,[RBP + -0x58]
CALL 0x0014f9f0
CMP AL,0x0
JZ 0x0014fcd6
JMP 0x0014fccc
LAB_0014fccc:
JMP 0x0014fcce
LAB_0014fcce:
MOV qword ptr [RBP + -0x58],0x1
LAB_0014fcd6:
MOV EDX,dword ptr [RBP + -0x5c]
LEA RDI,[0x251cd7]
MOV ESI,0x5e4
MOV ECX,0x10
CALL 0x0014fec0
CMP EAX,0x0
JZ 0x0014fd00
JMP 0x0014fcf6
LAB_0014fcf6:
JMP 0x0014fcf8
LAB_0014fcf8:
MOV qword ptr [RBP + -0x58],0x1
LAB_0014fd00:
JMP 0x0014fd02
LAB_0014fd02:
JMP 0x0014fd04
LAB_0014fd04:
JMP 0x0014fd06
LAB_0014fd06:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x8],RAX
LAB_0014fd0e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
int8 translog_get_file_max_lsn_stored(uint param_1)
{
char cVar1;
int iVar2;
int8 local_60 [7];
int8 local_28;
uint *local_20;
uint local_18;
uint local_14;
int8 local_10;
local_18 = 0;
local_14 = param_1;
inline_mysql_mutex_lock
(&DAT_00d7a1c8,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x5b7);
if (DAT_00d7a218 != 0) {
local_20 = DAT_00d7a210;
local_18 = *DAT_00d7a210;
}
inline_mysql_mutex_unlock(&DAT_00d7a1c8);
if (local_18 == 0) {
local_28 = translog_get_horizon();
local_18 = (uint)((ulong)local_28 >> 0x20);
}
if (local_14 < local_18) {
iVar2 = open_logfile_by_number_no_cache(local_14);
if (iVar2 < 0) {
local_10 = 1;
}
else {
cVar1 = translog_read_file_header(local_60,iVar2);
if (cVar1 != '\0') {
local_60[0] = 1;
}
iVar2 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_loghandler.c",
0x5e4,iVar2,0x10);
if (iVar2 != 0) {
local_60[0] = 1;
}
local_10 = local_60[0];
}
}
else {
local_10 = 0;
}
return local_10;
}
| |
24,427 | std::vector<int, std::allocator<int>> string_split<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) | monkey531[P]llama/common/common.h | static std::vector<T> string_split(const std::string & str, char delim) {
static_assert(!std::is_same<T, std::string>::value, "Please use the specialized version for std::string");
std::vector<T> values;
std::istringstream str_stream(str);
std::string token;
while (std::getline(str_stream, token, delim)) {
T value;
std::istringstream token_stream(token);
token_stream >> value;
values.push_back(value);
}
return values;
} | O2 | c | std::vector<int, std::allocator<int>> string_split<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x23f00
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %r15
pushq $0x2c
popq %rbp
leaq 0x1a8(%rsp), %r12
pushq $0x8
popq %r13
leaq 0x4(%rsp), %r14
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x240a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x37bb8
movq %r12, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x23f00
movq %r12, %rdi
movq %r14, %rsi
callq 0x235b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52a6a
movq %r12, %rdi
callq 0x23450
jmp 0x37b6d
leaq 0x8(%rsp), %rdi
callq 0x24218
leaq 0x28(%rsp), %rdi
callq 0x23450
movq %rbx, %rax
addq $0x328, %rsp # imm = 0x328
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x37c11
jmp 0x37be8
movq %rax, %r14
jmp 0x37bfd
movq %rax, %r14
leaq 0x1a8(%rsp), %rdi
callq 0x23450
leaq 0x8(%rsp), %rdi
callq 0x24218
leaq 0x28(%rsp), %rdi
callq 0x23450
movq %rbx, %rdi
callq 0x28130
movq %r14, %rdi
callq 0x23fd0
nop
| _ZL12string_splitIiESt6vectorIT_SaIS1_EERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 328h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
and qword ptr [rdi+10h], 0
lea rdi, [rsp+358h+var_330]
push 8
pop rdx
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
lea rax, [rsp+358h+var_340]
mov [rax-10h], rax
and qword ptr [rax-8], 0
mov byte ptr [rax], 0
lea r15, [rsp+358h+var_350]
push 2Ch ; ','
pop rbp
lea r12, [rsp+358h+var_1B0]
push 8
pop r13
lea r14, [rsp+358h+var_354]
loc_37B6D:
lea rdi, [rsp+358h+var_330]
mov rsi, r15
mov edx, ebp
call __ZSt7getlineIcSt11char_traitsIcESaIcEERSt13basic_istreamIT_T0_ES7_RNSt7__cxx1112basic_stringIS4_S5_T1_EES4_; std::getline<char,std::char_traits<char>,std::allocator<char>>(std::istream &,std::string &,char)
mov rcx, [rax]
mov rcx, [rcx-18h]
test byte ptr [rax+rcx+20h], 5
jnz short loc_37BB8
mov rdi, r12
mov rsi, r15
mov edx, r13d
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEEC1ERKNS_12basic_stringIcS2_S3_EESt13_Ios_Openmode; std::istringstream::basic_istringstream(std::string const&,std::_Ios_Openmode)
mov rdi, r12
mov rsi, r14
call __ZNSirsERi; std::istream::operator>>(int &)
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIiSaIiEE9push_backERKi; std::vector<int>::push_back(int const&)
mov rdi, r12
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
jmp short loc_37B6D
loc_37BB8:
lea rdi, [rsp+358h+var_350]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+358h+var_330]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
mov rax, rbx
add rsp, 328h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
jmp short loc_37C11
jmp short $+2
loc_37BE8:
mov r14, rax
jmp short loc_37BFD
mov r14, rax
lea rdi, [rsp+arg_1A0]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
loc_37BFD:
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_20]
call __ZNSt7__cxx1119basic_istringstreamIcSt11char_traitsIcESaIcEED1Ev; std::istringstream::~istringstream()
loc_37C11:
mov rdi, rbx
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov rdi, r14
call __Unwind_Resume
| long long string_split<int>(long long a1, long long a2)
{
_QWORD *v2; // rax
_BYTE v4[4]; // [rsp+4h] [rbp-354h] BYREF
_QWORD v5[2]; // [rsp+8h] [rbp-350h] BYREF
char v6; // [rsp+18h] [rbp-340h] BYREF
_BYTE v7[384]; // [rsp+28h] [rbp-330h] BYREF
_BYTE v8[432]; // [rsp+1A8h] [rbp-1B0h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::istringstream::basic_istringstream(v7, a2, 8LL);
v5[0] = &v6;
v5[1] = 0LL;
v6 = 0;
while ( 1 )
{
v2 = (_QWORD *)std::getline<char,std::char_traits<char>,std::allocator<char>>(v7, v5, 44LL);
if ( (*((_BYTE *)v2 + *(_QWORD *)(*v2 - 24LL) + 32) & 5) != 0 )
break;
std::istringstream::basic_istringstream(v8, v5, 8LL);
std::istream::operator>>(v8, v4);
std::vector<int>::push_back(a1, v4);
std::istringstream::~istringstream(v8);
}
std::string::~string(v5);
std::istringstream::~istringstream(v7);
return a1;
}
| string_split<int>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x328
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
AND qword ptr [RDI + 0x10],0x0
LAB_00137b36:
LEA RDI,[RSP + 0x28]
PUSH 0x8
POP RDX
CALL 0x00123f00
LEA RAX,[RSP + 0x18]
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
MOV byte ptr [RAX],0x0
LEA R15,[RSP + 0x8]
PUSH 0x2c
POP RBP
LEA R12,[RSP + 0x1a8]
PUSH 0x8
POP R13
LEA R14,[RSP + 0x4]
LAB_00137b6d:
LEA RDI,[RSP + 0x28]
MOV RSI,R15
MOV EDX,EBP
CALL 0x001240a0
MOV RCX,qword ptr [RAX]
MOV RCX,qword ptr [RCX + -0x18]
TEST byte ptr [RAX + RCX*0x1 + 0x20],0x5
JNZ 0x00137bb8
LAB_00137b8a:
MOV RDI,R12
MOV RSI,R15
MOV EDX,R13D
CALL 0x00123f00
LAB_00137b98:
MOV RDI,R12
MOV RSI,R14
CALL 0x001235b0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00152a6a
LAB_00137bae:
MOV RDI,R12
CALL 0x00123450
JMP 0x00137b6d
LAB_00137bb8:
LEA RDI,[RSP + 0x8]
CALL 0x00124218
LEA RDI,[RSP + 0x28]
CALL 0x00123450
MOV RAX,RBX
ADD RSP,0x328
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* std::vector<int, std::allocator<int> > string_split<int>(std::__cxx11::string const&, char) */
string * string_split<int>(string *param_1,char param_2)
{
istream *piVar1;
int7 in_register_00000031;
int local_354;
int1 *local_350;
int8 local_348;
int1 local_340 [16];
istringstream local_330 [384];
istream local_1b0 [384];
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
/* try { // try from 00137b36 to 00137b42 has its CatchHandler @ 00137be1 */
std::__cxx11::istringstream::istringstream(local_330,CONCAT71(in_register_00000031,param_2),8);
local_350 = local_340;
local_348 = 0;
local_340[0] = 0;
while( true ) {
/* try { // try from 00137b6d to 00137b7b has its CatchHandler @ 00137be8 */
piVar1 = std::getline<char,std::char_traits<char>,std::allocator<char>>
((istream *)local_330,(string *)&local_350,',');
if (((byte)piVar1[*(long *)(*(long *)piVar1 + -0x18) + 0x20] & 5) != 0) break;
/* try { // try from 00137b8a to 00137b97 has its CatchHandler @ 00137be6 */
std::__cxx11::istringstream::istringstream((istringstream *)local_1b0,(string *)&local_350,8);
/* try { // try from 00137b98 to 00137bad has its CatchHandler @ 00137bed */
std::istream::operator>>(local_1b0,&local_354);
std::vector<int,std::allocator<int>>::push_back
((vector<int,std::allocator<int>> *)param_1,&local_354);
std::__cxx11::istringstream::~istringstream((istringstream *)local_1b0);
}
std::__cxx11::string::~string((string *)&local_350);
std::__cxx11::istringstream::~istringstream(local_330);
return param_1;
}
| |
24,428 | Logger::log(Logger::Level, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 11AgReS1SoR11[P]Graph/Common/Logger/src/Logger.cpp | void Logger::log(Level level, std::string const& entity, std::string const& message)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto const levelStr = details::levelToString(level);
auto const timeStr = details::getCurrentTime();
auto const logMessage = "[" + timeStr + "][" + levelStr + "][" + entity + "] " + message;
std::cout << logMessage << std::endl;
if (m_logFile.is_open())
{
m_logFile << logMessage << std::endl;
}
} | O3 | cpp | Logger::log(Logger::Level, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
addq $0x220, %rdi # imm = 0x220
movq %rdi, (%rsp)
callq 0x2210
testl %eax, %eax
jne 0x291b
leaq 0xc8(%rsp), %rdi
movl %ebp, %esi
callq 0x21f0
leaq 0x108(%rsp), %rdi
callq 0x2240
leaq 0xaf6(%rip), %rsi # 0x3023
leaq 0xe8(%rsp), %rdi
leaq 0x108(%rsp), %rdx
callq 0x21a0
leaq 0xad9(%rip), %rsi # 0x3022
leaq 0xe8(%rsp), %rdi
callq 0x2290
leaq 0x38(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x257d
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x2583
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0x2070
leaq 0x58(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x25db
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x25e1
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa1e(%rip), %rsi # 0x3022
callq 0x2290
leaq 0x78(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2630
movq %rdx, 0x68(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x78(%rsp)
jmp 0x2636
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
leaq 0x68(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
callq 0x2070
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2690
movq %rdx, 0x88(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x98(%rsp)
jmp 0x2698
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x967(%rip), %rsi # 0x3025
callq 0x2290
leaq 0xb8(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x26f3
movq %rdx, 0xa8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xb8(%rsp)
jmp 0x26fa
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0xa8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x2070
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x274d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x2755
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xa8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x278a
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x27a7
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x68(%rsp), %rdi
cmpq %rbx, %rdi
je 0x27be
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x27da
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x27f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2817
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x27a0(%rip), %rdi # 0x4fc8
callq 0x21e0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x90(%r14), %rdi
callq 0x2050
testb %al, %al
je 0x28a7
addq $0x20, %r14
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x21e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x28be
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x118(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28df
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2900
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rsp), %rdi
callq 0x2150
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x2100
movq %rax, %r14
movq 0xa8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2947
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2947
movq %rax, %r14
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x2969
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2969
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2985
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x2985
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x29a6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x29a6
movq %rax, %r14
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x29c7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21d0
jmp 0x29c7
movq %rax, %r14
leaq 0xf8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a0b
movq 0xf8(%rsp), %rsi
jmp 0x2a03
movq %rax, %r14
jmp 0x2a0b
movq %rax, %r14
jmp 0x2a2c
movq %rax, %r14
jmp 0x2a4d
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2a0b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x118(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a2c
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0xd8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a4d
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x21d0
movq (%rsp), %rdi
callq 0x2150
movq %r14, %rdi
callq 0x2260
| _ZN6Logger3logENS_5LevelERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov r15, rcx
mov r12, rdx
mov ebp, esi
mov r14, rdi
add rdi, 220h
mov [rsp+158h+var_158], rdi
call _pthread_mutex_lock
test eax, eax
jnz loc_291B
lea rdi, [rsp+158h+var_90]
mov esi, ebp
call __ZN7details13levelToStringB5cxx11EN6Logger5LevelE; details::levelToString(Logger::Level)
lea rdi, [rsp+158h+var_50]
call __ZN7details14getCurrentTimeB5cxx11Ev; details::getCurrentTime(void)
lea rsi, asc_3022+1; "["
lea rdi, [rsp+158h+var_70]
lea rdx, [rsp+158h+var_50]
call __ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rsi, asc_3022; "]["
lea rdi, [rsp+158h+var_70]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rsi, [rsp+158h+var_120]
mov [rsi-10h], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_257D
mov [rsp+158h+var_130], rdx
mov rdx, [rcx]
mov [rsp+158h+var_120], rdx
jmp short loc_2583
loc_257D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_2583:
mov rdx, [rax+8]
lea rdi, [rsp+158h+var_130]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [rsp+158h+var_90]
mov rdx, [rsp+158h+var_88]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea rsi, [rsp+158h+var_100]
mov [rsi-10h], rsi
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_25DB
mov [rsp+158h+var_110], rdx
mov rdx, [rcx]
mov [rsp+158h+var_100], rdx
jmp short loc_25E1
loc_25DB:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rsi], xmm0
loc_25E1:
mov rdx, [rax+8]
lea rdi, [rsp+158h+var_110]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, asc_3022; "]["
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rbx, [rsp+158h+var_E0]
mov [rbx-10h], rbx
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2630
mov [rsp+158h+var_F0], rdx
mov rdx, [rcx]
mov [rsp+158h+var_E0], rdx
jmp short loc_2636
loc_2630:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbx], xmm0
loc_2636:
mov rdx, [rax+8]
lea rdi, [rsp+158h+var_F0]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [r12]
mov rdx, [r12+8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea r13, [rsp+158h+var_C0]
mov [r13-10h], r13
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_2690
mov [rsp+158h+var_D0], rdx
mov rdx, [rcx]
mov [rsp+158h+var_C0], rdx
jmp short loc_2698
loc_2690:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r13+0], xmm0
loc_2698:
mov rdx, [rax+8]
lea rdi, [rsp+158h+var_D0]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
lea rsi, asc_3025; "] "
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea rbp, [rsp+158h+var_A0]
mov [rbp-10h], rbp
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_26F3
mov [rsp+158h+var_B0], rdx
mov rdx, [rcx]
mov [rsp+158h+var_A0], rdx
jmp short loc_26FA
loc_26F3:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbp+0], xmm0
loc_26FA:
mov rdx, [rax+8]
lea rdi, [rsp+158h+var_B0]
mov [rdi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rsi, [r15]
mov rdx, [r15+8]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
lea r12, [rsp+158h+var_140]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_274D
mov [rsp+158h+var_150], rdx
mov rdx, [rcx]
mov [rsp+158h+var_140], rdx
jmp short loc_2755
loc_274D:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
loc_2755:
mov rdx, [rax+8]
mov [rsp+158h+var_148], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, [rsp+158h+var_B0]; void *
cmp rdi, rbp
jz short loc_278A
mov rsi, [rsp+158h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_278A:
mov rdi, [rsp+158h+var_D0]; void *
cmp rdi, r13
jz short loc_27A7
mov rsi, [rsp+158h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27A7:
mov rdi, [rsp+158h+var_F0]; void *
cmp rdi, rbx
jz short loc_27BE
mov rsi, [rsp+158h+var_E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27BE:
mov rdi, [rsp+158h+var_110]; void *
lea rax, [rsp+158h+var_100]
cmp rdi, rax
jz short loc_27DA
mov rsi, [rsp+158h+var_100]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27DA:
mov rdi, [rsp+158h+var_130]; void *
lea rax, [rsp+158h+var_120]
cmp rdi, rax
jz short loc_27F6
mov rsi, [rsp+158h+var_120]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27F6:
lea rax, [rsp+158h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2817
mov rsi, [rsp+158h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2817:
mov rsi, [rsp+158h+var_150]
mov rdx, [rsp+158h+var_148]
mov rdi, cs:_ZSt4cout_ptr
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r15, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, r15
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r15; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
lea rdi, [r14+90h]
call __ZNKSt12__basic_fileIcE7is_openEv; std::__basic_file<char>::is_open(void)
test al, al
jz short loc_28A7
add r14, 20h ; ' '
mov rsi, [rsp+158h+var_150]
mov rdx, [rsp+158h+var_148]
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov r14, rax
mov rax, [rax]
mov rdi, [rax-18h]
add rdi, r14
mov esi, 0Ah
call __ZNKSt9basic_iosIcSt11char_traitsIcEE5widenEc; std::ios::widen(char)
movsx esi, al; char
mov rdi, r14; this
call __ZNSo3putEc; std::ostream::put(char)
mov rdi, rax; this
call __ZNSo5flushEv; std::ostream::flush(void)
loc_28A7:
mov rdi, [rsp+158h+var_150]; void *
cmp rdi, r12
jz short loc_28BE
mov rsi, [rsp+158h+var_140]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28BE:
lea rax, [rsp+158h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_28DF
mov rsi, [rsp+158h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28DF:
lea rax, [rsp+158h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2900
mov rsi, [rsp+158h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2900:
mov rdi, [rsp+158h+var_158]
call _pthread_mutex_unlock
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_291B:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov r14, rax
mov rdi, [rsp+158h+var_B0]; void *
cmp rdi, rbp
jz short loc_2947
mov rsi, [rsp+158h+var_A0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2947
mov r14, rax
loc_2947:
mov rdi, [rsp+158h+var_D0]; void *
cmp rdi, r13
jz short loc_2969
mov rsi, [rsp+158h+var_C0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2969
mov r14, rax
loc_2969:
mov rdi, [rsp+158h+var_F0]; void *
cmp rdi, rbx
jz short loc_2985
mov rsi, [rsp+158h+var_E0]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2985
mov r14, rax
loc_2985:
mov rdi, [rsp+158h+var_110]; void *
lea rax, [rsp+158h+var_100]
cmp rdi, rax
jz short loc_29A6
mov rsi, [rsp+158h+var_100]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_29A6
mov r14, rax
loc_29A6:
mov rdi, [rsp+158h+var_130]; void *
lea rax, [rsp+158h+var_120]
cmp rdi, rax
jz short loc_29C7
mov rsi, [rsp+158h+var_120]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_29C7
mov r14, rax
loc_29C7:
lea rax, [rsp+158h+var_60]
mov rdi, [rax-10h]
cmp rdi, rax
jz short loc_2A0B
mov rsi, [rsp+158h+var_60]
jmp short loc_2A03
mov r14, rax
jmp short loc_2A0B
mov r14, rax
jmp short loc_2A2C
mov r14, rax
jmp short loc_2A4D
mov r14, rax
mov rdi, [rsp+158h+var_150]; void *
cmp rdi, r12
jz short loc_2A0B
mov rsi, [rsp+158h+var_140]
loc_2A03:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A0B:
lea rax, [rsp+158h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2A2C
mov rsi, [rsp+158h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A2C:
lea rax, [rsp+158h+var_80]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2A4D
mov rsi, [rsp+158h+var_80]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2A4D:
mov rdi, [rsp+158h+var_158]
call _pthread_mutex_unlock
mov rdi, r14
call __Unwind_Resume
| long long Logger::log(long long a1, int a2, _QWORD *a3, _QWORD *a4)
{
int v6; // eax
long long v7; // rax
__int128 *v8; // rcx
long long v9; // rax
__int128 *v10; // rcx
long long v11; // rax
__int128 *v12; // rcx
long long v13; // rax
__int128 *v14; // rcx
long long v15; // rax
__int128 *v16; // rcx
long long v17; // rax
__int128 *v18; // rcx
std::ostream *v19; // r15
char v20; // al
std::ostream *v21; // rax
std::ostream *v22; // r14
char v23; // al
std::ostream *v24; // rax
__int128 *v26; // [rsp+8h] [rbp-150h]
long long v27; // [rsp+10h] [rbp-148h]
__int128 v28; // [rsp+18h] [rbp-140h] BYREF
void *v29[2]; // [rsp+28h] [rbp-130h] BYREF
__int128 v30; // [rsp+38h] [rbp-120h] BYREF
void *v31[2]; // [rsp+48h] [rbp-110h] BYREF
__int128 v32; // [rsp+58h] [rbp-100h] BYREF
void *v33[2]; // [rsp+68h] [rbp-F0h] BYREF
__int128 v34; // [rsp+78h] [rbp-E0h] BYREF
void *v35[2]; // [rsp+88h] [rbp-D0h] BYREF
__int128 v36; // [rsp+98h] [rbp-C0h] BYREF
void *v37[2]; // [rsp+A8h] [rbp-B0h] BYREF
__int128 v38; // [rsp+B8h] [rbp-A0h] BYREF
void *v39[2]; // [rsp+C8h] [rbp-90h] BYREF
long long v40; // [rsp+D8h] [rbp-80h] BYREF
void *v41[2]; // [rsp+E8h] [rbp-70h] BYREF
long long v42; // [rsp+F8h] [rbp-60h] BYREF
void *v43[2]; // [rsp+108h] [rbp-50h] BYREF
long long v44; // [rsp+118h] [rbp-40h] BYREF
v6 = pthread_mutex_lock();
if ( v6 )
std::__throw_system_error(v6);
details::levelToString[abi:cxx11]((long long)v39, a2);
details::getCurrentTime[abi:cxx11](v43);
std::operator+<char>(v41, "[", v43);
v7 = std::string::append(v41, "][");
v29[0] = &v30;
v8 = (__int128 *)(v7 + 16);
if ( *(_QWORD *)v7 == v7 + 16 )
{
v30 = *v8;
}
else
{
v29[0] = *(void **)v7;
*(_QWORD *)&v30 = *(_QWORD *)v8;
}
v29[1] = *(void **)(v7 + 8);
*(_QWORD *)v7 = v8;
*(_QWORD *)(v7 + 8) = 0LL;
*(_BYTE *)(v7 + 16) = 0;
v9 = std::string::_M_append(v29, v39[0], v39[1]);
v31[0] = &v32;
v10 = (__int128 *)(v9 + 16);
if ( *(_QWORD *)v9 == v9 + 16 )
{
v32 = *v10;
}
else
{
v31[0] = *(void **)v9;
*(_QWORD *)&v32 = *(_QWORD *)v10;
}
v31[1] = *(void **)(v9 + 8);
*(_QWORD *)v9 = v10;
*(_QWORD *)(v9 + 8) = 0LL;
*(_BYTE *)(v9 + 16) = 0;
v11 = std::string::append(v31, "][");
v33[0] = &v34;
v12 = (__int128 *)(v11 + 16);
if ( *(_QWORD *)v11 == v11 + 16 )
{
v34 = *v12;
}
else
{
v33[0] = *(void **)v11;
*(_QWORD *)&v34 = *(_QWORD *)v12;
}
v33[1] = *(void **)(v11 + 8);
*(_QWORD *)v11 = v12;
*(_QWORD *)(v11 + 8) = 0LL;
*(_BYTE *)(v11 + 16) = 0;
v13 = std::string::_M_append(v33, *a3, a3[1]);
v35[0] = &v36;
v14 = (__int128 *)(v13 + 16);
if ( *(_QWORD *)v13 == v13 + 16 )
{
v36 = *v14;
}
else
{
v35[0] = *(void **)v13;
*(_QWORD *)&v36 = *(_QWORD *)v14;
}
v35[1] = *(void **)(v13 + 8);
*(_QWORD *)v13 = v14;
*(_QWORD *)(v13 + 8) = 0LL;
*(_BYTE *)(v13 + 16) = 0;
v15 = std::string::append(v35, "] ");
v37[0] = &v38;
v16 = (__int128 *)(v15 + 16);
if ( *(_QWORD *)v15 == v15 + 16 )
{
v38 = *v16;
}
else
{
v37[0] = *(void **)v15;
*(_QWORD *)&v38 = *(_QWORD *)v16;
}
v37[1] = *(void **)(v15 + 8);
*(_QWORD *)v15 = v16;
*(_QWORD *)(v15 + 8) = 0LL;
*(_BYTE *)(v15 + 16) = 0;
v17 = std::string::_M_append(v37, *a4, a4[1]);
v26 = &v28;
v18 = (__int128 *)(v17 + 16);
if ( *(_QWORD *)v17 == v17 + 16 )
{
v28 = *v18;
}
else
{
v26 = *(__int128 **)v17;
*(_QWORD *)&v28 = *(_QWORD *)v18;
}
v27 = *(_QWORD *)(v17 + 8);
*(_QWORD *)v17 = v18;
*(_QWORD *)(v17 + 8) = 0LL;
*(_BYTE *)(v17 + 16) = 0;
if ( v37[0] != &v38 )
operator delete(v37[0], v38 + 1);
if ( v35[0] != &v36 )
operator delete(v35[0], v36 + 1);
if ( v33[0] != &v34 )
operator delete(v33[0], v34 + 1);
if ( v31[0] != &v32 )
operator delete(v31[0], v32 + 1);
if ( v29[0] != &v30 )
operator delete(v29[0], v30 + 1);
if ( v41[0] != &v42 )
operator delete(v41[0], v42 + 1);
v19 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(&std::cout, v26, v27);
v20 = std::ios::widen((char *)v19 + *(_QWORD *)(*(_QWORD *)v19 - 24LL), 10LL);
v21 = (std::ostream *)std::ostream::put(v19, v20);
std::ostream::flush(v21);
if ( (unsigned __int8)std::__basic_file<char>::is_open(a1 + 144) )
{
v22 = (std::ostream *)std::__ostream_insert<char,std::char_traits<char>>(a1 + 32, v26, v27);
v23 = std::ios::widen((char *)v22 + *(_QWORD *)(*(_QWORD *)v22 - 24LL), 10LL);
v24 = (std::ostream *)std::ostream::put(v22, v23);
std::ostream::flush(v24);
}
if ( v26 != &v28 )
operator delete(v26, v28 + 1);
if ( v43[0] != &v44 )
operator delete(v43[0], v44 + 1);
if ( v39[0] != &v40 )
operator delete(v39[0], v40 + 1);
return pthread_mutex_unlock(a1 + 544);
}
| log:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV R15,RCX
MOV R12,RDX
MOV EBP,ESI
MOV R14,RDI
ADD RDI,0x220
MOV qword ptr [RSP],RDI
CALL 0x00102210
TEST EAX,EAX
JNZ 0x0010291b
LAB_0010250a:
LEA RDI,[RSP + 0xc8]
MOV ESI,EBP
CALL 0x001021f0
LAB_00102519:
LEA RDI,[RSP + 0x108]
CALL 0x00102240
LAB_00102526:
LEA RSI,[0x103023]
LEA RDI,[RSP + 0xe8]
LEA RDX,[RSP + 0x108]
CALL 0x001021a0
LAB_00102542:
LEA RSI,[0x103022]
LEA RDI,[RSP + 0xe8]
CALL 0x00102290
LEA RSI,[RSP + 0x38]
MOV qword ptr [RSI + -0x10],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0010257d
MOV qword ptr [RSP + 0x28],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x38],RDX
JMP 0x00102583
LAB_0010257d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_00102583:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
LAB_001025af:
CALL 0x00102070
LEA RSI,[RSP + 0x58]
MOV qword ptr [RSI + -0x10],RSI
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001025db
MOV qword ptr [RSP + 0x48],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x58],RDX
JMP 0x001025e1
LAB_001025db:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RSI],XMM0
LAB_001025e1:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x48]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001025fd:
LEA RSI,[0x103022]
CALL 0x00102290
LEA RBX,[RSP + 0x78]
MOV qword ptr [RBX + -0x10],RBX
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00102630
MOV qword ptr [RSP + 0x68],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x78],RDX
JMP 0x00102636
LAB_00102630:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBX],XMM0
LAB_00102636:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x68]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [R12]
MOV RDX,qword ptr [R12 + 0x8]
LAB_0010265b:
CALL 0x00102070
LEA R13,[RSP + 0x98]
MOV qword ptr [R13 + -0x10],R13
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x00102690
MOV qword ptr [RSP + 0x88],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x98],RDX
JMP 0x00102698
LAB_00102690:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R13],XMM0
LAB_00102698:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0x88]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001026b7:
LEA RSI,[0x103025]
CALL 0x00102290
LEA RBP,[RSP + 0xb8]
MOV qword ptr [RBP + -0x10],RBP
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001026f3
MOV qword ptr [RSP + 0xa8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0xb8],RDX
JMP 0x001026fa
LAB_001026f3:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBP],XMM0
LAB_001026fa:
MOV RDX,qword ptr [RAX + 0x8]
LEA RDI,[RSP + 0xa8]
MOV qword ptr [RDI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
LAB_00102720:
CALL 0x00102070
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x0010274d
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x00102755
LAB_0010274d:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
LAB_00102755:
MOV RDX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV RDI,qword ptr [RSP + 0xa8]
CMP RDI,RBP
JZ 0x0010278a
MOV RSI,qword ptr [RSP + 0xb8]
INC RSI
CALL 0x001021d0
LAB_0010278a:
MOV RDI,qword ptr [RSP + 0x88]
CMP RDI,R13
JZ 0x001027a7
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x001021d0
LAB_001027a7:
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,RBX
JZ 0x001027be
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001021d0
LAB_001027be:
MOV RDI,qword ptr [RSP + 0x48]
LEA RAX,[RSP + 0x58]
CMP RDI,RAX
JZ 0x001027da
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001021d0
LAB_001027da:
MOV RDI,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x38]
CMP RDI,RAX
JZ 0x001027f6
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001021d0
LAB_001027f6:
LEA RAX,[RSP + 0xf8]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00102817
MOV RSI,qword ptr [RSP + 0xf8]
INC RSI
CALL 0x001021d0
LAB_00102817:
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
LAB_00102821:
MOV RDI,qword ptr [0x00104fc8]
CALL 0x001021e0
MOV R15,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R15
MOV ESI,0xa
CALL 0x001021c0
MOVSX ESI,AL
MOV RDI,R15
CALL 0x00102030
MOV RDI,RAX
CALL 0x00102110
LEA RDI,[R14 + 0x90]
CALL 0x00102050
TEST AL,AL
JZ 0x001028a7
ADD R14,0x20
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RSP + 0x10]
MOV RDI,R14
CALL 0x001021e0
MOV R14,RAX
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + -0x18]
ADD RDI,R14
MOV ESI,0xa
CALL 0x001021c0
MOVSX ESI,AL
MOV RDI,R14
CALL 0x00102030
MOV RDI,RAX
CALL 0x00102110
LAB_001028a7:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x001028be
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001021d0
LAB_001028be:
LEA RAX,[RSP + 0x118]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001028df
MOV RSI,qword ptr [RSP + 0x118]
INC RSI
CALL 0x001021d0
LAB_001028df:
LEA RAX,[RSP + 0xd8]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00102900
MOV RSI,qword ptr [RSP + 0xd8]
INC RSI
CALL 0x001021d0
LAB_00102900:
MOV RDI,qword ptr [RSP]
CALL 0x00102150
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0010291b:
MOV EDI,EAX
CALL 0x00102100
LAB_00102922:
MOV R14,RAX
MOV RDI,qword ptr [RSP + 0xa8]
CMP RDI,RBP
JZ 0x00102947
MOV RSI,qword ptr [RSP + 0xb8]
INC RSI
CALL 0x001021d0
JMP 0x00102947
LAB_00102947:
MOV RDI,qword ptr [RSP + 0x88]
CMP RDI,R13
JZ 0x00102969
MOV RSI,qword ptr [RSP + 0x98]
INC RSI
CALL 0x001021d0
JMP 0x00102969
LAB_00102969:
MOV RDI,qword ptr [RSP + 0x68]
CMP RDI,RBX
JZ 0x00102985
MOV RSI,qword ptr [RSP + 0x78]
INC RSI
CALL 0x001021d0
JMP 0x00102985
LAB_00102985:
MOV RDI,qword ptr [RSP + 0x48]
LEA RAX,[RSP + 0x58]
CMP RDI,RAX
JZ 0x001029a6
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001021d0
JMP 0x001029a6
LAB_001029a6:
MOV RDI,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x38]
CMP RDI,RAX
JZ 0x001029c7
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001021d0
JMP 0x001029c7
LAB_001029c7:
LEA RAX,[RSP + 0xf8]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00102a0b
MOV RSI,qword ptr [RSP + 0xf8]
JMP 0x00102a03
LAB_00102a03:
INC RSI
CALL 0x001021d0
LAB_00102a0b:
LEA RAX,[RSP + 0x118]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00102a2c
MOV RSI,qword ptr [RSP + 0x118]
INC RSI
CALL 0x001021d0
LAB_00102a2c:
LEA RAX,[RSP + 0xd8]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00102a4d
MOV RSI,qword ptr [RSP + 0xd8]
INC RSI
CALL 0x001021d0
LAB_00102a4d:
MOV RDI,qword ptr [RSP]
CALL 0x00102150
MOV RDI,R14
CALL 0x00102260
|
/* Logger::log(Logger::Level, std::__cxx11::string const&, std::__cxx11::string const&) */
void __thiscall Logger::log(Logger *this,uint param_2,ulong *param_3,ulong *param_4)
{
long lVar1;
char cVar2;
int iVar3;
long *plVar4;
ostream *poVar5;
int8 uVar6;
long *plVar7;
long *unaff_RBX;
pthread_mutex_t *__mutex;
long *unaff_R13;
long *local_150;
long local_140;
long lStack_138;
long *local_130;
long local_128;
long local_120;
long lStack_118;
long *local_110;
long local_108;
long local_100;
long lStack_f8;
long *local_f0;
long local_e8;
long local_e0;
long lStack_d8;
long *local_d0;
long local_c8;
long local_c0;
long lStack_b8;
long *local_b0;
long local_a8;
long local_a0;
long lStack_98;
long *local_90 [2];
long local_80 [2];
long *local_70 [2];
long local_60 [2];
long *local_50 [2];
long local_40 [2];
__mutex = (pthread_mutex_t *)(this + 0x220);
iVar3 = pthread_mutex_lock(__mutex);
if (iVar3 == 0) {
/* try { // try from 0010250a to 00102518 has its CatchHandler @ 001029ec */
details::levelToString_abi_cxx11_((details *)local_90,param_2);
/* try { // try from 00102519 to 00102525 has its CatchHandler @ 001029e7 */
details::getCurrentTime_abi_cxx11_((details *)local_50);
/* try { // try from 00102526 to 00102541 has its CatchHandler @ 001029e2 */
std::operator+((char *)local_70,(string *)&DAT_00103023);
/* try { // try from 00102542 to 00102555 has its CatchHandler @ 001029c4 */
plVar4 = (long *)std::__cxx11::string::append((char *)local_70);
local_130 = &local_120;
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_120 = *plVar7;
lStack_118 = plVar4[3];
}
else {
local_120 = *plVar7;
local_130 = (long *)*plVar4;
}
local_128 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 001025af to 001025b3 has its CatchHandler @ 001029a3 */
plVar4 = (long *)std::__cxx11::string::_M_append((char *)&local_130,(ulong)local_90[0]);
local_110 = &local_100;
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_100 = *plVar7;
lStack_f8 = plVar4[3];
}
else {
local_100 = *plVar7;
local_110 = (long *)*plVar4;
}
local_108 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 001025fd to 00102608 has its CatchHandler @ 00102982 */
plVar4 = (long *)std::__cxx11::string::append((char *)&local_110);
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_e0 = *plVar7;
lStack_d8 = plVar4[3];
local_f0 = &local_e0;
}
else {
local_e0 = *plVar7;
local_f0 = (long *)*plVar4;
}
local_e8 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 0010265b to 0010265f has its CatchHandler @ 00102966 */
plVar4 = (long *)std::__cxx11::string::_M_append((char *)&local_f0,*param_3);
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_c0 = *plVar7;
lStack_b8 = plVar4[3];
local_d0 = &local_c0;
}
else {
local_c0 = *plVar7;
local_d0 = (long *)*plVar4;
}
local_c8 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 001026b7 to 001026c2 has its CatchHandler @ 00102944 */
plVar4 = (long *)std::__cxx11::string::append((char *)&local_d0);
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_a0 = *plVar7;
lStack_98 = plVar4[3];
local_b0 = &local_a0;
}
else {
local_a0 = *plVar7;
local_b0 = (long *)*plVar4;
}
local_a8 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
/* try { // try from 00102720 to 00102724 has its CatchHandler @ 00102922 */
plVar4 = (long *)std::__cxx11::string::_M_append((char *)&local_b0,*param_4);
plVar7 = plVar4 + 2;
if ((long *)*plVar4 == plVar7) {
local_140 = *plVar7;
lStack_138 = plVar4[3];
local_150 = &local_140;
}
else {
local_140 = *plVar7;
local_150 = (long *)*plVar4;
}
lVar1 = plVar4[1];
*plVar4 = (long)plVar7;
plVar4[1] = 0;
*(int1 *)(plVar4 + 2) = 0;
if (local_b0 != &local_a0) {
operator_delete(local_b0,local_a0 + 1);
}
if (local_d0 != &local_c0) {
operator_delete(local_d0,local_c0 + 1);
}
if (local_f0 != &local_e0) {
operator_delete(local_f0,local_e0 + 1);
}
if (local_110 != &local_100) {
operator_delete(local_110,local_100 + 1);
}
if (local_130 != &local_120) {
operator_delete(local_130,local_120 + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
/* try { // try from 00102821 to 001028a6 has its CatchHandler @ 001029f1 */
poVar5 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cout_00104fc8,(char *)local_150,lVar1);
std::ios::widen((char)*(int8 *)(*(long *)poVar5 + -0x18) + (char)poVar5);
std::ostream::put((char)poVar5);
std::ostream::flush();
cVar2 = std::__basic_file<char>::is_open();
if (cVar2 != '\0') {
poVar5 = std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(this + 0x20),(char *)local_150,lVar1);
std::ios::widen((char)*(int8 *)(*(long *)poVar5 + -0x18) + (char)poVar5);
std::ostream::put((char)poVar5);
std::ostream::flush();
}
if (local_150 != &local_140) {
operator_delete(local_150,local_140 + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
pthread_mutex_unlock(__mutex);
return;
}
uVar6 = std::__throw_system_error(iVar3);
/* catch() { ... } // from try @ 00102720 with catch @ 00102922 */
if (local_b0 != (long *)(ulong)param_2) {
operator_delete(local_b0,local_a0 + 1);
}
if (local_d0 != unaff_R13) {
operator_delete(local_d0,local_c0 + 1);
}
if (local_f0 != unaff_RBX) {
operator_delete(local_f0,local_e0 + 1);
}
if (local_110 != &local_100) {
operator_delete(local_110,local_100 + 1);
}
if (local_130 != &local_120) {
operator_delete(local_130,local_120 + 1);
}
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
if (local_90[0] != local_80) {
operator_delete(local_90[0],local_80[0] + 1);
}
pthread_mutex_unlock(__mutex);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar6);
}
| |
24,429 | js_agent_free | bluesky950520[P]quickjs/run-test262.c | static void js_agent_free(JSContext *ctx)
{
ThreadLocalStorage *tls = JS_GetRuntimeOpaque(JS_GetRuntime(ctx));
struct list_head *el, *el1;
Test262Agent *agent;
list_for_each_safe(el, el1, &tls->agent_list) {
agent = list_entry(el, Test262Agent, link);
join_thread(agent->tid);
JS_FreeValue(ctx, agent->broadcast_sab);
list_del(&agent->link);
free(agent);
}
} | O0 | c | js_agent_free:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2e1f0
movq %rax, %rdi
callq 0x299e0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
je 0x12767
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14580
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x40(%rax), %rdx
callq 0x29f80
movq (%rsp), %rdi
callq 0x15f90
movq (%rsp), %rdi
callq 0xe060
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x126fc
addq $0x28, %rsp
retq
nopl (%rax)
| js_agent_free:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov rdi, [rsp+28h+var_8]
call JS_GetRuntime
mov rdi, rax
call JS_GetRuntimeOpaque
mov [rsp+28h+var_10], rax
mov rax, [rsp+28h+var_10]
mov rax, [rax+60h]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov rax, [rax+8]
mov [rsp+28h+var_20], rax
loc_126FC:
mov rax, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_10]
add rcx, 58h ; 'X'
cmp rax, rcx
jz short loc_12767
mov rax, [rsp+28h+var_18]
mov [rsp+28h+var_28], rax
mov rax, [rsp+28h+var_28]
mov rdi, [rax+10h]
call join_thread
mov rdi, [rsp+28h+var_8]
mov rax, [rsp+28h+var_28]
mov rsi, [rax+38h]
mov rdx, [rax+40h]
call JS_FreeValue
mov rdi, [rsp+28h+var_28]
call list_del
mov rdi, [rsp+28h+var_28]
call _free
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov rax, [rax+8]
mov [rsp+28h+var_20], rax
jmp short loc_126FC
loc_12767:
add rsp, 28h
retn
| _QWORD * js_agent_free(long long a1)
{
long long Runtime; // rax
_QWORD *result; // rax
_QWORD *i; // [rsp+8h] [rbp-20h]
_QWORD *v4; // [rsp+10h] [rbp-18h]
long long RuntimeOpaque; // [rsp+18h] [rbp-10h]
Runtime = JS_GetRuntime(a1);
RuntimeOpaque = JS_GetRuntimeOpaque(Runtime);
v4 = *(_QWORD **)(RuntimeOpaque + 96);
for ( i = (_QWORD *)v4[1]; ; i = (_QWORD *)i[1] )
{
result = v4;
if ( v4 == (_QWORD *)(RuntimeOpaque + 88) )
break;
join_thread(v4[2]);
JS_FreeValue(a1, v4[7], v4[8]);
list_del(v4);
free(v4);
v4 = i;
}
return result;
}
| js_agent_free:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0012e1f0
MOV RDI,RAX
CALL 0x001299e0
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
LAB_001126fc:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
ADD RCX,0x58
CMP RAX,RCX
JZ 0x00112767
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00114580
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP]
MOV RSI,qword ptr [RAX + 0x38]
MOV RDX,qword ptr [RAX + 0x40]
CALL 0x00129f80
MOV RDI,qword ptr [RSP]
CALL 0x00115f90
MOV RDI,qword ptr [RSP]
CALL 0x0010e060
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001126fc
LAB_00112767:
ADD RSP,0x28
RET
|
void js_agent_free(int8 param_1)
{
int8 uVar1;
long lVar2;
int8 local_20;
int8 local_18;
uVar1 = JS_GetRuntime(param_1);
lVar2 = JS_GetRuntimeOpaque(uVar1);
local_18 = *(void **)(lVar2 + 0x60);
local_20 = *(void **)((long)local_18 + 8);
while (local_18 != (void *)(lVar2 + 0x58)) {
join_thread(*(int8 *)((long)local_18 + 0x10));
JS_FreeValue(param_1,*(int8 *)((long)local_18 + 0x38),
*(int8 *)((long)local_18 + 0x40));
list_del(local_18);
free(local_18);
local_18 = local_20;
local_20 = *(void **)((long)local_20 + 8);
}
return;
}
| |
24,430 | js_agent_free | bluesky950520[P]quickjs/run-test262.c | static void js_agent_free(JSContext *ctx)
{
ThreadLocalStorage *tls = JS_GetRuntimeOpaque(JS_GetRuntime(ctx));
struct list_head *el, *el1;
Test262Agent *agent;
list_for_each_safe(el, el1, &tls->agent_list) {
agent = list_entry(el, Test262Agent, link);
join_thread(agent->tid);
JS_FreeValue(ctx, agent->broadcast_sab);
list_del(&agent->link);
free(agent);
}
} | O2 | c | js_agent_free:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1dd35
movq %rax, %rdi
callq 0x1b9a5
movq %rax, %r14
movq 0x60(%rax), %r15
addq $0x58, %r14
cmpq %r14, %r15
je 0x110f0
movq 0x8(%r15), %r12
movq 0x10(%r15), %rdi
callq 0x12611
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rdx
movq %rbx, %rdi
callq 0x1bbce
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
movq %r15, %rdi
callq 0xe060
movq %r12, %r15
jmp 0x110b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_agent_free:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
call JS_GetRuntime
mov rdi, rax
call JS_GetRuntimeOpaque
mov r14, rax
mov r15, [rax+60h]
add r14, 58h ; 'X'
loc_110B3:
cmp r15, r14
jz short loc_110F0
mov r12, [r15+8]
mov rdi, [r15+10h]
call join_thread
mov rsi, [r15+38h]
mov rdx, [r15+40h]
mov rdi, rbx
call JS_FreeValue
mov rax, [r15]
mov rcx, [r15+8]
mov [rax+8], rcx
mov [rcx], rax
mov rdi, r15
call _free
mov r15, r12
jmp short loc_110B3
loc_110F0:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long js_agent_free(long long a1)
{
long long Runtime; // rax
long long result; // rax
long long *v3; // r15
long long *v4; // r14
long long *v5; // r12
long long v6; // rax
_QWORD *v7; // rcx
Runtime = JS_GetRuntime(a1);
result = JS_GetRuntimeOpaque(Runtime);
v3 = *(long long **)(result + 96);
v4 = (long long *)(result + 88);
while ( v3 != v4 )
{
v5 = (long long *)v3[1];
join_thread(v3[2]);
JS_FreeValue(a1, v3[7]);
v6 = *v3;
v7 = (_QWORD *)v3[1];
*(_QWORD *)(v6 + 8) = v7;
*v7 = v6;
result = free(v3);
v3 = v5;
}
return result;
}
| js_agent_free:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
CALL 0x0011dd35
MOV RDI,RAX
CALL 0x0011b9a5
MOV R14,RAX
MOV R15,qword ptr [RAX + 0x60]
ADD R14,0x58
LAB_001110b3:
CMP R15,R14
JZ 0x001110f0
MOV R12,qword ptr [R15 + 0x8]
MOV RDI,qword ptr [R15 + 0x10]
CALL 0x00112611
MOV RSI,qword ptr [R15 + 0x38]
MOV RDX,qword ptr [R15 + 0x40]
MOV RDI,RBX
CALL 0x0011bbce
MOV RAX,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
MOV RDI,R15
CALL 0x0010e060
MOV R15,R12
JMP 0x001110b3
LAB_001110f0:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
void js_agent_free(int8 param_1)
{
long *plVar1;
long lVar2;
long *plVar3;
int8 uVar4;
long lVar5;
long *__ptr;
uVar4 = JS_GetRuntime();
lVar5 = JS_GetRuntimeOpaque(uVar4);
__ptr = *(long **)(lVar5 + 0x60);
while (__ptr != (long *)(lVar5 + 0x58)) {
plVar1 = (long *)__ptr[1];
join_thread(__ptr[2]);
JS_FreeValue(param_1,__ptr[7],__ptr[8]);
lVar2 = *__ptr;
plVar3 = (long *)__ptr[1];
*(long **)(lVar2 + 8) = plVar3;
*plVar3 = lVar2;
free(__ptr);
__ptr = plVar1;
}
return;
}
| |
24,431 | Catch::Clara::ExeName::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const | AlayaLite/build_O3/_deps/libcoro-src/test/catch_amalgamated.cpp | Detail::InternalParseResult
ExeName::parse(std::string const&,
Detail::TokenStream const& tokens) const {
return Detail::InternalParseResult::ok(
Detail::ParseState(ParseResultType::NoMatch, tokens));
} | O3 | cpp | Catch::Clara::ExeName::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Clara::Detail::TokenStream const&) const:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x1, %esi
movq %rcx, %rdx
callq 0x59948
movl $0x0, 0x8(%rbx)
leaq 0xd5d47(%rip), %rax # 0x1305b8
addq $0x10, %rax
movq %rax, (%rbx)
movl (%r14), %eax
movl %eax, 0x10(%rbx)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x7e348
leaq 0xd5cc1(%rip), %rax # 0x130560
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movb $0x0, 0x50(%rbx)
movq %r14, %rdi
callq 0x77552
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x77552
movq %rbx, %rdi
callq 0x17740
| _ZNK5Catch5Clara7ExeName5parseERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKNS0_6Detail11TokenStreamE:
push r14
push rbx
sub rsp, 38h
mov rbx, rdi
lea r14, [rsp+48h+var_40]
mov rdi, r14
mov esi, 1
mov rdx, rcx
call _ZN5Catch5Clara6Detail10ParseStateC2ENS0_15ParseResultTypeERKNS1_11TokenStreamE; Catch::Clara::Detail::ParseState::ParseState(Catch::Clara::ParseResultType,Catch::Clara::Detail::TokenStream const&)
mov dword ptr [rbx+8], 0
lea rax, _ZTVN5Catch5Clara6Detail15ResultValueBaseINS1_10ParseStateEEE; `vtable for'Catch::Clara::Detail::ResultValueBase<Catch::Clara::Detail::ParseState>
add rax, 10h
mov [rbx], rax
mov eax, [r14]
mov [rbx+10h], eax
movups xmm0, xmmword ptr [r14+8]
movups xmmword ptr [rbx+18h], xmm0
lea rdi, [rbx+28h]
lea r14, [rsp+48h+var_28]
mov rsi, r14
call _ZNSt6vectorIN5Catch5Clara6Detail5TokenESaIS3_EEC2ERKS5_; std::vector<Catch::Clara::Detail::Token>::vector(std::vector<Catch::Clara::Detail::Token> const&)
lea rax, _ZTVN5Catch5Clara6Detail11BasicResultINS1_10ParseStateEEE; `vtable for'Catch::Clara::Detail::BasicResult<Catch::Clara::Detail::ParseState>
add rax, 10h
mov [rbx], rax
lea rax, [rbx+50h]
mov [rbx+40h], rax
mov qword ptr [rbx+48h], 0
mov byte ptr [rbx+50h], 0
mov rdi, r14
call _ZNSt6vectorIN5Catch5Clara6Detail5TokenESaIS3_EED2Ev; std::vector<Catch::Clara::Detail::Token>::~vector()
mov rax, rbx
add rsp, 38h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, r14
call _ZNSt6vectorIN5Catch5Clara6Detail5TokenESaIS3_EED2Ev; std::vector<Catch::Clara::Detail::Token>::~vector()
mov rdi, rbx
call __Unwind_Resume
| long long Catch::Clara::ExeName::parse(long long a1, long long a2, long long a3, _OWORD *a4)
{
int v5; // [rsp+8h] [rbp-40h] BYREF
__int128 v6; // [rsp+10h] [rbp-38h]
_BYTE v7[40]; // [rsp+20h] [rbp-28h] BYREF
Catch::Clara::Detail::ParseState::ParseState((long long)&v5, 1, a4);
*(_DWORD *)(a1 + 8) = 0;
*(_QWORD *)a1 = &`vtable for'Catch::Clara::Detail::ResultValueBase<Catch::Clara::Detail::ParseState> + 2;
*(_DWORD *)(a1 + 16) = v5;
*(_OWORD *)(a1 + 24) = v6;
std::vector<Catch::Clara::Detail::Token>::vector(a1 + 40, v7);
*(_QWORD *)a1 = &`vtable for'Catch::Clara::Detail::BasicResult<Catch::Clara::Detail::ParseState> + 2;
*(_QWORD *)(a1 + 64) = a1 + 80;
*(_QWORD *)(a1 + 72) = 0LL;
*(_BYTE *)(a1 + 80) = 0;
std::vector<Catch::Clara::Detail::Token>::~vector(v7);
return a1;
}
| parse:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RBX,RDI
LEA R14,[RSP + 0x8]
MOV RDI,R14
MOV ESI,0x1
MOV RDX,RCX
CALL 0x00159948
MOV dword ptr [RBX + 0x8],0x0
LEA RAX,[0x2305b8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [R14]
MOV dword ptr [RBX + 0x10],EAX
MOVUPS XMM0,xmmword ptr [R14 + 0x8]
MOVUPS xmmword ptr [RBX + 0x18],XMM0
LEA RDI,[RBX + 0x28]
LEA R14,[RSP + 0x20]
LAB_0015a890:
MOV RSI,R14
CALL 0x0017e348
LAB_0015a898:
LEA RAX,[0x230560]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RAX,[RBX + 0x50]
MOV qword ptr [RBX + 0x40],RAX
MOV qword ptr [RBX + 0x48],0x0
MOV byte ptr [RBX + 0x50],0x0
MOV RDI,R14
CALL 0x00177552
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R14
RET
|
/* Catch::Clara::ExeName::parse(std::__cxx11::string const&, Catch::Clara::Detail::TokenStream
const&) const */
string * Catch::Clara::ExeName::parse(string *param_1,TokenStream *param_2)
{
int4 local_40 [2];
int8 local_38;
int8 uStack_30;
vector<Catch::Clara::Detail::Token,std::allocator<Catch::Clara::Detail::Token>> local_28 [24];
Detail::ParseState::ParseState((ParseState *)local_40,1);
*(int4 *)(param_1 + 8) = 0;
*(int ***)param_1 = &PTR__ResultValueBase_002305c8;
*(int4 *)(param_1 + 0x10) = local_40[0];
*(int8 *)(param_1 + 0x18) = local_38;
*(int8 *)(param_1 + 0x20) = uStack_30;
/* try { // try from 0015a890 to 0015a897 has its CatchHandler @ 0015a8cd */
std::vector<Catch::Clara::Detail::Token,std::allocator<Catch::Clara::Detail::Token>>::vector
((vector<Catch::Clara::Detail::Token,std::allocator<Catch::Clara::Detail::Token>> *)
(param_1 + 0x28),(vector *)local_28);
*(int ***)param_1 = &PTR__BasicResult_00230570;
*(string **)(param_1 + 0x40) = param_1 + 0x50;
*(int8 *)(param_1 + 0x48) = 0;
param_1[0x50] = (string)0x0;
std::vector<Catch::Clara::Detail::Token,std::allocator<Catch::Clara::Detail::Token>>::~vector
(local_28);
return param_1;
}
| |
24,432 | rtree_add_key | eloqsql/storage/myisam/rt_key.c | int rtree_add_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *key,
uint key_length, uchar *page_buf, my_off_t *new_page)
{
uint page_size = mi_getint(page_buf);
uint nod_flag = mi_test_if_nod(page_buf);
DBUG_ENTER("rtree_add_key");
if (page_size + key_length + info->s->base.rec_reflength <=
keyinfo->block_length)
{
/* split won't be necessary */
if (nod_flag)
{
/* save key */
DBUG_ASSERT(_mi_kpos(nod_flag, key) < info->state->key_file_length);
memcpy(rt_PAGE_END(page_buf), key - nod_flag, key_length + nod_flag);
page_size += key_length + nod_flag;
}
else
{
/* save key */
DBUG_ASSERT(_mi_dpos(info, nod_flag, key + key_length +
info->s->base.rec_reflength) <
info->state->data_file_length + info->s->base.pack_reclength);
memcpy(rt_PAGE_END(page_buf), key, key_length +
info->s->base.rec_reflength);
page_size += key_length + info->s->base.rec_reflength;
}
mi_putint(page_buf, page_size, nod_flag);
DBUG_RETURN(0);
}
DBUG_RETURN((rtree_split_page(info, keyinfo, page_buf, key, key_length,
new_page) ? -1 : 1));
} | O0 | c | rtree_add_key:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xcada7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xcadae
xorl %eax, %eax
movl %eax, -0x4c(%rbp)
jmp 0xcadae
movl -0x4c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addl 0x178(%rcx), %eax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
cmpl %ecx, %eax
ja 0xcaee2
cmpl $0x0, -0x40(%rbp)
je 0xcae3a
jmp 0xcaddf
jmp 0xcade1
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x40(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x24(%rbp), %eax
addl -0x40(%rbp), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a090
movl -0x24(%rbp), %eax
addl -0x40(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0xcae9c
jmp 0xcae3c
jmp 0xcae3e
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
andl $0x7fff, %eax # imm = 0x7FFF
movl %eax, %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addl 0x178(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2a090
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addl 0x178(%rcx), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %edx
xorl %eax, %eax
movl $0x8000, %ecx # imm = 0x8000
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl -0x3c(%rbp), %ecx
movzwl %cx, %ecx
addl %ecx, %eax
movw %ax, -0x42(%rbp)
movzwl -0x42(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x48(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xcaf16
jmp 0xcaee4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq -0x38(%rbp), %r9
callq 0xd5190
movl %eax, %edx
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| rtree_add_key:
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_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov [rbp+var_3C], eax
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_CADA7
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_4C], eax
jmp short loc_CADAE
loc_CADA7:
xor eax, eax
mov [rbp+var_4C], eax
jmp short $+2
loc_CADAE:
mov eax, [rbp+var_4C]
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
add eax, [rbp+var_24]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
add eax, [rcx+178h]
mov rcx, [rbp+var_18]
movzx ecx, word ptr [rcx+0Eh]
cmp eax, ecx
ja loc_CAEE2
cmp [rbp+var_40], 0
jz short loc_CAE3A
jmp short $+2
loc_CADDF:
jmp short $+2
loc_CADE1:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_20]
mov eax, [rbp+var_40]
mov ecx, eax
xor eax, eax
sub rax, rcx
add rsi, rax
mov eax, [rbp+var_24]
add eax, [rbp+var_40]
mov eax, eax
mov edx, eax
call _memcpy
mov eax, [rbp+var_24]
add eax, [rbp+var_40]
add eax, [rbp+var_3C]
mov [rbp+var_3C], eax
jmp short loc_CAE9C
loc_CAE3A:
jmp short $+2
loc_CAE3C:
jmp short $+2
loc_CAE3E:
mov rdi, [rbp+var_30]
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
and eax, 7FFFh
mov eax, eax
add rdi, rax
mov rsi, [rbp+var_20]
mov eax, [rbp+var_24]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
add eax, [rcx+178h]
mov eax, eax
mov edx, eax
call _memcpy
mov eax, [rbp+var_24]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
add eax, [rcx+178h]
add eax, [rbp+var_3C]
mov [rbp+var_3C], eax
loc_CAE9C:
mov edx, [rbp+var_40]
xor eax, eax
mov ecx, 8000h
cmp edx, 0
cmovnz eax, ecx
mov ecx, [rbp+var_3C]
movzx ecx, cx
add eax, ecx
mov [rbp+var_42], ax
movzx eax, [rbp+var_42]
mov [rbp+var_48], eax
mov eax, [rbp+var_48]
mov cl, al
mov rax, [rbp+var_30]
mov [rax+1], cl
mov eax, [rbp+var_48]
shr eax, 8
mov cl, al
mov rax, [rbp+var_30]
mov [rax], cl
mov [rbp+var_4], 0
jmp short loc_CAF16
loc_CAEE2:
jmp short $+2
loc_CAEE4:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_20]
mov r8d, [rbp+var_24]
mov r9, [rbp+var_38]
call rtree_split_page
mov edx, eax
mov eax, 1
mov ecx, 0FFFFFFFFh
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_CAF16:
mov eax, [rbp+var_4]
add rsp, 50h
pop rbp
retn
| long long rtree_add_key(long long a1, long long a2, long long a3, unsigned int a4, long long a5, long long a6)
{
__int16 v6; // ax
int v7; // edx
unsigned int v8; // eax
unsigned int v10; // [rsp+4h] [rbp-4Ch]
int v11; // [rsp+14h] [rbp-3Ch]
v11 = _byteswap_ushort(*(_WORD *)a5) & 0x7FFF;
if ( (*(_BYTE *)a5 & 0x80) != 0 )
v10 = *(_DWORD *)(*(_QWORD *)a1 + 380LL);
else
v10 = 0;
if ( *(_DWORD *)(*(_QWORD *)a1 + 376LL) + a4 + v11 > *(unsigned __int16 *)(a2 + 14) )
{
v7 = rtree_split_page(a1, a2, a5, a3, a4, a6);
v8 = 1;
if ( v7 )
return (unsigned int)-1;
return v8;
}
else
{
if ( v10 )
{
memcpy((_byteswap_ushort(*(_WORD *)a5) & 0x7FFF) + a5, a3 - v10, v10 + a4);
LOWORD(v11) = v11 + v10 + a4;
}
else
{
memcpy((_byteswap_ushort(*(_WORD *)a5) & 0x7FFF) + a5, a3, *(_DWORD *)(*(_QWORD *)a1 + 376LL) + a4);
v11 += *(_DWORD *)(*(_QWORD *)a1 + 376LL) + a4;
}
v6 = 0;
if ( v10 )
v6 = 0x8000;
*(_BYTE *)(a5 + 1) = v11 + v6;
*(_BYTE *)a5 = (unsigned __int16)(v11 + v6) >> 8;
return 0;
}
}
| rtree_add_key:
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 dword ptr [RBP + -0x24],ECX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001cada7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001cadae
LAB_001cada7:
XOR EAX,EAX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001cadae
LAB_001cadae:
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
ADD EAX,dword ptr [RCX + 0x178]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RCX + 0xe]
CMP EAX,ECX
JA 0x001caee2
CMP dword ptr [RBP + -0x40],0x0
JZ 0x001cae3a
JMP 0x001caddf
LAB_001caddf:
JMP 0x001cade1
LAB_001cade1:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x40]
MOV ECX,EAX
XOR EAX,EAX
SUB RAX,RCX
ADD RSI,RAX
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,dword ptr [RBP + -0x40]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,dword ptr [RBP + -0x40]
ADD EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x001cae9c
LAB_001cae3a:
JMP 0x001cae3c
LAB_001cae3c:
JMP 0x001cae3e
LAB_001cae3e:
MOV RDI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
AND EAX,0x7fff
MOV EAX,EAX
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
ADD EAX,dword ptr [RCX + 0x178]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
ADD EAX,dword ptr [RCX + 0x178]
ADD EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x3c],EAX
LAB_001cae9c:
MOV EDX,dword ptr [RBP + -0x40]
XOR EAX,EAX
MOV ECX,0x8000
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV ECX,dword ptr [RBP + -0x3c]
MOVZX ECX,CX
ADD EAX,ECX
MOV word ptr [RBP + -0x42],AX
MOVZX EAX,word ptr [RBP + -0x42]
MOV dword ptr [RBP + -0x48],EAX
MOV EAX,dword ptr [RBP + -0x48]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX + 0x1],CL
MOV EAX,dword ptr [RBP + -0x48]
SHR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x30]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001caf16
LAB_001caee2:
JMP 0x001caee4
LAB_001caee4:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8D,dword ptr [RBP + -0x24]
MOV R9,qword ptr [RBP + -0x38]
CALL 0x001d5190
MOV EDX,EAX
MOV EAX,0x1
MOV ECX,0xffffffff
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_001caf16:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x50
POP RBP
RET
|
int4
rtree_add_key(long *param_1,long param_2,void *param_3,int param_4,byte *param_5,int8 param_6)
{
short sVar1;
uint uVar2;
int iVar3;
uint local_54;
short local_44;
int4 local_c;
uVar2 = (uint)param_5[1] | (*param_5 & 0x7f) << 8;
if ((*param_5 & 0x80) == 0) {
local_54 = 0;
}
else {
local_54 = *(uint *)(*param_1 + 0x17c);
}
if ((uint)*(ushort *)(param_2 + 0xe) < uVar2 + param_4 + *(int *)(*param_1 + 0x178)) {
iVar3 = rtree_split_page(param_1,param_2,param_5,param_3,param_4,param_6);
local_c = 1;
if (iVar3 != 0) {
local_c = 0xffffffff;
}
}
else {
if (local_54 == 0) {
memcpy(param_5 + ((uint)param_5[1] | (*param_5 & 0x7f) << 8),param_3,
(ulong)(uint)(param_4 + *(int *)(*param_1 + 0x178)));
sVar1 = (short)*(int4 *)(*param_1 + 0x178);
}
else {
memcpy(param_5 + ((uint)param_5[1] | (*param_5 & 0x7f) << 8),
(void *)((long)param_3 - (ulong)local_54),(ulong)(param_4 + local_54));
sVar1 = (short)local_54;
}
local_44 = (short)param_4 + sVar1 + (short)uVar2;
sVar1 = 0;
if (local_54 != 0) {
sVar1 = -0x8000;
}
param_5[1] = (byte)(sVar1 + local_44);
*param_5 = (byte)((ushort)(sVar1 + local_44) >> 8);
local_c = 0;
}
return local_c;
}
| |
24,433 | my_hash_sort_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,ulong *nr1, ulong *nr2)
{
const uchar *end = key + len;
ulong tmp1= *nr1;
ulong tmp2= *nr2;
for (; key < end ; key++)
{
MY_HASH_ADD(tmp1, tmp2, (uint) *key);
}
*nr1= tmp1;
*nr2= tmp2;
} | O3 | c | my_hash_sort_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0xaf29b
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0xaf26f
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
| my_hash_sort_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_AF29B
push rbp
mov rbp, rsp
add rdx, rsi
loc_AF26F:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_AF26F
pop rbp
loc_AF29B:
mov [rcx], rax
mov [r8], rdi
retn
| long long my_hash_sort_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
| my_hash_sort_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x001af29b
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_001af26f:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x001af26f
POP RBP
LAB_001af29b:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_bin(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
| |
24,434 | mark_all_entries | eloqsql/storage/myisam/rt_split.c | static void mark_all_entries(SplitStruct *node, int n_entries, int n_group)
{
SplitStruct *cur = node;
SplitStruct *end = node + n_entries;
for (; cur<end; ++cur)
{
if (cur->n_node)
{
continue;
}
cur->n_node = n_group;
}
} | O0 | c | mark_all_entries:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xd70f7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0xd70df
jmp 0xd70e9
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
jmp 0xd70c9
popq %rbp
retq
nopl (%rax)
| mark_all_entries_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_10], edx
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
movsxd rcx, [rbp+var_C]
shl rcx, 5
add rax, rcx
mov [rbp+var_20], rax
loc_D70C9:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_D70F7
mov rax, [rbp+var_18]
cmp dword ptr [rax+8], 0
jz short loc_D70DF
jmp short loc_D70E9
loc_D70DF:
mov ecx, [rbp+var_10]
mov rax, [rbp+var_18]
mov [rax+8], ecx
loc_D70E9:
mov rax, [rbp+var_18]
add rax, 20h ; ' '
mov [rbp+var_18], rax
jmp short loc_D70C9
loc_D70F7:
pop rbp
retn
| unsigned long long mark_all_entries_0(unsigned long long a1, int a2, int a3)
{
unsigned long long result; // rax
unsigned long long i; // [rsp+8h] [rbp-18h]
for ( i = a1; ; i += 32LL )
{
result = i;
if ( i >= 32LL * a2 + a1 )
break;
if ( !*(_DWORD *)(i + 8) )
*(_DWORD *)(i + 8) = a3;
}
return result;
}
| mark_all_entries:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV dword ptr [RBP + -0x10],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RBP + -0xc]
SHL RCX,0x5
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
LAB_001d70c9:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001d70f7
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x001d70df
JMP 0x001d70e9
LAB_001d70df:
MOV ECX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
LAB_001d70e9:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x20
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001d70c9
LAB_001d70f7:
POP RBP
RET
|
void mark_all_entries(ulong param_1,int param_2,int4 param_3)
{
int8 local_20;
for (local_20 = param_1; local_20 < param_1 + (long)param_2 * 0x20; local_20 = local_20 + 0x20) {
if (*(int *)(local_20 + 8) == 0) {
*(int4 *)(local_20 + 8) = param_3;
}
}
return;
}
| |
24,435 | void OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::transformLinearQuadWeightsToStencil<double>(double*, int) | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surface.cpp | inline void
transformLinearQuadWeightsToStencil(REAL w[4], int N) {
REAL wOrigin = w[0];
REAL wNext = w[1] * 0.5f;
REAL wCenter = w[2] / (REAL)N;
REAL wPrev = w[3] * 0.5f;
w[0] = wCenter + wNext + wPrev + wOrigin;
w[1] = wCenter + wNext;
w[2] = wCenter;
w[3] = wCenter + wPrev;
} | O2 | cpp | void OpenSubdiv::v3_6_0::Bfr::(anonymous namespace)::transformLinearQuadWeightsToStencil<double>(double*, int):
movsd 0x1acfb(%rip), %xmm0 # 0xbe4f0
movsd 0x8(%rdi), %xmm1
mulsd %xmm0, %xmm1
movsd 0x10(%rdi), %xmm2
cvtsi2sd %esi, %xmm3
divsd %xmm3, %xmm2
mulsd 0x18(%rdi), %xmm0
addsd %xmm2, %xmm1
movapd %xmm1, %xmm3
addsd %xmm0, %xmm3
addsd (%rdi), %xmm3
movsd %xmm3, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
addsd %xmm2, %xmm0
movsd %xmm0, 0x18(%rdi)
retq
| _ZN10OpenSubdiv6v3_6_03Bfr12_GLOBAL__N_135transformLinearQuadWeightsToStencilIdEEvPT_i:
movsd xmm0, cs:qword_BE4F0
movsd xmm1, qword ptr [rdi+8]
mulsd xmm1, xmm0
movsd xmm2, qword ptr [rdi+10h]
cvtsi2sd xmm3, esi
divsd xmm2, xmm3
mulsd xmm0, qword ptr [rdi+18h]
addsd xmm1, xmm2
movapd xmm3, xmm1
addsd xmm3, xmm0
addsd xmm3, qword ptr [rdi]
movsd qword ptr [rdi], xmm3
movsd qword ptr [rdi+8], xmm1
movsd qword ptr [rdi+10h], xmm2
addsd xmm0, xmm2
movsd qword ptr [rdi+18h], xmm0
retn
| void OpenSubdiv::v3_6_0::Bfr::`anonymous namespace'::transformLinearQuadWeightsToStencil<double>(
double *a1,
int a2)
{
double v2; // xmm2_8
double v3; // xmm0_8
double v4; // xmm1_8
v2 = a1[2] / (double)a2;
v3 = 0.5 * a1[3];
v4 = a1[1] * 0.5 + v2;
*a1 = v4 + v3 + *a1;
a1[1] = v4;
a1[2] = v2;
a1[3] = v3 + v2;
}
| transformLinearQuadWeightsToStencil<double>:
MOVSD XMM0,qword ptr [0x001be4f0]
MOVSD XMM1,qword ptr [RDI + 0x8]
MULSD XMM1,XMM0
MOVSD XMM2,qword ptr [RDI + 0x10]
CVTSI2SD XMM3,ESI
DIVSD XMM2,XMM3
MULSD XMM0,qword ptr [RDI + 0x18]
ADDSD XMM1,XMM2
MOVAPD XMM3,XMM1
ADDSD XMM3,XMM0
ADDSD XMM3,qword ptr [RDI]
MOVSD qword ptr [RDI],XMM3
MOVSD qword ptr [RDI + 0x8],XMM1
MOVSD qword ptr [RDI + 0x10],XMM2
ADDSD XMM0,XMM2
MOVSD qword ptr [RDI + 0x18],XMM0
RET
|
/* void OpenSubdiv::v3_6_0::Bfr::(anonymous
namespace)::transformLinearQuadWeightsToStencil<double>(double*, int) */
void OpenSubdiv::v3_6_0::Bfr::(anonymous_namespace)::transformLinearQuadWeightsToStencil<double>
(double *param_1,int param_2)
{
double dVar1;
double dVar2;
double dVar3;
dVar3 = param_1[2] / (double)param_2;
dVar1 = DAT_001be4f0 * param_1[3];
dVar2 = param_1[1] * DAT_001be4f0 + dVar3;
*param_1 = dVar2 + dVar1 + *param_1;
param_1[1] = dVar2;
param_1[2] = dVar3;
param_1[3] = dVar1 + dVar3;
return;
}
| |
24,436 | alaya::LinearPoolTest_PopTest_Test::TestBody() | AlayaLite/tests/utils/query_utils_test.cpp | TEST_F(LinearPoolTest, PopTest) {
pool_->insert(1, 2.5);
pool_->insert(2, 1.5);
pool_->insert(3, 3.0);
EXPECT_EQ(pool_->top(), 2);
EXPECT_EQ(pool_->pop(), 2);
EXPECT_EQ(pool_->pop(), 1);
EXPECT_EQ(pool_->pop(), 3);
} | O0 | cpp | alaya::LinearPoolTest_PopTest_Test::TestBody():
subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rax), %rdi
movl $0x1, %esi
movss 0xf3e37(%rip), %xmm0 # 0x10c004
callq 0x1ab00
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x2, %esi
movss 0xf3e20(%rip), %xmm0 # 0x10c008
callq 0x1ab00
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
movl $0x3, %esi
movss 0xf3e09(%rip), %xmm0 # 0x10c00c
callq 0x1ab00
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1adf0
movl %eax, 0x10c(%rsp)
movl $0x2, 0x108(%rsp)
leaq 0xf3e98(%rip), %rsi # 0x10c0c7
leaq 0xf5528(%rip), %rdx # 0x10d75e
leaq 0x110(%rsp), %rdi
movq %rdi, 0x60(%rsp)
leaq 0x10c(%rsp), %rcx
leaq 0x108(%rsp), %r8
callq 0x1ada0
movq 0x60(%rsp), %rdi
callq 0x1acb0
movb %al, 0x6f(%rsp)
jmp 0x18268
movb 0x6f(%rsp), %al
testb $0x1, %al
jne 0x18272
jmp 0x18290
jmp 0x18351
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x183cd
leaq 0xf0(%rsp), %rdi
callq 0xc0620
jmp 0x1829f
leaq 0x110(%rsp), %rdi
callq 0x1ad60
movq %rax, 0x50(%rsp)
jmp 0x182b3
movq 0x50(%rsp), %r8
leaq 0xf3d8b(%rip), %rdx # 0x10c04a
leaq 0xe8(%rsp), %rdi
movl $0x1, %esi
movl $0x2e, %ecx
callq 0xbc3b0
jmp 0x182d8
leaq 0xe8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xb8af0
jmp 0x182ef
leaq 0xe8(%rsp), %rdi
callq 0xbc440
leaq 0xf0(%rsp), %rdi
callq 0x1acd0
jmp 0x18351
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x18342
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0xbc440
leaq 0xf0(%rsp), %rdi
callq 0x1acd0
jmp 0x183cd
leaq 0x110(%rsp), %rdi
callq 0x1ace0
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1ae10
movl %eax, 0xd4(%rsp)
movl $0x2, 0xd0(%rsp)
leaq 0xf3d4f(%rip), %rsi # 0x10c0d4
leaq 0xf53d2(%rip), %rdx # 0x10d75e
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x40(%rsp)
leaq 0xd4(%rsp), %rcx
leaq 0xd0(%rsp), %r8
callq 0x1ada0
movq 0x40(%rsp), %rdi
callq 0x1acb0
movb %al, 0x4f(%rsp)
jmp 0x183be
movb 0x4f(%rsp), %al
testb $0x1, %al
jne 0x183c8
jmp 0x183f8
jmp 0x184b9
leaq 0x110(%rsp), %rdi
callq 0x1ace0
jmp 0x18793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x18535
leaq 0xc8(%rsp), %rdi
callq 0xc0620
jmp 0x18407
leaq 0xd8(%rsp), %rdi
callq 0x1ad60
movq %rax, 0x38(%rsp)
jmp 0x1841b
movq 0x38(%rsp), %r8
leaq 0xf3c23(%rip), %rdx # 0x10c04a
leaq 0xc0(%rsp), %rdi
movl $0x1, %esi
movl $0x30, %ecx
callq 0xbc3b0
jmp 0x18440
leaq 0xc0(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xb8af0
jmp 0x18457
leaq 0xc0(%rsp), %rdi
callq 0xbc440
leaq 0xc8(%rsp), %rdi
callq 0x1acd0
jmp 0x184b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x184aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xbc440
leaq 0xc8(%rsp), %rdi
callq 0x1acd0
jmp 0x18535
leaq 0xd8(%rsp), %rdi
callq 0x1ace0
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1ae10
movl %eax, 0xac(%rsp)
movl $0x1, 0xa8(%rsp)
leaq 0xf3be7(%rip), %rsi # 0x10c0d4
leaq 0xfa55b(%rip), %rdx # 0x112a4f
leaq 0xb0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xac(%rsp), %rcx
leaq 0xa8(%rsp), %r8
callq 0x1ada0
movq 0x28(%rsp), %rdi
callq 0x1acb0
movb %al, 0x37(%rsp)
jmp 0x18526
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x18530
jmp 0x18560
jmp 0x18621
leaq 0xd8(%rsp), %rdi
callq 0x1ace0
jmp 0x18793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x1869d
leaq 0xa0(%rsp), %rdi
callq 0xc0620
jmp 0x1856f
leaq 0xb0(%rsp), %rdi
callq 0x1ad60
movq %rax, 0x20(%rsp)
jmp 0x18583
movq 0x20(%rsp), %r8
leaq 0xf3abb(%rip), %rdx # 0x10c04a
leaq 0x98(%rsp), %rdi
movl $0x1, %esi
movl $0x31, %ecx
callq 0xbc3b0
jmp 0x185a8
leaq 0x98(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xb8af0
jmp 0x185bf
leaq 0x98(%rsp), %rdi
callq 0xbc440
leaq 0xa0(%rsp), %rdi
callq 0x1acd0
jmp 0x18621
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x18612
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xbc440
leaq 0xa0(%rsp), %rdi
callq 0x1acd0
jmp 0x1869d
leaq 0xb0(%rsp), %rdi
callq 0x1ace0
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1ae10
movl %eax, 0x84(%rsp)
movl $0x3, 0x80(%rsp)
leaq 0xf3a7f(%rip), %rsi # 0x10c0d4
leaq 0xf3a85(%rip), %rdx # 0x10c0e1
leaq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x84(%rsp), %rcx
leaq 0x80(%rsp), %r8
callq 0x1ada0
movq 0x10(%rsp), %rdi
callq 0x1acb0
movb %al, 0x1f(%rsp)
jmp 0x1868e
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x18698
jmp 0x186c8
jmp 0x18771
leaq 0xb0(%rsp), %rdi
callq 0x1ace0
jmp 0x18793
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x18786
leaq 0x78(%rsp), %rdi
callq 0xc0620
jmp 0x186d4
leaq 0x88(%rsp), %rdi
callq 0x1ad60
movq %rax, 0x8(%rsp)
jmp 0x186e8
movq 0x8(%rsp), %r8
leaq 0xf3956(%rip), %rdx # 0x10c04a
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
movl $0x32, %ecx
callq 0xbc3b0
jmp 0x1870a
leaq 0x70(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xb8af0
jmp 0x1871b
leaq 0x70(%rsp), %rdi
callq 0xbc440
leaq 0x78(%rsp), %rdi
callq 0x1acd0
jmp 0x18771
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x18765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xbc440
leaq 0x78(%rsp), %rdi
callq 0x1acd0
jmp 0x18786
leaq 0x88(%rsp), %rdi
callq 0x1ace0
addq $0x128, %rsp # imm = 0x128
retq
leaq 0x88(%rsp), %rdi
callq 0x1ace0
movq 0x100(%rsp), %rdi
callq 0x14c80
| _ZN5alaya27LinearPoolTest_PopTest_Test8TestBodyEv:
sub rsp, 128h
mov qword ptr [rsp+128h+var_8], rdi
mov rax, qword ptr [rsp+128h+var_8]
mov qword ptr [rsp+128h+var_D0], rax; int
mov rdi, [rax+10h]
mov esi, 1
movss xmm0, cs:dword_10C004
call _ZN5alaya10LinearPoolIfiE6insertEif; alaya::LinearPool<float,int>::insert(int,float)
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
mov esi, 2
movss xmm0, cs:dword_10C008
call _ZN5alaya10LinearPoolIfiE6insertEif; alaya::LinearPool<float,int>::insert(int,float)
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
mov esi, 3
movss xmm0, cs:dword_10C00C
call _ZN5alaya10LinearPoolIfiE6insertEif; alaya::LinearPool<float,int>::insert(int,float)
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
call _ZN5alaya10LinearPoolIfiE3topEv; alaya::LinearPool<float,int>::top(void)
mov [rsp+128h+var_1C], eax
mov [rsp+128h+var_20], 2
lea rsi, aPoolTop; "pool_->top()"
lea rdx, aVt102+4; "2"
lea rdi, [rsp+128h+var_18]
mov qword ptr [rsp+128h+var_C8], rdi; int
lea rcx, [rsp+128h+var_1C]
lea r8, [rsp+128h+var_20]
call _ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, qword ptr [rsp+128h+var_C8]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+128h+var_B9], al
jmp short $+2
loc_18268:
mov al, [rsp+128h+var_B9]
test al, 1
jnz short loc_18272
jmp short loc_18290
loc_18272:
jmp loc_18351
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_183CD
loc_18290:
lea rdi, [rsp+128h+var_38]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_1829F:
lea rdi, [rsp+128h+var_18]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+128h+var_D8], rax; char
jmp short $+2
loc_182B3:
mov r8, qword ptr [rsp+128h+var_D8]; int
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+128h+var_40]; int
mov esi, 1; int
mov ecx, 2Eh ; '.'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_182D8:
lea rdi, [rsp+128h+var_40]; char
lea rsi, [rsp+128h+var_38]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_182EF:
lea rdi, [rsp+128h+var_40]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+128h+var_38]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_18351
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_18342
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_E0]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_18342:
lea rdi, [rsp+arg_E8]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_183CD
loc_18351:
lea rdi, [rsp+128h+var_18]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
call _ZN5alaya10LinearPoolIfiE3popEv; alaya::LinearPool<float,int>::pop(void)
mov [rsp+128h+var_54], eax
mov [rsp+128h+var_58], 2
lea rsi, aPoolPop; "pool_->pop()"
lea rdx, aVt102+4; "2"
lea rdi, [rsp+128h+var_50]
mov qword ptr [rsp+128h+var_E8], rdi; __int16
lea rcx, [rsp+128h+var_54]
lea r8, [rsp+128h+var_58]
call _ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, qword ptr [rsp+128h+var_E8]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+128h+var_D9], al
jmp short $+2
loc_183BE:
mov al, [rsp+128h+var_D9]
test al, 1
jnz short loc_183C8
jmp short loc_183F8
loc_183C8:
jmp loc_184B9
loc_183CD:
lea rdi, [rsp+arg_108]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
jmp loc_18793
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_18535
loc_183F8:
lea rdi, [rsp+128h+var_60]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_18407:
lea rdi, [rsp+128h+var_50]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+128h+var_F0], rax; int
jmp short $+2
loc_1841B:
mov r8, qword ptr [rsp+128h+var_F0]; int
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+128h+var_68]; int
mov esi, 1; int
mov ecx, 30h ; '0'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_18440:
lea rdi, [rsp+128h+var_68]; char
lea rsi, [rsp+128h+var_60]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_18457:
lea rdi, [rsp+128h+var_68]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+128h+var_60]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_184B9
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_184AA
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_B8]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_184AA:
lea rdi, [rsp+arg_C0]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_18535
loc_184B9:
lea rdi, [rsp+128h+var_50]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
call _ZN5alaya10LinearPoolIfiE3popEv; alaya::LinearPool<float,int>::pop(void)
mov [rsp+128h+var_7C], eax
mov [rsp+128h+var_80], 1
lea rsi, aPoolPop; "pool_->pop()"
lea rdx, aFcntlPipeFd1FS+22h; "1"
lea rdi, [rsp+128h+var_78]
mov qword ptr [rsp+128h+var_100], rdi; int
lea rcx, [rsp+128h+var_7C]
lea r8, [rsp+128h+var_80]
call _ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, qword ptr [rsp+128h+var_100]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+128h+var_F1], al
jmp short $+2
loc_18526:
mov al, [rsp+128h+var_F1]
test al, 1
jnz short loc_18530
jmp short loc_18560
loc_18530:
jmp loc_18621
loc_18535:
lea rdi, [rsp+arg_D0]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
jmp loc_18793
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_1869D
loc_18560:
lea rdi, [rsp+128h+var_88]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_1856F:
lea rdi, [rsp+128h+var_78]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+128h+var_108], rax; int
jmp short $+2
loc_18583:
mov r8, qword ptr [rsp+128h+var_108]; int
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+128h+var_90]; int
mov esi, 1; int
mov ecx, 31h ; '1'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_185A8:
lea rdi, [rsp+128h+var_90]; char
lea rsi, [rsp+128h+var_88]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_185BF:
lea rdi, [rsp+128h+var_90]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+128h+var_88]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_18621
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_18612
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_90]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_18612:
lea rdi, [rsp+arg_98]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_1869D
loc_18621:
lea rdi, [rsp+128h+var_78]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
mov rax, qword ptr [rsp+128h+var_D0]
mov rdi, [rax+10h]
call _ZN5alaya10LinearPoolIfiE3popEv; alaya::LinearPool<float,int>::pop(void)
mov [rsp+128h+var_A4], eax
mov [rsp+128h+var_A8], 3
lea rsi, aPoolPop; "pool_->pop()"
lea rdx, a3; "3"
lea rdi, [rsp+128h+var_A0]
mov [rsp+128h+var_118], rdi; int
lea rcx, [rsp+128h+var_A4]
lea r8, [rsp+128h+var_A8]
call _ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
mov rdi, [rsp+128h+var_118]
call _ZNK7testing15AssertionResultcvbEv; testing::AssertionResult::operator bool(void)
mov [rsp+128h+var_109], al
jmp short $+2
loc_1868E:
mov al, [rsp+128h+var_109]
test al, 1
jnz short loc_18698
jmp short loc_186C8
loc_18698:
jmp loc_18771
loc_1869D:
lea rdi, [rsp+arg_A8]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
jmp loc_18793
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp loc_18786
loc_186C8:
lea rdi, [rsp+128h+var_B0]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_186D4:
lea rdi, [rsp+128h+var_A0]; this
call _ZNK7testing15AssertionResult15failure_messageEv; testing::AssertionResult::failure_message(void)
mov qword ptr [rsp+128h+var_120], rax; int
jmp short $+2
loc_186E8:
mov r8, qword ptr [rsp+128h+var_120]; int
lea rdx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/AlayaL"...
lea rdi, [rsp+128h+var_B8]; int
mov esi, 1; int
mov ecx, 32h ; '2'; int
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
jmp short $+2
loc_1870A:
lea rdi, [rsp+128h+var_B8]; char
lea rsi, [rsp+128h+var_B0]; int
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short $+2
loc_1871B:
lea rdi, [rsp+128h+var_B8]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
lea rdi, [rsp+128h+var_B0]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_18771
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
jmp short loc_18765
mov rcx, rax
mov eax, edx
mov [rsp+arg_F8], rcx
mov [rsp+arg_F4], eax
lea rdi, [rsp+arg_68]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
loc_18765:
lea rdi, [rsp+arg_70]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
jmp short loc_18786
loc_18771:
lea rdi, [rsp+128h+var_A0]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
add rsp, 128h
retn
loc_18786:
lea rdi, [rsp+arg_80]; this
call _ZN7testing15AssertionResultD2Ev; testing::AssertionResult::~AssertionResult()
loc_18793:
mov rdi, [rsp+arg_F8]
call __Unwind_Resume
| void alaya::LinearPoolTest_PopTest_Test::TestBody(alaya::LinearPoolTest_PopTest_Test *this)
{
int v1; // r9d
int v2; // r9d
int v3; // r9d
int v4; // r9d
void *v5; // [rsp+0h] [rbp-128h]
int v6; // [rsp+0h] [rbp-128h]
int v7; // [rsp+0h] [rbp-128h]
int v8; // [rsp+0h] [rbp-128h]
int v9; // [rsp+0h] [rbp-128h]
int v10; // [rsp+8h] [rbp-120h]
int v11; // [rsp+8h] [rbp-120h]
int v12; // [rsp+8h] [rbp-120h]
int v13; // [rsp+8h] [rbp-120h]
int v14; // [rsp+8h] [rbp-120h]
int v15; // [rsp+8h] [rbp-120h]
long long v16; // [rsp+10h] [rbp-118h]
int v17; // [rsp+10h] [rbp-118h]
int v18; // [rsp+10h] [rbp-118h]
int v19; // [rsp+10h] [rbp-118h]
int v20; // [rsp+10h] [rbp-118h]
int v21; // [rsp+18h] [rbp-110h]
int v22; // [rsp+20h] [rbp-108h]
int v23; // [rsp+20h] [rbp-108h]
int v24; // [rsp+28h] [rbp-100h]
int *v25; // [rsp+28h] [rbp-100h]
int v26; // [rsp+30h] [rbp-F8h]
int v27; // [rsp+38h] [rbp-F0h]
int v28; // [rsp+38h] [rbp-F0h]
__int16 v29; // [rsp+40h] [rbp-E8h]
__int16 *v30; // [rsp+40h] [rbp-E8h]
long long v31; // [rsp+48h] [rbp-E0h]
char v32; // [rsp+50h] [rbp-D8h]
int v33; // [rsp+50h] [rbp-D8h]
alaya::LinearPoolTest_PopTest_Test *v34; // [rsp+58h] [rbp-D0h]
int *v35; // [rsp+60h] [rbp-C8h]
int v36; // [rsp+68h] [rbp-C0h]
char v37[8]; // [rsp+70h] [rbp-B8h] BYREF
int v38; // [rsp+78h] [rbp-B0h] BYREF
int v39; // [rsp+80h] [rbp-A8h] BYREF
int v40; // [rsp+84h] [rbp-A4h] BYREF
long long v41[2]; // [rsp+88h] [rbp-A0h] BYREF
char v42[4]; // [rsp+98h] [rbp-90h] BYREF
int v43; // [rsp+A0h] [rbp-88h] BYREF
int v44; // [rsp+A8h] [rbp-80h] BYREF
int v45; // [rsp+ACh] [rbp-7Ch] BYREF
int v46[4]; // [rsp+B0h] [rbp-78h] BYREF
char v47[4]; // [rsp+C0h] [rbp-68h] BYREF
int v48; // [rsp+C8h] [rbp-60h] BYREF
int v49; // [rsp+D0h] [rbp-58h] BYREF
int v50; // [rsp+D4h] [rbp-54h] BYREF
__int16 v51[8]; // [rsp+D8h] [rbp-50h] BYREF
char v52[4]; // [rsp+E8h] [rbp-40h] BYREF
int v53[6]; // [rsp+F0h] [rbp-38h] BYREF
int v54; // [rsp+108h] [rbp-20h] BYREF
int v55; // [rsp+10Ch] [rbp-1Ch] BYREF
int v56[4]; // [rsp+110h] [rbp-18h] BYREF
int v57[2]; // [rsp+120h] [rbp-8h]
*(_QWORD *)v57 = this;
v34 = this;
alaya::LinearPool<float,int>::insert(*((_QWORD *)this + 2), 1LL, 2.5);
alaya::LinearPool<float,int>::insert(*((_QWORD *)this + 2), 2LL, 1.5);
alaya::LinearPool<float,int>::insert(*((_QWORD *)this + 2), 3LL, 3.0);
v55 = alaya::LinearPool<float,int>::top(*((_QWORD *)this + 2));
v54 = 2;
v35 = v56;
ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
v56,
"pool_->top()",
"2",
&v55,
&v54);
if ( (testing::AssertionResult::operator bool(v56) & 1) == 0 )
{
testing::Message::Message((testing::Message *)v53);
v33 = testing::AssertionResult::failure_message((testing::AssertionResult *)v56);
testing::internal::AssertHelper::AssertHelper(
(int)v52,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",
46,
v33,
v1,
v5,
v10,
v16);
testing::internal::AssertHelper::operator=(
(char)v52,
(int)v53,
v6,
v11,
v17,
v21,
v22,
v24,
v26,
v27,
v29,
v31,
v33,
(int)this,
(int)v56,
v36,
v37[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v52);
testing::Message::~Message((testing::Message *)v53);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v56);
v50 = alaya::LinearPool<float,int>::pop(*((_QWORD *)v34 + 2));
v49 = 2;
v30 = v51;
ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
v51,
"pool_->pop()",
"2",
&v50,
&v49);
HIBYTE(v31) = testing::AssertionResult::operator bool(v51);
if ( (v31 & 0x100000000000000LL) == 0 )
{
testing::Message::Message((testing::Message *)&v48);
v28 = testing::AssertionResult::failure_message((testing::AssertionResult *)v51);
testing::internal::AssertHelper::AssertHelper(
(int)v47,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",
48,
v28,
v2,
v5,
v10,
v16);
testing::internal::AssertHelper::operator=(
(char)v47,
(int)&v48,
v7,
v12,
v18,
v21,
v22,
v24,
v26,
v28,
(__int16)v51,
v31,
v32,
(int)v34,
(int)v35,
v36,
v37[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v47);
testing::Message::~Message((testing::Message *)&v48);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v51);
v45 = alaya::LinearPool<float,int>::pop(*((_QWORD *)v34 + 2));
v44 = 1;
v25 = v46;
ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
v46,
"pool_->pop()",
"1",
&v45,
&v44);
if ( (testing::AssertionResult::operator bool(v46) & 1) == 0 )
{
testing::Message::Message((testing::Message *)&v43);
v23 = testing::AssertionResult::failure_message((testing::AssertionResult *)v46);
testing::internal::AssertHelper::AssertHelper(
(int)v42,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",
49,
v23,
v3,
v5,
v10,
v16);
testing::internal::AssertHelper::operator=(
(char)v42,
(int)&v43,
v8,
v13,
v19,
v21,
v23,
(int)v46,
v26,
v27,
(__int16)v30,
v31,
v32,
(int)v34,
(int)v35,
v36,
v37[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v42);
testing::Message::~Message((testing::Message *)&v43);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v46);
v40 = alaya::LinearPool<float,int>::pop(*((_QWORD *)v34 + 2));
v39 = 3;
ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_(
v41,
"pool_->pop()",
"3",
&v40,
&v39);
if ( (testing::AssertionResult::operator bool(v41) & 1) == 0 )
{
testing::Message::Message((testing::Message *)&v38);
v14 = testing::AssertionResult::failure_message((testing::AssertionResult *)v41);
testing::internal::AssertHelper::AssertHelper(
(int)v37,
1,
(int)"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",
50,
v14,
v4,
v5,
v14,
(long long)v41);
testing::internal::AssertHelper::operator=(
(char)v37,
(int)&v38,
v9,
v15,
v20,
v21,
v22,
(int)v25,
v26,
v27,
(__int16)v30,
v31,
v32,
(int)v34,
(int)v35,
v36,
v37[0]);
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v37);
testing::Message::~Message((testing::Message *)&v38);
}
testing::AssertionResult::~AssertionResult((testing::AssertionResult *)v41);
}
| TestBody:
SUB RSP,0x128
MOV qword ptr [RSP + 0x120],RDI
MOV RAX,qword ptr [RSP + 0x120]
MOV qword ptr [RSP + 0x58],RAX
MOV RDI,qword ptr [RAX + 0x10]
MOV ESI,0x1
MOVSS XMM0,dword ptr [0x0020c004]
CALL 0x0011ab00
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
MOV ESI,0x2
MOVSS XMM0,dword ptr [0x0020c008]
CALL 0x0011ab00
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
MOV ESI,0x3
MOVSS XMM0,dword ptr [0x0020c00c]
CALL 0x0011ab00
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0011adf0
MOV dword ptr [RSP + 0x10c],EAX
MOV dword ptr [RSP + 0x108],0x2
LEA RSI,[0x20c0c7]
LEA RDX,[0x20d75e]
LEA RDI,[RSP + 0x110]
MOV qword ptr [RSP + 0x60],RDI
LEA RCX,[RSP + 0x10c]
LEA R8,[RSP + 0x108]
CALL 0x0011ada0
MOV RDI,qword ptr [RSP + 0x60]
LAB_0011825d:
CALL 0x0011acb0
MOV byte ptr [RSP + 0x6f],AL
JMP 0x00118268
LAB_00118268:
MOV AL,byte ptr [RSP + 0x6f]
TEST AL,0x1
JNZ 0x00118272
JMP 0x00118290
LAB_00118272:
JMP 0x00118351
LAB_00118290:
LEA RDI,[RSP + 0xf0]
CALL 0x001c0620
JMP 0x0011829f
LAB_0011829f:
LEA RDI,[RSP + 0x110]
CALL 0x0011ad60
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001182b3
LAB_001182b3:
MOV R8,qword ptr [RSP + 0x50]
LEA RDX,[0x20c04a]
LEA RDI,[RSP + 0xe8]
MOV ESI,0x1
MOV ECX,0x2e
CALL 0x001bc3b0
JMP 0x001182d8
LAB_001182d8:
LEA RDI,[RSP + 0xe8]
LEA RSI,[RSP + 0xf0]
CALL 0x001b8af0
LAB_001182ed:
JMP 0x001182ef
LAB_001182ef:
LEA RDI,[RSP + 0xe8]
CALL 0x001bc440
LEA RDI,[RSP + 0xf0]
CALL 0x0011acd0
JMP 0x00118351
LAB_00118351:
LEA RDI,[RSP + 0x110]
CALL 0x0011ace0
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0011ae10
MOV dword ptr [RSP + 0xd4],EAX
MOV dword ptr [RSP + 0xd0],0x2
LEA RSI,[0x20c0d4]
LEA RDX,[0x20d75e]
LEA RDI,[RSP + 0xd8]
MOV qword ptr [RSP + 0x40],RDI
LEA RCX,[RSP + 0xd4]
LEA R8,[RSP + 0xd0]
CALL 0x0011ada0
MOV RDI,qword ptr [RSP + 0x40]
LAB_001183b3:
CALL 0x0011acb0
MOV byte ptr [RSP + 0x4f],AL
JMP 0x001183be
LAB_001183be:
MOV AL,byte ptr [RSP + 0x4f]
TEST AL,0x1
JNZ 0x001183c8
JMP 0x001183f8
LAB_001183c8:
JMP 0x001184b9
LAB_001183f8:
LEA RDI,[RSP + 0xc8]
CALL 0x001c0620
JMP 0x00118407
LAB_00118407:
LEA RDI,[RSP + 0xd8]
CALL 0x0011ad60
MOV qword ptr [RSP + 0x38],RAX
JMP 0x0011841b
LAB_0011841b:
MOV R8,qword ptr [RSP + 0x38]
LEA RDX,[0x20c04a]
LEA RDI,[RSP + 0xc0]
MOV ESI,0x1
MOV ECX,0x30
CALL 0x001bc3b0
JMP 0x00118440
LAB_00118440:
LEA RDI,[RSP + 0xc0]
LEA RSI,[RSP + 0xc8]
CALL 0x001b8af0
LAB_00118455:
JMP 0x00118457
LAB_00118457:
LEA RDI,[RSP + 0xc0]
CALL 0x001bc440
LEA RDI,[RSP + 0xc8]
CALL 0x0011acd0
JMP 0x001184b9
LAB_001184b9:
LEA RDI,[RSP + 0xd8]
CALL 0x0011ace0
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0011ae10
MOV dword ptr [RSP + 0xac],EAX
MOV dword ptr [RSP + 0xa8],0x1
LEA RSI,[0x20c0d4]
LEA RDX,[0x212a4f]
LEA RDI,[RSP + 0xb0]
MOV qword ptr [RSP + 0x28],RDI
LEA RCX,[RSP + 0xac]
LEA R8,[RSP + 0xa8]
CALL 0x0011ada0
MOV RDI,qword ptr [RSP + 0x28]
LAB_0011851b:
CALL 0x0011acb0
MOV byte ptr [RSP + 0x37],AL
JMP 0x00118526
LAB_00118526:
MOV AL,byte ptr [RSP + 0x37]
TEST AL,0x1
JNZ 0x00118530
JMP 0x00118560
LAB_00118530:
JMP 0x00118621
LAB_00118560:
LEA RDI,[RSP + 0xa0]
CALL 0x001c0620
JMP 0x0011856f
LAB_0011856f:
LEA RDI,[RSP + 0xb0]
CALL 0x0011ad60
MOV qword ptr [RSP + 0x20],RAX
JMP 0x00118583
LAB_00118583:
MOV R8,qword ptr [RSP + 0x20]
LEA RDX,[0x20c04a]
LEA RDI,[RSP + 0x98]
MOV ESI,0x1
MOV ECX,0x31
CALL 0x001bc3b0
JMP 0x001185a8
LAB_001185a8:
LEA RDI,[RSP + 0x98]
LEA RSI,[RSP + 0xa0]
CALL 0x001b8af0
LAB_001185bd:
JMP 0x001185bf
LAB_001185bf:
LEA RDI,[RSP + 0x98]
CALL 0x001bc440
LEA RDI,[RSP + 0xa0]
CALL 0x0011acd0
JMP 0x00118621
LAB_00118621:
LEA RDI,[RSP + 0xb0]
CALL 0x0011ace0
MOV RAX,qword ptr [RSP + 0x58]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x0011ae10
MOV dword ptr [RSP + 0x84],EAX
MOV dword ptr [RSP + 0x80],0x3
LEA RSI,[0x20c0d4]
LEA RDX,[0x20c0e1]
LEA RDI,[RSP + 0x88]
MOV qword ptr [RSP + 0x10],RDI
LEA RCX,[RSP + 0x84]
LEA R8,[RSP + 0x80]
CALL 0x0011ada0
MOV RDI,qword ptr [RSP + 0x10]
LAB_00118683:
CALL 0x0011acb0
MOV byte ptr [RSP + 0x1f],AL
JMP 0x0011868e
LAB_0011868e:
MOV AL,byte ptr [RSP + 0x1f]
TEST AL,0x1
JNZ 0x00118698
JMP 0x001186c8
LAB_00118698:
JMP 0x00118771
LAB_001186c8:
LEA RDI,[RSP + 0x78]
CALL 0x001c0620
JMP 0x001186d4
LAB_001186d4:
LEA RDI,[RSP + 0x88]
CALL 0x0011ad60
MOV qword ptr [RSP + 0x8],RAX
JMP 0x001186e8
LAB_001186e8:
MOV R8,qword ptr [RSP + 0x8]
LEA RDX,[0x20c04a]
LEA RDI,[RSP + 0x70]
MOV ESI,0x1
MOV ECX,0x32
CALL 0x001bc3b0
JMP 0x0011870a
LAB_0011870a:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x78]
CALL 0x001b8af0
LAB_00118719:
JMP 0x0011871b
LAB_0011871b:
LEA RDI,[RSP + 0x70]
CALL 0x001bc440
LEA RDI,[RSP + 0x78]
CALL 0x0011acd0
JMP 0x00118771
LAB_00118771:
LEA RDI,[RSP + 0x88]
CALL 0x0011ace0
ADD RSP,0x128
RET
|
/* alaya::LinearPoolTest_PopTest_Test::TestBody() */
void __thiscall alaya::LinearPoolTest_PopTest_Test::TestBody(LinearPoolTest_PopTest_Test *this)
{
bool bVar1;
int8 uVar2;
AssertHelper local_b8 [8];
Message local_b0 [8];
int4 local_a8;
int4 local_a4;
AssertionResult local_a0 [16];
AssertHelper local_90 [8];
Message local_88 [8];
int4 local_80;
int4 local_7c;
AssertionResult local_78 [16];
AssertHelper local_68 [8];
Message local_60 [8];
int4 local_58;
int4 local_54;
AssertionResult local_50 [16];
AssertHelper local_40 [8];
Message local_38 [24];
int4 local_20;
int4 local_1c;
AssertionResult local_18 [16];
LinearPoolTest_PopTest_Test *local_8;
local_8 = this;
LinearPool<float,int>::insert(*(LinearPool<float,int> **)(this + 0x10),1,DAT_0020c004);
LinearPool<float,int>::insert(*(LinearPool<float,int> **)(this + 0x10),2,DAT_0020c008);
LinearPool<float,int>::insert(*(LinearPool<float,int> **)(this + 0x10),3,DAT_0020c00c);
local_1c = LinearPool<float,int>::top(*(LinearPool<float,int> **)(this + 0x10));
local_20 = 2;
_ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_18,"pool_->top()",&DAT_0020d75e,&local_1c,&local_20);
/* try { // try from 0011825d to 0011829c has its CatchHandler @ 00118277 */
bVar1 = testing::AssertionResult::operator_cast_to_bool(local_18);
if (!bVar1) {
testing::Message::Message(local_38);
/* try { // try from 0011829f to 001182d5 has its CatchHandler @ 0011830b */
uVar2 = testing::AssertionResult::failure_message(local_18);
testing::internal::AssertHelper::AssertHelper
(local_40,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",0x2e,
uVar2);
/* try { // try from 001182d8 to 001182ec has its CatchHandler @ 00118321 */
testing::internal::AssertHelper::operator=(local_40,local_38);
testing::internal::AssertHelper::~AssertHelper(local_40);
testing::Message::~Message(local_38);
}
testing::AssertionResult::~AssertionResult(local_18);
local_54 = LinearPool<float,int>::pop(*(LinearPool<float,int> **)(this + 0x10));
local_58 = 2;
_ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_50,"pool_->pop()",&DAT_0020d75e,&local_54,&local_58);
/* try { // try from 001183b3 to 00118404 has its CatchHandler @ 001183df */
bVar1 = testing::AssertionResult::operator_cast_to_bool(local_50);
if (!bVar1) {
testing::Message::Message(local_60);
/* try { // try from 00118407 to 0011843d has its CatchHandler @ 00118473 */
uVar2 = testing::AssertionResult::failure_message(local_50);
testing::internal::AssertHelper::AssertHelper
(local_68,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",0x30,
uVar2);
/* try { // try from 00118440 to 00118454 has its CatchHandler @ 00118489 */
testing::internal::AssertHelper::operator=(local_68,local_60);
testing::internal::AssertHelper::~AssertHelper(local_68);
testing::Message::~Message(local_60);
}
testing::AssertionResult::~AssertionResult(local_50);
local_7c = LinearPool<float,int>::pop(*(LinearPool<float,int> **)(this + 0x10));
local_80 = 1;
_ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_78,"pool_->pop()","1",&local_7c,&local_80);
/* try { // try from 0011851b to 0011856c has its CatchHandler @ 00118547 */
bVar1 = testing::AssertionResult::operator_cast_to_bool(local_78);
if (!bVar1) {
testing::Message::Message(local_88);
/* try { // try from 0011856f to 001185a5 has its CatchHandler @ 001185db */
uVar2 = testing::AssertionResult::failure_message(local_78);
testing::internal::AssertHelper::AssertHelper
(local_90,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",0x31,
uVar2);
/* try { // try from 001185a8 to 001185bc has its CatchHandler @ 001185f1 */
testing::internal::AssertHelper::operator=(local_90,local_88);
testing::internal::AssertHelper::~AssertHelper(local_90);
testing::Message::~Message(local_88);
}
testing::AssertionResult::~AssertionResult(local_78);
local_a4 = LinearPool<float,int>::pop(*(LinearPool<float,int> **)(this + 0x10));
local_a8 = 3;
_ZN7testing8internal8EqHelper7CompareIiiTnPNSt9enable_ifIXoontsr3std11is_integralIT_EE5valuentsr3std10is_pointerIT0_EE5valueEvE4typeELPv0EEENS_15AssertionResultEPKcSC_RKS4_RKS5_
(local_a0,"pool_->pop()",&DAT_0020c0e1,&local_a4,&local_a8);
/* try { // try from 00118683 to 001186d1 has its CatchHandler @ 001186af */
bVar1 = testing::AssertionResult::operator_cast_to_bool(local_a0);
if (!bVar1) {
testing::Message::Message(local_b0);
/* try { // try from 001186d4 to 00118707 has its CatchHandler @ 00118731 */
uVar2 = testing::AssertionResult::failure_message(local_a0);
testing::internal::AssertHelper::AssertHelper
(local_b8,1,
"/workspace/llm4binary/github2025/AlayaLite/tests/utils/query_utils_test.cpp",0x32,
uVar2);
/* try { // try from 0011870a to 00118718 has its CatchHandler @ 00118747 */
testing::internal::AssertHelper::operator=(local_b8,local_b0);
testing::internal::AssertHelper::~AssertHelper(local_b8);
testing::Message::~Message(local_b0);
}
testing::AssertionResult::~AssertionResult(local_a0);
return;
}
| |
24,437 | my_strnxfrm_latin1_de | eloqsql/strings/ctype-latin1.c | static size_t
my_strnxfrm_latin1_de(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar* src, size_t srclen, uint flags)
{
uchar *de= dst + dstlen;
const uchar *se= src + srclen;
uchar *d0= dst;
for ( ; src < se && dst < de && nweights; src++, nweights--)
{
uchar chr= combo1map[*src];
*dst++= chr;
if ((chr= combo2map[*src]) && dst < de && nweights > 1)
{
*dst++= chr;
nweights--;
}
}
return my_strxfrm_pad_desc_and_reverse(cs, d0, dst, de, nweights, flags, 0);
} | O0 | c | my_strnxfrm_latin1_de:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x3f3aa
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x38(%rbp), %rcx
movb %al, -0x4a(%rbp)
jae 0x3f3aa
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
testb $0x1, %al
jne 0x3f3b6
jmp 0x3f447
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xff49a(%rip), %rax # 0x13e860
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xff570(%rip), %rax # 0x13e960
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3f42b
movq -0x10(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x3f42b
cmpl $0x1, -0x1c(%rbp)
jbe 0x3f42b
movb -0x49(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f42d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f382
movq -0x8(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x42450
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| my_strnxfrm_latin1_de:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, [rbp+var_30]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov [rbp+var_48], rax
loc_3F382:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_4A], al
jnb short loc_3F3AA
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_38]
mov [rbp+var_4A], al
jnb short loc_3F3AA
cmp [rbp+var_1C], 0
setnz al
mov [rbp+var_4A], al
loc_3F3AA:
mov al, [rbp+var_4A]
test al, 1
jnz short loc_3F3B6
jmp loc_3F447
loc_3F3B6:
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo1map
mov al, [rax+rcx]
mov [rbp+var_49], al
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax]
mov ecx, eax
lea rax, combo2map
mov al, [rax+rcx]
mov [rbp+var_49], al
movzx eax, al
cmp eax, 0
jz short loc_3F42B
mov rax, [rbp+var_10]
cmp rax, [rbp+var_38]
jnb short loc_3F42B
cmp [rbp+var_1C], 1
jbe short loc_3F42B
mov cl, [rbp+var_49]
mov rax, [rbp+var_10]
mov rdx, rax
add rdx, 1
mov [rbp+var_10], rdx
mov [rax], cl
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
loc_3F42B:
jmp short $+2
loc_3F42D:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
mov eax, [rbp+var_1C]
add eax, 0FFFFFFFFh
mov [rbp+var_1C], eax
jmp loc_3F382
loc_3F447:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_38]
mov r8d, [rbp+var_1C]
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse
add rsp, 60h
pop rbp
retn
| long long my_strnxfrm_latin1_de(
int a1,
unsigned __int8 *a2,
long long a3,
unsigned int a4,
unsigned __int8 *a5,
long long a6,
int a7)
{
unsigned __int8 *v7; // rax
unsigned __int8 *v8; // rax
bool v10; // [rsp+16h] [rbp-4Ah]
unsigned __int8 v11; // [rsp+17h] [rbp-49h]
unsigned long long v12; // [rsp+28h] [rbp-38h]
unsigned __int8 *v13; // [rsp+38h] [rbp-28h]
unsigned __int8 *v15; // [rsp+50h] [rbp-10h]
v15 = a2;
v13 = a5;
v12 = (unsigned long long)&a2[a3];
while ( 1 )
{
v10 = 0;
if ( v13 < &a5[a6] )
{
v10 = 0;
if ( (unsigned long long)v15 < v12 )
v10 = a4 != 0;
}
if ( !v10 )
break;
v7 = v15++;
*v7 = combo1map[*v13];
v11 = combo2map[*v13];
if ( v11 && (unsigned long long)v15 < v12 && a4 > 1 )
{
v8 = v15++;
*v8 = v11;
--a4;
}
++v13;
--a4;
}
return my_strxfrm_pad_desc_and_reverse(a1, (_DWORD)a2, (_DWORD)v15, v12, a4, a7, 0);
}
| my_strnxfrm_latin1_de:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x48],RAX
LAB_0013f382:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x0013f3aa
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x4a],AL
JNC 0x0013f3aa
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_0013f3aa:
MOV AL,byte ptr [RBP + -0x4a]
TEST AL,0x1
JNZ 0x0013f3b6
JMP 0x0013f447
LAB_0013f3b6:
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23e860]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX]
MOV ECX,EAX
LEA RAX,[0x23e960]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV byte ptr [RBP + -0x49],AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013f42b
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x38]
JNC 0x0013f42b
CMP dword ptr [RBP + -0x1c],0x1
JBE 0x0013f42b
MOV CL,byte ptr [RBP + -0x49]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x10],RDX
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
LAB_0013f42b:
JMP 0x0013f42d
LAB_0013f42d:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0013f382
LAB_0013f447:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV R8D,dword ptr [RBP + -0x1c]
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00142450
ADD RSP,0x60
POP RBP
RET
|
void my_strnxfrm_latin1_de
(int8 param_1,char *param_2,long param_3,uint param_4,byte *param_5,
long param_6,int4 param_7)
{
char *pcVar1;
char *pcVar2;
bool bVar3;
byte *local_30;
uint local_24;
char *local_18;
pcVar1 = param_2 + param_3;
local_30 = param_5;
local_24 = param_4;
local_18 = param_2;
while( true ) {
bVar3 = false;
if ((local_30 < param_5 + param_6) && (bVar3 = false, local_18 < pcVar1)) {
bVar3 = local_24 != 0;
}
if (!bVar3) break;
pcVar2 = local_18 + 1;
*local_18 = combo1map[*local_30];
if (((combo2map[*local_30] != '\0') && (pcVar2 < pcVar1)) && (1 < local_24)) {
*pcVar2 = combo2map[*local_30];
local_24 = local_24 - 1;
pcVar2 = local_18 + 2;
}
local_18 = pcVar2;
local_30 = local_30 + 1;
local_24 = local_24 - 1;
}
my_strxfrm_pad_desc_and_reverse(param_1,param_2,local_18,pcVar1,local_24,param_7,0);
return;
}
| |
24,438 | mi_read_cache | eloqsql/storage/myisam/mi_cache.c | int _mi_read_cache(IO_CACHE *info, uchar *buff, my_off_t pos, size_t length,
int flag)
{
size_t read_length,in_buff_length;
my_off_t offset;
uchar *in_buff_pos;
DBUG_ENTER("_mi_read_cache");
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
if (pos < info->pos_in_file)
{
read_length=length;
if ((my_off_t) read_length > (my_off_t) (info->pos_in_file-pos))
read_length=(size_t)(info->pos_in_file-pos);
info->seek_not_done=1;
if (mysql_file_pread(info->file, buff, read_length, pos, MYF(MY_NABP)))
DBUG_RETURN(1);
if (!(length-=read_length))
DBUG_RETURN(0);
pos+=read_length;
buff+=read_length;
}
if (pos >= info->pos_in_file &&
(offset= (my_off_t) (pos - info->pos_in_file)) <
(my_off_t) (info->read_end - info->request_pos))
{
in_buff_pos=info->request_pos+ (uint)offset;
in_buff_length= MY_MIN(length, (size_t)(info->read_end-in_buff_pos));
memcpy(buff,info->request_pos+(uint) offset, in_buff_length);
if (!(length-=in_buff_length))
DBUG_RETURN(0);
pos+=in_buff_length;
buff+=in_buff_length;
}
else
in_buff_length=0;
if (flag & READING_NEXT)
{
if (pos != (info->pos_in_file +
(uint) (info->read_end - info->request_pos)))
{
info->pos_in_file=pos; /* Force start here */
info->read_pos=info->read_end=info->request_pos; /* Everything used */
info->seek_not_done=1;
}
else
info->read_pos=info->read_end; /* All block used */
if (!_my_b_read(info,buff,length))
DBUG_RETURN(0);
read_length=info->error;
}
else
{
info->seek_not_done=1;
if ((read_length= mysql_file_pread(info->file, buff, length, pos,
MYF(0))) == length)
DBUG_RETURN(0);
}
if (!(flag & READING_HEADER) || (int) read_length == -1 ||
read_length+in_buff_length < 3)
{
DBUG_PRINT("error",
("Error %d reading next-multi-part block (Got %d bytes)",
my_errno, (int) read_length));
if (!my_errno || my_errno == -1 || my_errno == HA_ERR_FILE_TOO_SHORT)
my_errno= HA_ERR_WRONG_IN_RECORD;
DBUG_RETURN(1);
}
bzero(buff+read_length,MI_BLOCK_INFO_HEADER_LENGTH - in_buff_length -
read_length);
DBUG_RETURN(0);
} | O3 | c | mi_read_cache:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, -0x34(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
movq (%rdi), %rax
movq %rax, %r14
subq %rdx, %r14
jbe 0x8ee6b
cmpq %rcx, %r14
movq %rcx, -0x40(%rbp)
cmovaeq %rcx, %r14
movl $0x1, 0xe0(%r13)
movl 0xd4(%r13), %ebx
leaq 0x2f720b(%rip), %rax # 0x386010
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %r15, -0x30(%rbp)
jne 0x8eff3
movl $0x4, %r8d
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0xa0664
movq %rax, %r15
movl $0x1, %ebx
testq %r15, %r15
movq -0x40(%rbp), %rcx
jne 0x8efe2
subq %r14, %rcx
je 0x8efa8
addq %r14, %r12
movq -0x30(%rbp), %r15
addq %r14, %r15
movq (%r13), %rax
movq %r12, %rdx
subq %rax, %rdx
jb 0x8eec1
movq 0x18(%r13), %r14
movq 0x28(%r13), %rsi
movq %r14, %rax
subq %rsi, %rax
xorl %ebx, %ebx
cmpq %rax, %rdx
jae 0x8eec1
movl %edx, %eax
addq %rax, %rsi
subq %rsi, %r14
cmpq %r14, %rcx
cmovbq %rcx, %r14
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r14, %rdx
movq %rcx, %r15
callq 0x29080
movq %r15, %rcx
subq %r14, %rcx
je 0x8efe2
addq %r14, %r12
movq -0x30(%rbp), %r15
addq %r14, %r15
jmp 0x8eec4
xorl %r14d, %r14d
testb $0x1, -0x34(%rbp)
jne 0x8ef31
movq %rcx, -0x40(%rbp)
movq %r15, -0x30(%rbp)
movl $0x1, 0xe0(%r13)
movl 0xd4(%r13), %ebx
leaq 0x2f7125(%rip), %r13 # 0x386010
movq (%r13), %rax
leaq -0x90(%rbp), %rdi
movl %ebx, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x8f057
movl %ebx, %edi
movq -0x30(%rbp), %r15
movq %r15, %rsi
movq -0x40(%rbp), %r13
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xa0664
movq %rax, %rbx
cmpq %r13, %rbx
jne 0x8ef79
jmp 0x8efa8
movq 0x18(%r13), %rsi
movq 0x28(%r13), %rax
movl %esi, %edx
subl %eax, %edx
addq (%r13), %rdx
cmpq %rdx, %r12
je 0x8ef5c
movq %r12, (%r13)
movq %rax, 0x18(%r13)
movl $0x1, 0xe0(%r13)
movq %rax, %rsi
movq %rsi, 0x10(%r13)
movq %r13, %rdi
movq %r15, %rsi
movq %rcx, %rdx
callq 0x95622
testl %eax, %eax
je 0x8efa8
movslq 0xe4(%r13), %rbx
testb $0x2, -0x34(%rbp)
je 0x8efac
movl %ebx, %eax
cmpl $-0x1, %eax
je 0x8efac
addq %rbx, %r14
cmpq $0x2, %r14
jbe 0x8efac
addq %rbx, %r15
movl $0x14, %edx
subq %r14, %rdx
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x292a0
jmp 0x8efe2
xorl %ebx, %ebx
jmp 0x8efe2
callq 0xa1b26
cmpl $0x0, (%rax)
je 0x8efd2
callq 0xa1b26
cmpl $-0x1, (%rax)
je 0x8efd2
callq 0xa1b26
movl $0x1, %ebx
cmpl $0xaf, (%rax)
jne 0x8efe2
callq 0xa1b26
movl $0x7f, (%rax)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rcx
leaq 0x2f7013(%rip), %rax # 0x386010
movq (%rax), %rax
leaq 0x4ca39(%rip), %rdx # 0xdba40
movq %rcx, -0x48(%rbp)
movq %rcx, %rdi
movq %r14, %rsi
movl $0x35, %ecx
callq *0x210(%rax)
movl $0x4, %r8d
movl %ebx, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0xa0664
movq %rax, %r15
xorl %esi, %esi
testq %rax, %rax
cmoveq %r14, %rsi
leaq 0x2f6fcb(%rip), %rax # 0x386010
movq (%rax), %rax
movq -0x48(%rbp), %rdi
callq *0x218(%rax)
jmp 0x8ee42
movq %rax, %r15
movq (%r13), %rax
leaq 0x4c9db(%rip), %rdx # 0xdba40
movq %r15, %rdi
movq -0x40(%rbp), %r13
movq %r13, %rsi
movl $0x5d, %ecx
callq *0x210(%rax)
movl %ebx, %edi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0xa0664
movq %rax, %rbx
cmpq $-0x1, %rax
movl $0x0, %esi
cmovneq %rax, %rsi
leaq 0x2f6f6b(%rip), %rax # 0x386010
movq (%rax), %rax
movq %r15, %rdi
movq -0x30(%rbp), %r15
callq *0x218(%rax)
jmp 0x8ef2a
nop
| _mi_read_cache:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rbp+var_34], r8d
mov r12, rdx
mov r15, rsi
mov r13, rdi
mov rax, [rdi]
mov r14, rax
sub r14, rdx
jbe loc_8EE6B
cmp r14, rcx
mov [rbp+var_40], rcx
cmovnb r14, rcx
mov dword ptr [r13+0E0h], 1
mov ebx, [r13+0D4h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_30], r15
jnz loc_8EFF3
mov r8d, 4
mov edi, ebx
mov rsi, r15
mov rdx, r14
mov rcx, r12
call my_pread
mov r15, rax
loc_8EE42:
mov ebx, 1
test r15, r15
mov rcx, [rbp+var_40]
jnz loc_8EFE2
sub rcx, r14
jz loc_8EFA8
add r12, r14
mov r15, [rbp+var_30]
add r15, r14
mov rax, [r13+0]
loc_8EE6B:
mov rdx, r12
sub rdx, rax
jb short loc_8EEC1
mov r14, [r13+18h]
mov rsi, [r13+28h]
mov rax, r14
sub rax, rsi
xor ebx, ebx
cmp rdx, rax
jnb short loc_8EEC1
mov eax, edx
add rsi, rax
sub r14, rsi
cmp rcx, r14
cmovb r14, rcx
mov [rbp+var_30], r15
mov rdi, r15
mov rdx, r14
mov r15, rcx
call _memcpy
mov rcx, r15
sub rcx, r14
jz loc_8EFE2
add r12, r14
mov r15, [rbp+var_30]
add r15, r14
jmp short loc_8EEC4
loc_8EEC1:
xor r14d, r14d
loc_8EEC4:
test byte ptr [rbp+var_34], 1
jnz short loc_8EF31
mov [rbp+var_40], rcx
mov [rbp+var_30], r15
mov dword ptr [r13+0E0h], 1
mov ebx, [r13+0D4h]
lea r13, PSI_server
mov rax, [r13+0]
lea rdi, [rbp+var_90]
mov esi, ebx
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_8F057
mov edi, ebx
mov r15, [rbp+var_30]
mov rsi, r15
mov r13, [rbp+var_40]
mov rdx, r13
mov rcx, r12
xor r8d, r8d
call my_pread
mov rbx, rax
loc_8EF2A:
cmp rbx, r13
jnz short loc_8EF79
jmp short loc_8EFA8
loc_8EF31:
mov rsi, [r13+18h]
mov rax, [r13+28h]
mov edx, esi
sub edx, eax
add rdx, [r13+0]
cmp r12, rdx
jz short loc_8EF5C
mov [r13+0], r12
mov [r13+18h], rax
mov dword ptr [r13+0E0h], 1
mov rsi, rax
loc_8EF5C:
mov [r13+10h], rsi
mov rdi, r13
mov rsi, r15
mov rdx, rcx
call _my_b_read
test eax, eax
jz short loc_8EFA8
movsxd rbx, dword ptr [r13+0E4h]
loc_8EF79:
test byte ptr [rbp+var_34], 2
jz short loc_8EFAC
mov eax, ebx
cmp eax, 0FFFFFFFFh
jz short loc_8EFAC
add r14, rbx
cmp r14, 2
jbe short loc_8EFAC
add r15, rbx
mov edx, 14h
sub rdx, r14
xor ebx, ebx
mov rdi, r15
xor esi, esi
call _memset
jmp short loc_8EFE2
loc_8EFA8:
xor ebx, ebx
jmp short loc_8EFE2
loc_8EFAC:
call _my_thread_var
cmp dword ptr [rax], 0
jz short loc_8EFD2
call _my_thread_var
cmp dword ptr [rax], 0FFFFFFFFh
jz short loc_8EFD2
call _my_thread_var
mov ebx, 1
cmp dword ptr [rax], 0AFh
jnz short loc_8EFE2
loc_8EFD2:
call _my_thread_var
mov dword ptr [rax], 7Fh
mov ebx, 1
loc_8EFE2:
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8EFF3:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_38; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_48], rcx
mov rdi, rcx
mov rsi, r14
mov ecx, 35h ; '5'
call qword ptr [rax+210h]
mov r8d, 4
mov edi, ebx
mov rsi, r15
mov rdx, r14
mov rcx, r12
call my_pread
mov r15, rax
xor esi, esi
test rax, rax
cmovz rsi, r14
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_48]
call qword ptr [rax+218h]
jmp loc_8EE42
loc_8F057:
mov r15, rax
mov rax, [r13+0]
lea rdx, aWorkspaceLlm4b_38; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov r13, [rbp+var_40]
mov rsi, r13
mov ecx, 5Dh ; ']'
call qword ptr [rax+210h]
mov edi, ebx
mov rsi, [rbp+var_30]
mov rdx, r13
mov rcx, r12
xor r8d, r8d
call my_pread
mov rbx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
mov esi, 0
cmovnz rsi, rax
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
mov r15, [rbp+var_30]
call qword ptr [rax+218h]
jmp loc_8EF2A
| long long mi_read_cache(long long *a1, long long a2, unsigned long long a3, unsigned long long a4, int a5)
{
unsigned long long v5; // r12
long long v6; // r15
unsigned long long v8; // rax
unsigned long long v9; // r14
unsigned int v10; // ebx
long long v11; // rax
long long v12; // r15
unsigned int v13; // ebx
unsigned long long v14; // rdx
long long v15; // rsi
long long v16; // rsi
unsigned long long v17; // r14
long long v18; // rdi
unsigned long long v19; // r15
unsigned int v20; // ebx
long long v21; // rax
long long v22; // rdi
unsigned long long v23; // r13
long long v24; // rbx
long long v25; // rsi
long long v26; // rax
unsigned long long v27; // r14
long long v28; // r15
unsigned long long v30; // rsi
long long v31; // r15
long long v32; // rax
long long v33; // rsi
_BYTE v34[72]; // [rsp+0h] [rbp-90h] BYREF
long long v35; // [rsp+48h] [rbp-48h]
unsigned long long v36; // [rsp+50h] [rbp-40h]
int v37; // [rsp+5Ch] [rbp-34h]
long long v38; // [rsp+60h] [rbp-30h]
v37 = a5;
v5 = a3;
v6 = a2;
v8 = *a1;
v9 = *a1 - a3;
if ( *a1 > a3 )
{
v36 = a4;
if ( v9 >= a4 )
v9 = a4;
*((_DWORD *)a1 + 56) = 1;
v10 = *((_DWORD *)a1 + 53);
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v34, v10, 6LL);
v38 = a2;
if ( v11 )
{
v35 = v11;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v11,
v9,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",
53LL);
v12 = my_pread(v10, a2, v9, v5, 4LL);
v30 = 0LL;
if ( !v12 )
v30 = v9;
((void ( *)(long long, unsigned long long))PSI_server[67])(v35, v30);
}
else
{
v12 = my_pread(v10, a2, v9, v5, 4LL);
}
v13 = 1;
if ( v12 )
return v13;
a4 = v36 - v9;
if ( v36 == v9 )
return 0;
v5 += v9;
v6 = v9 + v38;
v8 = *a1;
}
v14 = v5 - v8;
if ( v5 < v8 || (v15 = a1[5], v13 = 0, v14 >= a1[3] - v15) )
{
v17 = 0LL;
}
else
{
v16 = (unsigned int)v14 + v15;
v17 = a1[3] - v16;
if ( a4 < v17 )
v17 = a4;
v38 = v6;
v18 = v6;
v19 = a4;
memcpy(v18, v16, v17);
a4 = v19 - v17;
if ( v19 == v17 )
return v13;
v5 += v17;
v6 = v17 + v38;
}
if ( (v37 & 1) != 0 )
{
v25 = a1[3];
v26 = a1[5];
if ( v5 != *a1 + (unsigned int)(v25 - v26) )
{
*a1 = v5;
a1[3] = v26;
*((_DWORD *)a1 + 56) = 1;
v25 = v26;
}
a1[2] = v25;
v22 = (long long)a1;
if ( !(unsigned int)my_b_read(a1, v6, a4) )
return 0;
v24 = *((int *)a1 + 57);
}
else
{
v36 = a4;
v38 = v6;
*((_DWORD *)a1 + 56) = 1;
v20 = *((_DWORD *)a1 + 53);
v21 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v34, v20, 6LL);
if ( v21 )
{
v31 = v21;
v23 = v36;
((void ( *)(long long, unsigned long long, const char *, long long))PSI_server[66])(
v21,
v36,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",
93LL);
v32 = my_pread(v20, v38, v23, v5, 0LL);
v24 = v32;
v33 = 0LL;
if ( v32 != -1 )
v33 = v32;
v22 = v31;
v6 = v38;
((void ( *)(long long, long long))PSI_server[67])(v22, v33);
}
else
{
v22 = v20;
v6 = v38;
v23 = v36;
v24 = my_pread(v20, v38, v36, v5, 0LL);
}
if ( v24 == v23 )
return 0;
}
if ( (v37 & 2) == 0 || (_DWORD)v24 == -1 || (v27 = v24 + v17, v27 <= 2) )
{
if ( !*(_DWORD *)my_thread_var(v22)
|| *(_DWORD *)my_thread_var(v22) == -1
|| (v13 = 1, *(_DWORD *)my_thread_var(v22) == 175) )
{
*(_DWORD *)my_thread_var(v22) = 127;
return 1;
}
}
else
{
v28 = v24 + v6;
v13 = 0;
memset(v28, 0LL, 20 - v27);
}
return v13;
}
| _mi_read_cache:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV dword ptr [RBP + -0x34],R8D
MOV R12,RDX
MOV R15,RSI
MOV R13,RDI
MOV RAX,qword ptr [RDI]
MOV R14,RAX
SUB R14,RDX
JBE 0x0018ee6b
CMP R14,RCX
MOV qword ptr [RBP + -0x40],RCX
CMOVNC R14,RCX
MOV dword ptr [R13 + 0xe0],0x1
MOV EBX,dword ptr [R13 + 0xd4]
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x30],R15
JNZ 0x0018eff3
MOV R8D,0x4
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
CALL 0x001a0664
MOV R15,RAX
LAB_0018ee42:
MOV EBX,0x1
TEST R15,R15
MOV RCX,qword ptr [RBP + -0x40]
JNZ 0x0018efe2
SUB RCX,R14
JZ 0x0018efa8
ADD R12,R14
MOV R15,qword ptr [RBP + -0x30]
ADD R15,R14
MOV RAX,qword ptr [R13]
LAB_0018ee6b:
MOV RDX,R12
SUB RDX,RAX
JC 0x0018eec1
MOV R14,qword ptr [R13 + 0x18]
MOV RSI,qword ptr [R13 + 0x28]
MOV RAX,R14
SUB RAX,RSI
XOR EBX,EBX
CMP RDX,RAX
JNC 0x0018eec1
MOV EAX,EDX
ADD RSI,RAX
SUB R14,RSI
CMP RCX,R14
CMOVC R14,RCX
MOV qword ptr [RBP + -0x30],R15
MOV RDI,R15
MOV RDX,R14
MOV R15,RCX
CALL 0x00129080
MOV RCX,R15
SUB RCX,R14
JZ 0x0018efe2
ADD R12,R14
MOV R15,qword ptr [RBP + -0x30]
ADD R15,R14
JMP 0x0018eec4
LAB_0018eec1:
XOR R14D,R14D
LAB_0018eec4:
TEST byte ptr [RBP + -0x34],0x1
JNZ 0x0018ef31
MOV qword ptr [RBP + -0x40],RCX
MOV qword ptr [RBP + -0x30],R15
MOV dword ptr [R13 + 0xe0],0x1
MOV EBX,dword ptr [R13 + 0xd4]
LEA R13,[0x486010]
MOV RAX,qword ptr [R13]
LEA RDI,[RBP + -0x90]
MOV ESI,EBX
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0018f057
MOV EDI,EBX
MOV R15,qword ptr [RBP + -0x30]
MOV RSI,R15
MOV R13,qword ptr [RBP + -0x40]
MOV RDX,R13
MOV RCX,R12
XOR R8D,R8D
CALL 0x001a0664
MOV RBX,RAX
LAB_0018ef2a:
CMP RBX,R13
JNZ 0x0018ef79
JMP 0x0018efa8
LAB_0018ef31:
MOV RSI,qword ptr [R13 + 0x18]
MOV RAX,qword ptr [R13 + 0x28]
MOV EDX,ESI
SUB EDX,EAX
ADD RDX,qword ptr [R13]
CMP R12,RDX
JZ 0x0018ef5c
MOV qword ptr [R13],R12
MOV qword ptr [R13 + 0x18],RAX
MOV dword ptr [R13 + 0xe0],0x1
MOV RSI,RAX
LAB_0018ef5c:
MOV qword ptr [R13 + 0x10],RSI
MOV RDI,R13
MOV RSI,R15
MOV RDX,RCX
CALL 0x00195622
TEST EAX,EAX
JZ 0x0018efa8
MOVSXD RBX,dword ptr [R13 + 0xe4]
LAB_0018ef79:
TEST byte ptr [RBP + -0x34],0x2
JZ 0x0018efac
MOV EAX,EBX
CMP EAX,-0x1
JZ 0x0018efac
ADD R14,RBX
CMP R14,0x2
JBE 0x0018efac
ADD R15,RBX
MOV EDX,0x14
SUB RDX,R14
XOR EBX,EBX
MOV RDI,R15
XOR ESI,ESI
CALL 0x001292a0
JMP 0x0018efe2
LAB_0018efa8:
XOR EBX,EBX
JMP 0x0018efe2
LAB_0018efac:
CALL 0x001a1b26
CMP dword ptr [RAX],0x0
JZ 0x0018efd2
CALL 0x001a1b26
CMP dword ptr [RAX],-0x1
JZ 0x0018efd2
CALL 0x001a1b26
MOV EBX,0x1
CMP dword ptr [RAX],0xaf
JNZ 0x0018efe2
LAB_0018efd2:
CALL 0x001a1b26
MOV dword ptr [RAX],0x7f
MOV EBX,0x1
LAB_0018efe2:
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018eff3:
MOV RCX,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1dba40]
MOV qword ptr [RBP + -0x48],RCX
MOV RDI,RCX
MOV RSI,R14
MOV ECX,0x35
CALL qword ptr [RAX + 0x210]
MOV R8D,0x4
MOV EDI,EBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
CALL 0x001a0664
MOV R15,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R14
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
CALL qword ptr [RAX + 0x218]
JMP 0x0018ee42
LAB_0018f057:
MOV R15,RAX
MOV RAX,qword ptr [R13]
LEA RDX,[0x1dba40]
MOV RDI,R15
MOV R13,qword ptr [RBP + -0x40]
MOV RSI,R13
MOV ECX,0x5d
CALL qword ptr [RAX + 0x210]
MOV EDI,EBX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,R13
MOV RCX,R12
XOR R8D,R8D
CALL 0x001a0664
MOV RBX,RAX
CMP RAX,-0x1
MOV ESI,0x0
CMOVNZ RSI,RAX
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
MOV R15,qword ptr [RBP + -0x30]
CALL qword ptr [RAX + 0x218]
JMP 0x0018ef2a
|
int8 _mi_read_cache(ulong *param_1,void *param_2,ulong param_3,ulong param_4,uint param_5)
{
int4 uVar1;
int iVar2;
long lVar3;
int *piVar4;
int4 *puVar5;
void *__src;
ulong uVar6;
ulong uVar7;
ulong uVar8;
int1 local_98 [72];
long local_50;
ulong local_48;
uint local_3c;
void *local_38;
uVar8 = *param_1;
uVar7 = uVar8 - param_3;
local_3c = param_5;
if (param_3 <= uVar8 && uVar7 != 0) {
if (param_4 <= uVar7) {
uVar7 = param_4;
}
*(int4 *)(param_1 + 0x1c) = 1;
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_48 = param_4;
lVar3 = (**(code **)(PSI_server + 0x158))(local_98,uVar1,6);
local_38 = param_2;
if (lVar3 == 0) {
lVar3 = my_pread(uVar1,param_2,uVar7,param_3,4);
}
else {
local_50 = lVar3;
(**(code **)(PSI_server + 0x210))
(lVar3,uVar7,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c",
0x35);
lVar3 = my_pread(uVar1,param_2,uVar7,param_3,4);
uVar8 = 0;
if (lVar3 == 0) {
uVar8 = uVar7;
}
(**(code **)(PSI_server + 0x218))(local_50,uVar8);
}
if (lVar3 != 0) {
return 1;
}
param_4 = local_48 - uVar7;
if (param_4 == 0) {
return 0;
}
param_3 = param_3 + uVar7;
param_2 = (void *)((long)local_38 + uVar7);
uVar8 = *param_1;
}
if (param_3 < uVar8) {
LAB_0018eec1:
uVar8 = 0;
}
else {
if (param_1[3] - param_1[5] <= param_3 - uVar8) goto LAB_0018eec1;
__src = (void *)(param_1[5] + (param_3 - uVar8 & 0xffffffff));
uVar8 = param_1[3] - (long)__src;
if (param_4 < uVar8) {
uVar8 = param_4;
}
local_38 = param_2;
memcpy(param_2,__src,uVar8);
param_4 = param_4 - uVar8;
if (param_4 == 0) {
return 0;
}
param_3 = param_3 + uVar8;
param_2 = (void *)((long)local_38 + uVar8);
}
if ((local_3c & 1) == 0) {
*(int4 *)(param_1 + 0x1c) = 1;
uVar1 = *(int4 *)((long)param_1 + 0xd4);
local_48 = param_4;
local_38 = param_2;
lVar3 = (**(code **)(PSI_server + 0x158))(local_98,uVar1,6);
param_2 = local_38;
uVar6 = local_48;
if (lVar3 == 0) {
uVar7 = my_pread(uVar1,local_38,local_48,param_3,0);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar3,local_48,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_cache.c"
,0x5d);
uVar7 = my_pread(uVar1,local_38,uVar6,param_3,0);
param_2 = local_38;
(**(code **)(PSI_server + 0x218))(lVar3);
}
if (uVar7 != uVar6) {
LAB_0018ef79:
if ((((local_3c & 2) != 0) && ((int)uVar7 != -1)) && (2 < uVar8 + uVar7)) {
memset((void *)((long)param_2 + uVar7),0,0x14 - (uVar8 + uVar7));
return 0;
}
piVar4 = (int *)_my_thread_var();
if (((*piVar4 != 0) && (piVar4 = (int *)_my_thread_var(), *piVar4 != -1)) &&
(piVar4 = (int *)_my_thread_var(), *piVar4 != 0xaf)) {
return 1;
}
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x7f;
return 1;
}
}
else {
uVar7 = param_1[5];
uVar6 = param_1[3];
if (param_3 != (ulong)(uint)((int)param_1[3] - (int)uVar7) + *param_1) {
*param_1 = param_3;
param_1[3] = uVar7;
*(int4 *)(param_1 + 0x1c) = 1;
uVar6 = uVar7;
}
param_1[2] = uVar6;
iVar2 = _my_b_read(param_1,param_2,param_4);
if (iVar2 != 0) {
uVar7 = (ulong)*(int *)((long)param_1 + 0xe4);
goto LAB_0018ef79;
}
}
return 0;
}
| |
24,439 | fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | llama.cpp/common/common.cpp | std::string fs_get_cache_file(const std::string & filename) {
GGML_ASSERT(filename.find(DIRECTORY_SEPARATOR) == std::string::npos);
std::string cache_directory = fs_get_cache_directory();
const bool success = fs_create_directory_with_parents(cache_directory);
if (!success) {
throw std::runtime_error("failed to create cache directory: " + cache_directory);
}
return cache_directory + filename;
} | O3 | cpp | fs_get_cache_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
xorl %edx, %edx
callq 0x211d0
cmpq $-0x1, %rax
jne 0xf93b1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf8f84
movq %r15, %rdi
callq 0xf8e86
testb %al, %al
je 0xf93d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x66952
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf93a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20170
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2b22d(%rip), %rdi # 0x1245e5
leaq 0x206b8(%rip), %rdx # 0x119a77
leaq 0x2b3f7(%rip), %rcx # 0x1247bd
movl $0x353, %esi # imm = 0x353
xorl %eax, %eax
callq 0x20e20
movl $0x10, %edi
callq 0x20620
movq %rax, %rbx
leaq 0x2b40f(%rip), %rsi # 0x1247f5
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x65321
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x20450
xorl %ebp, %ebp
movq 0x68bb2(%rip), %rsi # 0x161fc0
movq 0x68b6b(%rip), %rdx # 0x161f80
movq %rbx, %rdi
callq 0x20a30
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf943b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x20170
testb %bpl, %bpl
jne 0xf9445
jmp 0xf9452
movq %rax, %r14
movq %rbx, %rdi
callq 0x20eb0
jmp 0xf9452
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf946d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20170
movq %r14, %rdi
callq 0x20ad0
| _Z17fs_get_cache_fileRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp; int
push r15; int
push r14; __int64
push rbx; int
sub rsp, 48h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi
mov esi, 2Fh ; '/'
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_F93B1
lea r15, [rsp+68h+var_60]
mov rdi, r15; int
call _Z22fs_get_cache_directoryB5cxx11v; fs_get_cache_directory(void)
mov rdi, r15
call _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; fs_create_directory_with_parents(std::string const&)
test al, al
jz short loc_F93D2
lea rsi, [rsp+68h+var_60]
mov rdi, rbx
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EERKS8_SA_; std::operator+<char>(std::string const&,std::string const&)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F93A3
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F93A3:
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_F93B1:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aFilenameFindDi; "filename.find(DIRECTORY_SEPARATOR) == s"...
mov esi, 353h
xor eax, eax
call _ggml_abort
loc_F93D2:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aFailedToCreate; "failed to create cache directory: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F943B
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F943B:
test bpl, bpl
jnz short loc_F9445
jmp short loc_F9452
mov r14, rax
loc_F9445:
mov rdi, rbx; void *
call ___cxa_free_exception
jmp short loc_F9452
mov r14, rax
loc_F9452:
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_F946D
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_F946D:
mov rdi, r14
call __Unwind_Resume
| _QWORD * fs_get_cache_file(_QWORD *a1, _QWORD *a2)
{
void *exception; // rbx
int v4[4]; // [rsp+8h] [rbp-60h] BYREF
long long v5; // [rsp+18h] [rbp-50h] BYREF
_BYTE v6[16]; // [rsp+28h] [rbp-40h] BYREF
if ( std::string::find(a2, 47LL, 0LL) != -1 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
851LL,
"GGML_ASSERT(%s) failed",
"filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
LABEL_7:
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v6, (long long)"failed to create cache directory: ", v4);
std::runtime_error::runtime_error(exception, v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
fs_get_cache_directory[abi:cxx11](v4);
if ( !(unsigned __int8)fs_create_directory_with_parents(v4) )
goto LABEL_7;
std::operator+<char>(a1, (long long)v4, a2);
if ( *(long long **)v4 != &v5 )
operator delete(*(void **)v4, v5 + 1);
return a1;
}
| fs_get_cache_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
MOV RBX,RDI
MOV RDI,RSI
MOV ESI,0x2f
XOR EDX,EDX
CALL 0x001211d0
CMP RAX,-0x1
JNZ 0x001f93b1
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x001f8f84
LAB_001f936c:
MOV RDI,R15
CALL 0x001f8e86
TEST AL,AL
JZ 0x001f93d2
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
MOV RDX,R14
CALL 0x00166952
LAB_001f9388:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001f93a3
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120170
LAB_001f93a3:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001f93b1:
LEA RDI,[0x2245e5]
LEA RDX,[0x219a77]
LEA RCX,[0x2247bd]
MOV ESI,0x353
XOR EAX,EAX
CALL 0x00120e20
LAB_001f93d2:
MOV EDI,0x10
CALL 0x00120620
MOV RBX,RAX
LAB_001f93df:
LEA RSI,[0x2247f5]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00165321
MOV BPL,0x1
LAB_001f93f8:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00120450
XOR EBP,EBP
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,RBX
CALL 0x00120a30
|
/* fs_get_cache_file(std::__cxx11::string const&) */
string * fs_get_cache_file(string *param_1)
{
char cVar1;
long lVar2;
runtime_error *this;
char in_SIL;
long *local_60 [2];
long local_50 [2];
string local_40 [32];
lVar2 = std::__cxx11::string::find(in_SIL,0x2f);
if (lVar2 != -1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x353,
"GGML_ASSERT(%s) failed","filename.find(DIRECTORY_SEPARATOR) == std::string::npos");
}
fs_get_cache_directory_abi_cxx11_();
/* try { // try from 001f936c to 001f9387 has its CatchHandler @ 001f944f */
cVar1 = fs_create_directory_with_parents((string *)local_60);
if (cVar1 != '\0') {
std::operator+(param_1,(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
return param_1;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f93df to 001f93f4 has its CatchHandler @ 001f9442 */
std::operator+((char *)local_40,(string *)"failed to create cache directory: ");
/* try { // try from 001f93f8 to 001f941c has its CatchHandler @ 001f941d */
std::runtime_error::runtime_error(this,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
| |
24,440 | my_wc_mb_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_wc_mb_tis620(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc,
uchar *str,
uchar *end __attribute__((unused)))
{
const uchar *pl;
if (str >= end)
return MY_CS_TOOSMALL;
pl= uni_to_cs[(wc>>8) & 0xFF];
str[0]= pl ? pl[wc & 0xFF] : '\0';
return (!str[0] && wc) ? MY_CS_ILUNI : 1;
} | O0 | c | my_wc_mb_tis620:
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 0x7cb67
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x7cbe2
movq -0x18(%rbp), %rcx
shrq $0x8, %rcx
andq $0xff, %rcx
leaq 0x191603(%rip), %rax # 0x20e180
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x7cba4
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
andq $0xff, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
jmp 0x7cbab
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0x7cbab
movl -0x34(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
movb %al, -0x35(%rbp)
jne 0x7cbcf
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_wc_mb_tis620:
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_7CB67
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_7CBE2
loc_7CB67:
mov rcx, [rbp+var_18]
shr rcx, 8
and rcx, 0FFh
lea rax, uni_to_cs_0
mov rax, [rax+rcx*8]
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_7CBA4
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
and rcx, 0FFh
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_34], eax
jmp short loc_7CBAB
loc_7CBA4:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_7CBAB:
mov eax, [rbp+var_34]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov rcx, [rbp+var_20]
xor eax, eax
cmp byte ptr [rcx], 0
mov [rbp+var_35], al
jnz short loc_7CBCF
cmp [rbp+var_18], 0
setnz al
mov [rbp+var_35], al
loc_7CBCF:
mov dl, [rbp+var_35]
mov eax, 1
xor ecx, ecx
test dl, 1
cmovnz eax, ecx
mov [rbp+var_4], eax
loc_7CBE2:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_tis620(long long a1, long long a2, _BYTE *a3, unsigned long long a4)
{
bool v5; // [rsp+1h] [rbp-35h]
char v6; // [rsp+2h] [rbp-34h]
long long v7; // [rsp+6h] [rbp-30h]
if ( (unsigned long long)a3 < a4 )
{
v7 = (long long)*(&uni_to_cs_0 + BYTE1(a2));
if ( v7 )
v6 = *(_BYTE *)(v7 + (unsigned __int8)a2);
else
v6 = 0;
*a3 = v6;
v5 = 0;
if ( !*a3 )
v5 = a2 != 0;
return !v5;
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_tis620:
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 0x0017cb67
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0017cbe2
LAB_0017cb67:
MOV RCX,qword ptr [RBP + -0x18]
SHR RCX,0x8
AND RCX,0xff
LEA RAX,[0x30e180]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0017cba4
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
AND RCX,0xff
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0017cbab
LAB_0017cba4:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x0017cbab
LAB_0017cbab:
MOV EAX,dword ptr [RBP + -0x34]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP byte ptr [RCX],0x0
MOV byte ptr [RBP + -0x35],AL
JNZ 0x0017cbcf
CMP qword ptr [RBP + -0x18],0x0
SETNZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_0017cbcf:
MOV DL,byte ptr [RBP + -0x35]
MOV EAX,0x1
XOR ECX,ECX
TEST DL,0x1
CMOVNZ EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
LAB_0017cbe2:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
uint my_wc_mb_tis620(int8 param_1,ulong param_2,char *param_3,char *param_4)
{
char cVar1;
uint local_c;
if (param_3 < param_4) {
if (*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) == 0) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(uni_to_cs + (param_2 >> 8 & 0xff) * 8) + (param_2 & 0xff));
}
*param_3 = cVar1;
local_c = (uint)(*param_3 != '\0' || param_2 == 0);
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
24,441 | rtree_get_first | eloqsql/storage/myisam/rt_index.c | int rtree_get_first(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
info->rtree_recursion_depth = -1;
info->buff_used = 1;
return rtree_get_req(info, keyinfo, key_length, root, 0);
} | O0 | c | rtree_get_first:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, %rax
jne 0xc8f51
callq 0xf6090
movl $0x89, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc8f84
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x3c0(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movb $0x1, 0x33d(%rax)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
xorl %r8d, %r8d
callq 0xc8f90
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| rtree_get_first:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_14]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_C8F51
call _my_thread_var
mov dword ptr [rax], 89h
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_C8F84
loc_C8F51:
mov rax, [rbp+var_10]
mov dword ptr [rax+3C0h], 0FFFFFFFFh
mov rax, [rbp+var_10]
mov byte ptr [rax+33Dh], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_18]
mov rcx, [rbp+var_20]
xor r8d, r8d
call rtree_get_req
mov [rbp+var_4], eax
loc_C8F84:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long rtree_get_first(long long a1, const char *a2, unsigned int a3)
{
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v4 = 112LL * (unsigned int)a2 + *(_QWORD *)(*(_QWORD *)a1 + 536LL);
v5 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * (unsigned int)a2);
if ( v5 == -1 )
{
*(_DWORD *)my_thread_var(a1, a2) = 137;
return (unsigned int)-1;
}
else
{
*(_DWORD *)(a1 + 960) = -1;
*(_BYTE *)(a1 + 829) = 1;
return (unsigned int)rtree_get_req(a1, v4, a3, v5, 0LL);
}
}
| rtree_get_first:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x14]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,-0x1
JNZ 0x001c8f51
CALL 0x001f6090
MOV dword ptr [RAX],0x89
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001c8f84
LAB_001c8f51:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c0],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x33d],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
XOR R8D,R8D
CALL 0x001c8f90
MOV dword ptr [RBP + -0x4],EAX
LAB_001c8f84:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 rtree_get_first(long *param_1,uint param_2,int4 param_3)
{
long lVar1;
long lVar2;
int4 *puVar3;
int4 local_c;
lVar1 = *(long *)(*param_1 + 0x218);
lVar2 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
if (lVar2 == -1) {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
local_c = 0xffffffff;
}
else {
*(int4 *)(param_1 + 0x78) = 0xffffffff;
*(int1 *)((long)param_1 + 0x33d) = 1;
local_c = rtree_get_req(param_1,lVar1 + (ulong)param_2 * 0x70,param_3,lVar2,0);
}
return local_c;
}
| |
24,442 | PCA::pca_model::pca_model(ggml_tensor*) | llama.cpp/examples/cvector-generator/pca.hpp | pca_model(struct ggml_tensor * t_input) {
#ifdef GGML_USE_CUDA
fprintf(stderr, "%s: using CUDA backend\n", __func__);
backend = ggml_backend_cuda_init(0); // init device 0
if (!backend) {
fprintf(stderr, "%s: ggml_backend_cuda_init() failed\n", __func__);
}
#endif
// TODO: enable Metal support when support for GGML_OP_SQRT is added
// #ifdef GGML_USE_METAL
// fprintf(stderr, "%s: using Metal backend\n", __func__);
// backend = ggml_backend_metal_init();
// if (!backend) {
// fprintf(stderr, "%s: ggml_backend_metal_init() failed\n", __func__);
// }
// #endif
// if there aren't GPU Backends fallback to CPU backend
if (!backend) {
backend = ggml_backend_cpu_init();
}
const int num_tensors = 4;
struct ggml_init_params params {
/*.mem_size =*/ ggml_tensor_overhead() * num_tensors,
/*.mem_buffer =*/ NULL,
/*.no_alloc =*/ true,
};
ctx = ggml_init(params);
auto n_samples = t_input->ne[0];
auto n_embd = t_input->ne[1];
dev_input = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_samples, n_embd);
dev_square = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, n_embd, n_embd);
dev_eigenvector = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, n_embd);
ggml_set_name(dev_input, "dev_input");
ggml_set_name(dev_square, "dev_square");
ggml_set_name(dev_eigenvector, "dev_eigenvector");
buffer = ggml_backend_alloc_ctx_tensors(ctx, backend);
ggml_backend_tensor_set(dev_input, t_input->data, 0, ggml_nbytes(t_input));
// initialize eigenvector to random normalized vector
{
std::vector<float> random_vec(ggml_nelements(dev_eigenvector), 0.0);
std::default_random_engine generator(static_cast<unsigned int>(std::time(0)));
std::uniform_real_distribution<float> distribution(0.0, 1.0);
float sum_sqr = 0.0; // for normalizing random_vec
for (size_t i = 0; i < random_vec.size(); ++i) {
float f = distribution(generator);
sum_sqr += f * f;
random_vec[i] = f;
}
// normalize it
float random_vec_norm = std::sqrt(sum_sqr);
for (size_t i = 0; i < random_vec.size(); ++i) {
random_vec[i] /= random_vec_norm;
}
ggml_backend_tensor_set(dev_eigenvector, random_vec.data(), 0, ggml_nbytes(dev_eigenvector));
}
} | O3 | cpp | PCA::pca_model::pca_model(ggml_tensor*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movq %r15, (%rdi)
callq 0x22750
movq %rax, (%rbx)
callq 0x21730
shlq $0x2, %rax
movq %rax, 0x40(%rsp)
movq %r15, 0x48(%rsp)
movb $0x1, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x225e0
movq %rax, 0x10(%rbx)
movq 0x10(%r14), %rdx
movq 0x18(%r14), %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x21310
movq %rax, 0x20(%rbx)
movq 0x10(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r15, %rcx
callq 0x21310
movq %rax, 0x28(%rbx)
movq 0x10(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x21790
movq %rax, 0x30(%rbx)
movq 0x20(%rbx), %rdi
leaq 0xe98e3(%rip), %rsi # 0x1156bf
callq 0x21bb0
movq 0x28(%rbx), %rdi
leaq 0xe98dd(%rip), %rsi # 0x1156c9
callq 0x21bb0
movq 0x30(%rbx), %rdi
leaq 0xe98d8(%rip), %rsi # 0x1156d4
callq 0x21bb0
movq (%rbx), %rsi
movq 0x10(%rbx), %rdi
callq 0x22370
movq %rax, 0x8(%rbx)
movq 0x20(%rbx), %r15
movq 0xf8(%r14), %r12
movq %r14, %rdi
callq 0x222d0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21630
movq 0x30(%rbx), %rdi
callq 0x221e0
leaq 0x38(%rsp), %r15
movl $0x0, (%r15)
leaq 0x20(%rsp), %r14
leaq 0x1f(%rsp), %rcx
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x2bfd0
xorl %edi, %edi
callq 0x21dd0
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x1e, %edx
movl %edx, %ecx
shll $0x1f, %ecx
orl %edx, %ecx
leal (%rax,%rcx), %edx
cmpl $0x1, %edx
adcl %eax, %ecx
movq %rcx, (%r15)
movq 0x8(%r14), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rsp)
cmpq (%r14), %rax
je 0x2bef5
xorl %r15d, %r15d
leaq 0x38(%rsp), %r14
movss %xmm0, 0x18(%rsp)
movq %r14, %rdi
callq 0x2c175
addss 0xe925d(%rip), %xmm0 # 0x11511c
movaps %xmm0, %xmm1
mulss %xmm0, %xmm1
movss 0x18(%rsp), %xmm2
addss %xmm1, %xmm2
movss %xmm2, 0x18(%rsp)
movq 0x20(%rsp), %rax
movss %xmm0, (%rax,%r15,4)
incq %r15
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r15
jb 0x2beaf
movss 0x18(%rsp), %xmm0
ucomiss 0xe921a(%rip), %xmm0 # 0x11511c
jb 0x2bf0a
sqrtss %xmm0, %xmm0
jmp 0x2bf0f
callq 0x222f0
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %rax
subq %r14, %rax
je 0x2bf44
sarq $0x2, %rax
cmpq $0x1, %rax
adcq $0x0, %rax
xorl %ecx, %ecx
movss (%r14,%rcx,4), %xmm1
divss %xmm0, %xmm1
movss %xmm1, (%r14,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0x2bf2c
movq 0x30(%rbx), %rbx
movq %rbx, %rdi
callq 0x222d0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21630
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2bf77
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x211a0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2bf85
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2bf9f
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x211a0
movq %rbx, %rdi
callq 0x21c10
nop
| _ZN3PCA9pca_modelC2EP11ggml_tensor:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r14, rsi
mov rbx, rdi
xor r15d, r15d
mov [rdi], r15
call _ggml_backend_cpu_init
mov [rbx], rax
call _ggml_tensor_overhead
shl rax, 2
mov qword ptr [rsp+78h+var_38], rax
mov qword ptr [rsp+78h+var_38+8], r15
mov byte ptr [rsp+78h+var_28], 1
mov rax, [rsp+78h+var_28]
mov [rsp+78h+var_68], rax
movups xmm0, [rsp+78h+var_38]
movups [rsp+78h+var_78], xmm0
call _ggml_init
mov [rbx+10h], rax
mov rdx, [r14+10h]
mov r15, [r14+18h]
mov rdi, rax
xor esi, esi
mov rcx, r15
call _ggml_new_tensor_2d
mov [rbx+20h], rax
mov rdi, [rbx+10h]
xor esi, esi
mov rdx, r15
mov rcx, r15
call _ggml_new_tensor_2d
mov [rbx+28h], rax
mov rdi, [rbx+10h]
xor esi, esi
mov rdx, r15
call _ggml_new_tensor_1d
mov [rbx+30h], rax
mov rdi, [rbx+20h]
lea rsi, aDevInput; "dev_input"
call _ggml_set_name
mov rdi, [rbx+28h]
lea rsi, aDevSquare; "dev_square"
call _ggml_set_name
mov rdi, [rbx+30h]
lea rsi, aDevEigenvector; "dev_eigenvector"
call _ggml_set_name
mov rsi, [rbx]
mov rdi, [rbx+10h]
call _ggml_backend_alloc_ctx_tensors
mov [rbx+8], rax
mov r15, [rbx+20h]
mov r12, [r14+0F8h]
mov rdi, r14
call _ggml_nbytes
mov rdi, r15
mov rsi, r12
xor edx, edx
mov rcx, rax
call _ggml_backend_tensor_set
mov rdi, [rbx+30h]
call _ggml_nelements
lea r15, [rsp+78h+var_40]
mov dword ptr [r15], 0
lea r14, [rsp+78h+var_58]
lea rcx, [rsp+78h+var_59]
mov rdi, r14
mov rsi, rax
mov rdx, r15
call _ZNSt6vectorIfSaIfEEC2EmRKfRKS0_; std::vector<float>::vector(ulong,float const&,std::allocator<float> const&)
xor edi, edi
call _time
mov ecx, eax
lea rcx, [rcx+rcx*2]
shr rcx, 20h
mov edx, eax
sub edx, ecx
shr edx, 1
add edx, ecx
shr edx, 1Eh
mov ecx, edx
shl ecx, 1Fh
or ecx, edx
lea edx, [rax+rcx]
cmp edx, 1
adc ecx, eax
mov [r15], rcx
mov rax, [r14+8]
xorps xmm0, xmm0
movss [rsp+78h+var_60], xmm0
cmp rax, [r14]
jz short loc_2BEF5
xor r15d, r15d
lea r14, [rsp+78h+var_40]
movss [rsp+78h+var_60], xmm0
loc_2BEAF:
mov rdi, r14
call _ZSt18generate_canonicalIfLm24ESt26linear_congruential_engineImLm16807ELm0ELm2147483647EEET_RT1_; std::generate_canonical<float,24ul,std::linear_congruential_engine<ulong,16807ul,0ul,2147483647ul>>(std::linear_congruential_engine<ulong,16807ul,0ul,2147483647ul> &)
addss xmm0, cs:dword_11511C
movaps xmm1, xmm0
mulss xmm1, xmm0
movss xmm2, [rsp+78h+var_60]
addss xmm2, xmm1
movss [rsp+78h+var_60], xmm2
mov rax, [rsp+78h+var_58]
movss dword ptr [rax+r15*4], xmm0
inc r15
mov rcx, [rsp+78h+var_50]
sub rcx, rax
sar rcx, 2
cmp r15, rcx
jb short loc_2BEAF
loc_2BEF5:
movss xmm0, [rsp+78h+var_60]
ucomiss xmm0, cs:dword_11511C
jb short loc_2BF0A
sqrtss xmm0, xmm0
jmp short loc_2BF0F
loc_2BF0A:
call _sqrtf
loc_2BF0F:
mov r14, [rsp+78h+var_58]
mov rax, [rsp+78h+var_50]
sub rax, r14
jz short loc_2BF44
sar rax, 2
cmp rax, 1
adc rax, 0
xor ecx, ecx
loc_2BF2C:
movss xmm1, dword ptr [r14+rcx*4]
divss xmm1, xmm0
movss dword ptr [r14+rcx*4], xmm1
inc rcx
cmp rax, rcx
jnz short loc_2BF2C
loc_2BF44:
mov rbx, [rbx+30h]
mov rdi, rbx
call _ggml_nbytes
mov rdi, rbx
mov rsi, r14
xor edx, edx
mov rcx, rax
call _ggml_backend_tensor_set
mov rdi, [rsp+78h+var_58]; void *
test rdi, rdi
jz short loc_2BF77
mov rsi, [rsp+78h+var_48]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2BF77:
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
jmp short $+2
loc_2BF85:
mov rbx, rax
mov rdi, [rsp+arg_18]; void *
test rdi, rdi
jz short loc_2BF9F
mov rsi, [rsp+arg_28]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2BF9F:
mov rdi, rbx
call __Unwind_Resume
| void PCA::pca_model::pca_model(_QWORD *a1, _QWORD *a2)
{
long long v2; // rdx
long long v3; // rax
long long v4; // r15
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
long long v8; // r9
long long v9; // r15
long long v10; // r12
long long v11; // rax
long long v12; // rax
unsigned int v13; // eax
unsigned long long v14; // r15
double v15; // xmm0_8
_BYTE *v16; // rax
float v17; // xmm0_4
float *v18; // r14
long long v19; // rax
long long v20; // rcx
long long v21; // rbx
long long v22; // rax
__int128 v23; // [rsp+0h] [rbp-78h]
long long v24; // [rsp+10h] [rbp-68h]
float v25; // [rsp+18h] [rbp-60h]
char v26; // [rsp+1Fh] [rbp-59h] BYREF
void *v27; // [rsp+20h] [rbp-58h] BYREF
_BYTE *v28; // [rsp+28h] [rbp-50h]
long long v29; // [rsp+30h] [rbp-48h]
long long v30; // [rsp+38h] [rbp-40h] BYREF
__int128 v31; // [rsp+40h] [rbp-38h]
long long v32; // [rsp+50h] [rbp-28h]
*a1 = 0LL;
*a1 = ggml_backend_cpu_init();
v31 = (unsigned long long)(4 * ggml_tensor_overhead());
LOBYTE(v32) = 1;
v24 = v32;
v23 = v31;
v3 = ggml_init(a1, a2, v2);
a1[2] = v3;
v4 = a2[3];
a1[4] = ggml_new_tensor_2d(v3, 0LL, a2[2], v4);
a1[5] = ggml_new_tensor_2d(a1[2], 0LL, v4, v4);
a1[6] = ggml_new_tensor_1d(a1[2], 0LL, v4);
ggml_set_name(a1[4], "dev_input");
ggml_set_name(a1[5], "dev_square");
ggml_set_name(a1[6], "dev_eigenvector");
a1[1] = ggml_backend_alloc_ctx_tensors(a1[2], *a1, v5, v6, v7, v8, v23, *((_QWORD *)&v23 + 1), v24);
v9 = a1[4];
v10 = a2[31];
v11 = ggml_nbytes(a2);
ggml_backend_tensor_set(v9, v10, 0LL, v11);
v12 = ggml_nelements(a1[6]);
LODWORD(v30) = 0;
std::vector<float>::vector(&v27, v12, &v30, &v26);
v13 = time(0LL);
v30 = v13
+ (v13 + ((v13 / 0x7FFFFFFF) | ((v13 / 0x7FFFFFFF) << 31)) == 0)
+ ((v13 / 0x7FFFFFFF) | ((v13 / 0x7FFFFFFF) << 31));
v25 = 0.0;
if ( v28 != v27 )
{
v14 = 0LL;
v25 = 0.0;
do
{
v15 = std::generate_canonical<float,24ul,std::linear_congruential_engine<unsigned long,16807ul,0ul,2147483647ul>>(&v30);
*(float *)&v15 = *(float *)&v15 + 0.0;
v25 = v25 + (float)(*(float *)&v15 * *(float *)&v15);
v16 = v27;
*((_DWORD *)v27 + v14++) = LODWORD(v15);
}
while ( v14 < (v28 - v16) >> 2 );
}
v17 = v25;
if ( v25 < 0.0 )
sqrtf();
else
v17 = fsqrt(v25);
v18 = (float *)v27;
if ( v28 != v27 )
{
v19 = ((v28 - (_BYTE *)v27) >> 2 == 0) + ((v28 - (_BYTE *)v27) >> 2);
v20 = 0LL;
do
{
v18[v20] = v18[v20] / v17;
++v20;
}
while ( v19 != v20 );
}
v21 = a1[6];
v22 = ggml_nbytes(v21);
ggml_backend_tensor_set(v21, v18, 0LL, v22);
if ( v27 )
operator delete(v27, v29 - (_QWORD)v27);
}
| pca_model:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R14,RSI
MOV RBX,RDI
XOR R15D,R15D
MOV qword ptr [RDI],R15
CALL 0x00122750
MOV qword ptr [RBX],RAX
CALL 0x00121730
SHL RAX,0x2
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],R15
MOV byte ptr [RSP + 0x50],0x1
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001225e0
MOV qword ptr [RBX + 0x10],RAX
MOV RDX,qword ptr [R14 + 0x10]
MOV R15,qword ptr [R14 + 0x18]
MOV RDI,RAX
XOR ESI,ESI
MOV RCX,R15
CALL 0x00121310
MOV qword ptr [RBX + 0x20],RAX
MOV RDI,qword ptr [RBX + 0x10]
XOR ESI,ESI
MOV RDX,R15
MOV RCX,R15
CALL 0x00121310
MOV qword ptr [RBX + 0x28],RAX
MOV RDI,qword ptr [RBX + 0x10]
XOR ESI,ESI
MOV RDX,R15
CALL 0x00121790
MOV qword ptr [RBX + 0x30],RAX
MOV RDI,qword ptr [RBX + 0x20]
LEA RSI,[0x2156bf]
CALL 0x00121bb0
MOV RDI,qword ptr [RBX + 0x28]
LEA RSI,[0x2156c9]
CALL 0x00121bb0
MOV RDI,qword ptr [RBX + 0x30]
LEA RSI,[0x2156d4]
CALL 0x00121bb0
MOV RSI,qword ptr [RBX]
MOV RDI,qword ptr [RBX + 0x10]
CALL 0x00122370
MOV qword ptr [RBX + 0x8],RAX
MOV R15,qword ptr [RBX + 0x20]
MOV R12,qword ptr [R14 + 0xf8]
MOV RDI,R14
CALL 0x001222d0
MOV RDI,R15
MOV RSI,R12
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00121630
MOV RDI,qword ptr [RBX + 0x30]
CALL 0x001221e0
LEA R15,[RSP + 0x38]
MOV dword ptr [R15],0x0
LEA R14,[RSP + 0x20]
LEA RCX,[RSP + 0x1f]
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R15
CALL 0x0012bfd0
XOR EDI,EDI
CALL 0x00121dd0
MOV ECX,EAX
LEA RCX,[RCX + RCX*0x2]
SHR RCX,0x20
MOV EDX,EAX
SUB EDX,ECX
SHR EDX,0x1
ADD EDX,ECX
SHR EDX,0x1e
MOV ECX,EDX
SHL ECX,0x1f
OR ECX,EDX
LEA EDX,[RAX + RCX*0x1]
CMP EDX,0x1
ADC ECX,EAX
MOV qword ptr [R15],RCX
MOV RAX,qword ptr [R14 + 0x8]
XORPS XMM0,XMM0
MOVSS dword ptr [RSP + 0x18],XMM0
CMP RAX,qword ptr [R14]
JZ 0x0012bef5
XOR R15D,R15D
LEA R14,[RSP + 0x38]
MOVSS dword ptr [RSP + 0x18],XMM0
LAB_0012beaf:
MOV RDI,R14
CALL 0x0012c175
ADDSS XMM0,dword ptr [0x0021511c]
MOVAPS XMM1,XMM0
MULSS XMM1,XMM0
MOVSS XMM2,dword ptr [RSP + 0x18]
ADDSS XMM2,XMM1
MOVSS dword ptr [RSP + 0x18],XMM2
MOV RAX,qword ptr [RSP + 0x20]
MOVSS dword ptr [RAX + R15*0x4],XMM0
INC R15
MOV RCX,qword ptr [RSP + 0x28]
SUB RCX,RAX
SAR RCX,0x2
CMP R15,RCX
JC 0x0012beaf
LAB_0012bef5:
MOVSS XMM0,dword ptr [RSP + 0x18]
UCOMISS XMM0,dword ptr [0x0021511c]
JC 0x0012bf0a
SQRTSS XMM0,XMM0
JMP 0x0012bf0f
LAB_0012bf0a:
CALL 0x001222f0
LAB_0012bf0f:
MOV R14,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x28]
SUB RAX,R14
JZ 0x0012bf44
SAR RAX,0x2
CMP RAX,0x1
ADC RAX,0x0
XOR ECX,ECX
LAB_0012bf2c:
MOVSS XMM1,dword ptr [R14 + RCX*0x4]
DIVSS XMM1,XMM0
MOVSS dword ptr [R14 + RCX*0x4],XMM1
INC RCX
CMP RAX,RCX
JNZ 0x0012bf2c
LAB_0012bf44:
MOV RBX,qword ptr [RBX + 0x30]
LAB_0012bf48:
MOV RDI,RBX
CALL 0x001222d0
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00121630
LAB_0012bf60:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0012bf77
MOV RSI,qword ptr [RSP + 0x30]
SUB RSI,RDI
CALL 0x001211a0
LAB_0012bf77:
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* PCA::pca_model::pca_model(ggml_tensor*) */
void __thiscall PCA::pca_model::pca_model(pca_model *this,ggml_tensor *param_1)
{
void *pvVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int8 uVar5;
float *pfVar6;
ulong uVar7;
long lVar8;
int iVar9;
long lVar10;
uint uVar11;
int8 in_R8;
int8 in_R9;
float fVar12;
int4 uVar13;
int4 uVar14;
float local_60;
void *local_58;
void *local_50;
long local_48;
int8 local_40;
long local_38;
int8 uStack_30;
int1 local_28;
int7 uStack_27;
*(int8 *)this = 0;
uVar3 = ggml_backend_cpu_init();
*(int8 *)this = uVar3;
local_38 = ggml_tensor_overhead();
local_38 = local_38 << 2;
uStack_30 = 0;
local_28 = 1;
uVar5 = CONCAT71(uStack_27,1);
uStack_30._0_4_ = 0;
uVar13 = (int4)local_38;
uVar14 = (int4)uStack_30;
uVar4 = ggml_init();
*(int8 *)(this + 0x10) = uVar4;
uVar3 = *(int8 *)(param_1 + 0x18);
uVar5 = ggml_new_tensor_2d(uVar4,0,*(int8 *)(param_1 + 0x10),uVar3,in_R8,in_R9,uVar13,uVar14
,uVar5);
*(int8 *)(this + 0x20) = uVar5;
uVar5 = ggml_new_tensor_2d(*(int8 *)(this + 0x10),0,uVar3,uVar3);
*(int8 *)(this + 0x28) = uVar5;
uVar3 = ggml_new_tensor_1d(*(int8 *)(this + 0x10),0,uVar3);
*(int8 *)(this + 0x30) = uVar3;
ggml_set_name(*(int8 *)(this + 0x20),"dev_input");
ggml_set_name(*(int8 *)(this + 0x28),"dev_square");
ggml_set_name(*(int8 *)(this + 0x30),"dev_eigenvector");
uVar3 = ggml_backend_alloc_ctx_tensors(*(int8 *)(this + 0x10),*(int8 *)this);
*(int8 *)(this + 8) = uVar3;
uVar3 = *(int8 *)(this + 0x20);
uVar5 = *(int8 *)(param_1 + 0xf8);
uVar4 = ggml_nbytes(param_1);
ggml_backend_tensor_set(uVar3,uVar5,0,uVar4);
pfVar6 = (float *)ggml_nelements(*(int8 *)(this + 0x30));
local_40 = (ulong)local_40._4_4_ << 0x20;
std::vector<float,std::allocator<float>>::vector((ulong)&local_58,pfVar6,(allocator *)&local_40);
uVar7 = time((time_t *)0x0);
iVar2 = (int)uVar7;
iVar9 = (int)((uVar7 & 0xffffffff) * 3 >> 0x20);
uVar11 = ((uint)(iVar2 - iVar9) >> 1) + iVar9 >> 0x1e;
uVar11 = uVar11 << 0x1f | uVar11;
local_40 = (ulong)(uVar11 + iVar2 + (uint)(iVar2 + uVar11 == 0));
local_60 = 0.0;
if (local_50 != local_58) {
uVar7 = 0;
local_60 = 0.0;
do {
/* try { // try from 0012beaf to 0012beb6 has its CatchHandler @ 0012bf85 */
fVar12 = std::
generate_canonical<float,24ul,std::linear_congruential_engine<unsigned_long,16807ul,0ul,2147483647ul>>
((linear_congruential_engine *)&local_40);
fVar12 = fVar12 + _DAT_0021511c;
local_60 = local_60 + fVar12 * fVar12;
*(float *)((long)local_58 + uVar7 * 4) = fVar12;
uVar7 = uVar7 + 1;
} while (uVar7 < (ulong)((long)local_50 - (long)local_58 >> 2));
}
if (local_60 < _DAT_0021511c) {
local_60 = sqrtf(local_60);
}
else {
local_60 = SQRT(local_60);
}
pvVar1 = local_58;
if ((long)local_50 - (long)local_58 != 0) {
lVar8 = (long)local_50 - (long)local_58 >> 2;
lVar10 = 0;
do {
*(float *)((long)local_58 + lVar10 * 4) = *(float *)((long)local_58 + lVar10 * 4) / local_60;
lVar10 = lVar10 + 1;
} while (lVar8 + (ulong)(lVar8 == 0) != lVar10);
}
uVar3 = *(int8 *)(this + 0x30);
/* try { // try from 0012bf48 to 0012bf5f has its CatchHandler @ 0012bf83 */
uVar5 = ggml_nbytes(uVar3);
ggml_backend_tensor_set(uVar3,pvVar1,0,uVar5);
if (local_58 != (void *)0x0) {
operator_delete(local_58,local_48 - (long)local_58);
}
return;
}
| |
24,443 | nibble_cmp | corpus-core[P]colibri-stateless/src/chains/eth/verifier/patricia_trie.c | static int nibble_cmp(nibbles_t nibbles, bytes_t path, int* path_n_len) {
int odd = (path.data[0] & 0x10) >> 4;
int nibbles_len = path.len * 2 - (odd ? 1 : 2);
*path_n_len = nibbles_len;
for (int i = 0; i < nibbles_len; i++) {
uint8_t pn = path.data[(i + 2 - odd) >> 1] >> ((i + odd) % 2 ? 0 : 4) & 0xf;
if (nibbles.len == i || nibbles.data[i] != pn)
return i;
}
return nibbles_len;
} | O0 | c | nibble_cmp:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x30(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
andl $0x10, %eax
sarl $0x4, %eax
movl %eax, -0x34(%rbp)
movl -0x28(%rbp), %eax
shll %eax
movl -0x34(%rbp), %esi
movl $0x2, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
subl %ecx, %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x14f9d
movq -0x20(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
subl -0x34(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movl -0x3c(%rbp), %eax
addl -0x34(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl -0x44(%rbp), %eax
movl %edx, %esi
movl $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
sarl %cl, %eax
andl $0xf, %eax
movb %al, -0x3d(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x3c(%rbp), %eax
je 0x14f88
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0x3d(%rbp), %ecx
cmpl %ecx, %eax
je 0x14f90
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14fa3
jmp 0x14f92
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x14f23
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| nibble_cmp:
push rbp
mov rbp, rsp
mov [rbp+var_18], edi
mov [rbp+var_10], rsi
mov [rbp+var_28], edx
mov [rbp+var_20], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
and eax, 10h
sar eax, 4
mov [rbp+var_34], eax
mov eax, [rbp+var_28]
shl eax, 1
mov esi, [rbp+var_34]
mov ecx, 2
mov edx, 1
cmp esi, 0
cmovnz ecx, edx
sub eax, ecx
mov [rbp+var_38], eax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax], ecx
mov [rbp+var_3C], 0
loc_14F23:
mov eax, [rbp+var_3C]
cmp eax, [rbp+var_38]
jge short loc_14F9D
mov rax, [rbp+var_20]
mov ecx, [rbp+var_3C]
add ecx, 2
sub ecx, [rbp+var_34]
sar ecx, 1
movsxd rcx, ecx
movzx eax, byte ptr [rax+rcx]
mov [rbp+var_44], eax
mov eax, [rbp+var_3C]
add eax, [rbp+var_34]
mov ecx, 2
cdq
idiv ecx
mov eax, [rbp+var_44]
mov esi, edx
mov ecx, 4
xor edx, edx
cmp esi, 0
cmovnz ecx, edx
sar eax, cl
and eax, 0Fh
mov [rbp+var_3D], al
mov eax, [rbp+var_18]
cmp eax, [rbp+var_3C]
jz short loc_14F88
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_3C]
movzx eax, byte ptr [rax+rcx]
movzx ecx, [rbp+var_3D]
cmp eax, ecx
jz short loc_14F90
loc_14F88:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
jmp short loc_14FA3
loc_14F90:
jmp short $+2
loc_14F92:
mov eax, [rbp+var_3C]
add eax, 1
mov [rbp+var_3C], eax
jmp short loc_14F23
loc_14F9D:
mov eax, [rbp+var_38]
mov [rbp+var_4], eax
loc_14FA3:
mov eax, [rbp+var_4]
pop rbp
retn
| long long nibble_cmp(int a1, long long a2, int a3, _BYTE *a4, _DWORD *a5)
{
int v5; // eax
int v6; // ecx
char v7; // cl
int i; // [rsp+8h] [rbp-3Ch]
int v10; // [rsp+Ch] [rbp-38h]
int v11; // [rsp+10h] [rbp-34h]
v11 = (*a4 & 0x10) >> 4;
v5 = 2 * a3;
v6 = 2;
if ( v11 )
v6 = 1;
v10 = v5 - v6;
*a5 = v5 - v6;
for ( i = 0; i < v10; ++i )
{
v7 = 4;
if ( (v11 + i) % 2 )
v7 = 0;
if ( a1 == i || *(_BYTE *)(a2 + i) != (((int)(unsigned __int8)a4[(i + 2 - v11) >> 1] >> v7) & 0xF) )
return (unsigned int)i;
}
return (unsigned int)v10;
}
| nibble_cmp:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x18],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x28],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x10
SAR EAX,0x4
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x28]
SHL EAX,0x1
MOV ESI,dword ptr [RBP + -0x34]
MOV ECX,0x2
MOV EDX,0x1
CMP ESI,0x0
CMOVNZ ECX,EDX
SUB EAX,ECX
MOV dword ptr [RBP + -0x38],EAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x3c],0x0
LAB_00114f23:
MOV EAX,dword ptr [RBP + -0x3c]
CMP EAX,dword ptr [RBP + -0x38]
JGE 0x00114f9d
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x3c]
ADD ECX,0x2
SUB ECX,dword ptr [RBP + -0x34]
SAR ECX,0x1
MOVSXD RCX,ECX
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,dword ptr [RBP + -0x34]
MOV ECX,0x2
CDQ
IDIV ECX
MOV EAX,dword ptr [RBP + -0x44]
MOV ESI,EDX
MOV ECX,0x4
XOR EDX,EDX
CMP ESI,0x0
CMOVNZ ECX,EDX
SAR EAX,CL
AND EAX,0xf
MOV byte ptr [RBP + -0x3d],AL
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x3c]
JZ 0x00114f88
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x3c]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOVZX ECX,byte ptr [RBP + -0x3d]
CMP EAX,ECX
JZ 0x00114f90
LAB_00114f88:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00114fa3
LAB_00114f90:
JMP 0x00114f92
LAB_00114f92:
MOV EAX,dword ptr [RBP + -0x3c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x00114f23
LAB_00114f9d:
MOV EAX,dword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x4],EAX
LAB_00114fa3:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int nibble_cmp(int param_1,long param_2,int param_3,byte *param_4,int *param_5)
{
int iVar1;
int iVar2;
sbyte sVar3;
int local_44;
iVar1 = (int)(*param_4 & 0x10) >> 4;
iVar2 = 2;
if (iVar1 != 0) {
iVar2 = 1;
}
iVar2 = param_3 * 2 - iVar2;
*param_5 = iVar2;
local_44 = 0;
while( true ) {
if (iVar2 <= local_44) {
return iVar2;
}
sVar3 = 4;
if ((local_44 + iVar1) % 2 != 0) {
sVar3 = 0;
}
if ((param_1 == local_44) ||
(*(byte *)(param_2 + local_44) !=
((byte)((int)(uint)param_4[(local_44 + 2) - iVar1 >> 1] >> sVar3) & 0xf))) break;
local_44 = local_44 + 1;
}
return local_44;
}
| |
24,444 | retrieve_auto_increment | eloqsql/storage/myisam/mi_key.c | ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record)
{
ulonglong value= 0; /* Store unsigned values here */
longlong s_value= 0; /* Store signed values here */
HA_KEYSEG *keyseg= info->s->keyinfo[info->s->base.auto_key-1].seg;
const uchar *key= (uchar*) record + keyseg->start;
switch (keyseg->type) {
case HA_KEYTYPE_INT8:
s_value= (longlong) *(const signed char*) key;
break;
case HA_KEYTYPE_BINARY:
value=(ulonglong) *(uchar*) key;
break;
case HA_KEYTYPE_SHORT_INT:
s_value= (longlong) sint2korr(key);
break;
case HA_KEYTYPE_USHORT_INT:
value=(ulonglong) uint2korr(key);
break;
case HA_KEYTYPE_LONG_INT:
s_value= (longlong) sint4korr(key);
break;
case HA_KEYTYPE_ULONG_INT:
value=(ulonglong) uint4korr(key);
break;
case HA_KEYTYPE_INT24:
s_value= (longlong) sint3korr(key);
break;
case HA_KEYTYPE_UINT24:
value=(ulonglong) uint3korr(key);
break;
case HA_KEYTYPE_FLOAT: /* This shouldn't be used */
{
float f_1;
float4get(f_1,key);
/* Ignore negative values */
value = (f_1 < (float) 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_DOUBLE: /* This shouldn't be used */
{
double f_1;
float8get(f_1,key);
/* Ignore negative values */
value = (f_1 < 0.0) ? 0 : (ulonglong) f_1;
break;
}
case HA_KEYTYPE_LONGLONG:
s_value= sint8korr(key);
break;
case HA_KEYTYPE_ULONGLONG:
value= uint8korr(key);
break;
default:
DBUG_ASSERT(0);
value=0; /* Error */
break;
}
/*
The following code works because if s_value < 0 then value is 0
and if s_value == 0 then value will contain either s_value or the
correct value.
*/
return (s_value > 0) ? (ulonglong) s_value : value;
} | O0 | c | retrieve_auto_increment:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq 0x218(%rcx), %rax
movl 0x184(%rcx), %ecx
decl %ecx
imulq $0x70, %rcx, %rcx
movq 0x28(%rax,%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x18(%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x48(%rbp)
subl $0xc, %eax
ja 0xb1c4e
movq -0x48(%rbp), %rax
leaq 0xb1d7a(%rip), %rcx # 0x163800
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movswq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movzwl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xb1b2d
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl $0xff000000, %eax # imm = 0xFF000000
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
jmp 0xb1b51
movq -0x30(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cltq
movq %rax, -0x20(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movq -0x30(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x30(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x34(%rbp), %xmm0
jbe 0xb1ba5
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xb1bd4
movss -0x34(%rbp), %xmm0
movss 0xa8452(%rip), %xmm2 # 0x15a004
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rcx
cvttss2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x40(%rbp), %xmm0
jbe 0xb1bfb
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xb1c2a
movsd -0x40(%rbp), %xmm0
movsd 0xb14a8(%rip), %xmm2 # 0x1630b0
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xb1c5a
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb1c5a
jmp 0xb1c50
jmp 0xb1c52
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0xb1c6b
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0xb1c73
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| retrieve_auto_increment:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
mov [rbp+var_20], 0
mov rax, [rbp+var_8]
mov rcx, [rax]
mov rax, [rcx+218h]
mov ecx, [rcx+184h]
dec ecx
imul rcx, 70h ; 'p'
mov rax, [rax+rcx+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_28]
mov ecx, [rcx+8]
add rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
movzx eax, byte ptr [rax+18h]
add eax, 0FFFFFFFEh; switch 13 cases
mov ecx, eax
mov [rbp+var_48], rcx
sub eax, 0Ch
ja def_B1A8D; jumptable 00000000000B1A8D default case, case 7
mov rax, [rbp+var_48]
lea rcx, jpt_B1A8D
movsxd rax, ds:(jpt_B1A8D - 163800h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_B1A8F:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 14
movsx rax, byte ptr [rax]
mov [rbp+var_20], rax
jmp loc_B1C5A
loc_B1AA0:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 2
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
jmp loc_B1C5A
loc_B1AB0:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 3
movsx rax, word ptr [rax]
mov [rbp+var_20], rax
jmp loc_B1C5A
loc_B1AC1:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 8
movzx eax, word ptr [rax]
mov [rbp+var_18], rax
jmp loc_B1C5A
loc_B1AD1:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 4
movsxd rax, dword ptr [rax]
mov [rbp+var_20], rax
jmp loc_B1C5A
loc_B1AE1:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 9
mov eax, [rax]
mov [rbp+var_18], rax
jmp loc_B1C5A
loc_B1AF0:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 12
movzx eax, byte ptr [rax+2]
and eax, 80h
cmp eax, 0
jz short loc_B1B2D
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+2]
shl eax, 10h
or eax, 0FF000000h
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_4C], eax
jmp short loc_B1B51
loc_B1B2D:
mov rax, [rbp+var_30]
movzx eax, byte ptr [rax+2]
shl eax, 10h
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx]
or eax, ecx
mov [rbp+var_4C], eax
loc_B1B51:
mov eax, [rbp+var_4C]
cdqe
mov [rbp+var_20], rax
jmp loc_B1C5A
loc_B1B5F:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 13
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_30]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov [rbp+var_18], rax
jmp loc_B1C5A
loc_B1B8B:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 5
mov eax, [rax]
mov [rbp+var_34], eax
xorps xmm0, xmm0
ucomiss xmm0, [rbp+var_34]
jbe short loc_B1BA5
xor eax, eax
mov [rbp+var_58], rax
jmp short loc_B1BD4
loc_B1BA5:
movss xmm0, [rbp+var_34]
movss xmm2, cs:dword_15A004
movaps xmm1, xmm0
subss xmm1, xmm2
cvttss2si rcx, xmm1
cvttss2si rax, xmm0
mov rdx, rax
sar rdx, 3Fh
and rcx, rdx
or rax, rcx
mov [rbp+var_58], rax
loc_B1BD4:
mov rax, [rbp+var_58]
mov [rbp+var_18], rax
jmp short loc_B1C5A
loc_B1BDE:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 6
mov rax, [rax]
mov [rbp+var_40], rax
xorps xmm0, xmm0
ucomisd xmm0, [rbp+var_40]
jbe short loc_B1BFB
xor eax, eax
mov [rbp+var_60], rax
jmp short loc_B1C2A
loc_B1BFB:
movsd xmm0, [rbp+var_40]
movsd xmm2, cs:qword_1630B0
movaps xmm1, xmm0
subsd xmm1, xmm2
cvttsd2si rcx, xmm1
cvttsd2si rax, xmm0
mov rdx, rax
sar rdx, 3Fh
and rcx, rdx
or rax, rcx
mov [rbp+var_60], rax
loc_B1C2A:
mov rax, [rbp+var_60]
mov [rbp+var_18], rax
jmp short loc_B1C5A
loc_B1C34:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 10
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_B1C5A
loc_B1C41:
mov rax, [rbp+var_30]; jumptable 00000000000B1A8D case 11
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_B1C5A
def_B1A8D:
jmp short $+2; jumptable 00000000000B1A8D default case, case 7
loc_B1C50:
jmp short $+2
loc_B1C52:
mov [rbp+var_18], 0
loc_B1C5A:
cmp [rbp+var_20], 0
jle short loc_B1C6B
mov rax, [rbp+var_20]
mov [rbp+var_68], rax
jmp short loc_B1C73
loc_B1C6B:
mov rax, [rbp+var_18]
mov [rbp+var_68], rax
loc_B1C73:
mov rax, [rbp+var_68]
pop rbp
retn
| long long retrieve_auto_increment(long long a1, long long a2)
{
long long v4; // [rsp+8h] [rbp-60h]
long long v5; // [rsp+10h] [rbp-58h]
signed int v6; // [rsp+1Ch] [rbp-4Ch]
float *v7; // [rsp+38h] [rbp-30h]
long long v8; // [rsp+40h] [rbp-28h]
long long v9; // [rsp+48h] [rbp-20h]
long long v10; // [rsp+50h] [rbp-18h]
v10 = 0LL;
v9 = 0LL;
v8 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 536LL)
+ 112LL * (unsigned int)(*(_DWORD *)(*(_QWORD *)a1 + 388LL) - 1)
+ 40);
v7 = (float *)(*(unsigned int *)(v8 + 8) + a2);
switch ( *(_BYTE *)(v8 + 24) )
{
case 2:
v10 = *(unsigned __int8 *)v7;
break;
case 3:
v9 = *(__int16 *)v7;
break;
case 4:
v9 = *(int *)v7;
break;
case 5:
if ( *v7 >= 0.0 )
v5 = (unsigned int)(int)*v7;
else
v5 = 0LL;
v10 = v5;
break;
case 6:
if ( *(double *)v7 >= 0.0 )
v4 = (unsigned int)(int)*(double *)v7;
else
v4 = 0LL;
v10 = v4;
break;
case 8:
v10 = *(unsigned __int16 *)v7;
break;
case 9:
v10 = *(unsigned int *)v7;
break;
case 0xA:
v9 = *(_QWORD *)v7;
break;
case 0xB:
v10 = *(_QWORD *)v7;
break;
case 0xC:
if ( (*((_BYTE *)v7 + 2) & 0x80) != 0 )
v6 = *(unsigned __int8 *)v7 | (*((unsigned __int8 *)v7 + 1) << 8) | (*((unsigned __int8 *)v7 + 2) << 16) | 0xFF000000;
else
v6 = *(unsigned __int8 *)v7 | (*((unsigned __int8 *)v7 + 1) << 8) | (*((unsigned __int8 *)v7 + 2) << 16);
v9 = v6;
break;
case 0xD:
v10 = (*((unsigned __int8 *)v7 + 2) << 16) | (unsigned int)*(unsigned __int16 *)v7;
break;
case 0xE:
v9 = *(char *)v7;
break;
default:
v10 = 0LL;
break;
}
if ( v9 <= 0 )
return v10;
else
return v9;
}
| retrieve_auto_increment:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],0x0
MOV qword ptr [RBP + -0x20],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RCX + 0x218]
MOV ECX,dword ptr [RCX + 0x184]
DEC ECX
IMUL RCX,RCX,0x70
MOV RAX,qword ptr [RAX + RCX*0x1 + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x8]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + 0x18]
ADD EAX,-0x2
MOV ECX,EAX
MOV qword ptr [RBP + -0x48],RCX
SUB EAX,0xc
JA 0x001b1c4e
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0x263800]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_e:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX RAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b1c5a
caseD_2:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_3:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX RAX,word ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b1c5a
caseD_8:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_4:
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b1c5a
caseD_9:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_c:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001b1b2d
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
SHL EAX,0x10
OR EAX,0xff000000
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
OR EAX,ECX
MOV dword ptr [RBP + -0x4c],EAX
JMP 0x001b1b51
LAB_001b1b2d:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + 0x2]
SHL EAX,0x10
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX]
OR EAX,ECX
MOV dword ptr [RBP + -0x4c],EAX
LAB_001b1b51:
MOV EAX,dword ptr [RBP + -0x4c]
CDQE
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b1c5a
caseD_d:
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x30]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_5:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
XORPS XMM0,XMM0
UCOMISS XMM0,dword ptr [RBP + -0x34]
JBE 0x001b1ba5
XOR EAX,EAX
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001b1bd4
LAB_001b1ba5:
MOVSS XMM0,dword ptr [RBP + -0x34]
MOVSS XMM2,dword ptr [0x0025a004]
MOVAPS XMM1,XMM0
SUBSS XMM1,XMM2
CVTTSS2SI RCX,XMM1
CVTTSS2SI RAX,XMM0
MOV RDX,RAX
SAR RDX,0x3f
AND RCX,RDX
OR RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_001b1bd4:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_6:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
XORPS XMM0,XMM0
UCOMISD XMM0,qword ptr [RBP + -0x40]
JBE 0x001b1bfb
XOR EAX,EAX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001b1c2a
LAB_001b1bfb:
MOVSD XMM0,qword ptr [RBP + -0x40]
MOVSD XMM2,qword ptr [0x002630b0]
MOVAPS XMM1,XMM0
SUBSD XMM1,XMM2
CVTTSD2SI RCX,XMM1
CVTTSD2SI RAX,XMM0
MOV RDX,RAX
SAR RDX,0x3f
AND RCX,RDX
OR RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_001b1c2a:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_a:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001b1c5a
caseD_b:
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b1c5a
caseD_7:
JMP 0x001b1c50
LAB_001b1c50:
JMP 0x001b1c52
LAB_001b1c52:
MOV qword ptr [RBP + -0x18],0x0
LAB_001b1c5a:
CMP qword ptr [RBP + -0x20],0x0
JLE 0x001b1c6b
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x001b1c73
LAB_001b1c6b:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x68],RAX
LAB_001b1c73:
MOV RAX,qword ptr [RBP + -0x68]
POP RBP
RET
|
double retrieve_auto_increment(long *param_1,long param_2)
{
float fVar1;
long lVar2;
double dVar3;
double *pdVar4;
double local_70;
double local_68;
double local_60;
uint local_54;
double local_28;
double local_20;
local_20 = 0.0;
local_28 = 0.0;
lVar2 = *(long *)(*(long *)(*param_1 + 0x218) + 0x28 +
(ulong)(*(int *)(*param_1 + 0x184) - 1) * 0x70);
pdVar4 = (double *)(param_2 + (ulong)*(uint *)(lVar2 + 8));
switch(*(int1 *)(lVar2 + 0x18)) {
case 2:
local_20 = (double)(ulong)*(byte *)pdVar4;
break;
case 3:
local_28 = (double)(long)(short)*(ushort *)pdVar4;
break;
case 4:
local_28 = (double)(long)(int)*(float *)pdVar4;
break;
case 5:
fVar1 = *(float *)pdVar4;
if (0.0 <= fVar1) {
local_60 = (double)((long)fVar1 | (long)(fVar1 - DAT_0025a004) & (long)fVar1 >> 0x3f);
}
else {
local_60 = 0.0;
}
local_20 = local_60;
break;
case 6:
dVar3 = *pdVar4;
if (0.0 <= dVar3) {
local_68 = (double)((long)dVar3 | (long)(dVar3 - DAT_002630b0) & (long)dVar3 >> 0x3f);
}
else {
local_68 = 0.0;
}
local_20 = local_68;
break;
default:
local_20 = 0.0;
break;
case 8:
local_20 = (double)(ulong)*(ushort *)pdVar4;
break;
case 9:
local_20 = (double)(ulong)(uint)*(float *)pdVar4;
break;
case 10:
local_28 = *pdVar4;
break;
case 0xb:
local_20 = *pdVar4;
break;
case 0xc:
if (((ulong)*pdVar4 & 0x800000) == 0) {
local_54 = (uint)*(byte *)((long)pdVar4 + 2) << 0x10 | (uint)*(byte *)((long)pdVar4 + 1) << 8
| (uint)*(byte *)pdVar4;
}
else {
local_54 = (uint)*(byte *)((long)pdVar4 + 2) << 0x10 | 0xff000000 |
(uint)*(byte *)((long)pdVar4 + 1) << 8 | (uint)*(byte *)pdVar4;
}
local_28 = (double)(long)(int)local_54;
break;
case 0xd:
local_20 = (double)(ulong)*(uint3 *)pdVar4;
break;
case 0xe:
local_28 = (double)(long)(char)*(byte *)pdVar4;
}
if ((long)local_28 < 1) {
local_70 = local_20;
}
else {
local_70 = local_28;
}
return local_70;
}
| |
24,445 | pvio_socket_wait_io_or_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_wait_io_or_timeout(MARIADB_PVIO *pvio, my_bool is_read, int timeout)
{
int rc;
struct st_pvio_socket *csock= NULL;
#ifndef _WIN32
struct pollfd p_fd;
#else
struct timeval tv= {0,0};
fd_set fds, exc_fds;
#endif
if (!pvio || !pvio->data)
return 0;
if (pvio->mysql->options.extension &&
pvio->mysql->options.extension->io_wait != NULL) {
my_socket handle;
if (pvio_socket_get_handle(pvio, &handle))
return 0;
return pvio->mysql->options.extension->io_wait(handle, is_read, timeout);
}
csock= (struct st_pvio_socket *)pvio->data;
{
#ifndef _WIN32
memset(&p_fd, 0, sizeof(p_fd));
p_fd.fd= csock->socket;
p_fd.events= (is_read) ? POLLIN : POLLOUT;
if (!timeout)
timeout= -1;
do {
rc= poll(&p_fd, 1, timeout);
} while (rc == -1 && errno == EINTR);
if (rc == 0)
errno= ETIMEDOUT;
#else
FD_ZERO(&fds);
FD_ZERO(&exc_fds);
FD_SET(csock->socket, &fds);
FD_SET(csock->socket, &exc_fds);
if (timeout >= 0)
{
tv.tv_sec= timeout / 1000;
tv.tv_usec= (timeout % 1000) * 1000;
}
rc= select(0, (is_read) ? &fds : NULL,
(is_read) ? NULL : &fds,
&exc_fds,
(timeout >= 0) ? &tv : NULL);
if (rc == SOCKET_ERROR)
{
errno= WSAGetLastError();
}
else if (rc == 0)
{
rc= SOCKET_ERROR;
WSASetLastError(WSAETIMEDOUT);
errno= ETIMEDOUT;
}
else if (FD_ISSET(csock->socket, &exc_fds))
{
int err;
int len = sizeof(int);
if (getsockopt(csock->socket, SOL_SOCKET, SO_ERROR, (char *)&err, &len) != SOCKET_ERROR)
{
WSASetLastError(err);
errno= err;
}
rc= SOCKET_ERROR;
}
#endif
}
return rc;
} | O0 | c | pvio_socket_wait_io_or_timeout:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x458fe
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4590a
movl $0x0, -0x4(%rbp)
jmp 0x45a14
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x480(%rax)
je 0x4597e
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
cmpq $0x0, 0x140(%rax)
je 0x4597e
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x46900
cmpb $0x0, %al
je 0x45952
movl $0x0, -0x4(%rbp)
jmp 0x45a14
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x480(%rax), %rax
movq 0x140(%rax), %rax
movl -0x34(%rbp), %edi
movb -0x11(%rbp), %cl
movl -0x18(%rbp), %edx
movsbl %cl, %esi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x45a14
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x13260
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movsbl -0x11(%rbp), %edx
movl $0x4, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movw %ax, -0x2c(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x459c7
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
jmp 0x459c9
movl -0x18(%rbp), %edx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x136a0
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $-0x1, -0x1c(%rbp)
movb %al, -0x35(%rbp)
jne 0x459f6
callq 0x13050
cmpl $0x4, (%rax)
sete %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x459c9
cmpl $0x0, -0x1c(%rbp)
jne 0x45a0e
callq 0x13050
movl $0x6e, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| pvio_socket_wait_io_or_timeout:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, sil
mov [rbp+var_10], rdi
mov [rbp+var_11], al
mov [rbp+var_18], edx
mov [rbp+var_28], 0
cmp [rbp+var_10], 0
jz short loc_458FE
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_4590A
loc_458FE:
mov [rbp+var_4], 0
jmp loc_45A14
loc_4590A:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
cmp qword ptr [rax+480h], 0
jz short loc_4597E
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
cmp qword ptr [rax+140h], 0
jz short loc_4597E
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_34]
call pvio_socket_get_handle
cmp al, 0
jz short loc_45952
mov [rbp+var_4], 0
jmp loc_45A14
loc_45952:
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rax, [rax+480h]
mov rax, [rax+140h]
mov edi, [rbp+var_34]
mov cl, [rbp+var_11]
mov edx, [rbp+var_18]
movsx esi, cl
call rax
mov [rbp+var_4], eax
jmp loc_45A14
loc_4597E:
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_28], rax
lea rdi, [rbp+var_30]
xor esi, esi
mov edx, 8
call _memset
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_30], eax
movsx edx, [rbp+var_11]
mov eax, 4
mov ecx, 1
cmp edx, 0
cmovnz eax, ecx
mov [rbp+var_2C], ax
cmp [rbp+var_18], 0
jnz short loc_459C7
mov [rbp+var_18], 0FFFFFFFFh
loc_459C7:
jmp short $+2
loc_459C9:
mov edx, [rbp+var_18]
lea rdi, [rbp+var_30]
mov esi, 1
call _poll
mov [rbp+var_1C], eax
xor eax, eax
cmp [rbp+var_1C], 0FFFFFFFFh
mov [rbp+var_35], al
jnz short loc_459F6
call ___errno_location
cmp dword ptr [rax], 4
setz al
mov [rbp+var_35], al
loc_459F6:
mov al, [rbp+var_35]
test al, 1
jnz short loc_459C9
cmp [rbp+var_1C], 0
jnz short loc_45A0E
call ___errno_location
mov dword ptr [rax], 6Eh ; 'n'
loc_45A0E:
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_45A14:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long pvio_socket_wait_io_or_timeout(int **a1, char a2, unsigned int a3)
{
__int16 v3; // ax
bool v5; // [rsp+Bh] [rbp-35h]
unsigned int v6; // [rsp+Ch] [rbp-34h] BYREF
int v7; // [rsp+10h] [rbp-30h] BYREF
__int16 v8; // [rsp+14h] [rbp-2Ch]
int *v9; // [rsp+18h] [rbp-28h]
unsigned int v10; // [rsp+24h] [rbp-1Ch]
unsigned int v11; // [rsp+28h] [rbp-18h]
char v12; // [rsp+2Fh] [rbp-11h]
int **v13; // [rsp+30h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v9 = 0LL;
if ( a1 && *v13 )
{
if ( *((_QWORD *)v13[8] + 144) && *(_QWORD *)(*((_QWORD *)v13[8] + 144) + 320LL) )
{
if ( (unsigned __int8)pvio_socket_get_handle(v13, &v6) )
return 0;
else
return (unsigned int)(*(long long ( **)(_QWORD, _QWORD, _QWORD))(*((_QWORD *)v13[8] + 144) + 320LL))(
v6,
(unsigned int)v12,
v11);
}
else
{
v9 = *v13;
memset(&v7, 0LL, 8LL);
v7 = *v9;
v3 = 4;
if ( v12 )
v3 = 1;
v8 = v3;
if ( !v11 )
v11 = -1;
do
{
v10 = poll(&v7, 1LL, v11);
v5 = 0;
if ( v10 == -1 )
v5 = *(_DWORD *)__errno_location(&v7) == 4;
}
while ( v5 );
if ( !v10 )
*(_DWORD *)__errno_location(&v7) = 110;
return v10;
}
}
else
{
return 0;
}
}
| pvio_socket_wait_io_or_timeout:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,SIL
MOV qword ptr [RBP + -0x10],RDI
MOV byte ptr [RBP + -0x11],AL
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x28],0x0
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001458fe
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x0014590a
LAB_001458fe:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00145a14
LAB_0014590a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x0014597e
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
CMP qword ptr [RAX + 0x140],0x0
JZ 0x0014597e
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x34]
CALL 0x00146900
CMP AL,0x0
JZ 0x00145952
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00145a14
LAB_00145952:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x140]
MOV EDI,dword ptr [RBP + -0x34]
MOV CL,byte ptr [RBP + -0x11]
MOV EDX,dword ptr [RBP + -0x18]
MOVSX ESI,CL
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00145a14
LAB_0014597e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
LEA RDI,[RBP + -0x30]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x00113260
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x30],EAX
MOVSX EDX,byte ptr [RBP + -0x11]
MOV EAX,0x4
MOV ECX,0x1
CMP EDX,0x0
CMOVNZ EAX,ECX
MOV word ptr [RBP + -0x2c],AX
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x001459c7
MOV dword ptr [RBP + -0x18],0xffffffff
LAB_001459c7:
JMP 0x001459c9
LAB_001459c9:
MOV EDX,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x30]
MOV ESI,0x1
CALL 0x001136a0
MOV dword ptr [RBP + -0x1c],EAX
XOR EAX,EAX
CMP dword ptr [RBP + -0x1c],-0x1
MOV byte ptr [RBP + -0x35],AL
JNZ 0x001459f6
CALL 0x00113050
CMP dword ptr [RAX],0x4
SETZ AL
MOV byte ptr [RBP + -0x35],AL
LAB_001459f6:
MOV AL,byte ptr [RBP + -0x35]
TEST AL,0x1
JNZ 0x001459c9
CMP dword ptr [RBP + -0x1c],0x0
JNZ 0x00145a0e
CALL 0x00113050
MOV dword ptr [RAX],0x6e
LAB_00145a0e:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00145a14:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int pvio_socket_wait_io_or_timeout(long *param_1,char param_2,int param_3)
{
char cVar1;
int *piVar2;
bool bVar3;
int4 local_3c;
pollfd local_38;
int *local_30;
int local_24;
int local_20;
char local_19;
long *local_18;
int local_c;
local_30 = (int *)0x0;
if ((param_1 == (long *)0x0) || (*param_1 == 0)) {
local_c = 0;
}
else {
local_20 = param_3;
local_19 = param_2;
local_18 = param_1;
if ((*(long *)(param_1[8] + 0x480) == 0) ||
(*(long *)(*(long *)(param_1[8] + 0x480) + 0x140) == 0)) {
local_30 = (int *)*param_1;
memset(&local_38,0,8);
local_38.fd = *local_30;
local_38.events = 4;
if (local_19 != '\0') {
local_38.events = 1;
}
if (local_20 == 0) {
local_20 = -1;
}
do {
local_24 = poll(&local_38,1,local_20);
bVar3 = false;
if (local_24 == -1) {
piVar2 = __errno_location();
bVar3 = *piVar2 == 4;
}
} while (bVar3);
if (local_24 == 0) {
piVar2 = __errno_location();
*piVar2 = 0x6e;
}
local_c = local_24;
}
else {
cVar1 = pvio_socket_get_handle(param_1,&local_3c);
if (cVar1 == '\0') {
local_c = (**(code **)(*(long *)(local_18[8] + 0x480) + 0x140))
(local_3c,(int)local_19,local_20,local_19);
}
else {
local_c = 0;
}
}
}
return local_c;
}
| |
24,446 | ulight::Non_Owning_Buffer<char>::Non_Owning_Buffer(char*, unsigned long, void*, void (*)(void*, char*, unsigned long)) | ulight/include/ulight/impl/buffer.hpp | [[nodiscard]]
constexpr Non_Owning_Buffer(
value_type* buffer,
std::size_t capacity,
void* flush_data,
void (*flush)(void*, value_type*, std::size_t)
)
: m_buffer { buffer }
, m_capacity { capacity }
, m_flush_data { flush_data }
, m_flush { flush }
{
ULIGHT_ASSERT(m_buffer != nullptr);
ULIGHT_ASSERT(m_capacity != 0);
// We deliberately have no expectations towards m_flush_data.
ULIGHT_ASSERT(m_flush != nullptr);
} | O0 | cpp | ulight::Non_Owning_Buffer<char>::Non_Owning_Buffer(char*, unsigned long, void*, void (*)(void*, char*, unsigned long)):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq (%rax), %rax
movb $0x0, -0x31(%rbp)
cmpq $0x0, %rax
je 0x784d
jmp 0x7898
movl $0x20, %edi
callq 0x50a0
movq %rax, %rdi
movq %rdi, -0x68(%rbp)
movq %rdi, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x13ca4(%rip), %rsi # 0x1b518
callq 0x7340
movq -0x68(%rbp), %rdi
leaq 0x20c84(%rip), %rax # 0x28508
movq %rax, 0x18(%rdi)
leaq 0x20d51(%rip), %rsi # 0x285e0
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
je 0x78ac
jmp 0x78f7
movl $0x20, %edi
callq 0x50a0
movq %rax, %rdi
movq %rdi, -0x70(%rbp)
movq %rdi, -0x40(%rbp)
movb $0x1, -0x41(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x13d3e(%rip), %rsi # 0x1b611
callq 0x7340
movq -0x70(%rbp), %rdi
leaq 0x20c3d(%rip), %rax # 0x28520
movq %rax, 0x18(%rdi)
leaq 0x20cf2(%rip), %rsi # 0x285e0
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, -0x51(%rbp)
cmpq $0x0, %rax
je 0x790b
jmp 0x7956
movl $0x20, %edi
callq 0x50a0
movq %rax, %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, -0x50(%rbp)
movb $0x1, -0x51(%rbp)
movb $0x0, (%rdi)
addq $0x8, %rdi
leaq 0x13cef(%rip), %rsi # 0x1b621
callq 0x7340
movq -0x78(%rbp), %rdi
leaq 0x20bf6(%rip), %rax # 0x28538
movq %rax, 0x18(%rdi)
leaq 0x20c93(%rip), %rsi # 0x285e0
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
addq $0x80, %rsp
popq %rbp
retq
nop
| _ZN6ulight17Non_Owning_BufferIcEC2EPcmPvPFvS3_S2_mE:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov [rbp+var_60], rax
mov rcx, [rbp+var_10]
mov [rax], rcx
mov rcx, [rbp+var_18]
mov [rax+8], rcx
mov rcx, [rbp+var_20]
mov [rax+10h], rcx
mov rcx, [rbp+var_28]
mov [rax+18h], rcx
mov qword ptr [rax+20h], 0
mov rax, [rax]
mov [rbp+var_31], 0
cmp rax, 0
jz short loc_784D
jmp short loc_7898
loc_784D:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov [rbp+var_68], rdi
mov [rbp+var_30], rdi
mov [rbp+var_31], 1
mov byte ptr [rdi], 0
add rdi, 8
lea rsi, aMBufferNullptr; "m_buffer != nullptr"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_68]; void *
lea rax, off_28508; "/workspace/llm4binary/github2025/ulight"...
mov [rdi+18h], rax
lea rsi, _ZTIN6ulight15Assertion_ErrorE; lptinfo
xor eax, eax
mov edx, eax; void (*)(void *)
call ___cxa_throw
loc_7898:
mov rax, [rbp+var_60]
mov rax, [rax+8]
mov [rbp+var_41], 0
cmp rax, 0
jz short loc_78AC
jmp short loc_78F7
loc_78AC:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov [rbp+var_70], rdi
mov [rbp+var_40], rdi
mov [rbp+var_41], 1
mov byte ptr [rdi], 0
add rdi, 8
lea rsi, aMCapacity0; "m_capacity != 0"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_70]; void *
lea rax, off_28520; "/workspace/llm4binary/github2025/ulight"...
mov [rdi+18h], rax
lea rsi, _ZTIN6ulight15Assertion_ErrorE; lptinfo
xor eax, eax
mov edx, eax; void (*)(void *)
call ___cxa_throw
loc_78F7:
mov rax, [rbp+var_60]
mov rax, [rax+18h]
mov [rbp+var_51], 0
cmp rax, 0
jz short loc_790B
jmp short loc_7956
loc_790B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, rax
mov [rbp+var_78], rdi
mov [rbp+var_50], rdi
mov [rbp+var_51], 1
mov byte ptr [rdi], 0
add rdi, 8
lea rsi, aMFlushNullptr; "m_flush != nullptr"
call _ZNSt17basic_string_viewIDuSt11char_traitsIDuEEC2EPKDu; std::u8string_view::basic_string_view(char8_t const*)
mov rdi, [rbp+var_78]; void *
lea rax, off_28538; "/workspace/llm4binary/github2025/ulight"...
mov [rdi+18h], rax
lea rsi, _ZTIN6ulight15Assertion_ErrorE; lptinfo
xor eax, eax
mov edx, eax; void (*)(void *)
call ___cxa_throw
loc_7956:
add rsp, 80h
pop rbp
retn
| long long ulight::Non_Owning_Buffer<char>::Non_Owning_Buffer(
_QWORD *a1,
long long a2,
long long a3,
long long a4,
long long a5)
{
long long result; // rax
long long *v6; // [rsp+30h] [rbp-50h]
long long *v7; // [rsp+40h] [rbp-40h]
long long *exception; // [rsp+50h] [rbp-30h]
*a1 = a2;
a1[1] = a3;
a1[2] = a4;
a1[3] = a5;
a1[4] = 0LL;
if ( !*a1 )
{
exception = (long long *)__cxa_allocate_exception(0x20uLL);
*(_BYTE *)exception = 0;
std::u8string_view::basic_string_view(exception + 1, (long long)"m_buffer != nullptr");
exception[3] = (long long)off_28508;
__cxa_throw(exception, (struct type_info *)&`typeinfo for'ulight::Assertion_Error, 0LL);
}
if ( !a1[1] )
{
v7 = (long long *)__cxa_allocate_exception(0x20uLL);
*(_BYTE *)v7 = 0;
std::u8string_view::basic_string_view(v7 + 1, (long long)"m_capacity != 0");
v7[3] = (long long)off_28520;
__cxa_throw(v7, (struct type_info *)&`typeinfo for'ulight::Assertion_Error, 0LL);
}
result = a1[3];
if ( !result )
{
v6 = (long long *)__cxa_allocate_exception(0x20uLL);
*(_BYTE *)v6 = 0;
std::u8string_view::basic_string_view(v6 + 1, (long long)"m_flush != nullptr");
v6[3] = (long long)off_28538;
__cxa_throw(v6, (struct type_info *)&`typeinfo for'ulight::Assertion_Error, 0LL);
}
return result;
}
| Non_Owning_Buffer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x60],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX + 0x8],RCX
MOV RCX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],0x0
MOV RAX,qword ptr [RAX]
MOV byte ptr [RBP + -0x31],0x0
CMP RAX,0x0
JZ 0x0010784d
JMP 0x00107898
LAB_0010784d:
MOV EDI,0x20
CALL 0x001050a0
MOV RDI,RAX
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x30],RDI
MOV byte ptr [RBP + -0x31],0x1
MOV byte ptr [RDI],0x0
ADD RDI,0x8
LEA RSI,[0x11b518]
CALL 0x00107340
MOV RDI,qword ptr [RBP + -0x68]
LEA RAX,[0x128508]
MOV qword ptr [RDI + 0x18],RAX
LEA RSI,[0x1285e0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001051f0
LAB_00107898:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x8]
MOV byte ptr [RBP + -0x41],0x0
CMP RAX,0x0
JZ 0x001078ac
JMP 0x001078f7
LAB_001078ac:
MOV EDI,0x20
CALL 0x001050a0
MOV RDI,RAX
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x40],RDI
MOV byte ptr [RBP + -0x41],0x1
MOV byte ptr [RDI],0x0
ADD RDI,0x8
LEA RSI,[0x11b611]
CALL 0x00107340
MOV RDI,qword ptr [RBP + -0x70]
LEA RAX,[0x128520]
MOV qword ptr [RDI + 0x18],RAX
LEA RSI,[0x1285e0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001051f0
LAB_001078f7:
MOV RAX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RAX + 0x18]
MOV byte ptr [RBP + -0x51],0x0
CMP RAX,0x0
JZ 0x0010790b
JMP 0x00107956
LAB_0010790b:
MOV EDI,0x20
CALL 0x001050a0
MOV RDI,RAX
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x50],RDI
MOV byte ptr [RBP + -0x51],0x1
MOV byte ptr [RDI],0x0
ADD RDI,0x8
LEA RSI,[0x11b621]
CALL 0x00107340
MOV RDI,qword ptr [RBP + -0x78]
LEA RAX,[0x128538]
MOV qword ptr [RDI + 0x18],RAX
LEA RSI,[0x1285e0]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x001051f0
LAB_00107956:
ADD RSP,0x80
POP RBP
RET
|
/* ulight::Non_Owning_Buffer<char>::Non_Owning_Buffer(char*, unsigned long, void*, void (*)(void*,
char*, unsigned long)) */
void __thiscall
ulight::Non_Owning_Buffer<char>::Non_Owning_Buffer
(Non_Owning_Buffer<char> *this,char *param_1,ulong param_2,void *param_3,
_func_void_void_ptr_char_ptr_ulong *param_4)
{
int1 *puVar1;
*(char **)this = param_1;
*(ulong *)(this + 8) = param_2;
*(void **)(this + 0x10) = param_3;
*(_func_void_void_ptr_char_ptr_ulong **)(this + 0x18) = param_4;
*(int8 *)(this + 0x20) = 0;
if (*(long *)this == 0) {
puVar1 = (int1 *)__cxa_allocate_exception(0x20);
*puVar1 = 0;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(puVar1 + 8),
(uchar *)"m_buffer != nullptr");
*(int ***)(puVar1 + 0x18) = &PTR_s__workspace_llm4binary_github2025_00128508;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar1,&Assertion_Error::typeinfo,0);
}
if (*(long *)(this + 8) != 0) {
if (*(long *)(this + 0x18) != 0) {
return;
}
puVar1 = (int1 *)__cxa_allocate_exception(0x20);
*puVar1 = 0;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(puVar1 + 8),
(uchar *)"m_flush != nullptr");
*(int ***)(puVar1 + 0x18) = &PTR_s__workspace_llm4binary_github2025_00128538;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar1,&Assertion_Error::typeinfo,0);
}
puVar1 = (int1 *)__cxa_allocate_exception(0x20);
*puVar1 = 0;
std::basic_string_view<char8_t,std::char_traits<char8_t>>::basic_string_view
((basic_string_view<char8_t,std::char_traits<char8_t>> *)(puVar1 + 8),
(uchar *)"m_capacity != 0");
*(int ***)(puVar1 + 0x18) = &PTR_s__workspace_llm4binary_github2025_00128520;
/* WARNING: Subroutine does not return */
__cxa_throw(puVar1,&Assertion_Error::typeinfo,0);
}
| |
24,447 | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]) | monkey531[P]llama/common/json.hpp | size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
} | O0 | cpp | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd5d60
movq %rax, 0x38(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd5d90
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xd5dc0
testb $0x1, %al
jne 0x18dae9
jmp 0x18dbc1
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd6f30
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0x18c860
testb $0x1, %al
jne 0x18db1c
jmp 0x18dbb0
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd5e40
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xd5d90
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0xd5dc0
testb $0x1, %al
jne 0x18db59
jmp 0x18db9b
leaq 0x38(%rsp), %rdi
callq 0xd6f30
movq %rax, %rdi
callq 0xd3440
leaq 0x38(%rsp), %rdi
callq 0xd5e00
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd5e00
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xd7650
leaq 0x38(%rsp), %rdi
callq 0xd5e40
jmp 0x18db26
movq 0x18(%rsp), %rdi
callq 0x18dbe0
movq $0x1, 0x50(%rsp)
jmp 0x18dbca
jmp 0x18dbb2
leaq 0x38(%rsp), %rdi
callq 0xd5e40
jmp 0x18dac2
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
sub rsp, 58h
mov [rsp+58h+var_10], rdi
mov [rsp+58h+var_18], rsi
mov rdi, [rsp+58h+var_10]
mov [rsp+58h+var_40], rdi
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+58h+var_20], rax
loc_18DAC2:
mov rdi, [rsp+58h+var_40]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+58h+var_28], rax
lea rdi, [rsp+58h+var_20]
lea rsi, [rsp+58h+var_28]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_18DAE9
jmp loc_18DBC1
loc_18DAE9:
mov rax, [rsp+58h+var_40]
add rax, 18h
mov [rsp+58h+var_48], rax
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+58h+var_48]
mov rsi, rax
mov rdx, [rsp+58h+var_18]
call _ZNKSt8equal_toIvEclIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA11_KcEEDTeqclsr3stdE7forwardIT_Efp_Eclsr3stdE7forwardIT0_Efp0_EEOSD_OSE_
test al, 1
jnz short loc_18DB1C
jmp loc_18DBB0
loc_18DB1C:
mov rax, [rsp+58h+var_20]
mov [rsp+58h+var_30], rax
loc_18DB26:
lea rdi, [rsp+58h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
mov rdi, [rsp+58h+var_40]
mov [rsp+58h+var_50], rax
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov rdi, [rsp+58h+var_50]
mov [rsp+58h+var_38], rax
lea rsi, [rsp+58h+var_38]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_18DB59
jmp short loc_18DB9B
loc_18DB59:
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
lea rdi, [rsp+58h+var_20]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov [rsp+58h+var_58], rax
lea rdi, [rsp+58h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov rdi, [rsp+58h+var_58]
mov rsi, rax
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_18DB26
loc_18DB9B:
mov rdi, [rsp+58h+var_40]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
mov [rsp+58h+var_8], 1
jmp short loc_18DBCA
loc_18DBB0:
jmp short $+2
loc_18DBB2:
lea rdi, [rsp+58h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp loc_18DAC2
loc_18DBC1:
mov [rsp+58h+var_8], 0
loc_18DBCA:
mov rax, [rsp+58h+var_8]
add rsp, 58h
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA11_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long a1,
long long a2)
{
long long v2; // rax
void *v3; // rax
long long v4; // rax
long long v6; // [rsp+0h] [rbp-58h]
_QWORD *v7; // [rsp+8h] [rbp-50h]
long long v8; // [rsp+20h] [rbp-38h] BYREF
long long v9; // [rsp+28h] [rbp-30h] BYREF
long long v10; // [rsp+30h] [rbp-28h] BYREF
long long i; // [rsp+38h] [rbp-20h] BYREF
long long v12; // [rsp+40h] [rbp-18h]
long long v13; // [rsp+48h] [rbp-10h]
v13 = a1;
v12 = a2;
for ( i = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(a1);
;
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i) )
{
v10 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)&i,
(long long)&v10) )
return 0LL;
v2 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
if ( std::equal_to<void>::operator()<std::string const&,char const(&)[11]>(a1 + 24, v2, v12) )
break;
}
v9 = i;
while ( 1 )
{
v7 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&v9);
v8 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(a1);
if ( !__gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)v7,
(long long)&v8) )
break;
v3 = (void *)__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)&i);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(v3);
v6 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator*((long long)&i);
v4 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator*((long long)&v9);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
v6,
v4);
__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator++(&i);
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back(a1);
return 1LL;
}
| |||
24,448 | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]) | monkey531[P]llama/common/json.hpp | size_type erase(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
// Since we cannot move const Keys, re-construct them in place
for (auto next = it; ++next != this->end(); ++it)
{
it->~value_type(); // Destroy but keep allocation
new (&*it) value_type{std::move(*next)};
}
Container::pop_back();
return 1;
}
}
return 0;
} | O2 | cpp | unsigned long nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, std::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::erase<char const (&) [11], 0>(char const (&) [11]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rbx
movq 0x8(%r14), %r13
cmpq %r13, %rbx
je 0x8a88f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4550a
testb %al, %al
jne 0x8a862
addq $0x30, %rbx
jmp 0x8a844
movq %rbx, %r15
leaq 0x30(%r15), %r12
cmpq 0x8(%r14), %r12
je 0x8a887
movq %r15, %rdi
callq 0x4e41e
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f082
movq %r12, %r15
jmp 0x8a865
movq %r14, %rdi
callq 0x8a518
xorl %eax, %eax
cmpq %r13, %rbx
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
mov rbx, [rdi]
loc_8A844:
mov r13, [r14+8]
cmp rbx, r13
jz short loc_8A88F
mov rdi, rbx
mov rsi, r15
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_8A862
add rbx, 30h ; '0'
jmp short loc_8A844
loc_8A862:
mov r15, rbx
loc_8A865:
lea r12, [r15+30h]
cmp r12, [r14+8]
jz short loc_8A887
mov rdi, r15; void *
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov rdi, r15
mov rsi, r12
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2EOSG_; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::pair(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&&)
mov r15, r12
jmp short loc_8A865
loc_8A887:
mov rdi, r14
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE8pop_backEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::pop_back(void)
loc_8A88F:
xor eax, eax
cmp rbx, r13
setnz al
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| _BOOL8 ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_(
long long *a1)
{
long long i; // rbx
long long v2; // r13
char *j; // r15
for ( i = *a1; ; i += 48LL )
{
v2 = a1[1];
if ( i == v2 )
break;
if ( std::operator==<char>(i) )
{
for ( j = (char *)i; j + 48 != (char *)a1[1]; j += 48 )
{
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~pair(j);
std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::pair(
(long long)j,
(long long)(j + 48));
}
std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::pop_back((long long)a1);
return i != v2;
}
}
return i != v2;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_0018a844:
MOV R13,qword ptr [R14 + 0x8]
CMP RBX,R13
JZ 0x0018a88f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0014550a
TEST AL,AL
JNZ 0x0018a862
ADD RBX,0x30
JMP 0x0018a844
LAB_0018a862:
MOV R15,RBX
LAB_0018a865:
LEA R12,[R15 + 0x30]
CMP R12,qword ptr [R14 + 0x8]
JZ 0x0018a887
MOV RDI,R15
CALL 0x0014e41e
MOV RDI,R15
MOV RSI,R12
CALL 0x0014f082
MOV R15,R12
JMP 0x0018a865
LAB_0018a887:
MOV RDI,R14
CALL 0x0018a518
LAB_0018a88f:
XOR EAX,EAX
CMP RBX,R13
SETNZ AL
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
bool _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseIRA5_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEmOSS_
(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*param_1,char *param_2)
{
pair *ppVar1;
string *psVar2;
bool bVar3;
string *psVar4;
pair *this;
for (psVar4 = *(string **)param_1; psVar2 = *(string **)(param_1 + 8), psVar4 != psVar2;
psVar4 = psVar4 + 0x30) {
bVar3 = std::operator==(psVar4,param_2);
this = (pair *)psVar4;
if (bVar3) goto LAB_0018a865;
}
LAB_0018a88f:
return psVar4 != psVar2;
LAB_0018a865:
while (ppVar1 = (pair *)((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this + 0x30), ppVar1 != *(pair **)(param_1 + 8)) {
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this);
std::
pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::pair((pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)this,ppVar1);
this = ppVar1;
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::pop_back(param_1);
goto LAB_0018a88f;
}
| |
24,449 | pfs_set_thread_user_v1 | eloqsql/storage/perfschema/pfs.cc | void pfs_set_thread_user_v1(const char *user, int user_len)
{
pfs_dirty_state dirty_state;
PFS_thread *pfs= my_thread_get_THR_PFS();
assert((user != NULL) || (user_len == 0));
assert(user_len >= 0);
assert((uint) user_len <= sizeof(pfs->m_username));
if (unlikely(pfs == NULL))
return;
aggregate_thread(pfs, pfs->m_account, pfs->m_user, pfs->m_host);
pfs->m_session_lock.allocated_to_dirty(& dirty_state);
clear_thread_account(pfs);
if (user_len > 0)
memcpy(pfs->m_username, user, user_len);
pfs->m_username_length= user_len;
set_thread_account(pfs);
bool enabled;
bool history;
if (pfs->m_account != NULL)
{
enabled= pfs->m_account->m_enabled;
history= pfs->m_account->m_history;
}
else
{
if ((pfs->m_username_length > 0) && (pfs->m_hostname_length > 0))
{
lookup_setup_actor(pfs,
pfs->m_username, pfs->m_username_length,
pfs->m_hostname, pfs->m_hostname_length,
&enabled, &history);
}
else
{
/* There is no setting for background threads */
enabled= true;
history= true;
}
}
pfs->set_enabled(enabled);
pfs->set_history(history);
pfs->m_session_lock.dirty_to_allocated(& dirty_state);
} | O0 | cpp | pfs_set_thread_user_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x45700
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4621f
jmp 0x46372
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x1620(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x1618(%rax), %rdx
movq -0x18(%rbp), %rax
movq 0x1610(%rax), %rcx
callq 0x315c0
movq -0x18(%rbp), %rdi
addq $0xcd8, %rdi # imm = 0xCD8
leaq -0x10(%rbp), %rsi
callq 0x4e370
movq -0x18(%rbp), %rdi
callq 0x31ca0
cmpl $0x0, -0xc(%rbp)
jle 0x46284
movq -0x18(%rbp), %rdi
addq $0xcdc, %rdi # imm = 0xCDC
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x26280
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xe5c(%rax)
movq -0x18(%rbp), %rdi
callq 0x2f410
movq -0x18(%rbp), %rax
cmpq $0x0, 0x1620(%rax)
je 0x462d6
movq -0x18(%rbp), %rax
movq 0x1620(%rax), %rax
movb 0xa6c(%rax), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq 0x1620(%rax), %rax
movb 0xa6d(%rax), %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x4633c
movq -0x18(%rbp), %rax
cmpl $0x0, 0xe5c(%rax)
jbe 0x46332
movq -0x18(%rbp), %rax
cmpl $0x0, 0xf60(%rax)
jbe 0x46332
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0xcdc, %rsi # imm = 0xCDC
movq -0x18(%rbp), %rax
movl 0xe5c(%rax), %edx
movq -0x18(%rbp), %rcx
addq $0xe60, %rcx # imm = 0xE60
movq -0x18(%rbp), %rax
movl 0xf60(%rax), %r8d
leaq -0x19(%rbp), %r9
leaq -0x1a(%rbp), %rax
movq %rax, (%rsp)
callq 0x3ff10
jmp 0x4633a
movb $0x1, -0x19(%rbp)
movb $0x1, -0x1a(%rbp)
jmp 0x4633c
movq -0x18(%rbp), %rdi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x34420
movq -0x18(%rbp), %rdi
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x34450
movq -0x18(%rbp), %rdi
addq $0xcd8, %rdi # imm = 0xCD8
leaq -0x10(%rbp), %rsi
callq 0x334b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| pfs_set_thread_user_v1:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4621F
jmp loc_46372
loc_4621F:
mov rdi, [rbp+var_18]; PFS_thread *
mov rax, [rbp+var_18]
mov rsi, [rax+1620h]; PFS_account *
mov rax, [rbp+var_18]
mov rdx, [rax+1618h]; PFS_user *
mov rax, [rbp+var_18]
mov rcx, [rax+1610h]; PFS_host *
call _Z16aggregate_threadP10PFS_threadP11PFS_accountP8PFS_userP8PFS_host; aggregate_thread(PFS_thread *,PFS_account *,PFS_user *,PFS_host *)
mov rdi, [rbp+var_18]
add rdi, 0CD8h
lea rsi, [rbp+var_10]
call _ZN8pfs_lock18allocated_to_dirtyEP15pfs_dirty_state; pfs_lock::allocated_to_dirty(pfs_dirty_state *)
mov rdi, [rbp+var_18]; PFS_thread *
call _Z20clear_thread_accountP10PFS_thread; clear_thread_account(PFS_thread *)
cmp [rbp+var_C], 0
jle short loc_46284
mov rdi, [rbp+var_18]
add rdi, 0CDCh
mov rsi, [rbp+var_8]
movsxd rdx, [rbp+var_C]
call _memcpy
loc_46284:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_18]
mov [rax+0E5Ch], ecx
mov rdi, [rbp+var_18]; PFS_thread *
call _Z18set_thread_accountP10PFS_thread; set_thread_account(PFS_thread *)
mov rax, [rbp+var_18]
cmp qword ptr [rax+1620h], 0
jz short loc_462D6
mov rax, [rbp+var_18]
mov rax, [rax+1620h]
mov al, [rax+0A6Ch]
and al, 1
mov [rbp+var_19], al
mov rax, [rbp+var_18]
mov rax, [rax+1620h]
mov al, [rax+0A6Dh]
and al, 1
mov [rbp+var_1A], al
jmp short loc_4633C
loc_462D6:
mov rax, [rbp+var_18]
cmp dword ptr [rax+0E5Ch], 0
jbe short loc_46332
mov rax, [rbp+var_18]
cmp dword ptr [rax+0F60h], 0
jbe short loc_46332
mov rdi, [rbp+var_18]; PFS_thread *
mov rsi, [rbp+var_18]
add rsi, 0CDCh; char *
mov rax, [rbp+var_18]
mov edx, [rax+0E5Ch]; unsigned int
mov rcx, [rbp+var_18]
add rcx, 0E60h; char *
mov rax, [rbp+var_18]
mov r8d, [rax+0F60h]; unsigned int
lea r9, [rbp+var_19]; bool *
lea rax, [rbp+var_1A]
mov [rsp+30h+var_30], rax; bool *
call _Z18lookup_setup_actorP10PFS_threadPKcjS2_jPbS3_; lookup_setup_actor(PFS_thread *,char const*,uint,char const*,uint,bool *,bool *)
jmp short loc_4633A
loc_46332:
mov [rbp+var_19], 1
mov [rbp+var_1A], 1
loc_4633A:
jmp short $+2
loc_4633C:
mov rdi, [rbp+var_18]; this
mov al, [rbp+var_19]
and al, 1
movzx esi, al; bool
call _ZN10PFS_thread11set_enabledEb; PFS_thread::set_enabled(bool)
mov rdi, [rbp+var_18]; this
mov al, [rbp+var_1A]
and al, 1
movzx esi, al; bool
call _ZN10PFS_thread11set_historyEb; PFS_thread::set_history(bool)
mov rdi, [rbp+var_18]
add rdi, 0CD8h
lea rsi, [rbp+var_10]
call _ZN8pfs_lock18dirty_to_allocatedEPK15pfs_dirty_state; pfs_lock::dirty_to_allocated(pfs_dirty_state const*)
loc_46372:
add rsp, 30h
pop rbp
retn
| long long pfs_set_thread_user_v1(long long a1, int a2)
{
long long result; // rax
unsigned int v3; // edx
bool v4; // [rsp+16h] [rbp-1Ah] BYREF
bool v5; // [rsp+17h] [rbp-19h] BYREF
PFS_thread *THR_PFS; // [rsp+18h] [rbp-18h]
int v7; // [rsp+20h] [rbp-10h] BYREF
int v8; // [rsp+24h] [rbp-Ch]
long long v9; // [rsp+28h] [rbp-8h]
v9 = a1;
v8 = a2;
THR_PFS = (PFS_thread *)my_thread_get_THR_PFS();
result = THR_PFS == 0LL;
if ( THR_PFS )
{
aggregate_thread(
THR_PFS,
*((PFS_account **)THR_PFS + 708),
*((PFS_user **)THR_PFS + 707),
*((PFS_host **)THR_PFS + 706));
pfs_lock::allocated_to_dirty((char *)THR_PFS + 3288, &v7);
clear_thread_account((PFS_account **)THR_PFS);
if ( v8 > 0 )
memcpy((char *)THR_PFS + 3292, v9, v8);
*((_DWORD *)THR_PFS + 919) = v8;
set_thread_account(THR_PFS);
if ( *((_QWORD *)THR_PFS + 708) )
{
v5 = *(_BYTE *)(*((_QWORD *)THR_PFS + 708) + 2668LL) & 1;
v4 = *(_BYTE *)(*((_QWORD *)THR_PFS + 708) + 2669LL) & 1;
}
else if ( *((_DWORD *)THR_PFS + 919) && *((_DWORD *)THR_PFS + 984) )
{
lookup_setup_actor(
THR_PFS,
(const char *)THR_PFS + 3292,
*((_DWORD *)THR_PFS + 919),
(const char *)THR_PFS + 3680,
*((_DWORD *)THR_PFS + 984),
&v5,
&v4);
}
else
{
v5 = 1;
v4 = 1;
}
PFS_thread::set_enabled(THR_PFS, v5);
PFS_thread::set_history(THR_PFS, v4);
return pfs_lock::dirty_to_allocated((PFS_thread *)((char *)THR_PFS + 3288), &v7, v3);
}
return result;
}
| pfs_set_thread_user_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CALL 0x00145700
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014621f
JMP 0x00146372
LAB_0014621f:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX + 0x1620]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX + 0x1618]
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0x1610]
CALL 0x001315c0
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0xcd8
LEA RSI,[RBP + -0x10]
CALL 0x0014e370
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00131ca0
CMP dword ptr [RBP + -0xc],0x0
JLE 0x00146284
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0xcdc
MOV RSI,qword ptr [RBP + -0x8]
MOVSXD RDX,dword ptr [RBP + -0xc]
CALL 0x00126280
LAB_00146284:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xe5c],ECX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0012f410
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x1620],0x0
JZ 0x001462d6
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x1620]
MOV AL,byte ptr [RAX + 0xa6c]
AND AL,0x1
MOV byte ptr [RBP + -0x19],AL
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x1620]
MOV AL,byte ptr [RAX + 0xa6d]
AND AL,0x1
MOV byte ptr [RBP + -0x1a],AL
JMP 0x0014633c
LAB_001462d6:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0xe5c],0x0
JBE 0x00146332
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX + 0xf60],0x0
JBE 0x00146332
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0xcdc
MOV RAX,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RAX + 0xe5c]
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0xe60
MOV RAX,qword ptr [RBP + -0x18]
MOV R8D,dword ptr [RAX + 0xf60]
LEA R9,[RBP + -0x19]
LEA RAX,[RBP + -0x1a]
MOV qword ptr [RSP],RAX
CALL 0x0013ff10
JMP 0x0014633a
LAB_00146332:
MOV byte ptr [RBP + -0x19],0x1
MOV byte ptr [RBP + -0x1a],0x1
LAB_0014633a:
JMP 0x0014633c
LAB_0014633c:
MOV RDI,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RBP + -0x19]
AND AL,0x1
MOVZX ESI,AL
CALL 0x00134420
MOV RDI,qword ptr [RBP + -0x18]
MOV AL,byte ptr [RBP + -0x1a]
AND AL,0x1
MOVZX ESI,AL
CALL 0x00134450
MOV RDI,qword ptr [RBP + -0x18]
ADD RDI,0xcd8
LEA RSI,[RBP + -0x10]
CALL 0x001334b0
LAB_00146372:
ADD RSP,0x30
POP RBP
RET
|
void pfs_set_thread_user_v1(void *param_1,int param_2)
{
bool local_22;
bool local_21;
PFS_thread *local_20;
pfs_dirty_state local_18 [4];
int local_14;
void *local_10;
local_14 = param_2;
local_10 = param_1;
local_20 = (PFS_thread *)my_thread_get_THR_PFS();
if (local_20 != (PFS_thread *)0x0) {
aggregate_thread(local_20,*(PFS_account **)(local_20 + 0x1620),*(PFS_user **)(local_20 + 0x1618)
,*(PFS_host **)(local_20 + 0x1610));
pfs_lock::allocated_to_dirty((pfs_lock *)(local_20 + 0xcd8),local_18);
clear_thread_account(local_20);
if (0 < local_14) {
memcpy(local_20 + 0xcdc,local_10,(long)local_14);
}
*(int *)(local_20 + 0xe5c) = local_14;
set_thread_account(local_20);
if (*(long *)(local_20 + 0x1620) == 0) {
if ((*(int *)(local_20 + 0xe5c) == 0) || (*(int *)(local_20 + 0xf60) == 0)) {
local_21 = true;
local_22 = true;
}
else {
lookup_setup_actor(local_20,(char *)(local_20 + 0xcdc),*(uint *)(local_20 + 0xe5c),
(char *)(local_20 + 0xe60),*(uint *)(local_20 + 0xf60),&local_21,
&local_22);
}
}
else {
local_21 = (bool)(*(byte *)(*(long *)(local_20 + 0x1620) + 0xa6c) & 1);
local_22 = (bool)(*(byte *)(*(long *)(local_20 + 0x1620) + 0xa6d) & 1);
}
PFS_thread::set_enabled(local_20,(bool)(local_21 & 1));
PFS_thread::set_history(local_20,(bool)(local_22 & 1));
pfs_lock::dirty_to_allocated((pfs_lock *)(local_20 + 0xcd8),local_18);
}
return;
}
| |
24,450 | my_base64_decode | eloqsql/mysys/base64.c | int
my_base64_decode(const char *src_base, size_t len,
void *dst, const char **end_ptr, int flags)
{
char *d= (char*) dst;
MY_BASE64_DECODER decoder;
decoder.src= src_base;
decoder.end= src_base + len;
decoder.error= 0;
decoder.mark= 0;
for ( ; ; )
{
decoder.c= 0;
decoder.state= 0;
if (my_base64_decoder_getch(&decoder) ||
my_base64_decoder_getch(&decoder) ||
my_base64_decoder_getch(&decoder) ||
my_base64_decoder_getch(&decoder))
break;
*d++= (decoder.c >> 16) & 0xff;
*d++= (decoder.c >> 8) & 0xff;
*d++= (decoder.c >> 0) & 0xff;
if (decoder.mark)
{
d-= decoder.mark;
if (!(flags & MY_BASE64_DECODE_ALLOW_MULTIPLE_CHUNKS))
break;
decoder.mark= 0;
}
}
/* Return error if there are more non-space characters */
decoder.state= 0;
if (!my_base64_decoder_skip_spaces(&decoder))
decoder.error= 1;
if (end_ptr != NULL)
*end_ptr= decoder.src;
return decoder.error ? -1 : (int) (d - (char*) dst);
} | O3 | c | my_base64_decode:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %r15d
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x48(%rbp), %rax
movq %rdi, (%rax)
addq %rdi, %rsi
movq %rsi, 0x8(%rax)
movq $0x0, 0x10(%rax)
movw $0x0, 0x18(%rax)
movq %rax, %rdi
callq 0x27072
movq %rbx, %r13
testb %al, %al
je 0x26fd1
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2704e
movzbl (%rax), %esi
leaq 0x38cc9(%rip), %rdx # 0x5fc70
cmpb $-0x2, (%rsi,%rdx)
jne 0x26fc8
incq %rax
cmpq %rcx, %rax
je 0x2704b
movzbl (%rax), %esi
incq %rax
cmpb $-0x2, (%rsi,%rdx)
je 0x26fb0
decq %rax
movl $0x1, -0x34(%rbp)
jmp 0x2704e
leaq -0x48(%rbp), %r12
movq %rbx, %r13
movq %r12, %rdi
callq 0x27072
testb %al, %al
jne 0x26f8c
movq %r12, %rdi
callq 0x27072
testb %al, %al
jne 0x26f8c
movq %r12, %rdi
callq 0x27072
testb %al, %al
jne 0x26f8c
movb -0x36(%rbp), %al
movb %al, (%r13)
movb -0x37(%rbp), %al
movb %al, 0x1(%r13)
movb -0x38(%rbp), %al
movb %al, 0x2(%r13)
addq $0x3, %r13
movzbl -0x2f(%rbp), %eax
testq %rax, %rax
je 0x2702f
subq %rax, %r13
testb $0x1, %r15b
je 0x26f8c
movb $0x0, -0x2f(%rbp)
movl $0x0, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movq %r12, %rdi
callq 0x27072
testb %al, %al
je 0x26fd8
jmp 0x26f8c
movq %rcx, %rax
testq %r14, %r14
je 0x27056
movq %rax, (%r14)
subl %ebx, %r13d
xorl %eax, %eax
cmpl -0x34(%rbp), %eax
sbbl %eax, %eax
orl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_base64_decode:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15d, r8d
mov r14, rcx
mov rbx, rdx
lea rax, [rbp+var_48]
mov [rax], rdi
add rsi, rdi
mov [rax+8], rsi
mov qword ptr [rax+10h], 0
mov word ptr [rax+18h], 0
mov rdi, rax
call my_base64_decoder_getch
mov r13, rbx
test al, al
jz short loc_26FD1
loc_26F8C:
mov rax, [rbp+var_48]
mov rcx, [rbp+var_40]
cmp rax, rcx
jnb loc_2704E
movzx esi, byte ptr [rax]
lea rdx, from_base64_table
cmp byte ptr [rsi+rdx], 0FEh
jnz short loc_26FC8
inc rax
loc_26FB0:
cmp rax, rcx
jz loc_2704B
movzx esi, byte ptr [rax]
inc rax
cmp byte ptr [rsi+rdx], 0FEh
jz short loc_26FB0
dec rax
loc_26FC8:
mov [rbp+var_34], 1
jmp short loc_2704E
loc_26FD1:
lea r12, [rbp+var_48]
mov r13, rbx
loc_26FD8:
mov rdi, r12
call my_base64_decoder_getch
test al, al
jnz short loc_26F8C
mov rdi, r12
call my_base64_decoder_getch
test al, al
jnz short loc_26F8C
mov rdi, r12
call my_base64_decoder_getch
test al, al
jnz short loc_26F8C
mov al, byte ptr [rbp+var_38+2]
mov [r13+0], al
mov al, byte ptr [rbp+var_38+1]
mov [r13+1], al
mov al, byte ptr [rbp+var_38]
mov [r13+2], al
add r13, 3
movzx eax, [rbp+var_2F]
test rax, rax
jz short loc_2702F
sub r13, rax
test r15b, 1
jz loc_26F8C
mov [rbp+var_2F], 0
loc_2702F:
mov [rbp+var_38], 0
mov [rbp+var_30], 0
mov rdi, r12
call my_base64_decoder_getch
test al, al
jz short loc_26FD8
jmp loc_26F8C
loc_2704B:
mov rax, rcx
loc_2704E:
test r14, r14
jz short loc_27056
mov [r14], rax
loc_27056:
sub r13d, ebx
xor eax, eax
cmp eax, [rbp+var_34]
sbb eax, eax
or eax, r13d
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_base64_decode(unsigned __int8 *a1, long long a2, _BYTE *a3, unsigned __int8 **a4, char a5)
{
_BYTE *v8; // r13
unsigned __int8 *v9; // rax
unsigned __int8 *v10; // rax
long long v11; // rsi
unsigned __int8 *v13; // [rsp+8h] [rbp-48h] BYREF
unsigned __int8 *v14; // [rsp+10h] [rbp-40h]
long long v15; // [rsp+18h] [rbp-38h]
__int16 v16; // [rsp+20h] [rbp-30h]
v13 = a1;
v14 = &a1[a2];
v15 = 0LL;
v16 = 0;
LODWORD(v8) = (_DWORD)a3;
if ( !(unsigned __int8)my_base64_decoder_getch(&v13) )
{
v8 = a3;
do
{
if ( (unsigned __int8)my_base64_decoder_getch(&v13)
|| (unsigned __int8)my_base64_decoder_getch(&v13)
|| (unsigned __int8)my_base64_decoder_getch(&v13) )
{
break;
}
*v8 = BYTE2(v15);
v8[1] = BYTE1(v15);
v8[2] = v15;
v8 += 3;
if ( HIBYTE(v16) )
{
v8 -= HIBYTE(v16);
if ( (a5 & 1) == 0 )
break;
HIBYTE(v16) = 0;
}
LODWORD(v15) = 0;
LOBYTE(v16) = 0;
}
while ( !(unsigned __int8)my_base64_decoder_getch(&v13) );
}
v9 = v13;
if ( v13 < v14 )
{
if ( from_base64_table[*v13] == 0xFE )
{
v10 = v13 + 1;
while ( v10 != v14 )
{
v11 = *v10++;
if ( from_base64_table[v11] != 0xFE )
{
v9 = v10 - 1;
goto LABEL_8;
}
}
v9 = v14;
}
else
{
LABEL_8:
HIDWORD(v15) = 1;
}
}
if ( a4 )
*a4 = v9;
return ((_DWORD)v8 - (_DWORD)a3) | (unsigned int)-(HIDWORD(v15) != 0);
}
| my_base64_decode:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15D,R8D
MOV R14,RCX
MOV RBX,RDX
LEA RAX,[RBP + -0x48]
MOV qword ptr [RAX],RDI
ADD RSI,RDI
MOV qword ptr [RAX + 0x8],RSI
MOV qword ptr [RAX + 0x10],0x0
MOV word ptr [RAX + 0x18],0x0
MOV RDI,RAX
CALL 0x00127072
MOV R13,RBX
TEST AL,AL
JZ 0x00126fd1
LAB_00126f8c:
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x40]
CMP RAX,RCX
JNC 0x0012704e
MOVZX ESI,byte ptr [RAX]
LEA RDX,[0x15fc70]
CMP byte ptr [RSI + RDX*0x1],0xfe
JNZ 0x00126fc8
INC RAX
LAB_00126fb0:
CMP RAX,RCX
JZ 0x0012704b
MOVZX ESI,byte ptr [RAX]
INC RAX
CMP byte ptr [RSI + RDX*0x1],0xfe
JZ 0x00126fb0
DEC RAX
LAB_00126fc8:
MOV dword ptr [RBP + -0x34],0x1
JMP 0x0012704e
LAB_00126fd1:
LEA R12,[RBP + -0x48]
MOV R13,RBX
LAB_00126fd8:
MOV RDI,R12
CALL 0x00127072
TEST AL,AL
JNZ 0x00126f8c
MOV RDI,R12
CALL 0x00127072
TEST AL,AL
JNZ 0x00126f8c
MOV RDI,R12
CALL 0x00127072
TEST AL,AL
JNZ 0x00126f8c
MOV AL,byte ptr [RBP + -0x36]
MOV byte ptr [R13],AL
MOV AL,byte ptr [RBP + -0x37]
MOV byte ptr [R13 + 0x1],AL
MOV AL,byte ptr [RBP + -0x38]
MOV byte ptr [R13 + 0x2],AL
ADD R13,0x3
MOVZX EAX,byte ptr [RBP + -0x2f]
TEST RAX,RAX
JZ 0x0012702f
SUB R13,RAX
TEST R15B,0x1
JZ 0x00126f8c
MOV byte ptr [RBP + -0x2f],0x0
LAB_0012702f:
MOV dword ptr [RBP + -0x38],0x0
MOV byte ptr [RBP + -0x30],0x0
MOV RDI,R12
CALL 0x00127072
TEST AL,AL
JZ 0x00126fd8
JMP 0x00126f8c
LAB_0012704b:
MOV RAX,RCX
LAB_0012704e:
TEST R14,R14
JZ 0x00127056
MOV qword ptr [R14],RAX
LAB_00127056:
SUB R13D,EBX
XOR EAX,EAX
CMP EAX,dword ptr [RBP + -0x34]
SBB EAX,EAX
OR EAX,R13D
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
uint my_base64_decode(byte *param_1,long param_2,int1 *param_3,int8 *param_4,
uint param_5)
{
char cVar1;
byte *pbVar2;
int1 *puVar3;
byte *local_50;
byte *local_48;
int8 local_40;
int2 local_38;
local_48 = param_1 + param_2;
local_40 = 0;
local_38 = 0;
local_50 = param_1;
cVar1 = my_base64_decoder_getch(&local_50);
puVar3 = param_3;
if (cVar1 == '\0') {
do {
cVar1 = my_base64_decoder_getch(&local_50);
if (((cVar1 != '\0') || (cVar1 = my_base64_decoder_getch(&local_50), cVar1 != '\0')) ||
(cVar1 = my_base64_decoder_getch(&local_50), cVar1 != '\0')) break;
*puVar3 = local_40._2_1_;
puVar3[1] = local_40._1_1_;
puVar3[2] = (int1)local_40;
puVar3 = puVar3 + 3;
if ((ulong)local_38._1_1_ != 0) {
puVar3 = puVar3 + -(ulong)local_38._1_1_;
if ((param_5 & 1) == 0) break;
local_38 = 0;
}
local_40 = local_40 & 0xffffffff00000000;
local_38 = local_38 & 0xff00;
cVar1 = my_base64_decoder_getch(&local_50);
} while (cVar1 == '\0');
}
if (local_50 < local_48) {
cVar1 = from_base64_table[*local_50];
while (cVar1 == -2) {
pbVar2 = local_50 + 1;
local_50 = local_48;
if (pbVar2 == local_48) goto LAB_0012704e;
local_50 = pbVar2;
cVar1 = from_base64_table[*pbVar2];
}
local_40._4_4_ = 1;
}
LAB_0012704e:
if (param_4 != (int8 *)0x0) {
*param_4 = local_50;
}
return -(uint)(local_40._4_4_ != 0) | (int)puVar3 - (int)param_3;
}
| |
24,451 | void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::array_t&&) | monkey531[P]llama/common/json.hpp | static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
{
j.m_data.m_value.destroy(j.m_data.m_type);
j.m_data.m_type = value_t::array;
j.m_data.m_value = std::move(arr);
j.set_parents();
j.assert_invariant();
} | O3 | cpp | void nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::array_t&&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movzbl (%r14), %esi
callq 0x5dcb0
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1a890
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x582ec
nop
| _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE2EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_ONSJ_7array_tE:
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
add rdi, 8
movzx esi, byte ptr [r14]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
movups xmm0, xmmword ptr [rbx]
movups xmmword ptr [rax], xmm0
mov rcx, [rbx+10h]
mov [rax+10h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
mov qword ptr [rbx+10h], 0
mov [r14+8], rax
mov rdi, r14
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
| long long nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
unsigned __int8 *a1,
long long a2)
{
long long result; // rax
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::json_value::destroy(
(long long **)a1 + 1,
*a1);
*a1 = 2;
result = operator new(0x18uLL);
*(_OWORD *)result = *(_OWORD *)a2;
*(_QWORD *)(result + 16) = *(_QWORD *)(a2 + 16);
*(_OWORD *)a2 = 0LL;
*(_QWORD *)(a2 + 16) = 0LL;
*((_QWORD *)a1 + 1) = result;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
return result;
}
| construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
ADD RDI,0x8
MOVZX ESI,byte ptr [R14]
CALL 0x0015dcb0
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011a890
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RAX],XMM0
MOV RCX,qword ptr [RBX + 0x10]
MOV qword ptr [RAX + 0x10],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001582ec
|
/* void
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::array_t&&) */
void nlohmann::json_abi_v3_11_3::detail::
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)2>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(basic_json *param_1,array_t *param_2)
{
int8 uVar1;
int8 *puVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy((json_value *)(param_1 + 8),*param_1);
*param_1 = (basic_json)0x2;
puVar2 = (int8 *)operator_new(0x18);
uVar1 = *(int8 *)(param_2 + 8);
*puVar2 = *(int8 *)param_2;
puVar2[1] = uVar1;
puVar2[2] = *(int8 *)(param_2 + 0x10);
*(int8 *)param_2 = 0;
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(param_2 + 0x10) = 0;
*(int8 **)(param_1 + 8) = puVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_1,0));
return;
}
| |
24,452 | JS_WriteObjectTag | bluesky950520[P]quickjs/quickjs.c | static int JS_WriteObjectTag(BCWriterState *s, JSValue obj)
{
JSObject *p = JS_VALUE_GET_OBJ(obj);
uint32_t i, prop_count;
JSShape *sh;
JSShapeProperty *pr;
int pass;
JSAtom atom;
bc_put_u8(s, BC_TAG_OBJECT);
prop_count = 0;
sh = p->shape;
for(pass = 0; pass < 2; pass++) {
if (pass == 1)
bc_put_leb128(s, prop_count);
for(i = 0, pr = get_shape_prop(sh); i < sh->prop_count; i++, pr++) {
atom = pr->atom;
if (atom != JS_ATOM_NULL && (pr->flags & JS_PROP_ENUMERABLE)) {
if (pr->flags & JS_PROP_TMASK) {
JS_ThrowTypeError(s->ctx, "only value properties are supported");
goto fail;
}
if (pass == 0) {
prop_count++;
} else {
bc_put_atom(s, atom);
if (JS_WriteObjectRec(s, p->prop[i].u.value))
goto fail;
}
}
}
}
return 0;
fail:
return -1;
} | O0 | c | JS_WriteObjectTag:
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movl $0x8, %esi
callq 0x7de90
movl $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x2, 0x14(%rsp)
jge 0x7ef3a
cmpl $0x1, 0x14(%rsp)
jne 0x7ee2a
movq 0x38(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x7ea20
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x32570
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x7ef28
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x7ef08
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x1a, %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x7ef08
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0x1a, %eax
andl $0x30, %eax
cmpl $0x0, %eax
je 0x7eeb6
movq 0x38(%rsp), %rax
movq (%rax), %rdi
leaq 0x95c4a(%rip), %rsi # 0x114aeb
movb $0x0, %al
callq 0x335f0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
jmp 0x7ef44
cmpl $0x0, 0x14(%rsp)
jne 0x7eeca
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x7ef06
movq 0x38(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x7f620
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x2c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x51570
cmpl $0x0, %eax
je 0x7ef04
jmp 0x7ef44
jmp 0x7ef06
jmp 0x7ef08
jmp 0x7ef0a
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
jmp 0x7ee41
jmp 0x7ef2a
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x7ee0a
movl $0x0, 0x54(%rsp)
jmp 0x7ef4c
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
| JS_WriteObjectTag:
sub rsp, 58h
mov [rsp+58h+var_18], rsi
mov [rsp+58h+var_10], rdx
mov [rsp+58h+var_20], rdi
mov rax, [rsp+58h+var_18]
mov [rsp+58h+var_28], rax
mov rdi, [rsp+58h+var_20]
mov esi, 8
call bc_put_u8
mov [rsp+58h+var_30], 0
mov rax, [rsp+58h+var_28]
mov rax, [rax+18h]
mov [rsp+58h+var_38], rax
mov [rsp+58h+var_44], 0
loc_7EE0A:
cmp [rsp+58h+var_44], 2
jge loc_7EF3A
cmp [rsp+58h+var_44], 1
jnz short loc_7EE2A
mov rdi, [rsp+58h+var_20]
mov esi, [rsp+58h+var_30]
call bc_put_leb128
loc_7EE2A:
mov [rsp+58h+var_2C], 0
mov rdi, [rsp+58h+var_38]
call get_shape_prop
mov [rsp+58h+var_40], rax
loc_7EE41:
mov eax, [rsp+58h+var_2C]
mov rcx, [rsp+58h+var_38]
cmp eax, [rcx+28h]
jnb loc_7EF28
mov rax, [rsp+58h+var_40]
mov eax, [rax+4]
mov [rsp+58h+var_48], eax
cmp [rsp+58h+var_48], 0
jz loc_7EF08
mov rax, [rsp+58h+var_40]
mov eax, [rax]
shr eax, 1Ah
and eax, 4
cmp eax, 0
jz loc_7EF08
mov rax, [rsp+58h+var_40]
mov eax, [rax]
shr eax, 1Ah
and eax, 30h
cmp eax, 0
jz short loc_7EEB6
mov rax, [rsp+58h+var_20]
mov rdi, [rax]
lea rsi, aOnlyValuePrope; "only value properties are supported"
mov al, 0
call JS_ThrowTypeError
mov [rsp+58h+var_58], rax
mov [rsp+58h+var_50], rdx
jmp loc_7EF44
loc_7EEB6:
cmp [rsp+58h+var_44], 0
jnz short loc_7EECA
mov eax, [rsp+58h+var_30]
add eax, 1
mov [rsp+58h+var_30], eax
jmp short loc_7EF06
loc_7EECA:
mov rdi, [rsp+58h+var_20]
mov esi, [rsp+58h+var_48]
call bc_put_atom
mov rdi, [rsp+58h+var_20]
mov rax, [rsp+58h+var_28]
mov rax, [rax+20h]
mov ecx, [rsp+58h+var_2C]
shl rcx, 4
add rax, rcx
mov rsi, [rax]
mov rdx, [rax+8]
call JS_WriteObjectRec
cmp eax, 0
jz short loc_7EF04
jmp short loc_7EF44
loc_7EF04:
jmp short $+2
loc_7EF06:
jmp short $+2
loc_7EF08:
jmp short $+2
loc_7EF0A:
mov eax, [rsp+58h+var_2C]
add eax, 1
mov [rsp+58h+var_2C], eax
mov rax, [rsp+58h+var_40]
add rax, 8
mov [rsp+58h+var_40], rax
jmp loc_7EE41
loc_7EF28:
jmp short $+2
loc_7EF2A:
mov eax, [rsp+58h+var_44]
add eax, 1
mov [rsp+58h+var_44], eax
jmp loc_7EE0A
loc_7EF3A:
mov [rsp+58h+var_4], 0
jmp short loc_7EF4C
loc_7EF44:
mov [rsp+58h+var_4], 0FFFFFFFFh
loc_7EF4C:
mov eax, [rsp+58h+var_4]
add rsp, 58h
retn
| long long JS_WriteObjectTag(
long long *a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v10; // rdx
long long v11; // r8
long long v12; // r9
__m128 v13; // xmm4
__m128 v14; // xmm5
long long *v15; // rax
double v16; // xmm4_8
double v17; // xmm5_8
char v19; // [rsp+0h] [rbp-58h]
unsigned int v20; // [rsp+10h] [rbp-48h]
int v21; // [rsp+14h] [rbp-44h]
_DWORD *i; // [rsp+18h] [rbp-40h]
long long v23; // [rsp+20h] [rbp-38h]
unsigned int v24; // [rsp+28h] [rbp-30h]
unsigned int v25; // [rsp+2Ch] [rbp-2Ch]
bc_put_u8((long long)a1, 8);
v24 = 0;
v23 = *(_QWORD *)(a2 + 24);
v21 = 0;
LABEL_2:
if ( v21 >= 2 )
return 0;
if ( v21 == 1 )
bc_put_leb128((long long)a1, v24);
v25 = 0;
for ( i = (_DWORD *)get_shape_prop(v23); ; i += 2 )
{
if ( v25 >= *(_DWORD *)(v23 + 40) )
{
++v21;
goto LABEL_2;
}
v20 = i[1];
if ( !v20 || ((*i >> 26) & 4) == 0 )
goto LABEL_14;
if ( ((*i >> 26) & 0x30) != 0 )
break;
if ( v21 )
{
bc_put_atom(a1, v20);
v15 = (long long *)(16LL * v25 + *(_QWORD *)(a2 + 32));
if ( (unsigned int)JS_WriteObjectRec(a1, *v15, v15[1], a3, a4, a5, a6, v16, v17, a9, a10) )
return (unsigned int)-1;
}
else
{
++v24;
}
LABEL_14:
++v25;
}
JS_ThrowTypeError(
*a1,
(long long)"only value properties are supported",
v10,
v23,
v11,
v12,
a3,
a4,
a5,
a6,
v13,
v14,
a9,
a10,
v19);
return (unsigned int)-1;
}
| JS_WriteObjectTag:
SUB RSP,0x58
MOV qword ptr [RSP + 0x40],RSI
MOV qword ptr [RSP + 0x48],RDX
MOV qword ptr [RSP + 0x38],RDI
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x38]
MOV ESI,0x8
CALL 0x0017de90
MOV dword ptr [RSP + 0x28],0x0
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV dword ptr [RSP + 0x14],0x0
LAB_0017ee0a:
CMP dword ptr [RSP + 0x14],0x2
JGE 0x0017ef3a
CMP dword ptr [RSP + 0x14],0x1
JNZ 0x0017ee2a
MOV RDI,qword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x28]
CALL 0x0017ea20
LAB_0017ee2a:
MOV dword ptr [RSP + 0x2c],0x0
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00132570
MOV qword ptr [RSP + 0x18],RAX
LAB_0017ee41:
MOV EAX,dword ptr [RSP + 0x2c]
MOV RCX,qword ptr [RSP + 0x20]
CMP EAX,dword ptr [RCX + 0x28]
JNC 0x0017ef28
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0x10],EAX
CMP dword ptr [RSP + 0x10],0x0
JZ 0x0017ef08
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX]
SHR EAX,0x1a
AND EAX,0x4
CMP EAX,0x0
JZ 0x0017ef08
MOV RAX,qword ptr [RSP + 0x18]
MOV EAX,dword ptr [RAX]
SHR EAX,0x1a
AND EAX,0x30
CMP EAX,0x0
JZ 0x0017eeb6
MOV RAX,qword ptr [RSP + 0x38]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x214aeb]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
JMP 0x0017ef44
LAB_0017eeb6:
CMP dword ptr [RSP + 0x14],0x0
JNZ 0x0017eeca
MOV EAX,dword ptr [RSP + 0x28]
ADD EAX,0x1
MOV dword ptr [RSP + 0x28],EAX
JMP 0x0017ef06
LAB_0017eeca:
MOV RDI,qword ptr [RSP + 0x38]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x0017f620
MOV RDI,qword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x20]
MOV ECX,dword ptr [RSP + 0x2c]
SHL RCX,0x4
ADD RAX,RCX
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00151570
CMP EAX,0x0
JZ 0x0017ef04
JMP 0x0017ef44
LAB_0017ef04:
JMP 0x0017ef06
LAB_0017ef06:
JMP 0x0017ef08
LAB_0017ef08:
JMP 0x0017ef0a
LAB_0017ef0a:
MOV EAX,dword ptr [RSP + 0x2c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x2c],EAX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x8
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0017ee41
LAB_0017ef28:
JMP 0x0017ef2a
LAB_0017ef2a:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x0017ee0a
LAB_0017ef3a:
MOV dword ptr [RSP + 0x54],0x0
JMP 0x0017ef4c
LAB_0017ef44:
MOV dword ptr [RSP + 0x54],0xffffffff
LAB_0017ef4c:
MOV EAX,dword ptr [RSP + 0x54]
ADD RSP,0x58
RET
|
int4 JS_WriteObjectTag(int8 *param_1,long param_2)
{
long lVar1;
int iVar2;
int8 *puVar3;
int local_44;
uint *local_40;
int local_30;
uint local_2c;
bc_put_u8(param_1,8);
local_30 = 0;
lVar1 = *(long *)(param_2 + 0x18);
local_44 = 0;
do {
if (1 < local_44) {
return 0;
}
if (local_44 == 1) {
bc_put_leb128(param_1,local_30);
}
local_2c = 0;
local_40 = (uint *)get_shape_prop(lVar1);
for (; local_2c < *(uint *)(lVar1 + 0x28); local_2c = local_2c + 1) {
if ((local_40[1] != 0) && ((*local_40 >> 0x1a & 4) != 0)) {
if ((*local_40 >> 0x1a & 0x30) != 0) {
JS_ThrowTypeError(*param_1,"only value properties are supported");
return 0xffffffff;
}
if (local_44 == 0) {
local_30 = local_30 + 1;
}
else {
bc_put_atom(param_1,local_40[1]);
puVar3 = (int8 *)(*(long *)(param_2 + 0x20) + (ulong)local_2c * 0x10);
iVar2 = JS_WriteObjectRec(param_1,*puVar3,puVar3[1]);
if (iVar2 != 0) {
return 0xffffffff;
}
}
}
local_40 = local_40 + 2;
}
local_44 = local_44 + 1;
} while( true );
}
| |
24,453 | thr_abort_locks_for_thread | eloqsql/mysys/thr_lock.c | my_bool thr_abort_locks_for_thread(THR_LOCK *lock, my_thread_id thread_id)
{
THR_LOCK_DATA *data;
my_bool found= FALSE;
DBUG_ENTER("thr_abort_locks_for_thread");
mysql_mutex_lock(&lock->mutex);
for (data= lock->read_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting read-wait lock"));
data->type= TL_UNLOCK; /* Mark killed */
/* It's safe to signal the cond first: we're still holding the mutex. */
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0; /* Removed from list */
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->read_wait.last= data->prev;
}
}
for (data= lock->write_wait.data; data ; data= data->next)
{
if (data->owner->thread_id == thread_id) /* purecov: tested */
{
DBUG_PRINT("info",("Aborting write-wait lock"));
data->type= TL_UNLOCK;
found= TRUE;
mysql_cond_signal(data->cond);
data->cond= 0;
if (((*data->prev)= data->next))
data->next->prev= data->prev;
else
lock->write_wait.last= data->prev;
}
}
wake_up_waiters(lock);
mysql_mutex_unlock(&lock->mutex);
DBUG_RETURN(found);
} | O3 | c | thr_abort_locks_for_thread:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
addq $0x18, %rdi
cmpq $0x0, 0x58(%r14)
movq %rdi, -0x30(%rbp)
jne 0xa38f3
callq 0x29210
movq 0x60(%r14), %r13
testq %r13, %r13
je 0xa3844
leaq 0x68(%r14), %rbx
xorl %r12d, %r12d
movq (%r13), %rax
cmpq %r15, 0x8(%rax)
jne 0xa3827
movl $0x0, 0x40(%r13)
movq 0x20(%r13), %r12
movq 0x30(%r12), %rdi
testq %rdi, %rdi
jne 0xa3832
movq %r12, %rdi
callq 0x295c0
movq $0x0, 0x20(%r13)
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
movq %rax, (%rcx)
leaq 0x10(%rax), %rcx
testq %rax, %rax
movq 0x10(%r13), %rax
cmoveq %rbx, %rcx
movq %rax, (%rcx)
movb $0x1, %r12b
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0xa37d7
jmp 0xa3847
leaq 0x2e27d7(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xa37f7
xorl %r12d, %r12d
movq 0x80(%r14), %r13
testq %r13, %r13
je 0xa38c7
leaq 0x88(%r14), %rbx
movq (%r13), %rax
cmpq %r15, 0x8(%rax)
jne 0xa38aa
movl $0x0, 0x40(%r13)
movq 0x20(%r13), %r12
movq 0x30(%r12), %rdi
testq %rdi, %rdi
jne 0xa38b5
movq %r12, %rdi
callq 0x295c0
movq $0x0, 0x20(%r13)
movq 0x8(%r13), %rax
movq 0x10(%r13), %rcx
movq %rax, (%rcx)
leaq 0x10(%rax), %rcx
testq %rax, %rax
movq 0x10(%r13), %rax
cmoveq %rbx, %rcx
movq %rax, (%rcx)
movb $0x1, %r12b
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0xa385a
jmp 0xa38c7
leaq 0x2e2754(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x170(%rax)
jmp 0xa387a
movq %r14, %rdi
callq 0xa29c1
movq 0x58(%r14), %rdi
testq %rdi, %rdi
jne 0xa3909
movq -0x30(%rbp), %rdi
callq 0x291d0
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38b77(%rip), %rsi # 0xdc471
movl $0x545, %edx # imm = 0x545
callq 0x2eb7f
jmp 0xa37c7
leaq 0x2e2700(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xa38d8
| thr_abort_locks_for_thread:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
add rdi, 18h
cmp qword ptr [r14+58h], 0
mov [rbp+var_30], rdi
jnz loc_A38F3
call _pthread_mutex_lock
loc_A37C7:
mov r13, [r14+60h]
test r13, r13
jz short loc_A3844
lea rbx, [r14+68h]
xor r12d, r12d
loc_A37D7:
mov rax, [r13+0]
cmp [rax+8], r15
jnz short loc_A3827
mov dword ptr [r13+40h], 0
mov r12, [r13+20h]
mov rdi, [r12+30h]
test rdi, rdi
jnz short loc_A3832
loc_A37F7:
mov rdi, r12
call _pthread_cond_signal
mov qword ptr [r13+20h], 0
mov rax, [r13+8]
mov rcx, [r13+10h]
mov [rcx], rax
lea rcx, [rax+10h]
test rax, rax
mov rax, [r13+10h]
cmovz rcx, rbx
mov [rcx], rax
mov r12b, 1
loc_A3827:
mov r13, [r13+8]
test r13, r13
jnz short loc_A37D7
jmp short loc_A3847
loc_A3832:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_A37F7
loc_A3844:
xor r12d, r12d
loc_A3847:
mov r13, [r14+80h]
test r13, r13
jz short loc_A38C7
lea rbx, [r14+88h]
loc_A385A:
mov rax, [r13+0]
cmp [rax+8], r15
jnz short loc_A38AA
mov dword ptr [r13+40h], 0
mov r12, [r13+20h]
mov rdi, [r12+30h]
test rdi, rdi
jnz short loc_A38B5
loc_A387A:
mov rdi, r12
call _pthread_cond_signal
mov qword ptr [r13+20h], 0
mov rax, [r13+8]
mov rcx, [r13+10h]
mov [rcx], rax
lea rcx, [rax+10h]
test rax, rax
mov rax, [r13+10h]
cmovz rcx, rbx
mov [rcx], rax
mov r12b, 1
loc_A38AA:
mov r13, [r13+8]
test r13, r13
jnz short loc_A385A
jmp short loc_A38C7
loc_A38B5:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+170h]
jmp short loc_A387A
loc_A38C7:
mov rdi, r14
call wake_up_waiters
mov rdi, [r14+58h]
test rdi, rdi
jnz short loc_A3909
loc_A38D8:
mov rdi, [rbp+var_30]
call _pthread_mutex_unlock
mov eax, r12d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_A38F3:
lea rsi, aWorkspaceLlm4b_23; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 545h
call psi_mutex_lock
jmp loc_A37C7
loc_A3909:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_A38D8
| long long thr_abort_locks_for_thread(_QWORD *a1, long long a2)
{
long long v3; // rdi
long long v4; // r13
long long v5; // r12
long long v6; // rdi
long long v7; // rax
_QWORD *v8; // rcx
long long i; // r13
long long v10; // rdi
long long v11; // rax
_QWORD *v12; // rcx
long long v13; // rdi
long long v15; // [rsp+0h] [rbp-30h]
v3 = (long long)(a1 + 3);
v15 = v3;
if ( a1[11] )
psi_mutex_lock(v3, (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x545u);
else
pthread_mutex_lock(v3);
v4 = a1[12];
if ( v4 )
{
LODWORD(v5) = 0;
do
{
if ( *(_QWORD *)(*(_QWORD *)v4 + 8LL) == a2 )
{
*(_DWORD *)(v4 + 64) = 0;
v5 = *(_QWORD *)(v4 + 32);
v6 = *(_QWORD *)(v5 + 48);
if ( v6 )
((void ( *)(long long))PSI_server[46])(v6);
pthread_cond_signal(v5);
*(_QWORD *)(v4 + 32) = 0LL;
v7 = *(_QWORD *)(v4 + 8);
**(_QWORD **)(v4 + 16) = v7;
v8 = (_QWORD *)(v7 + 16);
if ( !v7 )
v8 = a1 + 13;
*v8 = *(_QWORD *)(v4 + 16);
LOBYTE(v5) = 1;
}
v4 = *(_QWORD *)(v4 + 8);
}
while ( v4 );
}
else
{
LODWORD(v5) = 0;
}
for ( i = a1[16]; i; i = *(_QWORD *)(i + 8) )
{
if ( *(_QWORD *)(*(_QWORD *)i + 8LL) == a2 )
{
*(_DWORD *)(i + 64) = 0;
v5 = *(_QWORD *)(i + 32);
v10 = *(_QWORD *)(v5 + 48);
if ( v10 )
((void ( *)(long long))PSI_server[46])(v10);
pthread_cond_signal(v5);
*(_QWORD *)(i + 32) = 0LL;
v11 = *(_QWORD *)(i + 8);
**(_QWORD **)(i + 16) = v11;
v12 = (_QWORD *)(v11 + 16);
if ( !v11 )
v12 = a1 + 17;
*v12 = *(_QWORD *)(i + 16);
LOBYTE(v5) = 1;
}
}
wake_up_waiters((long long)a1);
v13 = a1[11];
if ( v13 )
((void ( *)(long long))PSI_server[44])(v13);
pthread_mutex_unlock(v15);
return (unsigned int)v5;
}
| thr_abort_locks_for_thread:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
ADD RDI,0x18
CMP qword ptr [R14 + 0x58],0x0
MOV qword ptr [RBP + -0x30],RDI
JNZ 0x001a38f3
CALL 0x00129210
LAB_001a37c7:
MOV R13,qword ptr [R14 + 0x60]
TEST R13,R13
JZ 0x001a3844
LEA RBX,[R14 + 0x68]
XOR R12D,R12D
LAB_001a37d7:
MOV RAX,qword ptr [R13]
CMP qword ptr [RAX + 0x8],R15
JNZ 0x001a3827
MOV dword ptr [R13 + 0x40],0x0
MOV R12,qword ptr [R13 + 0x20]
MOV RDI,qword ptr [R12 + 0x30]
TEST RDI,RDI
JNZ 0x001a3832
LAB_001a37f7:
MOV RDI,R12
CALL 0x001295c0
MOV qword ptr [R13 + 0x20],0x0
MOV RAX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [R13 + 0x10]
MOV qword ptr [RCX],RAX
LEA RCX,[RAX + 0x10]
TEST RAX,RAX
MOV RAX,qword ptr [R13 + 0x10]
CMOVZ RCX,RBX
MOV qword ptr [RCX],RAX
MOV R12B,0x1
LAB_001a3827:
MOV R13,qword ptr [R13 + 0x8]
TEST R13,R13
JNZ 0x001a37d7
JMP 0x001a3847
LAB_001a3832:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001a37f7
LAB_001a3844:
XOR R12D,R12D
LAB_001a3847:
MOV R13,qword ptr [R14 + 0x80]
TEST R13,R13
JZ 0x001a38c7
LEA RBX,[R14 + 0x88]
LAB_001a385a:
MOV RAX,qword ptr [R13]
CMP qword ptr [RAX + 0x8],R15
JNZ 0x001a38aa
MOV dword ptr [R13 + 0x40],0x0
MOV R12,qword ptr [R13 + 0x20]
MOV RDI,qword ptr [R12 + 0x30]
TEST RDI,RDI
JNZ 0x001a38b5
LAB_001a387a:
MOV RDI,R12
CALL 0x001295c0
MOV qword ptr [R13 + 0x20],0x0
MOV RAX,qword ptr [R13 + 0x8]
MOV RCX,qword ptr [R13 + 0x10]
MOV qword ptr [RCX],RAX
LEA RCX,[RAX + 0x10]
TEST RAX,RAX
MOV RAX,qword ptr [R13 + 0x10]
CMOVZ RCX,RBX
MOV qword ptr [RCX],RAX
MOV R12B,0x1
LAB_001a38aa:
MOV R13,qword ptr [R13 + 0x8]
TEST R13,R13
JNZ 0x001a385a
JMP 0x001a38c7
LAB_001a38b5:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x170]
JMP 0x001a387a
LAB_001a38c7:
MOV RDI,R14
CALL 0x001a29c1
MOV RDI,qword ptr [R14 + 0x58]
TEST RDI,RDI
JNZ 0x001a3909
LAB_001a38d8:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001291d0
MOV EAX,R12D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001a38f3:
LEA RSI,[0x1dc471]
MOV EDX,0x545
CALL 0x0012eb7f
JMP 0x001a37c7
LAB_001a3909:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001a38d8
|
ulong thr_abort_locks_for_thread(long param_1,long param_2)
{
pthread_cond_t *ppVar1;
long lVar2;
long *plVar3;
pthread_mutex_t *__mutex;
ulong uVar4;
long *plVar5;
__mutex = (pthread_mutex_t *)(param_1 + 0x18);
if (*(long *)(param_1 + 0x58) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x545);
}
plVar5 = *(long **)(param_1 + 0x60);
if (plVar5 == (long *)0x0) {
uVar4 = 0;
}
else {
uVar4 = 0;
do {
if (*(long *)(*plVar5 + 8) == param_2) {
*(int4 *)(plVar5 + 8) = 0;
ppVar1 = (pthread_cond_t *)plVar5[4];
if (ppVar1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(ppVar1);
plVar5[4] = 0;
lVar2 = plVar5[1];
*(long *)plVar5[2] = lVar2;
plVar3 = (long *)(lVar2 + 0x10);
if (lVar2 == 0) {
plVar3 = (long *)(param_1 + 0x68);
}
*plVar3 = plVar5[2];
uVar4 = CONCAT71((int7)((ulong)ppVar1 >> 8),1);
}
plVar5 = (long *)plVar5[1];
} while (plVar5 != (long *)0x0);
}
plVar5 = *(long **)(param_1 + 0x80);
if (plVar5 != (long *)0x0) {
do {
if (*(long *)(*plVar5 + 8) == param_2) {
*(int4 *)(plVar5 + 8) = 0;
ppVar1 = (pthread_cond_t *)plVar5[4];
if (ppVar1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))();
}
pthread_cond_signal(ppVar1);
plVar5[4] = 0;
lVar2 = plVar5[1];
*(long *)plVar5[2] = lVar2;
plVar3 = (long *)(lVar2 + 0x10);
if (lVar2 == 0) {
plVar3 = (long *)(param_1 + 0x88);
}
*plVar3 = plVar5[2];
uVar4 = CONCAT71((int7)((ulong)ppVar1 >> 8),1);
}
plVar5 = (long *)plVar5[1];
} while (plVar5 != (long *)0x0);
}
wake_up_waiters(param_1);
if (*(long *)(param_1 + 0x58) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
return uVar4 & 0xffffffff;
}
| |
24,454 | net_field_length | eloqsql/libmariadb/libmariadb/mariadb_lib.c | ulong
net_field_length(uchar **packet)
{
reg1 uchar *pos= *packet;
if (*pos < 251)
{
(*packet)++;
return (ulong) *pos;
}
if (*pos == 251)
{
(*packet)++;
return NULL_LENGTH;
}
if (*pos == 252)
{
(*packet)+=3;
return (ulong) uint2korr(pos+1);
}
if (*pos == 253)
{
(*packet)+=4;
return (ulong) uint3korr(pos+1);
}
(*packet)+=9; /* Must be 254 when here */
return (ulong) uint4korr(pos+1);
} | O0 | c | net_field_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfb, %eax
jge 0x1631f
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x8(%rbp)
jmp 0x16414
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfb, %eax
jne 0x16348
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x16414
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfc, %eax
jne 0x1638b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x3, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzwl %ax, %eax
movq %rax, -0x8(%rbp)
jmp 0x16414
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xfd, %eax
jne 0x163d1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x16414
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x9, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| net_field_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FBh
jge short loc_1631F
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
mov [rbp+var_8], rax
jmp loc_16414
loc_1631F:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FBh
jnz short loc_16348
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp loc_16414
loc_16348:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FCh
jnz short loc_1638B
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 3
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
movzx eax, ax
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
movzx ecx, cx
shl ecx, 8
add eax, ecx
movzx eax, ax
mov [rbp+var_8], rax
jmp loc_16414
loc_1638B:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
cmp eax, 0FDh
jnz short loc_163D1
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 4
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+3]
shl ecx, 10h
add eax, ecx
mov eax, eax
mov [rbp+var_8], rax
jmp short loc_16414
loc_163D1:
mov rax, [rbp+var_10]
mov rcx, [rax]
add rcx, 9
mov [rax], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+3]
shl ecx, 10h
add eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+4]
shl ecx, 18h
add eax, ecx
mov eax, eax
mov [rbp+var_8], rax
loc_16414:
mov rax, [rbp+var_8]
pop rbp
retn
| long long net_field_length(unsigned __int8 **a1)
{
int v1; // eax
int v2; // ecx
unsigned __int8 *v4; // [rsp+0h] [rbp-18h]
v4 = *a1;
if ( **a1 >= 0xFBu )
{
if ( *v4 == 251 )
{
++*a1;
return -1LL;
}
else if ( *v4 == 252 )
{
*a1 += 3;
return (unsigned __int16)((v4[2] << 8) + v4[1]);
}
else
{
if ( *v4 == 253 )
{
*a1 += 4;
v1 = (v4[2] << 8) + v4[1];
v2 = v4[3] << 16;
}
else
{
*a1 += 9;
v1 = (v4[3] << 16) + (v4[2] << 8) + v4[1];
v2 = v4[4] << 24;
}
return (unsigned int)(v2 + v1);
}
}
else
{
++*a1;
return *v4;
}
}
| net_field_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfb
JGE 0x0011631f
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00116414
LAB_0011631f:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfb
JNZ 0x00116348
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00116414
LAB_00116348:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfc
JNZ 0x0011638b
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x3
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
MOVZX ECX,CX
SHL ECX,0x8
ADD EAX,ECX
MOVZX EAX,AX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00116414
LAB_0011638b:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xfd
JNZ 0x001163d1
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x4
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL ECX,0x10
ADD EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00116414
LAB_001163d1:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
ADD RCX,0x9
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x1]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x3]
SHL ECX,0x10
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x4]
SHL ECX,0x18
ADD EAX,ECX
MOV EAX,EAX
MOV qword ptr [RBP + -0x8],RAX
LAB_00116414:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong net_field_length(long *param_1)
{
byte *pbVar1;
ulong local_10;
pbVar1 = (byte *)*param_1;
if (*pbVar1 < 0xfb) {
*param_1 = *param_1 + 1;
local_10 = (ulong)*pbVar1;
}
else if (*pbVar1 == 0xfb) {
*param_1 = *param_1 + 1;
local_10 = 0xffffffffffffffff;
}
else if (*pbVar1 == 0xfc) {
*param_1 = *param_1 + 3;
local_10 = (ulong)((uint)pbVar1[1] + (uint)pbVar1[2] * 0x100 & 0xffff);
}
else if (*pbVar1 == 0xfd) {
*param_1 = *param_1 + 4;
local_10 = (ulong)((uint)pbVar1[1] + (uint)pbVar1[2] * 0x100 + (uint)pbVar1[3] * 0x10000);
}
else {
*param_1 = *param_1 + 9;
local_10 = (ulong)((uint)pbVar1[1] + (uint)pbVar1[2] * 0x100 + (uint)pbVar1[3] * 0x10000 +
(uint)pbVar1[4] * 0x1000000);
}
return local_10;
}
| |
24,455 | ma_pvio_init | eloqsql/libmariadb/libmariadb/ma_pvio.c | MARIADB_PVIO *ma_pvio_init(MA_PVIO_CINFO *cinfo)
{
/* check connection type and load the required plugin.
* Currently we support the following pvio types:
* pvio_socket
* pvio_namedpipe
* pvio_sharedmed
*/
const char *pvio_plugins[] = {"pvio_socket", "pvio_npipe", "pvio_shmem"};
int type;
MARIADB_PVIO_PLUGIN *pvio_plugin;
MARIADB_PVIO *pvio= NULL;
switch (cinfo->type)
{
case PVIO_TYPE_UNIXSOCKET:
case PVIO_TYPE_SOCKET:
type= 0;
break;
#ifdef _WIN32
case PVIO_TYPE_NAMEDPIPE:
type= 1;
break;
case PVIO_TYPE_SHAREDMEM:
type= 2;
break;
#endif
default:
return NULL;
}
if (!(pvio_plugin= (MARIADB_PVIO_PLUGIN *)
mysql_client_find_plugin(cinfo->mysql,
pvio_plugins[type],
MARIADB_CLIENT_PVIO_PLUGIN)))
{
/* error already set in mysql_client_find_plugin */
return NULL;
}
/* coverity[var_deref_op] */
if (!(pvio= (MARIADB_PVIO *)calloc(1, sizeof(MARIADB_PVIO))))
{
my_set_error(cinfo->mysql, CR_OUT_OF_MEMORY, unknown_sqlstate, 0);
return NULL;
}
/* register error routine and methods */
pvio->methods= pvio_plugin->methods;
pvio->set_error= my_set_error;
pvio->type= cinfo->type;
/* set timeout to connect timeout - after successful connect we will set
* correct values for read and write */
if (pvio->methods->set_timeout)
{
pvio->methods->set_timeout(pvio, PVIO_CONNECT_TIMEOUT, cinfo->mysql->options.connect_timeout);
pvio->methods->set_timeout(pvio, PVIO_READ_TIMEOUT, cinfo->mysql->options.connect_timeout);
pvio->methods->set_timeout(pvio, PVIO_WRITE_TIMEOUT, cinfo->mysql->options.connect_timeout);
}
if (!(pvio->cache= calloc(1, PVIO_READ_AHEAD_CACHE_SIZE)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_OUT_OF_MEMORY, unknown_sqlstate, 0);
free(pvio);
return NULL;
}
pvio->cache_size= 0;
pvio->cache_pos= pvio->cache;
return pvio;
} | O0 | c | ma_pvio_init:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1e0f8d(%rip), %rax # 0x235b50
movq %rax, -0x20(%rbp)
movaps 0x1e0f72(%rip), %xmm0 # 0x235b40
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
ja 0x54bf1
jmp 0x54be8
movl $0x0, -0x34(%rbp)
jmp 0x54bfe
movq $0x0, -0x8(%rbp)
jmp 0x54da3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movslq -0x34(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rsi
movl $0x65, %edx
callq 0x67e10
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x54c30
movq $0x0, -0x8(%rbp)
jmp 0x54da3
movl $0x1, %edi
movl $0x70, %esi
callq 0x388c0
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
jne 0x54c78
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1f4d78(%rip), %rax # 0x2499d0
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x47bd0
movq $0x0, -0x8(%rbp)
jmp 0x54da3
movq -0x40(%rbp), %rax
movq 0x58(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x48(%rbp), %rax
leaq -0xd0c3(%rip), %rcx # 0x47bd0
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, (%rax)
je 0x54d1c
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0x390(%rcx), %edx
xorl %esi, %esi
callq *%rax
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0x390(%rcx), %edx
movl $0x1, %esi
callq *%rax
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movl 0x390(%rcx), %edx
movl $0x2, %esi
callq *%rax
movl $0x1, %edi
movl $0x4000, %esi # imm = 0x4000
callq 0x388c0
movq -0x48(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x54d7f
movq -0x48(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x54d6c
movq -0x48(%rbp), %rax
movq 0x50(%rax), %r8
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1f4c75(%rip), %rax # 0x2499d0
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq *%r8
movq -0x48(%rbp), %rdi
callq 0x381b0
movq $0x0, -0x8(%rbp)
jmp 0x54da3
movq -0x48(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| ma_pvio_init:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_10], rdi
mov rax, cs:off_235B50; "pvio_shmem"
mov [rbp+var_20], rax
movaps xmm0, xmmword ptr cs:off_235B40; "pvio_socket"
movaps [rbp+var_30], xmm0
mov [rbp+var_48], 0
mov rax, [rbp+var_10]
mov eax, [rax+14h]
sub eax, 1
ja short loc_54BF1
jmp short $+2
loc_54BE8:
mov [rbp+var_34], 0
jmp short loc_54BFE
loc_54BF1:
mov [rbp+var_8], 0
jmp loc_54DA3
loc_54BFE:
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
movsxd rax, [rbp+var_34]
mov rsi, qword ptr [rbp+rax*8+var_30]
mov edx, 65h ; 'e'
call mysql_client_find_plugin
mov [rbp+var_40], rax
cmp rax, 0
jnz short loc_54C30
mov [rbp+var_8], 0
jmp loc_54DA3
loc_54C30:
mov edi, 1
mov esi, 70h ; 'p'
call _calloc
mov [rbp+var_48], rax
cmp rax, 0
jnz short loc_54C78
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov [rbp+var_8], 0
jmp loc_54DA3
loc_54C78:
mov rax, [rbp+var_40]
mov rcx, [rax+58h]
mov rax, [rbp+var_48]
mov [rax+48h], rcx
mov rax, [rbp+var_48]
lea rcx, my_set_error
mov [rax+50h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+14h]
mov rax, [rbp+var_48]
mov [rax+20h], ecx
mov rax, [rbp+var_48]
mov rax, [rax+48h]
cmp qword ptr [rax], 0
jz short loc_54D1C
mov rax, [rbp+var_48]
mov rax, [rax+48h]
mov rax, [rax]
mov rdi, [rbp+var_48]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov edx, [rcx+390h]
xor esi, esi
call rax
mov rax, [rbp+var_48]
mov rax, [rax+48h]
mov rax, [rax]
mov rdi, [rbp+var_48]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov edx, [rcx+390h]
mov esi, 1
call rax
mov rax, [rbp+var_48]
mov rax, [rax+48h]
mov rax, [rax]
mov rdi, [rbp+var_48]
mov rcx, [rbp+var_10]
mov rcx, [rcx+18h]
mov edx, [rcx+390h]
mov esi, 2
call rax
loc_54D1C:
mov edi, 1
mov esi, 4000h
call _calloc
mov rcx, [rbp+var_48]
mov [rcx+8], rax
cmp rax, 0
jnz short loc_54D7F
mov rax, [rbp+var_48]
cmp qword ptr [rax+50h], 0
jz short loc_54D6C
mov rax, [rbp+var_48]
mov r8, [rax+50h]
mov rax, [rbp+var_10]
mov rdi, [rax+18h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor eax, eax
mov ecx, eax
mov al, 0
call r8
loc_54D6C:
mov rdi, [rbp+var_48]
call _free
mov [rbp+var_8], 0
jmp short loc_54DA3
loc_54D7F:
mov rax, [rbp+var_48]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_48]
mov rcx, [rax+8]
mov rax, [rbp+var_48]
mov [rax+10h], rcx
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
loc_54DA3:
mov rax, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long ma_pvio_init(long long a1)
{
long long plugin; // rax
long long v2; // rax
long long v4; // [rsp+8h] [rbp-48h]
long long v5; // [rsp+10h] [rbp-40h]
if ( *(_DWORD *)(a1 + 20) > 1u )
return 0LL;
plugin = mysql_client_find_plugin(*(_QWORD *)(a1 + 24), "pvio_socket", 101LL);
v5 = plugin;
if ( !plugin )
return 0LL;
v4 = calloc(1LL, 112LL);
if ( v4 )
{
*(_QWORD *)(v4 + 72) = *(_QWORD *)(v5 + 88);
*(_QWORD *)(v4 + 80) = my_set_error;
*(_DWORD *)(v4 + 32) = *(_DWORD *)(a1 + 20);
if ( **(_QWORD **)(v4 + 72) )
{
(**(void ( ***)(long long, _QWORD, _QWORD))(v4 + 72))(
v4,
0LL,
*(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
(**(void ( ***)(long long, long long, _QWORD))(v4 + 72))(
v4,
1LL,
*(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
(**(void ( ***)(long long, long long, _QWORD))(v4 + 72))(
v4,
2LL,
*(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
}
v2 = calloc(1LL, 0x4000LL);
*(_QWORD *)(v4 + 8) = v2;
if ( v2 )
{
*(_QWORD *)(v4 + 24) = 0LL;
*(_QWORD *)(v4 + 16) = *(_QWORD *)(v4 + 8);
return v4;
}
else
{
if ( *(_QWORD *)(v4 + 80) )
(*(void ( **)(_QWORD, long long, char *, _QWORD))(v4 + 80))(
*(_QWORD *)(a1 + 24),
2008LL,
SQLSTATE_UNKNOWN,
0LL);
free(v4);
return 0LL;
}
}
else
{
my_set_error(*(_QWORD *)(a1 + 24), 0x7D8u, (long long)SQLSTATE_UNKNOWN, 0LL);
return 0LL;
}
}
| ma_pvio_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [0x00335b50]
MOV qword ptr [RBP + -0x20],RAX
MOVAPS XMM0,xmmword ptr [0x00335b40]
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOV qword ptr [RBP + -0x48],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x14]
SUB EAX,0x1
JA 0x00154bf1
JMP 0x00154be8
LAB_00154be8:
MOV dword ptr [RBP + -0x34],0x0
JMP 0x00154bfe
LAB_00154bf1:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00154da3
LAB_00154bfe:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
MOVSXD RAX,dword ptr [RBP + -0x34]
MOV RSI,qword ptr [RBP + RAX*0x8 + -0x30]
MOV EDX,0x65
CALL 0x00167e10
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JNZ 0x00154c30
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00154da3
LAB_00154c30:
MOV EDI,0x1
MOV ESI,0x70
CALL 0x001388c0
MOV qword ptr [RBP + -0x48],RAX
CMP RAX,0x0
JNZ 0x00154c78
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00147bd0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00154da3
LAB_00154c78:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x48]
LEA RCX,[0x147bd0]
MOV qword ptr [RAX + 0x50],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x14]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x20],ECX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x48]
CMP qword ptr [RAX],0x0
JZ 0x00154d1c
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
XOR ESI,ESI
CALL RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
MOV ESI,0x1
CALL RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
MOV ESI,0x2
CALL RAX
LAB_00154d1c:
MOV EDI,0x1
MOV ESI,0x4000
CALL 0x001388c0
MOV RCX,qword ptr [RBP + -0x48]
MOV qword ptr [RCX + 0x8],RAX
CMP RAX,0x0
JNZ 0x00154d7f
MOV RAX,qword ptr [RBP + -0x48]
CMP qword ptr [RAX + 0x50],0x0
JZ 0x00154d6c
MOV RAX,qword ptr [RBP + -0x48]
MOV R8,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x18]
LEA RAX,[0x3499d0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL R8
LAB_00154d6c:
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001381b0
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00154da3
LAB_00154d7f:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
LAB_00154da3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
void * ma_pvio_init(long param_1)
{
long lVar1;
void *pvVar2;
void *local_10;
if (*(uint *)(param_1 + 0x14) < 2) {
lVar1 = mysql_client_find_plugin
(*(int8 *)(param_1 + 0x18),
CONCAT44(PTR_s_pvio_socket_00335b40._4_4_,PTR_s_pvio_socket_00335b40._0_4_),
0x65);
if (lVar1 == 0) {
local_10 = (void *)0x0;
}
else {
local_10 = calloc(1,0x70);
if (local_10 == (void *)0x0) {
my_set_error(*(int8 *)(param_1 + 0x18),0x7d8,SQLSTATE_UNKNOWN,0);
local_10 = (void *)0x0;
}
else {
*(int8 *)((long)local_10 + 0x48) = *(int8 *)(lVar1 + 0x58);
*(code **)((long)local_10 + 0x50) = my_set_error;
*(int4 *)((long)local_10 + 0x20) = *(int4 *)(param_1 + 0x14);
if (**(long **)((long)local_10 + 0x48) != 0) {
(*(code *)**(int8 **)((long)local_10 + 0x48))
(local_10,0,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
(*(code *)**(int8 **)((long)local_10 + 0x48))
(local_10,1,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
(*(code *)**(int8 **)((long)local_10 + 0x48))
(local_10,2,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
}
pvVar2 = calloc(1,0x4000);
*(void **)((long)local_10 + 8) = pvVar2;
if (pvVar2 == (void *)0x0) {
if (*(long *)((long)local_10 + 0x50) != 0) {
(**(code **)((long)local_10 + 0x50))
(*(int8 *)(param_1 + 0x18),0x7d8,SQLSTATE_UNKNOWN,0);
}
free(local_10);
local_10 = (void *)0x0;
}
else {
*(int8 *)((long)local_10 + 0x18) = 0;
*(int8 *)((long)local_10 + 0x10) = *(int8 *)((long)local_10 + 8);
}
}
}
}
else {
local_10 = (void *)0x0;
}
return local_10;
}
| |
24,456 | ma_pvio_init | eloqsql/libmariadb/libmariadb/ma_pvio.c | MARIADB_PVIO *ma_pvio_init(MA_PVIO_CINFO *cinfo)
{
/* check connection type and load the required plugin.
* Currently we support the following pvio types:
* pvio_socket
* pvio_namedpipe
* pvio_sharedmed
*/
const char *pvio_plugins[] = {"pvio_socket", "pvio_npipe", "pvio_shmem"};
int type;
MARIADB_PVIO_PLUGIN *pvio_plugin;
MARIADB_PVIO *pvio= NULL;
switch (cinfo->type)
{
case PVIO_TYPE_UNIXSOCKET:
case PVIO_TYPE_SOCKET:
type= 0;
break;
#ifdef _WIN32
case PVIO_TYPE_NAMEDPIPE:
type= 1;
break;
case PVIO_TYPE_SHAREDMEM:
type= 2;
break;
#endif
default:
return NULL;
}
if (!(pvio_plugin= (MARIADB_PVIO_PLUGIN *)
mysql_client_find_plugin(cinfo->mysql,
pvio_plugins[type],
MARIADB_CLIENT_PVIO_PLUGIN)))
{
/* error already set in mysql_client_find_plugin */
return NULL;
}
/* coverity[var_deref_op] */
if (!(pvio= (MARIADB_PVIO *)calloc(1, sizeof(MARIADB_PVIO))))
{
my_set_error(cinfo->mysql, CR_OUT_OF_MEMORY, unknown_sqlstate, 0);
return NULL;
}
/* register error routine and methods */
pvio->methods= pvio_plugin->methods;
pvio->set_error= my_set_error;
pvio->type= cinfo->type;
/* set timeout to connect timeout - after successful connect we will set
* correct values for read and write */
if (pvio->methods->set_timeout)
{
pvio->methods->set_timeout(pvio, PVIO_CONNECT_TIMEOUT, cinfo->mysql->options.connect_timeout);
pvio->methods->set_timeout(pvio, PVIO_READ_TIMEOUT, cinfo->mysql->options.connect_timeout);
pvio->methods->set_timeout(pvio, PVIO_WRITE_TIMEOUT, cinfo->mysql->options.connect_timeout);
}
if (!(pvio->cache= calloc(1, PVIO_READ_AHEAD_CACHE_SIZE)))
{
PVIO_SET_ERROR(cinfo->mysql, CR_OUT_OF_MEMORY, unknown_sqlstate, 0);
free(pvio);
return NULL;
}
pvio->cache_size= 0;
pvio->cache_pos= pvio->cache;
return pvio;
} | O3 | c | ma_pvio_init:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, 0x14(%rdi)
ja 0x4bf53
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x58b78(%rip), %rsi # 0xa49c6
movl $0x65, %edx
callq 0x5686c
testq %rax, %rax
je 0x4bf53
movq %rax, %r15
movl $0x1, %edi
movl $0x70, %esi
callq 0x378f0
testq %rax, %rax
je 0x4bf08
movq %rax, %rbx
movq 0x58(%r15), %rax
movq %rax, 0x48(%rbx)
leaq -0x78f1(%rip), %rcx # 0x4459d
movq %rcx, 0x50(%rbx)
movl 0x14(%r14), %ecx
movl %ecx, 0x20(%rbx)
movq (%rax), %rax
testq %rax, %rax
je 0x4bee2
movq 0x18(%r14), %rcx
movl 0x390(%rcx), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
movq 0x48(%rbx), %rax
movq 0x18(%r14), %rcx
movl 0x390(%rcx), %edx
movq %rbx, %rdi
movl $0x1, %esi
callq *(%rax)
movq 0x48(%rbx), %rax
movq 0x18(%r14), %rcx
movl 0x390(%rcx), %edx
movq %rbx, %rdi
movl $0x2, %esi
callq *(%rax)
movl $0x1, %edi
movl $0x4000, %esi # imm = 0x4000
callq 0x378f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4bf28
movq $0x0, 0x18(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x4bf55
movq 0x18(%r14), %rdi
leaq 0x30166d(%rip), %rax # 0x34d580
movq (%rax), %rdx
xorl %ebx, %ebx
movl $0x7d8, %esi # imm = 0x7D8
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x4459d
jmp 0x4bf55
movq 0x50(%rbx), %r8
testq %r8, %r8
je 0x4bf4b
movq 0x18(%r14), %rdi
leaq 0x301644(%rip), %rax # 0x34d580
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %ecx, %ecx
xorl %eax, %eax
callq *%r8
movq %rbx, %rdi
callq 0x37190
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| ma_pvio_init:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
cmp dword ptr [rdi+14h], 1
ja loc_4BF53
mov r14, rdi
mov rdi, [rdi+18h]
lea rsi, aPvioSocket; "pvio_socket"
mov edx, 65h ; 'e'
call mysql_client_find_plugin
test rax, rax
jz loc_4BF53
mov r15, rax
mov edi, 1
mov esi, 70h ; 'p'
call _calloc
test rax, rax
jz loc_4BF08
mov rbx, rax
mov rax, [r15+58h]
mov [rbx+48h], rax
lea rcx, my_set_error
mov [rbx+50h], rcx
mov ecx, [r14+14h]
mov [rbx+20h], ecx
mov rax, [rax]
test rax, rax
jz short loc_4BEE2
mov rcx, [r14+18h]
mov edx, [rcx+390h]
mov rdi, rbx
xor esi, esi
call rax
mov rax, [rbx+48h]
mov rcx, [r14+18h]
mov edx, [rcx+390h]
mov rdi, rbx
mov esi, 1
call qword ptr [rax]
mov rax, [rbx+48h]
mov rcx, [r14+18h]
mov edx, [rcx+390h]
mov rdi, rbx
mov esi, 2
call qword ptr [rax]
loc_4BEE2:
mov edi, 1
mov esi, 4000h
call _calloc
mov [rbx+8], rax
test rax, rax
jz short loc_4BF28
mov qword ptr [rbx+18h], 0
mov [rbx+10h], rax
jmp short loc_4BF55
loc_4BF08:
mov rdi, [r14+18h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
xor ebx, ebx
mov esi, 7D8h
xor ecx, ecx
xor eax, eax
call my_set_error
jmp short loc_4BF55
loc_4BF28:
mov r8, [rbx+50h]
test r8, r8
jz short loc_4BF4B
mov rdi, [r14+18h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor ecx, ecx
xor eax, eax
call r8
loc_4BF4B:
mov rdi, rbx
call _free
loc_4BF53:
xor ebx, ebx
loc_4BF55:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_pvio_init(long long a1)
{
long long plugin; // rax
long long v2; // r15
long long v3; // rax
long long v4; // rbx
void ( **v5)(long long, _QWORD, _QWORD); // rax
void ( *v6)(long long, _QWORD, _QWORD); // rax
long long v7; // rax
void ( *v8)(_QWORD, long long, char *, _QWORD); // r8
if ( *(_DWORD *)(a1 + 20) > 1u )
return 0LL;
plugin = mysql_client_find_plugin(*(_QWORD *)(a1 + 24), "pvio_socket", 101LL);
if ( !plugin )
return 0LL;
v2 = plugin;
v3 = calloc(1LL, 112LL);
if ( !v3 )
{
v4 = 0LL;
my_set_error(*(_QWORD *)(a1 + 24), 2008, (long long)SQLSTATE_UNKNOWN, 0LL);
return v4;
}
v4 = v3;
v5 = *(void ( ***)(long long, _QWORD, _QWORD))(v2 + 88);
*(_QWORD *)(v4 + 72) = v5;
*(_QWORD *)(v4 + 80) = my_set_error;
*(_DWORD *)(v4 + 32) = *(_DWORD *)(a1 + 20);
v6 = *v5;
if ( v6 )
{
v6(v4, 0LL, *(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
(**(void ( ***)(long long, long long, _QWORD))(v4 + 72))(
v4,
1LL,
*(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
(**(void ( ***)(long long, long long, _QWORD))(v4 + 72))(
v4,
2LL,
*(unsigned int *)(*(_QWORD *)(a1 + 24) + 912LL));
}
v7 = calloc(1LL, 0x4000LL);
*(_QWORD *)(v4 + 8) = v7;
if ( !v7 )
{
v8 = *(void ( **)(_QWORD, long long, char *, _QWORD))(v4 + 80);
if ( v8 )
v8(*(_QWORD *)(a1 + 24), 2008LL, SQLSTATE_UNKNOWN, 0LL);
free(v4);
return 0LL;
}
*(_QWORD *)(v4 + 24) = 0LL;
*(_QWORD *)(v4 + 16) = v7;
return v4;
}
| ma_pvio_init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
CMP dword ptr [RDI + 0x14],0x1
JA 0x0014bf53
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x18]
LEA RSI,[0x1a49c6]
MOV EDX,0x65
CALL 0x0015686c
TEST RAX,RAX
JZ 0x0014bf53
MOV R15,RAX
MOV EDI,0x1
MOV ESI,0x70
CALL 0x001378f0
TEST RAX,RAX
JZ 0x0014bf08
MOV RBX,RAX
MOV RAX,qword ptr [R15 + 0x58]
MOV qword ptr [RBX + 0x48],RAX
LEA RCX,[0x14459d]
MOV qword ptr [RBX + 0x50],RCX
MOV ECX,dword ptr [R14 + 0x14]
MOV dword ptr [RBX + 0x20],ECX
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0014bee2
MOV RCX,qword ptr [R14 + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
MOV RDI,RBX
XOR ESI,ESI
CALL RAX
MOV RAX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [R14 + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
MOV RDI,RBX
MOV ESI,0x1
CALL qword ptr [RAX]
MOV RAX,qword ptr [RBX + 0x48]
MOV RCX,qword ptr [R14 + 0x18]
MOV EDX,dword ptr [RCX + 0x390]
MOV RDI,RBX
MOV ESI,0x2
CALL qword ptr [RAX]
LAB_0014bee2:
MOV EDI,0x1
MOV ESI,0x4000
CALL 0x001378f0
MOV qword ptr [RBX + 0x8],RAX
TEST RAX,RAX
JZ 0x0014bf28
MOV qword ptr [RBX + 0x18],0x0
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0014bf55
LAB_0014bf08:
MOV RDI,qword ptr [R14 + 0x18]
LEA RAX,[0x44d580]
MOV RDX,qword ptr [RAX]
XOR EBX,EBX
MOV ESI,0x7d8
XOR ECX,ECX
XOR EAX,EAX
CALL 0x0014459d
JMP 0x0014bf55
LAB_0014bf28:
MOV R8,qword ptr [RBX + 0x50]
TEST R8,R8
JZ 0x0014bf4b
MOV RDI,qword ptr [R14 + 0x18]
LEA RAX,[0x44d580]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR ECX,ECX
XOR EAX,EAX
CALL R8
LAB_0014bf4b:
MOV RDI,RBX
CALL 0x00137190
LAB_0014bf53:
XOR EBX,EBX
LAB_0014bf55:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void * ma_pvio_init(long param_1)
{
int8 *puVar1;
code *pcVar2;
long lVar3;
void *__ptr;
void *pvVar4;
if ((*(uint *)(param_1 + 0x14) < 2) &&
(lVar3 = mysql_client_find_plugin(*(int8 *)(param_1 + 0x18),"pvio_socket",0x65),
lVar3 != 0)) {
__ptr = calloc(1,0x70);
if (__ptr == (void *)0x0) {
my_set_error(*(int8 *)(param_1 + 0x18),0x7d8,SQLSTATE_UNKNOWN,0);
return (void *)0x0;
}
puVar1 = *(int8 **)(lVar3 + 0x58);
*(int8 **)((long)__ptr + 0x48) = puVar1;
*(code **)((long)__ptr + 0x50) = my_set_error;
*(int4 *)((long)__ptr + 0x20) = *(int4 *)(param_1 + 0x14);
pcVar2 = (code *)*puVar1;
if (pcVar2 != (code *)0x0) {
(*pcVar2)(__ptr,0,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
(*(code *)**(int8 **)((long)__ptr + 0x48))
(__ptr,1,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
(*(code *)**(int8 **)((long)__ptr + 0x48))
(__ptr,2,*(int4 *)(*(long *)(param_1 + 0x18) + 0x390));
}
pvVar4 = calloc(1,0x4000);
*(void **)((long)__ptr + 8) = pvVar4;
if (pvVar4 != (void *)0x0) {
*(int8 *)((long)__ptr + 0x18) = 0;
*(void **)((long)__ptr + 0x10) = pvVar4;
return __ptr;
}
if (*(code **)((long)__ptr + 0x50) != (code *)0x0) {
(**(code **)((long)__ptr + 0x50))(*(int8 *)(param_1 + 0x18),0x7d8,SQLSTATE_UNKNOWN,0);
}
free(__ptr);
}
return (void *)0x0;
}
| |
24,457 | LefDefParser::lefStoreAlias() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lef_keywords.cpp | static int
GetTokenFromStack(char *s)
{
const char *ch; // utility variable
char *prS = NULL; // pointing to the previous char or s
char *save = s; // for debug printing
while (lefData->input_level >= 0) {
for (ch = lefData->current_stack[lefData->input_level]; *ch != 0; ch++) // skip white space
if (*ch != ' ' && *ch != '\t' && (lefData->lefNlToken || *ch != '\n'))
break;
// did we find anything? If not, decrement level and try again
if (*ch == 0)
lefData->input_level--;
else if (*ch == '\n') {
*s++ = *ch;
*s = 0;
if (lefData->lefDebug[11])
printf("Stack[%d] Newline token\n", lefData->input_level);
return TRUE;
} else { // we found something
for (; ; ch++) {
if (*ch == ' ' || *ch == '\t' || *ch == '\n' || *ch == 0) {
/* 10/10/2000 - Wanda da Rosa, pcr 341032
** Take out the lefData->last '"', the 1st will be skip later
*/
if (*prS == '"') {
*prS = '\0';
} else
*s++ = '\0';
lefData->current_stack[lefData->input_level] = ch;
if (lefData->lefDebug[11])
printf("Stack[%d]: <%s>, dm=%d\n",
lefData->input_level, save, lefData->lefDumbMode);
return TRUE;
}
/* 10/10/2000 - Wanda da Rosa, pcr 341032
** Save the location of the previous s
*/
prS = s;
*s++ = *ch;
}
}
}
return FALSE; // if we get here, we ran out of input levels
} | O3 | cpp | LefDefParser::lefStoreAlias():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x58fac(%rip), %r14 # 0x89fa8
addq $0x18, %r14
movq %r14, 0x20(%rsp)
leaq 0x1c(%rsp), %rbx
movl $0x2800, (%rbx) # imm = 0x2800
movl $0x2800, %edi # imm = 0x2800
callq 0x22b0
leaq 0x30(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x312ff
leaq 0x1c(%rsp), %rbx
movslq (%rbx), %rdi
callq 0x22b0
leaq 0x28(%rsp), %rdi
movq %rax, (%rdi)
movq %rbx, %rsi
callq 0x312ff
movslq 0x1c(%rsp), %rdi
callq 0x22b0
movq %rax, %rbx
movq 0x28(%rsp), %rax
cmpb $0x3d, (%rax)
jne 0x31064
cmpb $0x0, 0x1(%rax)
je 0x31075
leaq 0x2ee30(%rip), %rsi # 0x5fe9b
movl $0x3e8, %edi # imm = 0x3E8
callq 0x307ca
xorl %r13d, %r13d
leaq 0x2ee40(%rip), %r14 # 0x5febf
leaq 0x20(%rsp), %r15
testq %r13, %r13
jne 0x311a5
movq 0x28(%rsp), %r12
movl 0x1c(%rsp), %ebp
movq %r12, %r13
cmpl $0x2, %ebp
jl 0x31103
leaq 0x1(%r12), %rax
decl %ebp
movq %rax, %r13
callq 0x30722
cmpl $-0x1, %eax
je 0x31172
movb %al, -0x1(%r13)
cmpl $0xa, %eax
je 0x310c9
leaq 0x1(%r13), %rax
decl %ebp
jne 0x310a5
jmp 0x31103
leaq 0x5c510(%rip), %rax # 0x8d5e0
movq (%rax), %rax
movl 0x1e4(%rax), %edi
incl %edi
movl %edi, 0x1e4(%rax)
leaq 0x5c4d0(%rip), %rax # 0x8d5b8
movq (%rax), %rsi
movq 0x88(%rsi), %rcx
testq %rcx, %rcx
je 0x31103
movl %edi, %eax
cltd
idivl 0x4c(%rsi)
testl %edx, %edx
jne 0x31103
callq *%rcx
movb $0x0, (%r13)
movb (%r12), %al
movq %rbx, %r13
testb %al, %al
je 0x31134
leaq 0x1(%r12), %rbp
movq %rbx, %r13
movsbl %al, %edi
callq 0x23b0
movb %al, (%r13)
incq %r13
movb (%rbp), %al
incq %rbp
testb %al, %al
jne 0x3111b
movb $0x0, (%r13)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2080
movq %rax, %r13
testq %rax, %rax
je 0x31157
movq %r13, %rax
subq %rbx, %rax
movb $0x0, (%r12,%rax)
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2060
jmp 0x31084
leaq 0x2ed30(%rip), %rsi # 0x5fea9
movl $0x3e9, %edi # imm = 0x3E9
callq 0x307ca
movq 0x20(%rsp), %rdi
addq $-0x18, %rdi
leaq 0x30(%rsp), %rsi
callq 0x2140
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x20e0
leaq 0x1(%rax), %rdi
callq 0x22b0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x21d0
leaq 0x5c410(%rip), %r13 # 0x8d5e0
movq (%r13), %r12
movq 0x30(%rsp), %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x32a26
movq (%r13), %rax
cmpl $0x0, 0x220(%rax)
je 0x31257
addq $0x1658, %r12 # imm = 0x1658
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x32a66
movq %rax, %r12
movq %r15, %rdi
callq 0x20e0
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2250
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xf(%rsp), %rsi
callq 0x2140
movq %r14, %rdi
callq 0x2260
movq 0x28(%rsp), %rdi
callq 0x2260
movq %rbx, %rdi
callq 0x2260
jmp 0x31183
movq 0x10(%rsp), %rax
movl -0x8(%rax), %ecx
testl %ecx, %ecx
js 0x31272
leaq 0x10(%rsp), %rdi
callq 0x2070
movq 0x10(%rsp), %rax
leaq 0x10(%rsp), %r13
movq %rax, %rbp
movl -0x8(%rax), %ecx
testl %ecx, %ecx
js 0x3128e
movq %r13, %rdi
callq 0x2070
movq 0x10(%rsp), %rax
addq -0x18(%rax), %rax
cmpq %rax, %rbp
je 0x311f8
movsbl (%rbp), %edi
callq 0x23b0
movb %al, (%rbp)
incq %rbp
movq 0x10(%rsp), %rax
jmp 0x3127a
jmp 0x312c4
jmp 0x312de
jmp 0x312de
jmp 0x312c4
jmp 0x312de
jmp 0x312de
jmp 0x312de
movq %rax, %rbx
jmp 0x312e6
movq %rax, %rbx
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xf(%rsp), %rsi
callq 0x2140
jmp 0x312e1
jmp 0x312de
movq %rax, %rbx
movq 0x20(%rsp), %r14
addq $-0x18, %r14
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x2370
| _ZN12LefDefParser13lefStoreAliasEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r14, cs:_ZNSs4_Rep20_S_empty_rep_storageE_ptr
add r14, 18h
mov [rsp+68h+var_4C+4], r14
lea rbx, [rsp+68h+var_4C]
mov dword ptr [rbx], 2800h
mov edi, 2800h
call _malloc
lea rdi, [rsp+68h+var_38]; this
mov [rdi], rax
mov rsi, rbx; char **
call _ZN12LefDefParserL8GetTokenEPPcPi; LefDefParser::GetToken(char **,int *)
lea rbx, [rsp+68h+var_4C]
movsxd rdi, dword ptr [rbx]
call _malloc
lea rdi, [rsp+68h+var_40]; this
mov [rdi], rax
mov rsi, rbx; char **
call _ZN12LefDefParserL8GetTokenEPPcPi; LefDefParser::GetToken(char **,int *)
movsxd rdi, dword ptr [rsp+68h+var_4C]
call _malloc
mov rbx, rax
mov rax, [rsp+68h+var_40]
cmp byte ptr [rax], 3Dh ; '='
jnz short loc_31064
cmp byte ptr [rax+1], 0
jz short loc_31075
loc_31064:
lea rsi, aExpecting; "Expecting '='"
mov edi, offset stru_3E8; this
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
loc_31075:
xor r13d, r13d
lea r14, aEndalias; "&ENDALIAS"
lea r15, [rsp+68h+var_4C+4]
loc_31084:
test r13, r13
jnz loc_311A5
mov r12, [rsp+68h+var_40]
mov ebp, dword ptr [rsp+68h+var_4C]
mov r13, r12
cmp ebp, 2
jl short loc_31103
lea rax, [r12+1]
dec ebp
loc_310A5:
mov r13, rax
call _ZN12LefDefParser7lefGetcEv; LefDefParser::lefGetc(void)
cmp eax, 0FFFFFFFFh
jz loc_31172
mov [r13-1], al
cmp eax, 0Ah
jz short loc_310C9
lea rax, [r13+1]
dec ebp
jnz short loc_310A5
jmp short loc_31103
loc_310C9:
lea rax, _ZN12LefDefParser7lefDataE; LefDefParser::lefData
mov rax, [rax]
mov edi, [rax+1E4h]
inc edi
mov [rax+1E4h], edi
lea rax, _ZN12LefDefParser11lefSettingsE; LefDefParser::lefSettings
mov rsi, [rax]
mov rcx, [rsi+88h]
test rcx, rcx
jz short loc_31103
mov eax, edi
cdq
idiv dword ptr [rsi+4Ch]
test edx, edx
jnz short loc_31103
call rcx
loc_31103:
mov byte ptr [r13+0], 0
mov al, [r12]
mov r13, rbx
test al, al
jz short loc_31134
lea rbp, [r12+1]
mov r13, rbx
loc_3111B:
movsx edi, al
call _toupper
mov [r13+0], al
inc r13
mov al, [rbp+0]
inc rbp
test al, al
jnz short loc_3111B
loc_31134:
mov byte ptr [r13+0], 0
mov rdi, rbx
mov rsi, r14
call _strstr
mov r13, rax
test rax, rax
jz short loc_31157
mov rax, r13
sub rax, rbx
mov byte ptr [r12+rax], 0
loc_31157:
mov rdi, r12
call _strlen
mov rdi, r15; this
mov rsi, r12; char *
mov rdx, rax; unsigned __int64
call __ZNSs6appendEPKcm; std::string::append(char const*,ulong)
jmp loc_31084
loc_31172:
lea rsi, aEndOfFileInAli; "End of file in &ALIAS"
mov edi, (offset stru_3E8.st_name+1); this
call _ZN12LefDefParser8lefErrorEiPKc; LefDefParser::lefError(int,char const*)
loc_31183:
mov rdi, [rsp+68h+var_4C+4]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+68h+var_38]
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_311A5:
mov r14, [rsp+68h+var_4C+4]
mov rdi, r14
call _strlen
lea rdi, [rax+1]
call _malloc
mov r15, rax
mov rdi, rax
mov rsi, r14
call _strcpy
lea r13, _ZN12LefDefParser7lefDataE; LefDefParser::lefData
mov r12, [r13+0]
mov r14, [rsp+68h+var_38]
lea rdi, [rsp+68h+var_58]
lea rdx, [rsp+68h+var_59]
mov rsi, r14
call _ZNSsC2ISaIcEEEPKcRKS0_; std::string::string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, [r13+0]
cmp dword ptr [rax+220h], 0
jz short loc_31257
loc_311F8:
add r12, 1658h
lea rsi, [rsp+68h+var_58]
mov rdi, r12
call _ZNSt3mapISsSsN12LefDefParser17lefCompareStringsESaISt4pairIKSsSsEEEixEOSs; std::map<std::string,std::string,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string const,std::string>>>::operator[](std::string &&)
mov r12, rax
mov rdi, r15
call _strlen
mov rdi, r12; this
mov rsi, r15; char *
mov rdx, rax; unsigned __int64
call __ZNSs6assignEPKcm; std::string::assign(char const*,ulong)
mov rdi, [rsp+68h+var_58]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+68h+var_59]
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
mov rdi, r14
call _free
mov rdi, [rsp+68h+var_40]
call _free
mov rdi, rbx
call _free
jmp loc_31183
loc_31257:
mov rax, [rsp+68h+var_58]
mov ecx, [rax-8]
test ecx, ecx
js short loc_31272
lea rdi, [rsp+68h+var_58]; this
call __ZNSs12_M_leak_hardEv; std::string::_M_leak_hard(void)
mov rax, [rsp+68h+var_58]
loc_31272:
lea r13, [rsp+68h+var_58]
mov rbp, rax
loc_3127A:
mov ecx, [rax-8]
test ecx, ecx
js short loc_3128E
mov rdi, r13; this
call __ZNSs12_M_leak_hardEv; std::string::_M_leak_hard(void)
mov rax, [rsp+68h+var_58]
loc_3128E:
add rax, [rax-18h]
cmp rbp, rax
jz loc_311F8
movsx edi, byte ptr [rbp+0]
call _toupper
mov [rbp+0], al
inc rbp
mov rax, [rsp+68h+var_58]
jmp short loc_3127A
jmp short loc_312C4
jmp short loc_312DE
jmp short loc_312DE
jmp short loc_312C4
jmp short loc_312DE
jmp short loc_312DE
jmp short loc_312DE
mov rbx, rax
jmp short loc_312E6
loc_312C4:
mov rbx, rax
mov rdi, [rsp+arg_8]
add rdi, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+arg_7]
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
jmp short loc_312E1
jmp short $+2
loc_312DE:
mov rbx, rax
loc_312E1:
mov r14, [rsp+arg_18]
loc_312E6:
add r14, 0FFFFFFFFFFFFFFE8h
lea rsi, [rsp+arg_28]
mov rdi, r14
call __ZNSs4_Rep10_M_disposeERKSaIcE; std::string::_Rep::_M_dispose(std::allocator<char> const&)
mov rdi, rbx
call __Unwind_Resume
| long long LefDefParser::lefStoreAlias(LefDefParser *this)
{
int *v1; // rdx
int *v2; // rdx
LefDefParser *v3; // rdi
const char *v4; // rdx
_BYTE *v5; // rbx
long long v6; // r13
char *v7; // r12
char *v8; // r13
char *v9; // rax
int v10; // ebp
int v11; // eax
const char *v12; // rdx
int v13; // edi
void (*v14)(void); // rcx
char v15; // al
_BYTE *v16; // r13
char *v17; // rbp
unsigned long long v18; // rax
long long v20; // r14
long long v21; // rax
const char *v22; // r15
long long v23; // r12
void *v24; // r14
std::string *v25; // r12
unsigned long long v26; // rax
_BYTE *v27; // rax
_BYTE *i; // rbp
char v29; // [rsp+Fh] [rbp-59h] BYREF
_BYTE *v30; // [rsp+10h] [rbp-58h] BYREF
_BYTE v31[12]; // [rsp+1Ch] [rbp-4Ch] BYREF
char *v32; // [rsp+28h] [rbp-40h] BYREF
_QWORD v33[7]; // [rsp+30h] [rbp-38h] BYREF
*(_QWORD *)&v31[4] = (char *)&std::string::_Rep::_S_empty_rep_storage + 24;
*(_DWORD *)v31 = 10240;
v33[0] = malloc(10240LL);
LefDefParser::GetToken((LefDefParser *)v33, (char **)v31, v1);
v32 = (char *)malloc(*(int *)v31);
LefDefParser::GetToken((LefDefParser *)&v32, (char **)v31, v2);
v3 = (LefDefParser *)*(int *)v31;
v5 = (_BYTE *)malloc(*(int *)v31);
if ( *v32 != 61 || v32[1] )
{
v3 = (LefDefParser *)&stru_3E8;
LefDefParser::lefError((LefDefParser *)&stru_3E8, (long long)"Expecting '='", v4);
}
v6 = 0LL;
while ( !v6 )
{
v7 = v32;
v8 = v32;
if ( *(int *)v31 >= 2 )
{
v9 = v32 + 1;
v10 = *(_DWORD *)v31 - 1;
while ( 1 )
{
v8 = v9;
v11 = LefDefParser::lefGetc(v3);
if ( v11 == -1 )
{
LefDefParser::lefError((LefDefParser *)((char *)&stru_3E8.st_name + 1), (long long)"End of file in &ALIAS", v12);
return std::string::_Rep::_M_dispose(*(_QWORD *)&v31[4] - 24LL, v33);
}
*(v8 - 1) = v11;
if ( v11 == 10 )
break;
v9 = v8 + 1;
if ( !--v10 )
goto LABEL_15;
}
v13 = *(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) + 1;
*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 484LL) = v13;
v14 = (void (*)(void))*((_QWORD *)LefDefParser::lefSettings + 17);
if ( v14 && !(v13 % *((_DWORD *)LefDefParser::lefSettings + 19)) )
v14();
}
LABEL_15:
*v8 = 0;
v15 = *v7;
v16 = v5;
if ( *v7 )
{
v17 = v7 + 1;
v16 = v5;
do
{
*v16++ = toupper((unsigned int)v15);
v15 = *v17++;
}
while ( v15 );
}
*v16 = 0;
v6 = strstr(v5, "&ENDALIAS");
if ( v6 )
v7[v6 - (_QWORD)v5] = 0;
v18 = strlen(v7);
v3 = (LefDefParser *)&v31[4];
std::string::append((std::string *)&v31[4], v7, v18);
}
v20 = *(_QWORD *)&v31[4];
v21 = strlen(*(_QWORD *)&v31[4]);
v22 = (const char *)malloc(v21 + 1);
strcpy(v22, v20);
v23 = *(_QWORD *)LefDefParser::lefData;
v24 = (void *)v33[0];
std::string::string<std::allocator<char>>(&v30, v33[0], &v29);
if ( !*(_DWORD *)(*(_QWORD *)LefDefParser::lefData + 544LL) )
{
v27 = v30;
if ( *((int *)v30 - 2) >= 0 )
{
std::string::_M_leak_hard((std::string *)&v30);
v27 = v30;
}
for ( i = v27; ; ++i )
{
if ( *((int *)v27 - 2) >= 0 )
{
std::string::_M_leak_hard((std::string *)&v30);
v27 = v30;
}
if ( i == &v27[*((_QWORD *)v27 - 3)] )
break;
*i = toupper((unsigned int)(char)*i);
v27 = v30;
}
}
v25 = (std::string *)std::map<std::string,std::string,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string const,std::string>>>::operator[](
v23 + 5720,
&v30);
v26 = strlen(v22);
std::string::assign(v25, v22, v26);
std::string::_Rep::_M_dispose(v30 - 24, &v29);
free(v24);
free(v32);
free(v5);
return std::string::_Rep::_M_dispose(*(_QWORD *)&v31[4] - 24LL, v33);
}
| lefStoreAlias:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R14,qword ptr [0x00189fa8]
ADD R14,0x18
MOV qword ptr [RSP + 0x20],R14
LEA RBX,[RSP + 0x1c]
MOV dword ptr [RBX],0x2800
MOV EDI,0x2800
CALL 0x001022b0
LEA RDI,[RSP + 0x30]
MOV qword ptr [RDI],RAX
LAB_00131022:
MOV RSI,RBX
CALL 0x001312ff
LEA RBX,[RSP + 0x1c]
MOVSXD RDI,dword ptr [RBX]
CALL 0x001022b0
LEA RDI,[RSP + 0x28]
MOV qword ptr [RDI],RAX
LAB_0013103f:
MOV RSI,RBX
CALL 0x001312ff
MOVSXD RDI,dword ptr [RSP + 0x1c]
CALL 0x001022b0
MOV RBX,RAX
MOV RAX,qword ptr [RSP + 0x28]
CMP byte ptr [RAX],0x3d
JNZ 0x00131064
CMP byte ptr [RAX + 0x1],0x0
JZ 0x00131075
LAB_00131064:
LEA RSI,[0x15fe9b]
MOV EDI,0x3e8
CALL 0x001307ca
LAB_00131075:
XOR R13D,R13D
LEA R14,[0x15febf]
LEA R15,[RSP + 0x20]
LAB_00131084:
TEST R13,R13
JNZ 0x001311a5
MOV R12,qword ptr [RSP + 0x28]
MOV EBP,dword ptr [RSP + 0x1c]
MOV R13,R12
CMP EBP,0x2
JL 0x00131103
LEA RAX,[R12 + 0x1]
DEC EBP
LAB_001310a5:
MOV R13,RAX
LAB_001310a8:
CALL 0x00130722
CMP EAX,-0x1
JZ 0x00131172
MOV byte ptr [R13 + -0x1],AL
CMP EAX,0xa
JZ 0x001310c9
LEA RAX,[R13 + 0x1]
DEC EBP
JNZ 0x001310a5
JMP 0x00131103
LAB_001310c9:
LEA RAX,[0x18d5e0]
MOV RAX,qword ptr [RAX]
MOV EDI,dword ptr [RAX + 0x1e4]
INC EDI
MOV dword ptr [RAX + 0x1e4],EDI
LEA RAX,[0x18d5b8]
MOV RSI,qword ptr [RAX]
MOV RCX,qword ptr [RSI + 0x88]
TEST RCX,RCX
JZ 0x00131103
MOV EAX,EDI
CDQ
IDIV dword ptr [RSI + 0x4c]
TEST EDX,EDX
JNZ 0x00131103
LAB_00131101:
CALL RCX
LAB_00131103:
MOV byte ptr [R13],0x0
MOV AL,byte ptr [R12]
MOV R13,RBX
TEST AL,AL
JZ 0x00131134
LEA RBP,[R12 + 0x1]
MOV R13,RBX
LAB_0013111b:
MOVSX EDI,AL
CALL 0x001023b0
MOV byte ptr [R13],AL
INC R13
MOV AL,byte ptr [RBP]
INC RBP
TEST AL,AL
JNZ 0x0013111b
LAB_00131134:
MOV byte ptr [R13],0x0
MOV RDI,RBX
MOV RSI,R14
CALL 0x00102080
MOV R13,RAX
TEST RAX,RAX
JZ 0x00131157
MOV RAX,R13
SUB RAX,RBX
MOV byte ptr [R12 + RAX*0x1],0x0
LAB_00131157:
MOV RDI,R12
CALL 0x001020e0
LAB_0013115f:
MOV RDI,R15
MOV RSI,R12
MOV RDX,RAX
CALL 0x00102060
JMP 0x00131084
LAB_00131172:
LEA RSI,[0x15fea9]
MOV EDI,0x3e9
CALL 0x001307ca
LAB_00131183:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,-0x18
LEA RSI,[RSP + 0x30]
CALL 0x00102140
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001311a5:
MOV R14,qword ptr [RSP + 0x20]
MOV RDI,R14
CALL 0x001020e0
LEA RDI,[RAX + 0x1]
CALL 0x001022b0
MOV R15,RAX
MOV RDI,RAX
MOV RSI,R14
CALL 0x001021d0
LEA R13,[0x18d5e0]
MOV R12,qword ptr [R13]
MOV R14,qword ptr [RSP + 0x30]
LAB_001311d9:
LEA RDI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
MOV RSI,R14
CALL 0x00132a26
MOV RAX,qword ptr [R13]
CMP dword ptr [RAX + 0x220],0x0
JZ 0x00131257
LAB_001311f8:
ADD R12,0x1658
LAB_001311ff:
LEA RSI,[RSP + 0x10]
MOV RDI,R12
CALL 0x00132a66
MOV R12,RAX
MOV RDI,R15
CALL 0x001020e0
MOV RDI,R12
MOV RSI,R15
MOV RDX,RAX
CALL 0x00102250
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,-0x18
LEA RSI,[RSP + 0xf]
CALL 0x00102140
MOV RDI,R14
CALL 0x00102260
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00102260
MOV RDI,RBX
CALL 0x00102260
JMP 0x00131183
LAB_00131257:
MOV RAX,qword ptr [RSP + 0x10]
MOV ECX,dword ptr [RAX + -0x8]
TEST ECX,ECX
JS 0x00131272
LAB_00131263:
LEA RDI,[RSP + 0x10]
CALL 0x00102070
MOV RAX,qword ptr [RSP + 0x10]
LAB_00131272:
LEA R13,[RSP + 0x10]
MOV RBP,RAX
LAB_0013127a:
MOV ECX,dword ptr [RAX + -0x8]
TEST ECX,ECX
JS 0x0013128e
LAB_00131281:
MOV RDI,R13
CALL 0x00102070
LAB_00131289:
MOV RAX,qword ptr [RSP + 0x10]
LAB_0013128e:
ADD RAX,qword ptr [RAX + -0x18]
CMP RBP,RAX
JZ 0x001311f8
MOVSX EDI,byte ptr [RBP]
CALL 0x001023b0
MOV byte ptr [RBP],AL
INC RBP
MOV RAX,qword ptr [RSP + 0x10]
JMP 0x0013127a
|
/* LefDefParser::lefStoreAlias() */
void LefDefParser::lefStoreAlias(void)
{
char cVar1;
long lVar2;
int iVar3;
char *__haystack;
char *pcVar4;
size_t sVar5;
char *pcVar6;
int iVar7;
char *pcVar8;
allocator local_59;
char *local_58;
int local_4c;
char *local_48;
char *local_40;
char *local_38;
local_48 = PTR__S_empty_rep_storage_00189fa8 + 0x18;
local_4c = 0x2800;
local_38 = (char *)malloc(0x2800);
/* try { // try from 00131022 to 00131029 has its CatchHandler @ 001312bf */
GetToken(&local_38,&local_4c);
local_40 = (char *)malloc((long)local_4c);
/* try { // try from 0013103f to 00131046 has its CatchHandler @ 001312bd */
GetToken(&local_40,&local_4c);
__haystack = (char *)malloc((long)local_4c);
if ((*local_40 != '=') || (local_40[1] != '\0')) {
/* try { // try from 00131064 to 00131074 has its CatchHandler @ 001312b9 */
lefError(1000,"Expecting \'=\'");
}
pcVar4 = (char *)0x0;
do {
pcVar6 = local_40;
pcVar8 = local_48;
if (pcVar4 != (char *)0x0) {
sVar5 = strlen(local_48);
pcVar6 = (char *)malloc(sVar5 + 1);
strcpy(pcVar6,pcVar8);
pcVar4 = local_38;
lVar2 = lefData;
/* try { // try from 001311d9 to 001311ea has its CatchHandler @ 001312b3 */
std::string::string<std::allocator<char>>((string *)&local_58,local_38,&local_59);
if (*(int *)(lefData + 0x220) == 0) {
pcVar8 = local_58;
if (-1 < *(int *)(local_58 + -8)) {
/* try { // try from 00131263 to 0013126c has its CatchHandler @ 001312b1 */
std::string::_M_leak_hard();
pcVar8 = local_58;
}
while( true ) {
if (-1 < *(int *)(local_58 + -8)) {
/* try { // try from 00131281 to 00131288 has its CatchHandler @ 001312c4 */
std::string::_M_leak_hard();
}
if (pcVar8 == local_58 + *(long *)(local_58 + -0x18)) break;
iVar7 = toupper((int)*pcVar8);
*pcVar8 = (char)iVar7;
pcVar8 = pcVar8 + 1;
}
}
/* try { // try from 001311ff to 00131224 has its CatchHandler @ 001312b7 */
pcVar8 = (char *)std::
map<std::string,std::string,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string_const,std::string>>>
::operator[]((map<std::string,std::string,LefDefParser::lefCompareStrings,std::allocator<std::pair<std::string_const,std::string>>>
*)(lVar2 + 0x1658),(string *)&local_58);
strlen(pcVar6);
std::string::assign(pcVar8,(ulong)pcVar6);
std::string::_Rep::_M_dispose((allocator *)(local_58 + -0x18));
free(pcVar4);
free(local_40);
free(__haystack);
LAB_00131183:
std::string::_Rep::_M_dispose((allocator *)(local_48 + -0x18));
return;
}
pcVar4 = local_40;
if (1 < local_4c) {
iVar7 = local_4c + -1;
pcVar8 = local_40;
do {
pcVar4 = pcVar8 + 1;
/* try { // try from 001310a8 to 001310ac has its CatchHandler @ 001312de */
iVar3 = lefGetc();
if (iVar3 == -1) {
/* try { // try from 00131172 to 00131182 has its CatchHandler @ 001312bb */
lefError(0x3e9,"End of file in &ALIAS");
goto LAB_00131183;
}
*pcVar8 = (char)iVar3;
if (iVar3 == 10) {
iVar7 = *(int *)(lefData + 0x1e4) + 1;
*(int *)(lefData + 0x1e4) = iVar7;
if ((*(code **)(lefSettings + 0x88) != (code *)0x0) &&
(iVar7 % *(int *)(lefSettings + 0x4c) == 0)) {
/* try { // try from 00131101 to 00131102 has its CatchHandler @ 001312b5 */
(**(code **)(lefSettings + 0x88))();
}
break;
}
iVar7 = iVar7 + -1;
pcVar8 = pcVar4;
} while (iVar7 != 0);
}
*pcVar4 = '\0';
cVar1 = *pcVar6;
pcVar4 = __haystack;
pcVar8 = pcVar6;
while (cVar1 != '\0') {
pcVar8 = pcVar8 + 1;
iVar7 = toupper((int)cVar1);
*pcVar4 = (char)iVar7;
pcVar4 = pcVar4 + 1;
cVar1 = *pcVar8;
}
*pcVar4 = '\0';
pcVar4 = strstr(__haystack,"&ENDALIAS");
if (pcVar4 != (char *)0x0) {
pcVar6[(long)pcVar4 - (long)__haystack] = '\0';
}
strlen(pcVar6);
/* try { // try from 0013115f to 0013116c has its CatchHandler @ 001312dc */
std::string::append((char *)&local_48,(ulong)pcVar6);
} while( true );
}
| |
24,458 | my_string_repertoire | eloqsql/strings/ctype.c | my_repertoire_t
my_string_repertoire(CHARSET_INFO *cs, const char *str, size_t length)
{
if (cs->mbminlen == 1 && !(cs->state & MY_CS_NONASCII))
{
return my_string_repertoire_8bit(cs, str, length);
}
else
{
const char *strend= str + length;
my_wc_t wc;
int chlen;
for (;
(chlen= my_ci_mb_wc(cs, &wc, (uchar*) str, (uchar*) strend)) > 0;
str+= chlen)
{
if (wc > 0x7F)
return MY_REPERTOIRE_UNICODE30;
}
}
return MY_REPERTOIRE_ASCII;
} | O0 | c | my_string_repertoire:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x98(%rax)
jne 0xbe328
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
jne 0xbe328
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xbe0d0
movl %eax, -0x4(%rbp)
jmp 0xbe38b
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq *%rax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xbe382
cmpq $0x7f, -0x30(%rbp)
jbe 0xbe36d
movl $0x3, -0x4(%rbp)
jmp 0xbe38b
jmp 0xbe36f
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xbe334
jmp 0xbe384
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_string_repertoire:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp dword ptr [rax+98h], 1
jnz short loc_BE328
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
and eax, 2000h
cmp eax, 0
jnz short loc_BE328
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call my_string_repertoire_8bit
mov [rbp+var_4], eax
jmp short loc_BE38B
loc_BE328:
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_28], rax
loc_BE334:
mov rax, [rbp+var_10]
mov rax, [rax+0B8h]
mov rax, [rax+28h]
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_28]
lea rsi, [rbp+var_30]
call rax
mov [rbp+var_34], eax
cmp eax, 0
jle short loc_BE382
cmp [rbp+var_30], 7Fh
jbe short loc_BE36D
mov [rbp+var_4], 3
jmp short loc_BE38B
loc_BE36D:
jmp short $+2
loc_BE36F:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_BE334
loc_BE382:
jmp short $+2
loc_BE384:
mov [rbp+var_4], 1
loc_BE38B:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long my_string_repertoire(long long a1, unsigned __int8 *a2, long long a3)
{
int v4; // [rsp+Ch] [rbp-34h]
unsigned long long v5; // [rsp+10h] [rbp-30h] BYREF
unsigned __int8 *v6; // [rsp+18h] [rbp-28h]
long long v7; // [rsp+20h] [rbp-20h]
unsigned __int8 *v8; // [rsp+28h] [rbp-18h]
long long v9; // [rsp+30h] [rbp-10h]
v9 = a1;
v8 = a2;
v7 = a3;
if ( *(_DWORD *)(a1 + 152) != 1 || (*(_DWORD *)(v9 + 12) & 0x2000) != 0 )
{
v6 = &v8[v7];
while ( 1 )
{
v4 = (*(long long ( **)(long long, unsigned long long *, unsigned __int8 *, unsigned __int8 *))(*(_QWORD *)(v9 + 184) + 40LL))(
v9,
&v5,
v8,
v6);
if ( v4 <= 0 )
break;
if ( v5 > 0x7F )
return 3;
v8 += v4;
}
return 1;
}
else
{
return (unsigned int)my_string_repertoire_8bit(v9, v8, v7);
}
}
| my_string_repertoire:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x98],0x1
JNZ 0x001be328
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
AND EAX,0x2000
CMP EAX,0x0
JNZ 0x001be328
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x001be0d0
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001be38b
LAB_001be328:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
LAB_001be334:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RAX + 0x28]
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
LEA RSI,[RBP + -0x30]
CALL RAX
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001be382
CMP qword ptr [RBP + -0x30],0x7f
JBE 0x001be36d
MOV dword ptr [RBP + -0x4],0x3
JMP 0x001be38b
LAB_001be36d:
JMP 0x001be36f
LAB_001be36f:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001be334
LAB_001be382:
JMP 0x001be384
LAB_001be384:
MOV dword ptr [RBP + -0x4],0x1
LAB_001be38b:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
int4 my_string_repertoire(long param_1,long param_2,long param_3)
{
int iVar1;
ulong local_38;
long local_30;
long local_28;
long local_20;
long local_18;
int4 local_c;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
if ((*(int *)(param_1 + 0x98) == 1) && ((*(uint *)(param_1 + 0xc) & 0x2000) == 0)) {
local_c = my_string_repertoire_8bit(param_1,param_2,param_3);
}
else {
local_30 = param_2 + param_3;
while (iVar1 = (**(code **)(*(long *)(local_18 + 0xb8) + 0x28))
(local_18,&local_38,local_20,local_30), 0 < iVar1) {
if (0x7f < local_38) {
return 3;
}
local_20 = local_20 + iVar1;
}
local_c = 1;
}
return local_c;
}
| |
24,459 | js_finrec_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_finrec_constructor(JSContext *ctx, JSValue new_target, int argc, JSValue *argv)
{
if (JS_IsUndefined(new_target))
return JS_ThrowTypeError(ctx, "constructor requires 'new'");
JSValue cb = argv[0];
if (!JS_IsFunction(ctx, cb))
return JS_ThrowTypeError(ctx, "argument must be a function");
JSValue obj = js_create_from_ctor(ctx, new_target, JS_CLASS_FINALIZATION_REGISTRY);
if (JS_IsException(obj))
return JS_EXCEPTION;
JSFinalizationRegistryData *frd = js_malloc(ctx, sizeof(*frd));
if (!frd) {
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
}
init_list_head(&frd->entries);
frd->ctx = ctx;
frd->cb = js_dup(cb);
JS_SetOpaqueInternal(obj, frd);
return obj;
} | O2 | c | js_finrec_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
cmpl $0x3, %ebx
jne 0x3359d
leaq 0x555df(%rip), %rsi # 0x88b7a
jmp 0x33613
movq %rsi, %r15
movq (%r8), %r12
movq 0x8(%r8), %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1ce7d
testl %eax, %eax
je 0x3360c
pushq $0x3b
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3045a
movq %rdx, %r15
pushq $0x6
popq %rbp
cmpl $0x6, %r15d
je 0x33633
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x17214
testq %rax, %rax
je 0x33625
movq %rax, (%rax)
movq %rax, 0x8(%rax)
movq %r14, 0x10(%rax)
cmpl $-0x9, %r13d
jb 0x335fe
incl (%r12)
movq %r12, 0x18(%rax)
movq %r13, 0x20(%rax)
movq %rax, 0x30(%rbx)
jmp 0x33638
leaq 0x5612c(%rip), %rsi # 0x8973f
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1c64d
pushq $0x6
popq %r15
jmp 0x33638
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1801e
xorl %ebx, %ebx
movq %rbp, %r15
movq %rbx, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| js_finrec_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdx
mov r14, rdi
cmp ebx, 3
jnz short loc_3359D
lea rsi, aConstructorReq; "constructor requires 'new'"
jmp short loc_33613
loc_3359D:
mov r15, rsi
mov r12, [r8]
mov r13, [r8+8]
mov rdi, r14
mov rsi, r12
mov rdx, r13
call JS_IsFunction
test eax, eax
jz short loc_3360C
push 3Bh ; ';'
pop rcx
mov rdi, r14
mov rsi, r15
mov rdx, rbx
call js_create_from_ctor
mov r15, rdx
push 6
pop rbp
cmp r15d, 6
jz short loc_33633
mov rbx, rax
push 28h ; '('
pop rsi
mov rdi, r14
call js_malloc
test rax, rax
jz short loc_33625
mov [rax], rax
mov [rax+8], rax
mov [rax+10h], r14
cmp r13d, 0FFFFFFF7h
jb short loc_335FE
inc dword ptr [r12]
loc_335FE:
mov [rax+18h], r12
mov [rax+20h], r13
mov [rbx+30h], rax
jmp short loc_33638
loc_3360C:
lea rsi, aArgumentMustBe; "argument must be a function"
loc_33613:
xor ebx, ebx
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
push 6
pop r15
jmp short loc_33638
loc_33625:
mov rdi, r14
mov rsi, rbx
mov rdx, r15
call JS_FreeValue
loc_33633:
xor ebx, ebx
mov r15, rbp
loc_33638:
mov rax, rbx
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long js_finrec_constructor(
long long a1,
long long a2,
long long a3,
long long a4,
long long *a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
const char *v16; // rsi
_DWORD *v17; // r12
long long v18; // r13
unsigned long long v19; // rax
long long v20; // rdx
long long v21; // r15
long long v22; // rbx
_QWORD *v23; // rax
char v25; // [rsp-8h] [rbp-38h]
v25 = v14;
if ( (_DWORD)a3 == 3 )
{
v16 = "constructor requires 'new'";
LABEL_10:
v22 = 0LL;
JS_ThrowTypeError(a1, (long long)v16, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v25);
return v22;
}
v17 = (_DWORD *)*a5;
v18 = a5[1];
if ( !(unsigned int)JS_IsFunction(a1, *a5, v18) )
{
v16 = "argument must be a function";
goto LABEL_10;
}
v19 = js_create_from_ctor(a1, a2, a3, 59);
v21 = v20;
if ( (_DWORD)v20 == 6 )
return 0LL;
v22 = v19;
v23 = (_QWORD *)js_malloc(a1, 40LL);
if ( !v23 )
{
JS_FreeValue(a1, v22, v21);
return 0LL;
}
*v23 = v23;
v23[1] = v23;
v23[2] = a1;
if ( (unsigned int)v18 >= 0xFFFFFFF7 )
++*v17;
v23[3] = v17;
v23[4] = v18;
*(_QWORD *)(v22 + 48) = v23;
return v22;
}
| js_finrec_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R14,RDI
CMP EBX,0x3
JNZ 0x0013359d
LEA RSI,[0x188b7a]
JMP 0x00133613
LAB_0013359d:
MOV R15,RSI
MOV R12,qword ptr [R8]
MOV R13,qword ptr [R8 + 0x8]
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL 0x0011ce7d
TEST EAX,EAX
JZ 0x0013360c
PUSH 0x3b
POP RCX
MOV RDI,R14
MOV RSI,R15
MOV RDX,RBX
CALL 0x0013045a
MOV R15,RDX
PUSH 0x6
POP RBP
CMP R15D,0x6
JZ 0x00133633
MOV RBX,RAX
PUSH 0x28
POP RSI
MOV RDI,R14
CALL 0x00117214
TEST RAX,RAX
JZ 0x00133625
MOV qword ptr [RAX],RAX
MOV qword ptr [RAX + 0x8],RAX
MOV qword ptr [RAX + 0x10],R14
CMP R13D,-0x9
JC 0x001335fe
INC dword ptr [R12]
LAB_001335fe:
MOV qword ptr [RAX + 0x18],R12
MOV qword ptr [RAX + 0x20],R13
MOV qword ptr [RBX + 0x30],RAX
JMP 0x00133638
LAB_0013360c:
LEA RSI,[0x18973f]
LAB_00133613:
XOR EBX,EBX
MOV RDI,R14
XOR EAX,EAX
CALL 0x0011c64d
PUSH 0x6
POP R15
JMP 0x00133638
LAB_00133625:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0011801e
LAB_00133633:
XOR EBX,EBX
MOV R15,RBP
LAB_00133638:
MOV RAX,RBX
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int1 [16]
js_finrec_constructor
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int *piVar1;
int8 uVar2;
int iVar3;
long lVar4;
char *pcVar5;
int1 auVar6 [16];
if ((int)param_3 == 3) {
pcVar5 = "constructor requires \'new\'";
}
else {
piVar1 = (int *)*param_5;
uVar2 = param_5[1];
iVar3 = JS_IsFunction(param_1,piVar1,uVar2);
if (iVar3 != 0) {
auVar6 = js_create_from_ctor(param_1,param_2,param_3,0x3b);
if (auVar6._8_4_ != 6) {
lVar4 = js_malloc(param_1,0x28);
if (lVar4 != 0) {
*(long *)lVar4 = lVar4;
*(long *)(lVar4 + 8) = lVar4;
*(int8 *)(lVar4 + 0x10) = param_1;
if (0xfffffff6 < (uint)uVar2) {
*piVar1 = *piVar1 + 1;
}
*(int **)(lVar4 + 0x18) = piVar1;
*(int8 *)(lVar4 + 0x20) = uVar2;
*(long *)(auVar6._0_8_ + 0x30) = lVar4;
return auVar6;
}
JS_FreeValue(param_1,auVar6._0_8_,auVar6._8_8_);
}
return ZEXT816(6) << 0x40;
}
pcVar5 = "argument must be a function";
}
JS_ThrowTypeError(param_1,pcVar5);
return ZEXT816(6) << 0x40;
}
| |
24,460 | Window_funcs_sort::exec(JOIN*, bool) | eloqsql/sql/sql_window.cc | bool Window_funcs_sort::exec(JOIN *join, bool keep_filesort_result)
{
THD *thd= join->thd;
JOIN_TAB *join_tab= join->join_tab + join->total_join_tab_cnt();
/* Sort the table based on the most specific sorting criteria of
the window functions. */
if (create_sort_index(thd, join, join_tab, filesort))
return true;
TABLE *tbl= join_tab->table;
SORT_INFO *filesort_result= join_tab->filesort_result;
bool is_error= runner.exec(thd, tbl, filesort_result);
if (!keep_filesort_result)
{
delete join_tab->filesort_result;
join_tab->filesort_result= NULL;
}
return is_error;
} | O0 | cpp | Window_funcs_sort::exec(JOIN*, bool):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq 0x1a0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x97e140
movq -0x58(%rbp), %rcx
movl %eax, %edx
movq -0x50(%rbp), %rax
movl %edx, %edx
imulq $0x3b0, %rdx, %rdx # imm = 0x3B0
addq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x28(%rax), %rcx
callq 0x96b0d0
cmpl $0x0, %eax
je 0xb1c34f
movb $0x1, -0x1(%rbp)
jmp 0xb1c3d0
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x350(%rax), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0xb1c1b0
andb $0x1, %al
movb %al, -0x41(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xb1c3c8
movq -0x30(%rbp), %rax
movq 0x350(%rax), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xb1c3b9
movq -0x60(%rbp), %rdi
callq 0xc14f10
movq -0x60(%rbp), %rdi
movl $0x190, %esi # imm = 0x190
callq 0x7581c0
movq -0x30(%rbp), %rax
movq $0x0, 0x350(%rax)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN17Window_funcs_sort4execEP4JOINb:
push rbp
mov rbp, rsp
sub rsp, 60h
mov al, dl
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
and al, 1
mov [rbp+var_19], al
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_18]
mov rax, [rax+1A0h]
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_58], rax
mov rdi, [rbp+var_18]; this
call _ZN4JOIN18total_join_tab_cntEv; JOIN::total_join_tab_cnt(void)
mov rcx, [rbp+var_58]
mov edx, eax
mov rax, [rbp+var_50]
mov edx, edx
imul rdx, 3B0h
add rcx, rdx
mov [rbp+var_30], rcx
mov rdi, [rbp+var_28]; THD *
mov rsi, [rbp+var_18]; JOIN *
mov rdx, [rbp+var_30]; st_join_table *
mov rcx, [rax+28h]; Filesort *
call _Z17create_sort_indexP3THDP4JOINP13st_join_tableP8Filesort; create_sort_index(THD *,JOIN *,st_join_table *,Filesort *)
cmp eax, 0
jz short loc_B1C34F
mov [rbp+var_1], 1
jmp loc_B1C3D0
loc_B1C34F:
mov rdi, [rbp+var_50]
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov rax, [rax+350h]
mov [rbp+var_40], rax
add rdi, 8; this
mov rsi, [rbp+var_28]; THD *
mov rdx, [rbp+var_38]; TABLE *
mov rcx, [rbp+var_40]; SORT_INFO *
call _ZN18Window_func_runner4execEP3THDP5TABLEP9SORT_INFO; Window_func_runner::exec(THD *,TABLE *,SORT_INFO *)
and al, 1
mov [rbp+var_41], al
test [rbp+var_19], 1
jnz short loc_B1C3C8
mov rax, [rbp+var_30]
mov rax, [rax+350h]
mov [rbp+var_60], rax
cmp rax, 0
jz short loc_B1C3B9
mov rdi, [rbp+var_60]; this
call _ZN9SORT_INFOD2Ev; SORT_INFO::~SORT_INFO()
mov rdi, [rbp+var_60]; void *
mov esi, 190h; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1C3B9:
mov rax, [rbp+var_30]
mov qword ptr [rax+350h], 0
loc_B1C3C8:
mov al, [rbp+var_41]
and al, 1
mov [rbp+var_1], al
loc_B1C3D0:
mov al, [rbp+var_1]
and al, 1
add rsp, 60h
pop rbp
retn
| char Window_funcs_sort::exec(Filesort **this, JOIN *a2, char a3)
{
SORT_INFO *v4; // [rsp+0h] [rbp-60h]
long long v5; // [rsp+8h] [rbp-58h]
char v6; // [rsp+1Fh] [rbp-41h]
SORT_INFO **v7; // [rsp+30h] [rbp-30h]
THD *v8; // [rsp+38h] [rbp-28h]
char v9; // [rsp+47h] [rbp-19h]
v9 = a3 & 1;
v8 = (THD *)*((_QWORD *)a2 + 52);
v5 = *(_QWORD *)a2;
v7 = (SORT_INFO **)(944LL * (unsigned int)JOIN::total_join_tab_cnt(a2) + v5);
if ( (unsigned int)create_sort_index(v8, a2, (st_join_table *)v7, this[5]) )
return 1;
v6 = Window_func_runner::exec((Window_func_runner *)(this + 1), v8, *v7, v7[106]) & 1;
if ( (v9 & 1) == 0 )
{
v4 = v7[106];
if ( v4 )
{
SORT_INFO::~SORT_INFO(v4);
operator delete(v4, 0x190uLL);
}
v7[106] = 0LL;
}
return v6;
}
| check_period_overlaps:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
JMP 0x00b1c2e9
LAB_00b1c2e9:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
SUB EAX,0x2
MOV dword ptr [RBP + -0x24],EAX
MOV dword ptr [RBP + -0x28],0x0
LAB_00b1c2fd:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x00b1c3de
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x28]
SHL RCX,0x5
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x28]
SHL RCX,0x5
ADD RAX,RCX
CMP byte ptr [RAX + 0x1f],0x0
JZ 0x00b1c369
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00a80e50
TEST AL,0x1
JNZ 0x00b1c35e
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00a80e50
TEST AL,0x1
JNZ 0x00b1c35e
JMP 0x00b1c367
LAB_00b1c35e:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00b1c4b8
LAB_00b1c367:
JMP 0x00b1c369
LAB_00b1c369:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x28]
SHL RCX,0x5
ADD RAX,RCX
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00b21180
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00b21180
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x58]
MOV RDX,RAX
MOV EAX,dword ptr [RBP + -0x34]
MOV ECX,EAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x1e8]
CMP EAX,0x0
JZ 0x00b1c3ce
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00b1c4b8
LAB_00b1c3ce:
JMP 0x00b1c3d0
LAB_00b1c3d0:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00b1c2fd
LAB_00b1c3de:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
SUB EAX,0x1
MOV dword ptr [RBP + -0x38],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x10]
SUB EAX,0x2
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x38]
SHL RCX,0x5
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x3c]
SHL RCX,0x5
ADD RAX,RCX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00b21180
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00b21180
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x68]
MOV RDX,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x1f0]
CMP EAX,0x0
JG 0x00b1c46f
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00b1c4b8
LAB_00b1c46f:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00b21180
MOV qword ptr [RBP + -0x78],RAX
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00b21180
MOV RDI,qword ptr [RBP + -0x80]
MOV RSI,qword ptr [RBP + -0x78]
MOV RDX,RAX
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x1f0]
CMP EAX,0x0
JL 0x00b1c4b4
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00b1c4b8
LAB_00b1c4b4:
MOV byte ptr [RBP + -0x1],0x1
LAB_00b1c4b8:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x80
POP RBP
RET
|
/* TABLE::check_period_overlaps(st_key const&, unsigned char const*, unsigned char const*) */
int1 TABLE::check_period_overlaps(st_key *param_1,uchar *param_2,uchar *param_3)
{
int4 uVar1;
Field *pFVar2;
Field *this;
int iVar3;
int iVar4;
ulong uVar5;
int8 uVar6;
int8 uVar7;
uint local_30;
int1 local_9;
iVar4 = *(int *)(param_1 + 0x10);
local_30 = 0;
while( true ) {
if (iVar4 - 2U <= local_30) {
pFVar2 = *(Field **)(*(long *)(param_1 + 0x68) + (ulong)(*(int *)(param_1 + 0x10) - 1) * 0x20)
;
this = *(Field **)(*(long *)(param_1 + 0x68) + (ulong)(*(int *)(param_1 + 0x10) - 2) * 0x20);
uVar6 = Field::ptr_in_record(this,param_2);
uVar7 = Field::ptr_in_record(pFVar2,param_3);
iVar4 = (**(code **)(*(long *)pFVar2 + 0x1f0))(pFVar2,uVar6,uVar7);
if (iVar4 < 1) {
local_9 = 0;
}
else {
uVar6 = Field::ptr_in_record(pFVar2,param_2);
uVar7 = Field::ptr_in_record(this,param_3);
iVar4 = (**(code **)(*(long *)pFVar2 + 0x1f0))(pFVar2,uVar6,uVar7);
if (iVar4 < 0) {
local_9 = 1;
}
else {
local_9 = 0;
}
}
return local_9;
}
pFVar2 = *(Field **)(*(long *)(param_1 + 0x68) + (ulong)local_30 * 0x20);
if ((*(char *)(*(long *)(param_1 + 0x68) + (ulong)local_30 * 0x20 + 0x1f) != '\0') &&
((uVar5 = Field::is_null_in_record(pFVar2,param_2), (uVar5 & 1) != 0 ||
(uVar5 = Field::is_null_in_record(pFVar2,param_3), (uVar5 & 1) != 0)))) break;
uVar1 = *(int4 *)(*(long *)(param_1 + 0x68) + (ulong)local_30 * 0x20 + 0x10);
uVar6 = Field::ptr_in_record(pFVar2,param_2);
uVar7 = Field::ptr_in_record(pFVar2,param_3);
iVar3 = (**(code **)(*(long *)pFVar2 + 0x1e8))(pFVar2,uVar6,uVar7,uVar1);
if (iVar3 != 0) {
return 0;
}
local_30 = local_30 + 1;
}
return 0;
}
| |
24,461 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_binary() const | llama.cpp/common/json.hpp | const binary_t& get_binary() const
{
if (!is_binary())
{
JSON_THROW(type_error::create(302, detail::concat("type must be binary, but is ", type_name()), this));
}
return *get_ptr<const binary_t*>();
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::get_binary() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
cmpb $0x8, (%rdi)
jne 0xcc8ef
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x20680
movq %rax, %rbx
movq %r14, %rdi
callq 0x8e128
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x56846(%rip), %rsi # 0x123159
leaq 0x10(%rsp), %rdi
callq 0x83ab4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0xbfb0c
xorl %ebp, %ebp
leaq 0x97702(%rip), %rsi # 0x164040
leaq -0x5294d(%rip), %rdx # 0x79ff8
movq %rbx, %rdi
callq 0x20ab0
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcc96b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x20180
testb %bpl, %bpl
jne 0xcc975
jmp 0xcc97d
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f60
movq %r14, %rdi
callq 0x20b50
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; void *
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_CC8EF
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_CC8EF:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aTypeMustBeBina; "type must be binary, but is "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA29_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(char const(&)[29],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 12Eh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_CC96B
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CC96B:
test bpl, bpl
jnz short loc_CC975
jmp short loc_CC97D
mov r14, rax
loc_CC975:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_CC97D:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_binary(
long long a1)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
const char *v3; // [rsp+8h] [rbp-40h] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 != 8 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[29],char const*>(
(long long)v4,
(long long)"type must be binary, but is ",
&v3);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
exception,
302,
v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return *(_QWORD *)(a1 + 8);
}
| get_binary:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RDI
CMP byte ptr [RDI],0x8
JNZ 0x001cc8ef
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001cc8ef:
MOV EDI,0x20
CALL 0x00120680
MOV RBX,RAX
MOV RDI,R14
CALL 0x0018e128
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001cc90c:
LEA RSI,[0x223159]
LEA RDI,[RSP + 0x10]
CALL 0x00183ab4
MOV BPL,0x1
LAB_001cc920:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x001bfb0c
XOR EBP,EBP
LEA RSI,[0x264040]
LEA RDX,[0x179ff8]
MOV RDI,RBX
CALL 0x00120ab0
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>::get_binary() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::get_binary(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x8) {
return *(int8 *)(this + 8);
}
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001cc90c to 001cc91c has its CatchHandler @ 001cc972 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 001cc920 to 001cc94c has its CatchHandler @ 001cc94d */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
24,462 | google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.cc | void CodedInputStream::BackUpInputToCurrentPosition() {
int backup_bytes = BufferSize() + buffer_size_after_limit_ + overflow_bytes_;
if (backup_bytes > 0) {
input_->BackUp(backup_bytes);
// total_bytes_read_ doesn't include overflow_bytes_.
total_bytes_read_ -= BufferSize() + buffer_size_after_limit_;
buffer_end_ = buffer_;
buffer_size_after_limit_ = 0;
overflow_bytes_ = 0;
}
} | O0 | cpp | google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x21f90
movq (%rsp), %rcx
addl 0x2c(%rcx), %eax
addl 0x1c(%rcx), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x1e65d
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movl 0xc(%rsp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rdi
callq 0x21f90
movl %eax, %edx
movq (%rsp), %rax
addl 0x2c(%rax), %edx
movl 0x18(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x18(%rax)
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x1c(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf2io16CodedInputStream28BackUpInputToCurrentPositionEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rdi, [rsp+18h+var_8]; this
mov [rsp+18h+var_18], rdi
call _ZNK6google8protobuf2io16CodedInputStream10BufferSizeEv; google::protobuf::io::CodedInputStream::BufferSize(void)
mov rcx, [rsp+18h+var_18]
add eax, [rcx+2Ch]
add eax, [rcx+1Ch]
mov [rsp+18h+var_C], eax
cmp [rsp+18h+var_C], 0
jle short loc_1E65D
mov rax, [rsp+18h+var_18]
mov rdi, [rax+10h]
mov esi, [rsp+18h+var_C]
mov rax, [rdi]
call qword ptr [rax+18h]
mov rdi, [rsp+18h+var_18]; this
call _ZNK6google8protobuf2io16CodedInputStream10BufferSizeEv; google::protobuf::io::CodedInputStream::BufferSize(void)
mov edx, eax
mov rax, [rsp+18h+var_18]
add edx, [rax+2Ch]
mov ecx, [rax+18h]
sub ecx, edx
mov [rax+18h], ecx
mov rcx, [rax]
mov [rax+8], rcx
mov dword ptr [rax+2Ch], 0
mov dword ptr [rax+1Ch], 0
loc_1E65D:
add rsp, 18h
retn
| long long google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition(
google::protobuf::io::CodedInputStream *this)
{
long long result; // rax
int v2; // edx
result = *((_DWORD *)this + 7)
+ *((_DWORD *)this + 11)
+ (unsigned int)google::protobuf::io::CodedInputStream::BufferSize(this);
if ( (int)result > 0 )
{
(*(void ( **)(_QWORD, _QWORD))(**((_QWORD **)this + 2) + 24LL))(
*((_QWORD *)this + 2),
(unsigned int)result);
v2 = google::protobuf::io::CodedInputStream::BufferSize(this);
result = (long long)this;
*((_DWORD *)this + 6) -= *((_DWORD *)this + 11) + v2;
*((_QWORD *)this + 1) = *(_QWORD *)this;
*((_DWORD *)this + 11) = 0;
*((_DWORD *)this + 7) = 0;
}
return result;
}
| BackUpInputToCurrentPosition:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RDI,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RDI
CALL 0x00121f90
MOV RCX,qword ptr [RSP]
ADD EAX,dword ptr [RCX + 0x2c]
ADD EAX,dword ptr [RCX + 0x1c]
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0xc],0x0
JLE 0x0011e65d
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x10]
MOV ESI,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RSP]
CALL 0x00121f90
MOV EDX,EAX
MOV RAX,qword ptr [RSP]
ADD EDX,dword ptr [RAX + 0x2c]
MOV ECX,dword ptr [RAX + 0x18]
SUB ECX,EDX
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RAX]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x2c],0x0
MOV dword ptr [RAX + 0x1c],0x0
LAB_0011e65d:
ADD RSP,0x18
RET
|
/* google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition() */
void __thiscall
google::protobuf::io::CodedInputStream::BackUpInputToCurrentPosition(CodedInputStream *this)
{
int iVar1;
iVar1 = BufferSize(this);
iVar1 = iVar1 + *(int *)(this + 0x2c) + *(int *)(this + 0x1c);
if (0 < iVar1) {
(**(code **)(**(long **)(this + 0x10) + 0x18))(*(long **)(this + 0x10),iVar1);
iVar1 = BufferSize(this);
*(int *)(this + 0x18) = *(int *)(this + 0x18) - (iVar1 + *(int *)(this + 0x2c));
*(int8 *)(this + 8) = *(int8 *)this;
*(int4 *)(this + 0x2c) = 0;
*(int4 *)(this + 0x1c) = 0;
}
return;
}
| |
24,463 | parse_name(char const*) | monkey531[P]llama/src/llama-grammar.cpp | static const char * parse_name(const char * src) {
const char * pos = src;
while (is_word_char(*pos)) {
pos++;
}
if (pos == src) {
throw std::runtime_error(std::string("expecting name at ") + src);
}
return pos;
} | O3 | cpp | parse_name(char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
xorl %eax, %eax
movb (%r14,%rax), %cl
leal -0x61(%rcx), %edx
cmpb $0x1a, %dl
jb 0xa2ff3
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0xa2ff3
cmpb $0x2d, %cl
je 0xa2ff3
addb $-0x41, %cl
cmpb $0x19, %cl
ja 0xa2ff8
incq %rax
jmp 0xa2fd2
testq %rax, %rax
je 0xa3010
addq %rax, %r14
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x65cb0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x727a6(%rip), %rsi # 0x1157d3
leaq 0x727b1(%rip), %rdx # 0x1157e5
movq %rsp, %rdi
callq 0x65680
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6bef0
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xa306a
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xa3077
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x6aa30
xorl %ebp, %ebp
movq 0xb9f49(%rip), %rsi # 0x15cff0
movq 0xb9c42(%rip), %rdx # 0x15ccf0
movq %rbx, %rdi
callq 0x6b270
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xa30d0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x681a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa30e6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x681a0
testb %bpl, %bpl
jne 0xa310b
jmp 0xa3113
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xa310b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x681a0
jmp 0xa310b
movq %rax, %r14
movq %rbx, %rdi
callq 0x66d40
movq %r14, %rdi
callq 0x6b5d0
nop
| _ZL10parse_namePKc:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 40h
mov r14, rdi
xor eax, eax
loc_A2FD2:
mov cl, [r14+rax]
lea edx, [rcx-61h]
cmp dl, 1Ah
jb short loc_A2FF3
lea edx, [rcx-30h]
cmp dl, 0Ah
jb short loc_A2FF3
cmp cl, 2Dh ; '-'
jz short loc_A2FF3
add cl, 0BFh
cmp cl, 19h
ja short loc_A2FF8
loc_A2FF3:
inc rax
jmp short loc_A2FD2
loc_A2FF8:
test rax, rax
jz short loc_A3010
add r14, rax
mov rax, r14
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A3010:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aExpectingNameA; "expecting name at "
lea rdx, aExpectingNameA+12h; ""
mov rdi, rsp
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rsp
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
lea r12, [rsp+68h+var_38]
mov [r12-10h], r12
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jnz short loc_A306A
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
jmp short loc_A3077
loc_A306A:
mov [rsp+68h+var_48], rdx
mov rdx, [rcx]
mov [rsp+68h+var_38], rdx
loc_A3077:
mov rdx, [rax+8]
lea rsi, [rsp+68h+var_48]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov bpl, 1
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+68h+var_48]; void *
cmp rdi, r12
jz short loc_A30D0
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A30D0:
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r15
jz short loc_A30E6
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A30E6:
test bpl, bpl
jnz short loc_A310B
jmp short loc_A3113
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r15
jz short loc_A310B
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A310B
mov r14, rax
loc_A310B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A3113:
mov rdi, r14
call __Unwind_Resume
| const char * parse_name(const char *a1)
{
long long i; // rax
char v2; // cl
void *exception; // rbx
long long v5; // rax
__int128 *v6; // rcx
void *v7[2]; // [rsp+0h] [rbp-68h] BYREF
long long v8; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
__int128 v10; // [rsp+30h] [rbp-38h] BYREF
for ( i = 0LL; ; ++i )
{
v2 = a1[i];
if ( (unsigned __int8)(v2 - 97) >= 0x1Au
&& (unsigned __int8)(v2 - 48) >= 0xAu
&& v2 != 45
&& (unsigned __int8)(v2 - 65) > 0x19u )
{
break;
}
}
if ( !i )
{
exception = __cxa_allocate_exception(0x10uLL);
v7[0] = &v8;
std::string::_M_construct<char const*>(v7, "expecting name at ", "");
v5 = std::string::append(v7, a1);
v9[0] = &v10;
v6 = (__int128 *)(v5 + 16);
if ( *(_QWORD *)v5 == v5 + 16 )
{
v10 = *v6;
}
else
{
v9[0] = *(void **)v5;
*(_QWORD *)&v10 = *(_QWORD *)v6;
}
v9[1] = *(void **)(v5 + 8);
*(_QWORD *)v5 = v6;
*(_QWORD *)(v5 + 8) = 0LL;
*(_BYTE *)(v5 + 16) = 0;
std::runtime_error::runtime_error(exception, v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return &a1[i];
}
| parse_name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
XOR EAX,EAX
LAB_001a2fd2:
MOV CL,byte ptr [R14 + RAX*0x1]
LEA EDX,[RCX + -0x61]
CMP DL,0x1a
JC 0x001a2ff3
LEA EDX,[RCX + -0x30]
CMP DL,0xa
JC 0x001a2ff3
CMP CL,0x2d
JZ 0x001a2ff3
ADD CL,0xbf
CMP CL,0x19
JA 0x001a2ff8
LAB_001a2ff3:
INC RAX
JMP 0x001a2fd2
LAB_001a2ff8:
TEST RAX,RAX
JZ 0x001a3010
ADD R14,RAX
MOV RAX,R14
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a3010:
MOV EDI,0x10
CALL 0x00165cb0
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_001a3026:
LEA RSI,[0x2157d3]
LEA RDX,[0x2157e5]
MOV RDI,RSP
CALL 0x00165680
LAB_001a303c:
MOV RDI,RSP
MOV RSI,R14
CALL 0x0016bef0
LEA R12,[RSP + 0x30]
MOV qword ptr [R12 + -0x10],R12
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JNZ 0x001a306a
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
JMP 0x001a3077
LAB_001a306a:
MOV qword ptr [RSP + 0x20],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x30],RDX
LAB_001a3077:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
MOV BPL,0x1
LAB_001a3096:
MOV RDI,RBX
CALL 0x0016aa30
XOR EBP,EBP
MOV RSI,qword ptr [0x0025cff0]
MOV RDX,qword ptr [0x0025ccf0]
MOV RDI,RBX
CALL 0x0016b270
|
/* parse_name(char const*) */
char * parse_name(char *param_1)
{
char cVar1;
long lVar2;
runtime_error *this;
long *plVar3;
long *plVar4;
int1 *local_68 [2];
int1 local_58 [16];
long *local_48;
long local_40;
long local_38;
long lStack_30;
lVar2 = 0;
while( true ) {
cVar1 = param_1[lVar2];
if ((((0x19 < (byte)(cVar1 + 0x9fU)) && (9 < (byte)(cVar1 - 0x30U))) && (cVar1 != '-')) &&
(0x19 < (byte)(cVar1 + 0xbfU))) break;
lVar2 = lVar2 + 1;
}
if (lVar2 != 0) {
return param_1 + lVar2;
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
local_68[0] = local_58;
/* try { // try from 001a3026 to 001a303b has its CatchHandler @ 001a3108 */
std::__cxx11::string::_M_construct<char_const*>(local_68,"expecting name at ","");
/* try { // try from 001a303c to 001a3046 has its CatchHandler @ 001a30ed */
plVar3 = (long *)std::__cxx11::string::append((char *)local_68);
local_48 = (long *)*plVar3;
plVar4 = plVar3 + 2;
if (local_48 == plVar4) {
local_38 = *plVar4;
lStack_30 = plVar3[3];
local_48 = &local_38;
}
else {
local_38 = *plVar4;
}
local_40 = plVar3[1];
*plVar3 = (long)plVar4;
plVar3[1] = 0;
*(int1 *)(plVar3 + 2) = 0;
/* try { // try from 001a3096 to 001a30b5 has its CatchHandler @ 001a30b6 */
std::runtime_error::runtime_error(this,(string *)&local_48);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_0025cff0,PTR__runtime_error_0025ccf0);
}
| |
24,464 | my_b_cache_write_r | eloqsql/mysys/mf_iocache.c | static int _my_b_cache_write_r(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
my_off_t old_pos_in_file= info->pos_in_file;
int res= _my_b_cache_write(info, Buffer, Count);
if (res)
return res;
DBUG_ASSERT(!(info->myflags & MY_ENCRYPT));
DBUG_ASSERT(info->share);
copy_to_read_buffer(info, Buffer, old_pos_in_file);
return 0;
} | O3 | c | my_b_cache_write_r:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdi), %r15
movq %rdi, -0x30(%rbp)
callq 0x99b5d
testl %eax, %eax
jne 0x98b0a
movq -0x30(%rbp), %rax
movq (%rax), %r12
xorl %eax, %eax
subq %r15, %r12
je 0x98b0a
movq %r15, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x98(%rax), %r15
movq -0x30(%rbp), %r14
movq 0xe8(%r14), %r13
cmpq %r13, %r12
cmovbq %r12, %r13
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x99d2e
movq 0xc8(%r15), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x29090
movl $0x0, 0xe0(%r15)
movq 0xc8(%r15), %rax
addq %r13, %rax
movq %rax, 0xd0(%r15)
movq -0x38(%rbp), %rax
movq %rax, 0xb8(%r15)
movq 0x98(%r14), %rdi
callq 0x99f2f
addq %r13, %rbx
subq %r13, %r12
jne 0x98aa1
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _my_b_cache_write_r:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r15, [rdi]
mov [rbp+var_30], rdi
call _my_b_cache_write
test eax, eax
jnz loc_98B0A
mov rax, [rbp+var_30]
mov r12, [rax]
xor eax, eax
sub r12, r15
jz short loc_98B0A
mov [rbp+var_38], r15
mov rax, [rbp+var_30]
mov r15, [rax+98h]
mov r14, [rbp+var_30]
loc_98AA1:
mov r13, [r14+0E8h]
cmp r12, r13
cmovb r13, r12
mov rdi, r14
mov rsi, [rbp+var_38]
call lock_io_cache
mov rdi, [r15+0C8h]
mov rsi, rbx
mov rdx, r13
call _memcpy
mov dword ptr [r15+0E0h], 0
mov rax, [r15+0C8h]
add rax, r13
mov [r15+0D0h], rax
mov rax, [rbp+var_38]
mov [r15+0B8h], rax
mov rdi, [r14+98h]
call unlock_io_cache
add rbx, r13
sub r12, r13
jnz short loc_98AA1
xor eax, eax
loc_98B0A:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_b_cache_write_r(long long *a1, long long a2)
{
long long v3; // r15
long long result; // rax
unsigned long long v5; // r12
long long v6; // r15
unsigned long long v7; // r13
long long v8; // [rsp+8h] [rbp-38h]
v3 = *a1;
result = my_b_cache_write();
if ( !(_DWORD)result )
{
result = 0LL;
v5 = *a1 - v3;
if ( *a1 != v3 )
{
v8 = v3;
v6 = a1[19];
do
{
v7 = a1[29];
if ( v5 < v7 )
v7 = v5;
lock_io_cache(a1, v8);
memcpy(*(_QWORD *)(v6 + 200), a2, v7);
*(_DWORD *)(v6 + 224) = 0;
*(_QWORD *)(v6 + 208) = v7 + *(_QWORD *)(v6 + 200);
*(_QWORD *)(v6 + 184) = v8;
unlock_io_cache(a1[19]);
a2 += v7;
v5 -= v7;
}
while ( v5 );
return 0LL;
}
}
return result;
}
| _my_b_cache_write_r:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R15,qword ptr [RDI]
MOV qword ptr [RBP + -0x30],RDI
CALL 0x00199b5d
TEST EAX,EAX
JNZ 0x00198b0a
MOV RAX,qword ptr [RBP + -0x30]
MOV R12,qword ptr [RAX]
XOR EAX,EAX
SUB R12,R15
JZ 0x00198b0a
MOV qword ptr [RBP + -0x38],R15
MOV RAX,qword ptr [RBP + -0x30]
MOV R15,qword ptr [RAX + 0x98]
MOV R14,qword ptr [RBP + -0x30]
LAB_00198aa1:
MOV R13,qword ptr [R14 + 0xe8]
CMP R12,R13
CMOVC R13,R12
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00199d2e
MOV RDI,qword ptr [R15 + 0xc8]
MOV RSI,RBX
MOV RDX,R13
CALL 0x00129090
MOV dword ptr [R15 + 0xe0],0x0
MOV RAX,qword ptr [R15 + 0xc8]
ADD RAX,R13
MOV qword ptr [R15 + 0xd0],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [R15 + 0xb8],RAX
MOV RDI,qword ptr [R14 + 0x98]
CALL 0x00199f2f
ADD RBX,R13
SUB R12,R13
JNZ 0x00198aa1
XOR EAX,EAX
LAB_00198b0a:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 _my_b_cache_write_r(long *param_1,void *param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
ulong uVar4;
ulong __n;
lVar1 = *param_1;
uVar3 = _my_b_cache_write();
if ((int)uVar3 == 0) {
uVar3 = 0;
uVar4 = *param_1 - lVar1;
if (uVar4 != 0) {
lVar2 = param_1[0x13];
do {
__n = param_1[0x1d];
if (uVar4 < (ulong)param_1[0x1d]) {
__n = uVar4;
}
lock_io_cache(param_1,lVar1);
memcpy(*(void **)(lVar2 + 200),param_2,__n);
*(int4 *)(lVar2 + 0xe0) = 0;
*(ulong *)(lVar2 + 0xd0) = *(long *)(lVar2 + 200) + __n;
*(long *)(lVar2 + 0xb8) = lVar1;
unlock_io_cache(param_1[0x13]);
param_2 = (void *)((long)param_2 + __n);
uVar4 = uVar4 - __n;
} while (uVar4 != 0);
uVar3 = 0;
}
}
return uVar3;
}
| |
24,465 | minja::LoopControlException::LoopControlException(minja::LoopControlType) | monkey531[P]llama/common/minja.hpp | LoopControlException(LoopControlType control_type)
: std::runtime_error((control_type == LoopControlType::Continue ? "continue" : "break") + std::string(" outside of a loop")),
control_type(control_type) {} | O3 | cpp | minja::LoopControlException::LoopControlException(minja::LoopControlType):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x48305(%rip), %rsi # 0xb194a
leaq 0x48310(%rip), %rdx # 0xb195c
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x20d82
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
leaq 0x454a9(%rip), %rdx # 0xaeb11
leaq 0x4549c(%rip), %rcx # 0xaeb0b
cmoveq %rdx, %rcx
leaq (%rax,%rax,2), %r8
addq $0x5, %r8
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1a850
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x696ae
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x696b5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
callq 0x1a940
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x696f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a740
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x69707
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a740
leaq 0x7891a(%rip), %rax # 0xe2028
addq $0x10, %rax
movq %rax, (%r14)
movl %ebx, 0x10(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x69744
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a740
jmp 0x69744
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6975b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1a740
movq %rbx, %rdi
callq 0x1ad30
nop
| _ZN5minja20LoopControlExceptionC2ENS_15LoopControlTypeE:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov ebx, esi
mov r14, rdi
lea r12, [rsp+68h+var_30]
mov [r12-10h], r12
lea rsi, aOutsideOfALoop; " outside of a loop"
lea rdx, aOutsideOfALoop+12h; ""
lea r15, [rsp+68h+var_40]
mov rdi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
xor eax, eax
cmp ebx, 1
setz al
lea rdx, aContinue; "continue"
lea rcx, aBreak; "break"
cmovz rcx, rdx
lea r8, [rax+rax*2]
add r8, 5
mov rdi, r15
xor esi, esi
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7replaceEmmPKcm; std::string::replace(ulong,ulong,char const*,ulong)
lea r15, [rsp+68h+var_50]
mov [r15-10h], r15
mov rdx, [rax]
mov rcx, rax
add rcx, 10h
cmp rdx, rcx
jz short loc_696AE
mov [rsp+68h+var_60], rdx
mov rdx, [rcx]
mov [rsp+68h+var_50], rdx
jmp short loc_696B5
loc_696AE:
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r15], xmm0
loc_696B5:
mov rdx, [rax+8]
lea rsi, [rsp+68h+var_60]
mov [rsi+8], rdx
mov [rax], rcx
mov qword ptr [rax+8], 0
mov byte ptr [rax+10h], 0
mov rdi, r14
call __ZNSt13runtime_errorC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
mov rdi, [rsp+68h+var_60]; void *
cmp rdi, r15
jz short loc_696F0
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_696F0:
mov rdi, [rsp+68h+var_40]; void *
cmp rdi, r12
jz short loc_69707
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_69707:
lea rax, _ZTVN5minja20LoopControlExceptionE; `vtable for'minja::LoopControlException
add rax, 10h
mov [r14], rax
mov [r14+10h], ebx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r15
jz short loc_69744
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_69744
mov rbx, rax
loc_69744:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r12
jz short loc_6975B
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6975B:
mov rdi, rbx
call __Unwind_Resume
| long long * minja::LoopControlException::LoopControlException(long long a1, int a2)
{
const char *v2; // rcx
long long v3; // rax
__int128 *v4; // rcx
long long *result; // rax
void *v6[2]; // [rsp+8h] [rbp-60h] BYREF
__int128 v7; // [rsp+18h] [rbp-50h] BYREF
void *v8[2]; // [rsp+28h] [rbp-40h] BYREF
_QWORD v9[6]; // [rsp+38h] [rbp-30h] BYREF
v8[0] = v9;
std::string::_M_construct<char const*>((long long)v8, " outside of a loop", (long long)"");
v2 = "break";
if ( a2 == 1 )
v2 = "continue";
v3 = std::string::replace(v8, 0LL, 0LL, v2, 3LL * (a2 == 1) + 5);
v6[0] = &v7;
v4 = (__int128 *)(v3 + 16);
if ( *(_QWORD *)v3 == v3 + 16 )
{
v7 = *v4;
}
else
{
v6[0] = *(void **)v3;
*(_QWORD *)&v7 = *(_QWORD *)v4;
}
v6[1] = *(void **)(v3 + 8);
*(_QWORD *)v3 = v4;
*(_QWORD *)(v3 + 8) = 0LL;
*(_BYTE *)(v3 + 16) = 0;
std::runtime_error::runtime_error(a1, v6);
if ( v6[0] != &v7 )
operator delete(v6[0], v7 + 1);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
result = &`vtable for'minja::LoopControlException + 2;
*(_QWORD *)a1 = &`vtable for'minja::LoopControlException + 2;
*(_DWORD *)(a1 + 16) = a2;
return result;
}
| LoopControlException:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV EBX,ESI
MOV R14,RDI
LEA R12,[RSP + 0x38]
MOV qword ptr [R12 + -0x10],R12
LEA RSI,[0x1b194a]
LEA RDX,[0x1b195c]
LEA R15,[RSP + 0x28]
MOV RDI,R15
CALL 0x00120d82
XOR EAX,EAX
CMP EBX,0x1
SETZ AL
LEA RDX,[0x1aeb11]
LEA RCX,[0x1aeb0b]
CMOVZ RCX,RDX
LEA R8,[RAX + RAX*0x2]
ADD R8,0x5
LAB_0016967b:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0011a850
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
MOV RDX,qword ptr [RAX]
MOV RCX,RAX
ADD RCX,0x10
CMP RDX,RCX
JZ 0x001696ae
MOV qword ptr [RSP + 0x8],RDX
MOV RDX,qword ptr [RCX]
MOV qword ptr [RSP + 0x18],RDX
JMP 0x001696b5
LAB_001696ae:
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R15],XMM0
LAB_001696b5:
MOV RDX,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RAX],RCX
MOV qword ptr [RAX + 0x8],0x0
MOV byte ptr [RAX + 0x10],0x0
LAB_001696d1:
MOV RDI,R14
CALL 0x0011a940
LAB_001696d9:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R15
JZ 0x001696f0
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a740
LAB_001696f0:
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R12
JZ 0x00169707
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x0011a740
LAB_00169707:
LEA RAX,[0x1e2028]
ADD RAX,0x10
MOV qword ptr [R14],RAX
MOV dword ptr [R14 + 0x10],EBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* minja::LoopControlException::LoopControlException(minja::LoopControlType) */
void __thiscall
minja::LoopControlException::LoopControlException(LoopControlException *this,int param_2)
{
long *plVar1;
char *pcVar2;
long *plVar3;
long *local_60;
long local_58;
long local_50;
long lStack_48;
long *local_40 [2];
long local_30 [2];
local_40[0] = local_30;
std::__cxx11::string::_M_construct<char_const*>(local_40," outside of a loop","");
pcVar2 = "break";
if (param_2 == 1) {
pcVar2 = "continue";
}
/* try { // try from 0016967b to 00169686 has its CatchHandler @ 00169741 */
plVar1 = (long *)std::__cxx11::string::replace((ulong)local_40,0,(char *)0x0,(ulong)pcVar2);
plVar3 = plVar1 + 2;
if ((long *)*plVar1 == plVar3) {
local_50 = *plVar3;
lStack_48 = plVar1[3];
local_60 = &local_50;
}
else {
local_50 = *plVar3;
local_60 = (long *)*plVar1;
}
local_58 = plVar1[1];
*plVar1 = (long)plVar3;
plVar1[1] = 0;
*(int1 *)(plVar1 + 2) = 0;
/* try { // try from 001696d1 to 001696d8 has its CatchHandler @ 00169725 */
std::runtime_error::runtime_error((runtime_error *)this,(string *)&local_60);
if (local_60 != &local_50) {
operator_delete(local_60,local_50 + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
*(int ***)this = &PTR__runtime_error_001e2038;
*(int *)(this + 0x10) = param_2;
return;
}
| |
24,466 | psi_rwlock_rdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1d8066(%rip), %rax # 0x301e00
movq (%rax), %rax
movq 0x1a0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12db30
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x129df0
leaq 0x1d8023(%rip), %rax # 0x301e00
movq (%rax), %rax
movq 0x1a8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_rdlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
xor edx, edx
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_rdlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_129DF0
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1A8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_129DF0:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_rdlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[53])(v5, v4);
return v4;
}
| |||
24,467 | psi_rwlock_rdlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_rdlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_rdwait)
(&state, that->m_psi, PSI_RWLOCK_READLOCK, file, line);
int result= rw_rdlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_rdwait)(locker, result);
return result;
} | O3 | c | psi_rwlock_rdlock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %r14
leaq 0x38666a(%rip), %r15 # 0x3b8c08
movq (%r15), %rax
movq 0x90(%rdi), %rsi
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq *0x1a0(%rax)
movq %rax, %rbx
movq %r14, %rdi
callq 0xc89ec
movl %eax, %r14d
testq %rbx, %rbx
je 0x325d6
movq (%r15), %rax
movq %rbx, %rdi
movl %r14d, %esi
callq *0x1a8(%rax)
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| psi_rwlock_rdlock:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
mov r8d, edx
mov rcx, rsi
mov r14, rdi
lea r15, PSI_server
mov rax, [r15]
mov rsi, [rdi+90h]
lea rdi, [rbp+var_48]
xor edx, edx
call qword ptr [rax+1A0h]
mov rbx, rax
mov rdi, r14
call my_rw_rdlock
mov r14d, eax
test rbx, rbx
jz short loc_325D6
mov rax, [r15]
mov rdi, rbx
mov esi, r14d
call qword ptr [rax+1A8h]
loc_325D6:
mov eax, r14d
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
| long long psi_rwlock_rdlock(long long a1, long long a2, unsigned int a3)
{
long long v3; // rbx
unsigned int v4; // r14d
_BYTE v6[72]; // [rsp+8h] [rbp-48h] BYREF
v3 = ((long long ( *)(_BYTE *, _QWORD, _QWORD, long long, _QWORD))PSI_server[52])(
v6,
*(_QWORD *)(a1 + 144),
0LL,
a2,
a3);
v4 = my_rw_rdlock(a1);
if ( v3 )
((void ( *)(long long, _QWORD))PSI_server[53])(v3, v4);
return v4;
}
| psi_rwlock_rdlock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV R8D,EDX
MOV RCX,RSI
MOV R14,RDI
LEA R15,[0x4b8c08]
MOV RAX,qword ptr [R15]
MOV RSI,qword ptr [RDI + 0x90]
LEA RDI,[RBP + -0x48]
XOR EDX,EDX
CALL qword ptr [RAX + 0x1a0]
MOV RBX,RAX
MOV RDI,R14
CALL 0x001c89ec
MOV R14D,EAX
TEST RBX,RBX
JZ 0x001325d6
MOV RAX,qword ptr [R15]
MOV RDI,RBX
MOV ESI,R14D
CALL qword ptr [RAX + 0x1a8]
LAB_001325d6:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 psi_rwlock_rdlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [48];
lVar2 = (**(code **)(PSI_server + 0x1a0))
(local_50,*(int8 *)(param_1 + 0x90),0,param_2,param_3);
uVar1 = my_rw_rdlock(param_1);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1a8))(lVar2,uVar1);
}
return uVar1;
}
| |
24,468 | common_init() | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O0 | cpp | common_init():
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
xorl %eax, %eax
leaq 0x1b0ff8(%rip), %rcx # 0x2a6618
cmpl (%rcx), %eax
jg 0xf5643
callq 0x1be7b0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rcx
leaq 0x118ba8(%rip), %rdx # 0x20e1e4
movb $0x0, %al
callq 0x1be8a0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| _ZZ11common_initvENK3$_0clE14ggml_log_levelPKcPv:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov [rsp+28h+var_18], rdx
mov [rsp+28h+var_20], rcx
xor eax, eax
lea rcx, common_log_verbosity_thold
cmp eax, [rcx]
jg short loc_F5643
call _Z15common_log_mainv; common_log_main(void)
mov rdi, rax
mov esi, [rsp+28h+var_C]
mov rcx, [rsp+28h+var_18]
lea rdx, aSetCustomJinja_0+0FEh; "%s"
mov al, 0
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
loc_F5643:
add rsp, 28h
retn
| long long common_init(void)::$_0::operator()(long long a1, int a2, int a3)
{
long long result; // rax
int v4; // eax
int v5; // r8d
int v6; // r9d
result = 0LL;
if ( common_log_verbosity_thold >= 0 )
{
v4 = common_log_main();
return common_log_add(v4, a2, (unsigned int)"%s", a3, v5, v6);
}
return result;
}
| operator():
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x8],RCX
XOR EAX,EAX
LEA RCX,[0x3a6618]
CMP EAX,dword ptr [RCX]
JG 0x001f5643
CALL 0x002be7b0
MOV RDI,RAX
MOV ESI,dword ptr [RSP + 0x1c]
MOV RCX,qword ptr [RSP + 0x10]
LEA RDX,[0x30e1e4]
MOV AL,0x0
CALL 0x002be8a0
LAB_001f5643:
ADD RSP,0x28
RET
|
/* common_init()::$_0::TEMPNAMEPLACEHOLDERVALUE(ggml_log_level, char const*, void*) const */
void common_init()::$_0::operator()(int8 param_1,int4 param_2,int8 param_3)
{
int8 uVar1;
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,param_2,"%s",param_3);
}
return;
}
| |
24,469 | common_init() | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O1 | cpp | common_init():
pushq %rax
leaq 0x611d(%rip), %rdi # 0x780ce
xorl %esi, %esi
callq 0x1c050
leaq 0xbe479(%rip), %rax # 0x130438
cmpl $0x0, (%rax)
js 0x72013
callq 0xcd443
leaq 0xbdd68(%rip), %rcx # 0x12fd38
movl (%rcx), %ecx
leaq 0xbdd67(%rip), %rdx # 0x12fd40
movq (%rdx), %r8
leaq 0xbdd65(%rip), %rdx # 0x12fd48
movq (%rdx), %r9
leaq 0xbdd63(%rip), %r10 # 0x12fd50
leaq 0x7738d(%rip), %r11 # 0xe9381
leaq 0x7fbd2(%rip), %rdx # 0xf1bcd
movq %rax, %rdi
movl $0x2, %esi
xorl %eax, %eax
pushq %r11
pushq (%r10)
callq 0xcd4de
addq $0x10, %rsp
popq %rax
retq
| _Z11common_initv:
push rax
lea rdi, _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv; common_init(void)::$_0::__invoke(ggml_log_level,char const*,void *)
xor esi, esi
call _llama_log_set
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_72013
call _Z15common_log_mainv; common_log_main(void)
lea rcx, LLAMA_BUILD_NUMBER
mov ecx, [rcx]
lea rdx, LLAMA_COMMIT
mov r8, [rdx]
lea rdx, LLAMA_COMPILER
mov r9, [rdx]
lea r10, LLAMA_BUILD_TARGET
lea r11, aTarget+9; ""
lea rdx, aBuildDSWithSFo; "build: %d (%s) with %s for %s%s\n"
mov rdi, rax
mov esi, 2
xor eax, eax
push r11
push qword ptr [r10]
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
add rsp, 10h
loc_72013:
pop rax
retn
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> common_init(void)
{
int v0; // eax
llama_log_set(common_init(void)::$_0::__invoke, 0LL);
if ( common_log_verbosity_thold >= 0 )
{
v0 = common_log_main();
common_log_add(
v0,
2,
(unsigned int)"build: %d (%s) with %s for %s%s\n",
LLAMA_BUILD_NUMBER,
LLAMA_COMMIT[0],
LLAMA_COMPILER[0]);
}
}
| common_init:
PUSH RAX
LEA RDI,[0x1780ce]
XOR ESI,ESI
CALL 0x0011c050
LEA RAX,[0x230438]
CMP dword ptr [RAX],0x0
JS 0x00172013
CALL 0x001cd443
LEA RCX,[0x22fd38]
MOV ECX,dword ptr [RCX]
LEA RDX,[0x22fd40]
MOV R8,qword ptr [RDX]
LEA RDX,[0x22fd48]
MOV R9,qword ptr [RDX]
LEA R10,[0x22fd50]
LEA R11,[0x1e9381]
LEA RDX,[0x1f1bcd]
MOV RDI,RAX
MOV ESI,0x2
XOR EAX,EAX
PUSH R11
PUSH qword ptr [R10]
CALL 0x001cd4de
ADD RSP,0x10
LAB_00172013:
POP RAX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* common_init() */
int8 common_init(void)
{
int8 in_RAX;
int8 uVar1;
llama_log_set(common_init()::$_0::__invoke,0);
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,2,"build: %d (%s) with %s for %s%s\n",LLAMA_BUILD_NUMBER,LLAMA_COMMIT,
LLAMA_COMPILER,LLAMA_BUILD_TARGET,"");
}
return in_RAX;
}
| |
24,470 | common_init() | monkey531[P]llama/common/common.cpp | void common_init() {
llama_log_set([](ggml_log_level level, const char * text, void * /*user_data*/) {
if (LOG_DEFAULT_LLAMA <= common_log_verbosity_thold) {
common_log_add(common_log_main(), level, "%s", text);
}
}, NULL);
#ifdef NDEBUG
const char * build_type = "";
#else
const char * build_type = " (debug)";
#endif
LOG_INF("build: %d (%s) with %s for %s%s\n", LLAMA_BUILD_NUMBER, LLAMA_COMMIT, LLAMA_COMPILER, LLAMA_BUILD_TARGET, build_type);
} | O3 | cpp | common_init():
leaq 0xb5e97(%rip), %rax # 0x12d438
cmpl $0x0, (%rax)
js 0x775cf
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
callq 0xcb8a7
leaq 0x73716(%rip), %rdx # 0xeacd0
movq %rax, %rdi
movl %ebp, %esi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xcb944
retq
| _ZZ11common_initvEN3$_08__invokeE14ggml_log_levelPKcPv:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short locret_775CF
push rbp
push rbx
push rax
mov rbx, rsi
mov ebp, edi
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSetCustomJinja_0+0FEh; "%s"
mov rdi, rax
mov esi, ebp
mov rcx, rbx
xor eax, eax
add rsp, 8
pop rbx
pop rbp
jmp _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
locret_775CF:
retn
| void * common_init(void)::$_0::__invoke(int a1, int a2)
{
void *result; // rax
int v3; // eax
int v4; // r8d
int v5; // r9d
result = &common_log_verbosity_thold;
if ( common_log_verbosity_thold >= 0 )
{
v3 = common_log_main();
return (void *)common_log_add(v3, a1, (unsigned int)"%s", a2, v4, v5);
}
return result;
}
| __invoke:
LEA RAX,[0x22d438]
CMP dword ptr [RAX],0x0
JS 0x001775cf
PUSH RBP
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EBP,EDI
CALL 0x001cb8a7
LEA RDX,[0x1eacd0]
MOV RDI,RAX
MOV ESI,EBP
MOV RCX,RBX
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x001cb944
LAB_001775cf:
RET
|
/* __invoke(ggml_log_level, char const*, void*) */
void common_init()::$_0::__invoke(int4 param_1,int8 param_2)
{
int8 uVar1;
if (-1 < common_log_verbosity_thold) {
uVar1 = common_log_main();
common_log_add(uVar1,param_1,"%s",param_2);
return;
}
return;
}
| |
24,471 | test_final_sigma | bluesky950520[P]quickjs/quickjs.c | static BOOL test_final_sigma(JSString *p, int sigma_pos)
{
int k, c1;
/* before C: skip case ignorable chars and check there is
a cased letter */
k = sigma_pos;
for(;;) {
c1 = string_prevc(p, &k);
if (!lre_is_case_ignorable(c1))
break;
}
if (!lre_is_cased(c1))
return FALSE;
/* after C: skip case ignorable chars and check there is
no cased letter */
k = sigma_pos + 1;
for(;;) {
if (k >= p->len)
return TRUE;
c1 = string_getc(p, &k);
if (!lre_is_case_ignorable(c1))
break;
}
return !lre_is_cased(c1);
} | O0 | c | test_final_sigma:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd6be0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x1034d0
cmpl $0x0, %eax
jne 0xd6b48
jmp 0xd6b4a
jmp 0xd6b25
movl 0xc(%rsp), %edi
callq 0x103270
cmpl $0x0, %eax
jne 0xd6b62
movl $0x0, 0x24(%rsp)
jmp 0xd6bce
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
movq 0x4(%rcx), %rcx
andq $0x7fffffff, %rcx # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jl 0xd6b8f
movl $0x1, 0x24(%rsp)
jmp 0xd6bce
movq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x848a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
callq 0x1034d0
cmpl $0x0, %eax
jne 0xd6bb2
jmp 0xd6bb4
jmp 0xd6b6d
movl 0xc(%rsp), %edi
callq 0x103270
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| test_final_sigma:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], esi
mov eax, [rsp+28h+var_14]
mov [rsp+28h+var_18], eax
loc_D6B25:
mov rdi, [rsp+28h+var_10]
lea rsi, [rsp+28h+var_18]
call string_prevc
mov [rsp+28h+var_1C], eax
mov edi, [rsp+28h+var_1C]
call lre_is_case_ignorable
cmp eax, 0
jnz short loc_D6B48
jmp short loc_D6B4A
loc_D6B48:
jmp short loc_D6B25
loc_D6B4A:
mov edi, [rsp+28h+var_1C]
call lre_is_cased
cmp eax, 0
jnz short loc_D6B62
mov [rsp+28h+var_4], 0
jmp short loc_D6BCE
loc_D6B62:
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_18], eax
loc_D6B6D:
mov eax, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx+4]
and rcx, 7FFFFFFFh
cmp eax, ecx
jl short loc_D6B8F
mov [rsp+28h+var_4], 1
jmp short loc_D6BCE
loc_D6B8F:
mov rdi, [rsp+28h+var_10]
lea rsi, [rsp+28h+var_18]
call string_getc
mov [rsp+28h+var_1C], eax
mov edi, [rsp+28h+var_1C]
call lre_is_case_ignorable
cmp eax, 0
jnz short loc_D6BB2
jmp short loc_D6BB4
loc_D6BB2:
jmp short loc_D6B6D
loc_D6BB4:
mov edi, [rsp+28h+var_1C]
call lre_is_cased
cmp eax, 0
setnz al
xor al, 0FFh
and al, 1
movzx eax, al
mov [rsp+28h+var_4], eax
loc_D6BCE:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| _BOOL8 test_final_sigma(long long a1, int a2)
{
unsigned int v3; // [rsp+Ch] [rbp-1Ch]
unsigned int v4; // [rsp+Ch] [rbp-1Ch]
int v5; // [rsp+10h] [rbp-18h] BYREF
int v6; // [rsp+14h] [rbp-14h]
long long v7; // [rsp+18h] [rbp-10h]
v7 = a1;
v6 = a2;
v5 = a2;
do
v3 = string_prevc(v7, &v5);
while ( (unsigned int)lre_is_case_ignorable(v3) );
if ( (unsigned int)lre_is_cased(v3) )
{
v5 = v6 + 1;
do
{
if ( v5 >= (*(_DWORD *)(v7 + 4) & 0x7FFFFFFF) )
return 1;
v4 = string_getc(v7, &v5);
}
while ( (unsigned int)lre_is_case_ignorable(v4) );
return lre_is_cased(v4) == 0;
}
else
{
return 0;
}
}
| test_final_sigma:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],ESI
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x10],EAX
LAB_001d6b25:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x001d6be0
MOV dword ptr [RSP + 0xc],EAX
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x002034d0
CMP EAX,0x0
JNZ 0x001d6b48
JMP 0x001d6b4a
LAB_001d6b48:
JMP 0x001d6b25
LAB_001d6b4a:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00203270
CMP EAX,0x0
JNZ 0x001d6b62
MOV dword ptr [RSP + 0x24],0x0
JMP 0x001d6bce
LAB_001d6b62:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
LAB_001d6b6d:
MOV EAX,dword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX + 0x4]
AND RCX,0x7fffffff
CMP EAX,ECX
JL 0x001d6b8f
MOV dword ptr [RSP + 0x24],0x1
JMP 0x001d6bce
LAB_001d6b8f:
MOV RDI,qword ptr [RSP + 0x18]
LEA RSI,[RSP + 0x10]
CALL 0x001848a0
MOV dword ptr [RSP + 0xc],EAX
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x002034d0
CMP EAX,0x0
JNZ 0x001d6bb2
JMP 0x001d6bb4
LAB_001d6bb2:
JMP 0x001d6b6d
LAB_001d6bb4:
MOV EDI,dword ptr [RSP + 0xc]
CALL 0x00203270
CMP EAX,0x0
SETNZ AL
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RSP + 0x24],EAX
LAB_001d6bce:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
byte test_final_sigma(long param_1,int param_2)
{
byte bVar1;
int4 uVar2;
int iVar3;
int local_18;
int local_14;
long local_10;
local_18 = param_2;
local_14 = param_2;
local_10 = param_1;
do {
uVar2 = string_prevc(local_10,&local_18);
iVar3 = lre_is_case_ignorable(uVar2);
} while (iVar3 != 0);
iVar3 = lre_is_cased(uVar2);
if (iVar3 == 0) {
bVar1 = 0;
}
else {
local_18 = local_14 + 1;
do {
if ((int)((uint)*(int8 *)(local_10 + 4) & 0x7fffffff) <= local_18) {
return 1;
}
uVar2 = string_getc(local_10,&local_18);
iVar3 = lre_is_case_ignorable(uVar2);
} while (iVar3 != 0);
iVar3 = lre_is_cased(uVar2);
bVar1 = (iVar3 != 0 ^ 0xffU) & 1;
}
return bVar1;
}
| |
24,472 | js_parse_regexp | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_regexp(JSParseState *s)
{
const uint8_t *p, *p_next;
BOOL in_class;
StringBuffer b_s, *b = &b_s;
StringBuffer b2_s, *b2 = &b2_s;
uint32_t c;
p = s->buf_ptr;
p++;
in_class = FALSE;
if (string_buffer_init(s->ctx, b, 32))
return -1;
if (string_buffer_init(s->ctx, b2, 1))
goto fail;
for(;;) {
if (p >= s->buf_end) {
eof_error:
js_parse_error(s, "unexpected end of regexp");
goto fail;
}
c = *p++;
if (c == '\n' || c == '\r') {
goto eol_error;
} else if (c == '/') {
if (!in_class)
break;
} else if (c == '[') {
in_class = TRUE;
} else if (c == ']') {
/* XXX: incorrect as the first character in a class */
in_class = FALSE;
} else if (c == '\\') {
if (string_buffer_putc8(b, c))
goto fail;
c = *p++;
if (c == '\n' || c == '\r')
goto eol_error;
else if (c == '\0' && p >= s->buf_end)
goto eof_error;
else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p) {
goto invalid_utf8;
}
p = p_next;
if (c == CP_LS || c == CP_PS)
goto eol_error;
}
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p) {
invalid_utf8:
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
}
p = p_next;
/* LS or PS are considered as line terminator */
if (c == CP_LS || c == CP_PS) {
eol_error:
js_parse_error(s, "unexpected line terminator in regexp");
goto fail;
}
}
if (string_buffer_putc(b, c))
goto fail;
}
/* flags */
for(;;) {
c = utf8_decode(p, &p_next);
/* no need to test for invalid UTF-8, 0xFFFD is not ident_next */
if (!lre_js_is_ident_next(c))
break;
if (string_buffer_putc(b2, c))
goto fail;
p = p_next;
}
s->token.val = TOK_REGEXP;
s->token.u.regexp.body = string_buffer_end(b);
s->token.u.regexp.flags = string_buffer_end(b2);
s->buf_ptr = p;
return 0;
fail:
string_buffer_free(b);
string_buffer_free(b2);
return -1;
} | O0 | c | js_parse_regexp:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0xa8(%rsp), %rax
movq 0x70(%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
movl $0x0, 0x94(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movl $0x20, %edx
callq 0x50640
cmpl $0x0, %eax
je 0xa7b35
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
jmp 0xa7ecb
movq 0xa8(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
movl $0x1, %edx
callq 0x50640
cmpl $0x0, %eax
je 0xa7b59
jmp 0xa7eac
jmp 0xa7b5b
movq 0xa0(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jb 0xa7b8e
jmp 0xa7b73
movq 0xa8(%rsp), %rdi
leaq 0x67f96(%rip), %rsi # 0x10fb18
movb $0x0, %al
callq 0x48690
jmp 0xa7eac
movq 0xa0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xa0(%rsp)
movzbl (%rax), %eax
movl %eax, 0x3c(%rsp)
cmpl $0xa, 0x3c(%rsp)
je 0xa7bba
cmpl $0xd, 0x3c(%rsp)
jne 0xa7bbf
jmp 0xa7d6d
cmpl $0x2f, 0x3c(%rsp)
jne 0xa7bda
cmpl $0x0, 0x94(%rsp)
jne 0xa7bd5
jmp 0xa7db1
jmp 0xa7d92
cmpl $0x5b, 0x3c(%rsp)
jne 0xa7bf1
movl $0x1, 0x94(%rsp)
jmp 0xa7d90
cmpl $0x5d, 0x3c(%rsp)
jne 0xa7c08
movl $0x0, 0x94(%rsp)
jmp 0xa7d8e
cmpl $0x5c, 0x3c(%rsp)
jne 0xa7ced
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x84540
cmpl $0x0, %eax
je 0xa7c2b
jmp 0xa7eac
movq 0xa0(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0xa0(%rsp)
movzbl (%rax), %eax
movl %eax, 0x3c(%rsp)
cmpl $0xa, 0x3c(%rsp)
je 0xa7c57
cmpl $0xd, 0x3c(%rsp)
jne 0xa7c5c
jmp 0xa7d6d
cmpl $0x0, 0x3c(%rsp)
jne 0xa7c7e
movq 0xa0(%rsp), %rax
movq 0xa8(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jb 0xa7c7e
jmp 0xa7b73
cmpl $0x80, 0x3c(%rsp)
jb 0xa7ce4
movq 0xa0(%rsp), %rdi
addq $-0x1, %rdi
leaq 0x98(%rsp), %rsi
callq 0x1eb50
movl %eax, 0x3c(%rsp)
movq 0x98(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jne 0xa7cb9
jmp 0xa7d2c
movq 0x98(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpl $0x2028, 0x3c(%rsp) # imm = 0x2028
je 0xa7cdd
cmpl $0x2029, 0x3c(%rsp) # imm = 0x2029
jne 0xa7ce2
jmp 0xa7d6d
jmp 0xa7ce4
jmp 0xa7ce6
jmp 0xa7ce8
jmp 0xa7d8c
cmpl $0x80, 0x3c(%rsp)
jb 0xa7d8a
movq 0xa0(%rsp), %rdi
addq $-0x1, %rdi
leaq 0x98(%rsp), %rsi
callq 0x1eb50
movl %eax, 0x3c(%rsp)
movq 0x98(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jne 0xa7d47
jmp 0xa7d2c
movq 0xa8(%rsp), %rdi
leaq 0x67b49(%rip), %rsi # 0x10f884
movb $0x0, %al
callq 0x48690
jmp 0xa7eac
movq 0x98(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpl $0x2028, 0x3c(%rsp) # imm = 0x2028
je 0xa7d6b
cmpl $0x2029, 0x3c(%rsp) # imm = 0x2029
jne 0xa7d88
jmp 0xa7d6d
movq 0xa8(%rsp), %rdi
leaq 0x67db5(%rip), %rsi # 0x10fb31
movb $0x0, %al
callq 0x48690
jmp 0xa7eac
jmp 0xa7d8a
jmp 0xa7d8c
jmp 0xa7d8e
jmp 0xa7d90
jmp 0xa7d92
jmp 0xa7d94
movq 0x68(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x4da80
cmpl $0x0, %eax
je 0xa7dac
jmp 0xa7eac
jmp 0xa7b5b
jmp 0xa7db3
movq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1eb50
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %edi
callq 0x9f4a0
cmpl $0x0, %eax
jne 0xa7ddc
jmp 0xa7e06
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x4da80
cmpl $0x0, %eax
je 0xa7df4
jmp 0xa7eac
movq 0x98(%rsp), %rax
movq %rax, 0xa0(%rsp)
jmp 0xa7db3
movq 0xa8(%rsp), %rax
movl $0xffffff84, 0x20(%rax) # imm = 0xFFFFFF84
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4db00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4db00
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0xa0(%rsp), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x70(%rax)
movl $0x0, 0xb4(%rsp)
jmp 0xa7ecb
movq 0x68(%rsp), %rdi
callq 0x524b0
movq 0x40(%rsp), %rdi
callq 0x524b0
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
nopw (%rax,%rax)
| js_parse_regexp:
sub rsp, 0B8h
mov [rsp+0B8h+var_10], rdi
lea rax, [rsp+0B8h+var_48]
mov [rsp+0B8h+var_50], rax
lea rax, [rsp+0B8h+var_70]
mov [rsp+0B8h+var_78], rax
mov rax, [rsp+0B8h+var_10]
mov rax, [rax+70h]
mov [rsp+0B8h+var_18], rax
mov rax, [rsp+0B8h+var_18]
add rax, 1
mov [rsp+0B8h+var_18], rax
mov [rsp+0B8h+var_24], 0
mov rax, [rsp+0B8h+var_10]
mov rdi, [rax]
mov rsi, [rsp+0B8h+var_50]
mov edx, 20h ; ' '
call string_buffer_init
cmp eax, 0
jz short loc_A7B35
mov [rsp+0B8h+var_4], 0FFFFFFFFh
jmp loc_A7ECB
loc_A7B35:
mov rax, [rsp+0B8h+var_10]
mov rdi, [rax]
mov rsi, [rsp+0B8h+var_78]
mov edx, 1
call string_buffer_init
cmp eax, 0
jz short loc_A7B59
jmp loc_A7EAC
loc_A7B59:
jmp short $+2
loc_A7B5B:
mov rax, [rsp+0B8h+var_18]
mov rcx, [rsp+0B8h+var_10]
cmp rax, [rcx+78h]
jb short loc_A7B8E
jmp short $+2
loc_A7B73:
mov rdi, [rsp+0B8h+var_10]
lea rsi, aUnexpectedEndO_3; "unexpected end of regexp"
mov al, 0
call js_parse_error
jmp loc_A7EAC
loc_A7B8E:
mov rax, [rsp+0B8h+var_18]
mov rcx, rax
add rcx, 1
mov [rsp+0B8h+var_18], rcx
movzx eax, byte ptr [rax]
mov [rsp+0B8h+var_7C], eax
cmp [rsp+0B8h+var_7C], 0Ah
jz short loc_A7BBA
cmp [rsp+0B8h+var_7C], 0Dh
jnz short loc_A7BBF
loc_A7BBA:
jmp loc_A7D6D
loc_A7BBF:
cmp [rsp+0B8h+var_7C], 2Fh ; '/'
jnz short loc_A7BDA
cmp [rsp+0B8h+var_24], 0
jnz short loc_A7BD5
jmp loc_A7DB1
loc_A7BD5:
jmp loc_A7D92
loc_A7BDA:
cmp [rsp+0B8h+var_7C], 5Bh ; '['
jnz short loc_A7BF1
mov [rsp+0B8h+var_24], 1
jmp loc_A7D90
loc_A7BF1:
cmp [rsp+0B8h+var_7C], 5Dh ; ']'
jnz short loc_A7C08
mov [rsp+0B8h+var_24], 0
jmp loc_A7D8E
loc_A7C08:
cmp [rsp+0B8h+var_7C], 5Ch ; '\'
jnz loc_A7CED
mov rdi, [rsp+0B8h+var_50]
mov esi, [rsp+0B8h+var_7C]
call string_buffer_putc8
cmp eax, 0
jz short loc_A7C2B
jmp loc_A7EAC
loc_A7C2B:
mov rax, [rsp+0B8h+var_18]
mov rcx, rax
add rcx, 1
mov [rsp+0B8h+var_18], rcx
movzx eax, byte ptr [rax]
mov [rsp+0B8h+var_7C], eax
cmp [rsp+0B8h+var_7C], 0Ah
jz short loc_A7C57
cmp [rsp+0B8h+var_7C], 0Dh
jnz short loc_A7C5C
loc_A7C57:
jmp loc_A7D6D
loc_A7C5C:
cmp [rsp+0B8h+var_7C], 0
jnz short loc_A7C7E
mov rax, [rsp+0B8h+var_18]
mov rcx, [rsp+0B8h+var_10]
cmp rax, [rcx+78h]
jb short loc_A7C7E
jmp loc_A7B73
loc_A7C7E:
cmp [rsp+0B8h+var_7C], 80h
jb short loc_A7CE4
mov rdi, [rsp+0B8h+var_18]
add rdi, 0FFFFFFFFFFFFFFFFh
lea rsi, [rsp+0B8h+var_20]
call utf8_decode
mov [rsp+0B8h+var_7C], eax
mov rax, [rsp+0B8h+var_20]
cmp rax, [rsp+0B8h+var_18]
jnz short loc_A7CB9
jmp short loc_A7D2C
loc_A7CB9:
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_18], rax
cmp [rsp+0B8h+var_7C], 2028h
jz short loc_A7CDD
cmp [rsp+0B8h+var_7C], 2029h
jnz short loc_A7CE2
loc_A7CDD:
jmp loc_A7D6D
loc_A7CE2:
jmp short $+2
loc_A7CE4:
jmp short $+2
loc_A7CE6:
jmp short $+2
loc_A7CE8:
jmp loc_A7D8C
loc_A7CED:
cmp [rsp+0B8h+var_7C], 80h
jb loc_A7D8A
mov rdi, [rsp+0B8h+var_18]
add rdi, 0FFFFFFFFFFFFFFFFh
lea rsi, [rsp+0B8h+var_20]
call utf8_decode
mov [rsp+0B8h+var_7C], eax
mov rax, [rsp+0B8h+var_20]
cmp rax, [rsp+0B8h+var_18]
jnz short loc_A7D47
jmp short $+2
loc_A7D2C:
mov rdi, [rsp+0B8h+var_10]
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
mov al, 0
call js_parse_error
jmp loc_A7EAC
loc_A7D47:
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_18], rax
cmp [rsp+0B8h+var_7C], 2028h
jz short loc_A7D6B
cmp [rsp+0B8h+var_7C], 2029h
jnz short loc_A7D88
loc_A7D6B:
jmp short $+2
loc_A7D6D:
mov rdi, [rsp+0B8h+var_10]
lea rsi, aUnexpectedLine; "unexpected line terminator in regexp"
mov al, 0
call js_parse_error
jmp loc_A7EAC
loc_A7D88:
jmp short $+2
loc_A7D8A:
jmp short $+2
loc_A7D8C:
jmp short $+2
loc_A7D8E:
jmp short $+2
loc_A7D90:
jmp short $+2
loc_A7D92:
jmp short $+2
loc_A7D94:
mov rdi, [rsp+0B8h+var_50]
mov esi, [rsp+0B8h+var_7C]
call string_buffer_putc
cmp eax, 0
jz short loc_A7DAC
jmp loc_A7EAC
loc_A7DAC:
jmp loc_A7B5B
loc_A7DB1:
jmp short $+2
loc_A7DB3:
mov rdi, [rsp+0B8h+var_18]
lea rsi, [rsp+0B8h+var_20]
call utf8_decode
mov [rsp+0B8h+var_7C], eax
mov edi, [rsp+0B8h+var_7C]
call lre_js_is_ident_next
cmp eax, 0
jnz short loc_A7DDC
jmp short loc_A7E06
loc_A7DDC:
mov rdi, [rsp+0B8h+var_78]
mov esi, [rsp+0B8h+var_7C]
call string_buffer_putc
cmp eax, 0
jz short loc_A7DF4
jmp loc_A7EAC
loc_A7DF4:
mov rax, [rsp+0B8h+var_20]
mov [rsp+0B8h+var_18], rax
jmp short loc_A7DB3
loc_A7E06:
mov rax, [rsp+0B8h+var_10]
mov dword ptr [rax+20h], 0FFFFFF84h
mov rax, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_B0], rax
mov rdi, [rsp+0B8h+var_50]
call string_buffer_end
mov rcx, rax
mov rax, [rsp+0B8h+var_B0]
mov [rsp+0B8h+var_90], rcx
mov [rsp+0B8h+var_88], rdx
mov rcx, [rsp+0B8h+var_90]
mov [rax+38h], rcx
mov rcx, [rsp+0B8h+var_88]
mov [rax+40h], rcx
mov rax, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_A8], rax
mov rdi, [rsp+0B8h+var_78]
call string_buffer_end
mov rcx, rax
mov rax, [rsp+0B8h+var_A8]
mov [rsp+0B8h+var_A0], rcx
mov [rsp+0B8h+var_98], rdx
mov rcx, [rsp+0B8h+var_A0]
mov [rax+48h], rcx
mov rcx, [rsp+0B8h+var_98]
mov [rax+50h], rcx
mov rcx, [rsp+0B8h+var_18]
mov rax, [rsp+0B8h+var_10]
mov [rax+70h], rcx
mov [rsp+0B8h+var_4], 0
jmp short loc_A7ECB
loc_A7EAC:
mov rdi, [rsp+0B8h+var_50]
call string_buffer_free
mov rdi, [rsp+0B8h+var_78]
call string_buffer_free
mov [rsp+0B8h+var_4], 0FFFFFFFFh
loc_A7ECB:
mov eax, [rsp+0B8h+var_4]
add rsp, 0B8h
retn
| long long js_parse_regexp(
long long *a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
long long v9; // rdx
long long v10; // r8
long long v11; // r9
__m128 v12; // xmm4
__m128 v13; // xmm5
long long *v14; // rcx
unsigned __int8 *v15; // rax
unsigned __int8 *v16; // rcx
unsigned __int8 *v17; // rax
long long v18; // rdx
long long v19; // rdx
char v21; // [rsp+0h] [rbp-B8h]
long long *v22; // [rsp+8h] [rbp-B0h]
long long *v23; // [rsp+10h] [rbp-A8h]
unsigned int v24; // [rsp+3Ch] [rbp-7Ch]
unsigned int v25; // [rsp+3Ch] [rbp-7Ch]
long long v26[4]; // [rsp+48h] [rbp-70h] BYREF
long long *v27; // [rsp+68h] [rbp-50h]
_BYTE v28[36]; // [rsp+70h] [rbp-48h] BYREF
int v29; // [rsp+94h] [rbp-24h]
unsigned __int8 *v30; // [rsp+98h] [rbp-20h] BYREF
unsigned __int8 *v31; // [rsp+A0h] [rbp-18h]
long long *v32; // [rsp+A8h] [rbp-10h]
v32 = a1;
v27 = (long long *)v28;
v31 = (unsigned __int8 *)a1[14];
++v31;
v29 = 0;
if ( (unsigned int)string_buffer_init(*a1, (long long)v28, 0x20u) )
return (unsigned int)-1;
if ( (unsigned int)string_buffer_init(*v32, (long long)v26, 1u) )
{
LABEL_41:
string_buffer_free(v27);
string_buffer_free(v26);
return (unsigned int)-1;
}
while ( 1 )
{
v14 = v32;
if ( (unsigned long long)v31 >= v32[15] )
{
LABEL_5:
js_parse_error(
v32,
(long long)"unexpected end of regexp",
v9,
(long long)v14,
v10,
v11,
a2,
a3,
a4,
a5,
v12,
v13,
a8,
a9,
v21);
goto LABEL_41;
}
v15 = v31;
v16 = ++v31;
v24 = *v15;
if ( v24 == 10 || v24 == 13 )
{
LABEL_34:
js_parse_error(
v32,
(long long)"unexpected line terminator in regexp",
v9,
(long long)v16,
v10,
v11,
a2,
a3,
a4,
a5,
v12,
v13,
a8,
a9,
v21);
goto LABEL_41;
}
if ( v24 == 47 )
break;
switch ( v24 )
{
case '[':
v29 = 1;
break;
case ']':
v29 = 0;
break;
case '\\':
if ( (unsigned int)string_buffer_putc8(
(long long)v27,
0x5Cu,
a2,
a3,
a4,
a5,
v12,
v13,
a8,
a9,
v9,
(long long)v16,
v10,
v11) )
goto LABEL_41;
v17 = v31;
v16 = ++v31;
v24 = *v17;
if ( v24 == 10 || v24 == 13 )
goto LABEL_34;
if ( !*v17 )
{
v14 = v32;
if ( (unsigned long long)v31 >= v32[15] )
goto LABEL_5;
}
if ( v24 >= 0x80 )
{
v24 = utf8_decode(v31 - 1, &v30);
if ( v30 == v31 )
goto LABEL_31;
v31 = v30;
if ( v24 == 8232 || v24 == 8233 )
goto LABEL_34;
}
break;
default:
if ( v24 >= 0x80 )
{
v24 = utf8_decode(v31 - 1, &v30);
if ( v30 == v31 )
{
LABEL_31:
js_parse_error(
v32,
(long long)"invalid UTF-8 sequence",
v9,
(long long)v16,
v10,
v11,
a2,
a3,
a4,
a5,
v12,
v13,
a8,
a9,
v21);
goto LABEL_41;
}
v31 = v30;
if ( v24 == 8232 || v24 == 8233 )
goto LABEL_34;
}
break;
}
LABEL_35:
if ( (unsigned int)string_buffer_putc((long long)v27, v24) )
goto LABEL_41;
}
if ( v29 )
goto LABEL_35;
while ( 1 )
{
v25 = utf8_decode(v31, &v30);
if ( !lre_js_is_ident_next(v25) )
break;
if ( (unsigned int)string_buffer_putc((long long)v26, v25) )
goto LABEL_41;
v31 = v30;
}
*((_DWORD *)v32 + 8) = -124;
v22 = v32;
v22[7] = string_buffer_end((long long)v27);
v22[8] = v18;
v23 = v32;
v23[9] = string_buffer_end((long long)v26);
v23[10] = v19;
v32[14] = (long long)v31;
return 0;
}
| js_parse_regexp:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xa8],RDI
LEA RAX,[RSP + 0x70]
MOV qword ptr [RSP + 0x68],RAX
LEA RAX,[RSP + 0x48]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RAX + 0x70]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0xa0]
ADD RAX,0x1
MOV qword ptr [RSP + 0xa0],RAX
MOV dword ptr [RSP + 0x94],0x0
MOV RAX,qword ptr [RSP + 0xa8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x68]
MOV EDX,0x20
CALL 0x00150640
CMP EAX,0x0
JZ 0x001a7b35
MOV dword ptr [RSP + 0xb4],0xffffffff
JMP 0x001a7ecb
LAB_001a7b35:
MOV RAX,qword ptr [RSP + 0xa8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x40]
MOV EDX,0x1
CALL 0x00150640
CMP EAX,0x0
JZ 0x001a7b59
JMP 0x001a7eac
LAB_001a7b59:
JMP 0x001a7b5b
LAB_001a7b5b:
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
CMP RAX,qword ptr [RCX + 0x78]
JC 0x001a7b8e
JMP 0x001a7b73
LAB_001a7b73:
MOV RDI,qword ptr [RSP + 0xa8]
LEA RSI,[0x20fb18]
MOV AL,0x0
CALL 0x00148690
JMP 0x001a7eac
LAB_001a7b8e:
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xa0],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0xa
JZ 0x001a7bba
CMP dword ptr [RSP + 0x3c],0xd
JNZ 0x001a7bbf
LAB_001a7bba:
JMP 0x001a7d6d
LAB_001a7bbf:
CMP dword ptr [RSP + 0x3c],0x2f
JNZ 0x001a7bda
CMP dword ptr [RSP + 0x94],0x0
JNZ 0x001a7bd5
JMP 0x001a7db1
LAB_001a7bd5:
JMP 0x001a7d92
LAB_001a7bda:
CMP dword ptr [RSP + 0x3c],0x5b
JNZ 0x001a7bf1
MOV dword ptr [RSP + 0x94],0x1
JMP 0x001a7d90
LAB_001a7bf1:
CMP dword ptr [RSP + 0x3c],0x5d
JNZ 0x001a7c08
MOV dword ptr [RSP + 0x94],0x0
JMP 0x001a7d8e
LAB_001a7c08:
CMP dword ptr [RSP + 0x3c],0x5c
JNZ 0x001a7ced
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x00184540
CMP EAX,0x0
JZ 0x001a7c2b
JMP 0x001a7eac
LAB_001a7c2b:
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RSP + 0xa0],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RSP + 0x3c],EAX
CMP dword ptr [RSP + 0x3c],0xa
JZ 0x001a7c57
CMP dword ptr [RSP + 0x3c],0xd
JNZ 0x001a7c5c
LAB_001a7c57:
JMP 0x001a7d6d
LAB_001a7c5c:
CMP dword ptr [RSP + 0x3c],0x0
JNZ 0x001a7c7e
MOV RAX,qword ptr [RSP + 0xa0]
MOV RCX,qword ptr [RSP + 0xa8]
CMP RAX,qword ptr [RCX + 0x78]
JC 0x001a7c7e
JMP 0x001a7b73
LAB_001a7c7e:
CMP dword ptr [RSP + 0x3c],0x80
JC 0x001a7ce4
MOV RDI,qword ptr [RSP + 0xa0]
ADD RDI,-0x1
LEA RSI,[RSP + 0x98]
CALL 0x0011eb50
MOV dword ptr [RSP + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x98]
CMP RAX,qword ptr [RSP + 0xa0]
JNZ 0x001a7cb9
JMP 0x001a7d2c
LAB_001a7cb9:
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xa0],RAX
CMP dword ptr [RSP + 0x3c],0x2028
JZ 0x001a7cdd
CMP dword ptr [RSP + 0x3c],0x2029
JNZ 0x001a7ce2
LAB_001a7cdd:
JMP 0x001a7d6d
LAB_001a7ce2:
JMP 0x001a7ce4
LAB_001a7ce4:
JMP 0x001a7ce6
LAB_001a7ce6:
JMP 0x001a7ce8
LAB_001a7ce8:
JMP 0x001a7d8c
LAB_001a7ced:
CMP dword ptr [RSP + 0x3c],0x80
JC 0x001a7d8a
MOV RDI,qword ptr [RSP + 0xa0]
ADD RDI,-0x1
LEA RSI,[RSP + 0x98]
CALL 0x0011eb50
MOV dword ptr [RSP + 0x3c],EAX
MOV RAX,qword ptr [RSP + 0x98]
CMP RAX,qword ptr [RSP + 0xa0]
JNZ 0x001a7d47
JMP 0x001a7d2c
LAB_001a7d2c:
MOV RDI,qword ptr [RSP + 0xa8]
LEA RSI,[0x20f884]
MOV AL,0x0
CALL 0x00148690
JMP 0x001a7eac
LAB_001a7d47:
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xa0],RAX
CMP dword ptr [RSP + 0x3c],0x2028
JZ 0x001a7d6b
CMP dword ptr [RSP + 0x3c],0x2029
JNZ 0x001a7d88
LAB_001a7d6b:
JMP 0x001a7d6d
LAB_001a7d6d:
MOV RDI,qword ptr [RSP + 0xa8]
LEA RSI,[0x20fb31]
MOV AL,0x0
CALL 0x00148690
JMP 0x001a7eac
LAB_001a7d88:
JMP 0x001a7d8a
LAB_001a7d8a:
JMP 0x001a7d8c
LAB_001a7d8c:
JMP 0x001a7d8e
LAB_001a7d8e:
JMP 0x001a7d90
LAB_001a7d90:
JMP 0x001a7d92
LAB_001a7d92:
JMP 0x001a7d94
LAB_001a7d94:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x0014da80
CMP EAX,0x0
JZ 0x001a7dac
JMP 0x001a7eac
LAB_001a7dac:
JMP 0x001a7b5b
LAB_001a7db1:
JMP 0x001a7db3
LAB_001a7db3:
MOV RDI,qword ptr [RSP + 0xa0]
LEA RSI,[RSP + 0x98]
CALL 0x0011eb50
MOV dword ptr [RSP + 0x3c],EAX
MOV EDI,dword ptr [RSP + 0x3c]
CALL 0x0019f4a0
CMP EAX,0x0
JNZ 0x001a7ddc
JMP 0x001a7e06
LAB_001a7ddc:
MOV RDI,qword ptr [RSP + 0x40]
MOV ESI,dword ptr [RSP + 0x3c]
CALL 0x0014da80
CMP EAX,0x0
JZ 0x001a7df4
JMP 0x001a7eac
LAB_001a7df4:
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x001a7db3
LAB_001a7e06:
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RAX + 0x20],0xffffff84
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x0014db00
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x28],RCX
MOV qword ptr [RSP + 0x30],RDX
MOV RCX,qword ptr [RSP + 0x28]
MOV qword ptr [RAX + 0x38],RCX
MOV RCX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x0014db00
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x18],RCX
MOV qword ptr [RSP + 0x20],RDX
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RAX + 0x48],RCX
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX + 0x50],RCX
MOV RCX,qword ptr [RSP + 0xa0]
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RAX + 0x70],RCX
MOV dword ptr [RSP + 0xb4],0x0
JMP 0x001a7ecb
LAB_001a7eac:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001524b0
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x001524b0
MOV dword ptr [RSP + 0xb4],0xffffffff
LAB_001a7ecb:
MOV EAX,dword ptr [RSP + 0xb4]
ADD RSP,0xb8
RET
|
int4 js_parse_regexp(int8 *param_1)
{
byte *pbVar1;
int8 *puVar2;
int8 *puVar3;
int iVar4;
int4 uVar5;
byte *pbVar6;
int1 auVar7 [16];
uint local_7c;
int1 local_70 [32];
int1 *local_50;
int1 local_48 [36];
int local_24;
byte *local_20;
byte *local_18;
int8 *local_10;
local_50 = local_48;
local_18 = (byte *)(param_1[0xe] + 1);
local_24 = 0;
local_10 = param_1;
iVar4 = string_buffer_init(*param_1,local_50,0x20);
if (iVar4 != 0) {
return 0xffffffff;
}
iVar4 = string_buffer_init(*local_10,local_70,1);
pbVar1 = local_18;
while (local_18 = pbVar1, iVar4 == 0) {
if ((byte *)local_10[0xf] <= pbVar1) {
LAB_001a7b73:
js_parse_error(local_10,"unexpected end of regexp");
break;
}
local_18 = pbVar1 + 1;
local_7c = (uint)*pbVar1;
if ((local_7c == 10) || (local_7c == 0xd)) {
LAB_001a7d6d:
js_parse_error(local_10,"unexpected line terminator in regexp");
break;
}
if (local_7c == 0x2f) {
if (local_24 == 0) goto LAB_001a7db3;
}
else if (local_7c == 0x5b) {
local_24 = 1;
}
else if (local_7c == 0x5d) {
local_24 = 0;
}
else if (local_7c == 0x5c) {
iVar4 = string_buffer_putc8(local_50,0x5c);
pbVar1 = local_18;
if (iVar4 != 0) break;
pbVar6 = local_18 + 1;
local_7c = (uint)*local_18;
local_18 = pbVar6;
if ((local_7c == 10) || (local_7c == 0xd)) goto LAB_001a7d6d;
if ((local_7c == 0) && ((byte *)local_10[0xf] <= pbVar6)) goto LAB_001a7b73;
if (0x7f < local_7c) {
local_7c = utf8_decode(pbVar1,&local_20);
if (local_20 == local_18) goto LAB_001a7d2c;
goto joined_r0x001a7d5f;
}
}
else if (0x7f < local_7c) {
local_7c = utf8_decode(pbVar1,&local_20);
if (local_20 == local_18) {
LAB_001a7d2c:
js_parse_error(local_10,"invalid UTF-8 sequence");
break;
}
joined_r0x001a7d5f:
local_18 = local_20;
if ((local_7c == 0x2028) || (local_18 = local_20, local_7c == 0x2029)) goto LAB_001a7d6d;
}
iVar4 = string_buffer_putc(local_50,local_7c);
pbVar1 = local_18;
}
LAB_001a7eac:
string_buffer_free(local_50);
string_buffer_free(local_70);
return 0xffffffff;
LAB_001a7db3:
while( true ) {
uVar5 = utf8_decode(local_18,&local_20);
iVar4 = lre_js_is_ident_next(uVar5);
puVar2 = local_10;
if (iVar4 == 0) {
*(int4 *)(local_10 + 4) = 0xffffff84;
auVar7 = string_buffer_end(local_50);
puVar3 = local_10;
*(int1 (*) [16])(puVar2 + 7) = auVar7;
auVar7 = string_buffer_end(local_70);
*(int1 (*) [16])(puVar3 + 9) = auVar7;
local_10[0xe] = local_18;
return 0;
}
iVar4 = string_buffer_putc(local_70,uVar5);
if (iVar4 != 0) break;
local_18 = local_20;
}
goto LAB_001a7eac;
}
| |
24,473 | fct_update_table_derived_flags(PFS_table*) | eloqsql/storage/perfschema/pfs_instr.cc | void fct_update_table_derived_flags(PFS_table *pfs)
{
PFS_table_share *share= sanitize_table_share(pfs->m_share);
if (likely(share != NULL))
{
pfs->m_io_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_io_class.m_enabled;
pfs->m_io_timed= share->m_timed && global_table_io_class.m_timed;
pfs->m_lock_enabled= share->m_enabled &&
flag_global_instrumentation && global_table_lock_class.m_enabled;
pfs->m_lock_timed= share->m_timed && global_table_lock_class.m_timed;
}
else
{
pfs->m_io_enabled= false;
pfs->m_io_timed= false;
pfs->m_lock_enabled= false;
pfs->m_lock_timed= false;
}
} | O3 | cpp | fct_update_table_derived_flags(PFS_table*):
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x3d4b7
testq %rax, %rax
je 0x385e2
leaq 0x399e7b(%rip), %rdx # 0x3d2400
movb (%rdx), %r8b
leaq 0x39a6b1(%rip), %rsi # 0x3d2c40
xorl %ecx, %ecx
movl $0x0, %edi
testb %r8b, 0x4(%rax)
je 0x3859f
movl 0x4(%rsi), %edi
movb %dil, (%rbx)
movzbl 0x5(%rsi), %esi
cmpb $0x0, 0x5(%rax)
cmovel %ecx, %esi
movb %sil, 0x2(%rbx)
movb (%rdx), %dil
leaq 0x39a745(%rip), %rdx # 0x3d2d00
movl $0x0, %esi
testb %dil, 0x4(%rax)
je 0x385c9
movl 0x4(%rdx), %esi
movb %sil, 0x1(%rbx)
movzbl 0x5(%rdx), %edx
cmpb $0x0, 0x5(%rax)
cmovnel %edx, %ecx
movb %cl, 0x3(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movw $0x0, (%rbx)
movb $0x0, 0x2(%rbx)
xorl %ecx, %ecx
jmp 0x385d8
| _Z30fct_update_table_derived_flagsP9PFS_table:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+20h]; PFS_table_share *
call _Z20sanitize_table_shareP15PFS_table_share; sanitize_table_share(PFS_table_share *)
test rax, rax
jz short loc_385E2
lea rdx, flag_global_instrumentation
mov r8b, [rdx]
lea rsi, global_table_io_class
xor ecx, ecx
mov edi, 0
test [rax+4], r8b
jz short loc_3859F
mov edi, [rsi+4]
loc_3859F:
mov [rbx], dil
movzx esi, byte ptr [rsi+5]
cmp byte ptr [rax+5], 0
cmovz esi, ecx
mov [rbx+2], sil
mov dil, [rdx]
lea rdx, global_table_lock_class
mov esi, 0
test [rax+4], dil
jz short loc_385C9
mov esi, [rdx+4]
loc_385C9:
mov [rbx+1], sil
movzx edx, byte ptr [rdx+5]
cmp byte ptr [rax+5], 0
cmovnz ecx, edx
loc_385D8:
mov [rbx+3], cl
add rsp, 8
pop rbx
pop rbp
retn
loc_385E2:
mov word ptr [rbx], 0
mov byte ptr [rbx+2], 0
xor ecx, ecx
jmp short loc_385D8
| long long fct_update_table_derived_flags(PFS_table_share **a1)
{
long long result; // rax
char v3; // cl
int v4; // edi
char v5; // si
int v6; // esi
result = sanitize_table_share(a1[4]);
if ( result )
{
v3 = 0;
LOBYTE(v4) = 0;
if ( (flag_global_instrumentation[0] & *(_BYTE *)(result + 4)) != 0 )
v4 = *(&global_table_io_class + 1);
*(_BYTE *)a1 = v4;
v5 = *((_BYTE *)&global_table_io_class + 5);
if ( !*(_BYTE *)(result + 5) )
v5 = 0;
*((_BYTE *)a1 + 2) = v5;
LOBYTE(v6) = 0;
if ( (flag_global_instrumentation[0] & *(_BYTE *)(result + 4)) != 0 )
v6 = *(&global_table_lock_class + 1);
*((_BYTE *)a1 + 1) = v6;
if ( *(_BYTE *)(result + 5) )
v3 = *((_BYTE *)&global_table_lock_class + 5);
}
else
{
*(_WORD *)a1 = 0;
*((_BYTE *)a1 + 2) = 0;
v3 = 0;
}
*((_BYTE *)a1 + 3) = v3;
return result;
}
| fct_update_table_derived_flags:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x20]
CALL 0x0013d4b7
TEST RAX,RAX
JZ 0x001385e2
LEA RDX,[0x4d2400]
MOV R8B,byte ptr [RDX]
LEA RSI,[0x4d2c40]
XOR ECX,ECX
MOV EDI,0x0
TEST byte ptr [RAX + 0x4],R8B
JZ 0x0013859f
MOV EDI,dword ptr [RSI + 0x4]
LAB_0013859f:
MOV byte ptr [RBX],DIL
MOVZX ESI,byte ptr [RSI + 0x5]
CMP byte ptr [RAX + 0x5],0x0
CMOVZ ESI,ECX
MOV byte ptr [RBX + 0x2],SIL
MOV DIL,byte ptr [RDX]
LEA RDX,[0x4d2d00]
MOV ESI,0x0
TEST byte ptr [RAX + 0x4],DIL
JZ 0x001385c9
MOV ESI,dword ptr [RDX + 0x4]
LAB_001385c9:
MOV byte ptr [RBX + 0x1],SIL
MOVZX EDX,byte ptr [RDX + 0x5]
CMP byte ptr [RAX + 0x5],0x0
CMOVNZ ECX,EDX
LAB_001385d8:
MOV byte ptr [RBX + 0x3],CL
ADD RSP,0x8
POP RBX
POP RBP
RET
LAB_001385e2:
MOV word ptr [RBX],0x0
MOV byte ptr [RBX + 0x2],0x0
XOR ECX,ECX
JMP 0x001385d8
|
/* fct_update_table_derived_flags(PFS_table*) */
void fct_update_table_derived_flags(PFS_table *param_1)
{
long lVar1;
PFS_table PVar2;
lVar1 = sanitize_table_share(*(PFS_table_share **)(param_1 + 0x20));
if (lVar1 == 0) {
*(int2 *)param_1 = 0;
param_1[2] = (PFS_table)0x0;
PVar2 = (PFS_table)0x0;
}
else {
PVar2 = (PFS_table)0x0;
if ((*(byte *)(lVar1 + 4) & flag_global_instrumentation) != 0) {
PVar2 = SUB41(global_table_io_class._4_4_,0);
}
*param_1 = PVar2;
PVar2 = global_table_io_class[5];
if (*(char *)(lVar1 + 5) == '\0') {
PVar2 = (PFS_table)0x0;
}
param_1[2] = PVar2;
PVar2 = (PFS_table)0x0;
if ((*(byte *)(lVar1 + 4) & flag_global_instrumentation) != 0) {
PVar2 = SUB41(global_table_lock_class._4_4_,0);
}
param_1[1] = PVar2;
PVar2 = (PFS_table)0x0;
if (*(char *)(lVar1 + 5) != '\0') {
PVar2 = global_table_lock_class[5];
}
}
param_1[3] = PVar2;
return;
}
| |
24,474 | minja::Value::set(minja::Value const&, minja::Value const&) | monkey531[P]llama/common/minja.hpp | void set(const Value& key, const Value& value) {
if (!object_) throw std::runtime_error("Value is not an object: " + dump());
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
(*object_)[key.primitive_] = value;
} | O2 | cpp | minja::Value::set(minja::Value const&, minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x69895
movq %rdx, %rbx
movq %rsi, %r15
movq %rsi, %rdi
callq 0x62dfc
testb %al, %al
je 0x698f2
movq 0x20(%r14), %rdi
addq $0x40, %r15
movq %r15, %rsi
callq 0x699ba
movq %rax, %rdi
movq %rbx, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x69a12
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62e0c
leaq 0x49a6c(%rip), %rsi # 0xb3325
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x58436
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e20
xorl %ebp, %ebp
movq 0x9270f(%rip), %rsi # 0xfbff0
movq 0x92670(%rip), %rdx # 0xfbf58
movq %rbx, %rdi
callq 0x23ef0
jmp 0x6994d
pushq $0x10
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x62e0c
leaq 0x49a28(%rip), %rsi # 0xb333e
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x58436
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x23e20
xorl %ebp, %ebp
movq 0x926b2(%rip), %rsi # 0xfbff0
movq 0x92613(%rip), %rdx # 0xfbf58
movq %rbx, %rdi
callq 0x23ef0
jmp 0x69951
jmp 0x69960
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x241b8
jmp 0x69966
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x241b8
testb %bpl, %bpl
jne 0x6997c
jmp 0x69984
jmp 0x69979
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f80
| _ZN5minja5Value3setERKS0_S2_:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov r14, rdi
cmp qword ptr [rdi+20h], 0
jz short loc_69895
mov rbx, rdx
mov r15, rsi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz loc_698F2
mov rdi, [r14+20h]
add r15, 40h ; '@'
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEEixERSJ_; nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>::operator[](nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rdi, rax
mov rsi, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
jmp _ZN5minja5ValueaSERKS0_; minja::Value::operator=(minja::Value const&)
loc_69895:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnOb; "Value is not an object: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_6994D
loc_698F2:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_60]
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_60]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_40]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6994D:
jmp short loc_69951
jmp short loc_69960
loc_69951:
mov r14, rax
lea rdi, [rsp+68h+var_40]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_69966
loc_69960:
mov r14, rax
mov bpl, 1
loc_69966:
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_6997C
jmp short loc_69984
jmp short $+2
loc_69979:
mov r14, rax
loc_6997C:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_69984:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::set(minja::Value *this, const minja::Value *a2, const minja::Value *a3)
{
long long v4; // rax
void *exception; // rbx
void *v7; // rbx
_BYTE v8[32]; // [rsp+8h] [rbp-60h] BYREF
_BYTE v9[64]; // [rsp+28h] [rbp-40h] BYREF
if ( !*((_QWORD *)this + 4) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v9, (long long)"Value is not an object: ", (long long)v8);
std::runtime_error::runtime_error(exception, v9);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !minja::Value::is_primitive(a2) )
{
v7 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v8, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v9, (long long)"Unashable type: ", (long long)v8);
std::runtime_error::runtime_error(v7, v9);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v4 = nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::operator[](
*((_QWORD *)this + 4),
(char *)a2 + 64);
return minja::Value::operator=(v4, a3);
}
| set:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP qword ptr [RDI + 0x20],0x0
JZ 0x00169895
MOV RBX,RDX
MOV R15,RSI
MOV RDI,RSI
CALL 0x00162dfc
TEST AL,AL
JZ 0x001698f2
MOV RDI,qword ptr [R14 + 0x20]
ADD R15,0x40
MOV RSI,R15
CALL 0x001699ba
MOV RDI,RAX
MOV RSI,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00169a12
LAB_00169895:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_001698a0:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162e0c
LAB_001698b2:
LEA RSI,[0x1b3325]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00158436
MOV BPL,0x1
LAB_001698cb:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00123e20
XOR EBP,EBP
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,RBX
CALL 0x00123ef0
LAB_001698f2:
PUSH 0x10
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_001698fd:
LEA RDI,[RSP + 0x8]
PUSH -0x1
POP RDX
MOV RSI,R14
XOR ECX,ECX
CALL 0x00162e0c
LAB_0016990f:
LEA RSI,[0x1b333e]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00158436
MOV BPL,0x1
LAB_00169928:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00123e20
XOR EBP,EBP
MOV RSI,qword ptr [0x001fbff0]
MOV RDX,qword ptr [0x001fbf58]
MOV RDI,RBX
CALL 0x00123ef0
|
/* minja::Value::set(minja::Value const&, minja::Value const&) */
void __thiscall minja::Value::set(Value *this,Value *param_1,Value *param_2)
{
Value *this_00;
runtime_error *prVar1;
char cVar2;
int1 local_60 [32];
string local_40 [32];
if (*(long *)(this + 0x20) == 0) {
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001698a0 to 001698b1 has its CatchHandler @ 00169979 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 001698b2 to 001698c7 has its CatchHandler @ 00169960 */
std::operator+((char *)local_40,(string *)"Value is not an object: ");
/* try { // try from 001698cb to 001698ef has its CatchHandler @ 00169951 */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
cVar2 = is_primitive(param_1);
if (cVar2 != '\0') {
this_00 = (Value *)nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::operator[](*(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
**)(this + 0x20),param_1 + 0x40);
operator=(this_00,param_2);
return;
}
prVar1 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001698fd to 0016990e has its CatchHandler @ 00169977 */
dump_abi_cxx11_((int)local_60,SUB81(this,0));
/* try { // try from 0016990f to 00169924 has its CatchHandler @ 0016994f */
std::operator+((char *)local_40,(string *)"Unashable type: ");
/* try { // try from 00169928 to 0016994c has its CatchHandler @ 0016994d */
std::runtime_error::runtime_error(prVar1,local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar1,PTR_typeinfo_001fbff0,PTR__runtime_error_001fbf58);
}
| |
24,475 | nglog::tools::ShutdownLoggingUtilities() | ng-log[P]ng-log/src/utilities.cc | void ShutdownLoggingUtilities() {
CHECK(IsLoggingInitialized())
<< "You called ShutdownLogging() without calling "
"InitializeLogging() first!";
g_program_invocation_short_name = nullptr;
#ifdef HAVE_SYSLOG_H
closelog();
#endif
} | O0 | cpp | nglog::tools::ShutdownLoggingUtilities():
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
callq 0x4c550
xorb $-0x1, %al
movb $0x0, -0x69(%rbp)
testb $0x1, %al
jne 0x4c86c
jmp 0x4c8e9
leaq 0x375b(%rip), %rsi # 0x4ffce
leaq -0x68(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x134, %edx # imm = 0x134
callq 0x15010
movq -0x90(%rbp), %rdi
movb $0x1, -0x69(%rbp)
callq 0x10b40
movq %rax, -0x88(%rbp)
jmp 0x4c8a1
movq -0x88(%rbp), %rdi
leaq 0x37b5(%rip), %rsi # 0x50064
callq 0x96e0
movq %rax, -0x98(%rbp)
jmp 0x4c8bd
movq -0x98(%rbp), %rdi
leaq 0x37bf(%rip), %rsi # 0x5008a
callq 0x96e0
movq %rax, -0xa0(%rbp)
jmp 0x4c8d9
movq -0xa0(%rbp), %rsi
leaq -0x1(%rbp), %rdi
callq 0x1a380
testb $0x1, -0x69(%rbp)
jne 0x4c8f1
jmp 0x4c90e
leaq -0x68(%rbp), %rdi
callq 0x15080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x4c927
jmp 0x4c932
movq $0x0, 0x3649f(%rip) # 0x82db8
callq 0x96d0
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x15080
jmp 0x4c932
jmp 0x4c934
movq -0x78(%rbp), %rdi
callq 0x9cc0
movq %rax, %rdi
callq 0xc110
nopw %cs:(%rax,%rax)
| _ZN5nglog5tools24ShutdownLoggingUtilitiesEv:
push rbp
mov rbp, rsp
sub rsp, 0A0h
call _ZN5nglog20IsLoggingInitializedEv; nglog::IsLoggingInitialized(void)
xor al, 0FFh
mov [rbp+var_69], 0
test al, 1
jnz short loc_4C86C
jmp short loc_4C8E9
loc_4C86C:
lea rsi, aWorkspaceLlm4b_4; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rbp+var_68]; this
mov [rbp+var_90], rdi
mov edx, 134h; int
call _ZN5nglog15LogMessageFatalC2EPKci; nglog::LogMessageFatal::LogMessageFatal(char const*,int)
mov rdi, [rbp+var_90]; this
mov [rbp+var_69], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov [rbp+var_88], rax
jmp short $+2
loc_4C8A1:
mov rdi, [rbp+var_88]
lea rsi, aCheckFailedIsl_0; "Check failed: IsLoggingInitialized() "
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_98], rax
jmp short $+2
loc_4C8BD:
mov rdi, [rbp+var_98]
lea rsi, aYouCalledShutd; "You called ShutdownLogging() without ca"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_A0], rax
jmp short $+2
loc_4C8D9:
mov rsi, [rbp+var_A0]
lea rdi, [rbp+var_1]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_4C8E9:
test [rbp+var_69], 1
jnz short loc_4C8F1
jmp short loc_4C90E
loc_4C8F1:
lea rdi, [rbp+var_68]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
mov rcx, rax
mov eax, edx
mov [rbp+var_78], rcx
mov [rbp+var_7C], eax
test [rbp+var_69], 1
jnz short loc_4C927
jmp short loc_4C932
loc_4C90E:
mov cs:_ZN5nglogL31g_program_invocation_short_nameE, 0; nglog::g_program_invocation_short_name
call _closelog
add rsp, 0A0h
pop rbp
retn
loc_4C927:
lea rdi, [rbp+var_68]; this
call _ZN5nglog15LogMessageFatalD2Ev; nglog::LogMessageFatal::~LogMessageFatal()
jmp short $+2
loc_4C932:
jmp short $+2
loc_4C934:
mov rdi, [rbp+var_78]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long nglog::tools::ShutdownLoggingUtilities(nglog::tools *this, long long a2)
{
long long v3; // [rsp+8h] [rbp-98h]
long long v4; // [rsp+18h] [rbp-88h]
char v5; // [rsp+37h] [rbp-69h]
nglog::LogDestination *v6[12]; // [rsp+38h] [rbp-68h] BYREF
char v7; // [rsp+9Fh] [rbp-1h] BYREF
v5 = 0;
if ( !nglog::IsLoggingInitialized(this) )
{
nglog::LogMessageFatal::LogMessageFatal(
v6,
(std::this_thread *)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
0x134u);
v5 = 1;
v4 = nglog::LogMessage::stream((nglog::LogMessage *)v6);
v3 = std::operator<<<std::char_traits<char>>(v4, "Check failed: IsLoggingInitialized() ");
a2 = std::operator<<<std::char_traits<char>>(
v3,
"You called ShutdownLogging() without calling InitializeLogging() first!");
this = (nglog::tools *)&v7;
nglog::internal::LogMessageVoidify::operator&();
}
if ( (v5 & 1) != 0 )
nglog::LogMessageFatal::~LogMessageFatal(v6);
nglog::g_program_invocation_short_name = 0LL;
return closelog(this, a2);
}
| ShutdownLoggingUtilities:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
CALL 0x0014c550
XOR AL,0xff
MOV byte ptr [RBP + -0x69],0x0
TEST AL,0x1
JNZ 0x0014c86c
JMP 0x0014c8e9
LAB_0014c86c:
LEA RSI,[0x14ffce]
LEA RDI,[RBP + -0x68]
MOV qword ptr [RBP + -0x90],RDI
MOV EDX,0x134
CALL 0x00115010
MOV RDI,qword ptr [RBP + -0x90]
MOV byte ptr [RBP + -0x69],0x1
LAB_0014c893:
CALL 0x00110b40
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0014c8a1
LAB_0014c8a1:
MOV RDI,qword ptr [RBP + -0x88]
LEA RSI,[0x150064]
CALL 0x001096e0
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0014c8bd
LAB_0014c8bd:
MOV RDI,qword ptr [RBP + -0x98]
LEA RSI,[0x15008a]
CALL 0x001096e0
LAB_0014c8d0:
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x0014c8d9
LAB_0014c8d9:
MOV RSI,qword ptr [RBP + -0xa0]
LEA RDI,[RBP + -0x1]
CALL 0x0011a380
LAB_0014c8e9:
TEST byte ptr [RBP + -0x69],0x1
JNZ 0x0014c8f1
JMP 0x0014c90e
LAB_0014c8f1:
LEA RDI,[RBP + -0x68]
CALL 0x00115080
LAB_0014c8fa:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RBP + -0x78],RCX
MOV dword ptr [RBP + -0x7c],EAX
TEST byte ptr [RBP + -0x69],0x1
JNZ 0x0014c927
JMP 0x0014c932
LAB_0014c90e:
MOV qword ptr [0x00182db8],0x0
CALL 0x001096d0
ADD RSP,0xa0
POP RBP
RET
LAB_0014c927:
LEA RDI,[RBP + -0x68]
CALL 0x00115080
LAB_0014c930:
JMP 0x0014c932
LAB_0014c932:
JMP 0x0014c934
LAB_0014c934:
MOV RDI,qword ptr [RBP + -0x78]
CALL 0x00109cc0
|
/* nglog::tools::ShutdownLoggingUtilities() */
void nglog::tools::ShutdownLoggingUtilities(void)
{
byte bVar1;
ostream *poVar2;
int8 uVar3;
bool bVar4;
LogMessageFatal local_70 [103];
LogMessageVoidify local_9;
bVar1 = IsLoggingInitialized();
bVar4 = ((bVar1 ^ 0xff) & 1) != 0;
if (bVar4) {
LogMessageFatal::LogMessageFatal
(local_70,"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/utilities.cc",
0x134);
/* try { // try from 0014c893 to 0014c8cf has its CatchHandler @ 0014c8fa */
poVar2 = (ostream *)LogMessage::stream((LogMessage *)local_70);
poVar2 = std::operator<<(poVar2,"Check failed: IsLoggingInitialized() ");
poVar2 = std::operator<<(poVar2,
"You called ShutdownLogging() without calling InitializeLogging() first!"
);
internal::LogMessageVoidify::operator&(&local_9,poVar2);
uVar3 = LogMessageFatal::~LogMessageFatal(local_70);
/* catch(type#1 @ 00000000) { ... } // from try @ 0014c893 with catch @ 0014c8fa
*/
if (bVar4) {
/* try { // try from 0014c927 to 0014c92f has its CatchHandler @ 0014c93d */
LogMessageFatal::~LogMessageFatal(local_70);
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar3);
}
g_program_invocation_short_name = 0;
closelog();
return;
}
| |
24,476 | my_large_free | eloqsql/mysys/my_largepage.c | void my_large_free(void *ptr, size_t size)
{
DBUG_ENTER("my_large_free");
/*
The following implementations can only fail if ptr was not allocated with
my_large_malloc(), i.e. my_malloc_lock() was used so we should free it
with my_free_lock()
For ASAN, we need to explicitly unpoison this memory region because the OS
may reuse that memory for some TLS or stack variable. It will remain
poisoned if it was explicitly poisioned before release. If this happens,
we'll have hard to debug false positives like in MDEV-21239.
For valgrind, we mark it as UNDEFINED rather than NOACCESS because of the
implict reuse possiblility.
*/
#if defined(HAVE_MMAP) && !defined(_WIN32)
if (munmap(ptr, size))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size, errno);
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#elif defined(_WIN32)
/*
When RELEASE memory, the size parameter must be 0.
Do not use MEM_RELEASE with MEM_DECOMMIT.
*/
if (ptr && !VirtualFree(ptr, 0, MEM_RELEASE))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size,
GetLastError());
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#else
my_free_lock(ptr);
#endif
DBUG_VOID_RETURN;
} | O3 | c | my_large_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x294d0
testl %eax, %eax
je 0xa7814
callq 0x29790
movl (%rax), %r8d
movl $0x80, %esi
movl $0x24, %edi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x9db07
popq %rbx
popq %r14
popq %rbp
retq
| my_large_free:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _munmap
test eax, eax
jz short loc_A7814
call ___errno_location
mov r8d, [rax]
mov esi, 80h
mov edi, 24h ; '$'
mov rdx, r14
mov rcx, rbx
xor eax, eax
pop rbx
pop r14
pop rbp
jmp my_error
loc_A7814:
pop rbx
pop r14
pop rbp
retn
| unsigned long long my_large_free(long long a1, long long a2)
{
unsigned long long result; // rax
unsigned int *v3; // rax
result = munmap(a1, a2);
if ( (_DWORD)result )
{
v3 = (unsigned int *)__errno_location(a1);
return my_error(0x24u, 128LL, a1, a2, *v3);
}
return result;
}
| my_large_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x001294d0
TEST EAX,EAX
JZ 0x001a7814
CALL 0x00129790
MOV R8D,dword ptr [RAX]
MOV ESI,0x80
MOV EDI,0x24
MOV RDX,R14
MOV RCX,RBX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
JMP 0x0019db07
LAB_001a7814:
POP RBX
POP R14
POP RBP
RET
|
void my_large_free(void *param_1,size_t param_2)
{
int iVar1;
int *piVar2;
iVar1 = munmap(param_1,param_2);
if (iVar1 != 0) {
piVar2 = __errno_location();
my_error(0x24,0x80,param_1,param_2,*piVar2);
return;
}
return;
}
| |
24,477 | ft_make_key | eloqsql/storage/myisam/ft_update.c | uint _ft_make_key(MI_INFO *info, uint keynr, uchar *keybuf, FT_WORD *wptr,
my_off_t filepos)
{
uchar buf[HA_FT_MAXBYTELEN+16];
float weight=(float) ((filepos==HA_OFFSET_ERROR) ? 0 : wptr->weight);
DBUG_ENTER("_ft_make_key");
mi_float4store(buf,weight);
int2store(buf+HA_FT_WLEN,wptr->len);
memcpy(buf+HA_FT_WLEN+2,wptr->pos,wptr->len);
DBUG_RETURN(_mi_make_key(info,keynr,(uchar*) keybuf,buf,filepos));
} | O3 | c | ft_make_key:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %r8, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, %r8
je 0x745f5
cvtsd2ss 0x8(%rcx), %xmm0
movd %xmm0, %eax
jmp 0x745f7
xorl %eax, %eax
bswapl %eax
leaq -0x13a(%rbp), %rdi
movl %eax, -0x6(%rdi)
movq 0x10(%rcx), %rdx
movw %dx, -0x2(%rdi)
movq (%rcx), %rsi
movl $0x108, %ecx # imm = 0x108
callq 0x29420
leaq -0x140(%rbp), %rcx
movq %r12, %rdi
movl %r15d, %esi
movq %r14, %rdx
movq %rbx, %r8
callq 0x7af84
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x7464f
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| _ft_make_key:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 120h
mov rbx, r8
mov r14, rdx
mov r15d, esi
mov r12, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
cmp r8, 0FFFFFFFFFFFFFFFFh
jz short loc_745F5
cvtsd2ss xmm0, qword ptr [rcx+8]
movd eax, xmm0
jmp short loc_745F7
loc_745F5:
xor eax, eax
loc_745F7:
bswap eax
lea rdi, [rbp+var_13A]
mov [rdi-6], eax
mov rdx, [rcx+10h]
mov [rdi-2], dx
mov rsi, [rcx]
mov ecx, 108h
call ___memcpy_chk
lea rcx, [rbp+var_140]
mov rdi, r12
mov esi, r15d
mov rdx, r14
mov r8, rbx
call _mi_make_key
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_7464F
add rsp, 120h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7464F:
call ___stack_chk_fail
| long long ft_make_key(long long a1, unsigned int a2, long long a3, long long a4, long long a5, __m128i a6)
{
unsigned int v8; // eax
long long v9; // rdx
unsigned __int32 v11; // [rsp+0h] [rbp-140h] BYREF
__int16 v12; // [rsp+4h] [rbp-13Ch]
_BYTE v13[274]; // [rsp+6h] [rbp-13Ah] BYREF
unsigned long long v14; // [rsp+118h] [rbp-28h]
v14 = __readfsqword(0x28u);
if ( a5 == -1 )
{
v8 = 0;
}
else
{
*(float *)a6.m128i_i32 = *(double *)(a4 + 8);
v8 = _mm_cvtsi128_si32(a6);
}
v11 = _byteswap_ulong(v8);
v9 = *(_QWORD *)(a4 + 16);
v12 = v9;
__memcpy_chk(v13, *(_QWORD *)a4, v9, 264LL);
return mi_make_key(a1, a2, a3, &v11, a5);
}
| _ft_make_key:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x120
MOV RBX,R8
MOV R14,RDX
MOV R15D,ESI
MOV R12,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CMP R8,-0x1
JZ 0x001745f5
CVTSD2SS XMM0,qword ptr [RCX + 0x8]
MOVD EAX,XMM0
JMP 0x001745f7
LAB_001745f5:
XOR EAX,EAX
LAB_001745f7:
BSWAP EAX
LEA RDI,[RBP + -0x13a]
MOV dword ptr [RDI + -0x6],EAX
MOV RDX,qword ptr [RCX + 0x10]
MOV word ptr [RDI + -0x2],DX
MOV RSI,qword ptr [RCX]
MOV ECX,0x108
CALL 0x00129420
LEA RCX,[RBP + -0x140]
MOV RDI,R12
MOV ESI,R15D
MOV RDX,R14
MOV R8,RBX
CALL 0x0017af84
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x0017464f
ADD RSP,0x120
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017464f:
CALL 0x00129270
|
void _ft_make_key(int8 param_1,int4 param_2,int8 param_3,int8 *param_4,
long param_5)
{
long in_FS_OFFSET;
float fVar1;
uint local_148;
int2 local_144;
int1 local_142 [274];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
if (param_5 == -1) {
fVar1 = 0.0;
}
else {
fVar1 = (float)(double)param_4[1];
}
local_148 = (uint)fVar1 >> 0x18 | ((uint)fVar1 & 0xff0000) >> 8 | ((uint)fVar1 & 0xff00) << 8 |
(int)fVar1 << 0x18;
local_144 = (int2)param_4[2];
__memcpy_chk(local_142,*param_4,param_4[2],0x108);
_mi_make_key(param_1,param_2,param_3,&local_148,param_5);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,478 | translog_set_file_size | eloqsql/storage/maria/ma_loghandler.c | void translog_set_file_size(uint32 size)
{
struct st_translog_buffer *old_buffer= NULL;
DBUG_ENTER("translog_set_file_size");
translog_lock();
DBUG_PRINT("enter", ("Size: %lu", (ulong) size));
DBUG_ASSERT(size % TRANSLOG_PAGE_SIZE == 0);
DBUG_ASSERT(size >= TRANSLOG_MIN_FILE_SIZE);
log_descriptor.log_file_max_size= size;
/* if current file longer then finish it*/
if (LSN_OFFSET(log_descriptor.horizon) >= log_descriptor.log_file_max_size)
{
old_buffer= log_descriptor.bc.buffer;
translog_buffer_next(&log_descriptor.horizon, &log_descriptor.bc, 1);
translog_buffer_unlock(old_buffer);
}
translog_unlock();
if (old_buffer)
{
translog_buffer_lock(old_buffer);
translog_buffer_flush(old_buffer);
translog_buffer_unlock(old_buffer);
}
DBUG_VOID_RETURN;
} | O3 | c | translog_set_file_size:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0x3265f
movl %ebx, 0x3c6868(%rip) # 0x3fdf00
cmpl %ebx, 0xbc749a(%rip) # 0xbfeb38
jae 0x376a4
xorl %ebx, %ebx
jmp 0x376df
movq 0xbc74bd(%rip), %rbx # 0xbfeb68
leaq 0xbc7486(%rip), %rdi # 0xbfeb38
leaq 0xbc7487(%rip), %rsi # 0xbfeb40
movl $0x1, %edx
callq 0x37773
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x3775e
leaq 0x100090(%rbx), %rdi
callq 0x291c0
movq 0xbc7482(%rip), %r14 # 0xbfeb68
movq 0x1000d0(%r14), %rdi
testq %rdi, %rdi
jne 0x3773a
addq $0x100090, %r14 # imm = 0x100090
movq %r14, %rdi
callq 0x291c0
testq %rbx, %rbx
je 0x37735
movq %rbx, %rdi
callq 0x326ff
movq %rbx, %rdi
callq 0x363cd
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x3774c
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x291c0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x34e8cf(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x376f2
leaq 0x34e8bd(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x37722
leaq 0x34e8ab(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x376d3
| translog_set_file_size:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
call translog_lock
mov cs:dword_3FDF00, ebx
cmp dword ptr cs:qword_BFEB38, ebx
jnb short loc_376A4
xor ebx, ebx
jmp short loc_376DF
loc_376A4:
mov rbx, qword ptr cs:xmmword_BFEB60+8
lea rdi, qword_BFEB38
lea rsi, xmmword_BFEB40
mov edx, 1
call translog_buffer_next
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz loc_3775E
loc_376D3:
lea rdi, unk_100090[rbx]
call _pthread_mutex_unlock
loc_376DF:
mov r14, qword ptr cs:xmmword_BFEB60+8
mov rdi, ds:qword_1000D0[r14]
test rdi, rdi
jnz short loc_3773A
loc_376F2:
add r14, 100090h
mov rdi, r14
call _pthread_mutex_unlock
test rbx, rbx
jz short loc_37735
mov rdi, rbx
call translog_buffer_lock
mov rdi, rbx
call translog_buffer_flush
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz short loc_3774C
loc_37722:
add rbx, 100090h
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_37735:
pop rbx
pop r14
pop rbp
retn
loc_3773A:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_376F2
loc_3774C:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_37722
loc_3775E:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_376D3
| long long translog_set_file_size(unsigned int a1)
{
long long v1; // rbx
long long v2; // r14
long long result; // rax
translog_lock();
dword_3FDF00 = a1;
if ( (unsigned int)qword_BFEB38 >= a1 )
{
v1 = *((_QWORD *)&xmmword_BFEB60 + 1);
translog_buffer_next(&qword_BFEB38, &xmmword_BFEB40, 1LL);
if ( *(long long *)((char *)&qword_1000D0 + v1) )
PSI_server[44]();
pthread_mutex_unlock((char *)&unk_100090 + v1);
}
else
{
v1 = 0LL;
}
v2 = *((_QWORD *)&xmmword_BFEB60 + 1);
if ( *(long long *)((char *)&qword_1000D0 + *((_QWORD *)&xmmword_BFEB60 + 1)) )
PSI_server[44]();
result = pthread_mutex_unlock(v2 + 1048720);
if ( v1 )
{
translog_buffer_lock(v1);
translog_buffer_flush(v1);
if ( *(long long *)((char *)&qword_1000D0 + v1) )
PSI_server[44]();
return pthread_mutex_unlock(v1 + 1048720);
}
return result;
}
| translog_set_file_size:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
CALL 0x0013265f
MOV dword ptr [0x004fdf00],EBX
CMP dword ptr [0x00cfeb38],EBX
JNC 0x001376a4
XOR EBX,EBX
JMP 0x001376df
LAB_001376a4:
MOV RBX,qword ptr [0x00cfeb68]
LEA RDI,[0xcfeb38]
LEA RSI,[0xcfeb40]
MOV EDX,0x1
CALL 0x00137773
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x0013775e
LAB_001376d3:
LEA RDI,[RBX + 0x100090]
CALL 0x001291c0
LAB_001376df:
MOV R14,qword ptr [0x00cfeb68]
MOV RDI,qword ptr [R14 + 0x1000d0]
TEST RDI,RDI
JNZ 0x0013773a
LAB_001376f2:
ADD R14,0x100090
MOV RDI,R14
CALL 0x001291c0
TEST RBX,RBX
JZ 0x00137735
MOV RDI,RBX
CALL 0x001326ff
MOV RDI,RBX
CALL 0x001363cd
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x0013774c
LAB_00137722:
ADD RBX,0x100090
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x001291c0
LAB_00137735:
POP RBX
POP R14
POP RBP
RET
LAB_0013773a:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001376f2
LAB_0013774c:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00137722
LAB_0013775e:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001376d3
|
void translog_set_file_size(uint param_1)
{
long lVar1;
long lVar2;
translog_lock();
lVar2 = DAT_00cfeb68;
DAT_004fdf00 = param_1;
if ((uint)DAT_00cfeb38 < param_1) {
lVar2 = 0;
}
else {
translog_buffer_next(&DAT_00cfeb38,&DAT_00cfeb40,1);
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + lVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
}
lVar1 = DAT_00cfeb68;
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + DAT_00cfeb68) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar1));
if (lVar2 != 0) {
translog_buffer_lock(lVar2);
translog_buffer_flush(lVar2);
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + lVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + lVar2));
return;
}
return;
}
| |
24,479 | mi_reset | eloqsql/storage/myisam/mi_extra.c | int mi_reset(MI_INFO *info)
{
int error= 0;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_reset");
/*
Free buffers and reset the following flags:
EXTRA_CACHE, EXTRA_WRITE_CACHE, EXTRA_KEYREAD, EXTRA_QUICK
If the row buffer cache is large (for dynamic tables), reduce it
to save memory.
*/
if (info->opt_flag & (READ_CACHE_USED | WRITE_CACHE_USED))
{
info->opt_flag&= ~(READ_CACHE_USED | WRITE_CACHE_USED);
error= end_io_cache(&info->rec_cache);
}
if (share->base.blobs)
mi_alloc_rec_buff(info, -1, &info->rec_buff);
#if defined(HAVE_MMAP) && defined(HAVE_MADVISE)
if (info->opt_flag & MEMMAP_USED)
madvise((char*) share->file_map, share->state.state.data_file_length,
MADV_RANDOM);
#endif
info->opt_flag&= ~(KEY_READ_USED | REMEMBER_OLD_POS);
info->quick_mode=0;
info->lastinx= 0; /* Use first index as def */
info->last_search_keypage= info->lastpos= HA_OFFSET_ERROR;
info->page_changed= 1;
info->update= ((info->update & HA_STATE_CHANGED) | HA_STATE_NEXT_FOUND |
HA_STATE_PREV_FOUND);
DBUG_RETURN(error);
} | O3 | c | mi_reset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movl 0x1c8(%rdi), %eax
testb $0x12, %al
je 0x7a7aa
andl $-0x13, %eax
movl %eax, 0x1c8(%rbx)
leaq 0x220(%rbx), %rdi
callq 0x960d3
movl %eax, %r14d
jmp 0x7a7ad
xorl %r14d, %r14d
cmpl $0x0, 0x188(%r15)
je 0x7a7cd
leaq 0x120(%rbx), %rdx
movq %rbx, %rdi
movq $-0x1, %rsi
callq 0x7f8c9
movl 0x1c8(%rbx), %eax
testb $0x20, %al
je 0x7a7f2
movq 0x270(%r15), %rdi
movq 0x40(%r15), %rsi
movl $0x1, %edx
callq 0x29490
movl 0x1c8(%rbx), %eax
andl $-0x49, %eax
movl %eax, 0x1c8(%rbx)
movw $0x100, 0x33b(%rbx) # imm = 0x100
movl $0x0, 0x1d4(%rbx)
movq $-0x1, %rax
movq %rax, 0x170(%rbx)
movq %rax, 0x198(%rbx)
movl 0x1d0(%rbx), %eax
andl $0x1, %eax
orl $0x30, %eax
movl %eax, 0x1d0(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mi_reset:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r15, [rdi]
mov eax, [rdi+1C8h]
test al, 12h
jz short loc_7A7AA
and eax, 0FFFFFFEDh
mov [rbx+1C8h], eax
lea rdi, [rbx+220h]
call end_io_cache
mov r14d, eax
jmp short loc_7A7AD
loc_7A7AA:
xor r14d, r14d
loc_7A7AD:
cmp dword ptr [r15+188h], 0
jz short loc_7A7CD
lea rdx, [rbx+120h]
mov rdi, rbx
mov rsi, 0FFFFFFFFFFFFFFFFh
call mi_alloc_rec_buff
loc_7A7CD:
mov eax, [rbx+1C8h]
test al, 20h
jz short loc_7A7F2
mov rdi, [r15+270h]
mov rsi, [r15+40h]
mov edx, 1
call _madvise
mov eax, [rbx+1C8h]
loc_7A7F2:
and eax, 0FFFFFFB7h
mov [rbx+1C8h], eax
mov word ptr [rbx+33Bh], 100h
mov dword ptr [rbx+1D4h], 0
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbx+170h], rax
mov [rbx+198h], rax
mov eax, [rbx+1D0h]
and eax, 1
or eax, 30h
mov [rbx+1D0h], eax
mov eax, r14d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mi_reset(long long *a1)
{
long long v1; // r15
int v2; // eax
unsigned int v3; // r14d
int v4; // eax
v1 = *a1;
v2 = *((_DWORD *)a1 + 114);
if ( (v2 & 0x12) != 0 )
{
*((_DWORD *)a1 + 114) = v2 & 0xFFFFFFED;
v3 = end_io_cache(a1 + 68);
}
else
{
v3 = 0;
}
if ( *(_DWORD *)(v1 + 392) )
mi_alloc_rec_buff(a1, -1LL, a1 + 36);
v4 = *((_DWORD *)a1 + 114);
if ( (v4 & 0x20) != 0 )
{
madvise(*(_QWORD *)(v1 + 624), *(_QWORD *)(v1 + 64), 1LL);
v4 = *((_DWORD *)a1 + 114);
}
*((_DWORD *)a1 + 114) = v4 & 0xFFFFFFB7;
*(_WORD *)((char *)a1 + 827) = 256;
*((_DWORD *)a1 + 117) = 0;
a1[46] = -1LL;
a1[51] = -1LL;
*((_DWORD *)a1 + 116) = a1[58] & 1 | 0x30;
return v3;
}
| mi_reset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R15,qword ptr [RDI]
MOV EAX,dword ptr [RDI + 0x1c8]
TEST AL,0x12
JZ 0x0017a7aa
AND EAX,0xffffffed
MOV dword ptr [RBX + 0x1c8],EAX
LEA RDI,[RBX + 0x220]
CALL 0x001960d3
MOV R14D,EAX
JMP 0x0017a7ad
LAB_0017a7aa:
XOR R14D,R14D
LAB_0017a7ad:
CMP dword ptr [R15 + 0x188],0x0
JZ 0x0017a7cd
LEA RDX,[RBX + 0x120]
MOV RDI,RBX
MOV RSI,-0x1
CALL 0x0017f8c9
LAB_0017a7cd:
MOV EAX,dword ptr [RBX + 0x1c8]
TEST AL,0x20
JZ 0x0017a7f2
MOV RDI,qword ptr [R15 + 0x270]
MOV RSI,qword ptr [R15 + 0x40]
MOV EDX,0x1
CALL 0x00129490
MOV EAX,dword ptr [RBX + 0x1c8]
LAB_0017a7f2:
AND EAX,0xffffffb7
MOV dword ptr [RBX + 0x1c8],EAX
MOV word ptr [RBX + 0x33b],0x100
MOV dword ptr [RBX + 0x1d4],0x0
MOV RAX,-0x1
MOV qword ptr [RBX + 0x170],RAX
MOV qword ptr [RBX + 0x198],RAX
MOV EAX,dword ptr [RBX + 0x1d0]
AND EAX,0x1
OR EAX,0x30
MOV dword ptr [RBX + 0x1d0],EAX
MOV EAX,R14D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mi_reset(long *param_1)
{
long lVar1;
int4 uVar2;
uint uVar3;
lVar1 = *param_1;
if ((*(uint *)(param_1 + 0x39) & 0x12) == 0) {
uVar2 = 0;
}
else {
*(uint *)(param_1 + 0x39) = *(uint *)(param_1 + 0x39) & 0xffffffed;
uVar2 = end_io_cache(param_1 + 0x44);
}
if (*(int *)(lVar1 + 0x188) != 0) {
mi_alloc_rec_buff(param_1,0xffffffffffffffff,param_1 + 0x24);
}
uVar3 = *(uint *)(param_1 + 0x39);
if ((uVar3 & 0x20) != 0) {
madvise(*(void **)(lVar1 + 0x270),*(size_t *)(lVar1 + 0x40),1);
uVar3 = *(uint *)(param_1 + 0x39);
}
*(uint *)(param_1 + 0x39) = uVar3 & 0xffffffb7;
*(int2 *)((long)param_1 + 0x33b) = 0x100;
*(int4 *)((long)param_1 + 0x1d4) = 0;
param_1[0x2e] = -1;
param_1[0x33] = -1;
*(uint *)(param_1 + 0x3a) = *(uint *)(param_1 + 0x3a) & 1 | 0x30;
return uVar2;
}
| |
24,480 | Balloc | eloqsql/strings/dtoa.c | static Bigint *Balloc(int k, Stack_alloc *alloc)
{
Bigint *rv;
DBUG_ASSERT(k <= Kmax);
if (k <= Kmax && alloc->freelist[k])
{
rv= alloc->freelist[k];
alloc->freelist[k]= rv->p.next;
}
else
{
int x, len;
x= 1 << k;
len= MY_ALIGN(sizeof(Bigint) + x * sizeof(ULong), SIZEOF_CHARP);
if (alloc->free + len <= alloc->end)
{
rv= (Bigint*) alloc->free;
alloc->free+= len;
}
else
rv= (Bigint*) malloc(len);
rv->k= k;
rv->maxwds= x;
}
rv->sign= rv->wds= 0;
rv->p.x= (ULong*) (rv + 1);
return rv;
} | O0 | c | Balloc:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x724b1
cmpl $0xf, -0x4(%rbp)
jg 0x724f1
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0x724f1
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x18(%rax,%rcx,8)
jmp 0x72576
movl -0x4(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq $0x18, %rax
addq $0x8, %rax
subq $0x1, %rax
andq $-0x8, %rax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x72555
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0x72562
movslq -0x20(%rbp), %rdi
callq 0x243c0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
addq $0x18, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| Balloc:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
jmp short $+2
loc_724B1:
cmp [rbp+var_4], 0Fh
jg short loc_724F1
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
cmp qword ptr [rax+rcx*8+18h], 0
jz short loc_724F1
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov rax, [rax+rcx*8+18h]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdx, [rax]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_4]
mov [rax+rcx*8+18h], rdx
jmp loc_72576
loc_724F1:
mov ecx, [rbp+var_4]
mov eax, 1
shl eax, cl
mov [rbp+var_1C], eax
movsxd rax, [rbp+var_1C]
shl rax, 2
add rax, 18h
add rax, 8
sub rax, 1
and rax, 0FFFFFFFFFFFFFFF8h
mov [rbp+var_20], eax
mov rax, [rbp+var_10]
mov rax, [rax+8]
movsxd rcx, [rbp+var_20]
add rax, rcx
mov rcx, [rbp+var_10]
cmp rax, [rcx+10h]
ja short loc_72555
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov edx, [rbp+var_20]
mov rax, [rbp+var_10]
mov rcx, [rax+8]
movsxd rdx, edx
add rcx, rdx
mov [rax+8], rcx
jmp short loc_72562
loc_72555:
movsxd rdi, [rbp+var_20]
call _malloc
mov [rbp+var_18], rax
loc_72562:
mov ecx, [rbp+var_4]
mov rax, [rbp+var_18]
mov [rax+8], ecx
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_18]
mov [rax+0Ch], ecx
loc_72576:
mov rax, [rbp+var_18]
mov dword ptr [rax+14h], 0
mov rax, [rbp+var_18]
mov dword ptr [rax+10h], 0
mov rcx, [rbp+var_18]
add rcx, 18h
mov rax, [rbp+var_18]
mov [rax], rcx
mov rax, [rbp+var_18]
add rsp, 20h
pop rbp
retn
| long long Balloc(int a1, long long a2)
{
signed int v3; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
if ( a1 <= 15 && *(_QWORD *)(a2 + 8LL * a1 + 24) )
{
v4 = *(_QWORD *)(a2 + 8LL * a1 + 24);
*(_QWORD *)(a2 + 8LL * a1 + 24) = *(_QWORD *)v4;
}
else
{
v3 = (4 * (1 << a1) + 31) & 0xFFFFFFF8;
if ( (unsigned long long)(v3 + *(_QWORD *)(a2 + 8)) > *(_QWORD *)(a2 + 16) )
{
v4 = malloc(v3);
}
else
{
v4 = *(_QWORD *)(a2 + 8);
*(_QWORD *)(a2 + 8) = v3 + v4;
}
*(_DWORD *)(v4 + 8) = a1;
*(_DWORD *)(v4 + 12) = 1 << a1;
}
*(_DWORD *)(v4 + 20) = 0;
*(_DWORD *)(v4 + 16) = 0;
*(_QWORD *)v4 = v4 + 24;
return v4;
}
| Balloc:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001724b1
LAB_001724b1:
CMP dword ptr [RBP + -0x4],0xf
JG 0x001724f1
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
CMP qword ptr [RAX + RCX*0x8 + 0x18],0x0
JZ 0x001724f1
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x4]
MOV qword ptr [RAX + RCX*0x8 + 0x18],RDX
JMP 0x00172576
LAB_001724f1:
MOV ECX,dword ptr [RBP + -0x4]
MOV EAX,0x1
SHL EAX,CL
MOV dword ptr [RBP + -0x1c],EAX
MOVSXD RAX,dword ptr [RBP + -0x1c]
SHL RAX,0x2
ADD RAX,0x18
ADD RAX,0x8
SUB RAX,0x1
AND RAX,-0x8
MOV dword ptr [RBP + -0x20],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOVSXD RCX,dword ptr [RBP + -0x20]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x10]
JA 0x00172555
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV EDX,dword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x8]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x8],RCX
JMP 0x00172562
LAB_00172555:
MOVSXD RDI,dword ptr [RBP + -0x20]
CALL 0x001243c0
MOV qword ptr [RBP + -0x18],RAX
LAB_00172562:
MOV ECX,dword ptr [RBP + -0x4]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0xc],ECX
LAB_00172576:
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x10],0x0
MOV RCX,qword ptr [RBP + -0x18]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x20
POP RBP
RET
|
int8 * Balloc(int param_1,long param_2)
{
int iVar1;
uint uVar2;
int8 *local_20;
if ((param_1 < 0x10) && (*(long *)(param_2 + 0x18 + (long)param_1 * 8) != 0)) {
local_20 = *(int8 **)(param_2 + 0x18 + (long)param_1 * 8);
*(int8 *)(param_2 + 0x18 + (long)param_1 * 8) = *local_20;
}
else {
iVar1 = 1 << ((byte)param_1 & 0x1f);
uVar2 = iVar1 * 4 + 0x1fU & 0xfffffff8;
if (*(ulong *)(param_2 + 0x10) < (ulong)(*(long *)(param_2 + 8) + (long)(int)uVar2)) {
local_20 = (int8 *)malloc((long)(int)uVar2);
}
else {
local_20 = *(int8 **)(param_2 + 8);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + (long)(int)uVar2;
}
*(int *)(local_20 + 1) = param_1;
*(int *)((long)local_20 + 0xc) = iVar1;
}
*(int4 *)((long)local_20 + 0x14) = 0;
*(int4 *)(local_20 + 2) = 0;
*local_20 = local_20 + 3;
return local_20;
}
| |
24,481 | common_tokenize(llama_vocab const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | llama.cpp/common/common.cpp | std::vector<llama_token> common_tokenize(
const struct llama_vocab * vocab,
const std::string & text,
bool add_special,
bool parse_special) {
// upper limit for the number of tokens
int n_tokens = text.length() + 2 * add_special;
std::vector<llama_token> result(n_tokens);
n_tokens = llama_tokenize(vocab, text.data(), text.length(), result.data(), result.size(), add_special, parse_special);
if (n_tokens < 0) {
result.resize(-n_tokens);
int check = llama_tokenize(vocab, text.data(), text.length(), result.data(), result.size(), add_special, parse_special);
GGML_ASSERT(check == -n_tokens);
} else {
result.resize(n_tokens);
}
return result;
} | O3 | cpp | common_tokenize(llama_vocab const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leal (%r14,%r14), %eax
addl 0x8(%rdx), %eax
movslq %eax, %rsi
leaq 0x17(%rsp), %rdx
callq 0xb0c9e
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
subq %rcx, %r8
shrq $0x2, %r8
movl %ebp, (%rsp)
movq %r15, %rdi
movl %r14d, %r9d
callq 0x1cdb0
movl %eax, %r13d
testl %eax, %eax
js 0xb0182
movl %r13d, %esi
movq %rbx, %rdi
callq 0xb0d2a
jmp 0xb01bf
negl %r13d
movq %rbx, %rdi
movq %r13, %rsi
callq 0xb0d2a
movq (%r12), %rsi
movl 0x8(%r12), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
subq %rcx, %r8
shrq $0x2, %r8
movzbl %bpl, %eax
movl %eax, (%rsp)
movzbl %r14b, %r9d
movq %r15, %rdi
callq 0x1cdb0
cmpl %r13d, %eax
jne 0xb01d1
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20a39(%rip), %rdi # 0xd0c11
leaq 0x17eb1(%rip), %rdx # 0xc8090
leaq 0x21047(%rip), %rcx # 0xd122d
movl $0x4db, %esi # imm = 0x4DB
xorl %eax, %eax
callq 0x1ca40
jmp 0xb01f4
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb020b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1c110
movq %r14, %rdi
callq 0x1c7d0
| _Z15common_tokenizePK11llama_vocabRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov ebp, r8d
mov r14d, ecx
mov r12, rdx
mov r15, rsi
mov rbx, rdi
lea eax, [r14+r14]
add eax, [rdx+8]
movsxd rsi, eax
lea rdx, [rsp+48h+var_31]
call _ZNSt6vectorIiSaIiEEC2EmRKS0_; std::vector<int>::vector(ulong,std::allocator<int> const&)
mov rsi, [r12]
mov edx, [r12+8]
mov rcx, [rbx]
mov r8, [rbx+8]
sub r8, rcx
shr r8, 2
mov [rsp+48h+var_48], ebp
mov rdi, r15
mov r9d, r14d
call _llama_tokenize
mov r13d, eax
test eax, eax
js short loc_B0182
mov esi, r13d
mov rdi, rbx
call _ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
jmp short loc_B01BF
loc_B0182:
neg r13d
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rsi, [r12]
mov edx, [r12+8]
mov rcx, [rbx]
mov r8, [rbx+8]
sub r8, rcx
shr r8, 2
movzx eax, bpl
mov [rsp+48h+var_48], eax
movzx r9d, r14b
mov rdi, r15
call _llama_tokenize
cmp eax, r13d
jnz short loc_B01D1
loc_B01BF:
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_B01D1:
lea rdi, aWorkspaceLlm4b_3; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCheckNTokens; "check == -n_tokens"
mov esi, 4DBh
xor eax, eax
call _ggml_abort
jmp short $+2
loc_B01F4:
mov r14, rax
mov rdi, [rbx]; void *
test rdi, rdi
jz short loc_B020B
mov rsi, [rbx+10h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B020B:
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_tokenize(_QWORD *a1, long long a2, _QWORD *a3, unsigned int a4, int a5)
{
int v8; // eax
int v9; // r13d
long long v11; // r14
_BYTE v12[49]; // [rsp+17h] [rbp-31h] BYREF
std::vector<int>::vector(a1, (int)(*((_DWORD *)a3 + 2) + 2 * a4), v12);
v8 = llama_tokenize(a2, *a3, *((unsigned int *)a3 + 2), *a1, (a1[1] - *a1) >> 2, a4, a5);
if ( v8 < 0 )
{
v9 = -v8;
std::vector<int>::resize(a1, (unsigned int)-v8);
if ( (unsigned int)llama_tokenize(
a2,
*a3,
*((unsigned int *)a3 + 2),
*a1,
(a1[1] - *a1) >> 2,
(unsigned __int8)a4,
(unsigned __int8)a5) != v9 )
{
v11 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",
1243LL,
"GGML_ASSERT(%s) failed",
"check == -n_tokens");
if ( *a1 )
operator delete((void *)*a1, a1[2] - *a1);
_Unwind_Resume(v11);
}
}
else
{
std::vector<int>::resize(a1, (unsigned int)v8);
}
return a1;
}
| common_tokenize:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV EBP,R8D
MOV R14D,ECX
MOV R12,RDX
MOV R15,RSI
MOV RBX,RDI
LEA EAX,[R14 + R14*0x1]
ADD EAX,dword ptr [RDX + 0x8]
MOVSXD RSI,EAX
LEA RDX,[RSP + 0x17]
CALL 0x001b0c9e
MOV RSI,qword ptr [R12]
MOV EDX,dword ptr [R12 + 0x8]
MOV RCX,qword ptr [RBX]
MOV R8,qword ptr [RBX + 0x8]
SUB R8,RCX
SHR R8,0x2
LAB_001b0160:
MOV dword ptr [RSP],EBP
MOV RDI,R15
MOV R9D,R14D
CALL 0x0011cdb0
MOV R13D,EAX
TEST EAX,EAX
JS 0x001b0182
MOV ESI,R13D
MOV RDI,RBX
CALL 0x001b0d2a
JMP 0x001b01bf
LAB_001b0182:
NEG R13D
MOV RDI,RBX
MOV RSI,R13
CALL 0x001b0d2a
MOV RSI,qword ptr [R12]
MOV EDX,dword ptr [R12 + 0x8]
MOV RCX,qword ptr [RBX]
MOV R8,qword ptr [RBX + 0x8]
SUB R8,RCX
SHR R8,0x2
LAB_001b01a7:
MOVZX EAX,BPL
MOV dword ptr [RSP],EAX
MOVZX R9D,R14B
MOV RDI,R15
CALL 0x0011cdb0
CMP EAX,R13D
JNZ 0x001b01d1
LAB_001b01bf:
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001b01d1:
LEA RDI,[0x1d0c11]
LEA RDX,[0x1c8090]
LEA RCX,[0x1d122d]
MOV ESI,0x4db
XOR EAX,EAX
CALL 0x0011ca40
|
/* common_tokenize(llama_vocab const*, std::__cxx11::string const&, bool, bool) */
llama_vocab * common_tokenize(llama_vocab *param_1,string *param_2,bool param_3,bool param_4)
{
uint uVar1;
uint uVar2;
int7 in_register_00000009;
int7 in_register_00000011;
int8 *puVar3;
uint in_R8D;
puVar3 = (int8 *)CONCAT71(in_register_00000011,param_3);
std::vector<int,std::allocator<int>>::vector
((ulong)param_1,
(allocator *)
(long)((int)CONCAT71(in_register_00000009,param_4) * 2 + *(int *)(puVar3 + 1)));
/* try { // try from 001b0160 to 001b018f has its CatchHandler @ 001b01f4 */
uVar1 = llama_tokenize(param_2,*puVar3,*(int4 *)(puVar3 + 1),*(long *)param_1,
(ulong)(*(long *)(param_1 + 8) - *(long *)param_1) >> 2,
CONCAT71(in_register_00000009,param_4) & 0xffffffff,in_R8D);
if ((int)uVar1 < 0) {
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_1,(ulong)-uVar1);
/* try { // try from 001b01a7 to 001b01f1 has its CatchHandler @ 001b01f2 */
uVar2 = llama_tokenize(param_2,*puVar3,*(int4 *)(puVar3 + 1),*(long *)param_1,
(ulong)(*(long *)(param_1 + 8) - *(long *)param_1) >> 2,param_4,
in_R8D & 0xff);
if (uVar2 != -uVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/common.cpp",0x4db,
"GGML_ASSERT(%s) failed","check == -n_tokens");
}
}
else {
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_1,(ulong)uVar1);
}
return param_1;
}
| |
24,482 | net_stmt_close | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static my_bool net_stmt_close(MYSQL_STMT *stmt, my_bool remove)
{
char stmt_id[STMT_ID_LENGTH];
MA_MEM_ROOT *fields_ma_alloc_root= &((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root;
/* clear memory */
ma_free_root(&stmt->result.alloc, MYF(0)); /* allocated in mysql_stmt_store_result */
ma_free_root(&stmt->mem_root,MYF(0));
ma_free_root(fields_ma_alloc_root, MYF(0));
if (stmt->mysql)
{
CLEAR_CLIENT_ERROR(stmt->mysql);
/* remove from stmt list */
if (remove)
stmt->mysql->stmts= list_delete(stmt->mysql->stmts, &stmt->list);
/* check if all data are fetched */
if (stmt->mysql->status != MYSQL_STATUS_READY)
{
do {
stmt->mysql->methods->db_stmt_flush_unbuffered(stmt);
} while(mysql_stmt_more_results(stmt));
stmt->mysql->status= MYSQL_STATUS_READY;
}
if (stmt->state > MYSQL_STMT_INITTED)
{
int4store(stmt_id, stmt->stmt_id);
if (stmt->mysql->methods->db_command(stmt->mysql,COM_STMT_CLOSE, stmt_id,
sizeof(stmt_id), 1, stmt))
{
UPDATE_STMT_ERROR(stmt);
return 1;
}
}
}
return 0;
} | O3 | c | net_stmt_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq 0x340(%rdi), %r12
addq $0x90, %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x1e037
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1e037
movq %r12, %rdi
xorl %esi, %esi
callq 0x1e037
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x201c2
movl $0x0, 0x90(%rax)
movq 0x38(%rbx), %rax
movw $0x30, 0x29b(%rax)
movl $0x30303030, 0x297(%rax) # imm = 0x30303030
movq 0x38(%rbx), %rax
movb $0x0, 0x97(%rax)
movq 0x38(%rbx), %rax
movq 0x2a0(%rax), %rcx
testq %rcx, %rcx
je 0x200d0
movl $0x0, 0x4(%rcx)
movq 0x38(%rbx), %rax
testb %r14b, %r14b
je 0x200f7
movq 0x4c8(%rax), %rdi
leaq 0x320(%rbx), %rsi
callq 0x1d0d4
movq 0x38(%rbx), %rcx
movq %rax, 0x4c8(%rcx)
movq 0x38(%rbx), %rax
cmpl $0x0, 0x488(%rax)
je 0x2012f
movq 0x4d0(%rax), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x20125
movzwl 0x380(%rax), %ecx
testl $0x1008, %ecx # imm = 0x1008
jne 0x20100
movl $0x0, 0x488(%rax)
cmpl $0x0, 0x50(%rbx)
je 0x201bf
movl 0x40(%rbx), %eax
leaq -0x2c(%rbp), %rdx
movl %eax, (%rdx)
movq 0x38(%rbx), %rdi
movq 0x4d0(%rdi), %rax
movl $0x4, %ecx
movl $0x19, %esi
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x201bf
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movb $0x1, %r15b
jmp 0x201c2
xorl %r15d, %r15d
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x201e1
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| net_stmt_close:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r14d, esi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
mov r12, [rdi+340h]
add rdi, 90h
xor r15d, r15d
xor esi, esi
call ma_free_root
mov rdi, rbx
xor esi, esi
call ma_free_root
mov rdi, r12
xor esi, esi
call ma_free_root
mov rax, [rbx+38h]
test rax, rax
jz loc_201C2
mov dword ptr [rax+90h], 0
mov rax, [rbx+38h]
mov word ptr [rax+29Bh], 30h ; '0'
mov dword ptr [rax+297h], 30303030h
mov rax, [rbx+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbx+38h]
mov rcx, [rax+2A0h]
test rcx, rcx
jz short loc_200D0
mov dword ptr [rcx+4], 0
mov rax, [rbx+38h]
loc_200D0:
test r14b, r14b
jz short loc_200F7
mov rdi, [rax+4C8h]
lea rsi, [rbx+320h]
call list_delete
mov rcx, [rbx+38h]
mov [rcx+4C8h], rax
mov rax, [rbx+38h]
loc_200F7:
cmp dword ptr [rax+488h], 0
jz short loc_2012F
loc_20100:
mov rax, [rax+4D0h]
mov rdi, rbx
call qword ptr [rax+78h]
mov rax, [rbx+38h]
test rax, rax
jz short loc_20125
movzx ecx, word ptr [rax+380h]
test ecx, 1008h
jnz short loc_20100
loc_20125:
mov dword ptr [rax+488h], 0
loc_2012F:
cmp dword ptr [rbx+50h], 0
jz loc_201BF
mov eax, [rbx+40h]
lea rdx, [rbp+var_2C]
mov [rdx], eax
mov rdi, [rbx+38h]
mov rax, [rdi+4D0h]
mov ecx, 4
mov esi, 19h
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jz short loc_201BF
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r15b, 1
jmp short loc_201C2
loc_201BF:
xor r15d, r15d
loc_201C2:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_201E1
mov eax, r15d
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_201E1:
call ___stack_chk_fail
| long long net_stmt_close(long long a1, char a2)
{
long long v2; // r12
unsigned int v3; // r15d
long long v4; // rax
long long v5; // rax
long long v6; // rcx
long long v7; // rsi
int v9; // [rsp+4h] [rbp-2Ch] BYREF
unsigned long long v10; // [rsp+8h] [rbp-28h]
v10 = __readfsqword(0x28u);
v2 = *(_QWORD *)(a1 + 832);
v3 = 0;
ma_free_root(a1 + 144, 0);
ma_free_root(a1, 0);
ma_free_root(v2, 0);
v4 = *(_QWORD *)(a1 + 56);
if ( v4 )
{
*(_DWORD *)(v4 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v5 = *(_QWORD *)(a1 + 56);
v6 = *(_QWORD *)(v5 + 672);
if ( v6 )
{
*(_DWORD *)(v6 + 4) = 0;
v5 = *(_QWORD *)(a1 + 56);
}
if ( a2 )
{
*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1224LL) = list_delete(*(_QWORD **)(v5 + 1224), (_QWORD *)(a1 + 800));
v5 = *(_QWORD *)(a1 + 56);
}
if ( *(_DWORD *)(v5 + 1160) )
{
do
{
(*(void ( **)(long long))(*(_QWORD *)(v5 + 1232) + 120LL))(a1);
v5 = *(_QWORD *)(a1 + 56);
}
while ( v5 && (*(_WORD *)(v5 + 896) & 0x1008) != 0 );
*(_DWORD *)(v5 + 1160) = 0;
}
if ( *(_DWORD *)(a1 + 80)
&& (v9 = *(_DWORD *)(a1 + 64),
(*(unsigned int ( **)(_QWORD, long long, int *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
*(_QWORD *)(a1 + 56),
25LL,
&v9,
4LL,
1LL,
a1)) )
{
v7 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v7 + 144);
strncpy(a1 + 781, v7 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
LOBYTE(v3) = 1;
}
else
{
return 0;
}
}
return v3;
}
| net_stmt_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14D,ESI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R12,qword ptr [RDI + 0x340]
ADD RDI,0x90
XOR R15D,R15D
XOR ESI,ESI
CALL 0x0011e037
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0011e037
MOV RDI,R12
XOR ESI,ESI
CALL 0x0011e037
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x001201c2
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBX + 0x38]
MOV word ptr [RAX + 0x29b],0x30
MOV dword ptr [RAX + 0x297],0x30303030
MOV RAX,qword ptr [RBX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RAX + 0x2a0]
TEST RCX,RCX
JZ 0x001200d0
MOV dword ptr [RCX + 0x4],0x0
MOV RAX,qword ptr [RBX + 0x38]
LAB_001200d0:
TEST R14B,R14B
JZ 0x001200f7
MOV RDI,qword ptr [RAX + 0x4c8]
LEA RSI,[RBX + 0x320]
CALL 0x0011d0d4
MOV RCX,qword ptr [RBX + 0x38]
MOV qword ptr [RCX + 0x4c8],RAX
MOV RAX,qword ptr [RBX + 0x38]
LAB_001200f7:
CMP dword ptr [RAX + 0x488],0x0
JZ 0x0012012f
LAB_00120100:
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x00120125
MOVZX ECX,word ptr [RAX + 0x380]
TEST ECX,0x1008
JNZ 0x00120100
LAB_00120125:
MOV dword ptr [RAX + 0x488],0x0
LAB_0012012f:
CMP dword ptr [RBX + 0x50],0x0
JZ 0x001201bf
MOV EAX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x2c]
MOV dword ptr [RDX],EAX
MOV RDI,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ECX,0x4
MOV ESI,0x19
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x001201bf
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV R15B,0x1
JMP 0x001201c2
LAB_001201bf:
XOR R15D,R15D
LAB_001201c2:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001201e1
MOV EAX,R15D
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001201e1:
CALL 0x00113500
|
int8 net_stmt_close(long param_1,char param_2)
{
int iVar1;
int8 uVar2;
long lVar3;
int8 uVar4;
long in_FS_OFFSET;
int4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = *(int8 *)(param_1 + 0x340);
uVar4 = 0;
ma_free_root(param_1 + 0x90,0);
ma_free_root(param_1,0);
ma_free_root(uVar2,0);
if (*(long *)(param_1 + 0x38) != 0) {
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar3 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar3 + 0x29b) = 0x30;
*(int4 *)(lVar3 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar3 = *(long *)(param_1 + 0x38);
if (*(long *)(lVar3 + 0x2a0) != 0) {
*(int4 *)(*(long *)(lVar3 + 0x2a0) + 4) = 0;
lVar3 = *(long *)(param_1 + 0x38);
}
if (param_2 != '\0') {
uVar2 = list_delete(*(int8 *)(lVar3 + 0x4c8),param_1 + 800);
*(int8 *)(*(long *)(param_1 + 0x38) + 0x4c8) = uVar2;
lVar3 = *(long *)(param_1 + 0x38);
}
if (*(int *)(lVar3 + 0x488) != 0) {
do {
(**(code **)(*(long *)(lVar3 + 0x4d0) + 0x78))(param_1);
lVar3 = *(long *)(param_1 + 0x38);
if (lVar3 == 0) break;
} while ((*(ushort *)(lVar3 + 0x380) & 0x1008) != 0);
*(int4 *)(lVar3 + 0x488) = 0;
}
if (*(int *)(param_1 + 0x50) != 0) {
local_34 = *(int4 *)(param_1 + 0x40);
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(*(long *)(param_1 + 0x38),0x19,&local_34,4,1,param_1);
if (iVar1 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
goto LAB_001201c2;
}
}
uVar4 = 0;
}
LAB_001201c2:
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
24,483 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&) | monkey531[P]llama/common/./json.hpp | reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xa930b
movb $0x2, (%r14)
callq 0x3e186
movq %rax, %rdi
movq %rax, 0x8(%r14)
jmp 0xa9314
cmpl $0x2, %eax
jne 0xa9331
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xa9412
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23470
movq %rax, %rbx
movq %r14, %rdi
callq 0x43b2e
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x11b95(%rip), %rsi # 0xbaee8
leaq 0x10(%rsp), %rdi
callq 0xa93b4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x439e2
xorl %ebp, %ebp
leaq 0x52bca(%rip), %rsi # 0xfbf48
leaq -0x68cc7(%rip), %rdx # 0x406be
movq %rbx, %rdi
callq 0x23f10
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x241c8
testb %bpl, %bpl
jne 0xa93a4
jmp 0xa93ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x236b0
movq %r14, %rdi
callq 0x23f90
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; int
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_A930B
mov byte ptr [r14], 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJEEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>()
mov rdi, rax
mov [r14+8], rax
jmp short loc_A9314
loc_A930B:
cmp eax, 2
jnz short loc_A9331
mov rdi, [r14+8]
loc_A9314:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
mov rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_A9331:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rdi, [rsp+48h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_A93A4
jmp short loc_A93AC
mov r14, rax
loc_A93A4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A93AC:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
_BYTE v6[56]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>();
*(_QWORD *)(a1 + 8) = v3;
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
| emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001a930b
MOV byte ptr [R14],0x2
CALL 0x0013e186
MOV RDI,RAX
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001a9314
LAB_001a930b:
CMP EAX,0x2
JNZ 0x001a9331
MOV RDI,qword ptr [R14 + 0x8]
LAB_001a9314:
MOV RSI,RBX
CALL 0x001a9412
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001a9331:
PUSH 0x20
POP RDI
CALL 0x00123470
MOV RBX,RAX
MOV RDI,R14
CALL 0x00143b2e
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001a934c:
LEA RSI,[0x1baee8]
LEA RDI,[RSP + 0x10]
CALL 0x001a93b4
MOV BPL,0x1
LAB_001a9360:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x001439e2
XOR EBP,EBP
LEA RSI,[0x1fbf48]
LEA RDX,[0x1406be]
MOV RDI,RBX
CALL 0x00123f10
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&) */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
();
*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001a934c to 001a935c has its CatchHandler @ 001a93a1 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001a9360 to 001a938c has its CatchHandler @ 001a938d */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
| |
24,484 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&) | monkey531[P]llama/common/./json.hpp | reference emplace_back(Args&& ... args)
{
// emplace_back only works for null objects or arrays
if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
{
JSON_THROW(type_error::create(311, detail::concat("cannot use emplace_back() with ", type_name()), this));
}
// transform null object into an array
if (is_null())
{
m_data.m_type = value_t::array;
m_data.m_value = value_t::array;
assert_invariant();
}
// add element to array (perfect forwarding)
const auto old_capacity = m_data.m_value.array->capacity();
m_data.m_value.array->emplace_back(std::forward<Args>(args)...);
return set_parent(m_data.m_value.array->back(), old_capacity);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
jne 0xe5038
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x1a8c0
movq %rax, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
jmp 0xe5041
cmpl $0x2, %eax
jne 0xe505e
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xe517c
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
addq $-0x10, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1a450
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f468
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x11e71(%rip), %rsi # 0xf6ef3
leaq 0x10(%rsp), %rdi
callq 0xe50f4
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x137, %esi # imm = 0x137
movq %r14, %rcx
callq 0x5f210
xorl %ebp, %ebp
leaq 0x44eab(%rip), %rsi # 0x129f58
leaq -0x89a16(%rip), %rdx # 0x5b69e
movq %rbx, %rdi
callq 0x1af10
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe50da
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1a8e0
testb %bpl, %bpl
jne 0xe50e4
jmp 0xe50ec
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a690
movq %r14, %rdi
callq 0x1af90
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12emplace_backIJRSD_EEESF_DpOT_:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov rbx, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jnz short loc_E5038
mov byte ptr [r14], 2
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
jmp short loc_E5041
loc_E5038:
cmp eax, 2
jnz short loc_E505E
mov rdi, [r14+8]
loc_E5041:
mov rsi, rbx
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJRSD_EEESH_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)
mov rax, [r14+8]
mov rax, [rax+8]
add rax, 0FFFFFFFFFFFFFFF0h
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_E505E:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+48h+var_40]
mov [rdx], rax
lea rsi, aCannotUseEmpla; "cannot use emplace_back() with "
lea rdi, [rsp+48h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA32_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(char const(&)[32],char const* &&)
mov bpl, 1
lea rdx, [rsp+48h+var_38]
mov rdi, rbx; this
mov esi, 137h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E50DA
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E50DA:
test bpl, bpl
jnz short loc_E50E4
jmp short loc_E50EC
mov r14, rax
loc_E50E4:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_E50EC:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
long long a1,
long long a2)
{
long long v3; // rdi
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v6[2]; // [rsp+10h] [rbp-38h] BYREF
if ( *(_BYTE *)a1 )
{
if ( *(_BYTE *)a1 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[32],char const*>(
v6,
"cannot use emplace_back() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
311,
v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v3 = *(_QWORD *)(a1 + 8);
}
else
{
*(_BYTE *)a1 = 2;
v3 = operator new(0x18uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = v3;
}
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>&>(
v3,
a2);
return *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) - 16LL;
}
| emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JNZ 0x001e5038
MOV byte ptr [R14],0x2
MOV EDI,0x18
CALL 0x0011a8c0
MOV RDI,RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
JMP 0x001e5041
LAB_001e5038:
CMP EAX,0x2
JNZ 0x001e505e
MOV RDI,qword ptr [R14 + 0x8]
LAB_001e5041:
MOV RSI,RBX
CALL 0x001e517c
MOV RAX,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,-0x10
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001e505e:
MOV EDI,0x20
CALL 0x0011a450
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f468
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001e507b:
LEA RSI,[0x1f6ef3]
LEA RDI,[RSP + 0x10]
CALL 0x001e50f4
MOV BPL,0x1
LAB_001e508f:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x137
MOV RCX,R14
CALL 0x0015f210
XOR EBP,EBP
LEA RSI,[0x229f58]
LEA RDX,[0x15b69e]
MOV RDI,RBX
CALL 0x0011af10
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >,
void>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&) */
basic_json * __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this_00;
int8 uVar1;
char *local_40;
detail local_38 [32];
if (*this == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2;
this_00 = (vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*)operator_new(0x18);
*(int8 *)this_00 = 0;
*(int8 *)(this_00 + 8) = 0;
*(int8 *)(this_00 + 0x10) = 0;
*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8) = this_00;
}
else {
if (*this != (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_40 = (char *)type_name(this);
/* try { // try from 001e507b to 001e508b has its CatchHandler @ 001e50e1 */
detail::concat<std::__cxx11::string,char_const(&)[32],char_const*>
(local_38,"cannot use emplace_back() with ",&local_40);
/* try { // try from 001e508f to 001e50bb has its CatchHandler @ 001e50bc */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x137,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
this_00 = *(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 8);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&>
(this_00,param_1);
return (basic_json *)(*(long *)(*(long *)(this + 8) + 8) + -0x10);
}
| |
24,485 | alloc_dynamic | eloqsql/mysys/array.c | void *alloc_dynamic(DYNAMIC_ARRAY *array)
{
DBUG_ENTER("alloc_dynamic");
DBUG_ASSERT(array->size_of_element); /* Ensure init() is called */
if (array->elements == array->max_element)
{
char *new_ptr;
if (array->malloc_flags & MY_INIT_BUFFER_USED)
{
/*
In this scenario, the buffer is statically preallocated,
so we have to create an all-new malloc since we overflowed
*/
if (!(new_ptr= (char *) my_malloc(array->m_psi_key,
(array->max_element+
array->alloc_increment) *
array->size_of_element,
MYF(array->malloc_flags | MY_WME))))
DBUG_RETURN(0);
if (array->elements)
memcpy(new_ptr, array->buffer,
array->elements * array->size_of_element);
array->malloc_flags&= ~MY_INIT_BUFFER_USED;
}
else if (!(new_ptr=(char*)
my_realloc(array->m_psi_key, array->buffer,
(array->max_element+ array->alloc_increment) *
array->size_of_element,
MYF(MY_WME | MY_ALLOW_ZERO_PTR |
array->malloc_flags))))
DBUG_RETURN(0);
array->buffer= (uchar*) new_ptr;
array->max_element+=array->alloc_increment;
}
DBUG_RETURN(array->buffer+(array->elements++ * array->size_of_element));
} | O0 | c | alloc_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x84a6e
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x84b97
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
andq $0x100, %rax # imm = 0x100
cmpq $0x0, %rax
je 0x84b2a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdx
orq $0x10, %rdx
callq 0x7fad0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x84ae5
jmp 0x84ad8
movq $0x0, -0x8(%rbp)
jmp 0x84bc0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x84b12
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x370c0
movq -0x10(%rbp), %rax
movabsq $0xfffffeff, %rcx # imm = 0xFFFFFEFF
andq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
jmp 0x84b7b
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x10(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
orq $0x50, %rcx
callq 0x7fca0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x84b79
jmp 0x84b6f
movq $0x0, -0x8(%rbp)
jmp 0x84bc0
jmp 0x84b7b
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
jmp 0x84b99
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movq -0x10(%rbp), %rdx
imull 0x14(%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| alloc_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
jmp short $+2
loc_84A6E:
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
cmp eax, [rcx+0Ch]
jnz loc_84B97
mov rax, [rbp+var_10]
mov rax, [rax+20h]
and rax, 100h
cmp rax, 0
jz loc_84B2A
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+20h]
or rdx, 10h
call my_malloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_84AE5
jmp short $+2
loc_84AD8:
mov [rbp+var_8], 0
jmp loc_84BC0
loc_84AE5:
mov rax, [rbp+var_10]
cmp dword ptr [rax+8], 0
jz short loc_84B12
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+8]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
call _memcpy
loc_84B12:
mov rax, [rbp+var_10]
mov rcx, 0FFFFFEFFh
and rcx, [rax+20h]
mov [rax+20h], rcx
jmp short loc_84B7B
loc_84B2A:
mov rax, [rbp+var_10]
mov edi, [rax+18h]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rax, [rbp+var_10]
mov eax, [rax+0Ch]
mov rcx, [rbp+var_10]
add eax, [rcx+10h]
mov rcx, [rbp+var_10]
imul eax, [rcx+14h]
mov eax, eax
mov edx, eax
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
or rcx, 50h
call my_realloc
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_84B79
jmp short $+2
loc_84B6F:
mov [rbp+var_8], 0
jmp short loc_84BC0
loc_84B79:
jmp short $+2
loc_84B7B:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+10h]
mov rax, [rbp+var_10]
add ecx, [rax+0Ch]
mov [rax+0Ch], ecx
loc_84B97:
jmp short $+2
loc_84B99:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdx, [rbp+var_10]
mov ecx, [rdx+8]
mov esi, ecx
add esi, 1
mov [rdx+8], esi
mov rdx, [rbp+var_10]
imul ecx, [rdx+14h]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_84BC0:
mov rax, [rbp+var_8]
add rsp, 20h
pop rbp
retn
| long long alloc_dynamic(long long *a1)
{
long long v1; // rax
int v2; // ecx
long long v4; // [rsp+8h] [rbp-18h]
if ( *((_DWORD *)a1 + 2) != *((_DWORD *)a1 + 3) )
goto LABEL_11;
if ( (a1[4] & 0x100) == 0 )
{
v4 = my_realloc(
*((_DWORD *)a1 + 6),
*a1,
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
*((_BYTE *)a1 + 32) | 0x50u);
if ( !v4 )
return 0LL;
goto LABEL_10;
}
v4 = my_malloc(
*((_DWORD *)a1 + 6),
(unsigned int)(*((_DWORD *)a1 + 5) * (*((_DWORD *)a1 + 4) + *((_DWORD *)a1 + 3))),
*((_DWORD *)a1 + 8) | 0x10u);
if ( v4 )
{
if ( *((_DWORD *)a1 + 2) )
memcpy(v4, *a1, (unsigned int)(*((_DWORD *)a1 + 5) * *((_DWORD *)a1 + 2)));
a1[4] &= 0xFFFFFEFFuLL;
LABEL_10:
*a1 = v4;
*((_DWORD *)a1 + 3) += *((_DWORD *)a1 + 4);
LABEL_11:
v1 = *a1;
v2 = *((_DWORD *)a1 + 2);
*((_DWORD *)a1 + 2) = v2 + 1;
return (unsigned int)(*((_DWORD *)a1 + 5) * v2) + v1;
}
return 0LL;
}
| alloc_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
JMP 0x00184a6e
LAB_00184a6e:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0xc]
JNZ 0x00184b97
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
AND RAX,0x100
CMP RAX,0x0
JZ 0x00184b2a
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x20]
OR RDX,0x10
CALL 0x0017fad0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00184ae5
JMP 0x00184ad8
LAB_00184ad8:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00184bc0
LAB_00184ae5:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x8],0x0
JZ 0x00184b12
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
CALL 0x001370c0
LAB_00184b12:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,0xfffffeff
AND RCX,qword ptr [RAX + 0x20]
MOV qword ptr [RAX + 0x20],RCX
JMP 0x00184b7b
LAB_00184b2a:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDI,dword ptr [RAX + 0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0xc]
MOV RCX,qword ptr [RBP + -0x10]
ADD EAX,dword ptr [RCX + 0x10]
MOV RCX,qword ptr [RBP + -0x10]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
OR RCX,0x50
CALL 0x0017fca0
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00184b79
JMP 0x00184b6f
LAB_00184b6f:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00184bc0
LAB_00184b79:
JMP 0x00184b7b
LAB_00184b7b:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
ADD ECX,dword ptr [RAX + 0xc]
MOV dword ptr [RAX + 0xc],ECX
LAB_00184b97:
JMP 0x00184b99
LAB_00184b99:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RDX + 0x8]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x8],ESI
MOV RDX,qword ptr [RBP + -0x10]
IMUL ECX,dword ptr [RDX + 0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_00184bc0:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x20
POP RBP
RET
|
long alloc_dynamic(long *param_1)
{
long lVar1;
void *local_20;
if ((int)param_1[1] == *(int *)((long)param_1 + 0xc)) {
if ((param_1[4] & 0x100U) == 0) {
local_20 = (void *)my_realloc((int)param_1[3],*param_1,
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x50);
if (local_20 == (void *)0x0) {
return 0;
}
}
else {
local_20 = (void *)my_malloc((int)param_1[3],
(*(int *)((long)param_1 + 0xc) + (int)param_1[2]) *
*(int *)((long)param_1 + 0x14),param_1[4] | 0x10);
if (local_20 == (void *)0x0) {
return 0;
}
if ((int)param_1[1] != 0) {
memcpy(local_20,(void *)*param_1,
(ulong)(uint)((int)param_1[1] * *(int *)((long)param_1 + 0x14)));
}
param_1[4] = param_1[4] & 0xfffffeff;
}
*param_1 = (long)local_20;
*(int *)((long)param_1 + 0xc) = (int)param_1[2] + *(int *)((long)param_1 + 0xc);
}
lVar1 = param_1[1];
*(int *)(param_1 + 1) = (int)lVar1 + 1;
return *param_1 + (ulong)(uint)((int)lVar1 * *(int *)((long)param_1 + 0x14));
}
| |
24,486 | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*) | ng-log[P]ng-log/src/symbolize.cc | static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
ElfW(Half) sh_num,
const size_t sh_offset,
ElfW(Word) type,
ElfW(Shdr) * out) {
// Read at most 16 section headers at a time to save read calls.
ElfW(Shdr) buf[16];
for (size_t i = 0; i < sh_num;) {
const size_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
const size_t num_bytes_to_read =
(sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
sh_offset + i * sizeof(buf[0]));
if (len == -1) {
return false;
}
NGLOG_SAFE_ASSERT(static_cast<size_t>(len) % sizeof(buf[0]) == 0);
const size_t num_headers_in_buf = static_cast<size_t>(len) / sizeof(buf[0]);
NGLOG_SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
for (size_t j = 0; j < num_headers_in_buf; ++j) {
if (buf[j].sh_type == type) {
*out = buf[j];
return true;
}
}
i += num_headers_in_buf;
}
return false;
} | O2 | cpp | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %r8, 0x8(%rsp)
movl %ecx, %ebp
movq %rdx, %r8
movl %esi, %ebx
xorl %r12d, %r12d
movl $0x400, %eax # imm = 0x400
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
subq %r12, %rdx
jbe 0x1c785
shlq $0x6, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %r12, %rcx
shlq $0x6, %rcx
movq %r8, %r15
addq %r8, %rcx
movl %edi, %r13d
movq %rsi, %r14
callq 0x1bd2f
cmpq $-0x1, %rax
je 0x1c785
testb $0x3f, %al
jne 0x1c789
cmpq $0x43f, %rax # imm = 0x43F
ja 0x1c789
shrq $0x6, %rax
leaq 0x1(%rax), %rcx
leaq 0x14(%rsp), %rdx
decq %rcx
je 0x1c73a
leaq 0x40(%rdx), %rsi
cmpl %ebp, (%rdx)
movq %rsi, %rdx
jne 0x1c728
jmp 0x1c74d
addq %rax, %r12
movl $0x400, %eax # imm = 0x400
movq %r14, %rsi
movq %r15, %r8
movl %r13d, %edi
jmp 0x1c6da
movups -0x44(%rsi), %xmm0
movups -0x34(%rsi), %xmm1
movups -0x24(%rsi), %xmm2
movups -0x14(%rsi), %xmm3
movq 0x8(%rsp), %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movb $0x1, %al
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1c773
callq 0x7320
| _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov [rsp+448h+var_440], r8
mov ebp, ecx
mov r8, rdx; unsigned __int64
mov ebx, esi
xor r12d, r12d
mov eax, offset stru_400
lea rsi, [rsp+448h+var_438]; int
loc_1C6DA:
mov rdx, rbx
sub rdx, r12
jbe loc_1C785
shl rdx, 6
cmp rdx, rax
cmovnb rdx, rax; void *
mov rcx, r12
shl rcx, 6
mov r15, r8
add rcx, r8; unsigned __int64
mov r13d, edi
mov r14, rsi
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_1C785
test al, 3Fh
jnz short loc_1C789
cmp rax, 43Fh
ja short loc_1C789
shr rax, 6
lea rcx, [rax+1]
lea rdx, [rsp+448h+var_434]
loc_1C728:
dec rcx
jz short loc_1C73A
lea rsi, [rdx+40h]
cmp [rdx], ebp
mov rdx, rsi
jnz short loc_1C728
jmp short loc_1C74D
loc_1C73A:
add r12, rax
mov eax, 400h
mov rsi, r14
mov r8, r15
mov edi, r13d
jmp short loc_1C6DA
loc_1C74D:
movups xmm0, xmmword ptr [rsi-44h]
movups xmm1, xmmword ptr [rsi-34h]
movups xmm2, xmmword ptr [rsi-24h]
movups xmm3, xmmword ptr [rsi-14h]
mov rax, [rsp+448h+var_440]
movups xmmword ptr [rax+30h], xmm3
movups xmmword ptr [rax+20h], xmm2
movups xmmword ptr [rax+10h], xmm1
movups xmmword ptr [rax], xmm0
mov al, 1
loc_1C773:
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1C785:
xor eax, eax
jmp short loc_1C773
loc_1C789:
call _abort
| char nglog::tools::GetSectionHeaderByType(
unsigned long long a1,
unsigned int a2,
long long a3,
int a4,
_OWORD *a5)
{
unsigned long long v7; // rbx
unsigned long long v8; // r12
Elf64_Sym *v9; // rax
int *v10; // rsi
char *v11; // rdx
long long v12; // r15
int *v13; // r14
unsigned long long v14; // rax
unsigned long long v15; // rax
unsigned long long v16; // rcx
char *v17; // rdx
_DWORD *v18; // rsi
bool v19; // zf
__int128 v20; // xmm0
__int128 v21; // xmm1
__int128 v22; // xmm2
int v25; // [rsp+10h] [rbp-438h] BYREF
char v26; // [rsp+14h] [rbp-434h] BYREF
v7 = a2;
v8 = 0LL;
v9 = &stru_400;
v10 = &v25;
while ( v7 > v8 )
{
v11 = (char *)((v7 - v8) << 6);
if ( v11 >= (char *)v9 )
v11 = (char *)v9;
v12 = a3;
v13 = v10;
v14 = nglog::tools::ReadFromOffset(a1, (long long)v10, v11, a3 + (v8 << 6));
if ( v14 == -1LL )
break;
if ( (v14 & 0x3F) != 0 || v14 > 0x43F )
abort(a1);
v15 = v14 >> 6;
v16 = v15 + 1;
v17 = &v26;
while ( --v16 )
{
v18 = v17 + 64;
v19 = *(_DWORD *)v17 == a4;
v17 += 64;
if ( v19 )
{
v20 = *(_OWORD *)(v18 - 17);
v21 = *(_OWORD *)(v18 - 13);
v22 = *(_OWORD *)(v18 - 9);
a5[3] = *(_OWORD *)(v18 - 5);
a5[2] = v22;
a5[1] = v21;
*a5 = v20;
return 1;
}
}
v8 += v15;
v9 = &stru_400;
v10 = v13;
a3 = v12;
a1 = (unsigned int)a1;
}
return 0;
}
| GetSectionHeaderByType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV qword ptr [RSP + 0x8],R8
MOV EBP,ECX
MOV R8,RDX
MOV EBX,ESI
XOR R12D,R12D
MOV EAX,0x400
LEA RSI,[RSP + 0x10]
LAB_0011c6da:
MOV RDX,RBX
SUB RDX,R12
JBE 0x0011c785
SHL RDX,0x6
CMP RDX,RAX
CMOVNC RDX,RAX
MOV RCX,R12
SHL RCX,0x6
MOV R15,R8
ADD RCX,R8
MOV R13D,EDI
MOV R14,RSI
CALL 0x0011bd2f
CMP RAX,-0x1
JZ 0x0011c785
TEST AL,0x3f
JNZ 0x0011c789
CMP RAX,0x43f
JA 0x0011c789
SHR RAX,0x6
LEA RCX,[RAX + 0x1]
LEA RDX,[RSP + 0x14]
LAB_0011c728:
DEC RCX
JZ 0x0011c73a
LEA RSI,[RDX + 0x40]
CMP dword ptr [RDX],EBP
MOV RDX,RSI
JNZ 0x0011c728
JMP 0x0011c74d
LAB_0011c73a:
ADD R12,RAX
MOV EAX,0x400
MOV RSI,R14
MOV R8,R15
MOV EDI,R13D
JMP 0x0011c6da
LAB_0011c74d:
MOVUPS XMM0,xmmword ptr [RSI + -0x44]
MOVUPS XMM1,xmmword ptr [RSI + -0x34]
MOVUPS XMM2,xmmword ptr [RSI + -0x24]
MOVUPS XMM3,xmmword ptr [RSI + -0x14]
MOV RAX,qword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RAX + 0x30],XMM3
MOVUPS xmmword ptr [RAX + 0x20],XMM2
MOVUPS xmmword ptr [RAX + 0x10],XMM1
MOVUPS xmmword ptr [RAX],XMM0
MOV AL,0x1
LAB_0011c773:
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011c785:
XOR EAX,EAX
JMP 0x0011c773
LAB_0011c789:
CALL 0x00107320
|
/* nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int,
Elf64_Shdr*) */
int8
nglog::tools::GetSectionHeaderByType
(int param_1,ushort param_2,ulong param_3,uint param_4,Elf64_Shdr *param_5)
{
qword qVar1;
qword qVar2;
qword qVar3;
qword qVar4;
qword qVar5;
uint uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint *puVar10;
long lVar11;
ulong uVar12;
uint *puVar13;
ulong uVar14;
int6 in_register_00000032;
ulong uVar15;
int1 local_438 [4];
uint auStack_434 [257];
uVar14 = CONCAT62(in_register_00000032,param_2) & 0xffffffff;
uVar15 = 0;
while( true ) {
lVar11 = uVar14 - uVar15;
if (uVar14 < uVar15 || lVar11 == 0) {
return 0;
}
uVar12 = lVar11 * 0x40;
if (0x3ff < uVar12) {
uVar12 = 0x400;
}
uVar12 = ReadFromOffset(param_1,local_438,uVar12,uVar15 * 0x40 + param_3);
if (uVar12 == 0xffffffffffffffff) break;
if (((uVar12 & 0x3f) != 0) || (0x43f < uVar12)) {
/* WARNING: Subroutine does not return */
abort();
}
lVar11 = (uVar12 >> 6) + 1;
puVar10 = auStack_434;
while (puVar13 = puVar10, lVar11 = lVar11 + -1, lVar11 != 0) {
puVar10 = puVar13 + 0x10;
if (*puVar13 == param_4) {
uVar8 = puVar13[-1];
uVar9 = puVar13[0];
qVar1 = *(qword *)(puVar13 + 1);
qVar2 = *(qword *)(puVar13 + 3);
qVar3 = *(qword *)(puVar13 + 5);
qVar4 = *(qword *)(puVar13 + 7);
uVar6 = puVar13[9];
uVar7 = puVar13[10];
qVar5 = *(qword *)(puVar13 + 0xd);
param_5->sh_addralign = *(qword *)(puVar13 + 0xb);
param_5->sh_entsize = qVar5;
param_5->sh_size = qVar4;
param_5->sh_link = uVar6;
param_5->sh_info = uVar7;
param_5->sh_addr = qVar2;
param_5->sh_offset = qVar3;
param_5->sh_name = uVar8;
param_5->sh_type = uVar9;
param_5->sh_flags = qVar1;
return 1;
}
}
uVar15 = uVar15 + (uVar12 >> 6);
}
return 0;
}
| |
24,487 | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*) | ng-log[P]ng-log/src/symbolize.cc | static ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(const int fd,
ElfW(Half) sh_num,
const size_t sh_offset,
ElfW(Word) type,
ElfW(Shdr) * out) {
// Read at most 16 section headers at a time to save read calls.
ElfW(Shdr) buf[16];
for (size_t i = 0; i < sh_num;) {
const size_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
const size_t num_bytes_to_read =
(sizeof(buf) > num_bytes_left) ? num_bytes_left : sizeof(buf);
const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read,
sh_offset + i * sizeof(buf[0]));
if (len == -1) {
return false;
}
NGLOG_SAFE_ASSERT(static_cast<size_t>(len) % sizeof(buf[0]) == 0);
const size_t num_headers_in_buf = static_cast<size_t>(len) / sizeof(buf[0]);
NGLOG_SAFE_ASSERT(num_headers_in_buf <= sizeof(buf) / sizeof(buf[0]));
for (size_t j = 0; j < num_headers_in_buf; ++j) {
if (buf[j].sh_type == type) {
*out = buf[j];
return true;
}
}
i += num_headers_in_buf;
}
return false;
} | O3 | cpp | nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int, Elf64_Shdr*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdx, 0x8(%rsp)
testl %esi, %esi
je 0x20e2e
movq %r8, %rbx
movl %ecx, %ebp
movl %edi, %r15d
movl %esi, %r13d
xorl %r12d, %r12d
movl $0x400, %ecx # imm = 0x400
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
subq %r12, %rdx
shlq $0x6, %rdx
cmpq %rcx, %rdx
cmovaeq %rcx, %rdx
movq %r12, %rcx
shlq $0x6, %rcx
addq 0x8(%rsp), %rcx
movl %r15d, %edi
movq %rsi, %r14
callq 0x203c9
movq %rax, %rcx
cmpq $-0x1, %rax
sete %al
je 0x20e44
testb $0x3f, %cl
jne 0x20e4a
cmpq $0x43f, %rcx # imm = 0x43F
ja 0x20e4a
movq %rcx, %rdx
shrq $0x6, %rdx
leaq 0x14(%rsp), %rsi
movq %rdx, %rdi
testq %rcx, %rcx
je 0x20df5
cmpl %ebp, (%rsi)
je 0x20e09
addq $0x40, %rsi
decq %rdi
jne 0x20de8
addq %rdx, %r12
cmpq %r13, %r12
movl $0x400, %ecx # imm = 0x400
movq %r14, %rsi
jb 0x20d92
xorl %ecx, %ecx
jmp 0x20e30
movups -0x4(%rsi), %xmm0
movups 0xc(%rsi), %xmm1
movups 0x1c(%rsi), %xmm2
movups 0x2c(%rsi), %xmm3
movups %xmm3, 0x30(%rbx)
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, %al
movb $0x1, %cl
jmp 0x20e30
xorl %eax, %eax
andb %cl, %al
addq $0x418, %rsp # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ecx, %ecx
movb $0x1, %al
jmp 0x20e30
callq 0x72c0
| _ZN5nglog5toolsL22GetSectionHeaderByTypeEitmjP10Elf64_Shdr:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 418h
mov [rsp+448h+var_440], rdx
test esi, esi
jz loc_20E2E
mov rbx, r8
mov ebp, ecx
mov r15d, edi
mov r13d, esi
xor r12d, r12d
mov ecx, offset stru_400
lea rsi, [rsp+448h+var_438]; int
loc_20D92:
mov rdx, r13
sub rdx, r12
shl rdx, 6
cmp rdx, rcx
cmovnb rdx, rcx; void *
mov rcx, r12
shl rcx, 6
add rcx, [rsp+448h+var_440]; unsigned __int64
mov edi, r15d; this
mov r14, rsi
call _ZN5nglog5toolsL14ReadFromOffsetEiPvmm; nglog::tools::ReadFromOffset(int,void *,ulong,ulong)
mov rcx, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
setz al
jz short loc_20E44
test cl, 3Fh
jnz short loc_20E4A
cmp rcx, 43Fh
ja short loc_20E4A
mov rdx, rcx
shr rdx, 6
lea rsi, [rsp+448h+var_434]
mov rdi, rdx
test rcx, rcx
jz short loc_20DF5
loc_20DE8:
cmp [rsi], ebp
jz short loc_20E09
add rsi, 40h ; '@'
dec rdi
jnz short loc_20DE8
loc_20DF5:
add r12, rdx
cmp r12, r13
mov ecx, 400h
mov rsi, r14
jb short loc_20D92
xor ecx, ecx
jmp short loc_20E30
loc_20E09:
movups xmm0, xmmword ptr [rsi-4]
movups xmm1, xmmword ptr [rsi+0Ch]
movups xmm2, xmmword ptr [rsi+1Ch]
movups xmm3, xmmword ptr [rsi+2Ch]
movups xmmword ptr [rbx+30h], xmm3
movups xmmword ptr [rbx+20h], xmm2
movups xmmword ptr [rbx+10h], xmm1
movups xmmword ptr [rbx], xmm0
mov al, 1
mov cl, 1
jmp short loc_20E30
loc_20E2E:
xor eax, eax
loc_20E30:
and al, cl
add rsp, 418h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_20E44:
xor ecx, ecx
mov al, 1
jmp short loc_20E30
loc_20E4A:
call _abort
| char nglog::tools::GetSectionHeaderByType(
nglog::tools *this,
unsigned int a2,
long long a3,
int a4,
_OWORD *a5)
{
int v6; // ebp
unsigned int v7; // r15d
unsigned long long v8; // r13
unsigned long long v9; // r12
Elf64_Sym *v10; // rcx
int *v11; // rsi
char *v12; // rdx
int *v13; // r14
unsigned long long v14; // rcx
bool v15; // al
char *v16; // rsi
unsigned long long v17; // rdi
__int128 v18; // xmm0
__int128 v19; // xmm1
__int128 v20; // xmm2
int v23; // [rsp+10h] [rbp-438h] BYREF
char v24; // [rsp+14h] [rbp-434h] BYREF
if ( a2 )
{
v6 = a4;
v7 = (unsigned int)this;
v8 = a2;
v9 = 0LL;
v10 = &stru_400;
v11 = &v23;
while ( 1 )
{
v12 = (char *)((v8 - v9) << 6);
if ( v12 >= (char *)v10 )
v12 = (char *)v10;
v13 = v11;
v14 = nglog::tools::ReadFromOffset(v7, (long long)v11, v12, a3 + (v9 << 6));
v15 = v14 == -1LL;
if ( v14 == -1LL )
{
LOBYTE(a4) = 0;
v15 = 1;
return a4 & v15;
}
if ( (v14 & 0x3F) != 0 || v14 > 0x43F )
abort(v7);
v16 = &v24;
v17 = v14 >> 6;
if ( v14 )
break;
LABEL_11:
v9 += v14 >> 6;
v10 = &stru_400;
v11 = v13;
if ( v9 >= v8 )
{
LOBYTE(a4) = 0;
return a4 & v15;
}
}
while ( *(_DWORD *)v16 != v6 )
{
v16 += 64;
if ( !--v17 )
goto LABEL_11;
}
v18 = *(_OWORD *)(v16 - 4);
v19 = *(_OWORD *)(v16 + 12);
v20 = *(_OWORD *)(v16 + 28);
a5[3] = *(_OWORD *)(v16 + 44);
a5[2] = v20;
a5[1] = v19;
*a5 = v18;
v15 = 1;
LOBYTE(a4) = 1;
}
else
{
v15 = 0;
}
return a4 & v15;
}
| GetSectionHeaderByType:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x418
MOV qword ptr [RSP + 0x8],RDX
TEST ESI,ESI
JZ 0x00120e2e
MOV RBX,R8
MOV EBP,ECX
MOV R15D,EDI
MOV R13D,ESI
XOR R12D,R12D
MOV ECX,0x400
LEA RSI,[RSP + 0x10]
LAB_00120d92:
MOV RDX,R13
SUB RDX,R12
SHL RDX,0x6
CMP RDX,RCX
CMOVNC RDX,RCX
MOV RCX,R12
SHL RCX,0x6
ADD RCX,qword ptr [RSP + 0x8]
MOV EDI,R15D
MOV R14,RSI
CALL 0x001203c9
MOV RCX,RAX
CMP RAX,-0x1
SETZ AL
JZ 0x00120e44
TEST CL,0x3f
JNZ 0x00120e4a
CMP RCX,0x43f
JA 0x00120e4a
MOV RDX,RCX
SHR RDX,0x6
LEA RSI,[RSP + 0x14]
MOV RDI,RDX
TEST RCX,RCX
JZ 0x00120df5
LAB_00120de8:
CMP dword ptr [RSI],EBP
JZ 0x00120e09
ADD RSI,0x40
DEC RDI
JNZ 0x00120de8
LAB_00120df5:
ADD R12,RDX
CMP R12,R13
MOV ECX,0x400
MOV RSI,R14
JC 0x00120d92
XOR ECX,ECX
JMP 0x00120e30
LAB_00120e09:
MOVUPS XMM0,xmmword ptr [RSI + -0x4]
MOVUPS XMM1,xmmword ptr [RSI + 0xc]
MOVUPS XMM2,xmmword ptr [RSI + 0x1c]
MOVUPS XMM3,xmmword ptr [RSI + 0x2c]
MOVUPS xmmword ptr [RBX + 0x30],XMM3
MOVUPS xmmword ptr [RBX + 0x20],XMM2
MOVUPS xmmword ptr [RBX + 0x10],XMM1
MOVUPS xmmword ptr [RBX],XMM0
MOV AL,0x1
MOV CL,0x1
JMP 0x00120e30
LAB_00120e2e:
XOR EAX,EAX
LAB_00120e30:
AND AL,CL
ADD RSP,0x418
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00120e44:
XOR ECX,ECX
MOV AL,0x1
JMP 0x00120e30
LAB_00120e4a:
CALL 0x001072c0
|
/* nglog::tools::GetSectionHeaderByType(int, unsigned short, unsigned long, unsigned int,
Elf64_Shdr*) */
int8
nglog::tools::GetSectionHeaderByType
(int param_1,ushort param_2,ulong param_3,uint param_4,Elf64_Shdr *param_5)
{
qword qVar1;
qword qVar2;
qword qVar3;
qword qVar4;
qword qVar5;
ulong uVar6;
uint uVar7;
uint uVar8;
uint uVar9;
uint uVar10;
int7 uVar11;
ulong uVar12;
int6 in_register_00000032;
uint *puVar13;
ulong uVar14;
ulong uVar15;
ulong uVar16;
bool bVar17;
int1 local_438 [4];
uint auStack_434 [257];
if ((int)CONCAT62(in_register_00000032,param_2) == 0) {
bVar17 = false;
uVar11 = 0;
}
else {
uVar16 = CONCAT62(in_register_00000032,param_2) & 0xffffffff;
uVar15 = 0;
do {
uVar12 = (uVar16 - uVar15) * 0x40;
if (0x3ff < uVar12) {
uVar12 = 0x400;
}
uVar12 = ReadFromOffset(param_1,local_438,uVar12,uVar15 * 0x40 + param_3);
bVar17 = uVar12 == 0xffffffffffffffff;
uVar11 = (int7)(uVar12 >> 8);
if (bVar17) {
param_4 = 0;
bVar17 = true;
goto LAB_00120e30;
}
if (((uVar12 & 0x3f) != 0) || (0x43f < uVar12)) {
/* WARNING: Subroutine does not return */
abort();
}
puVar13 = auStack_434;
uVar14 = uVar12 >> 6;
uVar6 = uVar12;
while (uVar6 != 0) {
if (*puVar13 == param_4) {
uVar9 = puVar13[-1];
uVar10 = puVar13[0];
qVar1 = *(qword *)(puVar13 + 1);
qVar2 = *(qword *)(puVar13 + 3);
qVar3 = *(qword *)(puVar13 + 5);
qVar4 = *(qword *)(puVar13 + 7);
uVar7 = puVar13[9];
uVar8 = puVar13[10];
qVar5 = *(qword *)(puVar13 + 0xd);
param_5->sh_addralign = *(qword *)(puVar13 + 0xb);
param_5->sh_entsize = qVar5;
param_5->sh_size = qVar4;
param_5->sh_link = uVar7;
param_5->sh_info = uVar8;
param_5->sh_addr = qVar2;
param_5->sh_offset = qVar3;
param_5->sh_name = uVar9;
param_5->sh_type = uVar10;
param_5->sh_flags = qVar1;
bVar17 = true;
param_4 = 1;
goto LAB_00120e30;
}
puVar13 = puVar13 + 0x10;
uVar14 = uVar14 - 1;
uVar6 = uVar14;
}
uVar15 = uVar15 + (uVar12 >> 6);
} while (uVar15 < uVar16);
param_4 = 0;
}
LAB_00120e30:
return CONCAT71(uVar11,bVar17 & (byte)param_4);
}
| |
24,488 | mthd_stmt_get_result_metadata | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool mthd_stmt_get_result_metadata(MYSQL_STMT *stmt)
{
MYSQL_DATA *result;
MA_MEM_ROOT *fields_ma_alloc_root= &((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root;
if (!(result= stmt->mysql->methods->db_read_rows(stmt->mysql, (MYSQL_FIELD *)0,
7 + ma_extended_type_info_rows(stmt->mysql))))
return(1);
if (!(stmt->fields= unpack_fields(stmt->mysql, result, fields_ma_alloc_root,
stmt->field_count, 0)))
return(1);
return(0);
} | O0 | c | mthd_stmt_get_result_metadata:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x340(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2f420
movq -0x30(%rbp), %rdi
movl %eax, %edx
movq -0x28(%rbp), %rax
addl $0x7, %edx
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x2f4be
movb $0x1, -0x1(%rbp)
jmp 0x2f4f5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movl 0x60(%rax), %ecx
xorl %r8d, %r8d
callq 0x1e9c0
movq -0x10(%rbp), %rcx
movq %rax, 0x58(%rcx)
cmpq $0x0, %rax
jne 0x2f4f1
movb $0x1, -0x1(%rbp)
jmp 0x2f4f5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nop
| mthd_stmt_get_result_metadata:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+340h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+28h]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call ma_extended_type_info_rows
mov rdi, [rbp+var_30]
mov edx, eax
mov rax, [rbp+var_28]
add edx, 7
xor ecx, ecx
mov esi, ecx
call rax
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_2F4BE
mov [rbp+var_1], 1
jmp short loc_2F4F5
loc_2F4BE:
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_10]
mov ecx, [rax+60h]
xor r8d, r8d
call unpack_fields
mov rcx, [rbp+var_10]
mov [rcx+58h], rax
cmp rax, 0
jnz short loc_2F4F1
mov [rbp+var_1], 1
jmp short loc_2F4F5
loc_2F4F1:
mov [rbp+var_1], 0
loc_2F4F5:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| bool mthd_stmt_get_result_metadata(long long a1)
{
BOOL v1; // eax
long long v2; // rax
long long v4; // [rsp+0h] [rbp-30h]
long long ( *v5)(long long, _QWORD, _QWORD); // [rsp+8h] [rbp-28h]
long long v6; // [rsp+10h] [rbp-20h]
_QWORD *v7; // [rsp+18h] [rbp-18h]
v6 = *(_QWORD *)(a1 + 832);
v5 = *(long long ( **)(long long, _QWORD, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 40LL);
v4 = *(_QWORD *)(a1 + 56);
v1 = ma_extended_type_info_rows(v4);
v7 = (_QWORD *)v5(v4, 0LL, (unsigned int)(v1 + 7));
if ( !v7 )
return 1;
v2 = unpack_fields(*(_QWORD *)(a1 + 56), v7, v6, *(_DWORD *)(a1 + 96), 0);
*(_QWORD *)(a1 + 88) = v2;
return v2 == 0;
}
| mthd_stmt_get_result_metadata:
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 + 0x340]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x0012f420
MOV RDI,qword ptr [RBP + -0x30]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD EDX,0x7
XOR ECX,ECX
MOV ESI,ECX
CALL RAX
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x0012f4be
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012f4f5
LAB_0012f4be:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x60]
XOR R8D,R8D
CALL 0x0011e9c0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x58],RAX
CMP RAX,0x0
JNZ 0x0012f4f1
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012f4f5
LAB_0012f4f1:
MOV byte ptr [RBP + -0x1],0x0
LAB_0012f4f5:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 mthd_stmt_get_result_metadata(long param_1)
{
int8 uVar1;
code *pcVar2;
int8 uVar3;
int iVar4;
long lVar5;
int1 local_9;
uVar1 = *(int8 *)(param_1 + 0x340);
pcVar2 = *(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x28);
uVar3 = *(int8 *)(param_1 + 0x38);
iVar4 = ma_extended_type_info_rows(*(int8 *)(param_1 + 0x38));
lVar5 = (*pcVar2)(uVar3,0,iVar4 + 7);
if (lVar5 == 0) {
local_9 = 1;
}
else {
lVar5 = unpack_fields(*(int8 *)(param_1 + 0x38),lVar5,uVar1,
*(int4 *)(param_1 + 0x60),0);
*(long *)(param_1 + 0x58) = lVar5;
if (lVar5 == 0) {
local_9 = 1;
}
else {
local_9 = 0;
}
}
return local_9;
}
| |
24,489 | mthd_stmt_get_result_metadata | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | my_bool mthd_stmt_get_result_metadata(MYSQL_STMT *stmt)
{
MYSQL_DATA *result;
MA_MEM_ROOT *fields_ma_alloc_root= &((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root;
if (!(result= stmt->mysql->methods->db_read_rows(stmt->mysql, (MYSQL_FIELD *)0,
7 + ma_extended_type_info_rows(stmt->mysql))))
return(1);
if (!(stmt->fields= unpack_fields(stmt->mysql, result, fields_ma_alloc_root,
stmt->field_count, 0)))
return(1);
return(0);
} | O3 | c | mthd_stmt_get_result_metadata:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x340(%rdi), %r14
movq 0x38(%rdi), %rdi
movq 0x4d0(%rdi), %rax
movq 0x4f0(%rdi), %rcx
xorl %edx, %edx
btl $0x3, 0x70(%rcx)
adcl $0x7, %edx
xorl %esi, %esi
callq *0x28(%rax)
testq %rax, %rax
je 0x23ab5
movq 0x38(%rbx), %rdi
movl 0x60(%rbx), %ecx
movq %rax, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x1a560
movq %rax, 0x58(%rbx)
testq %rax, %rax
sete %al
jmp 0x23ab7
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
| mthd_stmt_get_result_metadata:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov r14, [rdi+340h]
mov rdi, [rdi+38h]
mov rax, [rdi+4D0h]
mov rcx, [rdi+4F0h]
xor edx, edx
bt dword ptr [rcx+70h], 3
adc edx, 7
xor esi, esi
call qword ptr [rax+28h]
test rax, rax
jz short loc_23AB5
mov rdi, [rbx+38h]
mov ecx, [rbx+60h]
mov rsi, rax
mov rdx, r14
xor r8d, r8d
call unpack_fields
mov [rbx+58h], rax
test rax, rax
setz al
jmp short loc_23AB7
loc_23AB5:
mov al, 1
loc_23AB7:
pop rbx
pop r14
pop rbp
retn
| bool mthd_stmt_get_result_metadata(long long a1)
{
long long v1; // r14
_QWORD *v2; // rax
long long v3; // rax
v1 = *(_QWORD *)(a1 + 832);
v2 = (_QWORD *)(*(long long ( **)(_QWORD, _QWORD, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 40LL))(
*(_QWORD *)(a1 + 56),
0LL,
(unsigned int)_bittest(
(const signed __int32 *)(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1264LL) + 112LL),
3u)
+ 7);
if ( !v2 )
return 1;
v3 = unpack_fields(*(_QWORD *)(a1 + 56), v2, v1, *(_DWORD *)(a1 + 96), 0);
*(_QWORD *)(a1 + 88) = v3;
return v3 == 0;
}
| mthd_stmt_get_result_metadata:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x340]
MOV RDI,qword ptr [RDI + 0x38]
MOV RAX,qword ptr [RDI + 0x4d0]
MOV RCX,qword ptr [RDI + 0x4f0]
XOR EDX,EDX
BT dword ptr [RCX + 0x70],0x3
ADC EDX,0x7
XOR ESI,ESI
CALL qword ptr [RAX + 0x28]
TEST RAX,RAX
JZ 0x00123ab5
MOV RDI,qword ptr [RBX + 0x38]
MOV ECX,dword ptr [RBX + 0x60]
MOV RSI,RAX
MOV RDX,R14
XOR R8D,R8D
CALL 0x0011a560
MOV qword ptr [RBX + 0x58],RAX
TEST RAX,RAX
SETZ AL
JMP 0x00123ab7
LAB_00123ab5:
MOV AL,0x1
LAB_00123ab7:
POP RBX
POP R14
POP RBP
RET
|
bool mthd_stmt_get_result_metadata(long param_1)
{
int8 uVar1;
long lVar2;
bool bVar3;
uVar1 = *(int8 *)(param_1 + 0x340);
lVar2 = *(long *)(param_1 + 0x38);
lVar2 = (**(code **)(*(long *)(lVar2 + 0x4d0) + 0x28))
(lVar2,0,((*(uint *)(*(long *)(lVar2 + 0x4f0) + 0x70) >> 3 & 1) != 0) + '\a');
if (lVar2 == 0) {
bVar3 = true;
}
else {
lVar2 = unpack_fields(*(int8 *)(param_1 + 0x38),lVar2,uVar1,
*(int4 *)(param_1 + 0x60),0);
*(long *)(param_1 + 0x58) = lVar2;
bVar3 = lVar2 == 0;
}
return bVar3;
}
| |
24,490 | fn_ext2 | eloqsql/mysys/mf_fn_ext.c | char *fn_ext2(const char *name)
{
register const char *pos, *gpos;
DBUG_ENTER("fn_ext");
DBUG_PRINT("mfunkt",("name: '%s'",name));
#if defined(FN_DEVCHAR) || defined(BASKSLASH_MBTAIL)
{
char buff[FN_REFLEN];
size_t res_length;
gpos= name+ dirname_part(buff,(char*) name, &res_length);
}
#else
if (!(gpos= strrchr(name, FN_LIBCHAR)))
gpos= name;
#endif
// locate the last occurrence of FN_EXTCHAR
pos= strrchr(gpos, FN_EXTCHAR);
DBUG_RETURN((char*) (pos ? pos : strend(gpos)));
} | O3 | c | fn_ext2:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x2f, %esi
callq 0x243c0
movq %rax, %rbx
testq %rax, %rax
cmoveq %r14, %rbx
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x243c0
testq %rax, %rax
je 0x348a6
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6318c
nop
| fn_ext2:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rdi
mov esi, 2Fh ; '/'
call _strrchr
mov rbx, rax
test rax, rax
cmovz rbx, r14
mov rdi, rbx
mov esi, 2Eh ; '.'
call _strrchr
test rax, rax
jz short loc_348A6
pop rbx
pop r14
pop rbp
retn
loc_348A6:
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp strend
| long long fn_ext2(long long a1)
{
long long v1; // rbx
long long result; // rax
v1 = strrchr(a1, 47LL);
if ( !v1 )
v1 = a1;
result = strrchr(v1, 46LL);
if ( !result )
return strend(v1);
return result;
}
| fn_ext2:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RDI
MOV ESI,0x2f
CALL 0x001243c0
MOV RBX,RAX
TEST RAX,RAX
CMOVZ RBX,R14
MOV RDI,RBX
MOV ESI,0x2e
CALL 0x001243c0
TEST RAX,RAX
JZ 0x001348a6
POP RBX
POP R14
POP RBP
RET
LAB_001348a6:
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x0016318c
|
void fn_ext2(char *param_1)
{
char *__s;
char *pcVar1;
__s = strrchr(param_1,0x2f);
if (__s == (char *)0x0) {
__s = param_1;
}
pcVar1 = strrchr(__s,0x2e);
if (pcVar1 != (char *)0x0) {
return;
}
strend(__s);
return;
}
| |
24,491 | ImageColorInvert | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | void ImageColorInvert(Image *image)
{
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
Color *pixels = LoadImageColors(*image);
for (int i = 0; i < image->width*image->height; i++)
{
pixels[i].r = 255 - pixels[i].r;
pixels[i].g = 255 - pixels[i].g;
pixels[i].b = 255 - pixels[i].b;
}
int format = image->format;
RL_FREE(image->data);
image->data = pixels;
image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
} | O2 | c | ImageColorInvert:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpq $0x0, (%rdi)
je 0x8429f
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x8429f
cmpl $0x0, 0xc(%rbx)
je 0x8429f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
xorl %r15d, %r15d
callq 0x7e527
movq %rax, %r14
movslq 0x8(%rbx), %rax
movslq 0xc(%rbx), %rcx
imulq %rax, %rcx
cmpq %rcx, %r15
jge 0x842aa
notb (%r14,%r15,4)
notb 0x1(%r14,%r15,4)
notb 0x2(%r14,%r15,4)
incq %r15
jmp 0x8427b
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x14(%rbx), %ebp
movq (%rbx), %rdi
callq 0x9640
movq %r14, (%rbx)
movl $0x7, 0x14(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x7fcdb
| ImageColorInvert:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
cmp qword ptr [rdi], 0
jz short loc_8429F
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz short loc_8429F
cmp dword ptr [rbx+0Ch], 0
jz short loc_8429F
mov rax, [rbx+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+38h+var_38], xmm0
xor r15d, r15d
call LoadImageColors
mov r14, rax
loc_8427B:
movsxd rax, dword ptr [rbx+8]
movsxd rcx, dword ptr [rbx+0Ch]
imul rcx, rax
cmp r15, rcx
jge short loc_842AA
not byte ptr [r14+r15*4]
not byte ptr [r14+r15*4+1]
not byte ptr [r14+r15*4+2]
inc r15
jmp short loc_8427B
loc_8429F:
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_842AA:
mov ebp, [rbx+14h]
mov rdi, [rbx]
call _free
mov [rbx], r14
mov dword ptr [rbx+14h], 7
mov rdi, rbx
mov esi, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
jmp ImageFormat
| void ImageColorInvert(
__m128i *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__m128 a8)
{
long long v8; // r15
long long ImageColors; // r14
int v10; // ebp
double v11; // xmm0_8
long long v12; // rdx
long long v13; // rcx
long long v14; // r8
int v15; // r9d
if ( a1->m128i_i64[0] && a1->m128i_i32[2] && a1->m128i_i32[3] )
{
v8 = 0LL;
ImageColors = LoadImageColors(
*a1,
(long long)a1,
a2,
a3,
a4,
a5,
a6,
a1->m128i_i64[0],
a1->m128i_i64[1],
a1[1].m128i_i64[0]);
while ( v8 < a1->m128i_i32[2] * (long long)a1->m128i_i32[3] )
{
*(_BYTE *)(ImageColors + 4 * v8) = ~*(_BYTE *)(ImageColors + 4 * v8);
*(_BYTE *)(ImageColors + 4 * v8 + 1) = ~*(_BYTE *)(ImageColors + 4 * v8 + 1);
*(_BYTE *)(ImageColors + 4 * v8 + 2) = ~*(_BYTE *)(ImageColors + 4 * v8 + 2);
++v8;
}
v10 = a1[1].m128i_i32[1];
v11 = free(a1->m128i_i64[0]);
a1->m128i_i64[0] = ImageColors;
a1[1].m128i_i32[1] = 7;
ImageFormat(a1->m128i_i64, v10, *(float *)&v11, a8, v12, v13, v14, v15);
}
}
| ImageColorInvert:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
CMP qword ptr [RDI],0x0
JZ 0x0018429f
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x0018429f
CMP dword ptr [RBX + 0xc],0x0
JZ 0x0018429f
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
XOR R15D,R15D
CALL 0x0017e527
MOV R14,RAX
LAB_0018427b:
MOVSXD RAX,dword ptr [RBX + 0x8]
MOVSXD RCX,dword ptr [RBX + 0xc]
IMUL RCX,RAX
CMP R15,RCX
JGE 0x001842aa
NOT byte ptr [R14 + R15*0x4]
NOT byte ptr [R14 + R15*0x4 + 0x1]
NOT byte ptr [R14 + R15*0x4 + 0x2]
INC R15
JMP 0x0018427b
LAB_0018429f:
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001842aa:
MOV EBP,dword ptr [RBX + 0x14]
MOV RDI,qword ptr [RBX]
CALL 0x00109640
MOV qword ptr [RBX],R14
MOV dword ptr [RBX + 0x14],0x7
MOV RDI,RBX
MOV ESI,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
JMP 0x0017fcdb
|
void ImageColorInvert(long *param_1)
{
byte *pbVar1;
int4 uVar2;
long lVar3;
long lVar4;
if (((*param_1 != 0) && ((int)param_1[1] != 0)) && (*(int *)((long)param_1 + 0xc) != 0)) {
lVar3 = LoadImageColors();
for (lVar4 = 0; lVar4 < (long)*(int *)((long)param_1 + 0xc) * (long)(int)param_1[1];
lVar4 = lVar4 + 1) {
pbVar1 = (byte *)(lVar3 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
pbVar1 = (byte *)(lVar3 + 1 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
pbVar1 = (byte *)(lVar3 + 2 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
}
uVar2 = *(int4 *)((long)param_1 + 0x14);
free((void *)*param_1);
*param_1 = lVar3;
*(int4 *)((long)param_1 + 0x14) = 7;
ImageFormat(param_1,uVar2);
return;
}
return;
}
| |
24,492 | ImageColorInvert | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rtextures.c | void ImageColorInvert(Image *image)
{
// Security check to avoid program crash
if ((image->data == NULL) || (image->width == 0) || (image->height == 0)) return;
Color *pixels = LoadImageColors(*image);
for (int i = 0; i < image->width*image->height; i++)
{
pixels[i].r = 255 - pixels[i].r;
pixels[i].g = 255 - pixels[i].g;
pixels[i].b = 255 - pixels[i].b;
}
int format = image->format;
RL_FREE(image->data);
image->data = pixels;
image->format = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8;
ImageFormat(image, format);
} | O3 | c | ImageColorInvert:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq $0x0, (%rdi)
je 0x98bce
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x98bce
cmpl $0x0, 0xc(%rbx)
je 0x98bce
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x92846
movq %rax, %r14
movl 0xc(%rbx), %eax
imull 0x8(%rbx), %eax
testl %eax, %eax
jle 0x98ba7
xorl %eax, %eax
notb (%r14,%rax,4)
notb 0x1(%r14,%rax,4)
notb 0x2(%r14,%rax,4)
incq %rax
movslq 0x8(%rbx), %rcx
movslq 0xc(%rbx), %rdx
imulq %rcx, %rdx
cmpq %rdx, %rax
jl 0x98b85
movl 0x14(%rbx), %ebp
movq (%rbx), %rdi
callq 0xa650
movq %r14, (%rbx)
movl $0x7, 0x14(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x94249
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| ImageColorInvert:
push rbp
push r14
push rbx
sub rsp, 20h
cmp qword ptr [rdi], 0
jz short loc_98BCE
mov rbx, rdi
cmp dword ptr [rdi+8], 0
jz short loc_98BCE
cmp dword ptr [rbx+0Ch], 0
jz short loc_98BCE
mov rax, [rbx+10h]
mov [rsp+38h+var_28], rax
movups xmm0, xmmword ptr [rbx]
movups [rsp+38h+var_38], xmm0
call LoadImageColors
mov r14, rax
mov eax, [rbx+0Ch]
imul eax, [rbx+8]
test eax, eax
jle short loc_98BA7
xor eax, eax
loc_98B85:
not byte ptr [r14+rax*4]
not byte ptr [r14+rax*4+1]
not byte ptr [r14+rax*4+2]
inc rax
movsxd rcx, dword ptr [rbx+8]
movsxd rdx, dword ptr [rbx+0Ch]
imul rdx, rcx
cmp rax, rdx
jl short loc_98B85
loc_98BA7:
mov ebp, [rbx+14h]
mov rdi, [rbx]
call _free
mov [rbx], r14
mov dword ptr [rbx+14h], 7
mov rdi, rbx
mov esi, ebp
add rsp, 20h
pop rbx
pop r14
pop rbp
jmp ImageFormat
loc_98BCE:
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
| void ImageColorInvert(__m128i *a1, long long a2, long long a3, long long a4, long long a5, long long a6)
{
__m128i v6; // xmm0
long long ImageColors; // r14
long long v8; // rax
int v9; // ebp
long long v10; // rdx
long long v11; // rcx
int v12; // r8d
int v13; // r9d
if ( a1->m128i_i64[0] && a1->m128i_i32[2] && a1->m128i_i32[3] )
{
v6 = *a1;
ImageColors = LoadImageColors(
*a1,
(long long)a1,
a2,
a3,
a4,
a5,
a6,
a1->m128i_i64[0],
a1->m128i_i64[1],
a1[1].m128i_i64[0]);
if ( a1->m128i_i32[2] * a1->m128i_i32[3] > 0 )
{
v8 = 0LL;
do
{
*(_BYTE *)(ImageColors + 4 * v8) = ~*(_BYTE *)(ImageColors + 4 * v8);
*(_BYTE *)(ImageColors + 4 * v8 + 1) = ~*(_BYTE *)(ImageColors + 4 * v8 + 1);
*(_BYTE *)(ImageColors + 4 * v8 + 2) = ~*(_BYTE *)(ImageColors + 4 * v8 + 2);
++v8;
}
while ( v8 < a1->m128i_i32[2] * (long long)a1->m128i_i32[3] );
}
v9 = a1[1].m128i_i32[1];
free(a1->m128i_i64[0]);
a1->m128i_i64[0] = ImageColors;
a1[1].m128i_i32[1] = 7;
ImageFormat(a1->m128i_i64, v9, *(float *)v6.m128i_i32, v10, v11, v12, v13);
}
}
| ImageColorInvert:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
CMP qword ptr [RDI],0x0
JZ 0x00198bce
MOV RBX,RDI
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00198bce
CMP dword ptr [RBX + 0xc],0x0
JZ 0x00198bce
MOV RAX,qword ptr [RBX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RBX]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00192846
MOV R14,RAX
MOV EAX,dword ptr [RBX + 0xc]
IMUL EAX,dword ptr [RBX + 0x8]
TEST EAX,EAX
JLE 0x00198ba7
XOR EAX,EAX
LAB_00198b85:
NOT byte ptr [R14 + RAX*0x4]
NOT byte ptr [R14 + RAX*0x4 + 0x1]
NOT byte ptr [R14 + RAX*0x4 + 0x2]
INC RAX
MOVSXD RCX,dword ptr [RBX + 0x8]
MOVSXD RDX,dword ptr [RBX + 0xc]
IMUL RDX,RCX
CMP RAX,RDX
JL 0x00198b85
LAB_00198ba7:
MOV EBP,dword ptr [RBX + 0x14]
MOV RDI,qword ptr [RBX]
CALL 0x0010a650
MOV qword ptr [RBX],R14
MOV dword ptr [RBX + 0x14],0x7
MOV RDI,RBX
MOV ESI,EBP
ADD RSP,0x20
POP RBX
POP R14
POP RBP
JMP 0x00194249
LAB_00198bce:
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
|
void ImageColorInvert(long *param_1)
{
byte *pbVar1;
int4 uVar2;
long lVar3;
long lVar4;
if (((*param_1 != 0) && ((int)param_1[1] != 0)) && (*(int *)((long)param_1 + 0xc) != 0)) {
lVar3 = LoadImageColors();
if (0 < *(int *)((long)param_1 + 0xc) * (int)param_1[1]) {
lVar4 = 0;
do {
pbVar1 = (byte *)(lVar3 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
pbVar1 = (byte *)(lVar3 + 1 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
pbVar1 = (byte *)(lVar3 + 2 + lVar4 * 4);
*pbVar1 = ~*pbVar1;
lVar4 = lVar4 + 1;
} while (lVar4 < (long)*(int *)((long)param_1 + 0xc) * (long)(int)param_1[1]);
}
uVar2 = *(int4 *)((long)param_1 + 0x14);
free((void *)*param_1);
*param_1 = lVar3;
*(int4 *)((long)param_1 + 0x14) = 7;
ImageFormat(param_1,uVar2);
return;
}
return;
}
| |
24,493 | ma_ft_update | eloqsql/storage/maria/ma_ft_update.c | int _ma_ft_update(MARIA_HA *info, uint keynr, uchar *keybuf,
const uchar *oldrec, const uchar *newrec, my_off_t pos)
{
int error= -1;
FT_WORD *oldlist,*newlist, *old_word, *new_word;
CHARSET_INFO *cs=info->s->keyinfo[keynr].seg->charset;
int cmp, cmp2;
DBUG_ENTER("_ma_ft_update");
if (!(old_word=oldlist=_ma_ft_parserecord(info, keynr, oldrec,
&info->ft_memroot)) ||
!(new_word=newlist=_ma_ft_parserecord(info, keynr, newrec,
&info->ft_memroot)))
goto err;
error=0;
while(old_word->pos && new_word->pos)
{
cmp= ha_compare_text(cs, (uchar*) old_word->pos,old_word->len,
(uchar*) new_word->pos,new_word->len,0);
cmp2= cmp ? 0 : (fabs(old_word->weight - new_word->weight) > 1.e-5);
if (cmp < 0 || cmp2)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, old_word, pos);
if (_ma_ck_delete(info, &key))
{
error= -1;
goto err;
}
}
if (cmp > 0 || cmp2)
{
MARIA_KEY key;
_ma_ft_make_key(info, &key, keynr, keybuf, new_word,pos);
if ((error= _ma_ck_write(info, &key)))
goto err;
}
if (cmp<=0) old_word++;
if (cmp>=0) new_word++;
}
if (old_word->pos)
error= _ma_ft_erase(info,keynr,keybuf,old_word,pos);
else if (new_word->pos)
error= _ma_ft_store(info,keynr,keybuf,new_word,pos);
err:
free_root(&info->ft_memroot, MYF(MY_MARK_BLOCKS_FREE));
DBUG_RETURN(error);
} | O0 | c | ma_ft_update:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x570(%rax), %rax
movl -0xc(%rbp), %ecx
imulq $0x118, %rcx, %rcx # imm = 0x118
addq %rcx, %rax
movq 0xc0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x328, %rcx # imm = 0x328
callq 0x73da0
movq %rax, -0x40(%rbp)
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x74004
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
addq $0x328, %rcx # imm = 0x328
callq 0x73da0
movq %rax, -0x48(%rbp)
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0x74009
jmp 0x741d2
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0xa9(%rbp)
je 0x74033
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x74042
jmp 0x74182
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rsi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
movq -0x58(%rbp), %rax
movq (%rax), %rcx
movq -0x58(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %r8d
xorl %r9d, %r9d
callq 0xf6c40
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
je 0x74082
xorl %eax, %eax
movl %eax, -0xb0(%rbp)
jmp 0x740b9
movq -0x50(%rbp), %rax
movsd 0x10(%rax), %xmm0
movq -0x58(%rbp), %rax
subsd 0x10(%rax), %xmm0
movaps 0xe5fa5(%rip), %xmm1 # 0x15a040
pand %xmm1, %xmm0
movsd 0xe5fc9(%rip), %xmm1 # 0x15a070
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x64(%rbp)
jl 0x740ce
cmpl $0x0, -0x68(%rbp)
je 0x7410f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x50(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0x88(%rbp), %rsi
callq 0x74200
movq -0x8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x69000
cmpb $0x0, %al
je 0x7410d
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
jmp 0x741d2
jmp 0x7410f
cmpl $0x0, -0x64(%rbp)
jg 0x7411b
cmpl $0x0, -0x68(%rbp)
je 0x74159
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x58(%rbp), %r8
movq -0x30(%rbp), %r9
leaq -0xa8(%rbp), %rsi
callq 0x74200
movq -0x8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x63500
movsbl %al, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x74157
jmp 0x741d2
jmp 0x74159
cmpl $0x0, -0x64(%rbp)
jg 0x7416b
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x64(%rbp)
jl 0x7417d
movq -0x58(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x58(%rbp)
jmp 0x74010
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
je 0x741a9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x74370
movl %eax, -0x34(%rbp)
jmp 0x741d0
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
je 0x741ce
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x74400
movl %eax, -0x34(%rbp)
jmp 0x741d0
jmp 0x741d2
movq -0x8(%rbp), %rdi
addq $0x328, %rdi # imm = 0x328
movl $0x2, %esi
callq 0xf0980
movl -0x34(%rbp), %eax
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nop
| _ma_ft_update:
push rbp
mov rbp, rsp
sub rsp, 0C0h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov [rbp+var_34], 0FFFFFFFFh
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+570h]
mov ecx, [rbp+var_C]
imul rcx, 118h
add rax, rcx
mov rax, [rax+0C0h]
mov rax, [rax]
mov [rbp+var_60], rax
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_8]
add rcx, 328h
call _ma_ft_parserecord
mov [rbp+var_40], rax
mov [rbp+var_50], rax
cmp rax, 0
jz short loc_74004
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_8]
add rcx, 328h
call _ma_ft_parserecord
mov [rbp+var_48], rax
mov [rbp+var_58], rax
cmp rax, 0
jnz short loc_74009
loc_74004:
jmp loc_741D2
loc_74009:
mov [rbp+var_34], 0
loc_74010:
mov rcx, [rbp+var_50]
xor eax, eax
cmp qword ptr [rcx], 0
mov [rbp+var_A9], al
jz short loc_74033
mov rax, [rbp+var_58]
cmp qword ptr [rax], 0
setnz al
mov [rbp+var_A9], al
loc_74033:
mov al, [rbp+var_A9]
test al, 1
jnz short loc_74042
jmp loc_74182
loc_74042:
mov rdi, [rbp+var_60]
mov rax, [rbp+var_50]
mov rsi, [rax]
mov rax, [rbp+var_50]
mov eax, [rax+8]
mov edx, eax
mov rax, [rbp+var_58]
mov rcx, [rax]
mov rax, [rbp+var_58]
mov eax, [rax+8]
mov r8d, eax
xor r9d, r9d
call ha_compare_text
mov [rbp+var_64], eax
cmp [rbp+var_64], 0
jz short loc_74082
xor eax, eax
mov [rbp+var_B0], eax
jmp short loc_740B9
loc_74082:
mov rax, [rbp+var_50]
movsd xmm0, qword ptr [rax+10h]
mov rax, [rbp+var_58]
subsd xmm0, qword ptr [rax+10h]
movaps xmm1, cs:xmmword_15A040
pand xmm0, xmm1
movsd xmm1, cs:qword_15A070
ucomisd xmm0, xmm1
setnbe al
and al, 1
movzx eax, al
mov [rbp+var_B0], eax
loc_740B9:
mov eax, [rbp+var_B0]
mov [rbp+var_68], eax
cmp [rbp+var_64], 0
jl short loc_740CE
cmp [rbp+var_68], 0
jz short loc_7410F
loc_740CE:
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_50]
mov r9, [rbp+var_30]
lea rsi, [rbp+var_88]
call _ma_ft_make_key
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_88]
call _ma_ck_delete
cmp al, 0
jz short loc_7410D
mov [rbp+var_34], 0FFFFFFFFh
jmp loc_741D2
loc_7410D:
jmp short $+2
loc_7410F:
cmp [rbp+var_64], 0
jg short loc_7411B
cmp [rbp+var_68], 0
jz short loc_74159
loc_7411B:
mov rdi, [rbp+var_8]
mov edx, [rbp+var_C]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_58]
mov r9, [rbp+var_30]
lea rsi, [rbp+var_A8]
call _ma_ft_make_key
mov rdi, [rbp+var_8]
lea rsi, [rbp+var_A8]
call _ma_ck_write
movsx eax, al
mov [rbp+var_34], eax
cmp eax, 0
jz short loc_74157
jmp short loc_741D2
loc_74157:
jmp short $+2
loc_74159:
cmp [rbp+var_64], 0
jg short loc_7416B
mov rax, [rbp+var_50]
add rax, 18h
mov [rbp+var_50], rax
loc_7416B:
cmp [rbp+var_64], 0
jl short loc_7417D
mov rax, [rbp+var_58]
add rax, 18h
mov [rbp+var_58], rax
loc_7417D:
jmp loc_74010
loc_74182:
mov rax, [rbp+var_50]
cmp qword ptr [rax], 0
jz short loc_741A9
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_50]
mov r8, [rbp+var_30]
call _ma_ft_erase
mov [rbp+var_34], eax
jmp short loc_741D0
loc_741A9:
mov rax, [rbp+var_58]
cmp qword ptr [rax], 0
jz short loc_741CE
mov rdi, [rbp+var_8]
mov esi, [rbp+var_C]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_58]
mov r8, [rbp+var_30]
call _ma_ft_store
mov [rbp+var_34], eax
loc_741CE:
jmp short $+2
loc_741D0:
jmp short $+2
loc_741D2:
mov rdi, [rbp+var_8]
add rdi, 328h
mov esi, 2
call free_root
mov eax, [rbp+var_34]
mov [rbp+var_B4], eax
mov eax, [rbp+var_B4]
add rsp, 0C0h
pop rbp
retn
| long long ma_ft_update(long long *a1, unsigned int a2, long long a3, long long a4, long long a5, long long a6)
{
__m128i v6; // xmm0
char v7; // al
BOOL v9; // [rsp+10h] [rbp-B0h]
bool v10; // [rsp+17h] [rbp-A9h]
_BYTE v11[32]; // [rsp+18h] [rbp-A8h] BYREF
long long v12[4]; // [rsp+38h] [rbp-88h] BYREF
BOOL v13; // [rsp+58h] [rbp-68h]
int v14; // [rsp+5Ch] [rbp-64h]
long long v15; // [rsp+60h] [rbp-60h]
long long v16; // [rsp+68h] [rbp-58h]
long long v17; // [rsp+70h] [rbp-50h]
long long v18; // [rsp+78h] [rbp-48h]
long long v19; // [rsp+80h] [rbp-40h]
unsigned int v20; // [rsp+8Ch] [rbp-34h]
long long v21; // [rsp+90h] [rbp-30h]
long long v22; // [rsp+98h] [rbp-28h]
long long v23; // [rsp+A0h] [rbp-20h]
long long v24; // [rsp+A8h] [rbp-18h]
unsigned int v25; // [rsp+B4h] [rbp-Ch]
long long *v26; // [rsp+B8h] [rbp-8h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = a4;
v22 = a5;
v21 = a6;
v20 = -1;
v15 = **(_QWORD **)(280LL * a2 + *(_QWORD *)(*a1 + 1392) + 192);
v19 = ma_ft_parserecord(a1, a2, a4, (long long)(a1 + 101));
v17 = v19;
if ( v19 )
{
v18 = ma_ft_parserecord(v26, v25, v22, (long long)(v26 + 101));
v16 = v18;
if ( v18 )
{
v20 = 0;
while ( 1 )
{
v10 = 0;
if ( *(_QWORD *)v17 )
v10 = *(_QWORD *)v16 != 0LL;
if ( !v10 )
break;
v14 = ha_compare_text(
v15,
*(_QWORD *)v17,
*(unsigned int *)(v17 + 8),
*(_QWORD *)v16,
*(unsigned int *)(v16 + 8),
0LL);
if ( v14 )
{
v9 = 0;
}
else
{
v6 = (__m128i)*(unsigned long long *)(v17 + 16);
*(double *)v6.m128i_i64 = *(double *)v6.m128i_i64 - *(double *)(v16 + 16);
v9 = *(double *)_mm_and_si128(v6, (__m128i)xmmword_15A040).m128i_i64 > 0.00001;
}
v13 = v9;
if ( v14 < 0 || v13 )
{
ma_ft_make_key(v26, v12, v25, v24, v17, v21);
if ( ma_ck_delete(v26, v12) )
{
v20 = -1;
goto LABEL_27;
}
}
if ( v14 > 0 || v13 )
{
ma_ft_make_key(v26, v11, v25, v24, v16, v21);
v7 = ma_ck_write((long long)v26, (long long)v11);
v20 = v7;
if ( v7 )
goto LABEL_27;
}
if ( v14 <= 0 )
v17 += 24LL;
if ( v14 >= 0 )
v16 += 24LL;
}
if ( *(_QWORD *)v17 )
{
v20 = ma_ft_erase(v26, v25, v24, v17, v21);
}
else if ( *(_QWORD *)v16 )
{
v20 = ma_ft_store(v26, v25, v24, v16, v21);
}
}
}
LABEL_27:
free_root(v26 + 101, 2LL);
return v20;
}
| _ma_ft_update:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xc0
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x34],0xffffffff
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x570]
MOV ECX,dword ptr [RBP + -0xc]
IMUL RCX,RCX,0x118
ADD RAX,RCX
MOV RAX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x328
CALL 0x00173da0
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,0x0
JZ 0x00174004
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x8]
ADD RCX,0x328
CALL 0x00173da0
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x58],RAX
CMP RAX,0x0
JNZ 0x00174009
LAB_00174004:
JMP 0x001741d2
LAB_00174009:
MOV dword ptr [RBP + -0x34],0x0
LAB_00174010:
MOV RCX,qword ptr [RBP + -0x50]
XOR EAX,EAX
CMP qword ptr [RCX],0x0
MOV byte ptr [RBP + -0xa9],AL
JZ 0x00174033
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RAX],0x0
SETNZ AL
MOV byte ptr [RBP + -0xa9],AL
LAB_00174033:
MOV AL,byte ptr [RBP + -0xa9]
TEST AL,0x1
JNZ 0x00174042
JMP 0x00174182
LAB_00174042:
MOV RDI,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x8]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x8]
MOV R8D,EAX
XOR R9D,R9D
CALL 0x001f6c40
MOV dword ptr [RBP + -0x64],EAX
CMP dword ptr [RBP + -0x64],0x0
JZ 0x00174082
XOR EAX,EAX
MOV dword ptr [RBP + -0xb0],EAX
JMP 0x001740b9
LAB_00174082:
MOV RAX,qword ptr [RBP + -0x50]
MOVSD XMM0,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x58]
SUBSD XMM0,qword ptr [RAX + 0x10]
MOVAPS XMM1,xmmword ptr [0x0025a040]
PAND XMM0,XMM1
MOVSD XMM1,qword ptr [0x0025a070]
UCOMISD XMM0,XMM1
SETA AL
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0xb0],EAX
LAB_001740b9:
MOV EAX,dword ptr [RBP + -0xb0]
MOV dword ptr [RBP + -0x68],EAX
CMP dword ptr [RBP + -0x64],0x0
JL 0x001740ce
CMP dword ptr [RBP + -0x68],0x0
JZ 0x0017410f
LAB_001740ce:
MOV RDI,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x50]
MOV R9,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0x88]
CALL 0x00174200
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0x88]
CALL 0x00169000
CMP AL,0x0
JZ 0x0017410d
MOV dword ptr [RBP + -0x34],0xffffffff
JMP 0x001741d2
LAB_0017410d:
JMP 0x0017410f
LAB_0017410f:
CMP dword ptr [RBP + -0x64],0x0
JG 0x0017411b
CMP dword ptr [RBP + -0x68],0x0
JZ 0x00174159
LAB_0017411b:
MOV RDI,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x58]
MOV R9,qword ptr [RBP + -0x30]
LEA RSI,[RBP + -0xa8]
CALL 0x00174200
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[RBP + -0xa8]
CALL 0x00163500
MOVSX EAX,AL
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JZ 0x00174157
JMP 0x001741d2
LAB_00174157:
JMP 0x00174159
LAB_00174159:
CMP dword ptr [RBP + -0x64],0x0
JG 0x0017416b
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x18
MOV qword ptr [RBP + -0x50],RAX
LAB_0017416b:
CMP dword ptr [RBP + -0x64],0x0
JL 0x0017417d
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x18
MOV qword ptr [RBP + -0x58],RAX
LAB_0017417d:
JMP 0x00174010
LAB_00174182:
MOV RAX,qword ptr [RBP + -0x50]
CMP qword ptr [RAX],0x0
JZ 0x001741a9
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x00174370
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001741d0
LAB_001741a9:
MOV RAX,qword ptr [RBP + -0x58]
CMP qword ptr [RAX],0x0
JZ 0x001741ce
MOV RDI,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x58]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x00174400
MOV dword ptr [RBP + -0x34],EAX
LAB_001741ce:
JMP 0x001741d0
LAB_001741d0:
JMP 0x001741d2
LAB_001741d2:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x328
MOV ESI,0x2
CALL 0x001f0980
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0xb4],EAX
MOV EAX,dword ptr [RBP + -0xb4]
ADD RSP,0xc0
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
int _ma_ft_update(long *param_1,uint param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6)
{
char cVar1;
bool bVar2;
uint local_b8;
int1 local_b0 [32];
int1 local_90 [32];
uint local_70;
int local_6c;
int8 local_68;
long *local_60;
long *local_58;
long *local_50;
long *local_48;
int local_3c;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
uint local_14;
long *local_10;
local_3c = -1;
local_68 = **(int8 **)(*(long *)(*param_1 + 0x570) + (ulong)param_2 * 0x118 + 0xc0);
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
local_58 = (long *)_ma_ft_parserecord(param_1,param_2,param_4,param_1 + 0x65);
local_48 = local_58;
if ((local_58 != (long *)0x0) &&
(local_60 = (long *)_ma_ft_parserecord(local_10,local_14,local_30,local_10 + 0x65),
local_50 = local_60, local_60 != (long *)0x0)) {
local_3c = 0;
while( true ) {
bVar2 = false;
if (*local_58 != 0) {
bVar2 = *local_60 != 0;
}
if (!bVar2) break;
local_6c = ha_compare_text(local_68,*local_58,(int)local_58[1],*local_60,(int)local_60[1],0);
if (local_6c == 0) {
local_b8 = (uint)(DAT_0025a070 <
(double)((ulong)((double)local_58[2] - (double)local_60[2]) & _DAT_0025a040
));
}
else {
local_b8 = 0;
}
local_70 = local_b8;
if ((local_6c < 0) || (local_b8 != 0)) {
_ma_ft_make_key(local_10,local_90,local_14,local_20,local_58);
cVar1 = _ma_ck_delete(local_10,local_90);
if (cVar1 != '\0') {
local_3c = -1;
goto LAB_001741d2;
}
}
if ((0 < local_6c) || (local_70 != 0)) {
_ma_ft_make_key(local_10,local_b0,local_14,local_20,local_60);
cVar1 = _ma_ck_write(local_10,local_b0);
local_3c = (int)cVar1;
if (local_3c != 0) goto LAB_001741d2;
}
if (local_6c < 1) {
local_58 = local_58 + 3;
}
if (-1 < local_6c) {
local_60 = local_60 + 3;
}
}
if (*local_58 == 0) {
if (*local_60 != 0) {
local_3c = _ma_ft_store(local_10,local_14,local_20,local_60,local_38);
}
}
else {
local_3c = _ma_ft_erase(local_10,local_14,local_20,local_58,local_38);
}
}
LAB_001741d2:
free_root(local_10 + 0x65,2);
return local_3c;
}
| |
24,494 | test_thread_reader | eloqsql/storage/maria/unittest/ma_pagecache_consist.c | static void *test_thread_reader(void *arg)
{
int param=*((int*) arg);
my_thread_init();
{
DBUG_ENTER("test_reader");
DBUG_PRINT("enter", ("param: %d", param));
reader(param);
DBUG_PRINT("info", ("Thread %s ended", my_thread_name()));
pthread_mutex_lock(&LOCK_thread_count);
ok(1, "reader%d: done", param);
thread_count--;
pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
free((uchar*) arg);
my_thread_end();
}
return 0;
} | O0 | c | test_thread_reader:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
callq 0xf6200
jmp 0x2b83c
movl -0xc(%rbp), %edi
callq 0x2ae90
jmp 0x2b846
leaq 0x44bc03(%rip), %rdi # 0x477450
callq 0x2a220
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0x125ac9(%rip), %rsi # 0x15132a
movb $0x0, %al
callq 0xd9ed0
movl 0x44bc0a(%rip), %eax # 0x477478
addl $-0x1, %eax
movl %eax, 0x44bc01(%rip) # 0x477478
leaq 0x44bba2(%rip), %rdi # 0x477420
callq 0x2a580
leaq 0x44bbc6(%rip), %rdi # 0x477450
callq 0x2a1f0
movq -0x8(%rbp), %rdi
callq 0x2a170
callq 0xf65a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| test_thread_reader:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_C], eax
call my_thread_init
jmp short $+2
loc_2B83C:
mov edi, [rbp+var_C]
call reader
jmp short $+2
loc_2B846:
lea rdi, LOCK_thread_count
call _pthread_mutex_lock
mov edx, [rbp+var_C]
mov edi, 1
lea rsi, aReaderDDone; "reader%d: done"
mov al, 0
call ok
mov eax, cs:thread_count
add eax, 0FFFFFFFFh
mov cs:thread_count, eax
lea rdi, COND_thread_count
call _pthread_cond_signal
lea rdi, LOCK_thread_count
call _pthread_mutex_unlock
mov rdi, [rbp+var_8]
call _free
call my_thread_end
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long test_thread_reader(int *a1)
{
int v1; // ecx
int v2; // r8d
int v3; // r9d
int v5; // [rsp+4h] [rbp-Ch]
v5 = *a1;
my_thread_init();
reader(v5);
pthread_mutex_lock(&LOCK_thread_count);
ok(1, (unsigned int)"reader%d: done", v5, v1, v2, v3);
--thread_count;
pthread_cond_signal(&COND_thread_count);
pthread_mutex_unlock(&LOCK_thread_count);
free(a1);
my_thread_end();
return 0LL;
}
| test_thread_reader:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0xc],EAX
CALL 0x001f6200
JMP 0x0012b83c
LAB_0012b83c:
MOV EDI,dword ptr [RBP + -0xc]
CALL 0x0012ae90
JMP 0x0012b846
LAB_0012b846:
LEA RDI,[0x577450]
CALL 0x0012a220
MOV EDX,dword ptr [RBP + -0xc]
MOV EDI,0x1
LEA RSI,[0x25132a]
MOV AL,0x0
CALL 0x001d9ed0
MOV EAX,dword ptr [0x00577478]
ADD EAX,-0x1
MOV dword ptr [0x00577478],EAX
LEA RDI,[0x577420]
CALL 0x0012a580
LEA RDI,[0x577450]
CALL 0x0012a1f0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a170
CALL 0x001f65a0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 test_thread_reader(uint *param_1,UI_STRING *param_2)
{
uint uVar1;
uVar1 = *param_1;
my_thread_init();
reader((UI *)(ulong)uVar1,param_2);
pthread_mutex_lock((pthread_mutex_t *)LOCK_thread_count);
ok(1,"reader%d: done",uVar1);
thread_count = thread_count + -1;
pthread_cond_signal((pthread_cond_t *)COND_thread_count);
pthread_mutex_unlock((pthread_mutex_t *)LOCK_thread_count);
free(param_1);
my_thread_end();
return 0;
}
| |
24,495 | test_thread_reader | eloqsql/storage/maria/unittest/ma_pagecache_consist.c | static void *test_thread_reader(void *arg)
{
int param=*((int*) arg);
my_thread_init();
{
DBUG_ENTER("test_reader");
DBUG_PRINT("enter", ("param: %d", param));
reader(param);
DBUG_PRINT("info", ("Thread %s ended", my_thread_name()));
pthread_mutex_lock(&LOCK_thread_count);
ok(1, "reader%d: done", param);
thread_count--;
pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
pthread_mutex_unlock(&LOCK_thread_count);
free((uchar*) arg);
my_thread_end();
}
return 0;
} | O3 | c | test_thread_reader:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %r14d
callq 0xa1c95
movl %r14d, %edi
callq 0x303f1
leaq 0x3cbca5(%rip), %r15 # 0x3fc850
movq %r15, %rdi
callq 0x29220
leaq 0xa88f8(%rip), %rsi # 0xd94b2
movl $0x1, %edi
movl %r14d, %edx
xorl %eax, %eax
callq 0x91347
decl 0x3cbca9(%rip) # 0x3fc878
leaq 0x3cbc4a(%rip), %rdi # 0x3fc820
callq 0x295c0
movq %r15, %rdi
callq 0x291e0
movq %rbx, %rdi
callq 0x29160
callq 0xa1f10
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| test_thread_reader:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov r14d, [rdi]
call my_thread_init
mov edi, r14d
call reader
lea r15, LOCK_thread_count
mov rdi, r15
call _pthread_mutex_lock
lea rsi, aReaderDDone; "reader%d: done"
mov edi, 1
mov edx, r14d
xor eax, eax
call ok
dec cs:thread_count
lea rdi, COND_thread_count
call _pthread_cond_signal
mov rdi, r15
call _pthread_mutex_unlock
mov rdi, rbx
call _free
call my_thread_end
xor eax, eax
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long test_thread_reader(int *a1)
{
char v1; // al
int v2; // r14d
int v3; // ecx
int v4; // r8d
int v5; // r9d
char v7; // [rsp-8h] [rbp-20h]
v7 = v1;
v2 = *a1;
my_thread_init();
reader(v2);
pthread_mutex_lock(&LOCK_thread_count);
ok(1, (unsigned int)"reader%d: done", v2, v3, v4, v5, v7);
--thread_count;
pthread_cond_signal(&COND_thread_count);
pthread_mutex_unlock(&LOCK_thread_count);
free(a1);
my_thread_end();
return 0LL;
}
| test_thread_reader:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14D,dword ptr [RDI]
CALL 0x001a1c95
MOV EDI,R14D
CALL 0x001303f1
LEA R15,[0x4fc850]
MOV RDI,R15
CALL 0x00129220
LEA RSI,[0x1d94b2]
MOV EDI,0x1
MOV EDX,R14D
XOR EAX,EAX
CALL 0x00191347
DEC dword ptr [0x004fc878]
LEA RDI,[0x4fc820]
CALL 0x001295c0
MOV RDI,R15
CALL 0x001291e0
MOV RDI,RBX
CALL 0x00129160
CALL 0x001a1f10
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int8 test_thread_reader(uint *param_1,UI_STRING *param_2)
{
uint uVar1;
uVar1 = *param_1;
my_thread_init();
reader((UI *)(ulong)uVar1,param_2);
pthread_mutex_lock((pthread_mutex_t *)LOCK_thread_count);
ok(1,"reader%d: done",uVar1);
thread_count = thread_count + -1;
pthread_cond_signal((pthread_cond_t *)COND_thread_count);
pthread_mutex_unlock((pthread_mutex_t *)LOCK_thread_count);
free(param_1);
my_thread_end();
return 0;
}
| |
24,496 | JS_ToInt32Clamp | bluesky950520[P]quickjs/quickjs.c | int JS_ToInt32Clamp(JSContext *ctx, int *pres, JSValue val,
int min, int max, int min_offset)
{
int res = JS_ToInt32SatFree(ctx, pres, js_dup(val));
if (res == 0) {
if (*pres < min) {
*pres += min_offset;
if (*pres < min)
*pres = min;
} else {
if (*pres > max)
*pres = max;
}
}
return res;
} | O1 | c | JS_ToInt32Clamp:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movq %rsi, %rbx
movq %rdx, 0x8(%rsp)
cmpl $-0x9, %ecx
jb 0x27778
movq 0x8(%rsp), %rax
incl (%rax)
movq %rbx, %rsi
callq 0x276c3
testl %eax, %eax
jne 0x277a0
movl (%rbx), %ecx
cmpl %r14d, %ecx
jge 0x2779a
addl 0x30(%rsp), %ecx
cmpl %r14d, %ecx
cmovlel %r14d, %ecx
movl %ecx, %ebp
jmp 0x2779e
cmpl %ebp, %ecx
jle 0x277a0
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| JS_ToInt32Clamp:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, r9d
mov r14d, r8d
mov rbx, rsi
mov [rsp+28h+var_20], rdx
cmp ecx, 0FFFFFFF7h
jb short loc_27778
mov rax, [rsp+28h+var_20]
inc dword ptr [rax]
loc_27778:
mov rsi, rbx
call JS_ToInt32SatFree
test eax, eax
jnz short loc_277A0
mov ecx, [rbx]
cmp ecx, r14d
jge short loc_2779A
add ecx, [rsp+28h+arg_0]
cmp ecx, r14d
cmovle ecx, r14d
mov ebp, ecx
jmp short loc_2779E
loc_2779A:
cmp ecx, ebp
jle short loc_277A0
loc_2779E:
mov [rbx], ebp
loc_277A0:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long JS_ToInt32Clamp(long long a1, int *a2, _DWORD *a3, long long a4, int a5, int a6, int a7)
{
long long result; // rax
int v10; // ecx
int v11; // ecx
if ( (unsigned int)a4 >= 0xFFFFFFF7 )
++*a3;
result = JS_ToInt32SatFree(a1, a2, (long long)a3, a4);
if ( !(_DWORD)result )
{
v10 = *a2;
if ( *a2 >= a5 )
{
if ( v10 <= a6 )
return result;
}
else
{
v11 = a7 + v10;
if ( v11 <= a5 )
v11 = a5;
a6 = v11;
}
*a2 = a6;
}
return result;
}
| JS_ToInt32Clamp:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBP,R9D
MOV R14D,R8D
MOV RBX,RSI
MOV qword ptr [RSP + 0x8],RDX
CMP ECX,-0x9
JC 0x00127778
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_00127778:
MOV RSI,RBX
CALL 0x001276c3
TEST EAX,EAX
JNZ 0x001277a0
MOV ECX,dword ptr [RBX]
CMP ECX,R14D
JGE 0x0012779a
ADD ECX,dword ptr [RSP + 0x30]
CMP ECX,R14D
CMOVLE ECX,R14D
MOV EBP,ECX
JMP 0x0012779e
LAB_0012779a:
CMP ECX,EBP
JLE 0x001277a0
LAB_0012779e:
MOV dword ptr [RBX],EBP
LAB_001277a0:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
void JS_ToInt32Clamp(int8 param_1,int *param_2,int *param_3,uint param_4,int param_5,
int param_6,int param_7)
{
int iVar1;
if (0xfffffff6 < param_4) {
*param_3 = *param_3 + 1;
}
iVar1 = JS_ToInt32SatFree(param_1,param_2);
if (iVar1 == 0) {
iVar1 = *param_2;
if (iVar1 < param_5) {
param_6 = iVar1 + param_7;
if (iVar1 + param_7 <= param_5) {
param_6 = param_5;
}
}
else if (iVar1 <= param_6) {
return;
}
*param_2 = param_6;
}
return;
}
| |
24,497 | Cpu::PrintRegisterState() | sp1187[P]veesem/src/core/spg200/cpu.cc | void Cpu::PrintRegisterState() {
std::printf(
"SP: %04x, R1: %04x, R2: %04x, R3: %04x, "
"R4: %04x, BP: %04x, SR: %04x, PC: %04x\n",
regs_[REG_SP], regs_[REG_R1], regs_[REG_R2], regs_[REG_R3], regs_[REG_R4], regs_[REG_BP],
regs_[REG_SR], regs_[REG_PC]);
std::printf(
" Full PC: %06x, DS: %02x, SB: %01x, Flags: %c%c%c%c, Interrupt mode: "
"%s\n",
GetCsPc(), (int)SR.ds, sb_[fiq_ ? 2 : irq_], SR.n ? 'N' : '-', SR.z ? 'Z' : '-',
SR.s ? 'S' : '-', SR.c ? 'C' : '-',
fiq_ ? "FIQ"
: irq_ ? "IRQ"
: "Normal");
} | O0 | cpp | Cpu::PrintRegisterState():
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x68(%rbp)
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x64(%rbp)
addq $0x8, %rdi
movl $0x2, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x60(%rbp)
addq $0x8, %rdi
movl $0x3, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x5c(%rbp)
addq $0x8, %rdi
movl $0x4, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x58(%rbp)
addq $0x8, %rdi
movl $0x5, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x54(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq -0x48(%rbp), %rdi
movzwl (%rax), %eax
movl %eax, -0x50(%rbp)
addq $0x8, %rdi
movl $0x7, %esi
callq 0x1e7a0
movl -0x68(%rbp), %esi
movl -0x64(%rbp), %edx
movl -0x60(%rbp), %ecx
movl -0x5c(%rbp), %r8d
movl -0x58(%rbp), %r9d
movl -0x54(%rbp), %r11d
movl -0x50(%rbp), %r10d
movzwl (%rax), %eax
leaq 0xd8b45(%rip), %rdi # 0xf3074
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
movb $0x0, %al
callq 0x7080
movq -0x48(%rbp), %rdi
callq 0x1a770
movq -0x48(%rbp), %rdi
movl %eax, -0x4c(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movzwl (%rcx), %ecx
sarl $0xa, %ecx
andl $0x3f, %ecx
movl %ecx, -0x3c(%rbp)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, -0x38(%rbp)
testb $0x1, 0x2a(%rax)
je 0x1a597
movl $0x2, %eax
movl %eax, -0x6c(%rbp)
jmp 0x1a5a6
movq -0x48(%rbp), %rax
movb 0x29(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x6c(%rbp)
movq -0x38(%rbp), %rdi
movl -0x6c(%rbp), %eax
movslq %eax, %rsi
callq 0x1e7d0
movq -0x48(%rbp), %rdi
movzbl (%rax), %eax
movl %eax, -0x74(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x9, %ecx
andl $0x1, %ecx
movb $0x4e, %al
movb $0x2d, %dl
movb %dl, -0x6e(%rbp)
cmpl $0x0, %ecx
movb %al, -0x6d(%rbp)
jne 0x1a5f3
movb -0x6e(%rbp), %al
movb %al, -0x6d(%rbp)
movq -0x48(%rbp), %rdi
movb -0x6d(%rbp), %al
movsbl %al, %eax
movl %eax, -0x7c(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x8, %ecx
andl $0x1, %ecx
movb $0x5a, %al
movb $0x2d, %dl
movb %dl, -0x76(%rbp)
cmpl $0x0, %ecx
movb %al, -0x75(%rbp)
jne 0x1a634
movb -0x76(%rbp), %al
movb %al, -0x75(%rbp)
movq -0x48(%rbp), %rdi
movb -0x75(%rbp), %al
movsbl %al, %eax
movl %eax, -0x84(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x7, %ecx
andl $0x1, %ecx
movb $0x53, %al
movb $0x2d, %dl
movb %dl, -0x7e(%rbp)
cmpl $0x0, %ecx
movb %al, -0x7d(%rbp)
jne 0x1a678
movb -0x7e(%rbp), %al
movb %al, -0x7d(%rbp)
movq -0x48(%rbp), %rdi
movb -0x7d(%rbp), %al
movsbl %al, %eax
movl %eax, -0x8c(%rbp)
addq $0x8, %rdi
movl $0x6, %esi
callq 0x1e7a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %ecx
sarl $0x6, %ecx
andl $0x1, %ecx
movb $0x43, %al
movb $0x2d, %dl
movb %dl, -0x86(%rbp)
cmpl $0x0, %ecx
movb %al, -0x85(%rbp)
jne 0x1a6c8
movb -0x86(%rbp), %al
movb %al, -0x85(%rbp)
movq -0x48(%rbp), %rax
movb -0x85(%rbp), %cl
movsbl %cl, %ecx
movl %ecx, -0x90(%rbp)
testb $0x1, 0x2a(%rax)
je 0x1a6f1
leaq 0xd8a26(%rip), %rax # 0xf310e
movq %rax, -0x98(%rbp)
jmp 0x1a714
movq -0x48(%rbp), %rax
movb 0x29(%rax), %dl
leaq 0xd8a17(%rip), %rax # 0xf3116
leaq 0xd8a0c(%rip), %rcx # 0xf3112
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x98(%rbp)
movl -0x90(%rbp), %r10d
movl -0x8c(%rbp), %r11d
movl -0x84(%rbp), %r9d
movl -0x7c(%rbp), %r8d
movl -0x74(%rbp), %ecx
movl -0x3c(%rbp), %edx
movl -0x4c(%rbp), %esi
movq -0x98(%rbp), %rax
leaq 0xd8980(%rip), %rdi # 0xf30c4
movl %r11d, (%rsp)
movl %r10d, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x7080
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN3Cpu18PrintRegisterStateEv:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_30], rdi
mov rdi, [rbp+var_30]
mov [rbp+var_48], rdi
add rdi, 8
xor eax, eax
mov esi, eax
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_68], eax
add rdi, 8
mov esi, 1
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_64], eax
add rdi, 8
mov esi, 2
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_60], eax
add rdi, 8
mov esi, 3
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_5C], eax
add rdi, 8
mov esi, 4
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_58], eax
add rdi, 8
mov esi, 5
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_54], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, word ptr [rax]
mov [rbp+var_50], eax
add rdi, 8
mov esi, 7
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov esi, [rbp+var_68]
mov edx, [rbp+var_64]
mov ecx, [rbp+var_60]
mov r8d, [rbp+var_5C]
mov r9d, [rbp+var_58]
mov r11d, [rbp+var_54]
mov r10d, [rbp+var_50]
movzx eax, word ptr [rax]
lea rdi, aSp04xR104xR204; "SP: %04x, R1: %04x, R2: %04x, R3: %04x,"...
mov [rsp+0B0h+var_B0], r11d
mov [rsp+0B0h+var_A8], r10d
mov dword ptr [rsp+0B0h+var_A0], eax
mov al, 0
call _printf
mov rdi, [rbp+var_48]; this
call _ZN3Cpu7GetCsPcEv; Cpu::GetCsPc(void)
mov rdi, [rbp+var_48]
mov [rbp+var_4C], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov rcx, rax
mov rax, [rbp+var_48]
mov [rbp+var_28], rcx
mov rcx, [rbp+var_28]
movzx ecx, word ptr [rcx]
sar ecx, 0Ah
and ecx, 3Fh
mov [rbp+var_3C], ecx
mov rcx, rax
add rcx, 18h
mov [rbp+var_38], rcx
test byte ptr [rax+2Ah], 1
jz short loc_1A597
mov eax, 2
mov [rbp+var_6C], eax
jmp short loc_1A5A6
loc_1A597:
mov rax, [rbp+var_48]
mov al, [rax+29h]
and al, 1
movzx eax, al
mov [rbp+var_6C], eax
loc_1A5A6:
mov rdi, [rbp+var_38]
mov eax, [rbp+var_6C]
movsxd rsi, eax
call _ZNSt5arrayIhLm3EEixEm; std::array<uchar,3ul>::operator[](ulong)
mov rdi, [rbp+var_48]
movzx eax, byte ptr [rax]
mov [rbp+var_74], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
movzx ecx, word ptr [rax]
sar ecx, 9
and ecx, 1
mov al, 4Eh ; 'N'
mov dl, 2Dh ; '-'
mov [rbp+var_6E], dl
cmp ecx, 0
mov [rbp+var_6D], al
jnz short loc_1A5F3
mov al, [rbp+var_6E]
mov [rbp+var_6D], al
loc_1A5F3:
mov rdi, [rbp+var_48]
mov al, [rbp+var_6D]
movsx eax, al
mov [rbp+var_7C], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax]
sar ecx, 8
and ecx, 1
mov al, 5Ah ; 'Z'
mov dl, 2Dh ; '-'
mov [rbp+var_76], dl
cmp ecx, 0
mov [rbp+var_75], al
jnz short loc_1A634
mov al, [rbp+var_76]
mov [rbp+var_75], al
loc_1A634:
mov rdi, [rbp+var_48]
mov al, [rbp+var_75]
movsx eax, al
mov [rbp+var_84], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
movzx ecx, word ptr [rax]
sar ecx, 7
and ecx, 1
mov al, 53h ; 'S'
mov dl, 2Dh ; '-'
mov [rbp+var_7E], dl
cmp ecx, 0
mov [rbp+var_7D], al
jnz short loc_1A678
mov al, [rbp+var_7E]
mov [rbp+var_7D], al
loc_1A678:
mov rdi, [rbp+var_48]
mov al, [rbp+var_7D]
movsx eax, al
mov [rbp+var_8C], eax
add rdi, 8
mov esi, 6
call _ZNSt5arrayItLm8EEixEm; std::array<ushort,8ul>::operator[](ulong)
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movzx ecx, word ptr [rax]
sar ecx, 6
and ecx, 1
mov al, 43h ; 'C'
mov dl, 2Dh ; '-'
mov [rbp+var_86], dl
cmp ecx, 0
mov [rbp+var_85], al
jnz short loc_1A6C8
mov al, [rbp+var_86]
mov [rbp+var_85], al
loc_1A6C8:
mov rax, [rbp+var_48]
mov cl, [rbp+var_85]
movsx ecx, cl
mov [rbp+var_90], ecx
test byte ptr [rax+2Ah], 1
jz short loc_1A6F1
lea rax, aFiq; "FIQ"
mov [rbp+var_98], rax
jmp short loc_1A714
loc_1A6F1:
mov rax, [rbp+var_48]
mov dl, [rax+29h]
lea rax, aNormal; "Normal"
lea rcx, aIrq; "IRQ"
test dl, 1
cmovnz rax, rcx
mov [rbp+var_98], rax
loc_1A714:
mov r10d, [rbp+var_90]
mov r11d, [rbp+var_8C]
mov r9d, [rbp+var_84]
mov r8d, [rbp+var_7C]
mov ecx, [rbp+var_74]
mov edx, [rbp+var_3C]
mov esi, [rbp+var_4C]
mov rax, [rbp+var_98]
lea rdi, aFullPc06xDs02x; " Full PC: %06x, DS: %02x, SB: %01x, Fl"...
mov [rsp+0B0h+var_B0], r11d
mov [rsp+0B0h+var_A8], r10d
mov [rsp+0B0h+var_A0], rax
mov al, 0
call _printf
add rsp, 0B0h
pop rbp
retn
| long long Cpu::PrintRegisterState(Cpu *this)
{
unsigned __int16 *v1; // rax
const char *v2; // rax
long long v4; // [rsp+0h] [rbp-B0h]
long long v5; // [rsp+8h] [rbp-A8h]
const char *v6; // [rsp+18h] [rbp-98h]
char v7; // [rsp+2Bh] [rbp-85h]
char v8; // [rsp+33h] [rbp-7Dh]
char v9; // [rsp+3Bh] [rbp-75h]
int v10; // [rsp+3Ch] [rbp-74h]
char v11; // [rsp+43h] [rbp-6Dh]
int v12; // [rsp+44h] [rbp-6Ch]
int v13; // [rsp+48h] [rbp-68h]
int v14; // [rsp+4Ch] [rbp-64h]
int v15; // [rsp+50h] [rbp-60h]
int v16; // [rsp+54h] [rbp-5Ch]
int v17; // [rsp+58h] [rbp-58h]
int v18; // [rsp+5Ch] [rbp-54h]
int v19; // [rsp+60h] [rbp-50h]
int CsPc; // [rsp+64h] [rbp-4Ch]
int v21; // [rsp+74h] [rbp-3Ch]
v13 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 0LL);
v14 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 1LL);
v15 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 2LL);
v16 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 3LL);
v17 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 4LL);
v18 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 5LL);
v19 = *(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL);
v1 = (unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 7LL);
printf(
"SP: %04x, R1: %04x, R2: %04x, R3: %04x, R4: %04x, BP: %04x, SR: %04x, PC: %04x\n",
v13,
v14,
v15,
v16,
v17,
v18,
v19,
*v1);
CsPc = Cpu::GetCsPc(this);
v21 = ((int)*(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL) >> 10) & 0x3F;
if ( (*((_BYTE *)this + 42) & 1) != 0 )
v12 = 2;
else
v12 = *((_BYTE *)this + 41) & 1;
v10 = *(unsigned __int8 *)std::array<unsigned char,3ul>::operator[]((char *)this + 24, v12);
v11 = 78;
if ( (((int)*(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL) >> 9) & 1) == 0 )
v11 = 45;
v9 = 90;
if ( (((int)*(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL) >> 8) & 1) == 0 )
v9 = 45;
v8 = 83;
if ( (((int)*(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL) >> 7) & 1) == 0 )
v8 = 45;
v7 = 67;
if ( (((int)*(unsigned __int16 *)std::array<unsigned short,8ul>::operator[]((char *)this + 8, 6LL) >> 6) & 1) == 0 )
v7 = 45;
if ( (*((_BYTE *)this + 42) & 1) != 0 )
{
v6 = "FIQ";
}
else
{
v2 = "Normal";
if ( (*((_BYTE *)this + 41) & 1) != 0 )
v2 = "IRQ";
v6 = v2;
}
LODWORD(v4) = v8;
LODWORD(v5) = v7;
return printf(
" Full PC: %06x, DS: %02x, SB: %01x, Flags: %c%c%c%c, Interrupt mode: %s\n",
CsPc,
v21,
v10,
(unsigned int)v11,
(unsigned int)v9,
v4,
v5,
v6);
}
| PrintRegisterState:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x30],RDI
MOV RDI,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x48],RDI
ADD RDI,0x8
XOR EAX,EAX
MOV ESI,EAX
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x68],EAX
ADD RDI,0x8
MOV ESI,0x1
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
ADD RDI,0x8
MOV ESI,0x2
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x60],EAX
ADD RDI,0x8
MOV ESI,0x3
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x5c],EAX
ADD RDI,0x8
MOV ESI,0x4
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x58],EAX
ADD RDI,0x8
MOV ESI,0x5
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x54],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,word ptr [RAX]
MOV dword ptr [RBP + -0x50],EAX
ADD RDI,0x8
MOV ESI,0x7
CALL 0x0011e7a0
MOV ESI,dword ptr [RBP + -0x68]
MOV EDX,dword ptr [RBP + -0x64]
MOV ECX,dword ptr [RBP + -0x60]
MOV R8D,dword ptr [RBP + -0x5c]
MOV R9D,dword ptr [RBP + -0x58]
MOV R11D,dword ptr [RBP + -0x54]
MOV R10D,dword ptr [RBP + -0x50]
MOVZX EAX,word ptr [RAX]
LEA RDI,[0x1f3074]
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV dword ptr [RSP + 0x10],EAX
MOV AL,0x0
CALL 0x00107080
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0011a770
MOV RDI,qword ptr [RBP + -0x48]
MOV dword ptr [RBP + -0x4c],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x28],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RCX]
SAR ECX,0xa
AND ECX,0x3f
MOV dword ptr [RBP + -0x3c],ECX
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RBP + -0x38],RCX
TEST byte ptr [RAX + 0x2a],0x1
JZ 0x0011a597
MOV EAX,0x2
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x0011a5a6
LAB_0011a597:
MOV RAX,qword ptr [RBP + -0x48]
MOV AL,byte ptr [RAX + 0x29]
AND AL,0x1
MOVZX EAX,AL
MOV dword ptr [RBP + -0x6c],EAX
LAB_0011a5a6:
MOV RDI,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RBP + -0x6c]
MOVSXD RSI,EAX
CALL 0x0011e7d0
MOV RDI,qword ptr [RBP + -0x48]
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x74],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX ECX,word ptr [RAX]
SAR ECX,0x9
AND ECX,0x1
MOV AL,0x4e
MOV DL,0x2d
MOV byte ptr [RBP + -0x6e],DL
CMP ECX,0x0
MOV byte ptr [RBP + -0x6d],AL
JNZ 0x0011a5f3
MOV AL,byte ptr [RBP + -0x6e]
MOV byte ptr [RBP + -0x6d],AL
LAB_0011a5f3:
MOV RDI,qword ptr [RBP + -0x48]
MOV AL,byte ptr [RBP + -0x6d]
MOVSX EAX,AL
MOV dword ptr [RBP + -0x7c],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX]
SAR ECX,0x8
AND ECX,0x1
MOV AL,0x5a
MOV DL,0x2d
MOV byte ptr [RBP + -0x76],DL
CMP ECX,0x0
MOV byte ptr [RBP + -0x75],AL
JNZ 0x0011a634
MOV AL,byte ptr [RBP + -0x76]
MOV byte ptr [RBP + -0x75],AL
LAB_0011a634:
MOV RDI,qword ptr [RBP + -0x48]
MOV AL,byte ptr [RBP + -0x75]
MOVSX EAX,AL
MOV dword ptr [RBP + -0x84],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVZX ECX,word ptr [RAX]
SAR ECX,0x7
AND ECX,0x1
MOV AL,0x53
MOV DL,0x2d
MOV byte ptr [RBP + -0x7e],DL
CMP ECX,0x0
MOV byte ptr [RBP + -0x7d],AL
JNZ 0x0011a678
MOV AL,byte ptr [RBP + -0x7e]
MOV byte ptr [RBP + -0x7d],AL
LAB_0011a678:
MOV RDI,qword ptr [RBP + -0x48]
MOV AL,byte ptr [RBP + -0x7d]
MOVSX EAX,AL
MOV dword ptr [RBP + -0x8c],EAX
ADD RDI,0x8
MOV ESI,0x6
CALL 0x0011e7a0
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVZX ECX,word ptr [RAX]
SAR ECX,0x6
AND ECX,0x1
MOV AL,0x43
MOV DL,0x2d
MOV byte ptr [RBP + -0x86],DL
CMP ECX,0x0
MOV byte ptr [RBP + -0x85],AL
JNZ 0x0011a6c8
MOV AL,byte ptr [RBP + -0x86]
MOV byte ptr [RBP + -0x85],AL
LAB_0011a6c8:
MOV RAX,qword ptr [RBP + -0x48]
MOV CL,byte ptr [RBP + -0x85]
MOVSX ECX,CL
MOV dword ptr [RBP + -0x90],ECX
TEST byte ptr [RAX + 0x2a],0x1
JZ 0x0011a6f1
LEA RAX,[0x1f310e]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x0011a714
LAB_0011a6f1:
MOV RAX,qword ptr [RBP + -0x48]
MOV DL,byte ptr [RAX + 0x29]
LEA RAX,[0x1f3116]
LEA RCX,[0x1f3112]
TEST DL,0x1
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
LAB_0011a714:
MOV R10D,dword ptr [RBP + -0x90]
MOV R11D,dword ptr [RBP + -0x8c]
MOV R9D,dword ptr [RBP + -0x84]
MOV R8D,dword ptr [RBP + -0x7c]
MOV ECX,dword ptr [RBP + -0x74]
MOV EDX,dword ptr [RBP + -0x3c]
MOV ESI,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x98]
LEA RDI,[0x1f30c4]
MOV dword ptr [RSP],R11D
MOV dword ptr [RSP + 0x8],R10D
MOV qword ptr [RSP + 0x10],RAX
MOV AL,0x0
CALL 0x00107080
ADD RSP,0xb0
POP RBP
RET
|
/* Cpu::PrintRegisterState() */
void __thiscall Cpu::PrintRegisterState(Cpu *this)
{
byte bVar1;
ushort uVar2;
ushort uVar3;
ushort uVar4;
ushort uVar5;
ushort uVar6;
ushort uVar7;
ushort uVar8;
uint uVar9;
ushort *puVar10;
byte *pbVar11;
int8 in_stack_ffffffffffffff58;
int4 uVar12;
char *local_a0;
char local_8d;
char local_85;
char local_7d;
char local_75;
uint local_74;
uVar12 = (int4)((ulong)in_stack_ffffffffffffff58 >> 0x20);
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),0);
uVar2 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),1);
uVar3 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),2);
uVar4 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),3);
uVar5 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),4);
uVar6 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),5);
uVar7 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
uVar8 = *puVar10;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),7);
printf("SP: %04x, R1: %04x, R2: %04x, R3: %04x, R4: %04x, BP: %04x, SR: %04x, PC: %04x\n",
(ulong)uVar2,(ulong)uVar3,(ulong)uVar4,(ulong)uVar5,(ulong)uVar6,(uint)uVar7,(uint)uVar8,
CONCAT44(uVar12,(uint)*puVar10));
uVar9 = GetCsPc(this);
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
uVar2 = *puVar10;
if (((byte)this[0x2a] & 1) == 0) {
local_74 = (uint)((byte)this[0x29] & 1);
}
else {
local_74 = 2;
}
pbVar11 = (byte *)std::array<unsigned_char,3ul>::operator[]
((array<unsigned_char,3ul> *)(this + 0x18),(long)(int)local_74);
bVar1 = *pbVar11;
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
local_75 = 'N';
if (((int)(uint)*puVar10 >> 9 & 1U) == 0) {
local_75 = '-';
}
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
local_7d = 'Z';
if (((int)(uint)*puVar10 >> 8 & 1U) == 0) {
local_7d = '-';
}
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
local_85 = 'S';
if (((int)(uint)*puVar10 >> 7 & 1U) == 0) {
local_85 = '-';
}
puVar10 = (ushort *)
std::array<unsigned_short,8ul>::operator[]((array<unsigned_short,8ul> *)(this + 8),6);
local_8d = 'C';
if (((int)(uint)*puVar10 >> 6 & 1U) == 0) {
local_8d = '-';
}
if (((byte)this[0x2a] & 1) == 0) {
local_a0 = "Normal";
if (((byte)this[0x29] & 1) != 0) {
local_a0 = "IRQ";
}
}
else {
local_a0 = "FIQ";
}
printf(" Full PC: %06x, DS: %02x, SB: %01x, Flags: %c%c%c%c, Interrupt mode: %s\n",(ulong)uVar9,
(ulong)(uint)((int)(uint)uVar2 >> 10),(ulong)bVar1,(ulong)(uint)(int)local_75,
(ulong)(uint)(int)local_7d,(int)local_85,(int)local_8d,local_a0);
return;
}
| |
24,498 | google::protobuf::compiler::java::ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(google::protobuf::io::Printer*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/java/message.cc | int ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(
io::Printer* printer) {
int bytecode_estimate = 10;
printer->Print(
"internal_$identifier$_fieldAccessorTable = new\n"
" com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable(\n"
" internal_$identifier$_descriptor,\n"
" new java.lang.String[] { ",
"identifier", UniqueFileScopeIdentifier(descriptor_), "ver",
GeneratedCodeVersionSuffix());
// All the bytecode_estimate calculation logic in this method must stay in
// sync with the similar logic in the GenerateFieldAccessorTable method
// above. See the corresponding comment in GenerateFieldAccessorTable for
// details.
for (int i = 0; i < descriptor_->field_count(); i++) {
const FieldDescriptor* field = descriptor_->field(i);
const FieldGeneratorInfo* info = context_->GetFieldGeneratorInfo(field);
bytecode_estimate += 6;
printer->Print("\"$field_name$\", ", "field_name", info->capitalized_name);
}
// We reproduce synthetic oneofs here since proto reflection needs these.
for (int i = 0; i < descriptor_->oneof_decl_count(); i++) {
const OneofDescriptor* oneof = descriptor_->oneof_decl(i);
const OneofGeneratorInfo* info = context_->GetOneofGeneratorInfo(oneof);
bytecode_estimate += 6;
printer->Print("\"$oneof_name$\", ", "oneof_name", info->capitalized_name);
}
printer->Print("});\n");
return bytecode_estimate;
} | O3 | cpp | google::protobuf::compiler::java::ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(google::protobuf::io::Printer*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x43761
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movw $0x3356, (%r12) # imm = 0x3356
movq $0x2, -0x8(%r12)
movb $0x0, 0x2(%r12)
leaq 0x11106f(%rip), %rsi # 0x1bb2c5
leaq 0xf3878(%rip), %rdx # 0x19dad5
leaq 0xf2bd1(%rip), %r8 # 0x19ce35
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r15, %rcx
callq 0xae7f2
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xaa283
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa296
callq 0x1f4a0
movq 0x8(%r14), %rax
cmpl $0x0, 0x4(%rax)
jle 0xaa2f1
movl $0xa, %ebp
xorl %r13d, %r13d
leaq 0x111656(%rip), %r12 # 0x1bb905
xorl %r15d, %r15d
movq 0x28(%rax), %rsi
addq %r13, %rsi
movq 0x40(%r14), %rdi
callq 0xceecc
addl $0x6, %ebp
leaq 0x20(%rax), %rcx
movq %rbx, %rdi
leaq 0x1110a5(%rip), %rsi # 0x1bb378
movq %r12, %rdx
callq 0x40d74
incq %r15
movq 0x8(%r14), %rax
movslq 0x4(%rax), %rcx
addq $0x48, %r13
cmpq %rcx, %r15
jl 0xaa2b2
jmp 0xaa2f6
movl $0xa, %ebp
cmpl $0x0, 0x68(%rax)
jle 0xaa346
xorl %r13d, %r13d
leaq 0x103dbb(%rip), %r12 # 0x1ae0c1
xorl %r15d, %r15d
movq 0x30(%rax), %rsi
addq %r13, %rsi
movq 0x40(%r14), %rdi
callq 0xcef84
addl $0x6, %ebp
leaq 0x20(%rax), %rcx
movq %rbx, %rdi
leaq 0x11105f(%rip), %rsi # 0x1bb389
movq %r12, %rdx
callq 0x40d74
incq %r15
movq 0x8(%r14), %rax
movslq 0x68(%rax), %rcx
addq $0x28, %r13
cmpq %rcx, %r15
jl 0xaa309
leaq 0x11a53f(%rip), %rsi # 0x1c488c
movq %rbx, %rdi
callq 0x2e40a
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xaa378
callq 0x1f4a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa38b
callq 0x1f4a0
movq %rbx, %rdi
callq 0x1f860
nop
| _ZN6google8protobuf8compiler4java25ImmutableMessageGenerator37GenerateFieldAccessorTableInitializerEPNS0_2io7PrinterE:
push rbp
push r15
push r14
push r13
push r12; char
push rbx; int
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov rsi, [rdi+8]; int
lea r15, [rsp+78h+var_50]
mov rdi, r15; int
call _ZN6google8protobuf8compiler4java25UniqueFileScopeIdentifierB5cxx11EPKNS0_10DescriptorE; google::protobuf::compiler::java::UniqueFileScopeIdentifier(google::protobuf::Descriptor const*)
lea r12, [rsp+78h+var_60]
mov [r12-10h], r12
mov word ptr [r12], 3356h
mov qword ptr [r12-8], 2
mov byte ptr [r12+2], 0
lea rsi, aInternalIdenti_1; "internal_$identifier$_fieldAccessorTabl"...
lea rdx, aFilenameIdenti+9; "identifier"
lea r8, aNever+2; "ver"
lea r9, [rsp+78h+var_70]
mov rdi, rbx
mov rcx, r15
call _ZN6google8protobuf2io7Printer5PrintIJA11_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEA4_cSA_EEEvPKcDpRKT_; google::protobuf::io::Printer::Print<char [11],std::string,char [4],std::string>(char const*,char [11],std::string,char [4],std::string const&)
mov rdi, [rsp+78h+var_70]; void *
cmp rdi, r12
jz short loc_AA283
call __ZdlPv; operator delete(void *)
loc_AA283:
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AA296
call __ZdlPv; operator delete(void *)
loc_AA296:
mov rax, [r14+8]
cmp dword ptr [rax+4], 0
jle short loc_AA2F1
mov ebp, 0Ah
xor r13d, r13d
lea r12, aBitFieldName+4; "field_name"
xor r15d, r15d
loc_AA2B2:
mov rsi, [rax+28h]
add rsi, r13; google::protobuf::FieldDescriptor *
mov rdi, [r14+40h]; this
call _ZNK6google8protobuf8compiler4java7Context21GetFieldGeneratorInfoEPKNS0_15FieldDescriptorE; google::protobuf::compiler::java::Context::GetFieldGeneratorInfo(google::protobuf::FieldDescriptor const*)
add ebp, 6
lea rcx, [rax+20h]
mov rdi, rbx
lea rsi, aFieldName_2; "\"$field_name$\", "
mov rdx, r12
call _ZN6google8protobuf2io7Printer5PrintIJA11_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvPKcDpRKT_; google::protobuf::io::Printer::Print<char [11],std::string>(char const*,char [11],std::string const&)
inc r15
mov rax, [r14+8]
movsxd rcx, dword ptr [rax+4]
add r13, 48h ; 'H'
cmp r15, rcx
jl short loc_AA2B2
jmp short loc_AA2F6
loc_AA2F1:
mov ebp, 0Ah
loc_AA2F6:
cmp dword ptr [rax+68h], 0
jle short loc_AA346
xor r13d, r13d
lea r12, aCamelOneofName+6; "oneof_name"
xor r15d, r15d
loc_AA309:
mov rsi, [rax+30h]
add rsi, r13
mov rdi, [r14+40h]
call _ZNK6google8protobuf8compiler4java7Context21GetOneofGeneratorInfoEPKNS0_15OneofDescriptorE; google::protobuf::compiler::java::Context::GetOneofGeneratorInfo(google::protobuf::OneofDescriptor const*)
add ebp, 6
lea rcx, [rax+20h]
mov rdi, rbx
lea rsi, aOneofName_0; "\"$oneof_name$\", "
mov rdx, r12
call _ZN6google8protobuf2io7Printer5PrintIJA11_cNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEvPKcDpRKT_; google::protobuf::io::Printer::Print<char [11],std::string>(char const*,char [11],std::string const&)
inc r15
mov rax, [r14+8]
movsxd rcx, dword ptr [rax+68h]
add r13, 28h ; '('
cmp r15, rcx
jl short loc_AA309
loc_AA346:
lea rsi, asc_1C4888+4; "});\n"
mov rdi, rbx
call _ZN6google8protobuf2io7Printer5PrintIJEEEvPKcDpRKT_
mov eax, ebp
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r12
jz short loc_AA378
call __ZdlPv; operator delete(void *)
loc_AA378:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AA38B
call __ZdlPv; operator delete(void *)
loc_AA38B:
mov rdi, rbx
call __Unwind_Resume
| long long google::protobuf::compiler::java::ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(
google::protobuf::compiler::java::ImmutableMessageGenerator *this,
google::protobuf::io::Printer *a2)
{
long long v2; // rax
unsigned int v3; // ebp
long long v4; // r13
long long v5; // r15
long long v6; // r13
long long v7; // r15
void *v9[2]; // [rsp+8h] [rbp-70h] BYREF
char v10[16]; // [rsp+18h] [rbp-60h] BYREF
int v11[4]; // [rsp+28h] [rbp-50h] BYREF
char v12; // [rsp+38h] [rbp-40h] BYREF
google::protobuf::compiler::java::UniqueFileScopeIdentifier[abi:cxx11]((long long)v11, *((_QWORD *)this + 1));
v9[0] = v10;
strcpy(v10, "V3");
v9[1] = &dword_0 + 2;
google::protobuf::io::Printer::Print<char [11],std::string,char [4],std::string>(
a2,
"internal_$identifier$_fieldAccessorTable = new\n"
" com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable(\n"
" internal_$identifier$_descriptor,\n"
" new java.lang.String[] { ",
"identifier",
v11,
"ver",
v9);
if ( v9[0] != v10 )
operator delete(v9[0]);
if ( *(char **)v11 != &v12 )
operator delete(*(void **)v11);
v2 = *((_QWORD *)this + 1);
if ( *(int *)(v2 + 4) <= 0 )
{
v3 = 10;
}
else
{
v3 = 10;
v4 = 0LL;
v5 = 0LL;
do
{
google::protobuf::compiler::java::Context::GetFieldGeneratorInfo(
*((google::protobuf::compiler::java::Context **)this + 8),
(const google::protobuf::FieldDescriptor *)(v4 + *(_QWORD *)(v2 + 40)));
v3 += 6;
google::protobuf::io::Printer::Print<char [11],std::string>(a2);
++v5;
v2 = *((_QWORD *)this + 1);
v4 += 72LL;
}
while ( v5 < *(int *)(v2 + 4) );
}
if ( *(int *)(v2 + 104) > 0 )
{
v6 = 0LL;
v7 = 0LL;
do
{
google::protobuf::compiler::java::Context::GetOneofGeneratorInfo(
*((google::protobuf::compiler::java::Context **)this + 8),
(const google::protobuf::OneofDescriptor *)(v6 + *(_QWORD *)(v2 + 48)));
v3 += 6;
google::protobuf::io::Printer::Print<char [11],std::string>(a2);
++v7;
v2 = *((_QWORD *)this + 1);
v6 += 40LL;
}
while ( v7 < *(int *)(v2 + 104) );
}
google::protobuf::io::Printer::Print<>(a2, "});\n");
return v3;
}
| GenerateFieldAccessorTableInitializer:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RDI + 0x8]
LEA R15,[RSP + 0x28]
MOV RDI,R15
CALL 0x00143761
LEA R12,[RSP + 0x18]
MOV qword ptr [R12 + -0x10],R12
MOV word ptr [R12],0x3356
MOV qword ptr [R12 + -0x8],0x2
MOV byte ptr [R12 + 0x2],0x0
LAB_001aa24f:
LEA RSI,[0x2bb2c5]
LEA RDX,[0x29dad5]
LEA R8,[0x29ce35]
LEA R9,[RSP + 0x8]
MOV RDI,RBX
MOV RCX,R15
CALL 0x001ae7f2
LAB_001aa274:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R12
JZ 0x001aa283
CALL 0x0011f4a0
LAB_001aa283:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001aa296
CALL 0x0011f4a0
LAB_001aa296:
MOV RAX,qword ptr [R14 + 0x8]
CMP dword ptr [RAX + 0x4],0x0
JLE 0x001aa2f1
MOV EBP,0xa
XOR R13D,R13D
LEA R12,[0x2bb905]
XOR R15D,R15D
LAB_001aa2b2:
MOV RSI,qword ptr [RAX + 0x28]
ADD RSI,R13
MOV RDI,qword ptr [R14 + 0x40]
CALL 0x001ceecc
ADD EBP,0x6
LEA RCX,[RAX + 0x20]
MOV RDI,RBX
LEA RSI,[0x2bb378]
MOV RDX,R12
CALL 0x00140d74
INC R15
MOV RAX,qword ptr [R14 + 0x8]
MOVSXD RCX,dword ptr [RAX + 0x4]
ADD R13,0x48
CMP R15,RCX
JL 0x001aa2b2
JMP 0x001aa2f6
LAB_001aa2f1:
MOV EBP,0xa
LAB_001aa2f6:
CMP dword ptr [RAX + 0x68],0x0
JLE 0x001aa346
XOR R13D,R13D
LEA R12,[0x2ae0c1]
XOR R15D,R15D
LAB_001aa309:
MOV RSI,qword ptr [RAX + 0x30]
ADD RSI,R13
MOV RDI,qword ptr [R14 + 0x40]
CALL 0x001cef84
ADD EBP,0x6
LEA RCX,[RAX + 0x20]
MOV RDI,RBX
LEA RSI,[0x2bb389]
MOV RDX,R12
CALL 0x00140d74
INC R15
MOV RAX,qword ptr [R14 + 0x8]
MOVSXD RCX,dword ptr [RAX + 0x68]
ADD R13,0x28
CMP R15,RCX
JL 0x001aa309
LAB_001aa346:
LEA RSI,[0x2c488c]
MOV RDI,RBX
CALL 0x0012e40a
MOV EAX,EBP
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x001aa27e) */
/* google::protobuf::compiler::java::ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer(google::protobuf::io::Printer*)
*/
int __thiscall
google::protobuf::compiler::java::ImmutableMessageGenerator::GenerateFieldAccessorTableInitializer
(ImmutableMessageGenerator *this,Printer *param_1)
{
long lVar1;
int iVar2;
long lVar3;
long lVar4;
int1 *local_50 [2];
int1 local_40 [16];
UniqueFileScopeIdentifier_abi_cxx11_((java *)local_50,*(Descriptor **)(this + 8));
/* try { // try from 001aa24f to 001aa273 has its CatchHandler @ 001aa366 */
io::Printer::Print<char[11],std::__cxx11::string,char[4],std::__cxx11::string>
((char *)param_1,
"internal_$identifier$_fieldAccessorTable = new\n com.google.protobuf.GeneratedMessage$ver$.FieldAccessorTable(\n internal_$identifier$_descriptor,\n new java.lang.String[] { "
,(string *)0x29dad5,(char *)local_50,(string *)0x29ce35);
if (local_50[0] != local_40) {
operator_delete(local_50[0]);
}
lVar1 = *(long *)(this + 8);
if (*(int *)(lVar1 + 4) < 1) {
iVar2 = 10;
}
else {
iVar2 = 10;
lVar3 = 0;
lVar4 = 0;
do {
Context::GetFieldGeneratorInfo
(*(Context **)(this + 0x40),(FieldDescriptor *)(*(long *)(lVar1 + 0x28) + lVar3));
iVar2 = iVar2 + 6;
io::Printer::Print<char[11],std::__cxx11::string>
((char *)param_1,"\"$field_name$\", ",(string *)0x2bb905);
lVar4 = lVar4 + 1;
lVar1 = *(long *)(this + 8);
lVar3 = lVar3 + 0x48;
} while (lVar4 < *(int *)(lVar1 + 4));
}
if (0 < *(int *)(lVar1 + 0x68)) {
lVar3 = 0;
lVar4 = 0;
do {
Context::GetOneofGeneratorInfo
(*(Context **)(this + 0x40),(OneofDescriptor *)(*(long *)(lVar1 + 0x30) + lVar3));
iVar2 = iVar2 + 6;
io::Printer::Print<char[11],std::__cxx11::string>
((char *)param_1,"\"$oneof_name$\", ",(string *)0x2ae0c1);
lVar4 = lVar4 + 1;
lVar1 = *(long *)(this + 8);
lVar3 = lVar3 + 0x28;
} while (lVar4 < *(int *)(lVar1 + 0x68));
}
io::Printer::Print<>(param_1,"});\n");
return iVar2;
}
| |
24,499 | process_dbl_arg | eloqsql/strings/my_vsnprintf.c | static char *process_dbl_arg(char *to, char *end, size_t width,
double par, char arg_type)
{
if (width == MAX_WIDTH)
width= FLT_DIG; /* width not set, use default */
else if (width >= FLOATING_POINT_DECIMALS)
width= FLOATING_POINT_DECIMALS - 1; /* max.precision for my_fcvt() */
width= MY_MIN(width, (size_t)(end-to) - 1);
if (arg_type == 'f')
to+= my_fcvt(par, (int)width , to, NULL);
else
to+= my_gcvt(par, MY_GCVT_ARG_DOUBLE, (int) width , to, NULL);
return to;
} | O3 | c | process_dbl_arg:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x1e, %rdx
movl $0x1e, %eax
cmovbq %rdx, %rax
cmpq $0xffff, %rdx # imm = 0xFFFF
movl $0x6, %edx
cmovneq %rax, %rdx
movq %rdi, %rbx
movq %rdi, %rax
notq %rax
addq %rsi, %rax
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpb $0x66, %cl
jne 0xd7ae8
movl %eax, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xd3074
jmp 0xd7af9
movl $0x1, %edi
movl %eax, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xd43f6
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| process_dbl_arg:
push rbp
mov rbp, rsp
push rbx
push rax
cmp rdx, 1Eh
mov eax, 1Eh
cmovb rax, rdx
cmp rdx, 0FFFFh
mov edx, 6
cmovnz rdx, rax
mov rbx, rdi
mov rax, rdi
not rax
add rax, rsi
cmp rdx, rax
cmovb rax, rdx
cmp cl, 66h ; 'f'
jnz short loc_D7AE8
mov edi, eax
mov rsi, rbx
xor edx, edx
call my_fcvt
jmp short loc_D7AF9
loc_D7AE8:
mov edi, 1
mov esi, eax
mov rdx, rbx
xor ecx, ecx
call my_gcvt
loc_D7AF9:
add rbx, rax
mov rax, rbx
add rsp, 8
pop rbx
pop rbp
retn
| char * process_dbl_arg(unsigned long long a1, long long a2, unsigned long long a3, char a4, double a5)
{
long long v5; // rax
bool v6; // zf
unsigned long long v7; // rdx
unsigned long long v8; // rax
long long v9; // rax
v5 = 30LL;
if ( a3 < 0x1E )
v5 = a3;
v6 = a3 == 0xFFFF;
v7 = 6LL;
if ( !v6 )
v7 = v5;
v8 = a2 + ~a1;
if ( v7 < v8 )
LODWORD(v8) = v7;
if ( a4 == 102 )
v9 = (long long)my_fcvt(v8, (_WORD *)a1, 0LL);
else
v9 = my_gcvt(1, v8, (_WORD *)a1, 0LL, a5);
return (char *)(v9 + a1);
}
| process_dbl_arg:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
CMP RDX,0x1e
MOV EAX,0x1e
CMOVC RAX,RDX
CMP RDX,0xffff
MOV EDX,0x6
CMOVNZ RDX,RAX
MOV RBX,RDI
MOV RAX,RDI
NOT RAX
ADD RAX,RSI
CMP RDX,RAX
CMOVC RAX,RDX
CMP CL,0x66
JNZ 0x001d7ae8
MOV EDI,EAX
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001d3074
JMP 0x001d7af9
LAB_001d7ae8:
MOV EDI,0x1
MOV ESI,EAX
MOV RDX,RBX
XOR ECX,ECX
CALL 0x001d43f6
LAB_001d7af9:
ADD RBX,RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long process_dbl_arg(ulong param_1,long param_2,ulong param_3,char param_4)
{
ulong uVar1;
long lVar2;
ulong uVar3;
uVar1 = 0x1e;
if (param_3 < 0x1e) {
uVar1 = param_3;
}
uVar3 = 6;
if (param_3 != 0xffff) {
uVar3 = uVar1;
}
uVar1 = ~param_1 + param_2;
if (uVar3 < ~param_1 + param_2) {
uVar1 = uVar3;
}
if (param_4 == 'f') {
lVar2 = my_fcvt(uVar1 & 0xffffffff,param_1,0);
}
else {
lVar2 = my_gcvt(1,uVar1 & 0xffffffff,param_1,0);
}
return param_1 + lVar2;
}
|
Subsets and Splits
C++ Functions Using STL
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ STL Function Queries
Filters C++ code examples that use standard library containers and algorithms, helping identify common programming patterns and library usage in code generation tasks.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.