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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
23,600 | glfwChooseVideoMode | untodesu[P]riteg/build_O2/_deps/glfw-src/src/monitor.c | const GLFWvidmode* _glfwChooseVideoMode(_GLFWmonitor* monitor,
const GLFWvidmode* desired)
{
int i;
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
unsigned int rateDiff, leastRateDiff = UINT_MAX;
unsigned int colorDiff, leastColorDiff = UINT_MAX;
const GLFWvidmode* current;
const GLFWvidmode* closest = NULL;
if (!refreshVideoModes(monitor))
return NULL;
for (i = 0; i < monitor->modeCount; i++)
{
current = monitor->modes + i;
colorDiff = 0;
if (desired->redBits != GLFW_DONT_CARE)
colorDiff += abs(current->redBits - desired->redBits);
if (desired->greenBits != GLFW_DONT_CARE)
colorDiff += abs(current->greenBits - desired->greenBits);
if (desired->blueBits != GLFW_DONT_CARE)
colorDiff += abs(current->blueBits - desired->blueBits);
sizeDiff = abs((current->width - desired->width) *
(current->width - desired->width) +
(current->height - desired->height) *
(current->height - desired->height));
if (desired->refreshRate != GLFW_DONT_CARE)
rateDiff = abs(current->refreshRate - desired->refreshRate);
else
rateDiff = UINT_MAX - current->refreshRate;
if ((colorDiff < leastColorDiff) ||
(colorDiff == leastColorDiff && sizeDiff < leastSizeDiff) ||
(colorDiff == leastColorDiff && sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
{
closest = current;
leastSizeDiff = sizeDiff;
leastRateDiff = rateDiff;
leastColorDiff = colorDiff;
}
}
return closest;
} | O2 | c | glfwChooseVideoMode:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x18040
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
je 0x18035
movl 0x28(%r14), %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0x18, %rcx, %rcx
pushq $-0x1
popq %rsi
xorl %edx, %edx
movl %esi, %edi
movl %esi, %r8d
cmpq %rdx, %rcx
je 0x18035
movq 0x20(%r14), %r9
movl 0x8(%rbx), %r10d
cmpl $-0x1, %r10d
je 0x17f88
movl 0x8(%r9,%rdx), %r11d
subl %r10d, %r11d
movl %r11d, %r10d
negl %r10d
cmovsl %r11d, %r10d
jmp 0x17f8b
xorl %r10d, %r10d
movl 0xc(%rbx), %r11d
cmpl $-0x1, %r11d
je 0x17faa
movl 0xc(%r9,%rdx), %ebp
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
addl %r11d, %r10d
movl 0x10(%rbx), %r11d
cmpl $-0x1, %r11d
je 0x17fc9
movl 0x10(%r9,%rdx), %ebp
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
addl %r11d, %r10d
movl 0x14(%rbx), %r11d
movl 0x14(%r9,%rdx), %ebp
cmpl $-0x1, %r11d
je 0x17fe7
subl %r11d, %ebp
movl %ebp, %r11d
negl %r11d
cmovsl %ebp, %r11d
jmp 0x17fec
notl %ebp
movl %ebp, %r11d
movl (%r9,%rdx), %r15d
movl 0x4(%r9,%rdx), %ebp
subl (%rbx), %r15d
subl 0x4(%rbx), %ebp
imull %r15d, %r15d
imull %ebp, %ebp
addl %r15d, %ebp
cmpl %r8d, %r10d
jb 0x1801e
jne 0x18010
cmpl %esi, %ebp
jb 0x1801e
cmpl %r8d, %r10d
jne 0x1802c
cmpl %esi, %ebp
jne 0x1802c
cmpl %edi, %r11d
jae 0x1802c
addq %rdx, %r9
movl %ebp, %esi
movl %r11d, %edi
movl %r10d, %r8d
movq %r9, %rax
addq $0x18, %rdx
jmp 0x17f5d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _glfwChooseVideoMode:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rsi
mov r14, rdi
call refreshVideoModes
mov ecx, eax
xor eax, eax
test ecx, ecx
jz loc_18035
mov ecx, [r14+28h]
test ecx, ecx
cmovle ecx, eax
imul rcx, 18h
push 0FFFFFFFFFFFFFFFFh
pop rsi
xor edx, edx
mov edi, esi
mov r8d, esi
loc_17F5D:
cmp rcx, rdx
jz loc_18035
mov r9, [r14+20h]
mov r10d, [rbx+8]
cmp r10d, 0FFFFFFFFh
jz short loc_17F88
mov r11d, [r9+rdx+8]
sub r11d, r10d
mov r10d, r11d
neg r10d
cmovs r10d, r11d
jmp short loc_17F8B
loc_17F88:
xor r10d, r10d
loc_17F8B:
mov r11d, [rbx+0Ch]
cmp r11d, 0FFFFFFFFh
jz short loc_17FAA
mov ebp, [r9+rdx+0Ch]
sub ebp, r11d
mov r11d, ebp
neg r11d
cmovs r11d, ebp
add r10d, r11d
loc_17FAA:
mov r11d, [rbx+10h]
cmp r11d, 0FFFFFFFFh
jz short loc_17FC9
mov ebp, [r9+rdx+10h]
sub ebp, r11d
mov r11d, ebp
neg r11d
cmovs r11d, ebp
add r10d, r11d
loc_17FC9:
mov r11d, [rbx+14h]
mov ebp, [r9+rdx+14h]
cmp r11d, 0FFFFFFFFh
jz short loc_17FE7
sub ebp, r11d
mov r11d, ebp
neg r11d
cmovs r11d, ebp
jmp short loc_17FEC
loc_17FE7:
not ebp
mov r11d, ebp
loc_17FEC:
mov r15d, [r9+rdx]
mov ebp, [r9+rdx+4]
sub r15d, [rbx]
sub ebp, [rbx+4]
imul r15d, r15d
imul ebp, ebp
add ebp, r15d
cmp r10d, r8d
jb short loc_1801E
jnz short loc_18010
cmp ebp, esi
jb short loc_1801E
loc_18010:
cmp r10d, r8d
jnz short loc_1802C
cmp ebp, esi
jnz short loc_1802C
cmp r11d, edi
jnb short loc_1802C
loc_1801E:
add r9, rdx
mov esi, ebp
mov edi, r11d
mov r8d, r10d
mov rax, r9
loc_1802C:
add rdx, 18h
jmp loc_17F5D
loc_18035:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long glfwChooseVideoMode(long long a1, _DWORD *a2)
{
int refreshed; // ecx
long long result; // rax
long long v6; // rcx
long long v7; // rcx
unsigned int v8; // esi
long long v9; // rdx
unsigned int v10; // edi
unsigned int v11; // r8d
long long v12; // r9
int v13; // r10d
int v14; // r11d
int v15; // r10d
int v16; // r11d
int v17; // ebp
int v18; // r11d
int v19; // r11d
int v20; // ebp
int v21; // r11d
int v22; // r11d
int v23; // ebp
int v24; // ebp
unsigned int v25; // r11d
int v26; // ebp
unsigned int v27; // ebp
refreshed = refreshVideoModes(a1);
result = 0LL;
if ( refreshed )
{
v6 = *(unsigned int *)(a1 + 40);
if ( (int)v6 <= 0 )
v6 = 0LL;
v7 = 24 * v6;
v8 = -1;
v9 = 0LL;
v10 = -1;
v11 = -1;
while ( v7 != v9 )
{
v12 = *(_QWORD *)(a1 + 32);
v13 = a2[2];
if ( v13 == -1 )
{
v15 = 0;
}
else
{
v14 = *(_DWORD *)(v12 + v9 + 8) - v13;
v15 = v13 - *(_DWORD *)(v12 + v9 + 8);
if ( v15 < 0 )
v15 = v14;
}
v16 = a2[3];
if ( v16 != -1 )
{
v17 = *(_DWORD *)(v12 + v9 + 12) - v16;
v18 = v16 - *(_DWORD *)(v12 + v9 + 12);
if ( v18 < 0 )
v18 = v17;
v15 += v18;
}
v19 = a2[4];
if ( v19 != -1 )
{
v20 = *(_DWORD *)(v12 + v9 + 16) - v19;
v21 = v19 - *(_DWORD *)(v12 + v9 + 16);
if ( v21 < 0 )
v21 = v20;
v15 += v21;
}
v22 = a2[5];
v23 = *(_DWORD *)(v12 + v9 + 20);
if ( v22 == -1 )
{
v25 = ~v23;
}
else
{
v24 = v23 - v22;
v25 = -v24;
if ( v24 > 0 )
v25 = v24;
}
v26 = *(_DWORD *)(v12 + v9 + 4) - a2[1];
v27 = (*(_DWORD *)(v12 + v9) - *a2) * (*(_DWORD *)(v12 + v9) - *a2) + v26 * v26;
if ( v15 < v11 || v15 == v11 && v27 < v8 || v15 == v11 && v27 == v8 && v25 < v10 )
{
v8 = v27;
v10 = v25;
v11 = v15;
result = v9 + v12;
}
v9 += 24LL;
}
}
return result;
}
| _glfwChooseVideoMode:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00118040
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
JZ 0x00118035
MOV ECX,dword ptr [R14 + 0x28]
TEST ECX,ECX
CMOVLE ECX,EAX
IMUL RCX,RCX,0x18
PUSH -0x1
POP RSI
XOR EDX,EDX
MOV EDI,ESI
MOV R8D,ESI
LAB_00117f5d:
CMP RCX,RDX
JZ 0x00118035
MOV R9,qword ptr [R14 + 0x20]
MOV R10D,dword ptr [RBX + 0x8]
CMP R10D,-0x1
JZ 0x00117f88
MOV R11D,dword ptr [R9 + RDX*0x1 + 0x8]
SUB R11D,R10D
MOV R10D,R11D
NEG R10D
CMOVS R10D,R11D
JMP 0x00117f8b
LAB_00117f88:
XOR R10D,R10D
LAB_00117f8b:
MOV R11D,dword ptr [RBX + 0xc]
CMP R11D,-0x1
JZ 0x00117faa
MOV EBP,dword ptr [R9 + RDX*0x1 + 0xc]
SUB EBP,R11D
MOV R11D,EBP
NEG R11D
CMOVS R11D,EBP
ADD R10D,R11D
LAB_00117faa:
MOV R11D,dword ptr [RBX + 0x10]
CMP R11D,-0x1
JZ 0x00117fc9
MOV EBP,dword ptr [R9 + RDX*0x1 + 0x10]
SUB EBP,R11D
MOV R11D,EBP
NEG R11D
CMOVS R11D,EBP
ADD R10D,R11D
LAB_00117fc9:
MOV R11D,dword ptr [RBX + 0x14]
MOV EBP,dword ptr [R9 + RDX*0x1 + 0x14]
CMP R11D,-0x1
JZ 0x00117fe7
SUB EBP,R11D
MOV R11D,EBP
NEG R11D
CMOVS R11D,EBP
JMP 0x00117fec
LAB_00117fe7:
NOT EBP
MOV R11D,EBP
LAB_00117fec:
MOV R15D,dword ptr [R9 + RDX*0x1]
MOV EBP,dword ptr [R9 + RDX*0x1 + 0x4]
SUB R15D,dword ptr [RBX]
SUB EBP,dword ptr [RBX + 0x4]
IMUL R15D,R15D
IMUL EBP,EBP
ADD EBP,R15D
CMP R10D,R8D
JC 0x0011801e
JNZ 0x00118010
CMP EBP,ESI
JC 0x0011801e
LAB_00118010:
CMP R10D,R8D
JNZ 0x0011802c
CMP EBP,ESI
JNZ 0x0011802c
CMP R11D,EDI
JNC 0x0011802c
LAB_0011801e:
ADD R9,RDX
MOV ESI,EBP
MOV EDI,R11D
MOV R8D,R10D
MOV RAX,R9
LAB_0011802c:
ADD RDX,0x18
JMP 0x00117f5d
LAB_00118035:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
long _glfwChooseVideoMode(long param_1,int *param_2)
{
long lVar1;
uint uVar2;
uint uVar3;
int iVar4;
long lVar5;
int iVar6;
uint uVar7;
uint uVar8;
uint uVar9;
long lVar10;
uint uVar11;
uint uVar12;
iVar4 = refreshVideoModes();
lVar10 = 0;
if (iVar4 != 0) {
uVar2 = *(uint *)(param_1 + 0x28);
if ((int)*(uint *)(param_1 + 0x28) < 1) {
uVar2 = 0;
}
uVar7 = 0xffffffff;
uVar8 = 0xffffffff;
uVar9 = 0xffffffff;
for (lVar5 = 0; (ulong)uVar2 * 0x18 - lVar5 != 0; lVar5 = lVar5 + 0x18) {
lVar1 = *(long *)(param_1 + 0x20);
if (param_2[2] == -1) {
uVar11 = 0;
}
else {
uVar12 = *(int *)(lVar1 + 8 + lVar5) - param_2[2];
uVar11 = -uVar12;
if (0 < (int)uVar12) {
uVar11 = uVar12;
}
}
if (param_2[3] != -1) {
iVar6 = *(int *)(lVar1 + 0xc + lVar5) - param_2[3];
iVar4 = -iVar6;
if (0 < iVar6) {
iVar4 = iVar6;
}
uVar11 = uVar11 + iVar4;
}
if (param_2[4] != -1) {
iVar6 = *(int *)(lVar1 + 0x10 + lVar5) - param_2[4];
iVar4 = -iVar6;
if (0 < iVar6) {
iVar4 = iVar6;
}
uVar11 = uVar11 + iVar4;
}
uVar12 = *(uint *)(lVar1 + 0x14 + lVar5);
if (param_2[5] == -1) {
uVar3 = ~uVar12;
}
else {
uVar12 = uVar12 - param_2[5];
uVar3 = -uVar12;
if (0 < (int)uVar12) {
uVar3 = uVar12;
}
}
iVar6 = *(int *)(lVar1 + lVar5) - *param_2;
iVar4 = *(int *)(lVar1 + 4 + lVar5) - param_2[1];
uVar12 = iVar4 * iVar4 + iVar6 * iVar6;
if (((uVar11 < uVar9) || ((uVar11 == uVar9 && (uVar12 < uVar7)))) ||
((uVar11 == uVar9 && ((uVar12 == uVar7 && (uVar3 < uVar8)))))) {
lVar10 = lVar1 + lVar5;
uVar8 = uVar3;
uVar9 = uVar11;
uVar7 = uVar12;
}
}
}
return lVar10;
}
| |
23,601 | translog_scanner_set_last_page | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)
{
my_bool page_ok;
if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))
{
/* It is last file => we can easy find last page address by horizon */
uint pagegrest= LSN_OFFSET(scanner->horizon) % TRANSLOG_PAGE_SIZE;
scanner->last_file_page= (scanner->horizon -
(pagegrest ? pagegrest : TRANSLOG_PAGE_SIZE));
return (0);
}
scanner->last_file_page= scanner->page_addr;
return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0));
} | O0 | c | translog_scanner_set_last_page:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rax
sarq $0x20, %rax
movq -0x10(%rbp), %rcx
movq 0x2008(%rcx), %rcx
sarq $0x20, %rcx
cmpl %ecx, %eax
jne 0x54ca0
movq -0x10(%rbp), %rcx
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq 0x2008(%rcx), %rax
andq $0x1fff, %rax # imm = 0x1FFF
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x2008(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x54c79
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x54c83
movl $0x2000, %eax # imm = 0x2000
movl %eax, -0x24(%rbp)
jmp 0x54c83
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %eax
movl %eax, %eax
subq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x54ccf
movq -0x10(%rbp), %rax
movq 0x2000(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x2010(%rax)
movq -0x10(%rbp), %rdi
addq $0x2010, %rdi # imm = 0x2010
leaq -0x11(%rbp), %rsi
xorl %edx, %edx
callq 0x51c90
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| translog_scanner_set_last_page:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+2000h]
sar rax, 20h
mov rcx, [rbp+var_10]
mov rcx, [rcx+2008h]
sar rcx, 20h
cmp eax, ecx
jnz short loc_54CA0
mov rcx, [rbp+var_10]
mov rax, 0FFFFFFFFh
and rax, [rcx+2008h]
and rax, 1FFFh
mov [rbp+var_18], eax
mov rax, [rbp+var_10]
mov rax, [rax+2008h]
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_54C79
mov eax, [rbp+var_18]
mov [rbp+var_24], eax
jmp short loc_54C83
loc_54C79:
mov eax, 2000h
mov [rbp+var_24], eax
jmp short $+2
loc_54C83:
mov rcx, [rbp+var_20]
mov eax, [rbp+var_24]
mov eax, eax
sub rcx, rax
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov [rbp+var_1], 0
jmp short loc_54CCF
loc_54CA0:
mov rax, [rbp+var_10]
mov rcx, [rax+2000h]
mov rax, [rbp+var_10]
mov [rax+2010h], rcx
mov rdi, [rbp+var_10]
add rdi, 2010h
lea rsi, [rbp+var_11]
xor edx, edx
call translog_get_last_page_addr
mov [rbp+var_1], al
loc_54CCF:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char translog_scanner_set_last_page(_QWORD *a1)
{
unsigned int v2; // [rsp+Ch] [rbp-24h]
bool v3; // [rsp+1Fh] [rbp-11h] BYREF
_QWORD *v4; // [rsp+20h] [rbp-10h]
v4 = a1;
if ( HIDWORD(a1[1024]) == HIDWORD(a1[1025]) )
{
if ( (v4[1025] & 0x1FFF) != 0 )
v2 = v4[1025] & 0x1FFF;
else
v2 = 0x2000;
v4[1026] = v4[1025] - v2;
return 0;
}
else
{
v4[1026] = v4[1024];
return translog_get_last_page_addr(v4 + 1026, &v3, 0);
}
}
| translog_scanner_set_last_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2000]
SAR RAX,0x20
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX + 0x2008]
SAR RCX,0x20
CMP EAX,ECX
JNZ 0x00154ca0
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,0xffffffff
AND RAX,qword ptr [RCX + 0x2008]
AND RAX,0x1fff
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2008]
MOV qword ptr [RBP + -0x20],RAX
CMP dword ptr [RBP + -0x18],0x0
JZ 0x00154c79
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00154c83
LAB_00154c79:
MOV EAX,0x2000
MOV dword ptr [RBP + -0x24],EAX
JMP 0x00154c83
LAB_00154c83:
MOV RCX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RBP + -0x24]
MOV EAX,EAX
SUB RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00154ccf
LAB_00154ca0:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x2000]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2010],RCX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2010
LEA RSI,[RBP + -0x11]
XOR EDX,EDX
CALL 0x00151c90
MOV byte ptr [RBP + -0x1],AL
LAB_00154ccf:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 translog_scanner_set_last_page(long param_1)
{
uint local_2c;
int1 local_19;
long local_18;
int1 local_9;
if ((int)((ulong)*(int8 *)(param_1 + 0x2000) >> 0x20) ==
(int)((ulong)*(int8 *)(param_1 + 0x2008) >> 0x20)) {
local_2c = (uint)*(ulong *)(param_1 + 0x2008) & 0x1fff;
if ((*(ulong *)(param_1 + 0x2008) & 0x1fff) == 0) {
local_2c = 0x2000;
}
*(ulong *)(param_1 + 0x2010) = *(long *)(param_1 + 0x2008) - (ulong)local_2c;
local_9 = 0;
}
else {
*(int8 *)(param_1 + 0x2010) = *(int8 *)(param_1 + 0x2000);
local_18 = param_1;
local_9 = translog_get_last_page_addr(param_1 + 0x2010,&local_19,0);
}
return local_9;
}
| |
23,602 | translog_scanner_set_last_page | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_scanner_set_last_page(TRANSLOG_SCANNER_DATA *scanner)
{
my_bool page_ok;
if (LSN_FILE_NO(scanner->page_addr) == LSN_FILE_NO(scanner->horizon))
{
/* It is last file => we can easy find last page address by horizon */
uint pagegrest= LSN_OFFSET(scanner->horizon) % TRANSLOG_PAGE_SIZE;
scanner->last_file_page= (scanner->horizon -
(pagegrest ? pagegrest : TRANSLOG_PAGE_SIZE));
return (0);
}
scanner->last_file_page= scanner->page_addr;
return (translog_get_last_page_addr(&scanner->last_file_page, &page_ok, 0));
} | O3 | c | translog_scanner_set_last_page:
movq 0x2000(%rdi), %rcx
movq 0x2008(%rdi), %rax
movq %rax, %rdx
xorq %rcx, %rdx
shrq $0x20, %rdx
jne 0x4c00f
movl %eax, %ecx
andl $0x1fff, %ecx # imm = 0x1FFF
movl $0x2000, %edx # imm = 0x2000
cmovnel %ecx, %edx
subq %rdx, %rax
movq %rax, 0x2010(%rdi)
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rcx, 0x2010(%rdi)
addq $0x2010, %rdi # imm = 0x2010
leaq -0x1(%rbp), %rsi
xorl %edx, %edx
callq 0x4a2c2
addq $0x10, %rsp
popq %rbp
retq
| translog_scanner_set_last_page:
mov rcx, [rdi+2000h]
mov rax, [rdi+2008h]
mov rdx, rax
xor rdx, rcx
shr rdx, 20h
jnz short loc_4C00F
mov ecx, eax
and ecx, 1FFFh
mov edx, 2000h
cmovnz edx, ecx
sub rax, rdx
mov [rdi+2010h], rax
xor eax, eax
retn
loc_4C00F:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rdi+2010h], rcx
add rdi, 2010h
lea rsi, [rbp-1]
xor edx, edx
call translog_get_last_page_addr
add rsp, 10h
pop rbp
retn
| char translog_scanner_set_last_page(_QWORD *a1)
{
long long v1; // rcx
unsigned long long v2; // rax
long long v3; // rdx
bool v5; // [rsp-9h] [rbp-9h] BYREF
v1 = a1[1024];
v2 = a1[1025];
if ( (v1 ^ v2) >> 32 )
{
a1[1026] = v1;
return translog_get_last_page_addr(a1 + 1026, &v5, 0);
}
else
{
v3 = 0x2000LL;
if ( (v2 & 0x1FFF) != 0 )
v3 = v2 & 0x1FFF;
a1[1026] = v2 - v3;
return 0;
}
}
| translog_scanner_set_last_page:
MOV RCX,qword ptr [RDI + 0x2000]
MOV RAX,qword ptr [RDI + 0x2008]
MOV RDX,RAX
XOR RDX,RCX
SHR RDX,0x20
JNZ 0x0014c00f
MOV ECX,EAX
AND ECX,0x1fff
MOV EDX,0x2000
CMOVNZ EDX,ECX
SUB RAX,RDX
MOV qword ptr [RDI + 0x2010],RAX
XOR EAX,EAX
RET
LAB_0014c00f:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RDI + 0x2010],RCX
ADD RDI,0x2010
LEA RSI,[RBP + -0x1]
XOR EDX,EDX
CALL 0x0014a2c2
ADD RSP,0x10
POP RBP
RET
|
int8 translog_scanner_set_last_page(long param_1)
{
ulong uVar1;
int8 uVar2;
ulong uVar3;
int1 local_9;
uVar1 = *(ulong *)(param_1 + 0x2008);
if ((uVar1 ^ *(ulong *)(param_1 + 0x2000)) >> 0x20 == 0) {
uVar3 = 0x2000;
if ((uVar1 & 0x1fff) != 0) {
uVar3 = uVar1 & 0x1fff;
}
*(ulong *)(param_1 + 0x2010) = uVar1 - uVar3;
return 0;
}
*(ulong *)(param_1 + 0x2010) = *(ulong *)(param_1 + 0x2000);
uVar2 = translog_get_last_page_addr(param_1 + 0x2010,&local_9,0);
return uVar2;
}
| |
23,603 | ma_hex2int | eloqsql/libmariadb/libmariadb/ma_tls.c | static signed char ma_hex2int(char c)
{
if (c >= '0' && c <= '9')
return c - '0';
if (c >= 'A' && c <= 'F')
return 10 + c - 'A';
if (c >= 'a' && c <= 'f')
return 10 + c - 'a';
return -1;
} | O0 | c | ma_hex2int:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jl 0x2c778
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x2c778
movsbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0x2c7be
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0x2c799
movsbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0x2c799
movsbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x2c7be
movsbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0x2c7ba
movsbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0x2c7ba
movsbl -0x2(%rbp), %eax
addl $0xa, %eax
subl $0x61, %eax
movb %al, -0x1(%rbp)
jmp 0x2c7be
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| ma_hex2int:
push rbp
mov rbp, rsp
mov al, dil
mov [rbp+var_2], al
movsx eax, [rbp+var_2]
cmp eax, 30h ; '0'
jl short loc_2C778
movsx eax, [rbp+var_2]
cmp eax, 39h ; '9'
jg short loc_2C778
movsx eax, [rbp+var_2]
sub eax, 30h ; '0'
mov [rbp+var_1], al
jmp short loc_2C7BE
loc_2C778:
movsx eax, [rbp+var_2]
cmp eax, 41h ; 'A'
jl short loc_2C799
movsx eax, [rbp+var_2]
cmp eax, 46h ; 'F'
jg short loc_2C799
movsx eax, [rbp+var_2]
add eax, 0Ah
sub eax, 41h ; 'A'
mov [rbp+var_1], al
jmp short loc_2C7BE
loc_2C799:
movsx eax, [rbp+var_2]
cmp eax, 61h ; 'a'
jl short loc_2C7BA
movsx eax, [rbp+var_2]
cmp eax, 66h ; 'f'
jg short loc_2C7BA
movsx eax, [rbp+var_2]
add eax, 0Ah
sub eax, 61h ; 'a'
mov [rbp+var_1], al
jmp short loc_2C7BE
loc_2C7BA:
mov [rbp+var_1], 0FFh
loc_2C7BE:
mov al, [rbp+var_1]
pop rbp
retn
| char ma_hex2int(char a1)
{
if ( a1 >= 48 && a1 <= 57 )
return a1 - 48;
if ( a1 >= 65 && a1 <= 70 )
return a1 - 55;
if ( a1 < 97 || a1 > 102 )
return -1;
return a1 - 87;
}
| ma_hex2int:
PUSH RBP
MOV RBP,RSP
MOV AL,DIL
MOV byte ptr [RBP + -0x2],AL
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x30
JL 0x0012c778
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x39
JG 0x0012c778
MOVSX EAX,byte ptr [RBP + -0x2]
SUB EAX,0x30
MOV byte ptr [RBP + -0x1],AL
JMP 0x0012c7be
LAB_0012c778:
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x41
JL 0x0012c799
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x46
JG 0x0012c799
MOVSX EAX,byte ptr [RBP + -0x2]
ADD EAX,0xa
SUB EAX,0x41
MOV byte ptr [RBP + -0x1],AL
JMP 0x0012c7be
LAB_0012c799:
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x61
JL 0x0012c7ba
MOVSX EAX,byte ptr [RBP + -0x2]
CMP EAX,0x66
JG 0x0012c7ba
MOVSX EAX,byte ptr [RBP + -0x2]
ADD EAX,0xa
SUB EAX,0x61
MOV byte ptr [RBP + -0x1],AL
JMP 0x0012c7be
LAB_0012c7ba:
MOV byte ptr [RBP + -0x1],0xff
LAB_0012c7be:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int8 ma_hex2int(char param_1)
{
ulong uVar1;
int1 local_9;
if ((param_1 < '0') || ('9' < param_1)) {
if ((param_1 < 'A') || ('F' < param_1)) {
if ((param_1 < 'a') || ('f' < param_1)) {
uVar1 = (ulong)(uint)(int)param_1;
local_9 = 0xff;
}
else {
uVar1 = (ulong)((int)param_1 - 0x57U);
local_9 = (int1)((int)param_1 - 0x57U);
}
}
else {
uVar1 = (ulong)((int)param_1 - 0x37U);
local_9 = (int1)((int)param_1 - 0x37U);
}
}
else {
uVar1 = (ulong)((int)param_1 - 0x30U);
local_9 = (int1)((int)param_1 - 0x30U);
}
return CONCAT71((int7)(uVar1 >> 8),local_9);
}
| |
23,604 | ma_SHA1Final | eloqsql/libmariadb/libmariadb/ma_sha1.c | void ma_SHA1Final(unsigned char digest[20], _MA_SHA1_CTX * context)
{
unsigned char bits[8];
unsigned int index, padLen;
/* Save number of bits */
bits[7] = context->count[0] & 0xFF;
bits[6] = (context->count[0] >> 8) & 0xFF;
bits[5] = (context->count[0] >> 16) & 0xFF;
bits[4] = (context->count[0] >> 24) & 0xFF;
bits[3] = context->count[1] & 0xFF;
bits[2] = (context->count[1] >> 8) & 0xFF;
bits[1] = (context->count[1] >> 16) & 0xFF;
bits[0] = (context->count[1] >> 24) & 0xFF;
/* Pad out to 56 mod 64.
*/
index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) ? (56 - index) : (120 - index);
ma_SHA1Update(context, PADDING, padLen);
/* Append length (before padding) */
ma_SHA1Update(context, bits, 8);
/* Store state in digest */
ma_SHA1Encode(digest, context->state, 20);
/* Zeroize sensitive information.
*/
memset((unsigned char*) context, 0, sizeof(*context));
} | O3 | c | ma_SHA1Final:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movl 0x14(%rsi), %eax
movl %eax, %ecx
bswapl %ecx
leaq -0x28(%rbp), %r15
movl %ecx, 0x4(%r15)
movl 0x18(%rsi), %ecx
bswapl %ecx
movl %ecx, (%r15)
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orl $0x38, %edx
subl %eax, %edx
leaq 0x1678c(%rip), %rsi # 0x4adc0
movq %rbx, %rdi
callq 0x33458
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x33458
xorl %eax, %eax
movb 0x3(%rbx,%rax,4), %cl
movb %cl, (%r14,%rax,4)
movb 0x2(%rbx,%rax,4), %cl
movb %cl, 0x1(%r14,%rax,4)
movb 0x1(%rbx,%rax,4), %cl
movb %cl, 0x2(%r14,%rax,4)
movb (%rbx,%rax,4), %cl
movb %cl, 0x3(%r14,%rax,4)
incq %rax
cmpq $0x5, %rax
jne 0x3464e
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x346ad
xorps %xmm0, %xmm0
movups %xmm0, 0x4c(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x30(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_SHA1Final:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
mov eax, [rsi+14h]
mov ecx, eax
bswap ecx
lea r15, [rbp+var_28]
mov [r15+4], ecx
mov ecx, [rsi+18h]
bswap ecx
mov [r15], ecx
shr eax, 3
and eax, 3Fh
xor edx, edx
cmp eax, 38h ; '8'
setnb dl
shl edx, 6
or edx, 38h
sub edx, eax
lea rsi, PADDING
mov rdi, rbx
call ma_SHA1Update
mov edx, 8
mov rdi, rbx
mov rsi, r15
call ma_SHA1Update
xor eax, eax
loc_3464E:
mov cl, [rbx+rax*4+3]
mov [r14+rax*4], cl
mov cl, [rbx+rax*4+2]
mov [r14+rax*4+1], cl
mov cl, [rbx+rax*4+1]
mov [r14+rax*4+2], cl
mov cl, [rbx+rax*4]
mov [r14+rax*4+3], cl
inc rax
cmp rax, 5
jnz short loc_3464E
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_346AD
xorps xmm0, xmm0
movups xmmword ptr [rbx+4Ch], xmm0
movups xmmword ptr [rbx+40h], xmm0
movups xmmword ptr [rbx+30h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_346AD:
call ___stack_chk_fail
| unsigned long long ma_SHA1Final(long long a1, long long a2)
{
unsigned int v2; // eax
long long i; // rax
unsigned long long result; // rax
_DWORD v5[2]; // [rsp+8h] [rbp-28h] BYREF
unsigned long long v6; // [rsp+10h] [rbp-20h]
v6 = __readfsqword(0x28u);
v2 = *(_DWORD *)(a2 + 20);
v5[1] = _byteswap_ulong(v2);
v5[0] = _byteswap_ulong(*(_DWORD *)(a2 + 24));
ma_SHA1Update(a2, (long long)&PADDING, (((((v2 >> 3) & 0x3F) >= 0x38) << 6) | 0x38) - ((v2 >> 3) & 0x3F));
ma_SHA1Update(a2, (long long)v5, 8uLL);
for ( i = 0LL; i != 5; ++i )
{
*(_BYTE *)(a1 + 4 * i) = *(_BYTE *)(a2 + 4 * i + 3);
*(_BYTE *)(a1 + 4 * i + 1) = *(_BYTE *)(a2 + 4 * i + 2);
*(_BYTE *)(a1 + 4 * i + 2) = *(_BYTE *)(a2 + 4 * i + 1);
*(_BYTE *)(a1 + 4 * i + 3) = *(_BYTE *)(a2 + 4 * i);
}
result = __readfsqword(0x28u);
*(_OWORD *)(a2 + 76) = 0LL;
*(_OWORD *)(a2 + 64) = 0LL;
*(_OWORD *)(a2 + 48) = 0LL;
*(_OWORD *)(a2 + 32) = 0LL;
*(_OWORD *)(a2 + 16) = 0LL;
*(_OWORD *)a2 = 0LL;
return result;
}
| ma_SHA1Final:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV EAX,dword ptr [RSI + 0x14]
MOV ECX,EAX
BSWAP ECX
LEA R15,[RBP + -0x28]
MOV dword ptr [R15 + 0x4],ECX
MOV ECX,dword ptr [RSI + 0x18]
BSWAP ECX
MOV dword ptr [R15],ECX
SHR EAX,0x3
AND EAX,0x3f
XOR EDX,EDX
CMP EAX,0x38
SETNC DL
SHL EDX,0x6
OR EDX,0x38
SUB EDX,EAX
LEA RSI,[0x14adc0]
MOV RDI,RBX
CALL 0x00133458
MOV EDX,0x8
MOV RDI,RBX
MOV RSI,R15
CALL 0x00133458
XOR EAX,EAX
LAB_0013464e:
MOV CL,byte ptr [RBX + RAX*0x4 + 0x3]
MOV byte ptr [R14 + RAX*0x4],CL
MOV CL,byte ptr [RBX + RAX*0x4 + 0x2]
MOV byte ptr [R14 + RAX*0x4 + 0x1],CL
MOV CL,byte ptr [RBX + RAX*0x4 + 0x1]
MOV byte ptr [R14 + RAX*0x4 + 0x2],CL
MOV CL,byte ptr [RBX + RAX*0x4]
MOV byte ptr [R14 + RAX*0x4 + 0x3],CL
INC RAX
CMP RAX,0x5
JNZ 0x0013464e
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001346ad
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x4c],XMM0
MOVUPS xmmword ptr [RBX + 0x40],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001346ad:
CALL 0x00113500
|
void ma_SHA1Final(long param_1,int8 *param_2)
{
uint uVar1;
uint uVar2;
long lVar3;
long in_FS_OFFSET;
uint local_30;
uint local_2c;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = *(uint *)((long)param_2 + 0x14);
local_2c = uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18;
uVar1 = *(uint *)(param_2 + 3);
local_30 = uVar1 >> 0x18 | (uVar1 & 0xff0000) >> 8 | (uVar1 & 0xff00) << 8 | uVar1 << 0x18;
uVar2 = uVar2 >> 3 & 0x3f;
ma_SHA1Update(param_2,PADDING,((uint)(0x37 < uVar2) << 6 | 0x38) - uVar2);
ma_SHA1Update(param_2,&local_30,8);
lVar3 = 0;
do {
*(int1 *)(param_1 + lVar3 * 4) = *(int1 *)((long)param_2 + lVar3 * 4 + 3);
*(int1 *)(param_1 + 1 + lVar3 * 4) = *(int1 *)((long)param_2 + lVar3 * 4 + 2);
*(int1 *)(param_1 + 2 + lVar3 * 4) = *(int1 *)((long)param_2 + lVar3 * 4 + 1);
*(int1 *)(param_1 + 3 + lVar3 * 4) = *(int1 *)((long)param_2 + lVar3 * 4);
lVar3 = lVar3 + 1;
} while (lVar3 != 5);
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
*(int8 *)((long)param_2 + 0x4c) = 0;
*(int8 *)((long)param_2 + 0x54) = 0;
param_2[8] = 0;
param_2[9] = 0;
param_2[6] = 0;
param_2[7] = 0;
param_2[4] = 0;
param_2[5] = 0;
param_2[2] = 0;
param_2[3] = 0;
*param_2 = 0;
param_2[1] = 0;
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,605 | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
if (m_full)
{
m_lost++;
return NULL;
}
uint index;
uint monotonic;
uint monotonic_max;
uint current_page_count;
value_type *pfs;
array_type *array;
void *addr;
void * volatile * typed_addr;
void *ptr;
/*
1: Try to find an available record within the existing pages
*/
current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
if (current_page_count != 0)
{
monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32);
monotonic_max= monotonic + current_page_count;
while (monotonic < monotonic_max)
{
/*
Scan in the [0 .. current_page_count - 1] range,
in parallel with m_monotonic (see below)
*/
index= monotonic % current_page_count;
/* Atomic Load, array= m_pages[index] */
addr= & m_pages[index];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array != NULL)
{
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
}
/*
Parallel scans collaborate to increase
the common monotonic scan counter.
Note that when all the existing page are full,
one thread will eventually add a new page,
and cause m_max_page_index to increase,
which fools all the modulo logic for scans already in progress,
because the monotonic counter is not folded to the same place
(sometime modulo N, sometime modulo N+1).
This is actually ok: since all the pages are full anyway,
there is nothing to miss, so better increase the monotonic
counter faster and then move on to the detection of new pages,
in part 2: below.
*/
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
};
}
/*
2: Try to add a new page, beyond the m_max_page_index limit
*/
while (current_page_count < m_max_page_count)
{
/* Peek for pages added by collaborating threads */
/* (2-a) Atomic Load, array= m_pages[current_page_count] */
addr= & m_pages[current_page_count];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
// ==================================================================
// BEGIN CRITICAL SECTION -- buffer expand
// ==================================================================
/*
On a fresh started server, buffers are typically empty.
When a sudden load spike is seen by the server,
multiple threads may want to expand the buffer at the same time.
Using a compare and swap to allow multiple pages to be added,
possibly freeing duplicate pages on collisions,
does not work well because the amount of code involved
when creating a new page can be significant (PFS_thread),
causing MANY collisions between (2-b) and (2-d).
A huge number of collisions (which can happen when thousands
of new connections hits the server after a restart)
leads to a huge memory consumption, and to OOM.
To mitigate this, we use here a mutex,
to enforce that only ONE page is added at a time,
so that scaling the buffer happens in a predictable
and controlled manner.
*/
pthread_mutex_lock(& m_critical_section);
/*
Peek again for pages added by collaborating threads,
this time as the only thread allowed to expand the buffer
*/
/* (2-b) Atomic Load, array= m_pages[current_page_count] */
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
/* (2-c) Found no page, allocate a new one */
array= new array_type();
builtin_memory_scalable_buffer.count_alloc(sizeof (array_type));
array->m_max= get_page_logical_size(current_page_count);
int rc= m_allocator->alloc_array(array);
if (rc != 0)
{
m_allocator->free_array(array);
delete array;
builtin_memory_scalable_buffer.count_free(sizeof (array_type));
m_lost++;
pthread_mutex_unlock(& m_critical_section);
return NULL;
}
/* Keep a pointer to this container, for static_deallocate(). */
array->m_container= reinterpret_cast<PFS_opaque_container *> (this);
/* (2-d) Atomic STORE, m_pages[current_page_count] = array */
ptr= array;
my_atomic_storeptr(typed_addr, ptr);
/* Advertise the new page */
PFS_atomic::add_u32(& m_max_page_index.m_u32, 1);
}
pthread_mutex_unlock(& m_critical_section);
// ==================================================================
// END CRITICAL SECTION -- buffer expand
// ==================================================================
}
assert(array != NULL);
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
current_page_count++;
}
m_lost++;
m_full= true;
return NULL;
} | O0 | c | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
testb $0x1, 0x9(%rax)
je 0x534b2
movq -0x88(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x53802
movq -0x88(%rbp), %rdi
addq $0x58, %rdi
callq 0x378b0
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x53596
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
callq 0x378b0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x53594
movl -0x20(%rbp), %eax
movl -0x28(%rbp), %ecx
xorl %edx, %edx
divl %ecx
movq -0x88(%rbp), %rax
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
leaq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x53577
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x538c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x53575
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53802
jmp 0x53577
movq -0x88(%rbp), %rdi
addq $0x18, %rdi
movl $0x1, %esi
callq 0x379a0
movl %eax, -0x20(%rbp)
jmp 0x534eb
jmp 0x53596
jmp 0x53598
movq -0x88(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpq 0x98(%rcx), %rax
jae 0x537e5
movq -0x88(%rbp), %rax
movl -0x28(%rbp), %ecx
leaq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x537a9
movq -0x88(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x264b0
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x53796
movl $0x60, %edi
callq 0x26310
movq %rax, %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rdi)
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
callq 0x53990
jmp 0x5366b
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x3b6603(%rip), %rdi # 0x409c80
movl $0x60, %esi
callq 0x379f0
movq -0x88(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x539b0
movl %eax, %ecx
movq -0x88(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq -0x38(%rbp), %rcx
movq %rdx, 0x50(%rcx)
movq 0x20a8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x539f0
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
je 0x5375e
movq -0x88(%rbp), %rax
movq 0x20a8(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x53870
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x53701
movq -0xa0(%rbp), %rdi
movl $0x60, %esi
callq 0x26320
leaq 0x3b6578(%rip), %rdi # 0x409c80
movl $0x60, %esi
callq 0x37b00
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
addq $0x1, %rax
movq %rax, (%rdi)
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x26260
movq $0x0, -0x8(%rbp)
jmp 0x53802
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
movl $0x60, %esi
callq 0x26320
jmp 0x5380f
movq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rdi, 0x58(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
xchgq %rax, (%rcx)
addq $0x58, %rdi
movl $0x1, %esi
callq 0x379a0
movq -0x88(%rbp), %rdi
addq $0x20b0, %rdi # imm = 0x20B0
callq 0x26260
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x538c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x537d7
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x53802
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x53598
movq -0x88(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, 0x9(%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x265e0
nopl (%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI11PFS_programLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_88], rax
test byte ptr [rax+9], 1
jz short loc_534B2
mov rax, [rbp+var_88]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov [rbp+var_8], 0
jmp loc_53802
loc_534B2:
mov rdi, [rbp+var_88]
add rdi, 58h ; 'X'; this
call _ZN10PFS_atomic8load_u32EPj; PFS_atomic::load_u32(uint *)
mov [rbp+var_28], eax
cmp [rbp+var_28], 0
jz loc_53596
mov rdi, [rbp+var_88]
add rdi, 18h; this
call _ZN10PFS_atomic8load_u32EPj; PFS_atomic::load_u32(uint *)
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add eax, [rbp+var_28]
mov [rbp+var_24], eax
loc_534EB:
mov eax, [rbp+var_20]
cmp eax, [rbp+var_24]
jnb loc_53594
mov eax, [rbp+var_20]
mov ecx, [rbp+var_28]
xor edx, edx; unsigned int
div ecx
mov rax, [rbp+var_88]
mov [rbp+var_1C], edx
mov ecx, [rbp+var_1C]
lea rax, [rax+rcx*8+0A8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_58], rax
mov rax, [rbp+var_58]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jz short loc_53577
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
call _ZN24PFS_buffer_default_arrayI11PFS_programE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state *)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_53575
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp loc_53802
loc_53575:
jmp short $+2
loc_53577:
mov rdi, [rbp+var_88]
add rdi, 18h; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
mov [rbp+var_20], eax
jmp loc_534EB
loc_53594:
jmp short $+2
loc_53596:
jmp short $+2
loc_53598:
mov rcx, [rbp+var_88]
mov eax, [rbp+var_28]
cmp rax, [rcx+98h]
jnb loc_537E5
mov rax, [rbp+var_88]
mov ecx, [rbp+var_28]
lea rax, [rax+rcx*8+0A8h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_48], rax
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz loc_537A9
mov rdi, [rbp+var_88]
add rdi, 20B0h
call _pthread_mutex_lock
mov rax, [rbp+var_48]
mov rax, [rax]
mov [rbp+var_68], rax
mov rax, [rbp+var_68]
mov [rbp+var_50], rax
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
cmp [rbp+var_38], 0
jnz loc_53796
mov edi, 60h ; '`'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov [rbp+var_98], rdi
mov rax, rdi
mov [rbp+var_90], rax
xorps xmm0, xmm0
movaps xmmword ptr [rdi+50h], xmm0
movaps xmmword ptr [rdi+40h], xmm0
movaps xmmword ptr [rdi+30h], xmm0
movaps xmmword ptr [rdi+20h], xmm0
movaps xmmword ptr [rdi+10h], xmm0
movaps xmmword ptr [rdi], xmm0
call _ZN24PFS_buffer_default_arrayI11PFS_programEC2Ev; PFS_buffer_default_array<PFS_program>::PFS_buffer_default_array(void)
jmp short $+2
loc_5366B:
mov rax, [rbp+var_90]
mov [rbp+var_38], rax
lea rdi, builtin_memory_scalable_buffer; this
mov esi, 60h ; '`'; unsigned __int64
call _ZN24PFS_builtin_memory_class11count_allocEm; PFS_builtin_memory_class::count_alloc(ulong)
mov rdi, [rbp+var_88]
mov esi, [rbp+var_28]
call _ZN29PFS_buffer_scalable_containerI11PFS_programLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE21get_page_logical_sizeEj; PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>::get_page_logical_size(uint)
mov ecx, eax
mov rax, [rbp+var_88]
mov ecx, ecx
mov edx, ecx
mov rcx, [rbp+var_38]
mov [rcx+50h], rdx
mov rdi, [rax+20A8h]
mov rsi, [rbp+var_38]
call _ZN28PFS_buffer_default_allocatorI11PFS_programE11alloc_arrayEP24PFS_buffer_default_arrayIS0_E; PFS_buffer_default_allocator<PFS_program>::alloc_array(PFS_buffer_default_array<PFS_program> *)
mov [rbp+var_78], eax
cmp [rbp+var_78], 0
jz loc_5375E
mov rax, [rbp+var_88]
mov rdi, [rax+20A8h]
mov rsi, [rbp+var_38]
call _ZN28PFS_buffer_default_allocatorI11PFS_programE10free_arrayEP24PFS_buffer_default_arrayIS0_E; PFS_buffer_default_allocator<PFS_program>::free_array(PFS_buffer_default_array<PFS_program> *)
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
cmp rax, 0
jz short loc_53701
mov rdi, [rbp+var_A0]; void *
mov esi, 60h ; '`'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_53701:
lea rdi, builtin_memory_scalable_buffer; this
mov esi, 60h ; '`'; unsigned __int64
call _ZN24PFS_builtin_memory_class10count_freeEm; PFS_builtin_memory_class::count_free(ulong)
mov rdi, [rbp+var_88]
mov rax, [rdi]
add rax, 1
mov [rdi], rax
add rdi, 20B0h
call _pthread_mutex_unlock
mov [rbp+var_8], 0
jmp loc_53802
mov rdi, [rbp+var_90]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
mov esi, 60h ; '`'; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp loc_5380F
loc_5375E:
mov rdi, [rbp+var_88]
mov rax, [rbp+var_38]
mov [rax+58h], rdi
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
mov rcx, [rbp+var_48]
mov rax, [rbp+var_50]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
xchg rax, [rcx]
add rdi, 58h ; 'X'; this
mov esi, (offset dword_0+1); unsigned int *
call _ZN10PFS_atomic7add_u32EPjj; PFS_atomic::add_u32(uint *,uint)
loc_53796:
mov rdi, [rbp+var_88]
add rdi, 20B0h
call _pthread_mutex_unlock
loc_537A9:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
call _ZN24PFS_buffer_default_arrayI11PFS_programE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_program>::allocate(pfs_dirty_state *)
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jz short loc_537D7
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
mov [rax+8], rcx
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_53802
loc_537D7:
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
jmp loc_53598
loc_537E5:
mov rax, [rbp+var_88]
mov rcx, [rax]
add rcx, 1
mov [rax], rcx
mov byte ptr [rax+9], 1
mov [rbp+var_8], 0
loc_53802:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
loc_5380F:
mov rdi, [rbp+var_70]
call __Unwind_Resume
| long long PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>::allocate(
long long a1,
unsigned int *a2)
{
_OWORD *v3; // [rsp+10h] [rbp-90h]
volatile long long *v4; // [rsp+58h] [rbp-48h]
long long v5; // [rsp+68h] [rbp-38h]
volatile long long v6; // [rsp+68h] [rbp-38h]
long long v7; // [rsp+70h] [rbp-30h]
long long v8; // [rsp+70h] [rbp-30h]
unsigned int u32; // [rsp+78h] [rbp-28h]
unsigned int v10; // [rsp+7Ch] [rbp-24h]
unsigned int v11; // [rsp+80h] [rbp-20h]
if ( (*(_BYTE *)(a1 + 9) & 1) != 0 )
{
++*(_QWORD *)a1;
return 0LL;
}
u32 = PFS_atomic::load_u32((PFS_atomic *)(a1 + 88), a2);
if ( !u32 )
goto LABEL_10;
v11 = PFS_atomic::load_u32((PFS_atomic *)(a1 + 24), a2);
v10 = u32 + v11;
while ( v11 < v10 )
{
v5 = *(_QWORD *)(a1 + 8LL * (v11 % u32) + 168);
if ( v5 )
{
v7 = PFS_buffer_default_array<PFS_program>::allocate(v5, a2);
if ( v7 )
{
*(_QWORD *)(v7 + 8) = v5;
return v7;
}
}
v11 = PFS_atomic::add_u32((PFS_atomic *)(a1 + 24), (unsigned int *)((char *)&dword_0 + 1));
}
while ( 1 )
{
LABEL_10:
if ( (unsigned long long)u32 >= *(_QWORD *)(a1 + 152) )
{
++*(_QWORD *)a1;
*(_BYTE *)(a1 + 9) = 1;
return 0LL;
}
v4 = (volatile long long *)(a1 + 8LL * u32 + 168);
v6 = *v4;
if ( !*v4 )
break;
LABEL_19:
v8 = PFS_buffer_default_array<PFS_program>::allocate(v6, a2);
if ( v8 )
{
*(_QWORD *)(v8 + 8) = v6;
return v8;
}
++u32;
}
pthread_mutex_lock(a1 + 8368);
v6 = *v4;
if ( *v4 )
{
LABEL_18:
pthread_mutex_unlock(a1 + 8368);
goto LABEL_19;
}
v3 = (_OWORD *)operator new(0x60uLL);
v3[5] = 0LL;
v3[4] = 0LL;
v3[3] = 0LL;
v3[2] = 0LL;
v3[1] = 0LL;
*v3 = 0LL;
PFS_buffer_default_array<PFS_program>::PFS_buffer_default_array();
v6 = (volatile long long)v3;
PFS_builtin_memory_class::count_alloc((PFS_builtin_memory_class *)&builtin_memory_scalable_buffer, 0x60uLL);
*((_QWORD *)v3 + 10) = (unsigned int)PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>::get_page_logical_size(
a1,
u32);
if ( !(unsigned int)PFS_buffer_default_allocator<PFS_program>::alloc_array(*(_QWORD *)(a1 + 8360), v3) )
{
*((_QWORD *)v3 + 11) = a1;
_InterlockedExchange64(v4, (long long)v3);
PFS_atomic::add_u32((PFS_atomic *)(a1 + 88), (unsigned int *)((char *)&dword_0 + 1));
goto LABEL_18;
}
PFS_buffer_default_allocator<PFS_program>::free_array(*(_QWORD *)(a1 + 8360), v3);
if ( v3 )
operator delete(v3, 0x60uLL);
PFS_builtin_memory_class::count_free((PFS_builtin_memory_class *)&builtin_memory_scalable_buffer, 0x60uLL);
++*(_QWORD *)a1;
pthread_mutex_unlock(a1 + 8368);
return 0LL;
}
| allocate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x88],RAX
TEST byte ptr [RAX + 0x9],0x1
JZ 0x001534b2
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00153802
LAB_001534b2:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x58
CALL 0x001378b0
MOV dword ptr [RBP + -0x28],EAX
CMP dword ptr [RBP + -0x28],0x0
JZ 0x00153596
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x18
CALL 0x001378b0
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x24],EAX
LAB_001534eb:
MOV EAX,dword ptr [RBP + -0x20]
CMP EAX,dword ptr [RBP + -0x24]
JNC 0x00153594
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x28]
XOR EDX,EDX
DIV ECX
MOV RAX,qword ptr [RBP + -0x88]
MOV dword ptr [RBP + -0x1c],EDX
MOV ECX,dword ptr [RBP + -0x1c]
LEA RAX,[RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JZ 0x00153577
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001538c0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00153575
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00153802
LAB_00153575:
JMP 0x00153577
LAB_00153577:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x18
MOV ESI,0x1
CALL 0x001379a0
MOV dword ptr [RBP + -0x20],EAX
JMP 0x001534eb
LAB_00153594:
JMP 0x00153596
LAB_00153596:
JMP 0x00153598
LAB_00153598:
MOV RCX,qword ptr [RBP + -0x88]
MOV EAX,dword ptr [RBP + -0x28]
CMP RAX,qword ptr [RCX + 0x98]
JNC 0x001537e5
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RBP + -0x28]
LEA RAX,[RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001537a9
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x20b0
CALL 0x001264b0
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00153796
MOV EDI,0x60
CALL 0x00126310
MOV RDI,RAX
MOV qword ptr [RBP + -0x98],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x90],RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RDI + 0x50],XMM0
MOVAPS xmmword ptr [RDI + 0x40],XMM0
MOVAPS xmmword ptr [RDI + 0x30],XMM0
MOVAPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS xmmword ptr [RDI],XMM0
LAB_00153664:
CALL 0x00153990
LAB_00153669:
JMP 0x0015366b
LAB_0015366b:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x38],RAX
LEA RDI,[0x509c80]
MOV ESI,0x60
CALL 0x001379f0
MOV RDI,qword ptr [RBP + -0x88]
MOV ESI,dword ptr [RBP + -0x28]
CALL 0x001539b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV ECX,ECX
MOV EDX,ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV qword ptr [RCX + 0x50],RDX
MOV RDI,qword ptr [RAX + 0x20a8]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x001539f0
MOV dword ptr [RBP + -0x78],EAX
CMP dword ptr [RBP + -0x78],0x0
JZ 0x0015375e
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,qword ptr [RAX + 0x20a8]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00153870
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
CMP RAX,0x0
JZ 0x00153701
MOV RDI,qword ptr [RBP + -0xa0]
MOV ESI,0x60
CALL 0x00126320
LAB_00153701:
LEA RDI,[0x509c80]
MOV ESI,0x60
CALL 0x00137b00
MOV RDI,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RDI]
ADD RAX,0x1
MOV qword ptr [RDI],RAX
ADD RDI,0x20b0
CALL 0x00126260
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00153802
LAB_0015375e:
MOV RDI,qword ptr [RBP + -0x88]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x58],RDI
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
MOV RCX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
XCHG qword ptr [RCX],RAX
ADD RDI,0x58
MOV ESI,0x1
CALL 0x001379a0
LAB_00153796:
MOV RDI,qword ptr [RBP + -0x88]
ADD RDI,0x20b0
CALL 0x00126260
LAB_001537a9:
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001538c0
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x001537d7
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00153802
LAB_001537d7:
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00153598
LAB_001537e5:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RAX]
ADD RCX,0x1
MOV qword ptr [RAX],RCX
MOV byte ptr [RAX + 0x9],0x1
MOV qword ptr [RBP + -0x8],0x0
LAB_00153802:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>,
PFS_buffer_default_allocator<PFS_program> >::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
::allocate(PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
*this,pfs_dirty_state *param_1)
{
PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
*pPVar1;
PFS_buffer_default_array<PFS_program> *this_00;
uint uVar2;
int iVar3;
long lVar4;
PFS_buffer_default_array<PFS_program> *local_40;
uint local_30;
uint local_28;
if (((byte)this[9] & 1) == 0) {
local_30 = PFS_atomic::load_u32((uint *)(this + 0x58));
if (local_30 != 0) {
local_28 = PFS_atomic::load_u32((uint *)(this + 0x18));
uVar2 = local_28 + local_30;
while (local_28 < uVar2) {
this_00 = *(PFS_buffer_default_array<PFS_program> **)
(this + (ulong)(local_28 % local_30) * 8 + 0xa8);
if ((this_00 != (PFS_buffer_default_array<PFS_program> *)0x0) &&
(lVar4 = PFS_buffer_default_array<PFS_program>::allocate(this_00,param_1), lVar4 != 0)) {
*(PFS_buffer_default_array<PFS_program> **)(lVar4 + 8) = this_00;
return lVar4;
}
local_28 = PFS_atomic::add_u32((uint *)(this + 0x18),1);
}
}
for (; (ulong)local_30 < *(ulong *)(this + 0x98); local_30 = local_30 + 1) {
pPVar1 = this + (ulong)local_30 * 8 + 0xa8;
local_40 = *(PFS_buffer_default_array<PFS_program> **)pPVar1;
if (local_40 == (PFS_buffer_default_array<PFS_program> *)0x0) {
pthread_mutex_lock((pthread_mutex_t *)(this + 0x20b0));
local_40 = *(PFS_buffer_default_array<PFS_program> **)pPVar1;
if (local_40 == (PFS_buffer_default_array<PFS_program> *)0x0) {
local_40 = (PFS_buffer_default_array<PFS_program> *)operator_new(0x60);
*(int8 *)(local_40 + 0x50) = 0;
*(int8 *)(local_40 + 0x58) = 0;
*(int8 *)(local_40 + 0x40) = 0;
*(int8 *)(local_40 + 0x48) = 0;
*(int8 *)(local_40 + 0x30) = 0;
*(int8 *)(local_40 + 0x38) = 0;
*(int8 *)(local_40 + 0x20) = 0;
*(int8 *)(local_40 + 0x28) = 0;
*(int8 *)(local_40 + 0x10) = 0;
*(int8 *)(local_40 + 0x18) = 0;
*(int8 *)local_40 = 0;
*(int8 *)(local_40 + 8) = 0;
/* try { // try from 00153664 to 00153668 has its CatchHandler @ 0015373c */
PFS_buffer_default_array<PFS_program>::PFS_buffer_default_array(local_40);
PFS_builtin_memory_class::count_alloc
((PFS_builtin_memory_class *)builtin_memory_scalable_buffer,0x60);
uVar2 = get_page_logical_size(this,local_30);
*(ulong *)(local_40 + 0x50) = (ulong)uVar2;
iVar3 = PFS_buffer_default_allocator<PFS_program>::alloc_array
(*(PFS_buffer_default_allocator<PFS_program> **)(this + 0x20a8),
(PFS_buffer_default_array *)local_40);
if (iVar3 != 0) {
PFS_buffer_default_allocator<PFS_program>::free_array
(*(PFS_buffer_default_allocator<PFS_program> **)(this + 0x20a8),
(PFS_buffer_default_array *)local_40);
if (local_40 != (PFS_buffer_default_array<PFS_program> *)0x0) {
operator_delete(local_40,0x60);
}
PFS_builtin_memory_class::count_free
((PFS_builtin_memory_class *)builtin_memory_scalable_buffer,0x60);
*(long *)this = *(long *)this + 1;
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x20b0));
return 0;
}
*(PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
**)(local_40 + 0x58) = this;
LOCK();
*(PFS_buffer_default_array<PFS_program> **)pPVar1 = local_40;
UNLOCK();
PFS_atomic::add_u32((uint *)(this + 0x58),1);
}
pthread_mutex_unlock((pthread_mutex_t *)(this + 0x20b0));
}
lVar4 = PFS_buffer_default_array<PFS_program>::allocate(local_40,param_1);
if (lVar4 != 0) {
*(PFS_buffer_default_array<PFS_program> **)(lVar4 + 8) = local_40;
return lVar4;
}
}
*(long *)this = *(long *)this + 1;
this[9] = (PFS_buffer_scalable_container<PFS_program,1024,1024,PFS_buffer_default_array<PFS_program>,PFS_buffer_default_allocator<PFS_program>>
)0x1;
}
else {
*(long *)this = *(long *)this + 1;
}
return 0;
}
| |
23,606 | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::allocate(pfs_dirty_state*) | eloqsql/storage/perfschema/pfs_buffer_container.h | value_type *allocate(pfs_dirty_state *dirty_state)
{
if (m_full)
{
m_lost++;
return NULL;
}
uint index;
uint monotonic;
uint monotonic_max;
uint current_page_count;
value_type *pfs;
array_type *array;
void *addr;
void * volatile * typed_addr;
void *ptr;
/*
1: Try to find an available record within the existing pages
*/
current_page_count= PFS_atomic::load_u32(& m_max_page_index.m_u32);
if (current_page_count != 0)
{
monotonic= PFS_atomic::load_u32(& m_monotonic.m_u32);
monotonic_max= monotonic + current_page_count;
while (monotonic < monotonic_max)
{
/*
Scan in the [0 .. current_page_count - 1] range,
in parallel with m_monotonic (see below)
*/
index= monotonic % current_page_count;
/* Atomic Load, array= m_pages[index] */
addr= & m_pages[index];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array != NULL)
{
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
}
/*
Parallel scans collaborate to increase
the common monotonic scan counter.
Note that when all the existing page are full,
one thread will eventually add a new page,
and cause m_max_page_index to increase,
which fools all the modulo logic for scans already in progress,
because the monotonic counter is not folded to the same place
(sometime modulo N, sometime modulo N+1).
This is actually ok: since all the pages are full anyway,
there is nothing to miss, so better increase the monotonic
counter faster and then move on to the detection of new pages,
in part 2: below.
*/
monotonic= PFS_atomic::add_u32(& m_monotonic.m_u32, 1);
};
}
/*
2: Try to add a new page, beyond the m_max_page_index limit
*/
while (current_page_count < m_max_page_count)
{
/* Peek for pages added by collaborating threads */
/* (2-a) Atomic Load, array= m_pages[current_page_count] */
addr= & m_pages[current_page_count];
typed_addr= static_cast<void * volatile *>(addr);
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
// ==================================================================
// BEGIN CRITICAL SECTION -- buffer expand
// ==================================================================
/*
On a fresh started server, buffers are typically empty.
When a sudden load spike is seen by the server,
multiple threads may want to expand the buffer at the same time.
Using a compare and swap to allow multiple pages to be added,
possibly freeing duplicate pages on collisions,
does not work well because the amount of code involved
when creating a new page can be significant (PFS_thread),
causing MANY collisions between (2-b) and (2-d).
A huge number of collisions (which can happen when thousands
of new connections hits the server after a restart)
leads to a huge memory consumption, and to OOM.
To mitigate this, we use here a mutex,
to enforce that only ONE page is added at a time,
so that scaling the buffer happens in a predictable
and controlled manner.
*/
pthread_mutex_lock(& m_critical_section);
/*
Peek again for pages added by collaborating threads,
this time as the only thread allowed to expand the buffer
*/
/* (2-b) Atomic Load, array= m_pages[current_page_count] */
ptr= my_atomic_loadptr(typed_addr);
array= static_cast<array_type *>(ptr);
if (array == NULL)
{
/* (2-c) Found no page, allocate a new one */
array= new array_type();
builtin_memory_scalable_buffer.count_alloc(sizeof (array_type));
array->m_max= get_page_logical_size(current_page_count);
int rc= m_allocator->alloc_array(array);
if (rc != 0)
{
m_allocator->free_array(array);
delete array;
builtin_memory_scalable_buffer.count_free(sizeof (array_type));
m_lost++;
pthread_mutex_unlock(& m_critical_section);
return NULL;
}
/* Keep a pointer to this container, for static_deallocate(). */
array->m_container= reinterpret_cast<PFS_opaque_container *> (this);
/* (2-d) Atomic STORE, m_pages[current_page_count] = array */
ptr= array;
my_atomic_storeptr(typed_addr, ptr);
/* Advertise the new page */
PFS_atomic::add_u32(& m_max_page_index.m_u32, 1);
}
pthread_mutex_unlock(& m_critical_section);
// ==================================================================
// END CRITICAL SECTION -- buffer expand
// ==================================================================
}
assert(array != NULL);
pfs= array->allocate(dirty_state);
if (pfs != NULL)
{
/* Keep a pointer to the parent page, for deallocate(). */
pfs->m_page= reinterpret_cast<PFS_opaque_container_page *> (array);
return pfs;
}
current_page_count++;
}
m_lost++;
m_full= true;
return NULL;
} | O3 | c | PFS_buffer_scalable_container<PFS_program, 1024, 1024, PFS_buffer_default_array<PFS_program>, PFS_buffer_default_allocator<PFS_program>>::allocate(pfs_dirty_state*):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rbx
cmpb $0x1, 0x9(%rdi)
jne 0x3f7de
incq (%rbx)
jmp 0x3f92d
movl 0x58(%rbx), %r12d
testl %r12d, %r12d
je 0x3f826
movl 0x18(%rbx), %eax
leal (%rax,%r12), %r14d
cmpl %r14d, %eax
jae 0x3f826
xorl %edx, %edx
divl %r12d
movq 0xa8(%rbx,%rdx,8), %r15
testq %r15, %r15
je 0x3f81a
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x3faf8
testq %rax, %rax
jne 0x3f947
movl $0x1, %eax
lock
xaddl %eax, 0x18(%rbx)
jmp 0x3f7ee
cmpq %r12, 0x98(%rbx)
jbe 0x3f926
leaq 0x4b0(%rbx), %r14
leal 0x1(%r12), %r15d
movl $0xc0, %eax
addq 0x2d776d(%rip), %rax # 0x316fb8
movq %rax, -0x48(%rbp)
movq %r14, -0x30(%rbp)
movq 0xa8(%rbx,%r12,8), %r13
movl %r15d, %eax
movq %rax, -0x40(%rbp)
testq %r13, %r13
jne 0x3f8fa
movq %r14, %rdi
callq 0x264d0
movq 0xa8(%rbx,%r12,8), %r13
testq %r13, %r13
jne 0x3f8f2
movl $0x88, %edi
callq 0x26330
movq %rax, %r13
movl $0x88, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x261c0
movl $0x88, %esi
movq -0x48(%rbp), %rdi
callq 0x3440e
movq -0x40(%rbp), %rax
cmpq %rax, 0x98(%rbx)
movl 0xa0(%rbx), %eax
movl $0x80, %ecx
cmovaq %rcx, %rax
movq %rax, 0x50(%r13)
movq 0x4a8(%rbx), %rdi
movq %r13, %rsi
callq 0x2dbe4
testl %eax, %eax
jne 0x3f950
movq %rbx, 0x58(%r13)
movq %r13, %rax
xchgq %rax, 0xa8(%rbx,%r12,8)
lock
incl 0x58(%rbx)
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x26250
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x3faf8
testq %rax, %rax
jne 0x3f93e
incl %r15d
movq -0x40(%rbp), %rax
movq %rax, %r12
cmpq %rax, 0x98(%rbx)
movq -0x30(%rbp), %r14
ja 0x3f853
incq (%rbx)
movb $0x1, 0x9(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x7d8(%rax)
jmp 0x3f92f
movq %r15, 0x7d8(%rax)
jmp 0x3f92f
movq 0x4a8(%rbx), %rdi
movq %r13, %rsi
callq 0x2df66
movl $0x88, %esi
movq %r13, %rdi
callq 0x26340
movl $0xc0, %edi
addq 0x2d7640(%rip), %rdi # 0x316fb8
movl $0x88, %esi
callq 0x34444
incq (%rbx)
movq -0x30(%rbp), %rdi
callq 0x26250
jmp 0x3f92d
| _ZN29PFS_buffer_scalable_containerI11PFS_accountLi128ELi128E17PFS_account_array21PFS_account_allocatorE8allocateEP15pfs_dirty_state:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov [rbp+var_38], rsi
mov rbx, rdi
cmp byte ptr [rdi+9], 1
jnz short loc_3F7DE
inc qword ptr [rbx]
jmp loc_3F92D
loc_3F7DE:
mov r12d, [rbx+58h]
test r12d, r12d
jz short loc_3F826
mov eax, [rbx+18h]
lea r14d, [rax+r12]
loc_3F7EE:
cmp eax, r14d
jnb short loc_3F826
xor edx, edx
div r12d
mov r15, [rbx+rdx*8+0A8h]
test r15, r15
jz short loc_3F81A
mov rdi, r15
mov rsi, [rbp+var_38]
call _ZN24PFS_buffer_default_arrayI11PFS_accountE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_account>::allocate(pfs_dirty_state *)
test rax, rax
jnz loc_3F947
loc_3F81A:
mov eax, 1
lock xadd [rbx+18h], eax
jmp short loc_3F7EE
loc_3F826:
cmp [rbx+98h], r12
jbe loc_3F926
lea r14, [rbx+4B0h]
lea r15d, [r12+1]
mov eax, 0C0h
add rax, cs:builtin_memory_scalable_buffer_ptr
mov [rbp+var_48], rax
mov [rbp+var_30], r14
loc_3F853:
mov r13, [rbx+r12*8+0A8h]
mov eax, r15d
mov [rbp+var_40], rax
test r13, r13
jnz loc_3F8FA
mov rdi, r14
call _pthread_mutex_lock
mov r13, [rbx+r12*8+0A8h]
test r13, r13
jnz short loc_3F8F2
mov edi, 88h; unsigned __int64
call __Znwm; operator new(ulong)
mov r13, rax
mov edx, 88h
mov rdi, rax
xor esi, esi
call _memset
mov esi, 88h; unsigned __int64
mov rdi, [rbp+var_48]; this
call _ZN15PFS_memory_stat19count_builtin_allocEm; PFS_memory_stat::count_builtin_alloc(ulong)
mov rax, [rbp+var_40]
cmp [rbx+98h], rax
mov eax, [rbx+0A0h]
mov ecx, 80h
cmova rax, rcx
mov [r13+50h], rax
mov rdi, [rbx+4A8h]
mov rsi, r13
call _ZN21PFS_account_allocator11alloc_arrayEP17PFS_account_array; PFS_account_allocator::alloc_array(PFS_account_array *)
test eax, eax
jnz short loc_3F950
mov [r13+58h], rbx
mov rax, r13
xchg rax, [rbx+r12*8+0A8h]
lock inc dword ptr [rbx+58h]
mov r14, [rbp+var_30]
loc_3F8F2:
mov rdi, r14
call _pthread_mutex_unlock
loc_3F8FA:
mov rdi, r13
mov rsi, [rbp+var_38]
call _ZN24PFS_buffer_default_arrayI11PFS_accountE8allocateEP15pfs_dirty_state; PFS_buffer_default_array<PFS_account>::allocate(pfs_dirty_state *)
test rax, rax
jnz short loc_3F93E
inc r15d
mov rax, [rbp+var_40]
mov r12, rax
cmp [rbx+98h], rax
mov r14, [rbp+var_30]
ja loc_3F853
loc_3F926:
inc qword ptr [rbx]
mov byte ptr [rbx+9], 1
loc_3F92D:
xor eax, eax
loc_3F92F:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3F93E:
mov [rax+7D8h], r13
jmp short loc_3F92F
loc_3F947:
mov [rax+7D8h], r15
jmp short loc_3F92F
loc_3F950:
mov rdi, [rbx+4A8h]
mov rsi, r13
call _ZN21PFS_account_allocator10free_arrayEP17PFS_account_array; PFS_account_allocator::free_array(PFS_account_array *)
mov esi, 88h; unsigned __int64
mov rdi, r13; void *
call __ZdlPvm; operator delete(void *,ulong)
mov edi, 0C0h
add rdi, cs:builtin_memory_scalable_buffer_ptr; this
mov esi, 88h; unsigned __int64
call _ZN15PFS_memory_stat18count_builtin_freeEm; PFS_memory_stat::count_builtin_free(ulong)
inc qword ptr [rbx]
mov rdi, [rbp+var_30]
call _pthread_mutex_unlock
jmp short loc_3F92D
| long long PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>::allocate(
long long a1,
long long a2)
{
unsigned long long v2; // r12
unsigned __int32 v3; // eax
unsigned __int32 v4; // r14d
long long v5; // rdx
long long v6; // r15
long long result; // rax
long long v8; // r14
unsigned int v9; // r15d
_QWORD *v10; // r13
long long v11; // rax
unsigned long long v12; // [rsp+10h] [rbp-40h]
if ( *(_BYTE *)(a1 + 9) == 1 )
{
++*(_QWORD *)a1;
return 0LL;
}
v2 = *(unsigned int *)(a1 + 88);
if ( (_DWORD)v2 )
{
v3 = *(_DWORD *)(a1 + 24);
v4 = v3 + v2;
while ( v3 < v4 )
{
v5 = v3 % (unsigned int)v2;
v6 = *(_QWORD *)(a1 + 8 * v5 + 168);
if ( v6 )
{
result = PFS_buffer_default_array<PFS_account>::allocate(*(_QWORD *)(a1 + 8 * v5 + 168), a2);
if ( result )
{
*(_QWORD *)(result + 2008) = v6;
return result;
}
}
v3 = _InterlockedExchangeAdd((volatile signed __int32 *)(a1 + 24), 1u);
}
}
if ( *(_QWORD *)(a1 + 152) <= v2 )
{
LABEL_20:
++*(_QWORD *)a1;
*(_BYTE *)(a1 + 9) = 1;
return 0LL;
}
v8 = a1 + 1200;
v9 = v2 + 1;
while ( 1 )
{
v10 = *(_QWORD **)(a1 + 8 * v2 + 168);
v12 = v9;
if ( v10 )
goto LABEL_18;
pthread_mutex_lock(v8);
v10 = *(_QWORD **)(a1 + 8 * v2 + 168);
if ( !v10 )
break;
LABEL_17:
pthread_mutex_unlock(v8);
LABEL_18:
result = PFS_buffer_default_array<PFS_account>::allocate(v10, a2);
if ( result )
{
*(_QWORD *)(result + 2008) = v10;
return result;
}
++v9;
v2 = v12;
v8 = a1 + 1200;
if ( *(_QWORD *)(a1 + 152) <= v12 )
goto LABEL_20;
}
v10 = (_QWORD *)operator new(0x88uLL);
memset(v10, 0LL, 136LL);
PFS_memory_stat::count_builtin_alloc((PFS_memory_stat *)&builtin_memory_scalable_buffer[12], 0x88uLL);
v11 = *(unsigned int *)(a1 + 160);
if ( *(_QWORD *)(a1 + 152) > (unsigned long long)v9 )
v11 = 128LL;
v10[10] = v11;
if ( !(unsigned int)PFS_account_allocator::alloc_array(*(_QWORD *)(a1 + 1192), (long long)v10) )
{
v10[11] = a1;
_InterlockedExchange64((volatile long long *)(a1 + 8 * v2 + 168), (long long)v10);
_InterlockedIncrement((volatile signed __int32 *)(a1 + 88));
v8 = a1 + 1200;
goto LABEL_17;
}
PFS_account_allocator::free_array(*(_QWORD *)(a1 + 1192), v10);
operator delete(v10, 0x88uLL);
PFS_memory_stat::count_builtin_free(&builtin_memory_scalable_buffer[12], 0x88uLL);
++*(_QWORD *)a1;
pthread_mutex_unlock(a1 + 1200);
return 0LL;
}
| allocate:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x38],RSI
MOV RBX,RDI
CMP byte ptr [RDI + 0x9],0x1
JNZ 0x0013f7de
INC qword ptr [RBX]
JMP 0x0013f92d
LAB_0013f7de:
MOV R12D,dword ptr [RBX + 0x58]
TEST R12D,R12D
JZ 0x0013f826
MOV EAX,dword ptr [RBX + 0x18]
LEA R14D,[RAX + R12*0x1]
LAB_0013f7ee:
CMP EAX,R14D
JNC 0x0013f826
XOR EDX,EDX
DIV R12D
MOV R15,qword ptr [RBX + RDX*0x8 + 0xa8]
TEST R15,R15
JZ 0x0013f81a
MOV RDI,R15
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0013faf8
TEST RAX,RAX
JNZ 0x0013f947
LAB_0013f81a:
MOV EAX,0x1
XADD.LOCK dword ptr [RBX + 0x18],EAX
JMP 0x0013f7ee
LAB_0013f826:
CMP qword ptr [RBX + 0x98],R12
JBE 0x0013f926
LEA R14,[RBX + 0x4b0]
LEA R15D,[R12 + 0x1]
MOV EAX,0xc0
ADD RAX,qword ptr [0x00416fb8]
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x30],R14
LAB_0013f853:
MOV R13,qword ptr [RBX + R12*0x8 + 0xa8]
MOV EAX,R15D
MOV qword ptr [RBP + -0x40],RAX
TEST R13,R13
JNZ 0x0013f8fa
MOV RDI,R14
CALL 0x001264d0
MOV R13,qword ptr [RBX + R12*0x8 + 0xa8]
TEST R13,R13
JNZ 0x0013f8f2
MOV EDI,0x88
CALL 0x00126330
MOV R13,RAX
MOV EDX,0x88
MOV RDI,RAX
XOR ESI,ESI
CALL 0x001261c0
MOV ESI,0x88
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x0013440e
MOV RAX,qword ptr [RBP + -0x40]
CMP qword ptr [RBX + 0x98],RAX
MOV EAX,dword ptr [RBX + 0xa0]
MOV ECX,0x80
CMOVA RAX,RCX
MOV qword ptr [R13 + 0x50],RAX
MOV RDI,qword ptr [RBX + 0x4a8]
MOV RSI,R13
CALL 0x0012dbe4
TEST EAX,EAX
JNZ 0x0013f950
MOV qword ptr [R13 + 0x58],RBX
MOV RAX,R13
XCHG qword ptr [RBX + R12*0x8 + 0xa8],RAX
INC.LOCK dword ptr [RBX + 0x58]
MOV R14,qword ptr [RBP + -0x30]
LAB_0013f8f2:
MOV RDI,R14
CALL 0x00126250
LAB_0013f8fa:
MOV RDI,R13
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0013faf8
TEST RAX,RAX
JNZ 0x0013f93e
INC R15D
MOV RAX,qword ptr [RBP + -0x40]
MOV R12,RAX
CMP qword ptr [RBX + 0x98],RAX
MOV R14,qword ptr [RBP + -0x30]
JA 0x0013f853
LAB_0013f926:
INC qword ptr [RBX]
MOV byte ptr [RBX + 0x9],0x1
LAB_0013f92d:
XOR EAX,EAX
LAB_0013f92f:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013f93e:
MOV qword ptr [RAX + 0x7d8],R13
JMP 0x0013f92f
LAB_0013f947:
MOV qword ptr [RAX + 0x7d8],R15
JMP 0x0013f92f
LAB_0013f950:
MOV RDI,qword ptr [RBX + 0x4a8]
MOV RSI,R13
CALL 0x0012df66
MOV ESI,0x88
MOV RDI,R13
CALL 0x00126340
MOV EDI,0xc0
ADD RDI,qword ptr [0x00416fb8]
MOV ESI,0x88
CALL 0x00134444
INC qword ptr [RBX]
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00126250
JMP 0x0013f92d
|
/* PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array,
PFS_account_allocator>::allocate(pfs_dirty_state*) */
long __thiscall
PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>::allocate
(PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
*this,pfs_dirty_state *param_1)
{
PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator> *pPVar1
;
pthread_mutex_t *__mutex;
uint uVar2;
int iVar3;
long lVar4;
PFS_memory_stat *this_00;
ulong uVar5;
PFS_buffer_default_array<PFS_account> *pPVar6;
ulong uVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
if (this[9] ==
(PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>)
0x1) {
*(long *)this = *(long *)this + 1;
}
else {
uVar10 = *(uint *)(this + 0x58);
uVar8 = (ulong)uVar10;
if (uVar10 != 0) {
uVar2 = *(uint *)(this + 0x18);
uVar9 = uVar2 + uVar10;
while (uVar2 < uVar9) {
pPVar6 = *(PFS_buffer_default_array<PFS_account> **)
(this + ((ulong)uVar2 % uVar8) * 8 + 0xa8);
if ((pPVar6 != (PFS_buffer_default_array<PFS_account> *)0x0) &&
(lVar4 = PFS_buffer_default_array<PFS_account>::allocate(pPVar6,param_1), lVar4 != 0)) {
*(PFS_buffer_default_array<PFS_account> **)(lVar4 + 0x7d8) = pPVar6;
return lVar4;
}
LOCK();
pPVar1 = this + 0x18;
uVar2 = *(uint *)pPVar1;
*(uint *)pPVar1 = *(uint *)pPVar1 + 1;
UNLOCK();
}
}
if (uVar8 < *(ulong *)(this + 0x98)) {
__mutex = (pthread_mutex_t *)(this + 0x4b0);
this_00 = (PFS_memory_stat *)(PTR_builtin_memory_scalable_buffer_00416fb8 + 0xc0);
do {
uVar10 = uVar10 + 1;
pPVar6 = *(PFS_buffer_default_array<PFS_account> **)(this + uVar8 * 8 + 0xa8);
uVar5 = (ulong)uVar10;
if (pPVar6 == (PFS_buffer_default_array<PFS_account> *)0x0) {
pthread_mutex_lock(__mutex);
pPVar6 = *(PFS_buffer_default_array<PFS_account> **)(this + uVar8 * 8 + 0xa8);
if (pPVar6 == (PFS_buffer_default_array<PFS_account> *)0x0) {
pPVar6 = (PFS_buffer_default_array<PFS_account> *)operator_new(0x88);
memset(pPVar6,0,0x88);
PFS_memory_stat::count_builtin_alloc(this_00,0x88);
uVar7 = (ulong)*(uint *)(this + 0xa0);
if (uVar5 < *(ulong *)(this + 0x98)) {
uVar7 = 0x80;
}
*(ulong *)((PFS_account_array *)pPVar6 + 0x50) = uVar7;
iVar3 = PFS_account_allocator::alloc_array
(*(PFS_account_allocator **)(this + 0x4a8),(PFS_account_array *)pPVar6
);
if (iVar3 != 0) {
PFS_account_allocator::free_array
(*(PFS_account_allocator **)(this + 0x4a8),(PFS_account_array *)pPVar6);
operator_delete(pPVar6,0x88);
PFS_memory_stat::count_builtin_free
((PFS_memory_stat *)(PTR_builtin_memory_scalable_buffer_00416fb8 + 0xc0),
0x88);
*(long *)this = *(long *)this + 1;
pthread_mutex_unlock(__mutex);
return 0;
}
*(PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
**)((PFS_account_array *)pPVar6 + 0x58) = this;
LOCK();
*(PFS_buffer_default_array<PFS_account> **)(this + uVar8 * 8 + 0xa8) = pPVar6;
UNLOCK();
LOCK();
*(int *)(this + 0x58) = *(int *)(this + 0x58) + 1;
UNLOCK();
}
pthread_mutex_unlock(__mutex);
}
lVar4 = PFS_buffer_default_array<PFS_account>::allocate(pPVar6,param_1);
if (lVar4 != 0) {
*(PFS_buffer_default_array<PFS_account> **)(lVar4 + 0x7d8) = pPVar6;
return lVar4;
}
uVar8 = uVar5;
} while (uVar5 < *(ulong *)(this + 0x98));
}
*(long *)this = *(long *)this + 1;
this[9] = (PFS_buffer_scalable_container<PFS_account,128,128,PFS_account_array,PFS_account_allocator>
)0x1;
}
return 0;
}
| |
23,607 | llama_sampler_logit_bias_free(llama_sampler*) | monkey531[P]llama/src/llama-sampling.cpp | static void llama_sampler_logit_bias_free(struct llama_sampler * smpl) {
delete (llama_sampler_logit_bias *) smpl->ctx;
} | O1 | cpp | llama_sampler_logit_bias_free(llama_sampler*):
pushq %rbx
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0xe44dc
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xe44b9
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x69220
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xe44ce
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
callq 0x69220
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x69220
popq %rbx
retq
| _ZL29llama_sampler_logit_bias_freeP13llama_sampler:
push rbx
mov rbx, [rdi+8]
test rbx, rbx
jz short loc_E44DC
mov rdi, [rbx+20h]; void *
test rdi, rdi
jz short loc_E44B9
mov rsi, [rbx+30h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E44B9:
mov rdi, [rbx+8]; void *
test rdi, rdi
jz short loc_E44CE
mov rsi, [rbx+18h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E44CE:
mov esi, 38h ; '8'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
loc_E44DC:
pop rbx
retn
| void llama_sampler_logit_bias_free(long long a1)
{
_QWORD *v1; // rbx
void *v2; // rdi
void *v3; // rdi
v1 = *(_QWORD **)(a1 + 8);
if ( v1 )
{
v2 = (void *)v1[4];
if ( v2 )
operator delete(v2, v1[6] - (_QWORD)v2);
v3 = (void *)v1[1];
if ( v3 )
operator delete(v3, v1[3] - (_QWORD)v3);
operator delete(v1, 0x38uLL);
}
}
| llama_sampler_logit_bias_free:
PUSH RBX
MOV RBX,qword ptr [RDI + 0x8]
TEST RBX,RBX
JZ 0x001e44dc
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x001e44b9
MOV RSI,qword ptr [RBX + 0x30]
SUB RSI,RDI
CALL 0x00169220
LAB_001e44b9:
MOV RDI,qword ptr [RBX + 0x8]
TEST RDI,RDI
JZ 0x001e44ce
MOV RSI,qword ptr [RBX + 0x18]
SUB RSI,RDI
CALL 0x00169220
LAB_001e44ce:
MOV ESI,0x38
MOV RDI,RBX
POP RBX
JMP 0x00169220
LAB_001e44dc:
POP RBX
RET
|
/* llama_sampler_logit_bias_free(llama_sampler*) */
void llama_sampler_logit_bias_free(llama_sampler *param_1)
{
void *pvVar1;
void *pvVar2;
pvVar1 = *(void **)(param_1 + 8);
if (pvVar1 != (void *)0x0) {
pvVar2 = *(void **)((long)pvVar1 + 0x20);
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,*(long *)((long)pvVar1 + 0x30) - (long)pvVar2);
}
pvVar2 = *(void **)((long)pvVar1 + 8);
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,*(long *)((long)pvVar1 + 0x18) - (long)pvVar2);
}
operator_delete(pvVar1,0x38);
return;
}
return;
}
| |
23,608 | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const | llama.cpp/common/minja/minja.hpp | Value call(const std::shared_ptr<Context> & context, ArgumentsValue & args) const {
if (!callable_) throw std::runtime_error("Value is not callable: " + dump());
return (*callable_)(context, args);
} | O3 | cpp | minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x8149d
cmpq $0x0, 0x10(%rsi)
je 0x814f8
movq %rdi, %rbx
callq *0x18(%rsi)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1c460
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x6cb9a
leaq 0x4b1ae(%rip), %rsi # 0xcc671
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x66b64
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c2c0
xorl %ebp, %ebp
movq 0x7eacf(%rip), %rsi # 0xfffb8
movq 0x7ea88(%rip), %rdx # 0xfff78
movq %rbx, %rdi
callq 0x1c7b0
callq 0x1ccf0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8151b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1c110
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x81536
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c110
testb %bpl, %bpl
jne 0x81560
jmp 0x81568
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x81560
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1c110
jmp 0x81560
movq %rax, %r14
movq %rbx, %rdi
callq 0x1caa0
movq %r14, %rdi
callq 0x1c7d0
| _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rsi, [rsi+30h]
test rsi, rsi
jz short loc_8149D
cmp qword ptr [rsi+10h], 0
jz short loc_814F8
mov rbx, rdi
call qword ptr [rsi+18h]
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_8149D:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotCall; "Value is not callable: "
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
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
loc_814F8:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov r14, rax
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_8151B
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8151B:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_81536
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_81536:
test bpl, bpl
jnz short loc_81560
jmp short loc_81568
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_81560
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_81560
mov r14, rax
loc_81560:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_81568:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::call(long long a1, long long a2)
{
long long v3; // rsi
void *exception; // rbx
_BYTE v6[16]; // [rsp+0h] [rbp-58h] BYREF
_QWORD v7[2]; // [rsp+20h] [rbp-38h] BYREF
v3 = *(_QWORD *)(a2 + 48);
if ( !v3 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v6, a2, 0xFFFFFFFF, 0);
std::operator+<char>(v7, (long long)"Value is not callable: ", (long long)v6);
std::runtime_error::runtime_error(exception, v7);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !*(_QWORD *)(v3 + 16) )
std::__throw_bad_function_call();
(*(void (**)(void))(v3 + 24))();
return a1;
}
| call:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RSI
MOV RSI,qword ptr [RSI + 0x30]
TEST RSI,RSI
JZ 0x0018149d
CMP qword ptr [RSI + 0x10],0x0
JZ 0x001814f8
MOV RBX,RDI
CALL qword ptr [RSI + 0x18]
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0018149d:
MOV EDI,0x10
CALL 0x0011c460
MOV RBX,RAX
LAB_001814aa:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0016cb9a
LAB_001814bc:
LEA RSI,[0x1cc671]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00166b64
MOV BPL,0x1
LAB_001814d3:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x0011c2c0
XOR EBP,EBP
MOV RSI,qword ptr [0x001fffb8]
MOV RDX,qword ptr [0x001fff78]
MOV RDI,RBX
CALL 0x0011c7b0
LAB_001814f8:
CALL 0x0011ccf0
|
/* minja::Value::call(std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&) const */
shared_ptr * minja::Value::call(shared_ptr *param_1,ArgumentsValue *param_2)
{
long lVar1;
runtime_error *this;
int1 auStack_58 [32];
string local_38 [32];
lVar1 = *(long *)(param_2 + 0x30);
if (lVar1 == 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001814aa to 001814bb has its CatchHandler @ 0018155d */
dump_abi_cxx11_((int)auStack_58,SUB81(param_2,0));
/* try { // try from 001814bc to 001814cf has its CatchHandler @ 0018153d */
std::operator+((char *)local_38,(string *)"Value is not callable: ");
/* try { // try from 001814d3 to 001814f7 has its CatchHandler @ 001814fd */
std::runtime_error::runtime_error(this,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001fffb8,PTR__runtime_error_001fff78);
}
if (*(long *)(lVar1 + 0x10) != 0) {
(**(code **)(lVar1 + 0x18))();
return param_1;
}
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
| |
23,609 | JS_FreeCString | bluesky950520[P]quickjs/quickjs.c | void JS_FreeCString(JSContext *ctx, const char *ptr)
{
JSString *p;
if (!ptr)
return;
/* purposely removing constness */
p = container_of(ptr, JSString, u);
JS_FreeValue(ctx, JS_MKPTR(JS_TAG_STRING, p));
} | O2 | c | JS_FreeCString:
testq %rsi, %rsi
je 0x1b068
addq $-0x18, %rsi
pushq $-0x7
popq %rdx
jmp 0x1801e
retq
| JS_FreeCString:
test rsi, rsi
jz short locret_1B068
add rsi, 0FFFFFFFFFFFFFFE8h
push 0FFFFFFFFFFFFFFF9h
pop rdx
jmp JS_FreeValue
locret_1B068:
retn
| long long JS_FreeCString(long long a1, long long a2)
{
long long result; // rax
if ( a2 )
return JS_FreeValue(a1, a2 - 24, -7LL);
return result;
}
| JS_FreeCString:
TEST RSI,RSI
JZ 0x0011b068
ADD RSI,-0x18
PUSH -0x7
POP RDX
JMP 0x0011801e
LAB_0011b068:
RET
|
void JS_FreeCString(int8 param_1,long param_2)
{
if (param_2 != 0) {
JS_FreeValue(param_1,param_2 + -0x18,0xfffffffffffffff9);
return;
}
return;
}
| |
23,610 | MatrixAdd | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Matrix MatrixAdd(Matrix left, Matrix right)
{
Matrix result = { 0 };
result.m0 = left.m0 + right.m0;
result.m1 = left.m1 + right.m1;
result.m2 = left.m2 + right.m2;
result.m3 = left.m3 + right.m3;
result.m4 = left.m4 + right.m4;
result.m5 = left.m5 + right.m5;
result.m6 = left.m6 + right.m6;
result.m7 = left.m7 + right.m7;
result.m8 = left.m8 + right.m8;
result.m9 = left.m9 + right.m9;
result.m10 = left.m10 + right.m10;
result.m11 = left.m11 + right.m11;
result.m12 = left.m12 + right.m12;
result.m13 = left.m13 + right.m13;
result.m14 = left.m14 + right.m14;
result.m15 = left.m15 + right.m15;
return result;
} | O0 | c | MatrixAdd:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, %rax
movq %rax, -0x8(%rbp)
leaq 0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %esi, %esi
movl $0x40, %edx
callq 0xa2d0
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movss (%rdx), %xmm0
addss (%rcx), %xmm0
movss %xmm0, (%rdi)
movss 0x10(%rdx), %xmm0
addss 0x10(%rcx), %xmm0
movss %xmm0, 0x10(%rdi)
movss 0x20(%rdx), %xmm0
addss 0x20(%rcx), %xmm0
movss %xmm0, 0x20(%rdi)
movss 0x30(%rdx), %xmm0
addss 0x30(%rcx), %xmm0
movss %xmm0, 0x30(%rdi)
movss 0x4(%rdx), %xmm0
addss 0x4(%rcx), %xmm0
movss %xmm0, 0x4(%rdi)
movss 0x14(%rdx), %xmm0
addss 0x14(%rcx), %xmm0
movss %xmm0, 0x14(%rdi)
movss 0x24(%rdx), %xmm0
addss 0x24(%rcx), %xmm0
movss %xmm0, 0x24(%rdi)
movss 0x34(%rdx), %xmm0
addss 0x34(%rcx), %xmm0
movss %xmm0, 0x34(%rdi)
movss 0x8(%rdx), %xmm0
addss 0x8(%rcx), %xmm0
movss %xmm0, 0x8(%rdi)
movss 0x18(%rdx), %xmm0
addss 0x18(%rcx), %xmm0
movss %xmm0, 0x18(%rdi)
movss 0x28(%rdx), %xmm0
addss 0x28(%rcx), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x38(%rdx), %xmm0
addss 0x38(%rcx), %xmm0
movss %xmm0, 0x38(%rdi)
movss 0xc(%rdx), %xmm0
addss 0xc(%rcx), %xmm0
movss %xmm0, 0xc(%rdi)
movss 0x1c(%rdx), %xmm0
addss 0x1c(%rcx), %xmm0
movss %xmm0, 0x1c(%rdi)
movss 0x2c(%rdx), %xmm0
addss 0x2c(%rcx), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0x3c(%rdx), %xmm0
addss 0x3c(%rcx), %xmm0
movss %xmm0, 0x3c(%rdi)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| MatrixAdd:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, rdi
mov [rbp+var_8], rax
lea rax, [rbp+arg_40]
mov [rbp+var_18], rax
lea rax, [rbp+arg_0]
mov [rbp+var_20], rax
xor esi, esi
mov edx, 40h ; '@'
call _memset
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_18]
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
movss xmm0, dword ptr [rdx]
addss xmm0, dword ptr [rcx]
movss dword ptr [rdi], xmm0
movss xmm0, dword ptr [rdx+10h]
addss xmm0, dword ptr [rcx+10h]
movss dword ptr [rdi+10h], xmm0
movss xmm0, dword ptr [rdx+20h]
addss xmm0, dword ptr [rcx+20h]
movss dword ptr [rdi+20h], xmm0
movss xmm0, dword ptr [rdx+30h]
addss xmm0, dword ptr [rcx+30h]
movss dword ptr [rdi+30h], xmm0
movss xmm0, dword ptr [rdx+4]
addss xmm0, dword ptr [rcx+4]
movss dword ptr [rdi+4], xmm0
movss xmm0, dword ptr [rdx+14h]
addss xmm0, dword ptr [rcx+14h]
movss dword ptr [rdi+14h], xmm0
movss xmm0, dword ptr [rdx+24h]
addss xmm0, dword ptr [rcx+24h]
movss dword ptr [rdi+24h], xmm0
movss xmm0, dword ptr [rdx+34h]
addss xmm0, dword ptr [rcx+34h]
movss dword ptr [rdi+34h], xmm0
movss xmm0, dword ptr [rdx+8]
addss xmm0, dword ptr [rcx+8]
movss dword ptr [rdi+8], xmm0
movss xmm0, dword ptr [rdx+18h]
addss xmm0, dword ptr [rcx+18h]
movss dword ptr [rdi+18h], xmm0
movss xmm0, dword ptr [rdx+28h]
addss xmm0, dword ptr [rcx+28h]
movss dword ptr [rdi+28h], xmm0
movss xmm0, dword ptr [rdx+38h]
addss xmm0, dword ptr [rcx+38h]
movss dword ptr [rdi+38h], xmm0
movss xmm0, dword ptr [rdx+0Ch]
addss xmm0, dword ptr [rcx+0Ch]
movss dword ptr [rdi+0Ch], xmm0
movss xmm0, dword ptr [rdx+1Ch]
addss xmm0, dword ptr [rcx+1Ch]
movss dword ptr [rdi+1Ch], xmm0
movss xmm0, dword ptr [rdx+2Ch]
addss xmm0, dword ptr [rcx+2Ch]
movss dword ptr [rdi+2Ch], xmm0
movss xmm0, dword ptr [rdx+3Ch]
addss xmm0, dword ptr [rcx+3Ch]
movss dword ptr [rdi+3Ch], xmm0
add rsp, 20h
pop rbp
retn
| float * MatrixAdd(
float *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
double a8,
double a9,
double a10,
double a11,
double a12,
double a13,
double a14,
double a15,
double a16,
double a17,
double a18,
double a19,
double a20,
double a21,
double a22,
double a23,
long long a24,
long long a25,
long long a26,
long long a27,
long long a28,
long long a29,
long long a30)
{
float *result; // rax
memset(a1, 0LL, 64LL);
result = a1;
*a1 = *(float *)&a15 + *(float *)&a23;
a1[4] = *(float *)&a17 + *(float *)&a25;
a1[8] = *(float *)&a19 + *(float *)&a27;
a1[12] = *(float *)&a21 + *(float *)&a29;
a1[1] = *((float *)&a15 + 1) + *((float *)&a23 + 1);
a1[5] = *((float *)&a17 + 1) + *((float *)&a25 + 1);
a1[9] = *((float *)&a19 + 1) + *((float *)&a27 + 1);
a1[13] = *((float *)&a21 + 1) + *((float *)&a29 + 1);
a1[2] = *(float *)&a16 + *(float *)&a24;
a1[6] = *(float *)&a18 + *(float *)&a26;
a1[10] = *(float *)&a20 + *(float *)&a28;
a1[14] = *(float *)&a22 + *(float *)&a30;
a1[3] = *((float *)&a16 + 1) + *((float *)&a24 + 1);
a1[7] = *((float *)&a18 + 1) + *((float *)&a26 + 1);
a1[11] = *((float *)&a20 + 1) + *((float *)&a28 + 1);
a1[15] = *((float *)&a22 + 1) + *((float *)&a30 + 1);
return result;
}
| MatrixAdd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x8],RAX
LEA RAX,[RBP + 0x50]
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x20],RAX
XOR ESI,ESI
MOV EDX,0x40
CALL 0x0010a2d0
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOVSS XMM0,dword ptr [RDX]
ADDSS XMM0,dword ptr [RCX]
MOVSS dword ptr [RDI],XMM0
MOVSS XMM0,dword ptr [RDX + 0x10]
ADDSS XMM0,dword ptr [RCX + 0x10]
MOVSS dword ptr [RDI + 0x10],XMM0
MOVSS XMM0,dword ptr [RDX + 0x20]
ADDSS XMM0,dword ptr [RCX + 0x20]
MOVSS dword ptr [RDI + 0x20],XMM0
MOVSS XMM0,dword ptr [RDX + 0x30]
ADDSS XMM0,dword ptr [RCX + 0x30]
MOVSS dword ptr [RDI + 0x30],XMM0
MOVSS XMM0,dword ptr [RDX + 0x4]
ADDSS XMM0,dword ptr [RCX + 0x4]
MOVSS dword ptr [RDI + 0x4],XMM0
MOVSS XMM0,dword ptr [RDX + 0x14]
ADDSS XMM0,dword ptr [RCX + 0x14]
MOVSS dword ptr [RDI + 0x14],XMM0
MOVSS XMM0,dword ptr [RDX + 0x24]
ADDSS XMM0,dword ptr [RCX + 0x24]
MOVSS dword ptr [RDI + 0x24],XMM0
MOVSS XMM0,dword ptr [RDX + 0x34]
ADDSS XMM0,dword ptr [RCX + 0x34]
MOVSS dword ptr [RDI + 0x34],XMM0
MOVSS XMM0,dword ptr [RDX + 0x8]
ADDSS XMM0,dword ptr [RCX + 0x8]
MOVSS dword ptr [RDI + 0x8],XMM0
MOVSS XMM0,dword ptr [RDX + 0x18]
ADDSS XMM0,dword ptr [RCX + 0x18]
MOVSS dword ptr [RDI + 0x18],XMM0
MOVSS XMM0,dword ptr [RDX + 0x28]
ADDSS XMM0,dword ptr [RCX + 0x28]
MOVSS dword ptr [RDI + 0x28],XMM0
MOVSS XMM0,dword ptr [RDX + 0x38]
ADDSS XMM0,dword ptr [RCX + 0x38]
MOVSS dword ptr [RDI + 0x38],XMM0
MOVSS XMM0,dword ptr [RDX + 0xc]
ADDSS XMM0,dword ptr [RCX + 0xc]
MOVSS dword ptr [RDI + 0xc],XMM0
MOVSS XMM0,dword ptr [RDX + 0x1c]
ADDSS XMM0,dword ptr [RCX + 0x1c]
MOVSS dword ptr [RDI + 0x1c],XMM0
MOVSS XMM0,dword ptr [RDX + 0x2c]
ADDSS XMM0,dword ptr [RCX + 0x2c]
MOVSS dword ptr [RDI + 0x2c],XMM0
MOVSS XMM0,dword ptr [RDX + 0x3c]
ADDSS XMM0,dword ptr [RCX + 0x3c]
MOVSS dword ptr [RDI + 0x3c],XMM0
ADD RSP,0x20
POP RBP
RET
|
float * MatrixAdd(float *param_1)
{
float fStack0000000000000008;
float fStack000000000000000c;
float fStack0000000000000010;
float fStack0000000000000014;
float fStack0000000000000018;
float fStack000000000000001c;
float fStack0000000000000020;
float fStack0000000000000024;
float fStack0000000000000028;
float fStack000000000000002c;
float fStack0000000000000030;
float fStack0000000000000034;
float fStack0000000000000038;
float fStack000000000000003c;
float fStack0000000000000040;
float fStack0000000000000044;
float fStack0000000000000048;
float fStack000000000000004c;
float fStack0000000000000050;
float fStack0000000000000054;
float fStack0000000000000058;
float fStack000000000000005c;
float fStack0000000000000060;
float fStack0000000000000064;
float fStack0000000000000068;
float fStack000000000000006c;
float fStack0000000000000070;
float fStack0000000000000074;
float fStack0000000000000078;
float fStack000000000000007c;
float fStack0000000000000080;
float fStack0000000000000084;
memset(param_1,0,0x40);
*param_1 = fStack0000000000000008 + fStack0000000000000048;
param_1[4] = fStack0000000000000018 + fStack0000000000000058;
param_1[8] = fStack0000000000000028 + fStack0000000000000068;
param_1[0xc] = fStack0000000000000038 + fStack0000000000000078;
param_1[1] = fStack000000000000000c + fStack000000000000004c;
param_1[5] = fStack000000000000001c + fStack000000000000005c;
param_1[9] = fStack000000000000002c + fStack000000000000006c;
param_1[0xd] = fStack000000000000003c + fStack000000000000007c;
param_1[2] = fStack0000000000000010 + fStack0000000000000050;
param_1[6] = fStack0000000000000020 + fStack0000000000000060;
param_1[10] = fStack0000000000000030 + fStack0000000000000070;
param_1[0xe] = fStack0000000000000040 + fStack0000000000000080;
param_1[3] = fStack0000000000000014 + fStack0000000000000054;
param_1[7] = fStack0000000000000024 + fStack0000000000000064;
param_1[0xb] = fStack0000000000000034 + fStack0000000000000074;
param_1[0xf] = fStack0000000000000044 + fStack0000000000000084;
return param_1;
}
| |
23,611 | MatrixAdd | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/raymath.h | RMAPI Matrix MatrixAdd(Matrix left, Matrix right)
{
Matrix result = { 0 };
result.m0 = left.m0 + right.m0;
result.m1 = left.m1 + right.m1;
result.m2 = left.m2 + right.m2;
result.m3 = left.m3 + right.m3;
result.m4 = left.m4 + right.m4;
result.m5 = left.m5 + right.m5;
result.m6 = left.m6 + right.m6;
result.m7 = left.m7 + right.m7;
result.m8 = left.m8 + right.m8;
result.m9 = left.m9 + right.m9;
result.m10 = left.m10 + right.m10;
result.m11 = left.m11 + right.m11;
result.m12 = left.m12 + right.m12;
result.m13 = left.m13 + right.m13;
result.m14 = left.m14 + right.m14;
result.m15 = left.m15 + right.m15;
return result;
} | O3 | c | MatrixAdd:
movq %rdi, %rax
movaps 0x8(%rsp), %xmm0
addps 0x48(%rsp), %xmm0
movups %xmm0, (%rdi)
movaps 0x18(%rsp), %xmm0
addps 0x58(%rsp), %xmm0
movups %xmm0, 0x10(%rdi)
movaps 0x28(%rsp), %xmm0
addps 0x68(%rsp), %xmm0
movups %xmm0, 0x20(%rdi)
movaps 0x38(%rsp), %xmm0
addps 0x78(%rsp), %xmm0
movups %xmm0, 0x30(%rdi)
retq
| MatrixAdd:
mov rax, rdi
movaps xmm0, [rsp+arg_0]
addps xmm0, [rsp+arg_40]
movups xmmword ptr [rdi], xmm0
movaps xmm0, [rsp+arg_10]
addps xmm0, [rsp+arg_50]
movups xmmword ptr [rdi+10h], xmm0
movaps xmm0, [rsp+arg_20]
addps xmm0, [rsp+arg_60]
movups xmmword ptr [rdi+20h], xmm0
movaps xmm0, [rsp+arg_30]
addps xmm0, [rsp+arg_70]
movups xmmword ptr [rdi+30h], xmm0
retn
| __m128 * MatrixAdd(
__m128 *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)
{
__m128 *result; // rax
result = a1;
*a1 = _mm_add_ps(a7, a11);
a1[1] = _mm_add_ps(a8, a12);
a1[2] = _mm_add_ps(a9, a13);
a1[3] = _mm_add_ps(a10, a14);
return result;
}
| MatrixAdd:
MOV RAX,RDI
MOVAPS XMM0,xmmword ptr [RSP + 0x8]
ADDPS XMM0,xmmword ptr [RSP + 0x48]
MOVUPS xmmword ptr [RDI],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x18]
ADDPS XMM0,xmmword ptr [RSP + 0x58]
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x28]
ADDPS XMM0,xmmword ptr [RSP + 0x68]
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVAPS XMM0,xmmword ptr [RSP + 0x38]
ADDPS XMM0,xmmword ptr [RSP + 0x78]
MOVUPS xmmword ptr [RDI + 0x30],XMM0
RET
|
float * MatrixAdd(float *param_1)
{
float fStack0000000000000008;
float fStack000000000000000c;
float fStack0000000000000010;
float fStack0000000000000014;
float fStack0000000000000018;
float fStack000000000000001c;
float fStack0000000000000020;
float fStack0000000000000024;
float fStack0000000000000028;
float fStack000000000000002c;
float fStack0000000000000030;
float fStack0000000000000034;
float fStack0000000000000038;
float fStack000000000000003c;
float fStack0000000000000040;
float fStack0000000000000044;
float fStack0000000000000048;
float fStack000000000000004c;
float fStack0000000000000050;
float fStack0000000000000054;
float fStack0000000000000058;
float fStack000000000000005c;
float fStack0000000000000060;
float fStack0000000000000064;
float fStack0000000000000068;
float fStack000000000000006c;
float fStack0000000000000070;
float fStack0000000000000074;
float fStack0000000000000078;
float fStack000000000000007c;
float fStack0000000000000080;
float fStack0000000000000084;
*param_1 = fStack0000000000000008 + fStack0000000000000048;
param_1[1] = fStack000000000000000c + fStack000000000000004c;
param_1[2] = fStack0000000000000010 + fStack0000000000000050;
param_1[3] = fStack0000000000000014 + fStack0000000000000054;
param_1[4] = fStack0000000000000018 + fStack0000000000000058;
param_1[5] = fStack000000000000001c + fStack000000000000005c;
param_1[6] = fStack0000000000000020 + fStack0000000000000060;
param_1[7] = fStack0000000000000024 + fStack0000000000000064;
param_1[8] = fStack0000000000000028 + fStack0000000000000068;
param_1[9] = fStack000000000000002c + fStack000000000000006c;
param_1[10] = fStack0000000000000030 + fStack0000000000000070;
param_1[0xb] = fStack0000000000000034 + fStack0000000000000074;
param_1[0xc] = fStack0000000000000038 + fStack0000000000000078;
param_1[0xd] = fStack000000000000003c + fStack000000000000007c;
param_1[0xe] = fStack0000000000000040 + fStack0000000000000080;
param_1[0xf] = fStack0000000000000044 + fStack0000000000000084;
return param_1;
}
| |
23,612 | main | monkey531[P]llama/examples/lookup/lookup-create.cpp | int main(int argc, char ** argv){
common_params params;
if (!common_params_parse(argc, argv, params, LLAMA_EXAMPLE_LOOKUP)) {
return 1;
}
// init llama.cpp
llama_backend_init();
llama_numa_init(params.numa);
// load the model
common_init_result llama_init = common_init_from_params(params);
llama_model_ptr & model = llama_init.model;
llama_context_ptr & ctx = llama_init.context;
GGML_ASSERT(model != nullptr);
// tokenize the prompt
std::vector<llama_token> inp;
inp = common_tokenize(ctx.get(), params.prompt, true, true);
fprintf(stderr, "%s: tokenization done\n", __func__);
common_ngram_cache ngram_cache;
common_ngram_cache_update(ngram_cache, LLAMA_NGRAM_STATIC, LLAMA_NGRAM_STATIC, inp, inp.size(), true);
fprintf(stderr, "%s: hashing done, writing file to %s\n", __func__, params.lookup_cache_static.c_str());
common_ngram_cache_save(ngram_cache, params.lookup_cache_static);
return 0;
} | O2 | cpp | main:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1360, %rsp # imm = 0x1360
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x78(%rsp), %r14
movq %r14, %rdi
callq 0x268a4
pushq $0xe
popq %rcx
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x289a9
testb %al, %al
jne 0x2671b
pushq $0x1
popq %rbx
leaq 0x78(%rsp), %rdi
callq 0x27254
movl %ebx, %eax
addq $0x1360, %rsp # imm = 0x1360
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24770
movl 0x728(%rsp), %edi
callq 0x24dc0
leaq 0x50(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x552ff
cmpq $0x0, 0x50(%rsp)
je 0x26842
andq $0x0, 0x10(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq 0x58(%rsp), %rsi
leaq 0xe90(%rsp), %rdx
leaq 0x18(%rsp), %rdi
pushq $0x1
popq %rcx
movl %ecx, %r8d
callq 0x5674d
movq %rsp, %rbx
leaq 0x18(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x281e0
movq %r14, %rdi
callq 0x281ac
movq 0xd97f5(%rip), %r14 # 0xfff88
movq (%r14), %rdi
leaq 0x859cb(%rip), %rsi # 0xac168
leaq 0x859db(%rip), %rdx # 0xac17f
xorl %eax, %eax
callq 0x24c70
leaq 0x48(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x8(%rbx), %r8
subq (%rbx), %r8
shrq $0x2, %r8
leaq 0x18(%rsp), %rdi
pushq $0x2
popq %rdx
pushq $0x1
popq %r9
movl %edx, %esi
movq %rbx, %rcx
callq 0x978c4
movq (%r14), %rdi
leaq 0xf30(%rsp), %r14
movq (%r14), %rcx
leaq 0x85980(%rip), %rsi # 0xac184
leaq 0x85974(%rip), %rdx # 0xac17f
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x24c70
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x9808e
leaq 0x18(%rsp), %rdi
callq 0x27f6a
movq %rsp, %rdi
callq 0x281ac
leaq 0x50(%rsp), %rdi
callq 0x27234
jmp 0x26703
leaq 0x8589b(%rip), %rdi # 0xac0e4
leaq 0x858f0(%rip), %rdx # 0xac140
leaq 0x85900(%rip), %rcx # 0xac157
pushq $0x1a
popq %rsi
xorl %eax, %eax
callq 0x24e90
movq %rax, %rbx
jmp 0x2687a
movq %rax, %rbx
jmp 0x26882
jmp 0x2688e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x27f6a
movq %rsp, %rdi
callq 0x281ac
leaq 0x50(%rsp), %rdi
callq 0x27234
jmp 0x26891
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x27254
movq %rbx, %rdi
callq 0x24f60
nop
| main:
push rbp
push r14
push rbx
sub rsp, 1360h
mov rbx, rsi
mov ebp, edi
lea r14, [rsp+1378h+var_1300]
mov rdi, r14; this
call _ZN13common_paramsC2Ev; common_params::common_params(void)
push 0Eh
pop rcx
mov edi, ebp
mov rsi, rbx
mov rdx, r14
xor r8d, r8d
call _Z19common_params_parseiPPcR13common_params13llama_examplePFviS0_E; common_params_parse(int,char **,common_params &,llama_example,void (*)(int,char **))
test al, al
jnz short loc_2671B
push 1
pop rbx
loc_26703:
lea rdi, [rsp+1378h+var_1300]; this
call _ZN13common_paramsD2Ev; common_params::~common_params()
mov eax, ebx
add rsp, 1360h
pop rbx
pop r14
pop rbp
retn
loc_2671B:
call _llama_backend_init
mov edi, [rsp+1378h+var_C50]
call _llama_numa_init
lea rdi, [rsp+1378h+var_1328]; this
lea rsi, [rsp+1378h+var_1300]
call _Z23common_init_from_paramsR13common_params; common_init_from_params(common_params &)
cmp [rsp+1378h+var_1328], 0
jz loc_26842
and [rsp+1378h+var_1368], 0
xorps xmm0, xmm0
movaps [rsp+1378h+var_1378], xmm0
mov rsi, [rsp+1378h+var_1320]
lea rdx, [rsp+1378h+var_4E8]
lea rdi, [rsp+1378h+var_1360]
push 1
pop rcx
mov r8d, ecx
call _Z15common_tokenizePK13llama_contextRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEbb; common_tokenize(llama_context const*,std::string const&,bool,bool)
mov rbx, rsp
lea r14, [rsp+1378h+var_1360]
mov rdi, rbx
mov rsi, r14
call _ZNSt6vectorIiSaIiEE14_M_move_assignEOS1_St17integral_constantIbLb1EE; std::vector<int>::_M_move_assign(std::vector<int>&&,std::integral_constant<bool,true>)
mov rdi, r14
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
mov r14, cs:stderr_ptr
mov rdi, [r14]
lea rsi, aSTokenizationD; "%s: tokenization done\n"
lea rdx, aMain; "main"
xor eax, eax
call _fprintf
lea rax, [rsp+1378h+var_1330]
mov [rax-30h], rax
mov qword ptr [rax-28h], 1
xorps xmm0, xmm0
movups xmmword ptr [rax-20h], xmm0
mov dword ptr [rax-10h], 3F800000h
movups xmmword ptr [rax-8], xmm0
mov r8, [rbx+8]
sub r8, [rbx]
shr r8, 2
lea rdi, [rsp+1378h+var_1360]
push 2
pop rdx
push 1
pop r9
mov esi, edx
mov rcx, rbx
call _Z25common_ngram_cache_updateRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEEiiRSt6vectorIiSaIiEEib; common_ngram_cache_update(std::unordered_map<common_ngram,std::unordered_map<int,int>,common_ngram_hash_function,std::equal_to<common_ngram>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>> &,int,int,std::vector<int> &,int,bool)
mov rdi, [r14]
lea r14, [rsp+1378h+var_448]
mov rcx, [r14]
lea rsi, aSHashingDoneWr; "%s: hashing done, writing file to %s\n"
lea rdx, aMain; "main"
xor ebx, ebx
xor eax, eax
call _fprintf
lea rdi, [rsp+1378h+var_1360]
mov rsi, r14
call _Z23common_ngram_cache_saveRSt13unordered_mapI12common_ngramS_IiiSt4hashIiESt8equal_toIiESaISt4pairIKiiEEE26common_ngram_hash_functionS3_IS0_ESaIS5_IKS0_S9_EEERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; common_ngram_cache_save(std::unordered_map<common_ngram,std::unordered_map<int,int>,common_ngram_hash_function,std::equal_to<common_ngram>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>> &,std::string &)
lea rdi, [rsp+1378h+var_1360]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
mov rdi, rsp
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
lea rdi, [rsp+1378h+var_1328]; this
call _ZN18common_init_resultD2Ev; common_init_result::~common_init_result()
jmp loc_26703
loc_26842:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aModelNullptr; "model != nullptr"
push 1Ah
pop rsi
xor eax, eax
call _ggml_abort
mov rbx, rax
jmp short loc_2687A
mov rbx, rax
jmp short loc_26882
jmp short loc_2688E
mov rbx, rax
lea rdi, [rsp+1378h+var_1360]
call _ZNSt10_HashtableI12common_ngramSt4pairIKS0_St13unordered_mapIiiSt4hashIiESt8equal_toIiESaIS1_IKiiEEEESaISC_ENSt8__detail10_Select1stES6_IS0_E26common_ngram_hash_functionNSE_18_Mod_range_hashingENSE_20_Default_ranged_hashENSE_20_Prime_rehash_policyENSE_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable()
loc_2687A:
mov rdi, rsp
call _ZNSt12_Vector_baseIiSaIiEED2Ev; std::_Vector_base<int>::~_Vector_base()
loc_26882:
lea rdi, [rsp+1378h+var_1328]; this
call _ZN18common_init_resultD2Ev; common_init_result::~common_init_result()
jmp short loc_26891
loc_2688E:
mov rbx, rax
loc_26891:
lea rdi, [rsp+1378h+var_1300]; this
call _ZN13common_paramsD2Ev; common_params::~common_params()
mov rdi, rbx
call __Unwind_Resume
| int main(int argc, const char **argv, const char **envp)
{
int v3; // ebx
long long v5; // rbx
__int128 v6; // [rsp+0h] [rbp-1378h] BYREF
long long v7; // [rsp+10h] [rbp-1368h]
_BYTE v8[48]; // [rsp+18h] [rbp-1360h] BYREF
char v9; // [rsp+48h] [rbp-1330h] BYREF
long long v10; // [rsp+50h] [rbp-1328h] BYREF
long long v11; // [rsp+58h] [rbp-1320h]
int v12; // [rsp+60h] [rbp-1318h]
int v13; // [rsp+68h] [rbp-1310h]
int v14; // [rsp+70h] [rbp-1308h]
char v15[1712]; // [rsp+78h] [rbp-1300h] BYREF
unsigned int v16; // [rsp+728h] [rbp-C50h]
_BYTE v17[160]; // [rsp+E90h] [rbp-4E8h] BYREF
const char *v18; // [rsp+F30h] [rbp-448h] BYREF
common_params::common_params((common_params *)v15);
if ( (unsigned __int8)common_params_parse((unsigned int)argc, argv, v15, 14LL, 0LL) )
{
llama_backend_init();
llama_numa_init(v16);
common_init_from_params((common_params *)&v10);
if ( !v10 )
{
v5 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/lookup/lookup-create.cpp",
26LL,
"GGML_ASSERT(%s) failed",
"model != nullptr");
std::_Vector_base<int>::~_Vector_base(&v6);
common_init_result::~common_init_result((common_init_result *)&v10);
common_params::~common_params((common_params *)v15);
_Unwind_Resume(v5);
}
v7 = 0LL;
v6 = 0LL;
common_tokenize(v8, v11, v17, 1LL, 1LL);
std::vector<int>::_M_move_assign(&v6, v8);
std::_Vector_base<int>::~_Vector_base(v8);
fprintf(stderr, "%s: tokenization done\n", "main");
common_ngram_cache_update(
(unsigned int)v8,
2,
2,
(unsigned int)&v6,
(*((_QWORD *)&v6 + 1) - (_QWORD)v6) >> 2,
1,
v6,
DWORD2(v6),
v7,
(unsigned int)&v9,
1,
0,
0,
1065353216,
0,
0,
v10,
v11,
v12,
v13,
v14,
v15[0]);
v3 = 0;
fprintf(stderr, "%s: hashing done, writing file to %s\n", "main", v18);
common_ngram_cache_save(v8, &v18);
std::_Hashtable<common_ngram,std::pair<common_ngram const,std::unordered_map<int,int>>,std::allocator<std::pair<common_ngram const,std::unordered_map<int,int>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::~_Hashtable(v8);
std::_Vector_base<int>::~_Vector_base(&v6);
common_init_result::~common_init_result((common_init_result *)&v10);
}
else
{
v3 = 1;
}
common_params::~common_params((common_params *)v15);
return v3;
}
| main:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x1360
MOV RBX,RSI
MOV EBP,EDI
LEA R14,[RSP + 0x78]
MOV RDI,R14
CALL 0x001268a4
LAB_001266e9:
PUSH 0xe
POP RCX
MOV EDI,EBP
MOV RSI,RBX
MOV RDX,R14
XOR R8D,R8D
CALL 0x001289a9
TEST AL,AL
JNZ 0x0012671b
PUSH 0x1
POP RBX
LAB_00126703:
LEA RDI,[RSP + 0x78]
CALL 0x00127254
MOV EAX,EBX
ADD RSP,0x1360
POP RBX
POP R14
POP RBP
RET
LAB_0012671b:
CALL 0x00124770
MOV EDI,dword ptr [RSP + 0x728]
CALL 0x00124dc0
LAB_0012672c:
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x78]
CALL 0x001552ff
CMP qword ptr [RSP + 0x50],0x0
JZ 0x00126842
AND qword ptr [RSP + 0x10],0x0
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV RSI,qword ptr [RSP + 0x58]
LEA RDX,[RSP + 0xe90]
LAB_00126761:
LEA RDI,[RSP + 0x18]
PUSH 0x1
POP RCX
MOV R8D,ECX
CALL 0x0015674d
MOV RBX,RSP
LEA R14,[RSP + 0x18]
MOV RDI,RBX
MOV RSI,R14
CALL 0x001281e0
MOV RDI,R14
CALL 0x001281ac
MOV R14,qword ptr [0x001fff88]
MOV RDI,qword ptr [R14]
LEA RSI,[0x1ac168]
LEA RDX,[0x1ac17f]
XOR EAX,EAX
CALL 0x00124c70
LEA RAX,[RSP + 0x48]
MOV qword ptr [RAX + -0x30],RAX
MOV qword ptr [RAX + -0x28],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + -0x20],XMM0
MOV dword ptr [RAX + -0x10],0x3f800000
MOVUPS xmmword ptr [RAX + -0x8],XMM0
MOV R8,qword ptr [RBX + 0x8]
SUB R8,qword ptr [RBX]
SHR R8,0x2
LAB_001267d9:
LEA RDI,[RSP + 0x18]
PUSH 0x2
POP RDX
PUSH 0x1
POP R9
MOV ESI,EDX
MOV RCX,RBX
CALL 0x001978c4
MOV RDI,qword ptr [R14]
LEA R14,[RSP + 0xf30]
MOV RCX,qword ptr [R14]
LEA RSI,[0x1ac184]
LEA RDX,[0x1ac17f]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00124c70
LEA RDI,[RSP + 0x18]
MOV RSI,R14
CALL 0x0019808e
LEA RDI,[RSP + 0x18]
CALL 0x00127f6a
MOV RDI,RSP
CALL 0x001281ac
LEA RDI,[RSP + 0x50]
CALL 0x00127234
JMP 0x00126703
LAB_00126842:
LEA RDI,[0x1ac0e4]
LEA RDX,[0x1ac140]
LEA RCX,[0x1ac157]
PUSH 0x1a
POP RSI
XOR EAX,EAX
CALL 0x00124e90
|
int8 main(int4 param_1,int8 param_2)
{
int *puVar1;
char cVar2;
int8 uVar3;
long local_1378;
long lStack_1370;
int8 local_1368;
int8 *local_1360;
int8 local_1358;
int8 local_1350;
int8 uStack_1348;
int4 local_1340;
int8 local_1338;
int8 uStack_1330;
long local_1328;
string *local_1320;
common_params local_1300 [1712];
int4 local_c50;
int1 local_4e8 [160];
int8 local_448 [134];
common_params::common_params(local_1300);
/* try { // try from 001266e9 to 0012672b has its CatchHandler @ 0012688e */
cVar2 = common_params_parse(param_1,param_2,local_1300,0xe,0);
if (cVar2 == '\0') {
uVar3 = 1;
}
else {
llama_backend_init();
llama_numa_init(local_c50);
/* try { // try from 0012672c to 0012673a has its CatchHandler @ 0012686b */
common_init_from_params((common_params *)&local_1328);
if (local_1328 == 0) {
/* try { // try from 00126842 to 00126860 has its CatchHandler @ 00126866 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/examples/lookup/lookup-create.cpp"
,0x1a,"GGML_ASSERT(%s) failed","model != nullptr");
}
local_1368 = 0;
local_1378 = 0;
lStack_1370 = 0;
/* try { // try from 00126761 to 00126770 has its CatchHandler @ 00126861 */
common_tokenize((llama_context *)&local_1360,local_1320,SUB81(local_4e8,0),true);
std::vector<int,std::allocator<int>>::_M_move_assign
(&local_1378,(_Vector_base<int,std::allocator<int>> *)&local_1360);
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_1360);
puVar1 = PTR_stderr_001fff88;
fprintf(*(FILE **)PTR_stderr_001fff88,"%s: tokenization done\n",&DAT_001ac17f);
local_1360 = &uStack_1330;
local_1358 = 1;
local_1350 = 0;
uStack_1348 = 0;
local_1340 = 0x3f800000;
local_1338 = 0;
uStack_1330 = 0;
/* try { // try from 001267d9 to 00126820 has its CatchHandler @ 0012686d */
common_ngram_cache_update
((unordered_map *)&local_1360,2,2,(vector *)&local_1378,
(int)((ulong)(lStack_1370 - local_1378) >> 2),true);
uVar3 = 0;
fprintf(*(FILE **)puVar1,"%s: hashing done, writing file to %s\n",&DAT_001ac17f,local_448[0]);
common_ngram_cache_save((unordered_map *)&local_1360,(string *)local_448);
std::
_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::~_Hashtable((_Hashtable<common_ngram,std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>,std::allocator<std::pair<common_ngram_const,std::unordered_map<int,int,std::hash<int>,std::equal_to<int>,std::allocator<std::pair<int_const,int>>>>>,std::__detail::_Select1st,std::equal_to<common_ngram>,common_ngram_hash_function,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)&local_1360);
std::_Vector_base<int,std::allocator<int>>::~_Vector_base
((_Vector_base<int,std::allocator<int>> *)&local_1378);
common_init_result::~common_init_result((common_init_result *)&local_1328);
}
common_params::~common_params(local_1300);
return uVar3;
}
| |
23,613 | FileWriterJson::writeHeader(std::filesystem::__cxx11::path const&) | shubhamoy[P]dir2txt/src/FileWriterJson.cpp | void FileWriterJson::writeHeader(const std::filesystem::path& rootPath) {
root = rootPath;
j["root"] = rootPath.string();
j["tree"] = nlohmann::json::array();
j["files"] = nlohmann::json::object();
} | O1 | cpp | FileWriterJson::writeHeader(std::filesystem::__cxx11::path const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x238, %rdi # imm = 0x238
callq 0x8520
movq (%r14), %rsi
leaq 0x30(%rsp), %r15
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, -0x10(%r15)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x9a84
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x295a6
addq $0x8, %rbx
leaq 0xef8e(%rip), %rsi # 0x3710d
movq %rbx, %rdi
callq 0x28e32
leaq 0x40(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x28ea8
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x281c0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8380
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x2, %r8d
callq 0x2d6cc
leaq 0xef2b(%rip), %rsi # 0x37108
movq %rbx, %rdi
callq 0x28e32
leaq 0x10(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x28ea8
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x2d6cc
leaq 0xd56f(%rip), %rsi # 0x35791
movq %rbx, %rdi
callq 0x28e32
movq %rsp, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x28ea8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x29abe
movq %rbx, %rdi
callq 0x29b94
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %r14
jmp 0x28264
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
jmp 0x282ae
movq %rax, %rbx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x29abe
movq %r14, %rdi
callq 0x29b94
jmp 0x28297
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x282ae
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8380
movq %rbx, %rdi
callq 0x85d0
| _ZN14FileWriterJson11writeHeaderERKNSt10filesystem7__cxx114pathE:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
add rdi, 238h
call __ZNSt10filesystem7__cxx114pathaSERKS1_; std::filesystem::__cxx11::path::operator=(std::filesystem::__cxx11::path const&)
mov rsi, [r14]
lea r15, [rsp+68h+var_38]
mov rdx, [r14+8]
add rdx, rsi
mov [r15-10h], r15
lea r14, [rsp+68h+var_48]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+68h+var_28]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
add rbx, 8
lea rsi, aRoot; "root"
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
lea r14, [rsp+68h+var_28]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+68h+var_48]; void *
cmp rdi, r15
jz short loc_281C0
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_281C0:
lea rdi, [rsp+68h+var_58]
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_12_0::detail::json_ref<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_12_0::detail::value_t)
lea rsi, aTree; "tree"
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
lea r14, [rsp+68h+var_58]
mov rdi, rax
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rsp
xor esi, esi
xor edx, edx
xor ecx, ecx
mov r8d, 1
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_12_0::detail::json_ref<nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_12_0::detail::value_t)
lea rsi, aStripCommentsF+1Bh; "files"
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERSD_PT_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator[]<char const>(char const *)
mov rbx, rsp
mov rdi, rax
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>)
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov r14, rsp
jmp short loc_28264
mov rbx, rax
lea r14, [rsp+arg_8]
loc_28264:
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_282AE
mov rbx, rax
lea r14, [rsp+arg_38]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_28297
mov rbx, rax
loc_28297:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r15
jz short loc_282AE
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_282AE:
mov rdi, rbx
call __Unwind_Resume
| long long FileWriterJson::writeHeader(FileWriterJson *this, const std::filesystem::__cxx11::path *a2)
{
_BYTE *v3; // rsi
long long v4; // rdx
int v5; // ebx
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
long long v10; // rax
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
long long v15; // rax
int v16; // edx
int v17; // ecx
int v18; // r8d
int v19; // r9d
long long v20; // rax
_BYTE v22[16]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v23[16]; // [rsp+10h] [rbp-58h] BYREF
void *v24[2]; // [rsp+20h] [rbp-48h] BYREF
_QWORD v25[2]; // [rsp+30h] [rbp-38h] BYREF
_BYTE v26[40]; // [rsp+40h] [rbp-28h] BYREF
std::filesystem::__cxx11::path::operator=((char *)this + 568);
v3 = *(_BYTE **)a2;
v4 = *(_QWORD *)a2 + *((_QWORD *)a2 + 1);
v24[0] = v25;
std::string::_M_construct<char const*>(v24, v3, v4);
ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(
v26,
v24);
v5 = (_DWORD)this + 8;
v10 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(int)this + 8,
(unsigned int)"root",
v6,
v7,
v8,
v9);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator=(
v10,
v26);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v26,
0LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v26);
if ( v24[0] != v25 )
operator delete(v24[0], v25[0] + 1LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v23,
0LL,
0LL,
0LL,
2LL);
v15 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
v5,
(unsigned int)"tree",
v11,
v12,
v13,
v14);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator=(
v15,
v23);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v23,
0LL);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v23);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v22,
0LL,
0LL,
0LL,
1LL);
v20 = nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
v5,
(unsigned int)"files",
v16,
v17,
v18,
v19);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::operator=(
v20,
v22);
nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
v22,
0LL);
return nlohmann::json_abi_v3_12_0::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
}
| writeHeader:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x238
CALL 0x00108520
MOV RSI,qword ptr [R14]
LEA R15,[RSP + 0x30]
MOV RDX,qword ptr [R14 + 0x8]
ADD RDX,RSI
MOV qword ptr [R15 + -0x10],R15
LEA R14,[RSP + 0x20]
MOV RDI,R14
CALL 0x00109a84
LAB_00128167:
LEA RDI,[RSP + 0x40]
MOV RSI,R14
CALL 0x001295a6
ADD RBX,0x8
LAB_00128178:
LEA RSI,[0x13710d]
MOV RDI,RBX
CALL 0x00128e32
LAB_00128187:
LEA R14,[RSP + 0x40]
MOV RDI,RAX
MOV RSI,R14
CALL 0x00128ea8
MOV RDI,R14
XOR ESI,ESI
CALL 0x00129abe
MOV RDI,R14
CALL 0x00129b94
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R15
JZ 0x001281c0
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x00108380
LAB_001281c0:
LEA RDI,[RSP + 0x10]
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,0x2
CALL 0x0012d6cc
LAB_001281d6:
LEA RSI,[0x137108]
MOV RDI,RBX
CALL 0x00128e32
LAB_001281e5:
LEA R14,[RSP + 0x10]
MOV RDI,RAX
MOV RSI,R14
CALL 0x00128ea8
MOV RDI,R14
XOR ESI,ESI
CALL 0x00129abe
MOV RDI,R14
CALL 0x00129b94
MOV RDI,RSP
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
MOV R8D,0x1
CALL 0x0012d6cc
LAB_0012821b:
LEA RSI,[0x135791]
MOV RDI,RBX
CALL 0x00128e32
LAB_0012822a:
MOV RBX,RSP
MOV RDI,RAX
MOV RSI,RBX
CALL 0x00128ea8
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00129abe
MOV RDI,RBX
CALL 0x00129b94
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* FileWriterJson::writeHeader(std::filesystem::__cxx11::path const&) */
void __thiscall FileWriterJson::writeHeader(FileWriterJson *this,path *param_1)
{
basic_json *pbVar1;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this_00;
data adStack_68 [16];
data local_58 [16];
long *local_48 [2];
long local_38 [2];
data local_28 [16];
std::filesystem::__cxx11::path::operator=((path *)(this + 0x238),param_1);
local_48[0] = local_38;
std::__cxx11::string::_M_construct<char_const*>
(local_48,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
/* try { // try from 00128167 to 00128173 has its CatchHandler @ 00128294 */
_ZN8nlohmann16json_abi_v3_12_010basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_28,local_48);
this_00 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(this + 8);
/* try { // try from 00128178 to 00128186 has its CatchHandler @ 00128278 */
pbVar1 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>(this_00,"root");
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar1,local_28);
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_28,0));
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_28);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_58,0,0,0,2);
/* try { // try from 001281d6 to 001281e4 has its CatchHandler @ 0012825c */
pbVar1 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>(this_00,"tree");
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar1,local_58);
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_58,0));
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_58);
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(adStack_68,0,0,0,1);
/* try { // try from 0012821b to 00128229 has its CatchHandler @ 00128254 */
pbVar1 = nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator[]<char_const>(this_00,"files");
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)pbVar1,adStack_68);
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(adStack_68,0));
nlohmann::json_abi_v3_12_0::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_12_0::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(adStack_68);
return;
}
| |
23,614 | common_params_get_system_info[abi:cxx11](common_params const&) | llama.cpp/common/common.cpp | std::string common_params_get_system_info(const common_params & params) {
std::ostringstream os;
os << "system_info: n_threads = " << params.cpuparams.n_threads;
if (params.cpuparams_batch.n_threads != -1) {
os << " (n_threads_batch = " << params.cpuparams_batch.n_threads << ")";
}
#if defined(_WIN32) && (_WIN32_WINNT >= 0x0601) && !defined(__MINGW64__) // windows 7 and later
// TODO: windows + arm64 + mingw64
DWORD logicalProcessorCount = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
os << " / " << logicalProcessorCount << " | " << llama_print_system_info();
#else
os << " / " << std::thread::hardware_concurrency() << " | " << llama_print_system_info();
#endif
return os.str();
} | O3 | cpp | common_params_get_system_info[abi:cxx11](common_params const&):
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x22070
leaq 0x2f349(%rip), %rsi # 0x12e5d2
movl $0x19, %edx
movq %r15, %rdi
callq 0x220d0
movl 0x274(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x21510
cmpl $-0x1, 0x488(%r14)
je 0xff2ec
leaq 0x2f334(%rip), %rsi # 0x12e5ec
leaq 0x8(%rsp), %rdi
movl $0x14, %edx
callq 0x220d0
movl 0x488(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x21510
leaq 0x276b2(%rip), %rsi # 0x126991
movl $0x1, %edx
movq %rax, %rdi
callq 0x220d0
leaq 0x2f30e(%rip), %rsi # 0x12e601
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x220d0
callq 0x21e40
movl %eax, %esi
leaq 0x8(%rsp), %rdi
callq 0x218a0
movq %rax, %r14
leaq 0x30897(%rip), %rsi # 0x12fbb4
movl $0x3, %edx
movq %rax, %rdi
callq 0x220d0
callq 0x21060
movq %rax, %r15
testq %rax, %rax
je 0xff34f
movq %r15, %rdi
callq 0x21690
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x220d0
jmp 0xff369
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22320
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x21670
movq 0x6ebdb(%rip), %rsi # 0x16df58
leaq 0x8(%rsp), %rdi
callq 0x21cb0
leaq 0x78(%rsp), %rdi
callq 0x21c80
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x6ebad(%rip), %rsi # 0x16df58
leaq 0x8(%rsp), %rdi
callq 0x21cb0
leaq 0x78(%rsp), %rdi
callq 0x21c80
movq %rbx, %rdi
callq 0x21b20
| _Z29common_params_get_system_infoB5cxx11RK13common_params:
push r15
push r14
push rbx
sub rsp, 180h
mov r14, rsi
mov rbx, rdi
lea r15, [rsp+198h+var_190]
mov rdi, r15
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, aSystemInfoNThr; "system_info: n_threads = "
mov edx, 19h
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)
mov esi, [r14+274h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
cmp dword ptr [r14+488h], 0FFFFFFFFh
jz short loc_FF2EC
lea rsi, aNThreadsBatch; " (n_threads_batch = "
lea rdi, [rsp+198h+var_190]
mov edx, 14h
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
mov esi, [r14+488h]
lea rdi, [rsp+198h+var_190]
call __ZNSolsEi; std::ostream::operator<<(int)
lea rsi, aCompreplyCompg_2+3Ah; ")"
mov edx, 1
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
loc_FF2EC:
lea rsi, asc_12E601; " / "
lea rdi, [rsp+198h+var_190]; this
mov edx, 3
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call __ZNSt6thread20hardware_concurrencyEv; std::thread::hardware_concurrency(void)
mov esi, eax
lea rdi, [rsp+198h+var_190]
call __ZNSo9_M_insertImEERSoT_; std::ostream::_M_insert<ulong>(ulong)
mov r14, rax
lea rsi, asc_12FBB3+1; " | "
mov edx, 3
mov rdi, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
call _llama_print_system_info
mov r15, rax
test rax, rax
jz short loc_FF34F
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
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_FF369
loc_FF34F:
mov rax, [r14]
mov rax, [rax-18h]
mov rdi, r14
add rdi, rax
mov esi, [r14+rax+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_FF369:
lea rsi, [rsp+198h+var_188]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+198h+var_190]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+198h+var_120]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rax, rbx
add rsp, 180h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_70]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, rbx
call __Unwind_Resume
| long long common_params_get_system_info[abi:cxx11](long long a1, long long a2)
{
long long v2; // rax
unsigned int v3; // eax
_QWORD *v4; // r14
long long v5; // rax
long long v6; // r15
long long v7; // rax
_BYTE v9[8]; // [rsp+8h] [rbp-190h] BYREF
_BYTE v10[104]; // [rsp+10h] [rbp-188h] BYREF
_BYTE v11[288]; // [rsp+78h] [rbp-120h] BYREF
std::ostringstream::basic_ostringstream(v9);
std::__ostream_insert<char,std::char_traits<char>>(v9, "system_info: n_threads = ", 25LL);
std::ostream::operator<<(v9, *(unsigned int *)(a2 + 628));
if ( *(_DWORD *)(a2 + 1160) != -1 )
{
std::__ostream_insert<char,std::char_traits<char>>(v9, " (n_threads_batch = ", 20LL);
v2 = std::ostream::operator<<(v9, *(unsigned int *)(a2 + 1160));
std::__ostream_insert<char,std::char_traits<char>>(v2, ")", 1LL);
}
std::__ostream_insert<char,std::char_traits<char>>(v9, " / ", 3LL);
v3 = std::thread::hardware_concurrency((std::thread *)v9);
v4 = (_QWORD *)std::ostream::_M_insert<unsigned long>(v9, v3);
std::__ostream_insert<char,std::char_traits<char>>(v4, " | ", 3LL);
v5 = llama_print_system_info();
v6 = v5;
if ( v5 )
{
v7 = strlen(v5);
std::__ostream_insert<char,std::char_traits<char>>(v4, v6, v7);
}
else
{
std::ios::clear((char *)v4 + *(_QWORD *)(*v4 - 24LL), *(_DWORD *)((char *)v4 + *(_QWORD *)(*v4 - 24LL) + 32) | 1u);
}
std::stringbuf::str(a1, v10);
std::ostringstream::~ostringstream(v9, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v11);
return a1;
}
| common_params_get_system_info[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x180
MOV R14,RSI
MOV RBX,RDI
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00122070
LAB_001ff282:
LEA RSI,[0x22e5d2]
MOV EDX,0x19
MOV RDI,R15
CALL 0x001220d0
MOV ESI,dword ptr [R14 + 0x274]
LEA RDI,[RSP + 0x8]
CALL 0x00121510
CMP dword ptr [R14 + 0x488],-0x1
JZ 0x001ff2ec
LEA RSI,[0x22e5ec]
LEA RDI,[RSP + 0x8]
MOV EDX,0x14
CALL 0x001220d0
MOV ESI,dword ptr [R14 + 0x488]
LEA RDI,[RSP + 0x8]
CALL 0x00121510
LEA RSI,[0x226991]
MOV EDX,0x1
MOV RDI,RAX
CALL 0x001220d0
LAB_001ff2ec:
LEA RSI,[0x22e601]
LEA RDI,[RSP + 0x8]
MOV EDX,0x3
CALL 0x001220d0
CALL 0x00121e40
MOV ESI,EAX
LEA RDI,[RSP + 0x8]
CALL 0x001218a0
MOV R14,RAX
LEA RSI,[0x22fbb4]
MOV EDX,0x3
MOV RDI,RAX
CALL 0x001220d0
CALL 0x00121060
MOV R15,RAX
TEST RAX,RAX
JZ 0x001ff34f
MOV RDI,R15
CALL 0x00121690
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x001220d0
JMP 0x001ff369
LAB_001ff34f:
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + -0x18]
MOV RDI,R14
ADD RDI,RAX
MOV ESI,dword ptr [R14 + RAX*0x1 + 0x20]
OR ESI,0x1
CALL 0x00122320
LAB_001ff369:
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
CALL 0x00121670
LAB_001ff376:
MOV RSI,qword ptr [0x0026df58]
LEA RDI,[RSP + 0x8]
CALL 0x00121cb0
LEA RDI,[RSP + 0x78]
CALL 0x00121c80
MOV RAX,RBX
ADD RSP,0x180
POP RBX
POP R14
POP R15
RET
|
/* common_params_get_system_info[abi:cxx11](common_params const&) */
common_params * common_params_get_system_info_abi_cxx11_(common_params *param_1)
{
ostream *poVar1;
char *__s;
size_t sVar2;
long in_RSI;
ostringstream local_190 [112];
ios_base local_120 [264];
std::__cxx11::ostringstream::ostringstream(local_190);
/* try { // try from 001ff282 to 001ff375 has its CatchHandler @ 001ff3a1 */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190,"system_info: n_threads = ",0x19);
std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x274));
if (*(int *)(in_RSI + 0x488) != -1) {
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_190," (n_threads_batch = ",0x14);
poVar1 = (ostream *)std::ostream::operator<<((ostream *)local_190,*(int *)(in_RSI + 0x488));
std::__ostream_insert<char,std::char_traits<char>>(poVar1,")",1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_190," / ",3);
std::thread::hardware_concurrency();
poVar1 = std::ostream::_M_insert<unsigned_long>((ulong)local_190);
std::__ostream_insert<char,std::char_traits<char>>(poVar1," | ",3);
__s = (char *)llama_print_system_info();
if (__s == (char *)0x0) {
std::ios::clear(poVar1 + *(long *)(*(long *)poVar1 + -0x18),
*(uint *)(poVar1 + *(long *)(*(long *)poVar1 + -0x18) + 0x20) | 1);
}
else {
sVar2 = strlen(__s);
std::__ostream_insert<char,std::char_traits<char>>(poVar1,__s,sVar2);
}
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream(local_190);
std::ios_base::~ios_base(local_120);
return param_1;
}
| |
23,615 | _bf_div | bluesky950520[P]quickjs/libbf.c | static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret, r_sign;
limb_t n, nb, precl;
r_sign = a->sign ^ b->sign;
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else if (a->expn == BF_EXP_INF) {
bf_set_inf(r, r_sign);
return 0;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (a->expn == BF_EXP_ZERO) {
if (b->expn == BF_EXP_ZERO) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (b->expn == BF_EXP_ZERO) {
bf_set_inf(r, r_sign);
return BF_ST_DIVIDE_ZERO;
}
/* number of limbs of the quotient (2 extra bits for rounding) */
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
nb = b->len;
n = bf_max(a->len, precl);
{
limb_t *taba, na;
slimb_t d;
na = n + nb;
#if LIMB_LOG2_BITS == 6
if (na >= (SIZE_MAX / sizeof(limb_t)) - 1) {
return BF_ST_MEM_ERROR; /* Return memory error status */
}
#endif
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
if (!taba)
goto fail;
d = na - a->len;
memset(taba, 0, d * sizeof(limb_t));
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
if (bf_resize(r, n + 1))
goto fail1;
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
fail1:
bf_free(s, taba);
goto fail;
}
/* see if non zero remainder */
if (mp_scan_nz(taba, nb))
r->tab[0] |= 1;
bf_free(r->ctx, taba);
r->expn = a->expn - b->expn + LIMB_BITS;
r->sign = r_sign;
ret = bf_normalize_and_round(r, prec, flags);
}
return ret;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O0 | c | _bf_div:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movl %r8d, 0x4c(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x58(%rsp), %rcx
xorl 0x8(%rcx), %eax
movl %eax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jge 0xf077c
movq 0x58(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jl 0xf0849
movq 0x60(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
je 0xf07a6
movq 0x58(%rsp), %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, 0x10(%rax)
jne 0xf07bd
movq 0x68(%rsp), %rdi
callq 0xec490
movl $0x0, 0x74(%rsp)
jmp 0xf0abb
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xf07fe
movq 0x58(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xf07fe
movq 0x68(%rsp), %rdi
callq 0xec490
movl $0x1, 0x74(%rsp)
jmp 0xf0abb
movq 0x60(%rsp), %rax
movabsq $0x7ffffffffffffffe, %rcx # imm = 0x7FFFFFFFFFFFFFFE
cmpq %rcx, 0x10(%rax)
jne 0xf082e
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xec570
movl $0x0, 0x74(%rsp)
jmp 0xf0abb
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xec530
movl $0x0, 0x74(%rsp)
jmp 0xf0abb
movq 0x60(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xf08a5
movq 0x58(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xf088a
movq 0x68(%rsp), %rdi
callq 0xec490
movl $0x1, 0x74(%rsp)
jmp 0xf0abb
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xec530
movl $0x0, 0x74(%rsp)
jmp 0xf0abb
movq 0x58(%rsp), %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
cmpq %rcx, 0x10(%rax)
jne 0xf08d5
movq 0x68(%rsp), %rdi
movl 0x38(%rsp), %esi
callq 0xec570
movl $0x2, 0x74(%rsp)
jmp 0xf0abb
jmp 0xf08d7
jmp 0xf08d9
movq 0x50(%rsp), %rax
addq $0x2, %rax
addq $0x40, %rax
subq $0x1, %rax
shrq $0x6, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0xed350
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movabsq $0x1ffffffffffffffe, %rax # imm = 0x1FFFFFFFFFFFFFFE
cmpq %rax, 0x10(%rsp)
jb 0xf0946
movl $0x20, 0x74(%rsp)
jmp 0xf0abb
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0xee350
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xf096f
jmp 0xf0aa9
movq 0x10(%rsp), %rax
movq 0x60(%rsp), %rcx
subq 0x18(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0xe370
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x60(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rdx
shlq $0x3, %rdx
callq 0xe610
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
callq 0xec2c0
cmpl $0x0, %eax
je 0xf09dd
jmp 0xf0a0f
movq 0x40(%rsp), %rdi
movq 0x68(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x58(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x28(%rsp), %r9
callq 0xee380
cmpl $0x0, %eax
je 0xf0a23
jmp 0xf0a0f
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xec6c0
jmp 0xf0aa9
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xee840
cmpq $0x0, %rax
je 0xf0a4b
movq 0x68(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rcx
orq $0x1, %rcx
movq %rcx, (%rax)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xec6c0
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x58(%rsp), %rax
subq 0x10(%rax), %rcx
addq $0x40, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x38(%rsp), %ecx
movq 0x68(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
callq 0xec6f0
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0xf0abb
movq 0x68(%rsp), %rdi
callq 0xec490
movl $0x20, 0x74(%rsp)
movl 0x74(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| __bf_div:
sub rsp, 78h
mov [rsp+78h+var_10], rdi
mov [rsp+78h+var_18], rsi
mov [rsp+78h+var_20], rdx
mov [rsp+78h+var_28], rcx
mov [rsp+78h+var_2C], r8d
mov rax, [rsp+78h+var_10]
mov rax, [rax]
mov [rsp+78h+var_38], rax
mov rax, [rsp+78h+var_18]
mov eax, [rax+8]
mov rcx, [rsp+78h+var_20]
xor eax, [rcx+8]
mov [rsp+78h+var_40], eax
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jge short loc_F077C
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jl loc_F0849
loc_F077C:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp [rax+10h], rcx
jz short loc_F07A6
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFFh
cmp [rax+10h], rcx
jnz short loc_F07BD
loc_F07A6:
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 0
jmp loc_F0ABB
loc_F07BD:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_F07FE
mov rax, [rsp+78h+var_20]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_F07FE
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 1
jmp loc_F0ABB
loc_F07FE:
mov rax, [rsp+78h+var_18]
mov rcx, 7FFFFFFFFFFFFFFEh
cmp [rax+10h], rcx
jnz short loc_F082E
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_inf
mov [rsp+78h+var_4], 0
jmp loc_F0ABB
loc_F082E:
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_zero
mov [rsp+78h+var_4], 0
jmp loc_F0ABB
loc_F0849:
mov rax, [rsp+78h+var_18]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_F08A5
mov rax, [rsp+78h+var_20]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_F088A
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 1
jmp loc_F0ABB
loc_F088A:
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_zero
mov [rsp+78h+var_4], 0
jmp loc_F0ABB
loc_F08A5:
mov rax, [rsp+78h+var_20]
mov rcx, 8000000000000000h
cmp [rax+10h], rcx
jnz short loc_F08D5
mov rdi, [rsp+78h+var_10]
mov esi, [rsp+78h+var_40]
call bf_set_inf
mov [rsp+78h+var_4], 2
jmp loc_F0ABB
loc_F08D5:
jmp short $+2
loc_F08D7:
jmp short $+2
loc_F08D9:
mov rax, [rsp+78h+var_28]
add rax, 2
add rax, 40h ; '@'
sub rax, 1
shr rax, 6
mov [rsp+78h+var_58], rax
mov rax, [rsp+78h+var_20]
mov rax, [rax+18h]
mov [rsp+78h+var_50], rax
mov rax, [rsp+78h+var_18]
mov rdi, [rax+18h]
mov rsi, [rsp+78h+var_58]
call bf_max
mov [rsp+78h+var_48], rax
mov rax, [rsp+78h+var_48]
add rax, [rsp+78h+var_50]
mov [rsp+78h+var_68], rax
mov rax, 1FFFFFFFFFFFFFFEh
cmp [rsp+78h+var_68], rax
jb short loc_F0946
mov [rsp+78h+var_4], 20h ; ' '
jmp loc_F0ABB
loc_F0946:
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_68]
add rsi, 1
shl rsi, 3
call bf_malloc
mov [rsp+78h+var_60], rax
cmp [rsp+78h+var_60], 0
jnz short loc_F096F
jmp loc_F0AA9
loc_F096F:
mov rax, [rsp+78h+var_68]
mov rcx, [rsp+78h+var_18]
sub rax, [rcx+18h]
mov [rsp+78h+var_70], rax
mov rdi, [rsp+78h+var_60]
mov rdx, [rsp+78h+var_70]
shl rdx, 3
xor esi, esi
call _memset
mov rdi, [rsp+78h+var_60]
mov rax, [rsp+78h+var_70]
shl rax, 3
add rdi, rax
mov rax, [rsp+78h+var_18]
mov rsi, [rax+20h]
mov rax, [rsp+78h+var_18]
mov rdx, [rax+18h]
shl rdx, 3
call _memcpy
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_48]
add rsi, 1
call bf_resize
cmp eax, 0
jz short loc_F09DD
jmp short loc_F0A0F
loc_F09DD:
mov rdi, [rsp+78h+var_38]
mov rax, [rsp+78h+var_10]
mov rsi, [rax+20h]
mov rdx, [rsp+78h+var_60]
mov rcx, [rsp+78h+var_68]
mov rax, [rsp+78h+var_20]
mov r8, [rax+20h]
mov r9, [rsp+78h+var_50]
call mp_divnorm
cmp eax, 0
jz short loc_F0A23
jmp short $+2
loc_F0A0F:
mov rdi, [rsp+78h+var_38]
mov rsi, [rsp+78h+var_60]
call bf_free_0
jmp loc_F0AA9
loc_F0A23:
mov rdi, [rsp+78h+var_60]
mov rsi, [rsp+78h+var_50]
call mp_scan_nz
cmp rax, 0
jz short loc_F0A4B
mov rax, [rsp+78h+var_10]
mov rax, [rax+20h]
mov rcx, [rax]
or rcx, 1
mov [rax], rcx
loc_F0A4B:
mov rax, [rsp+78h+var_10]
mov rdi, [rax]
mov rsi, [rsp+78h+var_60]
call bf_free_0
mov rax, [rsp+78h+var_18]
mov rcx, [rax+10h]
mov rax, [rsp+78h+var_20]
sub rcx, [rax+10h]
add rcx, 40h ; '@'
mov rax, [rsp+78h+var_10]
mov [rax+10h], rcx
mov ecx, [rsp+78h+var_40]
mov rax, [rsp+78h+var_10]
mov [rax+8], ecx
mov rdi, [rsp+78h+var_10]
mov rsi, [rsp+78h+var_28]
mov edx, [rsp+78h+var_2C]
call bf_normalize_and_round
mov [rsp+78h+var_3C], eax
mov eax, [rsp+78h+var_3C]
mov [rsp+78h+var_4], eax
jmp short loc_F0ABB
loc_F0AA9:
mov rdi, [rsp+78h+var_10]
call bf_set_nan
mov [rsp+78h+var_4], 20h ; ' '
loc_F0ABB:
mov eax, [rsp+78h+var_4]
add rsp, 78h
retn
| long long _bf_div(long long a1, long long a2, long long a3, long long a4, unsigned int a5)
{
long long v5; // rdx
long long v6; // rcx
long long v7; // r8
long long v8; // r9
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
long long *v17; // rax
long long v19; // [rsp+8h] [rbp-70h]
long long v20; // [rsp+10h] [rbp-68h]
_QWORD *v21; // [rsp+18h] [rbp-60h]
unsigned long long v22; // [rsp+28h] [rbp-50h]
long long v23; // [rsp+30h] [rbp-48h]
int v24; // [rsp+38h] [rbp-40h]
long long v25; // [rsp+40h] [rbp-38h]
v25 = *(_QWORD *)a1;
v24 = *(_DWORD *)(a3 + 8) ^ *(_DWORD *)(a2 + 8);
if ( *(long long *)(a2 + 16) < 0x7FFFFFFFFFFFFFFELL && *(long long *)(a3 + 16) < 0x7FFFFFFFFFFFFFFELL )
{
if ( *(_QWORD *)(a2 + 16) == 0x8000000000000000LL )
{
if ( *(_QWORD *)(a3 + 16) != 0x8000000000000000LL )
{
bf_set_zero(a1, v24);
return 0;
}
goto LABEL_8;
}
if ( *(_QWORD *)(a3 + 16) == 0x8000000000000000LL )
{
bf_set_inf(a1, v24);
return 2;
}
v22 = *(_QWORD *)(a3 + 24);
v23 = bf_max(*(_QWORD *)(a2 + 24), (unsigned long long)(a4 + 65) >> 6);
v20 = v22 + v23;
if ( v22 + v23 >= 0x1FFFFFFFFFFFFFFELL )
return 32;
v21 = (_QWORD *)bf_malloc(v25, 8 * (v20 + 1), v5, v6, v7, v8);
if ( v21 )
{
v19 = v20 - *(_QWORD *)(a2 + 24);
memset(v21, 0LL, 8 * v19);
memcpy(&v21[v19], *(_QWORD *)(a2 + 32), 8LL * *(_QWORD *)(a2 + 24));
if ( !(unsigned int)bf_resize((_QWORD *)a1, v23 + 1)
&& !(unsigned int)mp_divnorm(v25, *(_QWORD *)(a1 + 32), v21, v20, *(_QWORD *)(a3 + 32), v22) )
{
if ( mp_scan_nz((long long)v21, v22) )
{
v17 = *(long long **)(a1 + 32);
v14 = *v17 | 1;
*v17 = v14;
}
bf_free_0(*(_QWORD *)a1, (long long)v21, v13, v14, v15, v16);
*(_QWORD *)(a1 + 16) = *(_QWORD *)(a2 + 16) - *(_QWORD *)(a3 + 16) + 64LL;
*(_DWORD *)(a1 + 8) = v24;
return (unsigned int)bf_normalize_and_round((_QWORD *)a1, a4, a5);
}
bf_free_0(v25, (long long)v21, v9, v10, v11, v12);
}
bf_set_nan(a1);
return 32;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFFLL || *(_QWORD *)(a3 + 16) == 0x7FFFFFFFFFFFFFFFLL )
{
bf_set_nan(a1);
return 0;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFELL && *(_QWORD *)(a3 + 16) == 0x7FFFFFFFFFFFFFFELL )
{
LABEL_8:
bf_set_nan(a1);
return 1;
}
if ( *(_QWORD *)(a2 + 16) == 0x7FFFFFFFFFFFFFFELL )
bf_set_inf(a1, v24);
else
bf_set_zero(a1, v24);
return 0;
}
| __bf_div:
SUB RSP,0x78
MOV qword ptr [RSP + 0x68],RDI
MOV qword ptr [RSP + 0x60],RSI
MOV qword ptr [RSP + 0x58],RDX
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],R8D
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV EAX,dword ptr [RAX + 0x8]
MOV RCX,qword ptr [RSP + 0x58]
XOR EAX,dword ptr [RCX + 0x8]
MOV dword ptr [RSP + 0x38],EAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JGE 0x001f077c
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JL 0x001f0849
LAB_001f077c:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7fffffffffffffff
CMP qword ptr [RAX + 0x10],RCX
JZ 0x001f07a6
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7fffffffffffffff
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f07bd
LAB_001f07a6:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001ec490
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001f0abb
LAB_001f07bd:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f07fe
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f07fe
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001ec490
MOV dword ptr [RSP + 0x74],0x1
JMP 0x001f0abb
LAB_001f07fe:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,0x7ffffffffffffffe
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f082e
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001ec570
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001f0abb
LAB_001f082e:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001ec530
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001f0abb
LAB_001f0849:
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f08a5
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f088a
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001ec490
MOV dword ptr [RSP + 0x74],0x1
JMP 0x001f0abb
LAB_001f088a:
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001ec530
MOV dword ptr [RSP + 0x74],0x0
JMP 0x001f0abb
LAB_001f08a5:
MOV RAX,qword ptr [RSP + 0x58]
MOV RCX,-0x8000000000000000
CMP qword ptr [RAX + 0x10],RCX
JNZ 0x001f08d5
MOV RDI,qword ptr [RSP + 0x68]
MOV ESI,dword ptr [RSP + 0x38]
CALL 0x001ec570
MOV dword ptr [RSP + 0x74],0x2
JMP 0x001f0abb
LAB_001f08d5:
JMP 0x001f08d7
LAB_001f08d7:
JMP 0x001f08d9
LAB_001f08d9:
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x2
ADD RAX,0x40
SUB RAX,0x1
SHR RAX,0x6
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RSP + 0x20]
CALL 0x001ed350
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x30]
ADD RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,0x1ffffffffffffffe
CMP qword ptr [RSP + 0x10],RAX
JC 0x001f0946
MOV dword ptr [RSP + 0x74],0x20
JMP 0x001f0abb
LAB_001f0946:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x1
SHL RSI,0x3
CALL 0x001ee350
MOV qword ptr [RSP + 0x18],RAX
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x001f096f
JMP 0x001f0aa9
LAB_001f096f:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x60]
SUB RAX,qword ptr [RCX + 0x18]
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
SHL RDX,0x3
XOR ESI,ESI
CALL 0x0010e370
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x8]
SHL RAX,0x3
ADD RDI,RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV RSI,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RAX + 0x18]
SHL RDX,0x3
CALL 0x0010e610
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,0x1
CALL 0x001ec2c0
CMP EAX,0x0
JZ 0x001f09dd
JMP 0x001f0a0f
LAB_001f09dd:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RAX + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RAX + 0x20]
MOV R9,qword ptr [RSP + 0x28]
CALL 0x001ee380
CMP EAX,0x0
JZ 0x001f0a23
JMP 0x001f0a0f
LAB_001f0a0f:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001ec6c0
JMP 0x001f0aa9
LAB_001f0a23:
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x001ee840
CMP RAX,0x0
JZ 0x001f0a4b
MOV RAX,qword ptr [RSP + 0x68]
MOV RAX,qword ptr [RAX + 0x20]
MOV RCX,qword ptr [RAX]
OR RCX,0x1
MOV qword ptr [RAX],RCX
LAB_001f0a4b:
MOV RAX,qword ptr [RSP + 0x68]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x001ec6c0
MOV RAX,qword ptr [RSP + 0x60]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RSP + 0x58]
SUB RCX,qword ptr [RAX + 0x10]
ADD RCX,0x40
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RAX + 0x10],RCX
MOV ECX,dword ptr [RSP + 0x38]
MOV RAX,qword ptr [RSP + 0x68]
MOV dword ptr [RAX + 0x8],ECX
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x50]
MOV EDX,dword ptr [RSP + 0x4c]
CALL 0x001ec6f0
MOV dword ptr [RSP + 0x3c],EAX
MOV EAX,dword ptr [RSP + 0x3c]
MOV dword ptr [RSP + 0x74],EAX
JMP 0x001f0abb
LAB_001f0aa9:
MOV RDI,qword ptr [RSP + 0x68]
CALL 0x001ec490
MOV dword ptr [RSP + 0x74],0x20
LAB_001f0abb:
MOV EAX,dword ptr [RSP + 0x74]
ADD RSP,0x78
RET
|
int4 __bf_div(int8 *param_1,long param_2,long param_3,long param_4,int4 param_5)
{
int8 uVar1;
uint uVar2;
int iVar3;
int4 uVar4;
long lVar5;
ulong uVar6;
void *__s;
long lVar7;
long lVar8;
int4 local_4;
uVar1 = *param_1;
uVar2 = *(uint *)(param_2 + 8) ^ *(uint *)(param_3 + 8);
if ((*(long *)(param_2 + 0x10) < 0x7ffffffffffffffe) &&
(*(long *)(param_3 + 0x10) < 0x7ffffffffffffffe)) {
if (*(long *)(param_2 + 0x10) == -0x8000000000000000) {
if (*(long *)(param_3 + 0x10) == -0x8000000000000000) {
bf_set_nan(param_1);
local_4 = 1;
}
else {
bf_set_zero(param_1,uVar2);
local_4 = 0;
}
}
else if (*(long *)(param_3 + 0x10) == -0x8000000000000000) {
bf_set_inf(param_1,uVar2);
local_4 = 2;
}
else {
lVar8 = *(long *)(param_3 + 0x18);
lVar5 = bf_max(*(int8 *)(param_2 + 0x18),param_4 + 0x41U >> 6);
uVar6 = lVar5 + lVar8;
if (uVar6 < 0x1ffffffffffffffe) {
__s = (void *)bf_malloc(uVar1);
if (__s != (void *)0x0) {
lVar7 = uVar6 - *(long *)(param_2 + 0x18);
memset(__s,0,lVar7 * 8);
memcpy((void *)((long)__s + lVar7 * 8),*(void **)(param_2 + 0x20),
*(long *)(param_2 + 0x18) << 3);
iVar3 = bf_resize(param_1,lVar5 + 1);
if ((iVar3 == 0) &&
(iVar3 = mp_divnorm(uVar1,param_1[4],__s,uVar6,*(int8 *)(param_3 + 0x20),lVar8),
iVar3 == 0)) {
lVar8 = mp_scan_nz(__s,lVar8);
if (lVar8 != 0) {
*(ulong *)param_1[4] = *(ulong *)param_1[4] | 1;
}
bf_free(*param_1,__s);
param_1[2] = (*(long *)(param_2 + 0x10) - *(long *)(param_3 + 0x10)) + 0x40;
*(uint *)(param_1 + 1) = uVar2;
uVar4 = bf_normalize_and_round(param_1,param_4,param_5);
return uVar4;
}
bf_free(uVar1,__s);
}
bf_set_nan(param_1);
local_4 = 0x20;
}
else {
local_4 = 0x20;
}
}
}
else if ((*(long *)(param_2 + 0x10) == 0x7fffffffffffffff) ||
(*(long *)(param_3 + 0x10) == 0x7fffffffffffffff)) {
bf_set_nan(param_1);
local_4 = 0;
}
else if ((*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) &&
(*(long *)(param_3 + 0x10) == 0x7ffffffffffffffe)) {
bf_set_nan(param_1);
local_4 = 1;
}
else if (*(long *)(param_2 + 0x10) == 0x7ffffffffffffffe) {
bf_set_inf(param_1,uVar2);
local_4 = 0;
}
else {
bf_set_zero(param_1,uVar2);
local_4 = 0;
}
return local_4;
}
| |
23,616 | _bf_div | bluesky950520[P]quickjs/libbf.c | static int __bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec,
bf_flags_t flags)
{
bf_context_t *s = r->ctx;
int ret, r_sign;
limb_t n, nb, precl;
r_sign = a->sign ^ b->sign;
if (a->expn >= BF_EXP_INF || b->expn >= BF_EXP_INF) {
if (a->expn == BF_EXP_NAN || b->expn == BF_EXP_NAN) {
bf_set_nan(r);
return 0;
} else if (a->expn == BF_EXP_INF && b->expn == BF_EXP_INF) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else if (a->expn == BF_EXP_INF) {
bf_set_inf(r, r_sign);
return 0;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (a->expn == BF_EXP_ZERO) {
if (b->expn == BF_EXP_ZERO) {
bf_set_nan(r);
return BF_ST_INVALID_OP;
} else {
bf_set_zero(r, r_sign);
return 0;
}
} else if (b->expn == BF_EXP_ZERO) {
bf_set_inf(r, r_sign);
return BF_ST_DIVIDE_ZERO;
}
/* number of limbs of the quotient (2 extra bits for rounding) */
precl = (prec + 2 + LIMB_BITS - 1) / LIMB_BITS;
nb = b->len;
n = bf_max(a->len, precl);
{
limb_t *taba, na;
slimb_t d;
na = n + nb;
#if LIMB_LOG2_BITS == 6
if (na >= (SIZE_MAX / sizeof(limb_t)) - 1) {
return BF_ST_MEM_ERROR; /* Return memory error status */
}
#endif
taba = bf_malloc(s, (na + 1) * sizeof(limb_t));
if (!taba)
goto fail;
d = na - a->len;
memset(taba, 0, d * sizeof(limb_t));
memcpy(taba + d, a->tab, a->len * sizeof(limb_t));
if (bf_resize(r, n + 1))
goto fail1;
if (mp_divnorm(s, r->tab, taba, na, b->tab, nb)) {
fail1:
bf_free(s, taba);
goto fail;
}
/* see if non zero remainder */
if (mp_scan_nz(taba, nb))
r->tab[0] |= 1;
bf_free(r->ctx, taba);
r->expn = a->expn - b->expn + LIMB_BITS;
r->sign = r_sign;
ret = bf_normalize_and_round(r, prec, flags);
}
return ret;
fail:
bf_set_nan(r);
return BF_ST_MEM_ERROR;
} | O2 | c | _bf_div:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movabsq $0x7ffffffffffffffd, %rax # imm = 0x7FFFFFFFFFFFFFFD
movl 0x8(%rdx), %ebp
xorl 0x8(%rsi), %ebp
movq 0x10(%rsi), %rcx
cmpq %rax, %rcx
jle 0x758ee
leaq 0x2(%rax), %rdx
cmpq %rdx, %rcx
je 0x75901
movq 0x10(%r12), %rdx
jmp 0x758f8
movq 0x10(%r12), %rdx
cmpq %rax, %rdx
jle 0x7590e
leaq 0x2(%rax), %rsi
cmpq %rsi, %rdx
jne 0x7591e
movq %rbx, %rdi
callq 0x7317d
xorl %r14d, %r14d
jmp 0x7594e
addq $0x3, %rax
cmpq %rax, %rcx
jne 0x7593b
cmpq %rax, %rdx
je 0x7592f
jmp 0x75971
incq %rax
movq %rcx, %rsi
xorq %rax, %rsi
xorq %rax, %rdx
orq %rsi, %rdx
jne 0x75960
movq %rbx, %rdi
callq 0x7317d
pushq $0x1
jmp 0x7594c
cmpq %rax, %rdx
jne 0x7597d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x731ec
pushq $0x2
popq %r14
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rax, %rcx
jne 0x75971
movq %rbx, %rdi
movl %ebp, %esi
callq 0x731ec
jmp 0x75909
movq %rbx, %rdi
movl %ebp, %esi
callq 0x731c2
jmp 0x75909
movq %rsi, %r13
leaq 0x41(%r15), %rsi
shrq $0x6, %rsi
movq 0x18(%r12), %rcx
movq 0x18(%r13), %rax
cmpq %rsi, %rax
cmovgq %rax, %rsi
leaq (%rsi,%rcx), %rdx
pushq $0x20
popq %r14
movabsq $0x1ffffffffffffffd, %rax # imm = 0x1FFFFFFFFFFFFFFD
cmpq %rax, %rdx
ja 0x7594e
movq %rsi, 0x30(%rsp)
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movq (%rbx), %rax
movq %rdx, 0x20(%rsp)
leaq 0x8(,%rdx,8), %rdx
movq (%rax), %rdi
xorl %esi, %esi
movq %rax, 0x18(%rsp)
callq *0x8(%rax)
testq %rax, %rax
je 0x75a70
movq 0x20(%rsp), %rcx
subq 0x18(%r13), %rcx
movq %rcx, 0x28(%rsp)
leaq (,%rcx,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
movq %rax, (%rsp)
callq 0xe390
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
leaq (%rcx,%rax,8), %rdi
movq 0x18(%r13), %rdx
movq 0x20(%r13), %rsi
shlq $0x3, %rdx
callq 0xe630
movq 0x30(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0x730bf
testl %eax, %eax
jne 0x75a5f
movq 0x20(%rbx), %rsi
movq 0x20(%r12), %r8
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %r9
callq 0x74416
testl %eax, %eax
je 0x75a7d
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
xorl %edx, %edx
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x7317d
jmp 0x7594e
movq (%rsp), %rdi
movq %rdi, %r14
movq 0x10(%rsp), %rsi
callq 0x74939
testq %rax, %rax
je 0x75a9b
movq 0x20(%rbx), %rax
orq $0x1, (%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rax)
movq 0x10(%r13), %rax
subq 0x10(%r12), %rax
addq $0x40, %rax
movq %rax, 0x10(%rbx)
movl %ebp, 0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x732b7
| __bf_div:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15, rcx
mov r12, rdx
mov rbx, rdi
mov rax, 7FFFFFFFFFFFFFFDh
mov ebp, [rdx+8]
xor ebp, [rsi+8]
mov rcx, [rsi+10h]
cmp rcx, rax
jle short loc_758EE
lea rdx, [rax+2]
cmp rcx, rdx
jz short loc_75901
mov rdx, [r12+10h]
jmp short loc_758F8
loc_758EE:
mov rdx, [r12+10h]
cmp rdx, rax
jle short loc_7590E
loc_758F8:
lea rsi, [rax+2]
cmp rdx, rsi
jnz short loc_7591E
loc_75901:
mov rdi, rbx
call bf_set_nan
loc_75909:
xor r14d, r14d
jmp short loc_7594E
loc_7590E:
add rax, 3
cmp rcx, rax
jnz short loc_7593B
cmp rdx, rax
jz short loc_7592F
jmp short loc_75971
loc_7591E:
inc rax
mov rsi, rcx
xor rsi, rax
xor rdx, rax
or rdx, rsi
jnz short loc_75960
loc_7592F:
mov rdi, rbx
call bf_set_nan
push 1
jmp short loc_7594C
loc_7593B:
cmp rdx, rax
jnz short loc_7597D
mov rdi, rbx
mov esi, ebp
call bf_set_inf
push 2
loc_7594C:
pop r14
loc_7594E:
mov eax, r14d
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_75960:
cmp rcx, rax
jnz short loc_75971
mov rdi, rbx
mov esi, ebp
call bf_set_inf
jmp short loc_75909
loc_75971:
mov rdi, rbx
mov esi, ebp
call bf_set_zero
jmp short loc_75909
loc_7597D:
mov r13, rsi
lea rsi, [r15+41h]
shr rsi, 6
mov rcx, [r12+18h]
mov rax, [r13+18h]
cmp rax, rsi
cmovg rsi, rax
lea rdx, [rsi+rcx]
push 20h ; ' '
pop r14
mov rax, 1FFFFFFFFFFFFFFDh
cmp rdx, rax
ja short loc_7594E
mov [rsp+68h+var_38], rsi
mov [rsp+68h+var_58], rcx
mov [rsp+68h+var_5C], r8d
mov rax, [rbx]
mov [rsp+68h+var_48], rdx
lea rdx, ds:8[rdx*8]
mov rdi, [rax]
xor esi, esi
mov [rsp+68h+var_50], rax
call qword ptr [rax+8]
test rax, rax
jz loc_75A70
mov rcx, [rsp+68h+var_48]
sub rcx, [r13+18h]
mov [rsp+68h+var_40], rcx
lea rdx, ds:0[rcx*8]
mov rdi, rax
xor esi, esi
mov [rsp+68h+var_68], rax
call _memset
mov rax, [rsp+68h+var_40]
mov rcx, [rsp+68h+var_68]
lea rdi, [rcx+rax*8]
mov rdx, [r13+18h]
mov rsi, [r13+20h]
shl rdx, 3
call _memcpy
mov rsi, [rsp+68h+var_38]
inc rsi
mov rdi, rbx
call bf_resize
test eax, eax
jnz short loc_75A5F
mov rsi, [rbx+20h]
mov r8, [r12+20h]
mov rdi, [rsp+68h+var_50]
mov rdx, [rsp+68h+var_68]
mov rcx, [rsp+68h+var_48]
mov r9, [rsp+68h+var_58]
call mp_divnorm
test eax, eax
jz short loc_75A7D
loc_75A5F:
mov rax, [rsp+68h+var_50]
mov rdi, [rax]
mov rsi, [rsp+68h+var_68]
xor edx, edx
call qword ptr [rax+8]
loc_75A70:
mov rdi, rbx
call bf_set_nan
jmp loc_7594E
loc_75A7D:
mov rdi, [rsp+68h+var_68]
mov r14, rdi
mov rsi, [rsp+68h+var_58]
call mp_scan_nz
test rax, rax
jz short loc_75A9B
mov rax, [rbx+20h]
or qword ptr [rax], 1
loc_75A9B:
mov rax, [rbx]
mov rdi, [rax]
mov rsi, r14
xor edx, edx
call qword ptr [rax+8]
mov rax, [r13+10h]
sub rax, [r12+10h]
add rax, 40h ; '@'
mov [rbx+10h], rax
mov [rbx+8], ebp
mov rdi, rbx
mov rsi, r15
mov edx, [rsp+68h+var_5C]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_normalize_and_round
| long long _bf_div(_QWORD *a1, long long a2, long long a3, long long a4, unsigned int a5)
{
int v7; // ebp
long long v8; // rcx
long long v9; // rdx
unsigned int v10; // r14d
signed long long v13; // rsi
long long v14; // rcx
long long v15; // rax
_QWORD *v17; // [rsp+0h] [rbp-68h]
unsigned long long v19; // [rsp+10h] [rbp-58h]
_QWORD *v20; // [rsp+18h] [rbp-50h]
unsigned long long v21; // [rsp+20h] [rbp-48h]
unsigned long long v22; // [rsp+28h] [rbp-40h]
v7 = *(_DWORD *)(a2 + 8) ^ *(_DWORD *)(a3 + 8);
v8 = *(_QWORD *)(a2 + 16);
if ( v8 > 0x7FFFFFFFFFFFFFFDLL )
{
if ( v8 == 0x7FFFFFFFFFFFFFFFLL )
{
LABEL_6:
bf_set_nan((long long)a1);
return 0;
}
v9 = *(_QWORD *)(a3 + 16);
goto LABEL_5;
}
v9 = *(_QWORD *)(a3 + 16);
if ( v9 > 0x7FFFFFFFFFFFFFFDLL )
{
LABEL_5:
if ( v9 == 0x7FFFFFFFFFFFFFFFLL )
goto LABEL_6;
if ( !(v8 ^ 0x7FFFFFFFFFFFFFFELL | v9 ^ 0x7FFFFFFFFFFFFFFELL) )
goto LABEL_12;
if ( v8 == 0x7FFFFFFFFFFFFFFELL )
{
bf_set_inf((long long)a1, v7);
return 0;
}
goto LABEL_19;
}
if ( v8 == 0x8000000000000000LL )
{
if ( v9 == 0x8000000000000000LL )
{
LABEL_12:
bf_set_nan((long long)a1);
return 1;
}
LABEL_19:
bf_set_zero((long long)a1, v7);
return 0;
}
if ( v9 == 0x8000000000000000LL )
{
bf_set_inf((long long)a1, v7);
return 2;
}
v13 = (unsigned long long)(a4 + 65) >> 6;
v14 = *(_QWORD *)(a3 + 24);
if ( *(_QWORD *)(a2 + 24) > v13 )
v13 = *(_QWORD *)(a2 + 24);
v10 = 32;
if ( (unsigned long long)(v13 + v14) > 0x1FFFFFFFFFFFFFFDLL )
return v10;
v19 = *(_QWORD *)(a3 + 24);
v21 = v13 + v14;
v20 = (_QWORD *)*a1;
v15 = (*(long long ( **)(_QWORD, _QWORD, signed long long))(*a1 + 8LL))(
*(_QWORD *)*a1,
0LL,
8 * (v13 + v14) + 8);
if ( !v15 )
{
LABEL_27:
bf_set_nan((long long)a1);
return v10;
}
v22 = v21 - *(_QWORD *)(a2 + 24);
v17 = (_QWORD *)v15;
memset(v15, 0LL, 8 * v22);
memcpy(&v17[v22], *(_QWORD *)(a2 + 32), 8LL * *(_QWORD *)(a2 + 24));
if ( (unsigned int)bf_resize((long long)a1, v13 + 1)
|| (unsigned int)mp_divnorm(v20, a1[4], v17, v21, *(_QWORD *)(a3 + 32), v19) )
{
((void ( *)(_QWORD, _QWORD *, _QWORD))v20[1])(*v20, v17, 0LL);
goto LABEL_27;
}
if ( mp_scan_nz((long long)v17, v19) )
*(_QWORD *)a1[4] |= 1uLL;
(*(void ( **)(_QWORD, _QWORD *, _QWORD))(*a1 + 8LL))(*(_QWORD *)*a1, v17, 0LL);
a1[2] = *(_QWORD *)(a2 + 16) - *(_QWORD *)(a3 + 16) + 64LL;
*((_DWORD *)a1 + 2) = v7;
return bf_normalize_and_round(a1, a4, a5);
}
| __bf_div:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15,RCX
MOV R12,RDX
MOV RBX,RDI
MOV RAX,0x7ffffffffffffffd
MOV EBP,dword ptr [RDX + 0x8]
XOR EBP,dword ptr [RSI + 0x8]
MOV RCX,qword ptr [RSI + 0x10]
CMP RCX,RAX
JLE 0x001758ee
LEA RDX,[RAX + 0x2]
CMP RCX,RDX
JZ 0x00175901
MOV RDX,qword ptr [R12 + 0x10]
JMP 0x001758f8
LAB_001758ee:
MOV RDX,qword ptr [R12 + 0x10]
CMP RDX,RAX
JLE 0x0017590e
LAB_001758f8:
LEA RSI,[RAX + 0x2]
CMP RDX,RSI
JNZ 0x0017591e
LAB_00175901:
MOV RDI,RBX
CALL 0x0017317d
LAB_00175909:
XOR R14D,R14D
JMP 0x0017594e
LAB_0017590e:
ADD RAX,0x3
CMP RCX,RAX
JNZ 0x0017593b
CMP RDX,RAX
JZ 0x0017592f
JMP 0x00175971
LAB_0017591e:
INC RAX
MOV RSI,RCX
XOR RSI,RAX
XOR RDX,RAX
OR RDX,RSI
JNZ 0x00175960
LAB_0017592f:
MOV RDI,RBX
CALL 0x0017317d
PUSH 0x1
JMP 0x0017594c
LAB_0017593b:
CMP RDX,RAX
JNZ 0x0017597d
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001731ec
PUSH 0x2
LAB_0017594c:
POP R14
LAB_0017594e:
MOV EAX,R14D
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00175960:
CMP RCX,RAX
JNZ 0x00175971
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001731ec
JMP 0x00175909
LAB_00175971:
MOV RDI,RBX
MOV ESI,EBP
CALL 0x001731c2
JMP 0x00175909
LAB_0017597d:
MOV R13,RSI
LEA RSI,[R15 + 0x41]
SHR RSI,0x6
MOV RCX,qword ptr [R12 + 0x18]
MOV RAX,qword ptr [R13 + 0x18]
CMP RAX,RSI
CMOVG RSI,RAX
LEA RDX,[RSI + RCX*0x1]
PUSH 0x20
POP R14
MOV RAX,0x1ffffffffffffffd
CMP RDX,RAX
JA 0x0017594e
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x10],RCX
MOV dword ptr [RSP + 0xc],R8D
MOV RAX,qword ptr [RBX]
MOV qword ptr [RSP + 0x20],RDX
LEA RDX,[0x8 + RDX*0x8]
MOV RDI,qword ptr [RAX]
XOR ESI,ESI
MOV qword ptr [RSP + 0x18],RAX
CALL qword ptr [RAX + 0x8]
TEST RAX,RAX
JZ 0x00175a70
MOV RCX,qword ptr [RSP + 0x20]
SUB RCX,qword ptr [R13 + 0x18]
MOV qword ptr [RSP + 0x28],RCX
LEA RDX,[RCX*0x8]
MOV RDI,RAX
XOR ESI,ESI
MOV qword ptr [RSP],RAX
CALL 0x0010e390
MOV RAX,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP]
LEA RDI,[RCX + RAX*0x8]
MOV RDX,qword ptr [R13 + 0x18]
MOV RSI,qword ptr [R13 + 0x20]
SHL RDX,0x3
CALL 0x0010e630
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
MOV RDI,RBX
CALL 0x001730bf
TEST EAX,EAX
JNZ 0x00175a5f
MOV RSI,qword ptr [RBX + 0x20]
MOV R8,qword ptr [R12 + 0x20]
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x10]
CALL 0x00174416
TEST EAX,EAX
JZ 0x00175a7d
LAB_00175a5f:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RSP]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_00175a70:
MOV RDI,RBX
CALL 0x0017317d
JMP 0x0017594e
LAB_00175a7d:
MOV RDI,qword ptr [RSP]
MOV R14,RDI
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x00174939
TEST RAX,RAX
JZ 0x00175a9b
MOV RAX,qword ptr [RBX + 0x20]
OR qword ptr [RAX],0x1
LAB_00175a9b:
MOV RAX,qword ptr [RBX]
MOV RDI,qword ptr [RAX]
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R13 + 0x10]
SUB RAX,qword ptr [R12 + 0x10]
ADD RAX,0x40
MOV qword ptr [RBX + 0x10],RAX
MOV dword ptr [RBX + 0x8],EBP
MOV RDI,RBX
MOV RSI,R15
MOV EDX,dword ptr [RSP + 0xc]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001732b7
|
int8 __bf_div(long *param_1,long param_2,long param_3,long param_4,int4 param_5)
{
ulong uVar1;
int8 *puVar2;
int iVar3;
void *__s;
long lVar4;
int8 uVar5;
long lVar6;
uint uVar7;
ulong uVar8;
uVar7 = *(uint *)(param_3 + 8) ^ *(uint *)(param_2 + 8);
lVar4 = *(long *)(param_2 + 0x10);
if (lVar4 < 0x7ffffffffffffffe) {
lVar6 = *(long *)(param_3 + 0x10);
if (0x7ffffffffffffffd < lVar6) goto LAB_001758f8;
if (lVar4 != -0x8000000000000000) {
if (lVar6 == -0x8000000000000000) {
bf_set_inf(param_1,uVar7);
return 2;
}
uVar8 = param_4 + 0x41U >> 6;
lVar4 = *(long *)(param_3 + 0x18);
if ((long)uVar8 < (long)*(ulong *)(param_2 + 0x18)) {
uVar8 = *(ulong *)(param_2 + 0x18);
}
uVar1 = uVar8 + lVar4;
if (uVar1 < 0x1ffffffffffffffe) {
puVar2 = (int8 *)*param_1;
__s = (void *)(*(code *)puVar2[1])(*puVar2,0,uVar1 * 8 + 8);
if (__s != (void *)0x0) {
lVar6 = uVar1 - *(long *)(param_2 + 0x18);
memset(__s,0,lVar6 * 8);
memcpy((void *)((long)__s + lVar6 * 8),*(void **)(param_2 + 0x20),
*(long *)(param_2 + 0x18) << 3);
iVar3 = bf_resize(param_1,uVar8 + 1);
if ((iVar3 == 0) &&
(iVar3 = mp_divnorm(puVar2,param_1[4],__s,uVar1,*(int8 *)(param_3 + 0x20),lVar4),
iVar3 == 0)) {
lVar4 = mp_scan_nz(__s,lVar4);
if (lVar4 != 0) {
*(ulong *)param_1[4] = *(ulong *)param_1[4] | 1;
}
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,__s,0);
param_1[2] = (*(long *)(param_2 + 0x10) - *(long *)(param_3 + 0x10)) + 0x40;
*(uint *)(param_1 + 1) = uVar7;
uVar5 = bf_normalize_and_round(param_1,param_4,param_5);
return uVar5;
}
(*(code *)puVar2[1])(*puVar2,__s,0);
}
bf_set_nan(param_1);
return 0x20;
}
return 0x20;
}
if (lVar6 == -0x8000000000000000) goto LAB_0017592f;
LAB_00175971:
bf_set_zero(param_1,uVar7);
}
else {
if (lVar4 != 0x7fffffffffffffff) {
lVar6 = *(long *)(param_3 + 0x10);
LAB_001758f8:
if (lVar6 != 0x7fffffffffffffff) {
if (lVar6 == 0x7ffffffffffffffe && lVar4 == 0x7ffffffffffffffe) {
LAB_0017592f:
bf_set_nan(param_1);
return 1;
}
if (lVar4 == 0x7ffffffffffffffe) {
bf_set_inf(param_1,uVar7);
return 0;
}
goto LAB_00175971;
}
}
bf_set_nan(param_1);
}
return 0;
}
| |
23,617 | js_cond_wait | bluesky950520[P]quickjs/cutils.c | void js_cond_wait(js_cond_t *cond, js_mutex_t *mutex) {
#if defined(__APPLE__) && defined(__MACH__)
int r;
errno = 0;
r = pthread_cond_wait(cond, mutex);
/* Workaround for a bug in OS X at least up to 13.6
* See https://github.com/libuv/libuv/issues/4165
*/
if (r == EINVAL && errno == EBUSY)
return;
if (r)
abort();
#else
if (pthread_cond_wait(cond, mutex))
abort();
#endif
} | O0 | c | js_cond_wait:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe1f0
cmpl $0x0, %eax
je 0x21067
callq 0xe090
addq $0x18, %rsp
retq
nopl (%rax)
| js_cond_wait:
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 _pthread_cond_wait
cmp eax, 0
jz short loc_21067
call _abort
loc_21067:
add rsp, 18h
retn
| long long js_cond_wait(long long a1, long long a2)
{
long long result; // rax
result = pthread_cond_wait(a1, a2);
if ( (_DWORD)result )
abort();
return result;
}
| js_cond_wait:
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 0x0010e1f0
CMP EAX,0x0
JZ 0x00121067
CALL 0x0010e090
LAB_00121067:
ADD RSP,0x18
RET
|
void js_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2)
{
int iVar1;
iVar1 = pthread_cond_wait(param_1,param_2);
if (iVar1 != 0) {
/* WARNING: Subroutine does not return */
abort();
}
return;
}
| |
23,618 | js_cond_wait | bluesky950520[P]quickjs/cutils.c | void js_cond_wait(js_cond_t *cond, js_mutex_t *mutex) {
#if defined(__APPLE__) && defined(__MACH__)
int r;
errno = 0;
r = pthread_cond_wait(cond, mutex);
/* Workaround for a bug in OS X at least up to 13.6
* See https://github.com/libuv/libuv/issues/4165
*/
if (r == EINVAL && errno == EBUSY)
return;
if (r)
abort();
#else
if (pthread_cond_wait(cond, mutex))
abort();
#endif
} | O1 | c | js_cond_wait:
pushq %rax
callq 0xe1f0
testl %eax, %eax
jne 0x1c81b
popq %rax
retq
callq 0xe090
| js_cond_wait:
push rax
call _pthread_cond_wait
test eax, eax
jnz short loc_1C81B
pop rax
retn
loc_1C81B:
call _abort
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_wait(long long a1)
{
if ( (unsigned int)pthread_cond_wait() )
abort(a1);
}
| js_cond_wait:
PUSH RAX
CALL 0x0010e1f0
TEST EAX,EAX
JNZ 0x0011c81b
POP RAX
RET
LAB_0011c81b:
CALL 0x0010e090
|
int8 js_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_wait(param_1,param_2);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
23,619 | js_cond_wait | bluesky950520[P]quickjs/cutils.c | void js_cond_wait(js_cond_t *cond, js_mutex_t *mutex) {
#if defined(__APPLE__) && defined(__MACH__)
int r;
errno = 0;
r = pthread_cond_wait(cond, mutex);
/* Workaround for a bug in OS X at least up to 13.6
* See https://github.com/libuv/libuv/issues/4165
*/
if (r == EINVAL && errno == EBUSY)
return;
if (r)
abort();
#else
if (pthread_cond_wait(cond, mutex))
abort();
#endif
} | O2 | c | js_cond_wait:
pushq %rax
callq 0xe200
testl %eax, %eax
jne 0x16e4b
popq %rax
retq
callq 0xe090
| js_cond_wait:
push rax
call _pthread_cond_wait
test eax, eax
jnz short loc_16E4B
pop rax
retn
loc_16E4B:
call _abort
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_wait(long long a1)
{
if ( (unsigned int)pthread_cond_wait() )
abort(a1);
}
| js_cond_wait:
PUSH RAX
CALL 0x0010e200
TEST EAX,EAX
JNZ 0x00116e4b
POP RAX
RET
LAB_00116e4b:
CALL 0x0010e090
|
int8 js_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_wait(param_1,param_2);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
23,620 | js_cond_wait | bluesky950520[P]quickjs/cutils.c | void js_cond_wait(js_cond_t *cond, js_mutex_t *mutex) {
#if defined(__APPLE__) && defined(__MACH__)
int r;
errno = 0;
r = pthread_cond_wait(cond, mutex);
/* Workaround for a bug in OS X at least up to 13.6
* See https://github.com/libuv/libuv/issues/4165
*/
if (r == EINVAL && errno == EBUSY)
return;
if (r)
abort();
#else
if (pthread_cond_wait(cond, mutex))
abort();
#endif
} | O3 | c | js_cond_wait:
pushq %rax
callq 0xe1f0
testl %eax, %eax
jne 0x1d119
popq %rax
retq
callq 0xe090
| js_cond_wait:
push rax
call _pthread_cond_wait
test eax, eax
jnz short loc_1D119
pop rax
retn
loc_1D119:
call _abort
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> js_cond_wait(long long a1)
{
if ( (unsigned int)pthread_cond_wait() )
abort(a1);
}
| js_cond_wait:
PUSH RAX
CALL 0x0010e1f0
TEST EAX,EAX
JNZ 0x0011d119
POP RAX
RET
LAB_0011d119:
CALL 0x0010e090
|
int8 js_cond_wait(pthread_cond_t *param_1,pthread_mutex_t *param_2)
{
int iVar1;
int8 in_RAX;
iVar1 = pthread_cond_wait(param_1,param_2);
if (iVar1 == 0) {
return in_RAX;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
23,621 | my_sync_dir | eloqsql/mysys/my_sync.c | int my_sync_dir(const char *dir_name __attribute__((unused)),
myf my_flags __attribute__((unused)))
{
#ifdef NEED_EXPLICIT_SYNC_DIR
static const char cur_dir_name[]= {FN_CURLIB, 0};
File dir_fd;
int res= 0;
const char *correct_dir_name;
DBUG_ENTER("my_sync_dir");
DBUG_PRINT("my",("Dir: '%s' my_flags: %lu", dir_name, my_flags));
/* Sometimes the path does not contain an explicit directory */
correct_dir_name= (dir_name[0] == 0) ? cur_dir_name : dir_name;
/*
Syncing a dir may give EINVAL on tmpfs on Linux, which is ok.
EIO on the other hand is very important. Hence MY_IGNORE_BADFD.
*/
if ((dir_fd= my_open(correct_dir_name, O_RDONLY, MYF(my_flags))) >= 0)
{
if (my_sync(dir_fd, MYF(my_flags | MY_IGNORE_BADFD)))
res= 2;
if (my_close(dir_fd, MYF(my_flags)))
res= 3;
}
else
res= 1;
DBUG_RETURN(res);
#else
return 0;
#endif
} | O0 | c | my_sync_dir:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
jmp 0xfc599
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xfc5b2
leaq 0x67360(%rip), %rax # 0x16390c
movq %rax, -0x28(%rbp)
jmp 0xfc5ba
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0xfa960
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0xfc60f
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
orq $0x20, %rsi
callq 0xfc3f0
cmpl $0x0, %eax
je 0xfc5f5
movl $0x2, -0x18(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xfabf0
cmpl $0x0, %eax
je 0xfc60d
movl $0x3, -0x18(%rbp)
jmp 0xfc616
movl $0x1, -0x18(%rbp)
jmp 0xfc618
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| my_sync_dir:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
jmp short $+2
loc_FC599:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 0
jnz short loc_FC5B2
lea rax, my_sync_dir_cur_dir_name
mov [rbp+var_28], rax
jmp short loc_FC5BA
loc_FC5B2:
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
loc_FC5BA:
mov rax, [rbp+var_28]
mov [rbp+var_20], rax
mov rdi, [rbp+var_20]
mov rdx, [rbp+var_10]
xor esi, esi
call my_open
mov [rbp+var_14], eax
cmp eax, 0
jl short loc_FC60F
mov edi, [rbp+var_14]
mov rsi, [rbp+var_10]
or rsi, 20h
call my_sync
cmp eax, 0
jz short loc_FC5F5
mov [rbp+var_18], 2
loc_FC5F5:
mov edi, [rbp+var_14]
mov rsi, [rbp+var_10]
call my_close
cmp eax, 0
jz short loc_FC60D
mov [rbp+var_18], 3
loc_FC60D:
jmp short loc_FC616
loc_FC60F:
mov [rbp+var_18], 1
loc_FC616:
jmp short $+2
loc_FC618:
mov eax, [rbp+var_18]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
add rsp, 30h
pop rbp
retn
| long long my_sync_dir(_BYTE *a1, long long a2)
{
void *v3; // [rsp+8h] [rbp-28h]
unsigned int v4; // [rsp+18h] [rbp-18h]
signed int v5; // [rsp+1Ch] [rbp-14h]
v4 = 0;
if ( *a1 )
v3 = a1;
else
v3 = &my_sync_dir_cur_dir_name;
v5 = my_open((long long)v3, 0, a2);
if ( v5 < 0 )
{
return 1;
}
else
{
if ( (unsigned int)my_sync(v5, (const char *)(a2 | 0x20)) )
v4 = 2;
if ( (unsigned int)my_close(v5, (const char *)a2) )
return 3;
}
return v4;
}
| my_sync_dir:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x18],0x0
JMP 0x001fc599
LAB_001fc599:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JNZ 0x001fc5b2
LEA RAX,[0x26390c]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001fc5ba
LAB_001fc5b2:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001fc5ba:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RDI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
XOR ESI,ESI
CALL 0x001fa960
MOV dword ptr [RBP + -0x14],EAX
CMP EAX,0x0
JL 0x001fc60f
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x10]
OR RSI,0x20
CALL 0x001fc3f0
CMP EAX,0x0
JZ 0x001fc5f5
MOV dword ptr [RBP + -0x18],0x2
LAB_001fc5f5:
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001fabf0
CMP EAX,0x0
JZ 0x001fc60d
MOV dword ptr [RBP + -0x18],0x3
LAB_001fc60d:
JMP 0x001fc616
LAB_001fc60f:
MOV dword ptr [RBP + -0x18],0x1
LAB_001fc616:
JMP 0x001fc618
LAB_001fc618:
MOV EAX,dword ptr [RBP + -0x18]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD RSP,0x30
POP RBP
RET
|
int4 my_sync_dir(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
char *local_30;
int4 local_20;
local_20 = 0;
local_30 = param_1;
if (*param_1 == '\0') {
local_30 = ".";
}
iVar1 = my_open(local_30,0,param_2);
if (iVar1 < 0) {
local_20 = 1;
}
else {
iVar2 = my_sync(iVar1,param_2 | 0x20);
if (iVar2 != 0) {
local_20 = 2;
}
iVar1 = my_close(iVar1,param_2);
if (iVar1 != 0) {
local_20 = 3;
}
}
return local_20;
}
| |
23,622 | mp_sub_mul1 | bluesky950520[P]quickjs/libbf.c | static limb_t mp_sub_mul1(limb_t *tabr, const limb_t *taba, limb_t n,
limb_t b)
{
limb_t i, l;
dlimb_t t;
l = 0;
for(i = 0; i < n; i++) {
t = tabr[i] - (dlimb_t)taba[i] * (dlimb_t)b - l;
tabr[i] = t;
l = -(t >> LIMB_BITS);
}
return l;
} | O0 | c | mp_sub_mul1:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq $0x0, -0x30(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0xf5182
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rdx
movq (%rax,%rdx,8), %rcx
movq -0x10(%rsp), %rax
movq (%rax,%rdx,8), %rax
movq -0x20(%rsp), %rdx
mulq %rdx
movq %rax, %rsi
xorl %eax, %eax
subq %rsi, %rcx
sbbq %rdx, %rax
movq -0x30(%rsp), %rdx
subq %rdx, %rcx
sbbq $0x0, %rax
movq %rcx, -0x48(%rsp)
movq %rax, -0x40(%rsp)
movq -0x48(%rsp), %rdx
movq -0x8(%rsp), %rax
movq -0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rsp), %rax
negq %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0xf5106
movq -0x30(%rsp), %rax
retq
nopl (%rax,%rax)
| mp_sub_mul1:
mov [rsp+var_8], rdi
mov [rsp+var_10], rsi
mov [rsp+var_18], rdx
mov [rsp+var_20], rcx
mov [rsp+var_30], 0
mov [rsp+var_28], 0
loc_F5106:
mov rax, [rsp+var_28]
cmp rax, [rsp+var_18]
jnb short loc_F5182
mov rax, [rsp+var_8]
mov rdx, [rsp+var_28]
mov rcx, [rax+rdx*8]
mov rax, [rsp+var_10]
mov rax, [rax+rdx*8]
mov rdx, [rsp+var_20]
mul rdx
mov rsi, rax
xor eax, eax
sub rcx, rsi
sbb rax, rdx
mov rdx, [rsp+var_30]
sub rcx, rdx
sbb rax, 0
mov [rsp+var_48], rcx
mov [rsp+var_40], rax
mov rdx, [rsp+var_48]
mov rax, [rsp+var_8]
mov rcx, [rsp+var_28]
mov [rax+rcx*8], rdx
mov rax, [rsp+var_40]
neg rax
mov [rsp+var_30], rax
mov rax, [rsp+var_28]
add rax, 1
mov [rsp+var_28], rax
jmp short loc_F5106
loc_F5182:
mov rax, [rsp+var_30]
retn
| long long mp_sub_mul1(long long a1, long long a2, unsigned long long a3, unsigned long long a4)
{
unsigned __int128 v4; // kr00_16
long long v6; // [rsp+18h] [rbp-30h]
unsigned long long i; // [rsp+20h] [rbp-28h]
v6 = 0LL;
for ( i = 0LL; i < a3; ++i )
{
v4 = *(unsigned long long *)(a1 + 8 * i) - a4 * (unsigned __int128)*(unsigned long long *)(a2 + 8 * i);
*(_QWORD *)(a1 + 8 * i) = v4 - v6;
v6 = -(long long)((v4 - (unsigned long long)v6) >> 64);
}
return v6;
}
| mp_sub_mul1:
MOV qword ptr [RSP + -0x8],RDI
MOV qword ptr [RSP + -0x10],RSI
MOV qword ptr [RSP + -0x18],RDX
MOV qword ptr [RSP + -0x20],RCX
MOV qword ptr [RSP + -0x30],0x0
MOV qword ptr [RSP + -0x28],0x0
LAB_001f5106:
MOV RAX,qword ptr [RSP + -0x28]
CMP RAX,qword ptr [RSP + -0x18]
JNC 0x001f5182
MOV RAX,qword ptr [RSP + -0x8]
MOV RDX,qword ptr [RSP + -0x28]
MOV RCX,qword ptr [RAX + RDX*0x8]
MOV RAX,qword ptr [RSP + -0x10]
MOV RAX,qword ptr [RAX + RDX*0x8]
MOV RDX,qword ptr [RSP + -0x20]
MUL RDX
MOV RSI,RAX
XOR EAX,EAX
SUB RCX,RSI
SBB RAX,RDX
MOV RDX,qword ptr [RSP + -0x30]
SUB RCX,RDX
SBB RAX,0x0
MOV qword ptr [RSP + -0x48],RCX
MOV qword ptr [RSP + -0x40],RAX
MOV RDX,qword ptr [RSP + -0x48]
MOV RAX,qword ptr [RSP + -0x8]
MOV RCX,qword ptr [RSP + -0x28]
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP + -0x40]
NEG RAX
MOV qword ptr [RSP + -0x30],RAX
MOV RAX,qword ptr [RSP + -0x28]
ADD RAX,0x1
MOV qword ptr [RSP + -0x28],RAX
JMP 0x001f5106
LAB_001f5182:
MOV RAX,qword ptr [RSP + -0x30]
RET
|
ulong mp_sub_mul1(long param_1,long param_2,ulong param_3,ulong param_4)
{
ulong uVar1;
int1 auVar2 [16];
int1 auVar3 [16];
ulong uVar4;
ulong uVar5;
int8 local_30;
int8 local_28;
local_30 = 0;
for (local_28 = 0; local_28 < param_3; local_28 = local_28 + 1) {
uVar1 = *(ulong *)(param_1 + local_28 * 8);
auVar2._8_8_ = 0;
auVar2._0_8_ = *(ulong *)(param_2 + local_28 * 8);
auVar3._8_8_ = 0;
auVar3._0_8_ = param_4;
uVar4 = SUB168(auVar2 * auVar3,0);
uVar5 = uVar1 - uVar4;
*(ulong *)(param_1 + local_28 * 8) = uVar5 - local_30;
local_30 = -((-(ulong)(uVar1 < uVar4) - SUB168(auVar2 * auVar3,8)) - (ulong)(uVar5 < local_30));
}
return local_30;
}
| |
23,623 | LefDefParser::defiComponent::changeIdAndName(char const*, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiComponent.cpp | void defiComponent::changeIdAndName(const char* id, const char* name) {
int len;
if ((len = strlen(id)+1) > idSize_)
bumpId(len);
strcpy(id_, defData->DEFCASE(id));
if ((len = strlen(name)+1) > nameSize_)
bumpName(len);
strcpy(name_, defData->DEFCASE(name));
} | O3 | cpp | LefDefParser::defiComponent::changeIdAndName(char const*, char const*):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x70d0
incl %eax
cmpl 0x14(%r14), %eax
jle 0x12f2f
movq %r14, %rdi
movl %eax, %esi
callq 0x125cc
movq (%r14), %r12
movq 0x150(%r14), %rdi
movq %r15, %rsi
callq 0x1b638
movq %r12, %rdi
movq %rax, %rsi
callq 0x7190
movq %rbx, %rdi
callq 0x70d0
incl %eax
cmpl 0x10(%r14), %eax
jle 0x12f66
movq %r14, %rdi
movl %eax, %esi
callq 0x1259a
movq 0x8(%r14), %r15
movq 0x150(%r14), %rdi
movq %rbx, %rsi
callq 0x1b638
movq %r15, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7190
nop
| _ZN12LefDefParser13defiComponent15changeIdAndNameEPKcS2_:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rdi, rsi
call _strlen
inc eax
cmp eax, [r14+14h]
jle short loc_12F2F
mov rdi, r14; this
mov esi, eax; int
call _ZN12LefDefParser13defiComponent6bumpIdEi; LefDefParser::defiComponent::bumpId(int)
loc_12F2F:
mov r12, [r14]
mov rdi, [r14+150h]; this
mov rsi, r15; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r12
mov rsi, rax
call _strcpy
mov rdi, rbx
call _strlen
inc eax
cmp eax, [r14+10h]
jle short loc_12F66
mov rdi, r14; this
mov esi, eax; int
call _ZN12LefDefParser13defiComponent8bumpNameEi; LefDefParser::defiComponent::bumpName(int)
loc_12F66:
mov r15, [r14+8]
mov rdi, [r14+150h]; this
mov rsi, rbx; char *
call _ZN12LefDefParser8defrData7DEFCASEEPKc; LefDefParser::defrData::DEFCASE(char const*)
mov rdi, r15
mov rsi, rax
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
jmp _strcpy
| long long LefDefParser::defiComponent::changeIdAndName(
LefDefParser::defrData **this,
const char *a2,
const char *a3)
{
int v4; // eax
LefDefParser::defrData *v5; // r12
long long v6; // rax
int v7; // eax
LefDefParser::defrData *v8; // r15
long long v9; // rax
v4 = strlen(a2) + 1;
if ( v4 > *((_DWORD *)this + 5) )
LefDefParser::defiComponent::bumpId((LefDefParser::defiComponent *)this, v4);
v5 = *this;
v6 = LefDefParser::defrData::DEFCASE(this[42], a2);
strcpy(v5, v6);
v7 = strlen(a3) + 1;
if ( v7 > *((_DWORD *)this + 4) )
LefDefParser::defiComponent::bumpName((LefDefParser::defiComponent *)this, v7);
v8 = this[1];
v9 = LefDefParser::defrData::DEFCASE(this[42], a3);
return strcpy(v8, v9);
}
| changeIdAndName:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RDI,RSI
CALL 0x001070d0
INC EAX
CMP EAX,dword ptr [R14 + 0x14]
JLE 0x00112f2f
MOV RDI,R14
MOV ESI,EAX
CALL 0x001125cc
LAB_00112f2f:
MOV R12,qword ptr [R14]
MOV RDI,qword ptr [R14 + 0x150]
MOV RSI,R15
CALL 0x0011b638
MOV RDI,R12
MOV RSI,RAX
CALL 0x00107190
MOV RDI,RBX
CALL 0x001070d0
INC EAX
CMP EAX,dword ptr [R14 + 0x10]
JLE 0x00112f66
MOV RDI,R14
MOV ESI,EAX
CALL 0x0011259a
LAB_00112f66:
MOV R15,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x150]
MOV RSI,RBX
CALL 0x0011b638
MOV RDI,R15
MOV RSI,RAX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
JMP 0x00107190
|
/* LefDefParser::defiComponent::changeIdAndName(char const*, char const*) */
void __thiscall
LefDefParser::defiComponent::changeIdAndName(defiComponent *this,char *param_1,char *param_2)
{
char *pcVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
sVar3 = strlen(param_1);
iVar2 = (int)sVar3 + 1;
if (*(int *)(this + 0x14) < iVar2) {
bumpId(this,iVar2);
}
pcVar1 = *(char **)this;
pcVar4 = (char *)defrData::DEFCASE(*(defrData **)(this + 0x150),param_1);
strcpy(pcVar1,pcVar4);
sVar3 = strlen(param_2);
iVar2 = (int)sVar3 + 1;
if (*(int *)(this + 0x10) < iVar2) {
bumpName(this,iVar2);
}
pcVar1 = *(char **)(this + 8);
pcVar4 = (char *)defrData::DEFCASE(*(defrData **)(this + 0x150),param_2);
strcpy(pcVar1,pcVar4);
return;
}
| |
23,624 | js_symbol_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_symbol_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue str;
JSString *p;
if (!JS_IsUndefined(new_target))
return JS_ThrowTypeError(ctx, "not a constructor");
if (argc == 0 || JS_IsUndefined(argv[0])) {
p = NULL;
} else {
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
}
return JS_NewSymbolInternal(ctx, p, JS_ATOM_TYPE_SYMBOL);
} | O0 | c | js_symbol_constructor:
subq $0x68, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x34550
cmpl $0x0, %eax
jne 0x5da62
movq 0x40(%rsp), %rdi
leaq 0xb6ef8(%rip), %rsi # 0x114944
movb $0x0, %al
callq 0x335f0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
jmp 0x5db0d
cmpl $0x0, 0x3c(%rsp)
je 0x5da7f
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x34550
cmpl $0x0, %eax
je 0x5da8a
movq $0x0, 0x18(%rsp)
jmp 0x5daef
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x30030
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x29fb0
cmpl $0x0, %eax
je 0x5dae5
movl $0x0, 0x58(%rsp)
movq $0x6, 0x60(%rsp)
jmp 0x5db0d
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl $0x3, %edx
callq 0x63780
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax)
| js_symbol_constructor:
sub rsp, 68h
mov [rsp+68h+var_20], rsi
mov [rsp+68h+var_18], rdx
mov [rsp+68h+var_28], rdi
mov [rsp+68h+var_2C], ecx
mov [rsp+68h+var_38], r8
mov rdi, [rsp+68h+var_20]
mov rsi, [rsp+68h+var_18]
call JS_IsUndefined_1
cmp eax, 0
jnz short loc_5DA62
mov rdi, [rsp+68h+var_28]
lea rsi, aNotAConstructo; "not a constructor"
mov al, 0
call JS_ThrowTypeError
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
jmp loc_5DB0D
loc_5DA62:
cmp [rsp+68h+var_2C], 0
jz short loc_5DA7F
mov rax, [rsp+68h+var_38]
mov rdi, [rax]
mov rsi, [rax+8]
call JS_IsUndefined_1
cmp eax, 0
jz short loc_5DA8A
loc_5DA7F:
mov [rsp+68h+var_50], 0
jmp short loc_5DAEF
loc_5DA8A:
mov rdi, [rsp+68h+var_28]
mov rax, [rsp+68h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToString
mov [rsp+68h+var_60], rax
mov [rsp+68h+var_58], rdx
mov rax, [rsp+68h+var_60]
mov [rsp+68h+var_48], rax
mov rax, [rsp+68h+var_58]
mov [rsp+68h+var_40], rax
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_5DAE5
mov dword ptr [rsp+68h+var_10], 0
mov [rsp+68h+var_8], 6
jmp short loc_5DB0D
loc_5DAE5:
mov rax, [rsp+68h+var_48]
mov [rsp+68h+var_50], rax
loc_5DAEF:
mov rdi, [rsp+68h+var_28]
mov rsi, [rsp+68h+var_50]
mov edx, 3
call JS_NewSymbolInternal
mov [rsp+68h+var_10], rax
mov [rsp+68h+var_8], rdx
loc_5DB0D:
mov rax, [rsp+68h+var_10]
mov rdx, [rsp+68h+var_8]
add rsp, 68h
retn
| long long js_symbol_constructor(
long long a1,
long long a2,
int a3,
int a4,
long long *a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
__m128 v17; // xmm4
__m128 v18; // xmm5
long long v19; // rcx
long long v20; // r8
long long v21; // r9
int v23; // edx
char v25; // [rsp+0h] [rbp-68h]
long long v26; // [rsp+8h] [rbp-60h]
long long v29; // [rsp+58h] [rbp-10h]
if ( JS_IsUndefined_1(a2, a3) )
{
if ( !a4 || JS_IsUndefined_1(*a5, a5[1]) )
return JS_NewSymbolInternal(a1, 0LL, 3LL);
v26 = JS_ToString(a1, *a5, a5[1], v19, v20, v21);
if ( JS_IsException_1(v26, v23) )
{
LODWORD(v29) = 0;
return v29;
}
return JS_NewSymbolInternal(a1, v26, 3LL);
}
return JS_ThrowTypeError(
a1,
(long long)"not a constructor",
v13,
v14,
v15,
v16,
a6,
a7,
a8,
a9,
v17,
v18,
a12,
a13,
v25);
}
| js_symbol_constructor:
SUB RSP,0x68
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x50],RDX
MOV qword ptr [RSP + 0x40],RDI
MOV dword ptr [RSP + 0x3c],ECX
MOV qword ptr [RSP + 0x30],R8
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x00134550
CMP EAX,0x0
JNZ 0x0015da62
MOV RDI,qword ptr [RSP + 0x40]
LEA RSI,[0x214944]
MOV AL,0x0
CALL 0x001335f0
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
JMP 0x0015db0d
LAB_0015da62:
CMP dword ptr [RSP + 0x3c],0x0
JZ 0x0015da7f
MOV RAX,qword ptr [RSP + 0x30]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00134550
CMP EAX,0x0
JZ 0x0015da8a
LAB_0015da7f:
MOV qword ptr [RSP + 0x18],0x0
JMP 0x0015daef
LAB_0015da8a:
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00130030
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00129fb0
CMP EAX,0x0
JZ 0x0015dae5
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x6
JMP 0x0015db0d
LAB_0015dae5:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x18],RAX
LAB_0015daef:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,0x3
CALL 0x00163780
MOV qword ptr [RSP + 0x58],RAX
MOV qword ptr [RSP + 0x60],RDX
LAB_0015db0d:
MOV RAX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x60]
ADD RSP,0x68
RET
|
int1 [16]
js_symbol_constructor
(int8 param_1,int8 param_2,int8 param_3,int param_4,int8 *param_5)
{
int iVar1;
int1 auVar2 [16];
int8 local_50;
int4 local_10;
int4 uStack_c;
int8 local_8;
iVar1 = JS_IsUndefined(param_2,param_3);
if (iVar1 == 0) {
auVar2 = JS_ThrowTypeError(param_1,"not a constructor");
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
else {
if ((param_4 == 0) || (iVar1 = JS_IsUndefined(*param_5,param_5[1]), iVar1 != 0)) {
local_50 = 0;
}
else {
auVar2 = JS_ToString(param_1,*param_5,param_5[1]);
local_50 = auVar2._0_8_;
iVar1 = JS_IsException(local_50,auVar2._8_8_);
if (iVar1 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_0015db0d;
}
}
auVar2 = JS_NewSymbolInternal(param_1,local_50,3);
local_8 = auVar2._8_8_;
local_10 = auVar2._0_4_;
uStack_c = auVar2._4_4_;
}
LAB_0015db0d:
auVar2._4_4_ = uStack_c;
auVar2._0_4_ = local_10;
auVar2._8_8_ = local_8;
return auVar2;
}
| |
23,625 | js_symbol_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_symbol_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue str;
JSString *p;
if (!JS_IsUndefined(new_target))
return JS_ThrowTypeError(ctx, "not a constructor");
if (argc == 0 || JS_IsUndefined(argv[0])) {
p = NULL;
} else {
str = JS_ToString(ctx, argv[0]);
if (JS_IsException(str))
return JS_EXCEPTION;
p = JS_VALUE_GET_STRING(str);
}
return JS_NewSymbolInternal(ctx, p, JS_ATOM_TYPE_SYMBOL);
} | O2 | c | js_symbol_constructor:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %edx
jne 0x358bd
testl %ecx, %ecx
je 0x3589e
movq 0x8(%r8), %rdx
cmpl $0x3, %edx
jne 0x358e4
xorl %esi, %esi
pushq $0x3
popq %rdx
movq %rbx, %rdi
callq 0x385da
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x358d6
leaq 0x53fe4(%rip), %rsi # 0x898a8
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
pushq $0x6
popq %rdx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x1ebec
cmpl $0x6, %edx
jne 0x358fc
pushq $0x6
popq %rdx
xorl %r14d, %r14d
jmp 0x358d4
movq %rax, %rsi
jmp 0x358a0
| js_symbol_constructor:
push r14
push rbx
push rax
mov rbx, rdi
cmp edx, 3
jnz short loc_358BD
test ecx, ecx
jz short loc_3589E
mov rdx, [r8+8]
cmp edx, 3
jnz short loc_358E4
loc_3589E:
xor esi, esi
loc_358A0:
push 3
pop rdx
mov rdi, rbx
call JS_NewSymbolInternal
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_358D6
loc_358BD:
lea rsi, aNotAConstructo; "not a constructor"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
push 6
pop rdx
loc_358D4:
xor ecx, ecx
loc_358D6:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
loc_358E4:
mov rsi, [r8]
mov rdi, rbx
call JS_ToString
cmp edx, 6
jnz short loc_358FC
push 6
pop rdx
xor r14d, r14d
jmp short loc_358D4
loc_358FC:
mov rsi, rax
jmp short loc_358A0
| unsigned long long js_symbol_constructor(
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)
{
char v14; // al
long long v15; // rdx
long long v16; // rsi
long long v17; // rax
unsigned long long v18; // rcx
long long v19; // r14
long long v21; // rax
int v22; // edx
if ( (_DWORD)a11 != 3 )
{
v19 = 0LL;
JS_ThrowTypeError(
a1,
(long long)"not a constructor",
a11,
a12,
(long long)a13,
a14,
a2,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
v14);
goto LABEL_7;
}
if ( (_DWORD)a12 )
{
v15 = a13[1];
if ( (_DWORD)v15 != 3 )
{
v21 = JS_ToString(a1, *a13, v15);
if ( v22 != 6 )
{
v16 = v21;
goto LABEL_5;
}
v19 = 0LL;
LABEL_7:
v18 = 0LL;
return v18 | v19;
}
}
v16 = 0LL;
LABEL_5:
v17 = JS_NewSymbolInternal(a1, v16, 3LL);
v18 = v17 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v17;
return v18 | v19;
}
| js_symbol_constructor:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
CMP EDX,0x3
JNZ 0x001358bd
TEST ECX,ECX
JZ 0x0013589e
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,0x3
JNZ 0x001358e4
LAB_0013589e:
XOR ESI,ESI
LAB_001358a0:
PUSH 0x3
POP RDX
MOV RDI,RBX
CALL 0x001385da
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
JMP 0x001358d6
LAB_001358bd:
LEA RSI,[0x1898a8]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
PUSH 0x6
POP RDX
LAB_001358d4:
XOR ECX,ECX
LAB_001358d6:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001358e4:
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x0011ebec
CMP EDX,0x6
JNZ 0x001358fc
PUSH 0x6
POP RDX
XOR R14D,R14D
JMP 0x001358d4
LAB_001358fc:
MOV RSI,RAX
JMP 0x001358a0
|
ulong js_symbol_constructor
(int8 param_1,int8 param_2,int param_3,int param_4,int8 *param_5)
{
ulong uVar1;
ulong uVar2;
int8 uVar3;
int1 auVar4 [12];
if (param_3 == 3) {
if ((param_4 == 0) || ((int)param_5[1] == 3)) {
uVar3 = 0;
}
else {
auVar4 = JS_ToString(param_1,*param_5);
uVar3 = auVar4._0_8_;
if (auVar4._8_4_ == 6) goto LAB_001358d4;
}
uVar1 = JS_NewSymbolInternal(param_1,uVar3,3);
uVar2 = uVar1 & 0xffffffff00000000;
uVar1 = uVar1 & 0xffffffff;
}
else {
JS_ThrowTypeError(param_1,"not a constructor");
LAB_001358d4:
uVar1 = 0;
uVar2 = 0;
}
return uVar1 | uVar2;
}
| |
23,626 | pow5mult | eloqsql/strings/dtoa.c | static Bigint *pow5mult(Bigint *b, int k, Stack_alloc *alloc)
{
Bigint *b1, *p5, *p51=NULL;
int i;
static int p05[3]= { 5, 25, 125 };
my_bool overflow= FALSE;
if ((i= k & 3))
b= multadd(b, p05[i-1], 0, alloc);
if (!(k>>= 2))
return b;
p5= p5_a;
for (;;)
{
if (k & 1)
{
b1= mult(b, p5, alloc);
Bfree(b, alloc);
b= b1;
}
if (!(k>>= 1))
break;
/* Calculate next power of 5 */
if (overflow)
{
p51= mult(p5, p5, alloc);
Bfree(p5, alloc);
p5= p51;
}
else if (p5 < p5_a + P5A_MAX)
++p5;
else if (p5 == p5_a + P5A_MAX)
{
p5= mult(p5, p5, alloc);
overflow= TRUE;
}
}
if (p51)
Bfree(p51, alloc);
return b;
} | O3 | c | pow5mult:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r13
movl %esi, %eax
andl $0x3, %eax
je 0x5fa91
decl %eax
leaq 0x28346a(%rip), %rcx # 0x2e2ee8
movl (%rcx,%rax,4), %esi
movq %r13, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x5fede
movq %rax, %r13
cmpl $0x4, %r15d
jb 0x5fb79
movq %rbx, -0x38(%rbp)
shrl $0x2, %r15d
movb $0x1, %cl
leaq 0x3113d4(%rip), %rbx # 0x370e80
movq $0x0, -0x40(%rbp)
leaq 0x311455(%rip), %r12 # 0x370f10
movl %ecx, %r14d
cmpq %r12, %rbx
setb %cl
movl %ecx, -0x2c(%rbp)
testb $0x1, %r15b
je 0x5fafc
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %r12
movq -0x38(%rbp), %r13
movq %r13, %rdx
callq 0x5fb8b
movq %rax, -0x48(%rbp)
movq %r12, %rdi
leaq 0x311420(%rip), %r12 # 0x370f10
movq %r13, %rsi
callq 0x5fcad
movq -0x48(%rbp), %r13
cmpl $0x2, %r15d
jb 0x5fb67
shrl %r15d
testb $0x1, %r14b
je 0x5fb2c
cmpq %r12, %rbx
jb 0x5fb5b
movb $0x1, %r14b
jne 0x5fac7
movq %r12, %rdi
movq %r12, %rsi
movq -0x38(%rbp), %rdx
callq 0x5fb8b
movq %rax, %rbx
movl -0x2c(%rbp), %ecx
jmp 0x5fabb
movq %rbx, %rdi
movq %rbx, %r14
movq %rbx, %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdx
callq 0x5fb8b
movq %rax, -0x40(%rbp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5fcad
xorl %ecx, %ecx
movq -0x40(%rbp), %rbx
jmp 0x5fabb
addq $0x18, %rbx
movl -0x2c(%rbp), %ecx
jmp 0x5fabb
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x5fb79
movq -0x38(%rbp), %rsi
callq 0x5fcad
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| pow5mult:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r15d, esi
mov r13, rdi
mov eax, esi
and eax, 3
jz short loc_5FA91
dec eax
lea rcx, pow5mult_p05
mov esi, [rcx+rax*4]
mov rdi, r13
xor edx, edx
mov rcx, rbx
call multadd
mov r13, rax
loc_5FA91:
cmp r15d, 4
jb loc_5FB79
mov [rbp+var_38], rbx
shr r15d, 2
mov cl, 1
lea rbx, p5_a
mov [rbp+var_40], 0
lea r12, off_370F10
loc_5FABB:
mov r14d, ecx
cmp rbx, r12
setb cl
mov [rbp+var_2C], ecx
loc_5FAC7:
test r15b, 1
jz short loc_5FAFC
mov rdi, r13
mov rsi, rbx
mov r12, r13
mov r13, [rbp+var_38]
mov rdx, r13
call mult
mov [rbp+var_48], rax
mov rdi, r12
lea r12, off_370F10
mov rsi, r13
call Bfree
mov r13, [rbp+var_48]
loc_5FAFC:
cmp r15d, 2
jb short loc_5FB67
shr r15d, 1
test r14b, 1
jz short loc_5FB2C
cmp rbx, r12
jb short loc_5FB5B
mov r14b, 1
jnz short loc_5FAC7
mov rdi, r12
mov rsi, r12
mov rdx, [rbp+var_38]
call mult
mov rbx, rax
mov ecx, [rbp+var_2C]
jmp short loc_5FABB
loc_5FB2C:
mov rdi, rbx
mov r14, rbx
mov rsi, rbx
mov rbx, [rbp+var_38]
mov rdx, rbx
call mult
mov [rbp+var_40], rax
mov rdi, r14
mov rsi, rbx
call Bfree
xor ecx, ecx
mov rbx, [rbp+var_40]
jmp loc_5FABB
loc_5FB5B:
add rbx, 18h
mov ecx, [rbp+var_2C]
jmp loc_5FABB
loc_5FB67:
mov rdi, [rbp+var_40]
test rdi, rdi
jz short loc_5FB79
mov rsi, [rbp+var_38]
call Bfree
loc_5FB79:
mov rax, r13
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long pow5mult(long long a1, unsigned int a2, long long a3, int a4)
{
long long v5; // r13
unsigned int v6; // r15d
_UNKNOWN **v7; // rbx
char v8; // r14
long long v10; // [rsp+8h] [rbp-48h]
long long v11; // [rsp+10h] [rbp-40h]
long long v12; // [rsp+18h] [rbp-38h]
int v13; // [rsp+24h] [rbp-2Ch]
v5 = a1;
if ( (a2 & 3) != 0 )
v5 = multadd(a1, pow5mult_p05[(a2 & 3) - 1], 0LL, a3);
if ( a2 >= 4 )
{
v12 = a3;
v6 = a2 >> 2;
LOBYTE(a4) = 1;
v7 = &p5_a;
v11 = 0LL;
LABEL_5:
v8 = a4;
LOBYTE(a4) = v7 < &off_370F10;
v13 = a4;
while ( 1 )
{
if ( (v6 & 1) != 0 )
{
v10 = mult(v5, v7, v12);
Bfree(v5, v12);
v5 = v10;
}
if ( v6 < 2 )
break;
v6 >>= 1;
if ( (v8 & 1) == 0 )
{
v11 = mult(v7, v7, v12);
Bfree(v7, v12);
a4 = 0;
v7 = (_UNKNOWN **)v11;
goto LABEL_5;
}
if ( v7 < &off_370F10 )
{
v7 += 3;
a4 = v13;
goto LABEL_5;
}
v8 = 1;
if ( v7 == &off_370F10 )
{
v7 = (_UNKNOWN **)mult(&off_370F10, &off_370F10, v12);
a4 = v13;
goto LABEL_5;
}
}
if ( v11 )
Bfree(v11, v12);
}
return v5;
}
| pow5mult:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R15D,ESI
MOV R13,RDI
MOV EAX,ESI
AND EAX,0x3
JZ 0x0015fa91
DEC EAX
LEA RCX,[0x3e2ee8]
MOV ESI,dword ptr [RCX + RAX*0x4]
MOV RDI,R13
XOR EDX,EDX
MOV RCX,RBX
CALL 0x0015fede
MOV R13,RAX
LAB_0015fa91:
CMP R15D,0x4
JC 0x0015fb79
MOV qword ptr [RBP + -0x38],RBX
SHR R15D,0x2
MOV CL,0x1
LEA RBX,[0x470e80]
MOV qword ptr [RBP + -0x40],0x0
LEA R12,[0x470f10]
LAB_0015fabb:
MOV R14D,ECX
CMP RBX,R12
SETC CL
MOV dword ptr [RBP + -0x2c],ECX
LAB_0015fac7:
TEST R15B,0x1
JZ 0x0015fafc
MOV RDI,R13
MOV RSI,RBX
MOV R12,R13
MOV R13,qword ptr [RBP + -0x38]
MOV RDX,R13
CALL 0x0015fb8b
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,R12
LEA R12,[0x470f10]
MOV RSI,R13
CALL 0x0015fcad
MOV R13,qword ptr [RBP + -0x48]
LAB_0015fafc:
CMP R15D,0x2
JC 0x0015fb67
SHR R15D,0x1
TEST R14B,0x1
JZ 0x0015fb2c
CMP RBX,R12
JC 0x0015fb5b
MOV R14B,0x1
JNZ 0x0015fac7
MOV RDI,R12
MOV RSI,R12
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x0015fb8b
MOV RBX,RAX
MOV ECX,dword ptr [RBP + -0x2c]
JMP 0x0015fabb
LAB_0015fb2c:
MOV RDI,RBX
MOV R14,RBX
MOV RSI,RBX
MOV RBX,qword ptr [RBP + -0x38]
MOV RDX,RBX
CALL 0x0015fb8b
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0015fcad
XOR ECX,ECX
MOV RBX,qword ptr [RBP + -0x40]
JMP 0x0015fabb
LAB_0015fb5b:
ADD RBX,0x18
MOV ECX,dword ptr [RBP + -0x2c]
JMP 0x0015fabb
LAB_0015fb67:
MOV RDI,qword ptr [RBP + -0x40]
TEST RDI,RDI
JZ 0x0015fb79
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0015fcad
LAB_0015fb79:
MOV RAX,R13
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 pow5mult(int8 param_1,uint param_2,int8 param_3)
{
int1 *puVar1;
int8 uVar2;
bool bVar3;
bool bVar4;
int1 *local_48;
if ((param_2 & 3) != 0) {
param_1 = multadd(param_1,*(int4 *)(pow5mult_p05 + (ulong)((param_2 & 3) - 1) * 4),0,
param_3);
}
if (param_2 < 4) {
return param_1;
}
param_2 = param_2 >> 2;
local_48 = (int1 *)0x0;
puVar1 = p5_a;
bVar3 = true;
LAB_0015fabb:
do {
bVar4 = puVar1 < (int1 *)0x470f10;
uVar2 = param_1;
do {
param_1 = uVar2;
if ((param_2 & 1) != 0) {
param_1 = mult(uVar2,puVar1,param_3);
Bfree(uVar2,param_3);
}
if (param_2 < 2) {
if (local_48 == (int1 *)0x0) {
return param_1;
}
Bfree(local_48,param_3);
return param_1;
}
param_2 = param_2 >> 1;
if (!bVar3) {
local_48 = (int1 *)mult(puVar1,puVar1,param_3);
Bfree(puVar1,param_3);
bVar3 = false;
puVar1 = local_48;
goto LAB_0015fabb;
}
if (puVar1 < (int1 *)0x470f10) {
puVar1 = puVar1 + 0x18;
bVar3 = bVar4;
goto LAB_0015fabb;
}
bVar3 = true;
uVar2 = param_1;
} while (puVar1 != (int1 *)0x470f10);
puVar1 = (int1 *)mult(0x470f10,0x470f10,param_3);
bVar3 = bVar4;
} while( true );
}
| |
23,627 | my_coll_parser_scan_shift_sequence | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_shift_sequence(MY_COLL_RULE_PARSER *p)
{
MY_COLL_RULE before_extend;
memset(&p->rule.curr, 0, sizeof(p->rule.curr));
/* Scan single shift character or contraction */
if (!my_coll_parser_scan_character_list(p, p->rule.curr,
MY_UCA_MAX_CONTRACTION,
"Contraction"))
return 0;
before_extend= p->rule; /* Remember the part before "/" */
/* Append the part after "/" as expansion */
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_EXTEND)
{
my_coll_parser_scan(p);
if (!my_coll_parser_scan_character_list(p, p->rule.base,
MY_UCA_MAX_EXPANSION,
"Expansion"))
return 0;
}
else if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_CONTEXT)
{
/*
We support 2-character long context sequences only:
one character is the previous context, plus the current character.
It's OK as Unicode's CLDR does not have longer examples.
*/
my_coll_parser_scan(p);
p->rule.with_context= TRUE;
if (!my_coll_parser_scan_character_list(p, p->rule.curr + 1, 1, "context"))
return 0;
}
/* Add rule to the rule list */
if (my_coll_rules_add(p->rules, &p->rule))
return 0;
p->rule= before_extend; /* Restore to the state before "/" */
return 1;
} | O0 | c | my_coll_parser_scan_shift_sequence:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
addq $0x50, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x24190
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
movl $0x6, %edx
leaq 0x2c6c6(%rip), %rcx # 0x7be09
callq 0x4fd30
cmpl $0x0, %eax
jne 0x4f759
movl $0x0, -0x4(%rbp)
jmp 0x4f858
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
leaq -0xb0(%rbp), %rdi
movl $0xa0, %edx
callq 0x24230
movq -0x10(%rbp), %rdi
callq 0x4ed70
cmpl $0x8, (%rax)
jne 0x4f7b9
movq -0x10(%rbp), %rdi
callq 0x4f550
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
movl $0xa, %edx
leaq 0x2c485(%rip), %rcx # 0x7bc26
callq 0x4fd30
cmpl $0x0, %eax
jne 0x4f7b7
movl $0x0, -0x4(%rbp)
jmp 0x4f858
jmp 0x4f812
movq -0x10(%rbp), %rdi
callq 0x4ed70
cmpl $0x9, (%rax)
jne 0x4f810
movq -0x10(%rbp), %rdi
callq 0x4f550
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
addq $0x50, %rsi
addq $0x8, %rsi
movl $0x1, %edx
leaq 0x2d14c(%rip), %rcx # 0x7c947
callq 0x4fd30
cmpl $0x0, %eax
jne 0x4f80e
movl $0x0, -0x4(%rbp)
jmp 0x4f858
jmp 0x4f810
jmp 0x4f812
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x50, %rsi
callq 0x50080
cmpl $0x0, %eax
je 0x4f838
movl $0x0, -0x4(%rbp)
jmp 0x4f858
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
leaq -0xb0(%rbp), %rsi
movl $0xa0, %edx
callq 0x24230
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_shift_sequence:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
add rdi, 50h ; 'P'
xor esi, esi
mov edx, 30h ; '0'
call _memset
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
mov edx, 6
lea rcx, aContraction; "Contraction"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_4F759
mov [rbp+var_4], 0
jmp loc_4F858
loc_4F759:
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
lea rdi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 8
jnz short loc_4F7B9
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
mov edx, 0Ah
lea rcx, aExpansion; "Expansion"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_4F7B7
mov [rbp+var_4], 0
jmp loc_4F858
loc_4F7B7:
jmp short loc_4F812
loc_4F7B9:
mov rdi, [rbp+var_10]
call my_coll_parser_curr
cmp dword ptr [rax], 9
jnz short loc_4F810
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
add rsi, 50h ; 'P'
add rsi, 8
mov edx, 1
lea rcx, aCharsetsCharse_52+23h; "context"
call my_coll_parser_scan_character_list
cmp eax, 0
jnz short loc_4F80E
mov [rbp+var_4], 0
jmp short loc_4F858
loc_4F80E:
jmp short $+2
loc_4F810:
jmp short $+2
loc_4F812:
mov rax, [rbp+var_10]
mov rdi, [rax+0F0h]
mov rsi, [rbp+var_10]
add rsi, 50h ; 'P'
call my_coll_rules_add
cmp eax, 0
jz short loc_4F838
mov [rbp+var_4], 0
jmp short loc_4F858
loc_4F838:
mov rdi, [rbp+var_10]
add rdi, 50h ; 'P'
lea rsi, [rbp+var_B0]
mov edx, 0A0h
call _memcpy
mov [rbp+var_4], 1
loc_4F858:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
| long long my_coll_parser_scan_shift_sequence(long long a1)
{
_BYTE v2[160]; // [rsp+0h] [rbp-B0h] BYREF
long long v3; // [rsp+A0h] [rbp-10h]
v3 = a1;
memset(a1 + 160, 0LL, 48LL);
if ( (unsigned int)my_coll_parser_scan_character_list(v3, v3 + 160, 6LL, "Contraction") )
{
memcpy(v2, v3 + 80, sizeof(v2));
if ( *(_DWORD *)my_coll_parser_curr(v3) == 8 )
{
my_coll_parser_scan(v3);
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 80, 10LL, "Expansion") )
return 0;
}
else if ( *(_DWORD *)my_coll_parser_curr(v3) == 9 )
{
my_coll_parser_scan(v3);
*(_BYTE *)(v3 + 232) = 1;
if ( !(unsigned int)my_coll_parser_scan_character_list(v3, v3 + 168, 1LL, "context") )
return 0;
}
if ( (unsigned int)my_coll_rules_add(*(_QWORD *)(v3 + 240), v3 + 80) )
{
return 0;
}
else
{
memcpy(v3 + 80, v2, 160LL);
return 1;
}
}
else
{
return 0;
}
}
| my_coll_parser_scan_shift_sequence:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
ADD RDI,0x50
XOR ESI,ESI
MOV EDX,0x30
CALL 0x00124190
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
MOV EDX,0x6
LEA RCX,[0x17be09]
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0014f759
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014f858
LAB_0014f759:
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
LEA RDI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x00124230
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
CMP dword ptr [RAX],0x8
JNZ 0x0014f7b9
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f550
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
MOV EDX,0xa
LEA RCX,[0x17bc26]
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0014f7b7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014f858
LAB_0014f7b7:
JMP 0x0014f812
LAB_0014f7b9:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014ed70
CMP dword ptr [RAX],0x9
JNZ 0x0014f810
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0014f550
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
ADD RSI,0x50
ADD RSI,0x8
MOV EDX,0x1
LEA RCX,[0x17c947]
CALL 0x0014fd30
CMP EAX,0x0
JNZ 0x0014f80e
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014f858
LAB_0014f80e:
JMP 0x0014f810
LAB_0014f810:
JMP 0x0014f812
LAB_0014f812:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0xf0]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x50
CALL 0x00150080
CMP EAX,0x0
JZ 0x0014f838
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014f858
LAB_0014f838:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x50
LEA RSI,[RBP + -0xb0]
MOV EDX,0xa0
CALL 0x00124230
MOV dword ptr [RBP + -0x4],0x1
LAB_0014f858:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 my_coll_parser_scan_shift_sequence(long param_1)
{
int iVar1;
int *piVar2;
int1 local_b8 [160];
long local_18;
int4 local_c;
local_18 = param_1;
memset((void *)(param_1 + 0xa0),0,0x30);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa0,6,"Contraction");
if (iVar1 == 0) {
local_c = 0;
}
else {
memcpy(local_b8,(void *)(local_18 + 0x50),0xa0);
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 8) {
my_coll_parser_scan(local_18);
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0x50,10,"Expansion");
if (iVar1 == 0) {
return 0;
}
}
else {
piVar2 = (int *)my_coll_parser_curr(local_18);
if (*piVar2 == 9) {
my_coll_parser_scan(local_18);
*(int1 *)(local_18 + 0xe8) = 1;
iVar1 = my_coll_parser_scan_character_list(local_18,local_18 + 0xa8,1,"context");
if (iVar1 == 0) {
return 0;
}
}
}
iVar1 = my_coll_rules_add(*(int8 *)(local_18 + 0xf0),local_18 + 0x50);
if (iVar1 == 0) {
memcpy((void *)(local_18 + 0x50),local_b8,0xa0);
local_c = 1;
}
else {
local_c = 0;
}
}
return local_c;
}
| |
23,628 | gguf_get_val_f64 | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | double gguf_get_val_f64(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<double>();
} | O2 | cpp | gguf_get_val_f64:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x414f4
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
cmpq %rsi, %rax
jle 0x414f4
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e480
movq %rax, %rdi
callq 0x1d8f0
cmpq $0x1, %rax
jne 0x41510
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e480
movq %rax, %rdi
xorl %esi, %esi
callq 0x1ec30
movsd (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1dd52(%rip), %rdi # 0x5f24d
leaq 0xd0d3(%rip), %rdx # 0x4e5d5
leaq 0x1e1ba(%rip), %rcx # 0x5f6c3
movl $0x355, %esi # imm = 0x355
jmp 0x4152a
leaq 0x1dd36(%rip), %rdi # 0x5f24d
leaq 0xd0b7(%rip), %rdx # 0x4e5d5
leaq 0x1e26d(%rip), %rcx # 0x5f792
movl $0x356, %esi # imm = 0x356
xorl %eax, %eax
callq 0x1f9b0
| gguf_get_val_f64:
push r14
push rbx
push rax
test rsi, rsi
js short loc_414F4
mov rbx, rsi
mov r14, rdi
mov rax, [rdi+10h]
sub rax, [rdi+8]
push 58h ; 'X'
pop rcx
cqo
idiv rcx
cmp rax, rsi
jle short loc_414F4
add r14, 8
mov rdi, r14
mov rsi, rbx
call __ZNKSt6vectorI7gguf_kvSaIS0_EEixEm; std::vector<gguf_kv>::operator[](ulong)
mov rdi, rax; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_41510
mov rdi, r14
mov rsi, rbx
call __ZNKSt6vectorI7gguf_kvSaIS0_EEixEm; std::vector<gguf_kv>::operator[](ulong)
mov rdi, rax
xor esi, esi
call __ZNK7gguf_kv7get_valIdEERKT_m; gguf_kv::get_val<double>(ulong)
movsd xmm0, qword ptr [rax]
add rsp, 8
pop rbx
pop r14
retn
loc_414F4:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 355h
jmp short loc_4152A
loc_41510:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 356h
loc_4152A:
xor eax, eax
call _ggml_abort
| double gguf_get_val_f64(
long long a1,
long long a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
long long a11,
long long a12,
long long a13,
long long a14)
{
char v14; // al
gguf_kv *v15; // rax
long long v16; // rdx
long long v17; // rax
const char *v19; // rcx
int v20; // esi
char v21; // [rsp-8h] [rbp-18h]
v21 = v14;
if ( a2 < 0 || (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) / 88LL <= a2 )
{
v19 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v20 = 853;
goto LABEL_7;
}
v15 = (gguf_kv *)std::vector<gguf_kv>::operator[](a1 + 8, a2, (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) % 88LL);
if ( gguf_kv::get_ne(v15) != 1 )
{
v19 = "ctx->kv[key_id].get_ne() == 1";
v20 = 854;
LABEL_7:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v20,
(long long)"GGML_ASSERT(%s) failed",
(long long)v19,
a13,
a14,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
v21);
}
v17 = std::vector<gguf_kv>::operator[](a1 + 8, a2, v16);
return *(double *)gguf_kv::get_val<double>(v17, 0LL);
}
| gguf_get_val_f64:
PUSH R14
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x001414f4
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr [RDI + 0x10]
SUB RAX,qword ptr [RDI + 0x8]
PUSH 0x58
POP RCX
CQO
IDIV RCX
CMP RAX,RSI
JLE 0x001414f4
ADD R14,0x8
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011e480
MOV RDI,RAX
CALL 0x0011d8f0
CMP RAX,0x1
JNZ 0x00141510
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011e480
MOV RDI,RAX
XOR ESI,ESI
CALL 0x0011ec30
MOVSD XMM0,qword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R14
RET
LAB_001414f4:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f6c3]
MOV ESI,0x355
JMP 0x0014152a
LAB_00141510:
LEA RDI,[0x15f24d]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15f792]
MOV ESI,0x356
LAB_0014152a:
XOR EAX,EAX
CALL 0x0011f9b0
|
double gguf_get_val_f64(long param_1,ulong param_2)
{
gguf_kv *pgVar1;
long lVar2;
double *pdVar3;
char *pcVar4;
int8 uVar5;
if (((long)param_2 < 0) ||
((*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8)) / 0x58 <= (long)param_2)) {
pcVar4 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar5 = 0x355;
}
else {
pgVar1 = (gguf_kv *)
std::vector<gguf_kv,std::allocator<gguf_kv>>::operator[]
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),param_2);
lVar2 = gguf_kv::get_ne(pgVar1);
if (lVar2 == 1) {
pgVar1 = (gguf_kv *)
std::vector<gguf_kv,std::allocator<gguf_kv>>::operator[]
((vector<gguf_kv,std::allocator<gguf_kv>> *)(param_1 + 8),param_2);
pdVar3 = gguf_kv::get_val<double>(pgVar1,0);
return *pdVar3;
}
pcVar4 = "ctx->kv[key_id].get_ne() == 1";
uVar5 = 0x356;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar5,"GGML_ASSERT(%s) failed",pcVar4);
}
| |
23,629 | gguf_get_val_f64 | Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp | double gguf_get_val_f64(const struct gguf_context * ctx, int64_t key_id) {
GGML_ASSERT(key_id >= 0 && key_id < gguf_get_n_kv(ctx));
GGML_ASSERT(ctx->kv[key_id].get_ne() == 1);
return ctx->kv[key_id].get_val<double>();
} | O3 | cpp | gguf_get_val_f64:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
js 0x3ea04
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r15 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r15, %rax
cmpq %rsi, %rax
jle 0x3ea04
imulq $0x58, %rbx, %r12
addq %r12, %rdi
callq 0x16610
cmpq $0x1, %rax
jne 0x3ea20
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r15, %rax
cmpq %rbx, %rax
jbe 0x3e9ff
addq %r12, %rdi
xorl %esi, %esi
callq 0x17390
movsd (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x18ac8
leaq 0x1ead2(%rip), %rdi # 0x5d4dd
leaq 0xdc53(%rip), %rdx # 0x4c665
leaq 0x1ef3a(%rip), %rcx # 0x5d953
movl $0x355, %esi # imm = 0x355
jmp 0x3ea3a
leaq 0x1eab6(%rip), %rdi # 0x5d4dd
leaq 0xdc37(%rip), %rdx # 0x4c665
leaq 0x1efed(%rip), %rcx # 0x5da22
movl $0x356, %esi # imm = 0x356
xorl %eax, %eax
callq 0x17cd0
| gguf_get_val_f64:
push r15
push r14
push r12
push rbx
push rax
test rsi, rsi
js short loc_3EA04
mov rbx, rsi
mov r14, rdi
mov rdi, [rdi+8]
mov rax, [r14+10h]
sub rax, rdi
sar rax, 3
mov r15, 2E8BA2E8BA2E8BA3h
imul rax, r15
cmp rax, rsi
jle short loc_3EA04
imul r12, rbx, 58h ; 'X'
add rdi, r12; this
call __ZNK7gguf_kv6get_neEv; gguf_kv::get_ne(void)
cmp rax, 1
jnz short loc_3EA20
mov rdi, [r14+8]
mov rax, [r14+10h]
sub rax, rdi
sar rax, 3
imul rax, r15
cmp rax, rbx
jbe short loc_3E9FF
add rdi, r12
xor esi, esi
call __ZNK7gguf_kv7get_valIdEERKT_m; gguf_kv::get_val<double>(ulong)
movsd xmm0, qword ptr [rax]
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
loc_3E9FF:
call gguf_get_val_f64_cold_1
loc_3EA04:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyId0KeyIdGgu; "key_id >= 0 && key_id < gguf_get_n_kv(c"...
mov esi, 355h
jmp short loc_3EA3A
loc_3EA20:
lea rdi, aWorkspaceLlm4b_5; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aCtxKvKeyIdGetN; "ctx->kv[key_id].get_ne() == 1"
mov esi, 356h
loc_3EA3A:
xor eax, eax
call _ggml_abort
| double gguf_get_val_f64(long long a1, long long a2, long long a3, long long a4, int a5, int a6)
{
long long v7; // rdi
long long v8; // rdi
const char *v10; // rcx
int v11; // esi
if ( a2 < 0 || (v7 = *(_QWORD *)(a1 + 8), 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v7) >> 3) <= a2) )
{
v10 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
v11 = 853;
goto LABEL_9;
}
if ( gguf_kv::get_ne((gguf_kv *)(88 * a2 + v7)) != 1 )
{
v10 = "ctx->kv[key_id].get_ne() == 1";
v11 = 854;
LABEL_9:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
v11,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v10,
a5,
a6);
}
v8 = *(_QWORD *)(a1 + 8);
if ( 0x2E8BA2E8BA2E8BA3LL * ((*(_QWORD *)(a1 + 16) - v8) >> 3) <= (unsigned long long)a2 )
gguf_get_val_f64_cold_1(v8);
return *(double *)gguf_kv::get_val<double>(88 * a2 + v8, 0LL);
}
| gguf_get_val_f64:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
TEST RSI,RSI
JS 0x0013ea04
MOV RBX,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
SUB RAX,RDI
SAR RAX,0x3
MOV R15,0x2e8ba2e8ba2e8ba3
IMUL RAX,R15
CMP RAX,RSI
JLE 0x0013ea04
IMUL R12,RBX,0x58
ADD RDI,R12
CALL 0x00116610
CMP RAX,0x1
JNZ 0x0013ea20
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x10]
SUB RAX,RDI
SAR RAX,0x3
IMUL RAX,R15
CMP RAX,RBX
JBE 0x0013e9ff
ADD RDI,R12
XOR ESI,ESI
CALL 0x00117390
MOVSD XMM0,qword ptr [RAX]
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0013e9ff:
CALL 0x00118ac8
LAB_0013ea04:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15d953]
MOV ESI,0x355
JMP 0x0013ea3a
LAB_0013ea20:
LEA RDI,[0x15d4dd]
LEA RDX,[0x14c665]
LEA RCX,[0x15da22]
MOV ESI,0x356
LAB_0013ea3a:
XOR EAX,EAX
CALL 0x00117cd0
|
double gguf_get_val_f64(long param_1,ulong param_2)
{
long lVar1;
ulong uVar2;
double *pdVar3;
char *pcVar4;
int8 uVar5;
if ((-1 < (long)param_2) &&
(lVar1 = (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8) >> 3) * 0x2e8ba2e8ba2e8ba3,
lVar1 - param_2 != 0 && (long)param_2 <= lVar1)) {
lVar1 = gguf_kv::get_ne((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58));
if (lVar1 != 1) {
pcVar4 = "ctx->kv[key_id].get_ne() == 1";
uVar5 = 0x356;
goto LAB_0013ea3a;
}
uVar2 = (*(long *)(param_1 + 0x10) - *(long *)(param_1 + 8) >> 3) * 0x2e8ba2e8ba2e8ba3;
if (param_2 <= uVar2 && uVar2 - param_2 != 0) {
pdVar3 = gguf_kv::get_val<double>((gguf_kv *)(*(long *)(param_1 + 8) + param_2 * 0x58),0);
return *pdVar3;
}
gguf_get_val_f64_cold_1();
}
pcVar4 = "key_id >= 0 && key_id < gguf_get_n_kv(ctx)";
uVar5 = 0x355;
LAB_0013ea3a:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/gguf.cpp",
uVar5,"GGML_ASSERT(%s) failed",pcVar4);
}
| |
23,630 | fs_create_directory_with_parents(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | monkey531[P]llama/common/common.cpp | bool fs_create_directory_with_parents(const std::string & path) {
#ifdef _WIN32
std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
std::wstring wpath = converter.from_bytes(path);
// if the path already exists, check whether it's a directory
const DWORD attributes = GetFileAttributesW(wpath.c_str());
if ((attributes != INVALID_FILE_ATTRIBUTES) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return true;
}
size_t pos_slash = 0;
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('\\', pos_slash)) != std::string::npos) {
const std::wstring subpath = wpath.substr(0, pos_slash);
const wchar_t * test = subpath.c_str();
const bool success = CreateDirectoryW(test, NULL);
if (!success) {
const DWORD error = GetLastError();
// if the path already exists, ensure that it's a directory
if (error == ERROR_ALREADY_EXISTS) {
const DWORD attributes = GetFileAttributesW(subpath.c_str());
if (attributes == INVALID_FILE_ATTRIBUTES || !(attributes & FILE_ATTRIBUTE_DIRECTORY)) {
return false;
}
} else {
return false;
}
}
pos_slash += 1;
}
return true;
#else
// if the path already exists, check whether it's a directory
struct stat info;
if (stat(path.c_str(), &info) == 0) {
return S_ISDIR(info.st_mode);
}
size_t pos_slash = 1; // skip leading slashes for directory creation
// process path from front to back, procedurally creating directories
while ((pos_slash = path.find('/', pos_slash)) != std::string::npos) {
const std::string subpath = path.substr(0, pos_slash);
struct stat info;
// if the path already exists, ensure that it's a directory
if (stat(subpath.c_str(), &info) == 0) {
if (!S_ISDIR(info.st_mode)) {
return false;
}
} else {
// create parent directories
const int ret = mkdir(subpath.c_str(), 0755);
if (ret != 0) {
return false;
}
}
pos_slash += 1;
}
return true;
#endif // _WIN32
} | O3 | cpp | fs_create_directory_with_parents(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 $0x148, %rsp # imm = 0x148
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x18640
testl %eax, %eax
je 0x23213
movl $0x1, %r14d
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %rbx, %rdi
movl $0x2f, %esi
movq %r14, %rdx
callq 0x188d0
cmpq $-0x1, %rax
sete %bpl
je 0x23228
movq %rax, %r14
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x18730
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x18640
testl %eax, %eax
je 0x231d4
movq 0x8(%rsp), %rdi
movl $0x1ed, %esi # imm = 0x1ED
callq 0x18360
testl %eax, %eax
je 0x231e6
xorl %r13d, %r13d
jmp 0x231ec
movl 0x40(%rsp), %eax
movl $0xf000, %ecx # imm = 0xF000
andl %ecx, %eax
cmpl $0x4000, %eax # imm = 0x4000
jne 0x231cf
incq %r14
movb $0x1, %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x23208
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x186e0
testb %r13b, %r13b
jne 0x2317a
jmp 0x23228
movl $0xf000, %eax # imm = 0xF000
andl 0xd0(%rsp), %eax
cmpl $0x4000, %eax # imm = 0x4000
sete %bpl
movl %ebp, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _Z32fs_create_directory_with_parentsRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 148h
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+178h+var_C0]
call _stat
test eax, eax
jz loc_23213
mov r14d, 1
lea r15, [rsp+178h+var_170]
lea r12, [rsp+178h+var_150]
loc_2317A:
mov rdi, rbx
mov esi, 2Fh ; '/'
mov rdx, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEcm; std::string::find(char,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
setz bpl
jz loc_23228
mov r14, rax
mov rdi, r15
mov rsi, rbx
xor edx, edx
mov rcx, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, [rsp+178h+var_170]
mov rsi, r12
call _stat
test eax, eax
jz short loc_231D4
mov rdi, [rsp+178h+var_170]
mov esi, 1EDh
call _mkdir
test eax, eax
jz short loc_231E6
loc_231CF:
xor r13d, r13d
jmp short loc_231EC
loc_231D4:
mov eax, [rsp+178h+var_138]
mov ecx, 0F000h
and eax, ecx
cmp eax, 4000h
jnz short loc_231CF
loc_231E6:
inc r14
mov r13b, 1
loc_231EC:
mov rdi, [rsp+178h+var_170]; void *
lea rax, [rsp+178h+var_160]
cmp rdi, rax
jz short loc_23208
mov rsi, [rsp+178h+var_160]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_23208:
test r13b, r13b
jnz loc_2317A
jmp short loc_23228
loc_23213:
mov eax, 0F000h
and eax, [rsp+178h+var_A8]
cmp eax, 4000h
setz bpl
loc_23228:
mov eax, ebp
add rsp, 148h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long fs_create_directory_with_parents(_QWORD *a1)
{
unsigned int v1; // ebp
long long v2; // r14
long long v3; // rax
char v4; // r13
void *v6; // [rsp+8h] [rbp-170h] BYREF
long long v7; // [rsp+18h] [rbp-160h] BYREF
_BYTE v8[24]; // [rsp+28h] [rbp-150h] BYREF
int v9; // [rsp+40h] [rbp-138h]
_BYTE v10[24]; // [rsp+B8h] [rbp-C0h] BYREF
int v11; // [rsp+D0h] [rbp-A8h]
if ( (unsigned int)stat(*a1, v10) )
{
v2 = 1LL;
while ( 1 )
{
v3 = std::string::find(a1, 47LL, v2);
LOBYTE(v1) = v3 == -1;
if ( v3 == -1 )
return v1;
v2 = v3;
std::string::substr(&v6, a1, 0LL, v3);
if ( (unsigned int)stat(v6, v8) )
{
if ( !(unsigned int)mkdir(v6, 493LL) )
goto LABEL_8;
}
else if ( (v9 & 0xF000) == 0x4000 )
{
LABEL_8:
++v2;
v4 = 1;
goto LABEL_9;
}
v4 = 0;
LABEL_9:
if ( v6 != &v7 )
operator delete(v6, v7 + 1);
if ( !v4 )
return v1;
}
}
LOBYTE(v1) = (v11 & 0xF000) == 0x4000;
return v1;
}
| fs_create_directory_with_parents:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x148
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0xb8]
CALL 0x00118640
TEST EAX,EAX
JZ 0x00123213
MOV R14D,0x1
LEA R15,[RSP + 0x8]
LEA R12,[RSP + 0x28]
LAB_0012317a:
MOV RDI,RBX
MOV ESI,0x2f
MOV RDX,R14
CALL 0x001188d0
CMP RAX,-0x1
SETZ BPL
JZ 0x00123228
MOV R14,RAX
MOV RDI,R15
MOV RSI,RBX
XOR EDX,EDX
MOV RCX,RAX
CALL 0x00118730
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,R12
CALL 0x00118640
TEST EAX,EAX
JZ 0x001231d4
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,0x1ed
CALL 0x00118360
TEST EAX,EAX
JZ 0x001231e6
LAB_001231cf:
XOR R13D,R13D
JMP 0x001231ec
LAB_001231d4:
MOV EAX,dword ptr [RSP + 0x40]
MOV ECX,0xf000
AND EAX,ECX
CMP EAX,0x4000
JNZ 0x001231cf
LAB_001231e6:
INC R14
MOV R13B,0x1
LAB_001231ec:
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x00123208
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001186e0
LAB_00123208:
TEST R13B,R13B
JNZ 0x0012317a
JMP 0x00123228
LAB_00123213:
MOV EAX,0xf000
AND EAX,dword ptr [RSP + 0xd0]
CMP EAX,0x4000
SETZ BPL
LAB_00123228:
MOV EAX,EBP
ADD RSP,0x148
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* fs_create_directory_with_parents(std::__cxx11::string const&) */
ulong fs_create_directory_with_parents(string *param_1)
{
bool bVar1;
int iVar2;
long lVar3;
ulong unaff_RBP;
long *local_170 [2];
long local_160 [2];
stat local_150;
stat local_c0;
iVar2 = stat(*(char **)param_1,&local_c0);
if (iVar2 == 0) {
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),(local_c0.st_mode & 0xf000) == 0x4000);
}
else {
do {
lVar3 = std::__cxx11::string::find((char)param_1,0x2f);
unaff_RBP = CONCAT71((int7)(unaff_RBP >> 8),lVar3 == -1);
if (lVar3 == -1) break;
std::__cxx11::string::substr((ulong)local_170,(ulong)param_1);
iVar2 = stat((char *)local_170[0],&local_150);
if (iVar2 == 0) {
if ((local_150.st_mode & 0xf000) != 0x4000) goto LAB_001231cf;
LAB_001231e6:
bVar1 = true;
}
else {
iVar2 = mkdir((char *)local_170[0],0x1ed);
if (iVar2 == 0) goto LAB_001231e6;
LAB_001231cf:
bVar1 = false;
}
if (local_170[0] != local_160) {
operator_delete(local_170[0],local_160[0] + 1);
}
} while (bVar1);
}
return unaff_RBP & 0xffffffff;
}
| |
23,631 | store_page_range | eloqsql/storage/maria/ma_blockrec.c | static uchar *store_page_range(MARIA_SHARE *share,
uchar *to, MARIA_BITMAP_BLOCK *block,
ulong length,
uint *tot_ranges)
{
uint data_size= FULL_PAGE_SIZE(share);
ulong pages_left= (length + data_size -1) / data_size;
uint page_count, ranges, empty_space;
uchar *to_start;
DBUG_ENTER("store_page_range");
to_start= to;
to+= SUB_RANGE_SIZE;
/* Store number of unused bytes at last page */
empty_space= (uint) (pages_left * data_size - length);
int2store(to, empty_space);
to+= BLOCK_FILLER_SIZE;
ranges= 0;
do
{
pgcache_page_no_t page;
page= block->page;
page_count= block->page_count;
block++;
if (page_count > pages_left)
page_count= pages_left;
page_store(to, page);
to+= PAGE_STORE_SIZE;
pagerange_store(to, page_count);
to+= PAGERANGE_STORE_SIZE;
ranges++;
} while ((pages_left-= page_count));
/* Store number of ranges for this block */
int2store(to_start, ranges);
(*tot_ranges)+= ranges;
DBUG_RETURN(to);
} | O0 | c | store_page_range:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x7bc(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
subl %ecx, %eax
subl $0x4, %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl -0x2c(%rbp), %ecx
addq %rcx, %rax
subq $0x1, %rax
movl -0x2c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
imulq %rcx, %rax
subq -0x20(%rbp), %rax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x58(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movl -0x3c(%rbp), %eax
cmpq -0x38(%rbp), %rax
jbe 0x80c00
movq -0x38(%rbp), %rax
movl %eax, -0x3c(%rbp)
jmp 0x80c02
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x68(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x3c(%rbp), %eax
movw %ax, %cx
movq -0x70(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movq -0x38(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x80bcf
jmp 0x80c79
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x40(%rbp), %eax
movw %ax, %cx
movq -0x78(%rbp), %rax
movw %cx, (%rax)
movl -0x40(%rbp), %ecx
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
| store_page_range:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_8]
mov eax, [rax+7BCh]
mov rcx, [rbp+var_8]
mov ecx, [rcx+0C18h]
add ecx, 8
sub eax, ecx
sub eax, 4
mov [rbp+var_2C], eax
mov rax, [rbp+var_20]
mov ecx, [rbp+var_2C]
add rax, rcx
sub rax, 1
mov ecx, [rbp+var_2C]
xor edx, edx
div rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_2C]
imul rax, rcx
sub rax, [rbp+var_20]
mov [rbp+var_44], eax
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov eax, [rbp+var_44]
mov cx, ax
mov rax, [rbp+var_58]
mov [rax], cx
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov [rbp+var_40], 0
loc_80BCF:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_60], rax
mov rax, [rbp+var_18]
mov eax, [rax+8]
mov [rbp+var_3C], eax
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_18], rax
mov eax, [rbp+var_3C]
cmp rax, [rbp+var_38]
jbe short loc_80C00
mov rax, [rbp+var_38]
mov [rbp+var_3C], eax
loc_80C00:
jmp short $+2
loc_80C02:
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rax, [rbp+var_60]
mov ecx, eax
mov rax, [rbp+var_68]
mov [rax], ecx
mov rax, [rbp+var_60]
shr rax, 20h
mov cl, al
mov rax, [rbp+var_68]
mov [rax+4], cl
mov rax, [rbp+var_10]
add rax, 5
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov [rbp+var_70], rax
mov eax, [rbp+var_3C]
mov cx, ax
mov rax, [rbp+var_70]
mov [rax], cx
mov rax, [rbp+var_10]
add rax, 2
mov [rbp+var_10], rax
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
mov ecx, eax
mov rax, [rbp+var_38]
sub rax, rcx
mov [rbp+var_38], rax
cmp rax, 0
jnz loc_80BCF
jmp short $+2
loc_80C79:
mov rax, [rbp+var_50]
mov [rbp+var_78], rax
mov eax, [rbp+var_40]
mov cx, ax
mov rax, [rbp+var_78]
mov [rax], cx
mov ecx, [rbp+var_40]
mov rax, [rbp+var_28]
add ecx, [rax]
mov [rax], ecx
mov rax, [rbp+var_10]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
pop rbp
retn
| _WORD * store_page_range(long long a1, _WORD *a2, long long *a3, long long a4, _DWORD *a5)
{
long long v6; // [rsp+20h] [rbp-60h]
int v7; // [rsp+40h] [rbp-40h]
unsigned int v8; // [rsp+44h] [rbp-3Ch]
unsigned long long v9; // [rsp+48h] [rbp-38h]
unsigned int v10; // [rsp+54h] [rbp-2Ch]
_WORD *v12; // [rsp+70h] [rbp-10h]
v10 = *(_DWORD *)(a1 + 1980) - (*(_DWORD *)(a1 + 3096) + 8) - 4;
v9 = ((unsigned long long)v10 + a4 - 1) / v10;
a2[1] = v10 * v9 - a4;
v12 = a2 + 2;
v7 = 0;
do
{
v6 = *a3;
v8 = *((_DWORD *)a3 + 2);
a3 += 3;
if ( v8 > v9 )
v8 = v9;
*(_DWORD *)v12 = v6;
*((_BYTE *)v12 + 4) = BYTE4(v6);
*(_WORD *)((char *)v12 + 5) = v8;
v12 = (_WORD *)((char *)v12 + 7);
++v7;
v9 -= v8;
}
while ( v9 );
*a2 = v7;
*a5 += v7;
return v12;
}
| store_page_range:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
SUB EAX,ECX
SUB EAX,0x4
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x2c]
ADD RAX,RCX
SUB RAX,0x1
MOV ECX,dword ptr [RBP + -0x2c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x2c]
IMUL RAX,RCX
SUB RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RBP + -0x44],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV EAX,dword ptr [RBP + -0x44]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x58]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV dword ptr [RBP + -0x40],0x0
LAB_00180bcf:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x18],RAX
MOV EAX,dword ptr [RBP + -0x3c]
CMP RAX,qword ptr [RBP + -0x38]
JBE 0x00180c00
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RBP + -0x3c],EAX
LAB_00180c00:
JMP 0x00180c02
LAB_00180c02:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x68]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x60]
SHR RAX,0x20
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x68]
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x5
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x70],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x70]
MOV word ptr [RAX],CX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2
MOV qword ptr [RBP + -0x10],RAX
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x38]
SUB RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
CMP RAX,0x0
JNZ 0x00180bcf
JMP 0x00180c79
LAB_00180c79:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x78],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x78]
MOV word ptr [RAX],CX
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
ADD ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
POP RBP
RET
|
int4 *
store_page_range(long param_1,int2 *param_2,int8 *param_3,long param_4,int *param_5)
{
int8 uVar1;
uint uVar2;
int local_48;
uint local_44;
ulong local_40;
int8 *local_20;
int4 *local_18;
uVar2 = (*(int *)(param_1 + 0x7bc) - (*(int *)(param_1 + 0xc18) + 8)) - 4;
local_40 = ((param_4 + (ulong)uVar2) - 1) / (ulong)uVar2;
param_2[1] = (short)local_40 * (short)uVar2 - (short)param_4;
local_18 = (int4 *)(param_2 + 2);
local_48 = 0;
local_20 = param_3;
do {
uVar1 = *local_20;
local_44 = *(uint *)(local_20 + 1);
local_20 = local_20 + 3;
if (local_40 < local_44) {
local_44 = (uint)local_40;
}
*local_18 = (int)uVar1;
*(char *)(local_18 + 1) = (char)((ulong)uVar1 >> 0x20);
*(short *)((long)local_18 + 5) = (short)local_44;
local_18 = (int4 *)((long)local_18 + 7);
local_48 = local_48 + 1;
local_40 = local_40 - local_44;
} while (local_40 != 0);
*param_2 = (short)local_48;
*param_5 = local_48 + *param_5;
return local_18;
}
| |
23,632 | is_not_initialized | eloqsql/build_O0/libmariadb/libmariadb/ma_client_plugin.c | static int is_not_initialized(MYSQL *mysql, const char *name)
{
if (initialized)
return 0;
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD,
SQLSTATE_UNKNOWN, ER(CR_AUTH_PLUGIN_CANNOT_LOAD),
name, "not initialized");
return 1;
} | O0 | c | is_not_initialized:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpb $0x0, 0x2c159(%rip) # 0x61c30
je 0x35ae2
movl $0x0, -0x4(%rbp)
jmp 0x35b1c
movq -0x10(%rbp), %rdi
leaq 0x2a3c3(%rip), %rax # 0x5feb0
movq (%rax), %rdx
leaq 0x2a3c9(%rip), %rax # 0x5fec0
movq 0x1d8(%rax), %rcx
movq -0x18(%rbp), %r8
movl $0x80b, %esi # imm = 0x80B
leaq 0x16491(%rip), %r9 # 0x4bf9f
movb $0x0, %al
callq 0x15e30
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| is_not_initialized:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
cmp cs:initialized, 0
jz short loc_35AE2
mov [rbp+var_4], 0
jmp short loc_35B1C
loc_35AE2:
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
mov r8, [rbp+var_18]
mov esi, 80Bh
lea r9, aNotInitialized; "not initialized"
mov al, 0
call my_set_error
mov [rbp+var_4], 1
loc_35B1C:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long is_not_initialized(long long a1, long long a2)
{
if ( initialized )
{
return 0;
}
else
{
my_set_error(a1, 0x80Bu, (long long)SQLSTATE_UNKNOWN, (long long)client_errors[59], a2, "not initialized");
return 1;
}
}
| is_not_initialized:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
CMP byte ptr [0x00161c30],0x0
JZ 0x00135ae2
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00135b1c
LAB_00135ae2:
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x15feb0]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x15fec0]
MOV RCX,qword ptr [RAX + 0x1d8]
MOV R8,qword ptr [RBP + -0x18]
MOV ESI,0x80b
LEA R9,[0x14bf9f]
MOV AL,0x0
CALL 0x00115e30
MOV dword ptr [RBP + -0x4],0x1
LAB_00135b1c:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
bool is_not_initialized(int8 param_1,int8 param_2)
{
bool bVar1;
bVar1 = initialized == '\0';
if (bVar1) {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____00160098,
param_2,"not initialized");
}
return bVar1;
}
| |
23,633 | mi_log | eloqsql/storage/myisam/mi_log.c | int mi_log(int activate_log)
{
int error=0;
char buff[FN_REFLEN];
DBUG_ENTER("mi_log");
log_type=activate_log;
if (activate_log)
{
if (!myisam_pid)
myisam_pid=(ulong) getpid();
if (myisam_log_file < 0)
{
if ((myisam_log_file= mysql_file_create(mi_key_file_log,
fn_format(buff,
myisam_log_filename,
"", ".log", 4),
0,
(O_RDWR | O_BINARY | O_APPEND),
MYF(0))) < 0)
DBUG_RETURN(my_errno);
}
}
else if (myisam_log_file >= 0)
{
error= mysql_file_close(myisam_log_file, MYF(0)) ? my_errno : 0 ;
myisam_log_file= -1;
}
DBUG_RETURN(error);
} | O0 | c | mi_log:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x218(%rbp)
movl $0x0, -0x21c(%rbp)
movl -0x218(%rbp), %eax
movl %eax, 0xbd2074(%rip) # 0xc855a8
cmpl $0x0, -0x218(%rbp)
je 0xb35f2
cmpq $0x0, 0xbd2057(%rip) # 0xc855a0
jne 0xb3559
callq 0x2a950
cltq
movq %rax, 0xbd2047(%rip) # 0xc855a0
leaq 0x216fa0(%rip), %rax # 0x2ca500
cmpl $0x0, (%rax)
jge 0xb35f0
leaq 0xbd2010(%rip), %rax # 0xc85580
movl (%rax), %eax
movl %eax, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
leaq 0x216f72(%rip), %rax # 0x2ca4f8
movq (%rax), %rsi
leaq 0xaeaa6(%rip), %rdx # 0x162036
leaq 0xa9892(%rip), %rcx # 0x15ce29
movl $0x4, %r8d
callq 0xe3ae0
movl -0x220(%rbp), %edi
movq %rax, %rcx
leaq 0xa9c4a(%rip), %rsi # 0x15d1fc
movl $0x35, %edx
xorl %r8d, %r8d
movl $0x402, %r9d # imm = 0x402
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0xb36a0
leaq 0x216f2a(%rip), %rcx # 0x2ca500
movl %eax, (%rcx)
cmpl $0x0, %eax
jge 0xb35ee
jmp 0xb35df
callq 0xfe880
movl (%rax), %eax
movl %eax, -0x214(%rbp)
jmp 0xb3663
jmp 0xb35f0
jmp 0xb3655
leaq 0x216f07(%rip), %rax # 0x2ca500
cmpl $0x0, (%rax)
jl 0xb3653
leaq 0x216efb(%rip), %rax # 0x2ca500
movl (%rax), %edx
leaq 0xa9bee(%rip), %rdi # 0x15d1fc
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0xb3790
cmpl $0x0, %eax
je 0xb3630
callq 0xfe880
movl (%rax), %eax
movl %eax, -0x224(%rbp)
jmp 0xb363a
xorl %eax, %eax
movl %eax, -0x224(%rbp)
jmp 0xb363a
movl -0x224(%rbp), %eax
movl %eax, -0x21c(%rbp)
leaq 0x216eb3(%rip), %rax # 0x2ca500
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
jmp 0xb3655
jmp 0xb3657
movl -0x21c(%rbp), %eax
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %eax
movl %eax, -0x228(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xb3690
movl -0x228(%rbp), %eax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
callq 0x2a270
nopw %cs:(%rax,%rax)
| mi_log:
push rbp
mov rbp, rsp
sub rsp, 230h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_218], edi
mov [rbp+var_21C], 0
mov eax, [rbp+var_218]
mov cs:log_type, eax
cmp [rbp+var_218], 0
jz loc_B35F2
cmp cs:myisam_pid, 0
jnz short loc_B3559
call _getpid
cdqe
mov cs:myisam_pid, rax
loc_B3559:
lea rax, myisam_log_file
cmp dword ptr [rax], 0
jge loc_B35F0
lea rax, mi_key_file_log
mov eax, [rax]
mov [rbp+var_220], eax
lea rdi, [rbp+var_210]
lea rax, myisam_log_filename
mov rsi, [rax]
lea rdx, asc_162032+4; ""
lea rcx, aMyisamLog+6; ".log"
mov r8d, 4
call fn_format
mov edi, [rbp+var_220]
mov rcx, rax
lea rsi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 35h ; '5'
xor r8d, r8d
mov r9d, 402h
xor eax, eax
mov [rsp+230h+var_230], 0
call inline_mysql_file_create_1
lea rcx, myisam_log_file
mov [rcx], eax
cmp eax, 0
jge short loc_B35EE
jmp short $+2
loc_B35DF:
call _my_thread_var
mov eax, [rax]
mov [rbp+var_214], eax
jmp short loc_B3663
loc_B35EE:
jmp short $+2
loc_B35F0:
jmp short loc_B3655
loc_B35F2:
lea rax, myisam_log_file
cmp dword ptr [rax], 0
jl short loc_B3653
lea rax, myisam_log_file
mov edx, [rax]
lea rdi, aWorkspaceLlm4b_28; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 3Bh ; ';'
xor eax, eax
mov ecx, eax
call inline_mysql_file_close_5
cmp eax, 0
jz short loc_B3630
call _my_thread_var
mov eax, [rax]
mov [rbp+var_224], eax
jmp short loc_B363A
loc_B3630:
xor eax, eax
mov [rbp+var_224], eax
jmp short $+2
loc_B363A:
mov eax, [rbp+var_224]
mov [rbp+var_21C], eax
lea rax, myisam_log_file
mov dword ptr [rax], 0FFFFFFFFh
loc_B3653:
jmp short $+2
loc_B3655:
jmp short $+2
loc_B3657:
mov eax, [rbp+var_21C]
mov [rbp+var_214], eax
loc_B3663:
mov eax, [rbp+var_214]
mov [rbp+var_228], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_B3690
mov eax, [rbp+var_228]
add rsp, 230h
pop rbp
retn
loc_B3690:
call ___stack_chk_fail
| long long mi_log(int a1)
{
int v1; // eax
unsigned int v3; // [rsp+Ch] [rbp-224h]
unsigned int v4; // [rsp+10h] [rbp-220h]
unsigned int v5; // [rsp+14h] [rbp-21Ch]
_BYTE v7[520]; // [rsp+20h] [rbp-210h] BYREF
unsigned long long v8; // [rsp+228h] [rbp-8h]
v8 = __readfsqword(0x28u);
v5 = 0;
log_type = a1;
if ( !a1 )
{
if ( (myisam_log_file & 0x80000000) == 0 )
{
if ( (unsigned int)inline_mysql_file_close_5(
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
59LL,
myisam_log_file,
0LL) )
v3 = *(_DWORD *)my_thread_var(
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
(_BYTE *)&word_3A + 1);
else
v3 = 0;
v5 = v3;
myisam_log_file = -1;
}
return v5;
}
if ( !myisam_pid )
myisam_pid = (int)getpid();
if ( (myisam_log_file & 0x80000000) == 0 )
return v5;
v4 = mi_key_file_log;
v1 = fn_format(v7, myisam_log_filename, "", ".log", 4LL);
myisam_log_file = inline_mysql_file_create_1(
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",
53,
v1,
0,
1026,
0LL);
if ( (myisam_log_file & 0x80000000) == 0 )
return v5;
return *(unsigned int *)my_thread_var(v4, "/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c");
}
| mi_log:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x230
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x218],EDI
MOV dword ptr [RBP + -0x21c],0x0
MOV EAX,dword ptr [RBP + -0x218]
MOV dword ptr [0x00d855a8],EAX
CMP dword ptr [RBP + -0x218],0x0
JZ 0x001b35f2
CMP qword ptr [0x00d855a0],0x0
JNZ 0x001b3559
CALL 0x0012a950
CDQE
MOV qword ptr [0x00d855a0],RAX
LAB_001b3559:
LEA RAX,[0x3ca500]
CMP dword ptr [RAX],0x0
JGE 0x001b35f0
LEA RAX,[0xd85580]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x220],EAX
LEA RDI,[RBP + -0x210]
LEA RAX,[0x3ca4f8]
MOV RSI,qword ptr [RAX]
LEA RDX,[0x262036]
LEA RCX,[0x25ce29]
MOV R8D,0x4
CALL 0x001e3ae0
MOV EDI,dword ptr [RBP + -0x220]
MOV RCX,RAX
LEA RSI,[0x25d1fc]
MOV EDX,0x35
XOR R8D,R8D
MOV R9D,0x402
XOR EAX,EAX
MOV qword ptr [RSP],0x0
CALL 0x001b36a0
LEA RCX,[0x3ca500]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JGE 0x001b35ee
JMP 0x001b35df
LAB_001b35df:
CALL 0x001fe880
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x214],EAX
JMP 0x001b3663
LAB_001b35ee:
JMP 0x001b35f0
LAB_001b35f0:
JMP 0x001b3655
LAB_001b35f2:
LEA RAX,[0x3ca500]
CMP dword ptr [RAX],0x0
JL 0x001b3653
LEA RAX,[0x3ca500]
MOV EDX,dword ptr [RAX]
LEA RDI,[0x25d1fc]
MOV ESI,0x3b
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001b3790
CMP EAX,0x0
JZ 0x001b3630
CALL 0x001fe880
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x224],EAX
JMP 0x001b363a
LAB_001b3630:
XOR EAX,EAX
MOV dword ptr [RBP + -0x224],EAX
JMP 0x001b363a
LAB_001b363a:
MOV EAX,dword ptr [RBP + -0x224]
MOV dword ptr [RBP + -0x21c],EAX
LEA RAX,[0x3ca500]
MOV dword ptr [RAX],0xffffffff
LAB_001b3653:
JMP 0x001b3655
LAB_001b3655:
JMP 0x001b3657
LAB_001b3657:
MOV EAX,dword ptr [RBP + -0x21c]
MOV dword ptr [RBP + -0x214],EAX
LAB_001b3663:
MOV EAX,dword ptr [RBP + -0x214]
MOV dword ptr [RBP + -0x228],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001b3690
MOV EAX,dword ptr [RBP + -0x228]
ADD RSP,0x230
POP RBP
RET
LAB_001b3690:
CALL 0x0012a270
|
int4 mi_log(int param_1)
{
int4 uVar1;
__pid_t _Var2;
int iVar3;
int8 uVar4;
int4 *puVar5;
long in_FS_OFFSET;
int4 local_22c;
int4 local_224;
int4 local_21c;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_224 = 0;
log_type = param_1;
if (param_1 == 0) {
if (-1 < myisam_log_file) {
iVar3 = inline_mysql_file_close
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x3b,
myisam_log_file,0);
if (iVar3 == 0) {
local_22c = 0;
}
else {
puVar5 = (int4 *)_my_thread_var();
local_22c = *puVar5;
}
local_224 = local_22c;
myisam_log_file = -1;
}
}
else {
if (myisam_pid == 0) {
_Var2 = getpid();
myisam_pid = (long)_Var2;
}
uVar1 = mi_key_file_log;
if (myisam_log_file < 0) {
uVar4 = fn_format(local_218,myisam_log_filename,&DAT_00262036,".log",4);
myisam_log_file =
inline_mysql_file_create
(uVar1,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_log.c",0x35,
uVar4,0,0x402,0);
if (myisam_log_file < 0) {
puVar5 = (int4 *)_my_thread_var();
local_21c = *puVar5;
goto LAB_001b3663;
}
}
}
local_21c = local_224;
LAB_001b3663:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_21c;
}
| |
23,634 | mpvio_info | eloqsql/libmariadb/plugins/auth/my_auth.c | void mpvio_info(MARIADB_PVIO *pvio, MYSQL_PLUGIN_VIO_INFO *info)
{
memset(info, 0, sizeof(*info));
switch (pvio->type) {
case PVIO_TYPE_SOCKET:
info->protocol= MYSQL_VIO_TCP;
ma_pvio_get_handle(pvio, &info->socket);
return;
case PVIO_TYPE_UNIXSOCKET:
info->protocol= MYSQL_VIO_SOCKET;
ma_pvio_get_handle(pvio, &info->socket);
return;
/*
case VIO_TYPE_SSL:
{
struct sockaddr addr;
SOCKET_SIZE_TYPE addrlen= sizeof(addr);
if (getsockname(vio->sd, &addr, &addrlen))
return;
info->protocol= addr.sa_family == AF_UNIX ?
MYSQL_VIO_SOCKET : MYSQL_VIO_TCP;
info->socket= vio->sd;
return;
}
*/
#ifdef _WIN32
/*
case VIO_TYPE_NAMEDPIPE:
info->protocol= MYSQL_VIO_PIPE;
info->handle= vio->hPipe;
return;
*/
/* not supported yet
case VIO_TYPE_SHARED_MEMORY:
info->protocol= MYSQL_VIO_MEMORY;
info->handle= vio->handle_file_map;
return;
*/
#endif
default: DBUG_ASSERT(0);
}
} | O0 | c | mpvio_info:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x63722
jmp 0x636fb
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x6373f
jmp 0x63705
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x47ad0
jmp 0x63741
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x47ad0
jmp 0x63741
jmp 0x63741
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| mpvio_info:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov eax, [rax+20h]
mov [rbp+var_14], eax
test eax, eax
jz short loc_63722
jmp short $+2
loc_636FB:
mov eax, [rbp+var_14]
sub eax, 1
jnz short loc_6373F
jmp short $+2
loc_63705:
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, 4
call ma_pvio_get_handle
jmp short loc_63741
loc_63722:
mov rax, [rbp+var_10]
mov dword ptr [rax], 2
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
add rsi, 4
call ma_pvio_get_handle
jmp short loc_63741
loc_6373F:
jmp short $+2
loc_63741:
add rsp, 20h
pop rbp
retn
| char mpvio_info(long long a1, _QWORD *a2)
{
char result; // al
int v3; // [rsp+Ch] [rbp-14h]
*a2 = 0LL;
v3 = *(_DWORD *)(a1 + 32);
if ( v3 )
{
result = v3 - 1;
if ( v3 == 1 )
{
*(_DWORD *)a2 = 1;
return ma_pvio_get_handle(a1, (long long)a2 + 4);
}
}
else
{
*(_DWORD *)a2 = 2;
return ma_pvio_get_handle(a1, (long long)a2 + 4);
}
return result;
}
| mpvio_info:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x14],EAX
TEST EAX,EAX
JZ 0x00163722
JMP 0x001636fb
LAB_001636fb:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
JNZ 0x0016373f
JMP 0x00163705
LAB_00163705:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x4
CALL 0x00147ad0
JMP 0x00163741
LAB_00163722:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x2
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x4
CALL 0x00147ad0
JMP 0x00163741
LAB_0016373f:
JMP 0x00163741
LAB_00163741:
ADD RSP,0x20
POP RBP
RET
|
void mpvio_info(long param_1,int8 *param_2)
{
*param_2 = 0;
if (*(int *)(param_1 + 0x20) == 0) {
*(int4 *)param_2 = 2;
ma_pvio_get_handle(param_1,(long)param_2 + 4);
}
else if (*(int *)(param_1 + 0x20) == 1) {
*(int4 *)param_2 = 1;
ma_pvio_get_handle(param_1,(long)param_2 + 4);
}
return;
}
| |
23,635 | decode_pos | eloqsql/storage/myisam/mi_packrec.c | static uint decode_pos(MI_BIT_BUFF *bit_buff, MI_DECODE_TREE *decode_tree)
{
uint16 *pos=decode_tree->table;
for (;;)
{
if (get_bit(bit_buff))
pos++;
if (*pos & IS_CHAR)
return (uint) (*pos & ~IS_CHAR);
pos+= *pos;
}
} | O0 | c | decode_pos:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xbf61a
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x8(%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 0xbf63e
jmp 0xbf64a
movq -0x8(%rbp), %rdi
callq 0xbdad0
movq -0x8(%rbp), %rax
movl $0x1f, 0x4(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
je 0xbf64a
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax # imm = 0x8000
cmpl $0x0, %eax
je 0xbf66d
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
andl $0xffff7fff, %eax # imm = 0xFFFF7FFF
addq $0x20, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rax
movzwl (%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xbf5eb
nopw (%rax,%rax)
| decode_pos_0:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
loc_BF5EB:
mov rax, [rbp+var_8]
cmp dword ptr [rax+4], 0
jz short loc_BF61A
mov rax, [rbp+var_8]
mov eax, [rax]
mov rdx, [rbp+var_8]
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_BF63E
jmp short loc_BF64A
loc_BF61A:
mov rdi, [rbp+var_8]
call fill_buffer_0
mov rax, [rbp+var_8]
mov dword ptr [rax+4], 1Fh
mov rax, [rbp+var_8]
mov eax, [rax]
and eax, 80000000h
cmp eax, 0
jz short loc_BF64A
loc_BF63E:
mov rax, [rbp+var_18]
add rax, 2
mov [rbp+var_18], rax
loc_BF64A:
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 8000h
cmp eax, 0
jz short loc_BF66D
mov rax, [rbp+var_18]
movzx eax, word ptr [rax]
and eax, 0FFFF7FFFh
add rsp, 20h
pop rbp
retn
loc_BF66D:
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax]
mov rax, [rbp+var_18]
movsxd rcx, ecx
shl rcx, 1
add rax, rcx
mov [rbp+var_18], rax
jmp loc_BF5EB
| long long decode_pos_0(int *a1, _WORD **a2)
{
int v2; // eax
int v3; // ecx
_WORD *i; // [rsp+8h] [rbp-18h]
for ( i = *a2; ; i += (unsigned __int16)*i )
{
if ( !a1[1] )
{
fill_buffer_0((long long)a1);
a1[1] = 31;
if ( *a1 >= 0 )
goto LABEL_7;
LABEL_6:
++i;
goto LABEL_7;
}
v2 = *a1;
v3 = a1[1] - 1;
a1[1] = v3;
if ( ((1 << v3) & v2) != 0 )
goto LABEL_6;
LABEL_7:
if ( (*i & 0x8000) != 0 )
break;
}
return *i & 0x7FFF;
}
| decode_pos:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001bf5eb:
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x4],0x0
JZ 0x001bf61a
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x8]
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 0x001bf63e
JMP 0x001bf64a
LAB_001bf61a:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001bdad0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x4],0x1f
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
AND EAX,0x80000000
CMP EAX,0x0
JZ 0x001bf64a
LAB_001bf63e:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
MOV qword ptr [RBP + -0x18],RAX
LAB_001bf64a:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0x8000
CMP EAX,0x0
JZ 0x001bf66d
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,word ptr [RAX]
AND EAX,0xffff7fff
ADD RSP,0x20
POP RBP
RET
LAB_001bf66d:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
SHL RCX,0x1
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001bf5eb
|
ushort decode_pos(uint *param_1,int8 *param_2)
{
uint uVar1;
ushort *local_20;
local_20 = (ushort *)*param_2;
while( true ) {
if (param_1[1] == 0) {
fill_buffer(param_1);
param_1[1] = 0x1f;
uVar1 = *param_1 & 0x80000000;
}
else {
uVar1 = param_1[1];
param_1[1] = uVar1 - 1;
uVar1 = *param_1 & 1 << ((byte)(uVar1 - 1) & 0x1f);
}
if (uVar1 != 0) {
local_20 = local_20 + 1;
}
if ((*local_20 & 0x8000) != 0) break;
local_20 = local_20 + (int)(uint)*local_20;
}
return *local_20 & 0x7fff;
}
| |
23,636 | void yoyo::Logger::fatal<char const (&) [36]>(char const (&) [36], std::source_location&&) | isyoCode[P]yoyologger/test/../src/logger.hpp | void fatal(T&& str,
std::source_location&& loc = std::source_location::current()) {
log(LOGLEVEL::FATAL, std::forward<T>(str), std::move(loc));
} | O1 | cpp | void yoyo::Logger::fatal<char const (&) [36]>(char const (&) [36], std::source_location&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30d0
leaq (%rax,%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ed8
movq %r15, %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x64bc
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3e6a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3e91
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x33a0
nop
| _ZN4yoyo6Logger5fatalIRA36_KcEEvOT_OSt15source_location:
push r15; int
push r14; int
push r13; int
push r12; int
push rbx; char
sub rsp, 20h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r13, [rsp+48h+var_38]
mov [r13-10h], r13
mov rdi, rsi
call _strlen
lea rdx, [rax+r14]
mov r12, rsp
mov rdi, r12
mov rsi, r14
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, r15; int
mov esi, 4; int
mov rdx, r12; int
mov rcx, rbx; int
call _ZN4yoyo6Logger3logENS_8LOGLEVELEONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt15source_location; yoyo::Logger::log(yoyo::LOGLEVEL,std::string &&,std::source_location &&)
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_3E6A
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3E6A:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_3E91
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3E91:
mov rdi, rbx
call __Unwind_Resume
| fatal<char_const(&)[36]>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
MOV RDI,RSI
CALL 0x001030d0
LEA RDX,[RAX + R14*0x1]
MOV R12,RSP
MOV RDI,R12
MOV RSI,R14
CALL 0x00103ed8
LAB_00103e41:
MOV RDI,R15
MOV ESI,0x4
MOV RDX,R12
MOV RCX,RBX
CALL 0x001064bc
LAB_00103e54:
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00103e6a
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00103290
LAB_00103e6a:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* void yoyo::Logger::fatal<char const (&) [36]>(char const (&) [36], std::source_location&&) */
void __thiscall
yoyo::Logger::fatal<char_const(&)[36]>(Logger *this,char *param_1,source_location *param_2)
{
size_t sVar1;
long *local_48 [2];
long local_38 [2];
local_48[0] = local_38;
sVar1 = strlen(param_1);
std::__cxx11::string::_M_construct<char_const*>(local_48,param_1,param_1 + sVar1);
/* try { // try from 00103e41 to 00103e53 has its CatchHandler @ 00103e78 */
log(this,4,local_48,param_2);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
| ||
23,637 | void yoyo::Logger::fatal<char const (&) [36]>(char const (&) [36], std::source_location&&) | isyoCode[P]yoyologger/test/../src/logger.hpp | void fatal(T&& str,
std::source_location&& loc = std::source_location::current()) {
log(LOGLEVEL::FATAL, std::forward<T>(str), std::move(loc));
} | O3 | cpp | void yoyo::Logger::fatal<char const (&) [36]>(char const (&) [36], std::source_location&&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0x30d0
leaq (%rax,%r14), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3ef0
movq %r15, %rdi
movl $0x4, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x64e6
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3c3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3c65
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x33a0
nop
| _ZN4yoyo6Logger5fatalIRA34_KcEEvOT_OSt15source_location:
push r15; int
push r14; int
push r13; int
push r12; int
push rbx; char
sub rsp, 20h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
lea r13, [rsp+48h+var_38]
mov [r13-10h], r13
mov rdi, rsi
call _strlen
lea rdx, [rax+r14]
mov r12, rsp
mov rdi, r12
mov rsi, r14
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, r15; int
mov esi, 4; int
mov rdx, r12; int
mov rcx, rbx; int
call _ZN4yoyo6Logger3logENS_8LOGLEVELEONSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEOSt15source_location; yoyo::Logger::log(yoyo::LOGLEVEL,std::string &&,std::source_location &&)
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r13
jz short loc_3C3E
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C3E:
add rsp, 20h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+0]; void *
cmp rdi, r13
jz short loc_3C65
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C65:
mov rdi, rbx
call __Unwind_Resume
| fatal<char_const(&)[34]>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x20
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
LEA R13,[RSP + 0x10]
MOV qword ptr [R13 + -0x10],R13
MOV RDI,RSI
CALL 0x001030d0
LEA RDX,[RAX + R14*0x1]
MOV R12,RSP
MOV RDI,R12
MOV RSI,R14
CALL 0x00103ef0
LAB_00103c15:
MOV RDI,R15
MOV ESI,0x4
MOV RDX,R12
MOV RCX,RBX
CALL 0x001064e6
LAB_00103c28:
MOV RDI,qword ptr [RSP]
CMP RDI,R13
JZ 0x00103c3e
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x00103290
LAB_00103c3e:
ADD RSP,0x20
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* void yoyo::Logger::fatal<char const (&) [34]>(char const (&) [34], std::source_location&&) */
void __thiscall
yoyo::Logger::fatal<char_const(&)[34]>(Logger *this,char *param_1,source_location *param_2)
{
size_t sVar1;
long *local_48 [2];
long local_38 [2];
local_48[0] = local_38;
sVar1 = strlen(param_1);
std::__cxx11::string::_M_construct<char_const*>(local_48,param_1,param_1 + sVar1);
/* try { // try from 00103c15 to 00103c27 has its CatchHandler @ 00103c4c */
log(this,4,local_48,param_2);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
return;
}
| ||
23,638 | ftparser_alloc_param | eloqsql/storage/myisam/ft_parser.c | MYSQL_FTPARSER_PARAM* ftparser_alloc_param(MI_INFO *info)
{
if (!info->ftparser_param)
{
/*
. info->ftparser_param can not be zero after the initialization,
because it always includes built-in fulltext parser. And built-in
parser can be called even if the table has no fulltext indexes and
no varchar/text fields.
ftb_find_relevance... parser (ftb_find_relevance_parse,
ftb_find_relevance_add_word) calls ftb_check_phrase... parser
(ftb_check_phrase_internal, ftb_phrase_add_word). Thus MAX_PARAM_NR=2.
*/
info->ftparser_param= (MYSQL_FTPARSER_PARAM *)
my_malloc(mi_key_memory_FTPARSER_PARAM,
MAX_PARAM_NR * sizeof(MYSQL_FTPARSER_PARAM) * info->s->ftkeys,
MYF(MY_WME | MY_ZEROFILL));
init_alloc_root(mi_key_memory_ft_memroot, &info->ft_memroot,
FTPARSER_MEMROOT_ALLOC_SIZE, 0, MYF(0));
}
return info->ftparser_param;
} | O3 | c | ftparser_alloc_param:
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x4917c
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x35d588(%rip), %rax # 0x3a6714
movl (%rax), %edi
movq (%rbx), %rax
movl 0x34c(%rax), %esi
shlq $0x7, %rsi
movl $0x30, %edx
callq 0x5a3c5
movq %rax, 0xd0(%rbx)
leaq 0x35d565(%rip), %rax # 0x3a6718
movl (%rax), %edi
leaq 0x90(%rbx), %rsi
movl $0x10000, %edx # imm = 0x10000
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x57eb8
movq 0xd0(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| ftparser_alloc_param:
mov rax, [rdi+0D0h]
test rax, rax
jz short loc_4917C
retn
loc_4917C:
push rbp
mov rbp, rsp
push rbx
push rax
mov rbx, rdi
lea rax, mi_key_memory_FTPARSER_PARAM
mov edi, [rax]
mov rax, [rbx]
mov esi, [rax+34Ch]
shl rsi, 7
mov edx, 30h ; '0'
call my_malloc
mov [rbx+0D0h], rax
lea rax, mi_key_memory_ft_memroot
mov edi, [rax]
lea rsi, [rbx+90h]
mov edx, 10000h
xor ecx, ecx
xor r8d, r8d
call init_alloc_root
mov rax, [rbx+0D0h]
add rsp, 8
pop rbx
pop rbp
retn
| long long ftparser_alloc_param(_QWORD *a1, long long a2, long long a3, long long a4)
{
long long result; // rax
result = a1[26];
if ( !result )
{
a1[26] = my_malloc(mi_key_memory_FTPARSER_PARAM, (unsigned long long)*(unsigned int *)(*a1 + 844LL) << 7, 48LL, a4);
init_alloc_root(mi_key_memory_ft_memroot, a1 + 18, 0x10000LL, 0LL, 0LL);
return a1[26];
}
return result;
}
| ftparser_alloc_param:
MOV RAX,qword ptr [RDI + 0xd0]
TEST RAX,RAX
JZ 0x0014917c
RET
LAB_0014917c:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x4a6714]
MOV EDI,dword ptr [RAX]
MOV RAX,qword ptr [RBX]
MOV ESI,dword ptr [RAX + 0x34c]
SHL RSI,0x7
MOV EDX,0x30
CALL 0x0015a3c5
MOV qword ptr [RBX + 0xd0],RAX
LEA RAX,[0x4a6718]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBX + 0x90]
MOV EDX,0x10000
XOR ECX,ECX
XOR R8D,R8D
CALL 0x00157eb8
MOV RAX,qword ptr [RBX + 0xd0]
ADD RSP,0x8
POP RBX
POP RBP
RET
|
long ftparser_alloc_param(long *param_1)
{
long lVar1;
int8 in_R9;
long lVar2;
lVar2 = param_1[0x1a];
if (lVar2 != 0) {
return lVar2;
}
lVar1 = my_malloc(mi_key_memory_FTPARSER_PARAM,(ulong)*(uint *)(*param_1 + 0x34c) << 7,0x30);
param_1[0x1a] = lVar1;
init_alloc_root(mi_key_memory_ft_memroot,param_1 + 0x12,0x10000,0,0,in_R9,lVar2);
return param_1[0x1a];
}
| |
23,639 | my_realpath | eloqsql/mysys/my_symlink.c | int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
} | O3 | c | my_realpath:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1010, %rsp # imm = 0x1010
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
leaq -0x1030(%rbp), %rsi
movq %r14, %rdi
callq 0x29490
testq %rax, %rax
je 0xa3c29
movl $0x1ff, %edx # imm = 0x1FF
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd9de4
xorl %eax, %eax
jmp 0xa3c78
callq 0x29770
movl (%rax), %r12d
callq 0xa48d6
movl %r12d, (%rax)
testb $0x10, %r15b
je 0xa3c57
callq 0xa48d6
movl (%rax), %ecx
movl $0x1a, %edi
xorl %esi, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0xa0ebb
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xab950
callq 0xa48d6
xorl %ecx, %ecx
cmpl $0x2, (%rax)
sete %cl
leal -0x1(,%rcx,2), %eax
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0xa3c97
addq $0x1010, %rsp # imm = 0x1010
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x29240
| my_realpath:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 1010h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
lea rsi, [rbp+var_1030]
mov rdi, r14
call _realpath
test rax, rax
jz short loc_A3C29
mov edx, 1FFh
mov rdi, rbx
mov rsi, rax
call strmake
xor eax, eax
jmp short loc_A3C78
loc_A3C29:
call ___errno_location
mov r12d, [rax]
call _my_thread_var
mov [rax], r12d
test r15b, 10h
jz short loc_A3C57
call _my_thread_var
mov ecx, [rax]
mov edi, 1Ah
xor esi, esi
mov rdx, r14
xor eax, eax
call my_error
loc_A3C57:
mov rdi, rbx
mov rsi, r14
xor edx, edx
call my_load_path
call _my_thread_var
xor ecx, ecx
cmp dword ptr [rax], 2
setz cl
lea eax, ds:0FFFFFFFFFFFFFFFFh[rcx*2]
loc_A3C78:
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_A3C97
add rsp, 1010h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A3C97:
call ___stack_chk_fail
| long long my_realpath(long long a1, long long a2, char a3)
{
long long v4; // rax
int v6; // r12d
unsigned int *v7; // rax
_BYTE v8[4104]; // [rsp+0h] [rbp-1030h] BYREF
unsigned long long v9; // [rsp+1008h] [rbp-28h]
v9 = __readfsqword(0x28u);
v4 = realpath(a2, v8);
if ( v4 )
{
strmake(a1, v4, 511LL);
return 0LL;
}
else
{
v6 = *(_DWORD *)__errno_location(a2);
*(_DWORD *)my_thread_var(a2) = v6;
if ( (a3 & 0x10) != 0 )
{
v7 = (unsigned int *)my_thread_var(a2);
my_error(0x1Au, 0LL, a2, *v7);
}
my_load_path(a1, a2, 0LL);
return 2 * (unsigned int)(*(_DWORD *)my_thread_var(a1) == 2) - 1;
}
}
| my_realpath:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1010
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
LEA RSI,[RBP + -0x1030]
MOV RDI,R14
CALL 0x00129490
TEST RAX,RAX
JZ 0x001a3c29
MOV EDX,0x1ff
MOV RDI,RBX
MOV RSI,RAX
CALL 0x001d9de4
XOR EAX,EAX
JMP 0x001a3c78
LAB_001a3c29:
CALL 0x00129770
MOV R12D,dword ptr [RAX]
CALL 0x001a48d6
MOV dword ptr [RAX],R12D
TEST R15B,0x10
JZ 0x001a3c57
CALL 0x001a48d6
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR ESI,ESI
MOV RDX,R14
XOR EAX,EAX
CALL 0x001a0ebb
LAB_001a3c57:
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x001ab950
CALL 0x001a48d6
XOR ECX,ECX
CMP dword ptr [RAX],0x2
SETZ CL
LEA EAX,[-0x1 + RCX*0x2]
LAB_001a3c78:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001a3c97
ADD RSP,0x1010
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a3c97:
CALL 0x00129240
|
int my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
char local_1038 [4104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
pcVar2 = realpath(param_2,local_1038);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
iVar1 = (uint)(*piVar3 == 2) * 2 + -1;
}
else {
strmake(param_1,pcVar2,0x1ff);
iVar1 = 0;
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return iVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,640 | decltype(fp(0)) fmt::v10::loc_value::visit<fmt::v10::detail::loc_writer<char>>(fmt::v10::detail::loc_writer<char>&&) | aimrt_mujoco_sim/_deps/fmt-src/include/fmt/core.h | FMT_CONSTEXPR FMT_INLINE auto visit_format_arg(
Visitor&& vis, const basic_format_arg<Context>& arg) -> decltype(vis(0)) {
switch (arg.type_) {
case detail::type::none_type:
break;
case detail::type::int_type:
return vis(arg.value_.int_value);
case detail::type::uint_type:
return vis(arg.value_.uint_value);
case detail::type::long_long_type:
return vis(arg.value_.long_long_value);
case detail::type::ulong_long_type:
return vis(arg.value_.ulong_long_value);
case detail::type::int128_type:
return vis(detail::convert_for_visit(arg.value_.int128_value));
case detail::type::uint128_type:
return vis(detail::convert_for_visit(arg.value_.uint128_value));
case detail::type::bool_type:
return vis(arg.value_.bool_value);
case detail::type::char_type:
return vis(arg.value_.char_value);
case detail::type::float_type:
return vis(arg.value_.float_value);
case detail::type::double_type:
return vis(arg.value_.double_value);
case detail::type::long_double_type:
return vis(arg.value_.long_double_value);
case detail::type::cstring_type:
return vis(arg.value_.string.data);
case detail::type::string_type:
using sv = basic_string_view<typename Context::char_type>;
return vis(sv(arg.value_.string.data, arg.value_.string.size));
case detail::type::pointer_type:
return vis(arg.value_.pointer);
case detail::type::custom_type:
return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
}
return vis(monostate());
} | O3 | c | decltype(fp(0)) fmt::v10::loc_value::visit<fmt::v10::detail::loc_writer<char>>(fmt::v10::detail::loc_writer<char>&&):
movl 0x10(%rdi), %eax
decl %eax
cmpl $0x5, %eax
ja 0x35c96
leaq 0x12b447(%rip), %rcx # 0x16107c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x35cea
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x36490
movq (%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x360bc
movq (%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x362b4
movl (%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x35ee0
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x3669a
xorl %eax, %eax
retq
nop
| _ZN3fmt3v109loc_value5visitINS0_6detail10loc_writerIcEEEEDTclfp_Li0EEEOT_:
mov eax, [rdi+10h]
dec eax; switch 6 cases
cmp eax, 5
ja short def_35C3C; jumptable 0000000000035C3C default case
lea rcx, jpt_35C3C; int
movsxd rax, ds:(jpt_35C3C - 16107Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_35C3E:
mov eax, [rdi]; jumptable 0000000000035C3C case 1
mov rdi, rsi; int
mov esi, eax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclIiTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
loc_35C4A:
mov rax, [rdi]; jumptable 0000000000035C3C case 5
mov rdx, [rdi+8]; int
mov rdi, rsi; int
mov rsi, rax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclInTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
loc_35C5C:
mov rax, [rdi]; jumptable 0000000000035C3C case 3
mov rdi, rsi; int
mov rsi, rax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclIxTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
loc_35C6A:
mov rax, [rdi]; jumptable 0000000000035C3C case 4
mov rdi, rsi; int
mov rsi, rax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclIyTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
loc_35C78:
mov eax, [rdi]; jumptable 0000000000035C3C case 2
mov rdi, rsi; int
mov esi, eax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclIjTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
loc_35C84:
mov rax, [rdi]; jumptable 0000000000035C3C case 6
mov rdx, [rdi+8]; int
mov rdi, rsi; int
mov rsi, rax; int
jmp _ZN3fmt3v106detail10loc_writerIcEclIoTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
def_35C3C:
xor eax, eax; jumptable 0000000000035C3C default case
retn
| long long fmt::v10::loc_value::visit<fmt::v10::detail::loc_writer<char>>(
long long a1,
int a2,
int a3,
int a4,
int a5,
int a6,
void *a7,
long long a8,
long long a9,
void *a10,
void *a11,
long long a12,
long long a13,
int a14,
int a15,
int a16,
char a17)
{
long long result; // rax
switch ( *(_DWORD *)(a1 + 16) )
{
case 1:
result = ZN3fmt3v106detail10loc_writerIcEclIiTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_DWORD *)a1,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
(int)a10,
a11,
a12,
a13,
a14,
a15);
break;
case 2:
result = ZN3fmt3v106detail10loc_writerIcEclIjTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_DWORD *)a1,
a3,
a4,
a5,
a6,
(int)a7,
a8,
a9,
a10,
(int)a11,
a12,
a13,
a14,
a15);
break;
case 3:
result = ZN3fmt3v106detail10loc_writerIcEclIxTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_QWORD *)a1,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
(int)a10,
a11,
a12,
a13,
a14,
a15);
break;
case 4:
result = ZN3fmt3v106detail10loc_writerIcEclIyTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_QWORD *)a1,
a3,
a4,
a5,
a6,
(int)a7,
a8,
a9,
a10,
(int)a11,
a12,
a13,
a14,
a15);
break;
case 5:
result = ZN3fmt3v106detail10loc_writerIcEclInTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_QWORD *)a1,
*(_QWORD *)(a1 + 8),
a4,
a5,
a6,
a7,
a8,
a9,
(int)a10,
a11,
a12,
a13,
a14,
a15);
break;
case 6:
result = ZN3fmt3v106detail10loc_writerIcEclIoTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_(
a2,
*(_QWORD *)a1,
*(_QWORD *)(a1 + 8),
a4,
a5,
a6,
a7,
a8,
a9,
(int)a10,
a11,
a12,
a13,
a14,
a15,
a16,
a17);
break;
default:
result = 0LL;
break;
}
return result;
}
| visit<fmt::v10::detail::loc_writer<char>>:
MOV EAX,dword ptr [RDI + 0x10]
DEC EAX
CMP EAX,0x5
JA 0x00135c96
LEA RCX,[0x26107c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV EAX,dword ptr [RDI]
MOV RDI,RSI
MOV ESI,EAX
JMP 0x00135cea
caseD_5:
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RDI,RSI
MOV RSI,RAX
JMP 0x00136490
caseD_3:
MOV RAX,qword ptr [RDI]
MOV RDI,RSI
MOV RSI,RAX
JMP 0x001360bc
caseD_4:
MOV RAX,qword ptr [RDI]
MOV RDI,RSI
MOV RSI,RAX
JMP 0x001362b4
caseD_2:
MOV EAX,dword ptr [RDI]
MOV RDI,RSI
MOV ESI,EAX
JMP 0x00135ee0
caseD_6:
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
MOV RDI,RSI
MOV RSI,RAX
JMP 0x0013669a
default:
XOR EAX,EAX
RET
|
/* decltype ({parm#1}(0)) fmt::v10::loc_value::visit<fmt::v10::detail::loc_writer<char>
>(fmt::v10::detail::loc_writer<char>&&) */
int8 __thiscall
fmt::v10::loc_value::visit<fmt::v10::detail::loc_writer<char>>(loc_value *this,loc_writer *param_1)
{
int8 uVar1;
switch(*(int4 *)(this + 0x10)) {
case 1:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclIiTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int4 *)this);
return uVar1;
case 2:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclIjTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int4 *)this);
return uVar1;
case 3:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclIxTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int8 *)this);
return uVar1;
case 4:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclIyTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int8 *)this);
return uVar1;
case 5:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclInTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int8 *)this,*(int8 *)(this + 8));
return uVar1;
case 6:
uVar1 = _ZN3fmt3v106detail10loc_writerIcEclIoTnNSt9enable_ifIXsr10is_integerIT_EE5valueEiE4typeELi0EEEbS6_
(param_1,*(int8 *)this,*(int8 *)(this + 8));
return uVar1;
default:
return 0;
}
}
| |
23,641 | verify_beacon_header | corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c | static bool verify_beacon_header(ssz_ob_t* header, bytes32_t exec_blockhash, bytes_t blockhash_proof) {
// check merkle proof
ssz_ob_t header_body_root = ssz_get(header, "bodyRoot");
bytes32_t root_hash;
ssz_verify_single_merkle_proof(blockhash_proof, exec_blockhash, BLOCKHASH_BLOCKBODY_GINDEX, root_hash);
if (ssz_is_error(header_body_root) || header_body_root.bytes.len != 32 || memcmp(root_hash, header_body_root.bytes.data, 32)) return false;
return true;
} | O0 | c | verify_beacon_header:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq 0x427aa(%rip), %rdx # 0x52833
callq 0x1c760
movq -0x28(%rbp), %rdx
leaq -0x60(%rbp), %r8
movl -0x18(%rbp), %edi
movq -0x10(%rbp), %rsi
movl $0x32c, %ecx # imm = 0x32C
callq 0x1d740
leaq -0x40(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x10030
testb $0x1, %al
jne 0x100ea
cmpl $0x20, -0x40(%rbp)
jne 0x100ea
leaq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x20, %edx
callq 0x5310
cmpl $0x0, %eax
je 0x100f0
movb $0x0, -0x1(%rbp)
jmp 0x100f4
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| verify_beacon_header:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_18], edx
mov [rbp+var_10], rcx
mov [rbp+var_20], rdi
mov [rbp+var_28], rsi
mov rsi, [rbp+var_20]
lea rdi, [rbp+var_40]
lea rdx, aBodyroot; "bodyRoot"
call ssz_get
mov rdx, [rbp+var_28]
lea r8, [rbp+var_60]
mov edi, [rbp+var_18]
mov rsi, [rbp+var_10]
mov ecx, 32Ch
call ssz_verify_single_merkle_proof
lea rax, [rbp+var_40]
mov rcx, [rax]
mov [rsp+80h+var_80], rcx
mov rcx, [rax+8]
mov [rsp+80h+var_78], rcx
mov rax, [rax+10h]
mov [rsp+80h+var_70], rax
call ssz_is_error
test al, 1
jnz short loc_100EA
cmp [rbp+var_40], 20h ; ' '
jnz short loc_100EA
lea rdi, [rbp+var_60]
mov rsi, [rbp+var_38]
mov edx, 20h ; ' '
call _memcmp
cmp eax, 0
jz short loc_100F0
loc_100EA:
mov [rbp+var_1], 0
jmp short loc_100F4
loc_100F0:
mov [rbp+var_1], 1
loc_100F4:
mov al, [rbp+var_1]
and al, 1
add rsp, 80h
pop rbp
retn
| bool verify_beacon_header(long long a1, long long a2, unsigned int a3, long long a4)
{
unsigned int v4; // edi
int v5; // esi
int v6; // edx
int v7; // r8d
int v8; // r9d
_BYTE v10[32]; // [rsp+20h] [rbp-60h] BYREF
long long v11; // [rsp+40h] [rbp-40h] BYREF
long long v12; // [rsp+48h] [rbp-38h]
long long v13; // [rsp+50h] [rbp-30h]
long long v14; // [rsp+58h] [rbp-28h]
long long v15; // [rsp+60h] [rbp-20h]
unsigned int v16; // [rsp+68h] [rbp-18h]
long long v17; // [rsp+70h] [rbp-10h]
v16 = a3;
v17 = a4;
v15 = a1;
v14 = a2;
ssz_get(&v11, a1, "bodyRoot");
v4 = v16;
v5 = v17;
ssz_verify_single_merkle_proof(v16, v17, v14, 812LL, v10);
return (ssz_is_error(v4, v5, v6, v12, v7, v8, v11, v12, v13) & 1) == 0
&& (_DWORD)v11 == 32
&& !(unsigned int)memcmp(v10, v12, 32LL);
}
| verify_beacon_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x10],RCX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RSI
MOV RSI,qword ptr [RBP + -0x20]
LEA RDI,[RBP + -0x40]
LEA RDX,[0x152833]
CALL 0x0011c760
MOV RDX,qword ptr [RBP + -0x28]
LEA R8,[RBP + -0x60]
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x10]
MOV ECX,0x32c
CALL 0x0011d740
LEA RAX,[RBP + -0x40]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP],RCX
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CALL 0x00110030
TEST AL,0x1
JNZ 0x001100ea
CMP dword ptr [RBP + -0x40],0x20
JNZ 0x001100ea
LEA RDI,[RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x38]
MOV EDX,0x20
CALL 0x00105310
CMP EAX,0x0
JZ 0x001100f0
LAB_001100ea:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x001100f4
LAB_001100f0:
MOV byte ptr [RBP + -0x1],0x1
LAB_001100f4:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x80
POP RBP
RET
|
int1
verify_beacon_header(int8 param_1,int8 param_2,int4 param_3,int8 param_4)
{
int iVar1;
ulong uVar2;
int1 local_68 [32];
int local_48 [2];
void *local_40;
int8 local_30;
int8 local_28;
int4 local_20;
int8 local_18;
local_30 = param_2;
local_28 = param_1;
local_20 = param_3;
local_18 = param_4;
ssz_get(local_48,param_1,"bodyRoot");
ssz_verify_single_merkle_proof(local_20,local_18,local_30,0x32c,local_68);
uVar2 = ssz_is_error();
if ((((uVar2 & 1) == 0) && (local_48[0] == 0x20)) &&
(iVar1 = memcmp(local_68,local_40,0x20), iVar1 == 0)) {
return 1;
}
return 0;
}
| |
23,642 | verify_beacon_header | corpus-core[P]colibri-stateless/src/chains/eth/verifier/verify_blockhash_proof.c | static bool verify_beacon_header(ssz_ob_t* header, bytes32_t exec_blockhash, bytes_t blockhash_proof) {
// check merkle proof
ssz_ob_t header_body_root = ssz_get(header, "bodyRoot");
bytes32_t root_hash;
ssz_verify_single_merkle_proof(blockhash_proof, exec_blockhash, BLOCKHASH_BLOCKBODY_GINDEX, root_hash);
if (ssz_is_error(header_body_root) || header_body_root.bytes.len != 32 || memcmp(root_hash, header_body_root.bytes.data, 32)) return false;
return true;
} | O1 | c | verify_beacon_header:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x3069d(%rip), %rdx # 0x3d84c
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x14ddd
leaq 0x20(%rsp), %r8
movl $0x32c, %ecx # imm = 0x32C
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x159be
xorl %eax, %eax
cmpq $0x0, 0x10(%r15)
je 0xd212
movq 0x10(%rsp), %rcx
testq %rcx, %rcx
je 0xd212
cmpl $0x20, 0x8(%rsp)
jne 0xd212
movdqu (%rcx), %xmm0
movdqu 0x10(%rcx), %xmm1
pcmpeqb 0x30(%rsp), %xmm1
pcmpeqb 0x20(%rsp), %xmm0
pand %xmm1, %xmm0
pmovmskb %xmm0, %eax
cmpl $0xffff, %eax # imm = 0xFFFF
sete %al
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
| verify_beacon_header:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov rbx, rcx
mov ebp, edx
mov r14, rsi
mov rsi, rdi
lea rdx, aBodyroot; "bodyRoot"
lea r15, [rsp+68h+var_60]
mov rdi, r15
call ssz_get
lea r8, [rsp+68h+var_48]
mov ecx, 32Ch
mov edi, ebp
mov rsi, rbx
mov rdx, r14
call ssz_verify_single_merkle_proof
xor eax, eax
cmp qword ptr [r15+10h], 0
jz short loc_D212
mov rcx, [rsp+68h+var_58]
test rcx, rcx
jz short loc_D212
cmp [rsp+68h+var_60], 20h ; ' '
jnz short loc_D212
movdqu xmm0, xmmword ptr [rcx]
movdqu xmm1, xmmword ptr [rcx+10h]
pcmpeqb xmm1, [rsp+68h+var_38]
pcmpeqb xmm0, [rsp+68h+var_48]
pand xmm0, xmm1
pmovmskb eax, xmm0
cmp eax, 0FFFFh
setz al
loc_D212:
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
| bool verify_beacon_header(long long a1, long long a2, unsigned int a3, long long a4)
{
bool result; // al
int v7; // [rsp+8h] [rbp-60h] BYREF
const __m128i *v8; // [rsp+10h] [rbp-58h]
long long v9; // [rsp+18h] [rbp-50h]
__m128i v10[4]; // [rsp+20h] [rbp-48h] BYREF
ssz_get(&v7, a1, "bodyRoot");
ssz_verify_single_merkle_proof(a3, a4, a2, 812LL, v10);
result = 0;
if ( v9 && v8 && v7 == 32 )
return _mm_movemask_epi8(_mm_and_si128(_mm_cmpeq_epi8(_mm_loadu_si128(v8), v10[0]), _mm_cmpeq_epi8(_mm_loadu_si128(v8 + 1), v10[1]))) == 0xFFFF;
return result;
}
| verify_beacon_header:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RCX
MOV EBP,EDX
MOV R14,RSI
MOV RSI,RDI
LEA RDX,[0x13d84c]
LEA R15,[RSP + 0x8]
MOV RDI,R15
CALL 0x00114ddd
LEA R8,[RSP + 0x20]
MOV ECX,0x32c
MOV EDI,EBP
MOV RSI,RBX
MOV RDX,R14
CALL 0x001159be
XOR EAX,EAX
CMP qword ptr [R15 + 0x10],0x0
JZ 0x0010d212
MOV RCX,qword ptr [RSP + 0x10]
TEST RCX,RCX
JZ 0x0010d212
CMP dword ptr [RSP + 0x8],0x20
JNZ 0x0010d212
MOVDQU XMM0,xmmword ptr [RCX]
MOVDQU XMM1,xmmword ptr [RCX + 0x10]
PCMPEQB XMM1,xmmword ptr [RSP + 0x30]
PCMPEQB XMM0,xmmword ptr [RSP + 0x20]
PAND XMM0,XMM1
PMOVMSKB EAX,XMM0
CMP EAX,0xffff
SETZ AL
LAB_0010d212:
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
|
int2
verify_beacon_header(int8 param_1,int8 param_2,int4 param_3,int8 param_4)
{
ushort uVar1;
int2 uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int local_60 [2];
char *local_58;
long local_50;
char local_48;
char cStack_47;
char cStack_46;
char cStack_45;
char cStack_44;
char cStack_43;
char cStack_42;
char cStack_41;
char cStack_40;
char cStack_3f;
char cStack_3e;
char cStack_3d;
char cStack_3c;
char cStack_3b;
char cStack_3a;
char cStack_39;
char local_38;
char cStack_37;
char cStack_36;
char cStack_35;
char cStack_34;
char cStack_33;
char cStack_32;
char cStack_31;
char cStack_30;
char cStack_2f;
char cStack_2e;
char cStack_2d;
char cStack_2c;
char cStack_2b;
char cStack_2a;
char cStack_29;
ssz_get(local_60,param_1,"bodyRoot");
ssz_verify_single_merkle_proof(param_3,param_4,param_2,0x32c,&local_48);
uVar2 = 0;
if (((local_50 != 0) && (local_58 != (char *)0x0)) && (local_60[0] == 0x20)) {
auVar4[0] = -(local_58[0x10] == local_38);
auVar4[1] = -(local_58[0x11] == cStack_37);
auVar4[2] = -(local_58[0x12] == cStack_36);
auVar4[3] = -(local_58[0x13] == cStack_35);
auVar4[4] = -(local_58[0x14] == cStack_34);
auVar4[5] = -(local_58[0x15] == cStack_33);
auVar4[6] = -(local_58[0x16] == cStack_32);
auVar4[7] = -(local_58[0x17] == cStack_31);
auVar4[8] = -(local_58[0x18] == cStack_30);
auVar4[9] = -(local_58[0x19] == cStack_2f);
auVar4[10] = -(local_58[0x1a] == cStack_2e);
auVar4[0xb] = -(local_58[0x1b] == cStack_2d);
auVar4[0xc] = -(local_58[0x1c] == cStack_2c);
auVar4[0xd] = -(local_58[0x1d] == cStack_2b);
auVar4[0xe] = -(local_58[0x1e] == cStack_2a);
auVar4[0xf] = -(local_58[0x1f] == cStack_29);
auVar3[0] = -(*local_58 == local_48);
auVar3[1] = -(local_58[1] == cStack_47);
auVar3[2] = -(local_58[2] == cStack_46);
auVar3[3] = -(local_58[3] == cStack_45);
auVar3[4] = -(local_58[4] == cStack_44);
auVar3[5] = -(local_58[5] == cStack_43);
auVar3[6] = -(local_58[6] == cStack_42);
auVar3[7] = -(local_58[7] == cStack_41);
auVar3[8] = -(local_58[8] == cStack_40);
auVar3[9] = -(local_58[9] == cStack_3f);
auVar3[10] = -(local_58[10] == cStack_3e);
auVar3[0xb] = -(local_58[0xb] == cStack_3d);
auVar3[0xc] = -(local_58[0xc] == cStack_3c);
auVar3[0xd] = -(local_58[0xd] == cStack_3b);
auVar3[0xe] = -(local_58[0xe] == cStack_3a);
auVar3[0xf] = -(local_58[0xf] == cStack_39);
auVar3 = auVar3 & auVar4;
uVar1 = (ushort)(SUB161(auVar3 >> 7,0) & 1) | (ushort)(SUB161(auVar3 >> 0xf,0) & 1) << 1 |
(ushort)(SUB161(auVar3 >> 0x17,0) & 1) << 2 |
(ushort)(SUB161(auVar3 >> 0x1f,0) & 1) << 3 |
(ushort)(SUB161(auVar3 >> 0x27,0) & 1) << 4 |
(ushort)(SUB161(auVar3 >> 0x2f,0) & 1) << 5 |
(ushort)(SUB161(auVar3 >> 0x37,0) & 1) << 6 |
(ushort)(SUB161(auVar3 >> 0x3f,0) & 1) << 7 |
(ushort)(SUB161(auVar3 >> 0x47,0) & 1) << 8 |
(ushort)(SUB161(auVar3 >> 0x4f,0) & 1) << 9 |
(ushort)(SUB161(auVar3 >> 0x57,0) & 1) << 10 |
(ushort)(SUB161(auVar3 >> 0x5f,0) & 1) << 0xb |
(ushort)(SUB161(auVar3 >> 0x67,0) & 1) << 0xc |
(ushort)(SUB161(auVar3 >> 0x6f,0) & 1) << 0xd |
(ushort)(SUB161(auVar3 >> 0x77,0) & 1) << 0xe | (ushort)(byte)(auVar3[0xf] >> 7) << 0xf;
uVar2 = CONCAT11((char)(uVar1 >> 8),uVar1 == 0xffff);
}
return uVar2;
}
| |
23,643 | ssz_from_json | corpus-core[P]colibri-stateless/src/util/ssz_builder.c | ssz_ob_t ssz_from_json(json_t json, const ssz_def_t* def) {
ssz_builder_t buf = {0};
buf.def = def;
switch (def->type) {
case SSZ_TYPE_CONTAINER:
for (int i = 0; i < def->def.container.len; i++) {
ssz_ob_t ob = ssz_from_json(json_get(json, def->def.container.elements[i].name), def->def.container.elements + i);
ssz_add_bytes(&buf, def->def.container.elements[i].name, ob.bytes);
safe_free(ob.bytes.data);
}
return ssz_builder_to_bytes(&buf);
case SSZ_TYPE_UINT: {
buffer_append(&buf.fixed, bytes(NULL, def->def.uint.len));
if (def->def.uint.len <= 8) {
uint64_t val = json_as_uint64(json);
for (int i = 0; i < def->def.uint.len; i++)
buf.fixed.data.data[i] = (uint8_t) ((val >> (i * 8)) & 0xff);
}
else {
memset(buf.fixed.data.data, 0, def->def.uint.len);
bytes_t bytes = json_as_bytes(json, &buf.dynamic);
if (bytes.len > def->def.uint.len) bytes.len = def->def.uint.len;
// switch order
for (int i = 0; i < bytes.len; i++)
buf.fixed.data.data[bytes.len - i - 1] = bytes.data[i];
buffer_free(&buf.dynamic);
}
return (ssz_ob_t) {.def = def, .bytes = buf.fixed.data};
}
case SSZ_TYPE_BOOLEAN: {
buffer_grow(&buf.fixed, 1);
buf.fixed.data.data[0] = json_as_bool(json) ? 1 : 0;
return (ssz_ob_t) {.def = def, .bytes = buf.fixed.data};
}
case SSZ_TYPE_NONE: {
return (ssz_ob_t) {.def = def, .bytes = {0}};
}
case SSZ_TYPE_VECTOR: {
if (def->def.vector.type->type == SSZ_TYPE_UINT && def->def.vector.type->def.uint.len == 1) {
bytes_t bytes = json_as_bytes(json, &buf.fixed);
if (bytes.len > def->def.vector.len)
bytes.len = def->def.vector.len;
else if (bytes.len < def->def.vector.len)
buffer_append(&buf.fixed, bytes(NULL, def->def.vector.len - bytes.len));
return (ssz_ob_t) {.def = def, .bytes = buf.fixed.data};
}
else {
for (int i = 0; i < def->def.vector.len; i++) {
ssz_ob_t ob = ssz_from_json(json_at(json, i), def->def.vector.type);
buffer_append(&buf.fixed, ob.bytes);
safe_free(ob.bytes.data);
}
return (ssz_ob_t) {.def = def, .bytes = buf.fixed.data};
}
}
case SSZ_TYPE_LIST: {
if (def->def.vector.type->type == SSZ_TYPE_UINT && def->def.vector.type->def.uint.len == 1)
return (ssz_ob_t) {.def = def, .bytes = json_as_bytes(json, &buf.fixed)};
uint32_t len = json_len(json);
if (ssz_is_dynamic(def->def.vector.type))
for (uint32_t i = 0; i < len; i++) {
ssz_ob_t ob = ssz_from_json(json_at(json, i), def->def.vector.type);
ssz_add_uint32(&buf, 4 * len + buf.dynamic.data.len);
buffer_append(&buf.dynamic, ob.bytes);
safe_free(ob.bytes.data);
}
else {
buffer_grow(&buf.fixed, len * ssz_fixed_length(def->def.vector.type));
for (int i = 0; i < len; i++) {
ssz_ob_t ob = ssz_from_json(json_at(json, i), def->def.vector.type);
buffer_append(&buf.fixed, ob.bytes);
safe_free(ob.bytes.data);
}
}
return ssz_builder_to_bytes(&buf);
}
default:
return (ssz_ob_t) {.def = def, .bytes = {0}};
}
} | O3 | c | ssz_from_json:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rsp)
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl 0x8(%rsi), %eax
cmpq $0x8, %rax
ja 0x547f3
leaq 0x110(%rsp), %r15
leaq 0x3597e(%rip), %rcx # 0x8a168
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, (%r13)
movq $0x0, 0x8(%r13)
jmp 0x54bbd
leaq 0x48(%rsp), %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x50f71
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x55b34
movq 0x8(%rbx), %rcx
movb %al, (%rcx)
jmp 0x54bb5
movq 0x10(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x549eb
cmpl $0x1, 0x10(%rax)
jne 0x549eb
leaq 0x48(%rsp), %rdi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x55a84
movl %eax, (%r13)
movq %rdx, 0x8(%r13)
jmp 0x54bbd
leaq 0x48(%rsp), %rbx
movl 0x10(%r14), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x50fdd
movl 0x10(%r14), %edx
cmpq $0x8, %rdx
ja 0x54b56
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x559b9
cmpl $0x0, 0x10(%r14)
je 0x54bb5
xorl %ecx, %ecx
xorl %edx, %edx
movq %rax, %rsi
shrq %cl, %rsi
movq 0x50(%rsp), %rdi
movb %sil, (%rdi,%rdx)
incq %rdx
movl 0x10(%r14), %esi
addq $0x8, %rcx
cmpq %rsi, %rdx
jb 0x548c1
jmp 0x54bb5
cmpl $0x0, 0x18(%r14)
je 0x54c8c
movq %r13, 0x18(%rsp)
xorl %ebx, %ebx
leaq 0x40(%rsp), %r13
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%rbx), %rsi
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x556e5
movq 0x10(%r14), %rsi
addq %rbx, %rsi
movq 0xd0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xc0(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x547a4
movq 0x10(%r14), %rax
movq (%rax,%rbx), %rsi
movl 0x20(%rsp), %edx
movq 0x28(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rcx
callq 0x544a0
movq %rbp, %rdi
callq 0x50f4c
incq %r12
movl 0x18(%r14), %eax
addq $0x20, %rbx
cmpq %rax, %r12
jb 0x548ff
movl 0x60(%rsp), %esi
movq 0x68(%rsp), %rdx
movq 0x18(%rsp), %r13
jmp 0x54c90
movq 0x10(%r14), %rax
cmpl $0x0, 0x8(%rax)
jne 0x54ac3
cmpl $0x1, 0x10(%rax)
jne 0x54ac3
leaq 0x48(%rsp), %rbx
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x55a84
movl 0x18(%r14), %esi
subl %eax, %esi
jbe 0x54bb5
movq %rbx, %rdi
xorl %edx, %edx
callq 0x50fdd
jmp 0x54bb5
movq %r13, 0x18(%rsp)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x558ca
movq %rax, %r12
movl %r12d, %ebp
movq 0x10(%r14), %rdi
callq 0x51c74
testb %al, %al
je 0x54bc6
testl %ebp, %ebp
je 0x54c5b
shll $0x2, %ebp
movl %r12d, %r12d
xorl %r13d, %r13d
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x90(%rsp), %rdi
movq %r13, %rsi
callq 0x557fb
movq 0x10(%r14), %rsi
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x547a4
movl 0x60(%rsp), %eax
addl %ebp, %eax
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x4, %esi
leaq 0x3c(%rsp), %rdx
callq 0x50fdd
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rbx
leaq 0x60(%rsp), %rdi
movq %rbx, %rdx
callq 0x50fdd
movq %rbx, %rdi
callq 0x50f4c
incq %r13
cmpq %r13, %r12
jne 0x54a2e
jmp 0x54c5b
movq %r13, 0x18(%rsp)
cmpl $0x0, 0x18(%r14)
je 0x54b4a
xorl %r12d, %r12d
leaq 0xa8(%rsp), %r13
leaq 0x20(%rsp), %rbp
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x557fb
movq 0x10(%r14), %rsi
movq 0xb8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0xa8(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
callq 0x547a4
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x50fdd
movq %rbx, %rdi
callq 0x50f4c
incq %r12
movl 0x18(%r14), %eax
cmpq %rax, %r12
jb 0x54adf
movups 0x48(%rsp), %xmm0
movq 0x18(%rsp), %r13
jmp 0x54bb8
leaq 0x60(%rsp), %r12
movq -0x10(%r12), %rdi
xorl %esi, %esi
callq 0x21120
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x55a84
movl 0x10(%r14), %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
testl %ecx, %ecx
je 0x54bad
movl %ecx, %eax
decl %ecx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movq 0x50(%rsp), %r8
movl %ecx, %r9d
movb %dil, (%r8,%r9)
incq %rsi
decl %ecx
cmpq %rsi, %rax
jne 0x54b93
movq %r12, %rdi
callq 0x510bf
movups (%rbx), %xmm0
movups %xmm0, (%r13)
movq %r14, 0x10(%r13)
jmp 0x54cb9
leaq 0x48(%rsp), %r13
movl %r12d, %ebx
movq 0x10(%r14), %rdi
callq 0x51cbc
imulq %rax, %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x50f71
testl %ebp, %ebp
je 0x54c5b
movl %r12d, %r13d
xorl %r12d, %r12d
leaq 0x20(%rsp), %rbp
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
leaq 0x78(%rsp), %rdi
movq %r12, %rsi
callq 0x557fb
movq 0x10(%r14), %rsi
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
callq 0x547a4
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rbx
leaq 0x48(%rsp), %rdi
movq %rbx, %rdx
callq 0x50fdd
movq %rbx, %rdi
callq 0x50f4c
incq %r12
cmpq %r12, %r13
jne 0x54bf5
leaq 0x48(%rsp), %rdi
leaq 0x60(%rsp), %rbx
movl (%rbx), %esi
movq 0x8(%rbx), %rdx
callq 0x50fdd
movq %rbx, %rdi
callq 0x510bf
movups -0x18(%rbx), %xmm0
movq 0x18(%rsp), %r13
movups %xmm0, (%r13)
movq -0x20(%rbx), %rax
jmp 0x54cb5
xorl %edx, %edx
xorl %esi, %esi
leaq 0x48(%rsp), %rdi
leaq 0x60(%rsp), %r14
callq 0x50fdd
movq %r14, %rdi
callq 0x510bf
movups -0x18(%r14), %xmm0
movups %xmm0, (%r13)
movq -0x20(%r14), %rax
movq %rax, 0x10(%r13)
movq %r13, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| ssz_from_json:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0D8h
mov r14, rsi
mov r13, rdi
xorps xmm0, xmm0
movups [rsp+108h+var_A0], xmm0
movups [rsp+108h+var_B0], xmm0
movups [rsp+108h+var_C0], xmm0
mov [rsp+108h+var_C8], rsi
mov eax, [rsi+8]
cmp rax, 8; switch 9 cases
ja short def_547F1; jumptable 00000000000547F1 default case, cases 5-8
lea r15, [rsp+108h+arg_0]
lea rcx, jpt_547F1
movsxd rax, ds:(jpt_547F1 - 8A168h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
def_547F1:
mov dword ptr [r13+0], 0; jumptable 00000000000547F1 default case, cases 5-8
mov qword ptr [r13+8], 0
jmp loc_54BBD
loc_54808:
lea rbx, [rsp+108h+var_C0]; jumptable 00000000000547F1 case 1
mov esi, 1
mov rdi, rbx
call buffer_grow
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
call json_as_bool
mov rcx, [rbx+8]
mov [rcx], al
jmp loc_54BB5
loc_5483B:
mov rax, [r14+10h]; jumptable 00000000000547F1 case 4
cmp dword ptr [rax+8], 0
jnz loc_549EB
cmp dword ptr [rax+10h], 1
jnz loc_549EB
lea rdi, [rsp+108h+var_C0]
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
call json_as_bytes
mov [r13+0], eax
mov [r13+8], rdx
jmp loc_54BBD
loc_5487B:
lea rbx, [rsp+108h+var_C0]; jumptable 00000000000547F1 case 0
mov esi, [r14+10h]
mov rdi, rbx
xor edx, edx
call buffer_append
mov edx, [r14+10h]
cmp rdx, 8
ja loc_54B56
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
call json_as_uint64
cmp dword ptr [r14+10h], 0
jz loc_54BB5
xor ecx, ecx
xor edx, edx
loc_548C1:
mov rsi, rax
shr rsi, cl
mov rdi, qword ptr [rsp+108h+var_C0+8]
mov [rdi+rdx], sil
inc rdx
mov esi, [r14+10h]
add rcx, 8
cmp rdx, rsi
jb short loc_548C1
jmp loc_54BB5
loc_548E5:
cmp dword ptr [r14+18h], 0; jumptable 00000000000547F1 case 2
jz loc_54C8C
mov [rsp+108h+var_F0], r13
xor ebx, ebx
lea r13, [rsp+108h+var_C8]
xor r12d, r12d
loc_548FF:
mov rax, [r14+10h]
mov rsi, [rax+rbx]
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
lea rdi, [rsp+108h+var_48]
call json_get
mov rsi, [r14+10h]
add rsi, rbx
mov rax, [rsp+108h+var_38]
mov [rsp+108h+var_F8], rax
movups xmm0, [rsp+108h+var_48]
movups [rsp+108h+var_108], xmm0
lea rdi, [rsp+108h+var_E8]
call ssz_from_json
mov rax, [r14+10h]
mov rsi, [rax+rbx]
mov edx, [rsp+108h+var_E8]
mov rbp, [rsp+108h+var_E0]
mov rdi, r13
mov rcx, rbp
call ssz_add_bytes
mov rdi, rbp
call safe_free
inc r12
mov eax, [r14+18h]
add rbx, 20h ; ' '
cmp r12, rax
jb loc_548FF
mov esi, dword ptr [rsp+108h+var_B0+8]
mov rdx, qword ptr [rsp+108h+var_A0]
mov r13, [rsp+108h+var_F0]
jmp loc_54C90
loc_5499A:
mov rax, [r14+10h]; jumptable 00000000000547F1 case 3
cmp dword ptr [rax+8], 0
jnz loc_54AC3
cmp dword ptr [rax+10h], 1
jnz loc_54AC3
lea rbx, [rsp+108h+var_C0]
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
mov rdi, rbx
call json_as_bytes
mov esi, [r14+18h]
sub esi, eax
jbe loc_54BB5
mov rdi, rbx
xor edx, edx
call buffer_append
jmp loc_54BB5
loc_549EB:
mov [rsp+108h+var_F0], r13
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
call json_len
mov r12, rax
mov ebp, r12d
mov rdi, [r14+10h]
call ssz_is_dynamic
test al, al
jz loc_54BC6
test ebp, ebp
jz loc_54C5B
shl ebp, 2
mov r12d, r12d
xor r13d, r13d
loc_54A2E:
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
lea rdi, [rsp+108h+var_78]
mov rsi, r13
call json_at
mov rsi, [r14+10h]
mov rax, [rsp+108h+var_68]
mov [rsp+108h+var_F8], rax
movups xmm0, [rsp+108h+var_78]
movups [rsp+108h+var_108], xmm0
lea rdi, [rsp+108h+var_E8]
call ssz_from_json
mov eax, dword ptr [rsp+108h+var_B0+8]
add eax, ebp
mov [rsp+108h+var_CC], eax
lea rdi, [rsp+108h+var_C0]
mov esi, 4
lea rdx, [rsp+108h+var_CC]
call buffer_append
mov esi, [rsp+108h+var_E8]
mov rbx, [rsp+108h+var_E0]
lea rdi, [rsp+108h+var_B0+8]
mov rdx, rbx
call buffer_append
mov rdi, rbx
call safe_free
inc r13
cmp r12, r13
jnz loc_54A2E
jmp loc_54C5B
loc_54AC3:
mov [rsp+108h+var_F0], r13
cmp dword ptr [r14+18h], 0
jz short loc_54B4A
xor r12d, r12d
lea r13, [rsp+108h+var_60]
lea rbp, [rsp+108h+var_E8]
loc_54ADF:
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
mov rdi, r13
mov rsi, r12
call json_at
mov rsi, [r14+10h]
mov rax, [rsp+108h+var_50]
mov [rsp+108h+var_F8], rax
movups xmm0, [rsp+108h+var_60]
movups [rsp+108h+var_108], xmm0
mov rdi, rbp
call ssz_from_json
mov esi, [rsp+108h+var_E8]
mov rbx, [rsp+108h+var_E0]
lea rdi, [rsp+108h+var_C0]
mov rdx, rbx
call buffer_append
mov rdi, rbx
call safe_free
inc r12
mov eax, [r14+18h]
cmp r12, rax
jb short loc_54ADF
loc_54B4A:
movups xmm0, [rsp+108h+var_C0]
mov r13, [rsp+108h+var_F0]
jmp short loc_54BB8
loc_54B56:
lea r12, [rsp+108h+var_B0+8]
mov rdi, [r12-10h]
xor esi, esi
call _memset
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
mov rdi, r12
call json_as_bytes
mov ecx, [r14+10h]
cmp eax, ecx
cmovb ecx, eax
test ecx, ecx
jz short loc_54BAD
mov eax, ecx
dec ecx
xor esi, esi
loc_54B93:
mov dil, [rdx+rsi]
mov r8, qword ptr [rsp+108h+var_C0+8]
mov r9d, ecx
mov [r8+r9], dil
inc rsi
dec ecx
cmp rax, rsi
jnz short loc_54B93
loc_54BAD:
mov rdi, r12
call buffer_free
loc_54BB5:
movups xmm0, xmmword ptr [rbx]
loc_54BB8:
movups xmmword ptr [r13+0], xmm0
loc_54BBD:
mov [r13+10h], r14
jmp loc_54CB9
loc_54BC6:
lea r13, [rsp+108h+var_C0]
mov ebx, r12d
mov rdi, [r14+10h]
call ssz_fixed_length
imul rbx, rax
mov rdi, r13
mov rsi, rbx
call buffer_grow
test ebp, ebp
jz short loc_54C5B
mov r13d, r12d
xor r12d, r12d
lea rbp, [rsp+108h+var_E8]
loc_54BF5:
mov rax, [r15+10h]
mov [rsp+108h+var_F8], rax
movups xmm0, xmmword ptr [r15]
movups [rsp+108h+var_108], xmm0
lea rdi, [rsp+108h+var_90]
mov rsi, r12
call json_at
mov rsi, [r14+10h]
mov rax, [rsp+108h+var_80]
mov [rsp+108h+var_F8], rax
movups xmm0, [rsp+108h+var_90]
movups [rsp+108h+var_108], xmm0
mov rdi, rbp
call ssz_from_json
mov esi, [rsp+108h+var_E8]
mov rbx, [rsp+108h+var_E0]
lea rdi, [rsp+108h+var_C0]
mov rdx, rbx
call buffer_append
mov rdi, rbx
call safe_free
inc r12
cmp r13, r12
jnz short loc_54BF5
loc_54C5B:
lea rdi, [rsp+108h+var_C0]
lea rbx, [rsp+108h+var_B0+8]
mov esi, [rbx]
mov rdx, [rbx+8]
call buffer_append
mov rdi, rbx
call buffer_free
movups xmm0, xmmword ptr [rbx-18h]
mov r13, [rsp+108h+var_F0]
movups xmmword ptr [r13+0], xmm0
mov rax, [rbx-20h]
jmp short loc_54CB5
loc_54C8C:
xor edx, edx
xor esi, esi
loc_54C90:
lea rdi, [rsp+108h+var_C0]
lea r14, [rsp+108h+var_B0+8]
call buffer_append
mov rdi, r14
call buffer_free
movups xmm0, xmmword ptr [r14-18h]
movups xmmword ptr [r13+0], xmm0
mov rax, [r14-20h]
loc_54CB5:
mov [r13+10h], rax
loc_54CB9:
mov rax, r13
add rsp, 0D8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ssz_from_json(
long long a1,
_DWORD *a2,
int a3,
int a4,
int a5,
int a6,
long long a7,
long long a8,
long long a9)
{
long long v10; // r13
int v11; // edx
int v12; // ecx
int v13; // r8d
int v14; // r9d
char v15; // al
long long v16; // rax
long long v17; // rdx
unsigned int v18; // esi
int v19; // ecx
int v20; // r8d
int v21; // r9d
unsigned long long v22; // rdx
unsigned long long v23; // rax
long long v24; // rcx
unsigned long long v25; // rdx
long long v26; // rbx
unsigned long long v27; // r12
int v28; // edx
int v29; // ecx
int v30; // r8d
int v31; // r9d
long long v32; // rbp
unsigned int v33; // esi
long long v34; // rdx
long long v35; // rax
unsigned int v36; // eax
unsigned int v37; // esi
bool v38; // cc
unsigned int v39; // esi
unsigned int v40; // r12d
int v41; // edx
int v42; // ecx
int v43; // r8d
int v44; // r9d
long long j; // r13
int v46; // edx
int v47; // ecx
int v48; // r8d
int v49; // r9d
long long v50; // rbx
unsigned long long v51; // r12
int v52; // edx
int v53; // ecx
int v54; // r8d
int v55; // r9d
long long v56; // rbx
__int128 v57; // xmm0
int v58; // edx
int v59; // ecx
int v60; // r8d
int v61; // r9d
unsigned int v62; // eax
long long v63; // rdx
unsigned int v64; // ecx
long long v65; // rax
unsigned int v66; // ecx
long long i; // rsi
unsigned long long v68; // rbx
int v69; // edx
int v70; // ecx
int v71; // r8d
int v72; // r9d
long long v73; // r13
long long k; // r12
int v75; // edx
int v76; // ecx
int v77; // r8d
int v78; // r9d
long long v79; // rbx
_DWORD *v80; // rax
unsigned int v82; // [rsp+20h] [rbp-E8h] BYREF
long long v83; // [rsp+28h] [rbp-E0h]
int v84; // [rsp+3Ch] [rbp-CCh] BYREF
_DWORD *v85; // [rsp+40h] [rbp-C8h] BYREF
__int128 v86; // [rsp+48h] [rbp-C0h] BYREF
__int128 v87; // [rsp+58h] [rbp-B0h] BYREF
__int128 v88; // [rsp+68h] [rbp-A0h]
__int128 v89; // [rsp+78h] [rbp-90h] BYREF
__int128 v90; // [rsp+90h] [rbp-78h] BYREF
__int128 v91; // [rsp+A8h] [rbp-60h] BYREF
__int128 v92; // [rsp+C0h] [rbp-48h] BYREF
v10 = a1;
v88 = 0LL;
v87 = 0LL;
v86 = 0LL;
v85 = a2;
switch ( a2[2] )
{
case 0:
v18 = a2[4];
buffer_append((unsigned int *)&v86, v18, 0LL);
v22 = (unsigned int)a2[4];
if ( v22 > 8 )
{
memset(*((_QWORD *)&v86 + 1), 0LL, v22);
v62 = json_as_bytes((unsigned int)&v87 + 8, 0, v58, v59, v60, v61, a7, a8, a9);
v64 = a2[4];
if ( v62 < v64 )
v64 = v62;
if ( v64 )
{
v65 = v64;
v66 = v64 - 1;
for ( i = 0LL; i != v65; ++i )
*(_BYTE *)(*((_QWORD *)&v86 + 1) + v66--) = *(_BYTE *)(v63 + i);
}
buffer_free((long long)&v87 + 8);
}
else
{
v23 = json_as_uint64((unsigned int)&v86, v18, v22, v19, v20, v21, a7, a8, a9);
if ( a2[4] )
{
v24 = 0LL;
v25 = 0LL;
do
{
*(_BYTE *)(*((_QWORD *)&v86 + 1) + v25++) = v23 >> v24;
v24 += 8LL;
}
while ( v25 < (unsigned int)a2[4] );
}
}
goto LABEL_35;
case 1:
buffer_grow((long long)&v86, 1uLL);
v15 = json_as_bool((unsigned int)&v86, 1, v11, v12, v13, v14, a7, a8, a9);
**((_BYTE **)&v86 + 1) = v15;
goto LABEL_35;
case 2:
if ( a2[6] )
{
v26 = 0LL;
v27 = 0LL;
do
{
json_get((unsigned int)&v92, *(_QWORD *)(*((_QWORD *)a2 + 2) + v26), a3, a4, a5, a6, a7, a8, a9);
ssz_from_json((unsigned int)&v82, v26 + a2[4], v28, v29, v30, v31, v92);
v32 = v83;
ssz_add_bytes((long long)&v85, *(const char **)(*((_QWORD *)a2 + 2) + v26), v82, v83);
safe_free(v32);
++v27;
v26 += 32LL;
}
while ( v27 < (unsigned int)a2[6] );
v33 = DWORD2(v87);
v34 = v88;
v10 = a1;
}
else
{
v34 = 0LL;
v33 = 0;
}
buffer_append((unsigned int *)&v86, v33, v34);
buffer_free((long long)&v87 + 8);
*(_OWORD *)v10 = v86;
v80 = v85;
goto LABEL_44;
case 3:
v35 = *((_QWORD *)a2 + 2);
if ( *(_DWORD *)(v35 + 8) || *(_DWORD *)(v35 + 16) != 1 )
{
if ( a2[6] )
{
v51 = 0LL;
do
{
json_at((unsigned int)&v91, v51, a3, a4, a5, a6, a7, a8, a9);
ssz_from_json((unsigned int)&v82, *((_QWORD *)a2 + 2), v52, v53, v54, v55, v91);
v56 = v83;
buffer_append((unsigned int *)&v86, v82, v83);
safe_free(v56);
++v51;
}
while ( v51 < (unsigned int)a2[6] );
}
v57 = v86;
v10 = a1;
}
else
{
v36 = json_as_bytes((unsigned int)&v86, (_DWORD)a2, a3, a4, a5, a6, a7, a8, a9);
v37 = a2[6];
v38 = v37 <= v36;
v39 = v37 - v36;
if ( !v38 )
buffer_append((unsigned int *)&v86, v39, 0LL);
LABEL_35:
v57 = v86;
}
*(_OWORD *)v10 = v57;
goto LABEL_37;
case 4:
v16 = *((_QWORD *)a2 + 2);
if ( *(_DWORD *)(v16 + 8) || *(_DWORD *)(v16 + 16) != 1 )
{
v40 = json_len(a1, (_DWORD)a2, a3, a4, a5, a6, a7, a8, a9);
if ( (unsigned __int8)ssz_is_dynamic(*((_QWORD *)a2 + 2)) )
{
if ( v40 )
{
for ( j = 0LL; j != v40; ++j )
{
json_at((unsigned int)&v90, j, v41, v42, v43, v44, a7, a8, a9);
ssz_from_json((unsigned int)&v82, *((_QWORD *)a2 + 2), v46, v47, v48, v49, v90);
v84 = 4 * v40 + DWORD2(v87);
buffer_append((unsigned int *)&v86, 4u, (long long)&v84);
v50 = v83;
buffer_append((unsigned int *)&v87 + 2, v82, v83);
safe_free(v50);
}
}
}
else
{
v68 = ssz_fixed_length(*((_QWORD *)a2 + 2)) * v40;
buffer_grow((long long)&v86, v68);
if ( v40 )
{
v73 = v40;
for ( k = 0LL; k != v73; ++k )
{
json_at((unsigned int)&v89, k, v69, v70, v71, v72, a7, a8, a9);
ssz_from_json((unsigned int)&v82, *((_QWORD *)a2 + 2), v75, v76, v77, v78, v89);
v79 = v83;
buffer_append((unsigned int *)&v86, v82, v83);
safe_free(v79);
}
}
}
buffer_append((unsigned int *)&v86, DWORD2(v87), v88);
buffer_free((long long)&v87 + 8);
v10 = a1;
*(_OWORD *)a1 = v86;
v80 = v85;
LABEL_44:
*(_QWORD *)(v10 + 16) = v80;
}
else
{
*(_DWORD *)a1 = json_as_bytes((unsigned int)&v86, (_DWORD)a2, a3, a4, a5, a6, a7, a8, a9);
*(_QWORD *)(a1 + 8) = v17;
LABEL_37:
*(_QWORD *)(v10 + 16) = a2;
}
return v10;
default:
*(_DWORD *)a1 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
goto LABEL_37;
}
}
| ssz_from_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV R14,RSI
MOV R13,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSP + 0x68],XMM0
MOVUPS xmmword ptr [RSP + 0x58],XMM0
MOVUPS xmmword ptr [RSP + 0x48],XMM0
MOV qword ptr [RSP + 0x40],RSI
MOV EAX,dword ptr [RSI + 0x8]
CMP RAX,0x8
JA 0x001547f3
LEA R15,[RSP + 0x110]
LEA RCX,[0x18a168]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV dword ptr [R13],0x0
MOV qword ptr [R13 + 0x8],0x0
JMP 0x00154bbd
caseD_1:
LEA RBX,[RSP + 0x48]
MOV ESI,0x1
MOV RDI,RBX
CALL 0x00150f71
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00155b34
MOV RCX,qword ptr [RBX + 0x8]
MOV byte ptr [RCX],AL
JMP 0x00154bb5
caseD_4:
MOV RAX,qword ptr [R14 + 0x10]
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x001549eb
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x001549eb
LEA RDI,[RSP + 0x48]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x00155a84
MOV dword ptr [R13],EAX
MOV qword ptr [R13 + 0x8],RDX
JMP 0x00154bbd
caseD_0:
LEA RBX,[RSP + 0x48]
MOV ESI,dword ptr [R14 + 0x10]
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00150fdd
MOV EDX,dword ptr [R14 + 0x10]
CMP RDX,0x8
JA 0x00154b56
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001559b9
CMP dword ptr [R14 + 0x10],0x0
JZ 0x00154bb5
XOR ECX,ECX
XOR EDX,EDX
LAB_001548c1:
MOV RSI,RAX
SHR RSI,CL
MOV RDI,qword ptr [RSP + 0x50]
MOV byte ptr [RDI + RDX*0x1],SIL
INC RDX
MOV ESI,dword ptr [R14 + 0x10]
ADD RCX,0x8
CMP RDX,RSI
JC 0x001548c1
JMP 0x00154bb5
caseD_2:
CMP dword ptr [R14 + 0x18],0x0
JZ 0x00154c8c
MOV qword ptr [RSP + 0x18],R13
XOR EBX,EBX
LEA R13,[RSP + 0x40]
XOR R12D,R12D
LAB_001548ff:
MOV RAX,qword ptr [R14 + 0x10]
MOV RSI,qword ptr [RAX + RBX*0x1]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0xc0]
CALL 0x001556e5
MOV RSI,qword ptr [R14 + 0x10]
ADD RSI,RBX
MOV RAX,qword ptr [RSP + 0xd0]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0xc0]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x20]
CALL 0x001547a4
MOV RAX,qword ptr [R14 + 0x10]
MOV RSI,qword ptr [RAX + RBX*0x1]
MOV EDX,dword ptr [RSP + 0x20]
MOV RBP,qword ptr [RSP + 0x28]
MOV RDI,R13
MOV RCX,RBP
CALL 0x001544a0
MOV RDI,RBP
CALL 0x00150f4c
INC R12
MOV EAX,dword ptr [R14 + 0x18]
ADD RBX,0x20
CMP R12,RAX
JC 0x001548ff
MOV ESI,dword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x68]
MOV R13,qword ptr [RSP + 0x18]
JMP 0x00154c90
caseD_3:
MOV RAX,qword ptr [R14 + 0x10]
CMP dword ptr [RAX + 0x8],0x0
JNZ 0x00154ac3
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x00154ac3
LEA RBX,[RSP + 0x48]
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
CALL 0x00155a84
MOV ESI,dword ptr [R14 + 0x18]
SUB ESI,EAX
JBE 0x00154bb5
MOV RDI,RBX
XOR EDX,EDX
CALL 0x00150fdd
JMP 0x00154bb5
LAB_001549eb:
MOV qword ptr [RSP + 0x18],R13
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
CALL 0x001558ca
MOV R12,RAX
MOV EBP,R12D
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x00151c74
TEST AL,AL
JZ 0x00154bc6
TEST EBP,EBP
JZ 0x00154c5b
SHL EBP,0x2
MOV R12D,R12D
XOR R13D,R13D
LAB_00154a2e:
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x90]
MOV RSI,R13
CALL 0x001557fb
MOV RSI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x90]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x20]
CALL 0x001547a4
MOV EAX,dword ptr [RSP + 0x60]
ADD EAX,EBP
MOV dword ptr [RSP + 0x3c],EAX
LEA RDI,[RSP + 0x48]
MOV ESI,0x4
LEA RDX,[RSP + 0x3c]
CALL 0x00150fdd
MOV ESI,dword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
LEA RDI,[RSP + 0x60]
MOV RDX,RBX
CALL 0x00150fdd
MOV RDI,RBX
CALL 0x00150f4c
INC R13
CMP R12,R13
JNZ 0x00154a2e
JMP 0x00154c5b
LAB_00154ac3:
MOV qword ptr [RSP + 0x18],R13
CMP dword ptr [R14 + 0x18],0x0
JZ 0x00154b4a
XOR R12D,R12D
LEA R13,[RSP + 0xa8]
LEA RBP,[RSP + 0x20]
LAB_00154adf:
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R13
MOV RSI,R12
CALL 0x001557fb
MOV RSI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0xa8]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBP
CALL 0x001547a4
MOV ESI,dword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
LEA RDI,[RSP + 0x48]
MOV RDX,RBX
CALL 0x00150fdd
MOV RDI,RBX
CALL 0x00150f4c
INC R12
MOV EAX,dword ptr [R14 + 0x18]
CMP R12,RAX
JC 0x00154adf
LAB_00154b4a:
MOVUPS XMM0,xmmword ptr [RSP + 0x48]
MOV R13,qword ptr [RSP + 0x18]
JMP 0x00154bb8
LAB_00154b56:
LEA R12,[RSP + 0x60]
MOV RDI,qword ptr [R12 + -0x10]
XOR ESI,ESI
CALL 0x00121120
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,R12
CALL 0x00155a84
MOV ECX,dword ptr [R14 + 0x10]
CMP EAX,ECX
CMOVC ECX,EAX
TEST ECX,ECX
JZ 0x00154bad
MOV EAX,ECX
DEC ECX
XOR ESI,ESI
LAB_00154b93:
MOV DIL,byte ptr [RDX + RSI*0x1]
MOV R8,qword ptr [RSP + 0x50]
MOV R9D,ECX
MOV byte ptr [R8 + R9*0x1],DIL
INC RSI
DEC ECX
CMP RAX,RSI
JNZ 0x00154b93
LAB_00154bad:
MOV RDI,R12
CALL 0x001510bf
LAB_00154bb5:
MOVUPS XMM0,xmmword ptr [RBX]
LAB_00154bb8:
MOVUPS xmmword ptr [R13],XMM0
LAB_00154bbd:
MOV qword ptr [R13 + 0x10],R14
JMP 0x00154cb9
LAB_00154bc6:
LEA R13,[RSP + 0x48]
MOV EBX,R12D
MOV RDI,qword ptr [R14 + 0x10]
CALL 0x00151cbc
IMUL RBX,RAX
MOV RDI,R13
MOV RSI,RBX
CALL 0x00150f71
TEST EBP,EBP
JZ 0x00154c5b
MOV R13D,R12D
XOR R12D,R12D
LEA RBP,[RSP + 0x20]
LAB_00154bf5:
MOV RAX,qword ptr [R15 + 0x10]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RSP],XMM0
LEA RDI,[RSP + 0x78]
MOV RSI,R12
CALL 0x001557fb
MOV RSI,qword ptr [R14 + 0x10]
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x78]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBP
CALL 0x001547a4
MOV ESI,dword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
LEA RDI,[RSP + 0x48]
MOV RDX,RBX
CALL 0x00150fdd
MOV RDI,RBX
CALL 0x00150f4c
INC R12
CMP R13,R12
JNZ 0x00154bf5
LAB_00154c5b:
LEA RDI,[RSP + 0x48]
LEA RBX,[RSP + 0x60]
MOV ESI,dword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
CALL 0x00150fdd
MOV RDI,RBX
CALL 0x001510bf
MOVUPS XMM0,xmmword ptr [RBX + -0x18]
MOV R13,qword ptr [RSP + 0x18]
MOVUPS xmmword ptr [R13],XMM0
MOV RAX,qword ptr [RBX + -0x20]
JMP 0x00154cb5
LAB_00154c8c:
XOR EDX,EDX
XOR ESI,ESI
LAB_00154c90:
LEA RDI,[RSP + 0x48]
LEA R14,[RSP + 0x60]
CALL 0x00150fdd
MOV RDI,R14
CALL 0x001510bf
MOVUPS XMM0,xmmword ptr [R14 + -0x18]
MOVUPS xmmword ptr [R13],XMM0
MOV RAX,qword ptr [R14 + -0x20]
LAB_00154cb5:
MOV qword ptr [R13 + 0x10],RAX
LAB_00154cb9:
MOV RAX,R13
ADD RSP,0xd8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * ssz_from_json(int8 *param_1,long param_2)
{
int8 uVar1;
int1 uVar2;
char cVar3;
int4 uVar4;
uint uVar5;
uint uVar6;
long lVar7;
byte bVar8;
int8 extraout_RDX;
ulong uVar9;
long extraout_RDX_00;
int iVar10;
ulong uVar11;
int4 local_e8 [2];
int8 local_e0;
int local_cc;
long local_c8;
int8 local_c0;
int8 uStack_b8;
int8 local_b0;
ulong uStack_a8;
int8 local_a0;
int8 uStack_98;
int1 local_90 [24];
int1 local_78 [24];
int1 local_60 [24];
int1 local_48 [24];
local_a0 = 0;
uStack_98 = 0;
local_b0 = 0;
uStack_a8 = 0;
local_c0 = 0;
uStack_b8 = (int1 *)0x0;
local_c8 = param_2;
switch(*(int4 *)(param_2 + 8)) {
case 0:
buffer_append(&local_c0,*(int4 *)(param_2 + 0x10),0);
if ((ulong)*(uint *)(param_2 + 0x10) < 9) {
uVar11 = json_as_uint64();
if (*(int *)(param_2 + 0x10) != 0) {
bVar8 = 0;
uVar9 = 0;
do {
uStack_b8[uVar9] = (char)(uVar11 >> (bVar8 & 0x3f));
uVar9 = uVar9 + 1;
bVar8 = bVar8 + 8;
} while (uVar9 < *(uint *)(param_2 + 0x10));
}
}
else {
memset(uStack_b8,0,(ulong)*(uint *)(param_2 + 0x10));
uVar6 = json_as_bytes(&uStack_a8);
uVar5 = *(uint *)(param_2 + 0x10);
if (uVar6 < *(uint *)(param_2 + 0x10)) {
uVar5 = uVar6;
}
uVar11 = (ulong)uVar5;
if (uVar5 != 0) {
uVar9 = 0;
do {
uVar5 = uVar5 - 1;
uStack_b8[uVar5] = *(int1 *)(extraout_RDX_00 + uVar9);
uVar9 = uVar9 + 1;
} while (uVar11 != uVar9);
}
buffer_free(&uStack_a8);
}
break;
case 1:
buffer_grow(&local_c0,1);
uVar2 = json_as_bool();
*uStack_b8 = uVar2;
break;
case 2:
if (*(int *)(param_2 + 0x18) == 0) {
uVar11 = 0;
}
else {
lVar7 = 0;
uVar11 = 0;
do {
json_get(local_48,*(int8 *)(*(long *)(param_2 + 0x10) + lVar7));
ssz_from_json(local_e8,*(long *)(param_2 + 0x10) + lVar7);
uVar1 = local_e0;
ssz_add_bytes(&local_c8,*(int8 *)(*(long *)(param_2 + 0x10) + lVar7),local_e8[0],
local_e0);
safe_free(uVar1);
uVar11 = uVar11 + 1;
lVar7 = lVar7 + 0x20;
} while (uVar11 < *(uint *)(param_2 + 0x18));
uVar11 = uStack_a8 & 0xffffffff;
}
buffer_append(&local_c0,uVar11,local_a0);
buffer_free(&uStack_a8);
*param_1 = local_c0;
param_1[1] = uStack_b8;
LAB_00154cb5:
param_1[2] = local_c8;
return param_1;
case 3:
if ((*(int *)(*(long *)(param_2 + 0x10) + 8) == 0) &&
(*(int *)(*(long *)(param_2 + 0x10) + 0x10) == 1)) {
uVar5 = json_as_bytes(&local_c0);
iVar10 = *(uint *)(param_2 + 0x18) - uVar5;
if (uVar5 <= *(uint *)(param_2 + 0x18) && iVar10 != 0) {
buffer_append(&local_c0,iVar10,0);
}
break;
}
if (*(int *)(param_2 + 0x18) != 0) {
uVar11 = 0;
do {
json_at(local_60,uVar11);
ssz_from_json(local_e8,*(int8 *)(param_2 + 0x10));
uVar1 = local_e0;
buffer_append(&local_c0,local_e8[0],local_e0);
safe_free(uVar1);
uVar11 = uVar11 + 1;
} while (uVar11 < *(uint *)(param_2 + 0x18));
}
goto LAB_00154bb8;
case 4:
if ((*(int *)(*(long *)(param_2 + 0x10) + 8) != 0) ||
(*(int *)(*(long *)(param_2 + 0x10) + 0x10) != 1)) {
uVar5 = json_len();
cVar3 = ssz_is_dynamic(*(int8 *)(param_2 + 0x10));
if (cVar3 == '\0') {
lVar7 = ssz_fixed_length(*(int8 *)(param_2 + 0x10));
buffer_grow(&local_c0,(ulong)uVar5 * lVar7);
if (uVar5 != 0) {
uVar11 = 0;
do {
json_at(local_90,uVar11);
ssz_from_json(local_e8,*(int8 *)(param_2 + 0x10));
uVar1 = local_e0;
buffer_append(&local_c0,local_e8[0],local_e0);
safe_free(uVar1);
uVar11 = uVar11 + 1;
} while (uVar5 != uVar11);
}
}
else if (uVar5 != 0) {
uVar11 = 0;
do {
json_at(local_78,uVar11);
ssz_from_json(local_e8,*(int8 *)(param_2 + 0x10));
local_cc = (int)uStack_a8 + uVar5 * 4;
buffer_append(&local_c0,4,&local_cc);
uVar1 = local_e0;
buffer_append(&uStack_a8,local_e8[0],local_e0);
safe_free(uVar1);
uVar11 = uVar11 + 1;
} while (uVar5 != uVar11);
}
buffer_append(&local_c0,uStack_a8 & 0xffffffff,local_a0);
buffer_free(&uStack_a8);
*param_1 = local_c0;
param_1[1] = uStack_b8;
goto LAB_00154cb5;
}
uVar4 = json_as_bytes(&local_c0);
*(int4 *)param_1 = uVar4;
param_1[1] = extraout_RDX;
goto LAB_00154bbd;
default:
*(int4 *)param_1 = 0;
param_1[1] = 0;
goto LAB_00154bbd;
}
LAB_00154bb8:
*(int4 *)param_1 = (int4)local_c0;
*(int4 *)((long)param_1 + 4) = local_c0._4_4_;
*(int4 *)(param_1 + 1) = (int4)uStack_b8;
*(int4 *)((long)param_1 + 0xc) = uStack_b8._4_4_;
LAB_00154bbd:
param_1[2] = param_2;
return param_1;
}
| |
23,644 | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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> const&) | monkey531[P]llama/common/./json.hpp | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
} | O0 | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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> const&):
subq $0xe8, %rsp
movq %rdx, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xa2c40
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x125d08
jmp 0x125e43
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq %rcx, (%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x125d25
jmp 0x125e0b
movb $0x1, 0x93(%rsp)
movl $0x20, %edi
callq 0x50540
movq %rax, 0x10(%rsp)
leaq 0xa7(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x50d60
movq 0x18(%rsp), %rdx
leaq 0xa9564(%rip), %rsi # 0x1cf2be
leaq 0xa8(%rsp), %rdi
callq 0x61bd0
jmp 0x125d69
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rdi
movl $0xca, %esi
leaq 0xa8(%rsp), %rdx
callq 0xbb830
jmp 0x125d87
movq 0x10(%rsp), %rdi
movb $0x0, 0x93(%rsp)
leaq 0x12c485(%rip), %rsi # 0x252220
leaq -0x6a3c2(%rip), %rdx # 0xbb9e0
callq 0x508f0
jmp 0x125f0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x125de3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x510c0
leaq 0xa7(%rsp), %rdi
callq 0x510a0
testb $0x1, 0x93(%rsp)
jne 0x125dfc
jmp 0x125e06
movq 0x10(%rsp), %rdi
callq 0x50c40
jmp 0x125f01
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x125f10
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0xc8(%rsp), %rcx
leaq 0x70(%rsp), %rdx
callq 0x125f50
movq 0x30(%rsp), %rax
addq $0xe8, %rsp
retq
movb $0x1, 0x47(%rsp)
movl $0x20, %edi
callq 0x50540
movq 0x38(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xa04c0
movq %rax, 0x48(%rsp)
leaq 0xaf2d1(%rip), %rsi # 0x1d513e
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x126090
jmp 0x125e7e
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rdi
movl $0x135, %esi # imm = 0x135
leaq 0x50(%rsp), %rdx
callq 0xbbd90
jmp 0x125e99
movq 0x8(%rsp), %rdi
movb $0x0, 0x47(%rsp)
leaq 0x12c24e(%rip), %rsi # 0x2520f8
leaq -0x85941(%rip), %rdx # 0xa0570
callq 0x508f0
jmp 0x125f0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x125eec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x47(%rsp)
jne 0x125ef5
jmp 0x125eff
movq 0x8(%rsp), %rdi
callq 0x50c40
jmp 0x125f01
movq 0x98(%rsp), %rdi
callq 0x50940
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
sub rsp, 0E8h
mov qword ptr [rsp+0E8h+var_C8], rdx; int
mov qword ptr [rsp+0E8h+var_C0], rdi; int
mov rax, rdi
mov qword ptr [rsp+0E8h+var_B8], rax; int
mov [rsp+0E8h+var_8], rdi
mov qword ptr [rsp+0E8h+var_10], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_20], rcx
mov rdi, qword ptr [rsp+0E8h+var_10]
mov qword ptr [rsp+0E8h+var_B0], rdi; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; 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>::is_array(void)
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_125D08
jmp loc_125E43
loc_125D08:
mov rax, qword ptr [rsp+0E8h+var_C8]
mov rcx, qword ptr [rsp+0E8h+var_B0]
cmp [rax], rcx
setnz al
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_125D25
jmp loc_125E0B
loc_125D25:
mov [rsp+0E8h+var_55], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0E8h+var_D8], rax; int
lea rdi, [rsp+0E8h+var_41]
mov qword ptr [rsp+0E8h+var_D0], rdi; char
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rdx, qword ptr [rsp+0E8h+var_D0]
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdi, [rsp+0E8h+var_40]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_125D69:
mov rcx, qword ptr [rsp+0E8h+var_B0]
mov rdi, [rsp+0E8h+var_D8]; int
mov esi, 0CAh
lea rdx, [rsp+0E8h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_125D87:
mov rdi, [rsp+0E8h+var_D8]; void *
mov [rsp+0E8h+var_55], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_125F0E
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_125DE3
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, [rsp+arg_A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_125DE3:
lea rdi, [rsp+arg_9F]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_8B], 1
jnz short loc_125DFC
jmp short loc_125E06
loc_125DFC:
mov rdi, [rsp+arg_8]; void *
call ___cxa_free_exception
loc_125E06:
jmp loc_125F01
loc_125E0B:
mov rsi, qword ptr [rsp+0E8h+var_C8]
lea rdi, [rsp+0E8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERKSH_; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::iter_impl(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const> const&)
mov rdi, qword ptr [rsp+0E8h+var_C0]
mov rsi, qword ptr [rsp+0E8h+var_B0]
mov rcx, [rsp+0E8h+var_20]
lea rdx, [rsp+0E8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, qword ptr [rsp+0E8h+var_B8]
add rsp, 0E8h
retn
loc_125E43:
mov [rsp+0E8h+var_A1], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, qword ptr [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_E0], rax; int
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+0E8h+var_A0], rax; int
lea rsi, aCannotUseInser; "cannot use insert() with "
lea rdi, [rsp+0E8h+var_98]; int
lea rdx, [rsp+0E8h+var_A0]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
jmp short $+2
loc_125E7E:
mov rcx, qword ptr [rsp+0E8h+var_B0]
mov rdi, [rsp+0E8h+var_E0]; int
mov esi, 135h
lea rdx, [rsp+0E8h+var_98]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_125E99:
mov rdi, [rsp+0E8h+var_E0]; void *
mov [rsp+0E8h+var_A1], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
| 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>::insert(
long long a1,
_BYTE *a2,
_QWORD *a3,
long long a4)
{
int v5; // ecx
int v6; // r8d
int v7; // r9d
int v8; // [rsp+0h] [rbp-E8h]
void *exception; // [rsp+8h] [rbp-E0h]
nlohmann::json_abi_v3_11_3::detail::type_error *v10; // [rsp+8h] [rbp-E0h]
int v11; // [rsp+10h] [rbp-D8h]
nlohmann::json_abi_v3_11_3::detail::invalid_iterator *v12; // [rsp+10h] [rbp-D8h]
long long v13; // [rsp+18h] [rbp-D0h]
int v15[2]; // [rsp+48h] [rbp-A0h] BYREF
int v16[8]; // [rsp+50h] [rbp-98h] BYREF
char v17[55]; // [rsp+70h] [rbp-78h] BYREF
char v18; // [rsp+A7h] [rbp-41h] BYREF
_BYTE v19[32]; // [rsp+A8h] [rbp-40h] BYREF
long long v20; // [rsp+C8h] [rbp-20h]
_QWORD *v21; // [rsp+D0h] [rbp-18h]
int v22[2]; // [rsp+D8h] [rbp-10h]
long long v23; // [rsp+E0h] [rbp-8h]
v23 = a1;
*(_QWORD *)v22 = a2;
v21 = a3;
v20 = a4;
if ( !nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(a2) )
{
exception = __cxa_allocate_exception(0x20uLL);
*(_QWORD *)v15 = 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(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
(int)v16,
(int)"cannot use insert() with ",
(int)v15,
v5,
v6,
v7,
v8,
exception,
v11,
v13);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v10,
309,
(long long)v16,
(long long)a2);
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
if ( (_BYTE *)*a3 != a2 )
{
v12 = (nlohmann::json_abi_v3_11_3::detail::invalid_iterator *)__cxa_allocate_exception(0x20uLL);
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>(
(long long)v19,
(long long)"iterator does not fit current value",
(long long)&v18);
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v12,
202,
(long long)v19,
(long long)a2);
v17[35] = 0;
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::invalid_iterator::~invalid_iterator);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::iter_impl(v17);
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>::insert_iterator<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&>(
a1,
a2,
v17,
v20);
return a1;
}
| |||
23,645 | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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> const&) | monkey531[P]llama/common/./json.hpp | iterator insert(const_iterator pos, const basic_json& val)
{
// insert only works for arrays
if (JSON_HEDLEY_LIKELY(is_array()))
{
// check if iterator pos fits to this JSON value
if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
// insert to array and return iterator
return insert_iterator(pos, val);
}
JSON_THROW(type_error::create(309, detail::concat("cannot use insert() with ", type_name()), this));
} | 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> 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> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
cmpb $0x2, (%rsi)
jne 0x6f4be
movq (%rdx), %rsi
cmpq %r14, %rsi
jne 0x6f51a
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rax)
movq 0x18(%rdx), %rdx
movq %rdx, 0x18(%rax)
movq %r14, %rsi
movq %rax, %rdx
callq 0x6f5bc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x18360
movq %rax, %rbx
movq %r14, %rdi
callq 0x3e096
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x4d2a7(%rip), %rsi # 0xbc789
movq %rsp, %rdi
callq 0x6f62e
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x135, %esi # imm = 0x135
movq %r14, %rcx
callq 0x49cf4
xorl %ebp, %ebp
leaq 0x7edaf(%rip), %rsi # 0xee2b8
leaq -0x23160(%rip), %rdx # 0x4c3b0
movq %rbx, %rdi
callq 0x18b30
jmp 0x6f574
movl $0x20, %edi
callq 0x18360
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4a07d(%rip), %rsi # 0xb95b4
leaq 0x4a099(%rip), %rdx # 0xb95d7
movq %rsp, %rdi
callq 0x590a2
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x49aa2
xorl %ebp, %ebp
leaq 0x7ee7b(%rip), %rsi # 0xee3e0
leaq -0x231bc(%rip), %rdx # 0x4c3b0
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x6f595
jmp 0x6f5a2
jmp 0x6f5a9
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f5a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x6f5ac
jmp 0x6f5b4
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6insertENS0_6detail9iter_implIKSD_EERSG_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rsi
cmp byte ptr [rsi], 2
jnz short loc_6F4BE
mov rsi, [rdx]
cmp rsi, r14
jnz loc_6F51A
mov rbx, rdi
lea rax, [rsp+68h+var_40]
mov [rax], rsi
movups xmm0, xmmword ptr [rdx+8]
movups xmmword ptr [rax+8], xmm0
mov rdx, [rdx+18h]
mov [rax+18h], rdx
mov rsi, r14
mov rdx, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE15insert_iteratorIJRKSD_EEENS0_6detail9iter_implISD_EENSI_ISF_EEDpOT_; 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>::insert_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov rax, rbx
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6F4BE:
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+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseInser; "cannot use insert() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 135h; 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
jmp short loc_6F574
loc_6F51A:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
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 bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_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_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_6F574:
mov r14, rax
mov rdi, [rsp+68h+var_68]
cmp rdi, r15
jnz short loc_6F595
jmp short loc_6F5A2
jmp short loc_6F5A9
mov r14, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_6F5A2
loc_6F595:
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_6F5A2:
test bpl, bpl
jnz short loc_6F5AC
jmp short loc_6F5B4
loc_6F5A9:
mov r14, rax
loc_6F5AC:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_6F5B4:
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>::insert(
long long a1,
unsigned __int8 *a2,
long long a3)
{
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v5; // rbx
_QWORD v6[2]; // [rsp+0h] [rbp-68h] BYREF
_QWORD v7[3]; // [rsp+10h] [rbp-58h] BYREF
unsigned __int8 *v8; // [rsp+28h] [rbp-40h] BYREF
__int128 v9; // [rsp+30h] [rbp-38h]
long long v10; // [rsp+40h] [rbp-28h]
if ( *a2 != 2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v7[2] = 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(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
v6,
"cannot use insert() 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,
309,
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);
}
if ( *(unsigned __int8 **)a3 != a2 )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v6[0] = v7;
std::string::_M_construct<char const*>((long long)v6, "iterator does not fit current value", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
202,
v6);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v8 = *(unsigned __int8 **)a3;
v9 = *(_OWORD *)(a3 + 8);
v10 = *(_QWORD *)(a3 + 24);
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>::insert_iterator<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&>(
a1,
a2,
&v8);
return a1;
}
| insert:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RSI
CMP byte ptr [RSI],0x2
JNZ 0x0016f4be
MOV RSI,qword ptr [RDX]
CMP RSI,R14
JNZ 0x0016f51a
MOV RBX,RDI
LEA RAX,[RSP + 0x28]
MOV qword ptr [RAX],RSI
MOVUPS XMM0,xmmword ptr [RDX + 0x8]
MOVUPS xmmword ptr [RAX + 0x8],XMM0
MOV RDX,qword ptr [RDX + 0x18]
MOV qword ptr [RAX + 0x18],RDX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0016f5bc
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016f4be:
MOV EDI,0x20
CALL 0x00118360
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013e096
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0016f4db:
LEA RSI,[0x1bc789]
MOV RDI,RSP
CALL 0x0016f62e
MOV BPL,0x1
LAB_0016f4ed:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x135
MOV RCX,R14
CALL 0x00149cf4
XOR EBP,EBP
LEA RSI,[0x1ee2b8]
LEA RDX,[0x14c3b0]
MOV RDI,RBX
CALL 0x00118b30
LAB_0016f51a:
MOV EDI,0x20
CALL 0x00118360
MOV RBX,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_0016f530:
LEA RSI,[0x1b95b4]
LEA RDX,[0x1b95d7]
MOV RDI,RSP
CALL 0x001590a2
MOV BPL,0x1
LAB_0016f549:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x00149aa2
XOR EBP,EBP
LEA RSI,[0x1ee3e0]
LEA RDX,[0x14c3b0]
MOV RDI,RBX
CALL 0x00118b30
|
/* 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>::insert(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> 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> const&) */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
* __thiscall
nlohmann::json_abi_v3_11_3::
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>
::insert(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<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_2,long *param_3)
{
int8 uVar1;
int1 *local_68 [2];
int1 local_58 [16];
char *local_48;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*local_40;
int4 local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
long local_28;
if (*param_2 !=
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x2) {
uVar1 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name(param_2);
/* try { // try from 0016f4db to 0016f4e9 has its CatchHandler @ 0016f5a9 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)local_68,"cannot use insert() with ",&local_48);
/* try { // try from 0016f4ed to 0016f517 has its CatchHandler @ 0016f584 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0x135,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_40 = (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_3;
if (local_40 == param_2) {
local_38 = (int4)param_3[1];
uStack_34 = *(int4 *)((long)param_3 + 0xc);
uStack_30 = (int4)param_3[2];
uStack_2c = *(int4 *)((long)param_3 + 0x14);
local_28 = param_3[3];
insert_iterator<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&>
(this,param_2,&local_40);
return this;
}
uVar1 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
/* try { // try from 0016f530 to 0016f545 has its CatchHandler @ 0016f582 */
std::__cxx11::string::_M_construct<char_const*>(local_68,"iterator does not fit current value","")
;
/* try { // try from 0016f549 to 0016f573 has its CatchHandler @ 0016f574 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar1,0xca,local_68,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
| |
23,646 | json_as_string | corpus-core[P]colibri-stateless/src/util/json.c | char* json_as_string(json_t val, buffer_t* buffer) {
buffer->data.len = 0;
buffer_grow(buffer, val.len + 1);
if (val.type == JSON_TYPE_STRING)
buffer_append(buffer, bytes((uint8_t*) val.start + 1, val.len - 2));
else
buffer_append(buffer, bytes((uint8_t*) val.start, val.len));
buffer->data.data[buffer->data.len] = '\0';
return (char*) buffer->data.data;
} | O0 | c | json_as_string:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movl $0x0, (%rcx)
movq -0x8(%rbp), %rdi
movq 0x8(%rax), %rsi
addq $0x1, %rsi
callq 0x9dfa0
movq -0x30(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0xa5d85
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq 0x8(%rax), %rcx
subq $0x2, %rcx
movl %ecx, -0x18(%rbp)
movq (%rax), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x9e080
jmp 0xa5da7
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rdi
movq 0x8(%rax), %rcx
movl %ecx, -0x28(%rbp)
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x9e080
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| json_as_string:
push rbp
mov rbp, rsp
sub rsp, 30h
lea rax, [rbp+arg_0]
mov [rbp+var_30], rax
mov [rbp+var_8], rdi
mov rcx, [rbp+var_8]
mov dword ptr [rcx], 0
mov rdi, [rbp+var_8]
mov rsi, [rax+8]
add rsi, 1
call buffer_grow
mov rax, [rbp+var_30]
cmp dword ptr [rax+10h], 1
jnz short loc_A5D85
mov rax, [rbp+var_30]
mov rdi, [rbp+var_8]
mov rcx, [rax+8]
sub rcx, 2
mov [rbp+var_18], ecx
mov rax, [rax]
add rax, 1
mov [rbp+var_10], rax
mov esi, [rbp+var_18]
mov rdx, [rbp+var_10]
call buffer_append
jmp short loc_A5DA7
loc_A5D85:
mov rax, [rbp+var_30]
mov rdi, [rbp+var_8]
mov rcx, [rax+8]
mov [rbp+var_28], ecx
mov rax, [rax]
mov [rbp+var_20], rax
mov esi, [rbp+var_28]
mov rdx, [rbp+var_20]
call buffer_append
loc_A5DA7:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov rcx, [rbp+var_8]
mov ecx, [rcx]
mov byte ptr [rax+rcx], 0
mov rax, [rbp+var_8]
mov rax, [rax+8]
add rsp, 30h
pop rbp
retn
| long long json_as_string(
unsigned int *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
int a9)
{
*a1 = 0;
buffer_grow((unsigned long long)a1, a8 + 1);
if ( a9 == 1 )
buffer_append(a1, a8 - 2, a7 + 1);
else
buffer_append(a1, a8, a7);
*(_BYTE *)(*((_QWORD *)a1 + 1) + *a1) = 0;
return *((_QWORD *)a1 + 1);
}
| json_as_string:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
LEA RAX,[RBP + 0x10]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV RCX,qword ptr [RBP + -0x8]
MOV dword ptr [RCX],0x0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x8]
ADD RSI,0x1
CALL 0x0019dfa0
MOV RAX,qword ptr [RBP + -0x30]
CMP dword ptr [RAX + 0x10],0x1
JNZ 0x001a5d85
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
SUB RCX,0x2
MOV dword ptr [RBP + -0x18],ECX
MOV RAX,qword ptr [RAX]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
MOV ESI,dword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x10]
CALL 0x0019e080
JMP 0x001a5da7
LAB_001a5d85:
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x28],ECX
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV ESI,dword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0019e080
LAB_001a5da7:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
ADD RSP,0x30
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8 json_as_string(uint *param_1)
{
long in_stack_00000008;
ulong in_stack_00000010;
int in_stack_00000018;
*param_1 = 0;
buffer_grow(param_1,in_stack_00000010 + 1);
if (in_stack_00000018 == 1) {
buffer_append(param_1,(int)in_stack_00000010 + -2,in_stack_00000008 + 1);
}
else {
buffer_append(param_1,in_stack_00000010 & 0xffffffff,in_stack_00000008);
}
*(int1 *)(*(long *)(param_1 + 2) + (ulong)*param_1) = 0;
return *(int8 *)(param_1 + 2);
}
| |
23,647 | json_as_string | corpus-core[P]colibri-stateless/src/util/json.c | char* json_as_string(json_t val, buffer_t* buffer) {
buffer->data.len = 0;
buffer_grow(buffer, val.len + 1);
if (val.type == JSON_TYPE_STRING)
buffer_append(buffer, bytes((uint8_t*) val.start + 1, val.len - 2));
else
buffer_append(buffer, bytes((uint8_t*) val.start, val.len));
buffer->data.data[buffer->data.len] = '\0';
return (char*) buffer->data.data;
} | O2 | c | json_as_string:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, (%rdi)
leaq 0x20(%rsp), %r15
movq 0x8(%r15), %r14
leaq 0x1(%r14), %rsi
callq 0x4b01d
cmpl $0x1, 0x10(%r15)
jne 0x4f7bd
addl $-0x2, %r14d
movq (%r15), %rdx
incq %rdx
jmp 0x4f7c0
movq (%r15), %rdx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4b08b
movq 0x8(%rbx), %rax
movl (%rbx), %ecx
movb $0x0, (%rax,%rcx)
movq 0x8(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
| json_as_string:
push r15
push r14
push rbx
mov rbx, rdi
and dword ptr [rdi], 0
lea r15, [rsp+18h+arg_0]
mov r14, [r15+8]
lea rsi, [r14+1]
call buffer_grow
cmp dword ptr [r15+10h], 1
jnz short loc_4F7BD
add r14d, 0FFFFFFFEh
mov rdx, [r15]
inc rdx
jmp short loc_4F7C0
loc_4F7BD:
mov rdx, [r15]
loc_4F7C0:
mov rdi, rbx
mov esi, r14d
call buffer_append
mov rax, [rbx+8]
mov ecx, [rbx]
mov byte ptr [rax+rcx], 0
mov rax, [rbx+8]
pop rbx
pop r14
pop r15
retn
| long long json_as_string(
unsigned int *a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
long long a7,
long long a8,
int a9)
{
unsigned int v9; // r14d
long long v10; // rdx
*a1 = 0;
v9 = a8;
buffer_grow((long long)a1, a8 + 1);
if ( a9 == 1 )
{
v9 = a8 - 2;
v10 = a7 + 1;
}
else
{
v10 = a7;
}
buffer_append(a1, v9, v10);
*(_BYTE *)(*((_QWORD *)a1 + 1) + *a1) = 0;
return *((_QWORD *)a1 + 1);
}
| json_as_string:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
AND dword ptr [RDI],0x0
LEA R15,[RSP + 0x20]
MOV R14,qword ptr [R15 + 0x8]
LEA RSI,[R14 + 0x1]
CALL 0x0014b01d
CMP dword ptr [R15 + 0x10],0x1
JNZ 0x0014f7bd
ADD R14D,-0x2
MOV RDX,qword ptr [R15]
INC RDX
JMP 0x0014f7c0
LAB_0014f7bd:
MOV RDX,qword ptr [R15]
LAB_0014f7c0:
MOV RDI,RBX
MOV ESI,R14D
CALL 0x0014b08b
MOV RAX,qword ptr [RBX + 0x8]
MOV ECX,dword ptr [RBX]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RAX,qword ptr [RBX + 0x8]
POP RBX
POP R14
POP R15
RET
|
int8 json_as_string(uint *param_1)
{
long in_stack_00000008;
ulong in_stack_00000010;
int in_stack_00000018;
*param_1 = 0;
buffer_grow(param_1,in_stack_00000010 + 1);
if (in_stack_00000018 == 1) {
in_stack_00000010 = (ulong)((int)in_stack_00000010 - 2);
in_stack_00000008 = in_stack_00000008 + 1;
}
buffer_append(param_1,in_stack_00000010 & 0xffffffff,in_stack_00000008);
*(int1 *)(*(long *)(param_1 + 2) + (ulong)*param_1) = 0;
return *(int8 *)(param_1 + 2);
}
| |
23,648 | evmone::EOF1Header::get_data(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>) const | corpus-core[P]colibri-stateless/build_O1/_deps/evmone_external-src/lib/evmone/eof.hpp | [[nodiscard]] bytes_view get_data(bytes_view container) const noexcept
{
return container.substr(data_offset);
} | O1 | cpp | evmone::EOF1Header::get_data(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned char>>) const:
pushq %rax
movq %rdx, %r8
movl 0x44(%rdi), %edx
movq %rsi, %rax
subq %rdx, %rax
jb 0x46209
addq %rdx, %r8
movq %r8, %rdx
popq %rcx
retq
movq %rsi, %rcx
leaq 0x41160(%rip), %rdi # 0x87373
leaq 0x4113f(%rip), %rsi # 0x87359
xorl %eax, %eax
callq 0x22050
movq %rax, %rdi
callq 0x30731
| _ZNK6evmone10EOF1Header8get_dataESt17basic_string_viewIhN4evmc11byte_traitsIhEEE:
push rax
mov r8, rdx
mov edx, [rdi+44h]
mov rax, rsi
sub rax, rdx
jb short loc_46209
add r8, rdx
mov rdx, r8
pop rcx
retn
loc_46209:
mov rcx, rsi
lea rdi, aSPosWhichIsZuS; "%s: __pos (which is %zu) > __size (whic"...
lea rsi, aBasicStringVie; "basic_string_view::substr"
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
mov rdi, rax
call __clang_call_terminate
| unsigned long long evmone::EOF1Header::get_data(long long a1, unsigned long long a2)
{
unsigned long long v2; // rdx
unsigned long long result; // rax
v2 = *(unsigned int *)(a1 + 68);
result = a2 - v2;
if ( a2 < v2 )
std::__throw_out_of_range_fmt(
"%s: __pos (which is %zu) > __size (which is %zu)",
"basic_string_view::substr",
v2,
a2);
return result;
}
| get_data:
PUSH RAX
MOV R8,RDX
MOV EDX,dword ptr [RDI + 0x44]
MOV RAX,RSI
SUB RAX,RDX
JC 0x00146209
ADD R8,RDX
MOV RDX,R8
POP RCX
RET
LAB_00146209:
MOV RCX,RSI
LEA RDI,[0x187373]
LEA RSI,[0x187359]
XOR EAX,EAX
CALL 0x00122050
|
/* evmone::EOF1Header::get_data(std::basic_string_view<unsigned char, evmc::byte_traits<unsigned
char> >) const */
int1 [16] evmone::EOF1Header::get_data(long param_1,ulong param_2,long param_3)
{
ulong uVar1;
int1 auVar2 [16];
uVar1 = (ulong)*(uint *)(param_1 + 0x44);
auVar2._0_8_ = param_2 - uVar1;
if (uVar1 <= param_2) {
auVar2._8_8_ = param_3 + uVar1;
return auVar2;
}
/* try { // try from 00146209 to 00146220 has its CatchHandler @ 00146221 */
/* WARNING: Subroutine does not return */
std::__throw_out_of_range_fmt
("%s: __pos (which is %zu) > __size (which is %zu)","basic_string_view::substr",uVar1,
param_2);
}
| |
23,649 | clip_model_loader::get_string(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>>&, bool) | llama.cpp/examples/llava/clip.cpp | void get_string(const std::string & key, std::string & output, bool required = true) {
const int i = gguf_find_key(ctx_gguf.get(), key.c_str());
if (i < 0) {
if (required) throw std::runtime_error("Key not found: " + key);
return;
}
output = std::string(gguf_get_val_str(ctx_gguf.get(), i));
} | O3 | cpp | clip_model_loader::get_string(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>>&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rsi), %rsi
callq 0x23840
testl %eax, %eax
js 0x4c1e6
movq 0x8(%r15), %rdi
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movq %rax, %rsi
callq 0x24ba0
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2bb54
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23ba0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c1eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x231f0
jmp 0x4c1eb
testb %bpl, %bpl
jne 0x4c1f6
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x23850
movq %rax, %rbx
leaq 0xecf60(%rip), %rsi # 0x13916a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2cedf
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23590
xorl %ebp, %ebp
movq 0x142d90(%rip), %rsi # 0x18efc0
movq 0x142d49(%rip), %rdx # 0x18ef80
movq %rbx, %rdi
callq 0x23e00
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c25d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x231f0
testb %bpl, %bpl
jne 0x4c267
jmp 0x4c26f
movq %rax, %r14
movq %rbx, %rdi
callq 0x24440
movq %r14, %rdi
callq 0x23ee0
nop
| _ZN17clip_model_loader10get_stringERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERS5_b:
push rbp
push r15
push r14
push rbx
sub rsp, 28h
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdi+8]
mov rsi, [rsi]
call _gguf_find_key
test eax, eax
js short loc_4C1E6
mov rdi, [r15+8]
and eax, 7FFFFFFFh
mov rsi, rax
call _gguf_get_val_str
lea r14, [rsp+48h+var_40]
lea rdx, [rsp+48h+var_41]
mov rdi, r14
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rdi, rbx
mov rsi, r14
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r14]; void *
lea rax, [rsp+48h+var_30]
cmp rdi, rax
jz short loc_4C1EB
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_4C1EB
loc_4C1E6:
test bpl, bpl
jnz short loc_4C1F6
loc_4C1EB:
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4C1F6:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aKeyNotFound; "Key not found: "
lea rdi, [rsp+48h+var_40]
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+48h+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:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+48h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4C25D
mov rsi, [rsp+48h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4C25D:
test bpl, bpl
jnz short loc_4C267
jmp short loc_4C26F
mov r14, rax
loc_4C267:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_4C26F:
mov rdi, r14
call __Unwind_Resume
| void clip_model_loader::get_string(long long a1, _QWORD *a2, long long a3, char a4)
{
int key; // eax
long long val_str; // rax
void *exception; // rbx
void *v9[2]; // [rsp+8h] [rbp-40h] BYREF
long long v10; // [rsp+18h] [rbp-30h] BYREF
key = gguf_find_key(*(_QWORD *)(a1 + 8), *a2);
if ( key < 0 )
{
if ( a4 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v9, (long long)"Key not found: ", a2);
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);
}
}
else
{
val_str = gguf_get_val_str(*(_QWORD *)(a1 + 8), key & 0x7FFFFFFF);
std::string::basic_string<std::allocator<char>>(v9, val_str);
std::string::operator=(a3, v9);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 1);
}
}
| get_string:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI]
CALL 0x00123840
TEST EAX,EAX
JS 0x0014c1e6
MOV RDI,qword ptr [R15 + 0x8]
AND EAX,0x7fffffff
MOV RSI,RAX
CALL 0x00124ba0
LEA R14,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
MOV RDI,R14
MOV RSI,RAX
CALL 0x0012bb54
MOV RDI,RBX
MOV RSI,R14
CALL 0x00123ba0
MOV RDI,qword ptr [R14]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x0014c1eb
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001231f0
JMP 0x0014c1eb
LAB_0014c1e6:
TEST BPL,BPL
JNZ 0x0014c1f6
LAB_0014c1eb:
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014c1f6:
MOV EDI,0x10
CALL 0x00123850
MOV RBX,RAX
LAB_0014c203:
LEA RSI,[0x23916a]
LEA RDI,[RSP + 0x8]
MOV RDX,R14
CALL 0x0012cedf
MOV BPL,0x1
LAB_0014c21a:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00123590
XOR EBP,EBP
MOV RSI,qword ptr [0x0028efc0]
MOV RDX,qword ptr [0x0028ef80]
MOV RDI,RBX
CALL 0x00123e00
|
/* clip_model_loader::get_string(std::__cxx11::string const&, std::__cxx11::string&, bool) */
void __thiscall
clip_model_loader::get_string(clip_model_loader *this,string *param_1,string *param_2,bool param_3)
{
uint uVar1;
char *pcVar2;
runtime_error *this_00;
allocator local_41;
long *local_40 [2];
long local_30 [2];
uVar1 = gguf_find_key(*(int8 *)(this + 8),*(int8 *)param_1);
if ((int)uVar1 < 0) {
if (param_3) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0014c203 to 0014c216 has its CatchHandler @ 0014c264 */
std::operator+((char *)local_40,(string *)"Key not found: ");
/* try { // try from 0014c21a to 0014c23e has its CatchHandler @ 0014c23f */
std::runtime_error::runtime_error(this_00,(string *)local_40);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0028efc0,PTR__runtime_error_0028ef80);
}
}
else {
pcVar2 = (char *)gguf_get_val_str(*(int8 *)(this + 8),uVar1 & 0x7fffffff);
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,pcVar2,&local_41);
std::__cxx11::string::operator=(param_2,(string *)local_40);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
}
return;
}
| |
23,650 | minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
Value result;
bool first = true;
for (const auto& part : parts) {
if (!part) throw std::runtime_error("FilterExpr.part is null");
if (first) {
first = false;
result = part->evaluate(context);
} else {
if (auto ce = dynamic_cast<CallExpr*>(part.get())) {
auto target = ce->object->evaluate(context);
ArgumentsValue args = ce->args.evaluate(context);
args.args.insert(args.args.begin(), result);
result = target.call(context, args);
} else {
auto callable = part->evaluate(context);
ArgumentsValue args;
args.args.insert(args.args.begin(), result);
result = callable.call(context, args);
}
}
}
return result;
} | O1 | cpp | minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %rbp
movq %rsi, %r15
leaq 0x40(%rdi), %r12
movq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rdi, (%rsp)
movb $0x0, 0x40(%rdi)
movq %r12, %rdi
movl $0x1, %esi
callq 0x3175a
movq %r12, %rdi
movl $0x1, %esi
callq 0x3175a
movq 0x20(%r15), %r13
movq 0x28(%r15), %rbx
cmpq %rbx, %r13
je 0x758d6
movb $0x1, %al
leaq 0x58(%rsp), %r15
leaq 0x20(%rsp), %r14
movq %rbp, 0x8(%rsp)
movq %rbx, 0x18(%rsp)
movq (%r13), %rdi
testq %rdi, %rdi
je 0x758ec
testb $0x1, %al
je 0x75697
movq (%r13), %rsi
movq %r15, %rdi
movq %rbp, %rdx
callq 0x66e66
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x6d3aa
leaq 0x98(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x3175a
movq %r12, %rdi
callq 0x36dc4
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x7564a
callq 0x31024
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x7565c
callq 0x31024
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x7566b
callq 0x31024
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x75804
movq 0x78918(%rip), %rax # 0xedf98
cmpb $0x0, (%rax)
je 0x757ef
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x757f9
movl %eax, 0x14(%rsp)
movq %r14, %r12
movq %r15, %rbx
leaq 0x76e58(%rip), %rsi # 0xec500
leaq 0x773b9(%rip), %rdx # 0xeca68
xorl %ecx, %ecx
callq 0x19790
testq %rax, %rax
je 0x7571a
movq %rax, %rbp
movq 0x20(%rax), %rsi
movq %rbx, %rdi
movq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x66e66
addq $0x30, %rbp
movq %r12, %r14
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x7253c
movq 0x20(%rsp), %rsi
movq %r14, %rdi
movq (%rsp), %rdx
callq 0x746f6
movq %r14, %rcx
leaq 0xa8(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x73876
movq (%rsp), %rdi
movq %r14, %rsi
jmp 0x75773
movq (%r13), %rsi
movq %rbx, %rbp
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
callq 0x66e66
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %r12, %r14
movq %r12, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x746f6
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
callq 0x73876
movq (%rsp), %rdi
movq %r15, %rsi
callq 0x6d3aa
leaq 0xe8(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3175a
movq %rbp, %rdi
callq 0x36dc4
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x757a4
callq 0x31024
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x757b6
callq 0x31024
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
movq %r12, %rbp
je 0x757cb
callq 0x31024
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x75820
movq 0x787b9(%rip), %rax # 0xedf98
cmpb $0x0, (%rax)
je 0x7580b
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x75815
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x75804
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
jmp 0x758c9
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x75820
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x38(%rsp), %rdi
callq 0x74be4
movq %rbp, %rdi
callq 0x6db3a
leaq 0x98(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3175a
movq %rbp, %rdi
callq 0x36dc4
movq 0x90(%rsp), %rdi
testq %rdi, %rdi
je 0x7585e
callq 0x31024
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
movq %rbx, %r15
movq 0x18(%rsp), %rbx
movq 0x8(%rsp), %rbp
je 0x7587d
callq 0x31024
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
movq %r12, %r14
je 0x7588f
callq 0x31024
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x758c5
movq 0x786f8(%rip), %rax # 0xedf98
cmpb $0x0, (%rax)
je 0x758b0
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x758ba
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x758c5
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x14(%rsp), %eax
addq $0x10, %r13
cmpq %rbx, %r13
jne 0x755ee
movq (%rsp), %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x19370
movq %rax, %r15
leaq 0x486bf(%rip), %rsi # 0xbdfbf
movq %rax, %rdi
callq 0x19280
movq 0x786e1(%rip), %rsi # 0xedff0
movq 0x7865a(%rip), %rdx # 0xedf70
movq %r15, %rdi
callq 0x19ba0
jmp 0x7592d
jmp 0x7592d
jmp 0x7595f
jmp 0x7592d
movq %rax, %r14
jmp 0x75944
jmp 0x7595f
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x74be4
leaq 0x20(%rsp), %rdi
callq 0x6db3a
leaq 0x58(%rsp), %rdi
callq 0x6715c
jmp 0x75962
jmp 0x7595f
movq %rax, %r14
movq %r15, %rdi
callq 0x19510
jmp 0x75962
movq %rax, %r14
movq (%rsp), %rdi
callq 0x6715c
movq %r14, %rdi
callq 0x19c00
nop
| _ZNK5minja10FilterExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov rbp, rdx
mov r15, rsi
lea r12, [rdi+40h]
mov qword ptr [rdi+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
mov [rsp+128h+var_128], rdi
mov byte ptr [rdi+40h], 0
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, [r15+20h]
mov rbx, [r15+28h]
cmp r13, rbx
jz loc_758D6
mov al, 1
lea r15, [rsp+128h+var_D0]
lea r14, [rsp+128h+var_108]
mov [rsp+128h+var_120], rbp
mov [rsp+128h+var_110], rbx
loc_755EE:
mov rdi, [r13+0]; lpsrc
test rdi, rdi
jz loc_758EC
test al, 1
jz loc_75697
mov rsi, [r13+0]
mov rdi, r15
mov rdx, rbp
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, [rsp+128h+var_128]
mov rsi, r15
call _ZN5minja5ValueaSEOS0_; minja::Value::operator=(minja::Value&&)
lea r12, [rsp+128h+var_90]
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+128h+var_98]
test rdi, rdi
jz short loc_7564A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7564A:
mov rdi, [rsp+128h+var_A8]
test rdi, rdi
jz short loc_7565C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7565C:
mov rdi, [rsp+128h+var_B8]
test rdi, rdi
jz short loc_7566B
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7566B:
mov rdi, [rsp+128h+var_C8]
test rdi, rdi
jz loc_75804
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz loc_757EF
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp loc_757F9
loc_75697:
mov [rsp+128h+var_114], eax
mov r12, r14
mov rbx, r15
lea rsi, _ZTIN5minja10ExpressionE; lpstype
lea rdx, _ZTIN5minja8CallExprE; lpdtype
xor ecx, ecx; s2d
call ___dynamic_cast
test rax, rax
jz short loc_7571A
mov rbp, rax
mov rsi, [rax+20h]
mov rdi, rbx
mov r15, [rsp+128h+var_120]
mov rdx, r15
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
add rbp, 30h ; '0'
mov r14, r12
mov rdi, r12
mov rsi, rbp
mov rdx, r15
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
mov rsi, qword ptr [rsp+128h+var_108]
mov rdi, r14
mov rdx, [rsp+128h+var_128]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
mov rcx, r14
lea r14, [rsp+128h+var_80]
mov rsi, rbx
mov rdi, r14
mov rdx, r15
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rdi, [rsp+128h+var_128]
mov rsi, r14
jmp short loc_75773
loc_7571A:
mov rsi, [r13+0]
mov rbp, rbx
mov rdi, rbx
mov rdx, [rsp+128h+var_120]
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
xorps xmm0, xmm0
movaps [rsp+128h+var_E8], xmm0
movaps [rsp+128h+var_F8], xmm0
movaps [rsp+128h+var_108], xmm0
mov r14, r12
mov rdi, r12
xor esi, esi
mov rdx, [rsp+128h+var_128]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
lea r15, [rsp+128h+var_80]
mov rdi, r15
mov rsi, rbp
mov rdx, [rsp+128h+var_120]
mov rcx, r14
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
mov rdi, [rsp+128h+var_128]
mov rsi, r15
loc_75773:
call _ZN5minja5ValueaSEOS0_; minja::Value::operator=(minja::Value&&)
lea rbp, [rsp+128h+var_40]
mov rdi, rbp
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+128h+var_48]
test rdi, rdi
jz short loc_757A4
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_757A4:
mov rdi, [rsp+128h+var_58]
test rdi, rdi
jz short loc_757B6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_757B6:
mov rdi, [rsp+128h+var_68]
test rdi, rdi
mov rbp, r12
jz short loc_757CB
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_757CB:
mov rdi, [rsp+128h+var_78]
test rdi, rdi
jz short loc_75820
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_7580B
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_75815
loc_757EF:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_757F9:
cmp eax, 1
jnz short loc_75804
mov rax, [rdi]
call qword ptr [rax+18h]
loc_75804:
xor eax, eax
jmp loc_758C9
loc_7580B:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_75815:
cmp eax, 1
jnz short loc_75820
mov rax, [rdi]
call qword ptr [rax+18h]
loc_75820:
lea rdi, [rsp+128h+var_F8+8]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
mov rdi, rbp
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
lea rbp, [rsp+128h+var_90]
mov rdi, rbp
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbp
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+128h+var_98]
test rdi, rdi
jz short loc_7585E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7585E:
mov rdi, [rsp+128h+var_A8]
test rdi, rdi
mov r15, rbx
mov rbx, [rsp+128h+var_110]
mov rbp, [rsp+128h+var_120]
jz short loc_7587D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7587D:
mov rdi, [rsp+128h+var_B8]
test rdi, rdi
mov r14, r12
jz short loc_7588F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7588F:
mov rdi, [rsp+128h+var_C8]
test rdi, rdi
jz short loc_758C5
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_758B0
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_758BA
loc_758B0:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_758BA:
cmp eax, 1
jnz short loc_758C5
mov rax, [rdi]
call qword ptr [rax+18h]
loc_758C5:
mov eax, [rsp+128h+var_114]
loc_758C9:
add r13, 10h
cmp r13, rbx
jnz loc_755EE
loc_758D6:
mov rax, [rsp+128h+var_128]
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_758EC:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aFilterexprPart; "FilterExpr.part is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_7592D
jmp short loc_7592D
jmp short loc_7595F
jmp short loc_7592D
mov r14, rax
jmp short loc_75944
jmp short loc_7595F
loc_7592D:
mov r14, rax
lea rdi, [rsp+128h+var_F8+8]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
lea rdi, [rsp+128h+var_108]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
loc_75944:
lea rdi, [rsp+128h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_75962
jmp short loc_7595F
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_75962
loc_7595F:
mov r14, rax
loc_75962:
mov rdi, [rsp+128h+var_128]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, r14
call __Unwind_Resume
| long long minja::FilterExpr::do_evaluate(long long a1, long long a2, long long a3)
{
int v3; // eax
void (****v5)(void); // r13
void (****v6)(void); // rbx
long long v7; // rdi
signed __int32 v8; // eax
void (****v9)(void); // rax
void (****v10)(void); // rbp
long long v11; // rdi
signed __int32 v12; // eax
long long v13; // rdi
signed __int32 v14; // eax
std::runtime_error *exception; // r15
long long v18; // [rsp+8h] [rbp-120h]
int v19; // [rsp+14h] [rbp-114h]
void (****v20)(void); // [rsp+18h] [rbp-110h]
_OWORD v21[3]; // [rsp+20h] [rbp-108h] BYREF
char v22[8]; // [rsp+58h] [rbp-D0h] BYREF
long long v23; // [rsp+60h] [rbp-C8h]
volatile signed __int32 *v24; // [rsp+70h] [rbp-B8h]
volatile signed __int32 *v25; // [rsp+80h] [rbp-A8h]
volatile signed __int32 *v26; // [rsp+90h] [rbp-98h]
char v27[16]; // [rsp+98h] [rbp-90h] BYREF
char v28[8]; // [rsp+A8h] [rbp-80h] BYREF
long long v29; // [rsp+B0h] [rbp-78h]
volatile signed __int32 *v30; // [rsp+C0h] [rbp-68h]
volatile signed __int32 *v31; // [rsp+D0h] [rbp-58h]
volatile signed __int32 *v32; // [rsp+E0h] [rbp-48h]
char v33[64]; // [rsp+E8h] [rbp-40h] BYREF
*(_QWORD *)(a1 + 72) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_BYTE *)(a1 + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
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 + 64));
v5 = *(void (*****)(void))(a2 + 32);
v6 = *(void (*****)(void))(a2 + 40);
if ( v5 != v6 )
{
LOBYTE(v3) = 1;
v18 = a3;
v20 = *(void (*****)(void))(a2 + 40);
do
{
if ( !*v5 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterExpr.part is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (v3 & 1) != 0 )
{
minja::Expression::evaluate((long long)v22, *v5);
minja::Value::operator=(a1, (long long)v22);
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(v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
if ( v26 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v26);
if ( v25 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v25);
if ( v24 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v24);
v7 = v23;
if ( v23 )
{
if ( _libc_single_threaded )
{
v8 = *(_DWORD *)(v23 + 12);
*(_DWORD *)(v23 + 12) = v8 - 1;
}
else
{
v8 = _InterlockedExchangeAdd((volatile signed __int32 *)(v23 + 12), 0xFFFFFFFF);
}
if ( v8 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v7 + 24LL))(v7, 0LL);
}
v3 = 0;
}
else
{
v19 = v3;
v9 = (void (****)(void))__dynamic_cast(
*v5,
(const struct __class_type_info *)&`typeinfo for'minja::Expression,
(const struct __class_type_info *)&`typeinfo for'minja::CallExpr,
0LL);
if ( v9 )
{
v10 = v9;
minja::Expression::evaluate((long long)v22, v9[4]);
minja::ArgumentsExpression::evaluate(v21, v10 + 6, v18);
std::vector<minja::Value>::insert((long long *)v21, *(long long *)&v21[0], (const minja::Value *)a1);
}
else
{
minja::Expression::evaluate((long long)v22, *v5);
memset(v21, 0, sizeof(v21));
std::vector<minja::Value>::insert((long long *)v21, 0LL, (const minja::Value *)a1);
}
minja::Value::call((long long)v28, (long long)v22);
minja::Value::operator=(a1, (long long)v28);
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(v33);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v33);
if ( v32 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v32);
if ( v31 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
v11 = v29;
if ( v29 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v29 + 12);
*(_DWORD *)(v29 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v29 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
std::vector<std::pair<std::string,minja::Value>>::~vector((long long *)&v21[1] + 1);
std::vector<minja::Value>::~vector(v21);
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(v27);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
if ( v26 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v26);
v6 = v20;
if ( v25 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v25);
if ( v24 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v24);
v13 = v23;
if ( v23 )
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v23 + 12);
*(_DWORD *)(v23 + 12) = v14 - 1;
}
else
{
v14 = _InterlockedExchangeAdd((volatile signed __int32 *)(v23 + 12), 0xFFFFFFFF);
}
if ( v14 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v13 + 24LL))(v13, 0LL);
}
v3 = v19;
}
v5 += 2;
}
while ( v5 != v6 );
}
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV RBP,RDX
MOV R15,RSI
LEA R12,[RDI + 0x40]
MOV qword ptr [RDI + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [RSP],RDI
MOV byte ptr [RDI + 0x40],0x0
MOV RDI,R12
MOV ESI,0x1
CALL 0x0013175a
MOV RDI,R12
MOV ESI,0x1
CALL 0x0013175a
MOV R13,qword ptr [R15 + 0x20]
MOV RBX,qword ptr [R15 + 0x28]
CMP R13,RBX
JZ 0x001758d6
MOV AL,0x1
LEA R15,[RSP + 0x58]
LEA R14,[RSP + 0x20]
MOV qword ptr [RSP + 0x8],RBP
MOV qword ptr [RSP + 0x18],RBX
LAB_001755ee:
MOV RDI,qword ptr [R13]
TEST RDI,RDI
JZ 0x001758ec
TEST AL,0x1
JZ 0x00175697
MOV RSI,qword ptr [R13]
LAB_00175607:
MOV RDI,R15
MOV RDX,RBP
CALL 0x00166e66
MOV RDI,qword ptr [RSP]
MOV RSI,R15
CALL 0x0016d3aa
LEA R12,[RSP + 0x98]
MOV RDI,R12
XOR ESI,ESI
CALL 0x0013175a
MOV RDI,R12
CALL 0x00136dc4
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
JZ 0x0017564a
CALL 0x00131024
LAB_0017564a:
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
JZ 0x0017565c
CALL 0x00131024
LAB_0017565c:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x0017566b
CALL 0x00131024
LAB_0017566b:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00175804
MOV RAX,qword ptr [0x001edf98]
CMP byte ptr [RAX],0x0
JZ 0x001757ef
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001757f9
LAB_00175697:
MOV dword ptr [RSP + 0x14],EAX
MOV R12,R14
MOV RBX,R15
LEA RSI,[0x1ec500]
LEA RDX,[0x1eca68]
XOR ECX,ECX
CALL 0x00119790
TEST RAX,RAX
JZ 0x0017571a
MOV RBP,RAX
MOV RSI,qword ptr [RAX + 0x20]
LAB_001756c2:
MOV RDI,RBX
MOV R15,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x00166e66
ADD RBP,0x30
LAB_001756d6:
MOV R14,R12
MOV RDI,R12
MOV RSI,RBP
MOV RDX,R15
CALL 0x0017253c
MOV RSI,qword ptr [RSP + 0x20]
LAB_001756ec:
MOV RDI,R14
MOV RDX,qword ptr [RSP]
CALL 0x001746f6
MOV RCX,R14
LEA R14,[RSP + 0xa8]
LAB_00175703:
MOV RSI,RBX
MOV RDI,R14
MOV RDX,R15
CALL 0x00173876
MOV RDI,qword ptr [RSP]
MOV RSI,R14
JMP 0x00175773
LAB_0017571a:
MOV RSI,qword ptr [R13]
LAB_0017571e:
MOV RBP,RBX
MOV RDI,RBX
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00166e66
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
LAB_00175740:
MOV R14,R12
MOV RDI,R12
XOR ESI,ESI
MOV RDX,qword ptr [RSP]
CALL 0x001746f6
LEA R15,[RSP + 0xa8]
LAB_00175759:
MOV RDI,R15
MOV RSI,RBP
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,R14
CALL 0x00173876
LAB_0017576c:
MOV RDI,qword ptr [RSP]
MOV RSI,R15
LAB_00175773:
CALL 0x0016d3aa
LEA RBP,[RSP + 0xe8]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0013175a
MOV RDI,RBP
CALL 0x00136dc4
MOV RDI,qword ptr [RSP + 0xe0]
TEST RDI,RDI
JZ 0x001757a4
CALL 0x00131024
LAB_001757a4:
MOV RDI,qword ptr [RSP + 0xd0]
TEST RDI,RDI
JZ 0x001757b6
CALL 0x00131024
LAB_001757b6:
MOV RDI,qword ptr [RSP + 0xc0]
TEST RDI,RDI
MOV RBP,R12
JZ 0x001757cb
CALL 0x00131024
LAB_001757cb:
MOV RDI,qword ptr [RSP + 0xb0]
TEST RDI,RDI
JZ 0x00175820
MOV RAX,qword ptr [0x001edf98]
CMP byte ptr [RAX],0x0
JZ 0x0017580b
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00175815
LAB_001757ef:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001757f9:
CMP EAX,0x1
JNZ 0x00175804
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00175804:
XOR EAX,EAX
JMP 0x001758c9
LAB_0017580b:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00175815:
CMP EAX,0x1
JNZ 0x00175820
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00175820:
LEA RDI,[RSP + 0x38]
CALL 0x00174be4
MOV RDI,RBP
CALL 0x0016db3a
LEA RBP,[RSP + 0x98]
MOV RDI,RBP
XOR ESI,ESI
CALL 0x0013175a
MOV RDI,RBP
CALL 0x00136dc4
MOV RDI,qword ptr [RSP + 0x90]
TEST RDI,RDI
JZ 0x0017585e
CALL 0x00131024
LAB_0017585e:
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
MOV R15,RBX
MOV RBX,qword ptr [RSP + 0x18]
MOV RBP,qword ptr [RSP + 0x8]
JZ 0x0017587d
CALL 0x00131024
LAB_0017587d:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
MOV R14,R12
JZ 0x0017588f
CALL 0x00131024
LAB_0017588f:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x001758c5
MOV RAX,qword ptr [0x001edf98]
CMP byte ptr [RAX],0x0
JZ 0x001758b0
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001758ba
LAB_001758b0:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001758ba:
CMP EAX,0x1
JNZ 0x001758c5
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001758c5:
MOV EAX,dword ptr [RSP + 0x14]
LAB_001758c9:
ADD R13,0x10
CMP R13,RBX
JNZ 0x001755ee
LAB_001758d6:
MOV RAX,qword ptr [RSP]
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001758ec:
MOV EDI,0x10
CALL 0x00119370
MOV R15,RAX
LAB_001758f9:
LEA RSI,[0x1bdfbf]
MOV RDI,RAX
CALL 0x00119280
LAB_00175908:
MOV RSI,qword ptr [0x001edff0]
MOV RDX,qword ptr [0x001edf70]
MOV RDI,R15
CALL 0x00119ba0
|
/* minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
FilterExpr * __thiscall minja::FilterExpr::do_evaluate(FilterExpr *this,shared_ptr *param_1)
{
int *piVar1;
long *plVar2;
int iVar3;
long lVar4;
runtime_error *this_00;
bool bVar5;
long *plVar6;
int8 local_108;
int8 uStack_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
Expression local_d0 [8];
long *local_c8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_a8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
data local_90 [16];
shared_ptr local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
bVar5 = (bool)((char)this + '@');
*(int8 *)(this + 0x48) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
this[0x40] = (FilterExpr)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar5);
plVar6 = *(long **)(param_1 + 0x20);
plVar2 = *(long **)(param_1 + 0x28);
if (plVar6 != plVar2) {
bVar5 = true;
do {
if (*plVar6 == 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001758f9 to 00175907 has its CatchHandler @ 00175952 */
std::runtime_error::runtime_error(this_00,"FilterExpr.part is null");
/* try { // try from 00175908 to 0017591d has its CatchHandler @ 00175950 */
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001edff0,PTR__runtime_error_001edf70);
}
if (bVar5) {
/* try { // try from 00175607 to 00175611 has its CatchHandler @ 0017595f */
Expression::evaluate(local_d0,(shared_ptr *)*plVar6);
Value::operator=((Value *)this,(Value *)local_d0);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001edf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
bVar5 = false;
}
else {
lVar4 = __dynamic_cast(*plVar6,&Expression::typeinfo,&CallExpr::typeinfo,0);
if (lVar4 == 0) {
/* try { // try from 0017571e to 0017572d has its CatchHandler @ 00175922 */
Expression::evaluate(local_d0,(shared_ptr *)*plVar6);
local_e8 = 0;
uStack_e0 = 0;
local_f8 = 0;
uStack_f0 = 0;
local_108 = 0;
uStack_100 = 0;
/* try { // try from 00175740 to 00175750 has its CatchHandler @ 00175920 */
std::vector<minja::Value,std::allocator<minja::Value>>::insert
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108,0,this);
/* try { // try from 00175759 to 0017576b has its CatchHandler @ 0017591e */
Value::call(local_80,(ArgumentsValue *)local_d0);
}
else {
/* try { // try from 001756c2 to 001756d1 has its CatchHandler @ 0017592b */
Expression::evaluate(local_d0,*(shared_ptr **)(lVar4 + 0x20));
/* try { // try from 001756d6 to 001756e6 has its CatchHandler @ 00175926 */
ArgumentsExpression::evaluate((shared_ptr *)&local_108);
/* try { // try from 001756ec to 001756f7 has its CatchHandler @ 00175924 */
std::vector<minja::Value,std::allocator<minja::Value>>::insert
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108,local_108,this)
;
/* try { // try from 00175703 to 00175710 has its CatchHandler @ 0017592d */
Value::call(local_80,(ArgumentsValue *)local_d0);
}
Value::operator=((Value *)this,(Value *)local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001edf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)&uStack_f0);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001edf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
}
plVar6 = plVar6 + 2;
} while (plVar6 != plVar2);
}
return this;
}
| |
23,651 | minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const | monkey531[P]llama/common/minja.hpp | Value do_evaluate(const std::shared_ptr<Context> & context) const override {
Value result;
bool first = true;
for (const auto& part : parts) {
if (!part) throw std::runtime_error("FilterExpr.part is null");
if (first) {
first = false;
result = part->evaluate(context);
} else {
if (auto ce = dynamic_cast<CallExpr*>(part.get())) {
auto target = ce->object->evaluate(context);
ArgumentsValue args = ce->args.evaluate(context);
args.args.insert(args.args.begin(), result);
result = target.call(context, args);
} else {
auto callable = part->evaluate(context);
ArgumentsValue args;
args.args.insert(args.args.begin(), result);
result = callable.call(context, args);
}
}
}
return result;
} | O3 | cpp | minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0x40(%rdi), %r12
movq $0x0, 0x48(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x40(%rdi)
movq %r12, %rdi
movl $0x1, %esi
callq 0x31156
movq %r12, %rdi
movl $0x1, %esi
callq 0x31156
movq 0x20(%r15), %r13
movq 0x28(%r15), %rax
movq %rax, 0x40(%rsp)
cmpq %rax, %r13
je 0x73e6c
movb $0x1, %al
leaq 0x48(%rsp), %rbp
leaq 0x98(%rsp), %rbx
movq (%r13), %r12
testq %r12, %r12
je 0x73e83
testb $0x1, %al
je 0x73c78
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x65552
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x6ba08
jmp 0x73ddb
movq %rbp, %r15
movq %r12, %rdi
leaq 0x7587b(%rip), %rsi # 0xe9500
leaq 0x75ddc(%rip), %rdx # 0xe9a68
xorl %ecx, %ecx
callq 0x19790
testq %rax, %rax
je 0x73ce9
movq %rax, %rbp
movq 0x20(%rax), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x65552
addq $0x30, %rbp
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x70b72
movq 0x10(%rsp), %rsi
movq %r12, %rdi
movq 0x8(%rsp), %rdx
callq 0x72dd2
movq %r15, %rbp
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x71ef2
jmp 0x73d31
movq %r15, %rbp
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x65552
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
movq 0x8(%rsp), %rdx
callq 0x72dd2
movq %rbx, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x71ef2
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6ba08
leaq 0xd8(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x31156
movq %r12, %rdi
callq 0x364a4
movq 0xd0(%rsp), %rdi
testq %rdi, %rdi
je 0x73d6a
callq 0x309ec
movq 0xc0(%rsp), %rdi
testq %rdi, %rdi
je 0x73d7c
callq 0x309ec
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x73d8e
callq 0x309ec
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x73dc7
movq 0x771f6(%rip), %rax # 0xeaf98
cmpb $0x0, (%rax)
je 0x73db2
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x73dbc
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x73dc7
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x7323a
leaq 0x10(%rsp), %rdi
callq 0x6c1a6
leaq 0x88(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x31156
movq %r12, %rdi
callq 0x364a4
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x73e07
callq 0x309ec
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x73e16
callq 0x309ec
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x73e25
callq 0x309ec
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x73e5b
movq 0x77162(%rip), %rax # 0xeaf98
cmpb $0x0, (%rax)
je 0x73e46
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x73e50
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x73e5b
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %r13
xorl %eax, %eax
cmpq 0x40(%rsp), %r13
jne 0x73c47
movq 0x8(%rsp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x19370
movq %rax, %r15
leaq 0x47118(%rip), %rsi # 0xbafaf
movq %rax, %rdi
callq 0x19280
movq 0x7714a(%rip), %rsi # 0xeaff0
movq 0x770c3(%rip), %rdx # 0xeaf70
movq %r15, %rdi
callq 0x19ba0
jmp 0x73ec4
jmp 0x73ec4
jmp 0x73ef6
jmp 0x73ec4
movq %rax, %r14
jmp 0x73edb
jmp 0x73ef6
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x7323a
leaq 0x10(%rsp), %rdi
callq 0x6c1a6
leaq 0x48(%rsp), %rdi
callq 0x65844
jmp 0x73ef9
jmp 0x73ef6
movq %rax, %r14
movq %r15, %rdi
callq 0x19510
jmp 0x73ef9
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x65844
movq %r14, %rdi
callq 0x19c00
nop
| _ZNK5minja10FilterExpr11do_evaluateERKSt10shared_ptrINS_7ContextEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov r14, rdx
mov r15, rsi
lea r12, [rdi+40h]
mov qword ptr [rdi+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+30h], xmm0
mov [rsp+118h+var_110], rdi
mov byte ptr [rdi+40h], 0
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r13, [r15+20h]
mov rax, [r15+28h]
mov [rsp+118h+var_D8], rax
cmp r13, rax
jz loc_73E6C
mov al, 1
lea rbp, [rsp+118h+var_D0]
lea rbx, [rsp+118h+var_80]
loc_73C47:
mov r12, [r13+0]
test r12, r12
jz loc_73E83
test al, 1
jz short loc_73C78
mov rdi, rbp
mov rsi, r12
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
mov rdi, [rsp+118h+var_110]
mov rsi, rbp
call _ZN5minja5ValueaSEOS0_; minja::Value::operator=(minja::Value&&)
jmp loc_73DDB
loc_73C78:
mov r15, rbp
mov rdi, r12; lpsrc
lea rsi, _ZTIN5minja10ExpressionE; lpstype
lea rdx, _ZTIN5minja8CallExprE; lpdtype
xor ecx, ecx; s2d
call ___dynamic_cast
test rax, rax
jz short loc_73CE9
mov rbp, rax
mov rsi, [rax+20h]
mov rdi, r15
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
add rbp, 30h ; '0'
lea r12, [rsp+118h+var_108]
mov rdi, r12
mov rsi, rbp
mov rdx, r14
call _ZNK5minja19ArgumentsExpression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::ArgumentsExpression::evaluate(std::shared_ptr<minja::Context> const&)
mov rsi, qword ptr [rsp+118h+var_108]
mov rdi, r12
mov rdx, [rsp+118h+var_110]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
mov rbp, r15
mov rdi, rbx
mov rsi, r15
mov rdx, r14
mov rcx, r12
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
jmp short loc_73D31
loc_73CE9:
mov rbp, r15
mov rdi, r15
mov rsi, r12
mov rdx, r14
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
xorps xmm0, xmm0
movaps [rsp+118h+var_E8], xmm0
movaps [rsp+118h+var_F8], xmm0
movaps [rsp+118h+var_108], xmm0
lea r12, [rsp+118h+var_108]
mov rdi, r12
xor esi, esi
mov rdx, [rsp+118h+var_110]
call _ZNSt6vectorIN5minja5ValueESaIS1_EE6insertEN9__gnu_cxx17__normal_iteratorIPKS1_S3_EERS6_; std::vector<minja::Value>::insert(__gnu_cxx::__normal_iterator<minja::Value const*,std::vector<minja::Value>>,minja::Value const&)
mov rdi, rbx
mov rsi, rbp
mov rdx, r14
mov rcx, r12
call _ZNK5minja5Value4callERKSt10shared_ptrINS_7ContextEERNS_14ArgumentsValueE; minja::Value::call(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)
loc_73D31:
mov rdi, [rsp+118h+var_110]
mov rsi, rbx
call _ZN5minja5ValueaSEOS0_; minja::Value::operator=(minja::Value&&)
lea r12, [rsp+118h+var_40]
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+118h+var_48]
test rdi, rdi
jz short loc_73D6A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73D6A:
mov rdi, [rsp+118h+var_58]
test rdi, rdi
jz short loc_73D7C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73D7C:
mov rdi, [rsp+118h+var_68]
test rdi, rdi
jz short loc_73D8E
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73D8E:
mov rdi, [rsp+118h+var_78]
test rdi, rdi
jz short loc_73DC7
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_73DB2
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_73DBC
loc_73DB2:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_73DBC:
cmp eax, 1
jnz short loc_73DC7
mov rax, [rdi]
call qword ptr [rax+18h]
loc_73DC7:
lea rdi, [rsp+118h+var_F8+8]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
lea rdi, [rsp+118h+var_108]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
loc_73DDB:
lea r12, [rsp+118h+var_90]
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+118h+var_98]
test rdi, rdi
jz short loc_73E07
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73E07:
mov rdi, [rsp+118h+var_A8]
test rdi, rdi
jz short loc_73E16
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73E16:
mov rdi, [rsp+118h+var_B8]
test rdi, rdi
jz short loc_73E25
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_73E25:
mov rdi, [rsp+118h+var_C8]
test rdi, rdi
jz short loc_73E5B
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_73E46
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_73E50
loc_73E46:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_73E50:
cmp eax, 1
jnz short loc_73E5B
mov rax, [rdi]
call qword ptr [rax+18h]
loc_73E5B:
add r13, 10h
xor eax, eax
cmp r13, [rsp+118h+var_D8]
jnz loc_73C47
loc_73E6C:
mov rax, [rsp+118h+var_110]
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_73E83:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aFilterexprPart; "FilterExpr.part is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_73EC4
jmp short loc_73EC4
jmp short loc_73EF6
jmp short loc_73EC4
mov r14, rax
jmp short loc_73EDB
jmp short loc_73EF6
loc_73EC4:
mov r14, rax
lea rdi, [rsp+118h+var_F8+8]
call _ZNSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN5minja5ValueEESaIS9_EED2Ev; std::vector<std::pair<std::string,minja::Value>>::~vector()
lea rdi, [rsp+118h+var_108]
call _ZNSt6vectorIN5minja5ValueESaIS1_EED2Ev; std::vector<minja::Value>::~vector()
loc_73EDB:
lea rdi, [rsp+118h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_73EF9
jmp short loc_73EF6
mov r14, rax
mov rdi, r15; void *
call ___cxa_free_exception
jmp short loc_73EF9
loc_73EF6:
mov r14, rax
loc_73EF9:
mov rdi, [rsp+118h+var_110]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rdi, r14
call __Unwind_Resume
| long long minja::FilterExpr::do_evaluate(long long a1, long long a2, long long a3)
{
void (****v4)(void); // r13
char v5; // al
char *v6; // rbp
void (***v7)(void); // r12
long long v8; // r15
void (****v9)(void); // rax
void (****v10)(void); // rbp
long long v11; // rdi
signed __int32 v12; // eax
long long v13; // rdi
signed __int32 v14; // eax
std::runtime_error *exception; // r15
_OWORD v18[3]; // [rsp+10h] [rbp-108h] BYREF
void (****v19)(void); // [rsp+40h] [rbp-D8h]
char v20; // [rsp+48h] [rbp-D0h] BYREF
long long v21; // [rsp+50h] [rbp-C8h]
volatile signed __int32 *v22; // [rsp+60h] [rbp-B8h]
volatile signed __int32 *v23; // [rsp+70h] [rbp-A8h]
volatile signed __int32 *v24; // [rsp+80h] [rbp-98h]
char v25[16]; // [rsp+88h] [rbp-90h] BYREF
_BYTE v26[8]; // [rsp+98h] [rbp-80h] BYREF
long long v27; // [rsp+A0h] [rbp-78h]
volatile signed __int32 *v28; // [rsp+B0h] [rbp-68h]
volatile signed __int32 *v29; // [rsp+C0h] [rbp-58h]
volatile signed __int32 *v30; // [rsp+D0h] [rbp-48h]
char v31[64]; // [rsp+D8h] [rbp-40h] BYREF
*(_QWORD *)(a1 + 72) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_BYTE *)(a1 + 64) = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)(a1 + 64));
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 + 64));
v4 = *(void (*****)(void))(a2 + 32);
v19 = *(void (*****)(void))(a2 + 40);
if ( v4 != v19 )
{
v5 = 1;
v6 = &v20;
do
{
v7 = *v4;
if ( !*v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "FilterExpr.part is null");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( (v5 & 1) != 0 )
{
minja::Expression::evaluate((long long)v6, *v4);
minja::Value::operator=(a1, (long long)v6);
}
else
{
v8 = (long long)v6;
v9 = (void (****)(void))__dynamic_cast(
*v4,
(const struct __class_type_info *)&`typeinfo for'minja::Expression,
(const struct __class_type_info *)&`typeinfo for'minja::CallExpr,
0LL);
if ( v9 )
{
v10 = v9;
minja::Expression::evaluate(v8, v9[4]);
minja::ArgumentsExpression::evaluate(v18, v10 + 6, a3);
std::vector<minja::Value>::insert((long long *)v18, *(long long *)&v18[0], (const minja::Value *)a1);
v6 = (char *)v8;
}
else
{
minja::Expression::evaluate((long long)v6, v7);
memset(v18, 0, sizeof(v18));
std::vector<minja::Value>::insert((long long *)v18, 0LL, (const minja::Value *)a1);
}
minja::Value::call((long long)v26, v8);
minja::Value::operator=(a1, (long long)v26);
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(v31);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v31);
if ( v30 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v30);
if ( v29 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v29);
if ( v28 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v28);
v11 = v27;
if ( v27 )
{
if ( _libc_single_threaded )
{
v12 = *(_DWORD *)(v27 + 12);
*(_DWORD *)(v27 + 12) = v12 - 1;
}
else
{
v12 = _InterlockedExchangeAdd((volatile signed __int32 *)(v27 + 12), 0xFFFFFFFF);
}
if ( v12 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v11 + 24LL))(v11, 0LL);
}
std::vector<std::pair<std::string,minja::Value>>::~vector((char **)&v18[1] + 1);
std::vector<minja::Value>::~vector(v18);
}
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(v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v25);
if ( v24 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v24);
if ( v23 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v23);
if ( v22 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v22);
v13 = v21;
if ( v21 )
{
if ( _libc_single_threaded )
{
v14 = *(_DWORD *)(v21 + 12);
*(_DWORD *)(v21 + 12) = v14 - 1;
}
else
{
v14 = _InterlockedExchangeAdd((volatile signed __int32 *)(v21 + 12), 0xFFFFFFFF);
}
if ( v14 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v13 + 24LL))(v13, 0LL);
}
v4 += 2;
v5 = 0;
}
while ( v4 != v19 );
}
return a1;
}
| do_evaluate:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R14,RDX
MOV R15,RSI
LEA R12,[RDI + 0x40]
MOV qword ptr [RDI + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOV qword ptr [RSP + 0x8],RDI
MOV byte ptr [RDI + 0x40],0x0
MOV RDI,R12
MOV ESI,0x1
CALL 0x00131156
MOV RDI,R12
MOV ESI,0x1
CALL 0x00131156
MOV R13,qword ptr [R15 + 0x20]
MOV RAX,qword ptr [R15 + 0x28]
MOV qword ptr [RSP + 0x40],RAX
CMP R13,RAX
JZ 0x00173e6c
MOV AL,0x1
LEA RBP,[RSP + 0x48]
LEA RBX,[RSP + 0x98]
LAB_00173c47:
MOV R12,qword ptr [R13]
TEST R12,R12
JZ 0x00173e83
TEST AL,0x1
JZ 0x00173c78
LAB_00173c58:
MOV RDI,RBP
MOV RSI,R12
MOV RDX,R14
CALL 0x00165552
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
CALL 0x0016ba08
JMP 0x00173ddb
LAB_00173c78:
MOV R15,RBP
MOV RDI,R12
LEA RSI,[0x1e9500]
LEA RDX,[0x1e9a68]
XOR ECX,ECX
CALL 0x00119790
TEST RAX,RAX
JZ 0x00173ce9
MOV RBP,RAX
MOV RSI,qword ptr [RAX + 0x20]
LAB_00173c9f:
MOV RDI,R15
MOV RDX,R14
CALL 0x00165552
ADD RBP,0x30
LAB_00173cae:
LEA R12,[RSP + 0x10]
MOV RDI,R12
MOV RSI,RBP
MOV RDX,R14
CALL 0x00170b72
MOV RSI,qword ptr [RSP + 0x10]
LAB_00173cc6:
MOV RDI,R12
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00172dd2
LAB_00173cd3:
MOV RBP,R15
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
CALL 0x00171ef2
JMP 0x00173d31
LAB_00173ce9:
MOV RBP,R15
MOV RDI,R15
MOV RSI,R12
MOV RDX,R14
CALL 0x00165552
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_00173d0c:
LEA R12,[RSP + 0x10]
MOV RDI,R12
XOR ESI,ESI
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x00172dd2
LAB_00173d20:
MOV RDI,RBX
MOV RSI,RBP
MOV RDX,R14
MOV RCX,R12
CALL 0x00171ef2
LAB_00173d31:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBX
CALL 0x0016ba08
LEA R12,[RSP + 0xd8]
MOV RDI,R12
XOR ESI,ESI
CALL 0x00131156
MOV RDI,R12
CALL 0x001364a4
MOV RDI,qword ptr [RSP + 0xd0]
TEST RDI,RDI
JZ 0x00173d6a
CALL 0x001309ec
LAB_00173d6a:
MOV RDI,qword ptr [RSP + 0xc0]
TEST RDI,RDI
JZ 0x00173d7c
CALL 0x001309ec
LAB_00173d7c:
MOV RDI,qword ptr [RSP + 0xb0]
TEST RDI,RDI
JZ 0x00173d8e
CALL 0x001309ec
LAB_00173d8e:
MOV RDI,qword ptr [RSP + 0xa0]
TEST RDI,RDI
JZ 0x00173dc7
MOV RAX,qword ptr [0x001eaf98]
CMP byte ptr [RAX],0x0
JZ 0x00173db2
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00173dbc
LAB_00173db2:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00173dbc:
CMP EAX,0x1
JNZ 0x00173dc7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00173dc7:
LEA RDI,[RSP + 0x28]
CALL 0x0017323a
LEA RDI,[RSP + 0x10]
CALL 0x0016c1a6
LAB_00173ddb:
LEA R12,[RSP + 0x88]
MOV RDI,R12
XOR ESI,ESI
CALL 0x00131156
MOV RDI,R12
CALL 0x001364a4
MOV RDI,qword ptr [RSP + 0x80]
TEST RDI,RDI
JZ 0x00173e07
CALL 0x001309ec
LAB_00173e07:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x00173e16
CALL 0x001309ec
LAB_00173e16:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x00173e25
CALL 0x001309ec
LAB_00173e25:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x00173e5b
MOV RAX,qword ptr [0x001eaf98]
CMP byte ptr [RAX],0x0
JZ 0x00173e46
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x00173e50
LAB_00173e46:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_00173e50:
CMP EAX,0x1
JNZ 0x00173e5b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_00173e5b:
ADD R13,0x10
XOR EAX,EAX
CMP R13,qword ptr [RSP + 0x40]
JNZ 0x00173c47
LAB_00173e6c:
MOV RAX,qword ptr [RSP + 0x8]
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00173e83:
MOV EDI,0x10
CALL 0x00119370
MOV R15,RAX
LAB_00173e90:
LEA RSI,[0x1bafaf]
MOV RDI,RAX
CALL 0x00119280
LAB_00173e9f:
MOV RSI,qword ptr [0x001eaff0]
MOV RDX,qword ptr [0x001eaf70]
MOV RDI,R15
CALL 0x00119ba0
|
/* minja::FilterExpr::do_evaluate(std::shared_ptr<minja::Context> const&) const */
FilterExpr * __thiscall minja::FilterExpr::do_evaluate(FilterExpr *this,shared_ptr *param_1)
{
int *piVar1;
shared_ptr *psVar2;
int iVar3;
long lVar4;
runtime_error *this_00;
bool bVar5;
int8 *puVar6;
int8 local_108;
int8 uStack_100;
int8 local_f8;
int8 uStack_f0;
int8 local_e8;
int8 uStack_e0;
int8 *local_d8;
Expression local_d0 [8];
long *local_c8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_b8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_a8;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_98;
data local_90 [16];
shared_ptr local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
bVar5 = (bool)((char)this + '@');
*(int8 *)(this + 0x48) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
this[0x40] = (FilterExpr)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar5);
puVar6 = *(int8 **)(param_1 + 0x20);
local_d8 = *(int8 **)(param_1 + 0x28);
if (puVar6 != local_d8) {
bVar5 = true;
do {
psVar2 = (shared_ptr *)*puVar6;
if (psVar2 == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00173e90 to 00173e9e has its CatchHandler @ 00173ee9 */
std::runtime_error::runtime_error(this_00,"FilterExpr.part is null");
/* try { // try from 00173e9f to 00173eb4 has its CatchHandler @ 00173ee7 */
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001eaff0,PTR__runtime_error_001eaf70);
}
if (bVar5) {
/* try { // try from 00173c58 to 00173c65 has its CatchHandler @ 00173ef6 */
Expression::evaluate(local_d0,psVar2);
Value::operator=((Value *)this,(Value *)local_d0);
}
else {
lVar4 = __dynamic_cast(psVar2,&Expression::typeinfo,&CallExpr::typeinfo,0);
if (lVar4 == 0) {
/* try { // try from 00173ce9 to 00173cf9 has its CatchHandler @ 00173eb9 */
Expression::evaluate(local_d0,psVar2);
local_e8 = 0;
uStack_e0 = 0;
local_f8 = 0;
uStack_f0 = 0;
local_108 = 0;
uStack_100 = 0;
/* try { // try from 00173d0c to 00173d1f has its CatchHandler @ 00173eb7 */
std::vector<minja::Value,std::allocator<minja::Value>>::insert
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108,0,this);
/* try { // try from 00173d20 to 00173d30 has its CatchHandler @ 00173eb5 */
Value::call(local_80,(ArgumentsValue *)local_d0);
}
else {
/* try { // try from 00173c9f to 00173ca9 has its CatchHandler @ 00173ec2 */
Expression::evaluate(local_d0,*(shared_ptr **)(lVar4 + 0x20));
/* try { // try from 00173cae to 00173cc0 has its CatchHandler @ 00173ebd */
ArgumentsExpression::evaluate((shared_ptr *)&local_108);
/* try { // try from 00173cc6 to 00173cd2 has its CatchHandler @ 00173ebb */
std::vector<minja::Value,std::allocator<minja::Value>>::insert
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108,local_108,this)
;
/* try { // try from 00173cd3 to 00173ce6 has its CatchHandler @ 00173ec4 */
Value::call(local_80,(ArgumentsValue *)local_d0);
}
Value::operator=((Value *)this,(Value *)local_80);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_001eaf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
std::
vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
::~vector((vector<std::pair<std::__cxx11::string,minja::Value>,std::allocator<std::pair<std::__cxx11::string,minja::Value>>>
*)&uStack_f0);
std::vector<minja::Value,std::allocator<minja::Value>>::~vector
((vector<minja::Value,std::allocator<minja::Value>> *)&local_108);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_90,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_90);
if (local_98 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_98);
}
if (local_a8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_a8);
}
if (local_b8 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_b8);
}
if (local_c8 != (long *)0x0) {
if (*PTR___libc_single_threaded_001eaf98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_c8 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_c8 + 0xc);
*(int *)((long)local_c8 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_c8 + 0x18))();
}
}
puVar6 = puVar6 + 2;
bVar5 = false;
} while (puVar6 != local_d8);
}
return this;
}
| |
23,652 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char*, int, unsigned long, unsigned long, unsigned long, unsigned long) | monkey531[P]llama/common/json.hpp | inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
std::uint64_t rest, std::uint64_t ten_k)
{
JSON_ASSERT(len >= 1);
JSON_ASSERT(dist <= delta);
JSON_ASSERT(rest <= delta);
JSON_ASSERT(ten_k > 0);
// <--------------------------- delta ---->
// <---- dist --------->
// --------------[------------------+-------------------]--------------
// M- w M+
//
// ten_k
// <------>
// <---- rest ---->
// --------------[------------------+----+--------------]--------------
// w V
// = buf * 10^k
//
// ten_k represents a unit-in-the-last-place in the decimal representation
// stored in buf.
// Decrement buf by ten_k while this takes buf closer to w.
// The tests are written in this order to avoid overflow in unsigned
// integer arithmetic.
while (rest < dist
&& delta - rest >= ten_k
&& (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
{
JSON_ASSERT(buf[len - 1] != '0');
buf[len - 1]--;
rest += ten_k;
}
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char*, int, unsigned long, unsigned long, unsigned long, unsigned long):
pushq %rax
testl %esi, %esi
jle 0x81964
cmpq %rcx, %rdx
ja 0x81980
movq %rcx, %r10
subq %r8, %r10
jb 0x8199c
testq %r9, %r9
je 0x819b8
movq %rdx, %rax
subq %r8, %rax
setbe %r11b
cmpq %r9, %r10
setb %r10b
orb %r11b, %r10b
jne 0x81941
movl %esi, %esi
addq %r9, %r8
subq %r8, %rcx
movq %rdx, %r10
negq %r10
cmpq %rdx, %r8
jb 0x81917
leaq (%r10,%r8), %r11
cmpq %r11, %rax
jbe 0x81941
movb -0x1(%rdi,%rsi), %r11b
cmpb $0x30, %r11b
je 0x81943
decb %r11b
movb %r11b, -0x1(%rdi,%rsi)
subq %r9, %rcx
setb %r11b
cmpq %rdx, %r8
jae 0x81941
subq %r9, %rax
addq %r9, %r8
testb %r11b, %r11b
je 0x81909
popq %rax
retq
leaq 0x2fb44(%rip), %rdi # 0xb148e
leaq 0x2e318(%rip), %rdx # 0xafc69
leaq 0x32920(%rip), %rcx # 0xb4278
movl $0x444d, %esi # imm = 0x444D
xorl %eax, %eax
callq 0x19b50
leaq 0x2fb23(%rip), %rdi # 0xb148e
leaq 0x2e2f7(%rip), %rdx # 0xafc69
leaq 0x328d0(%rip), %rcx # 0xb4249
movl $0x4431, %esi # imm = 0x4431
jmp 0x8195d
leaq 0x2fb07(%rip), %rdi # 0xb148e
leaq 0x2e2db(%rip), %rdx # 0xafc69
leaq 0x328bd(%rip), %rcx # 0xb4252
movl $0x4432, %esi # imm = 0x4432
jmp 0x8195d
leaq 0x2faeb(%rip), %rdi # 0xb148e
leaq 0x2e2bf(%rip), %rdx # 0xafc69
leaq 0x328af(%rip), %rcx # 0xb4260
movl $0x4433, %esi # imm = 0x4433
jmp 0x8195d
leaq 0x2facf(%rip), %rdi # 0xb148e
leaq 0x2e2a3(%rip), %rdx # 0xafc69
leaq 0x328a1(%rip), %rcx # 0xb426e
movl $0x4434, %esi # imm = 0x4434
jmp 0x8195d
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl12grisu2_roundEPcimmmm:
push rax
test esi, esi
jle loc_81964
cmp rdx, rcx
ja loc_81980
mov r10, rcx
sub r10, r8
jb loc_8199C
test r9, r9
jz loc_819B8
mov rax, rdx
sub rax, r8
setbe r11b
cmp r10, r9
setb r10b
or r10b, r11b
jnz short loc_81941
mov esi, esi
add r8, r9
sub rcx, r8
mov r10, rdx
neg r10
loc_81909:
cmp r8, rdx
jb short loc_81917
lea r11, [r10+r8]
cmp rax, r11
jbe short loc_81941
loc_81917:
mov r11b, [rdi+rsi-1]
cmp r11b, 30h ; '0'
jz short loc_81943
dec r11b
mov [rdi+rsi-1], r11b
sub rcx, r9
setb r11b
cmp r8, rdx
jnb short loc_81941
sub rax, r9
add r8, r9
test r11b, r11b
jz short loc_81909
loc_81941:
pop rax
retn
loc_81943:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aBufLen10; "buf[len - 1] != '0'"
mov esi, 444Dh
loc_8195D:
xor eax, eax
call _ggml_abort
loc_81964:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aLen1; "len >= 1"
mov esi, 4431h
jmp short loc_8195D
loc_81980:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDistDelta; "dist <= delta"
mov esi, 4432h
jmp short loc_8195D
loc_8199C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRestDelta; "rest <= delta"
mov esi, 4433h
jmp short loc_8195D
loc_819B8:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTenK0; "ten_k > 0"
mov esi, 4434h
jmp short loc_8195D
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
char *a2,
unsigned long long a3,
unsigned long long a4,
unsigned long long a5,
unsigned long long a6)
{
unsigned long long v6; // rax
unsigned long long v7; // r8
unsigned long long v8; // rcx
char v9; // r11
bool v10; // cf
if ( (int)a2 <= 0 )
goto LABEL_14;
if ( a3 > a4 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17458LL,
"GGML_ASSERT(%s) failed",
"dist <= delta");
goto LABEL_14;
}
if ( a4 < a5 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17459LL,
"GGML_ASSERT(%s) failed",
"rest <= delta");
goto LABEL_14;
}
if ( !a6 )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17460LL,
"GGML_ASSERT(%s) failed",
"ten_k > 0");
goto LABEL_14;
}
v6 = a3 - a5;
if ( a3 > a5 && a4 - a5 >= a6 )
{
v7 = a6 + a5;
v8 = a4 - v7;
while ( 1 )
{
if ( v7 >= a3 && v6 <= v7 - a3 )
return;
v9 = *((_BYTE *)this + (unsigned int)a2 - 1);
if ( v9 == 48 )
break;
*((_BYTE *)this + (unsigned int)a2 - 1) = v9 - 1;
v10 = v8 < a6;
v8 -= a6;
if ( v7 < a3 )
{
v6 -= a6;
v7 += a6;
if ( !v10 )
continue;
}
return;
}
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17485LL,
"GGML_ASSERT(%s) failed",
"buf[len - 1] != '0'");
while ( 1 )
LABEL_14:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
17457LL,
"GGML_ASSERT(%s) failed",
"len >= 1");
}
}
| grisu2_round:
PUSH RAX
TEST ESI,ESI
JLE 0x00181964
CMP RDX,RCX
JA 0x00181980
MOV R10,RCX
SUB R10,R8
JC 0x0018199c
TEST R9,R9
JZ 0x001819b8
MOV RAX,RDX
SUB RAX,R8
SETBE R11B
CMP R10,R9
SETC R10B
OR R10B,R11B
JNZ 0x00181941
MOV ESI,ESI
ADD R8,R9
SUB RCX,R8
MOV R10,RDX
NEG R10
LAB_00181909:
CMP R8,RDX
JC 0x00181917
LEA R11,[R10 + R8*0x1]
CMP RAX,R11
JBE 0x00181941
LAB_00181917:
MOV R11B,byte ptr [RDI + RSI*0x1 + -0x1]
CMP R11B,0x30
JZ 0x00181943
DEC R11B
MOV byte ptr [RDI + RSI*0x1 + -0x1],R11B
SUB RCX,R9
SETC R11B
CMP R8,RDX
JNC 0x00181941
SUB RAX,R9
ADD R8,R9
TEST R11B,R11B
JZ 0x00181909
LAB_00181941:
POP RAX
RET
LAB_00181943:
LEA RDI,[0x1b148e]
LEA RDX,[0x1afc69]
LEA RCX,[0x1b4278]
MOV ESI,0x444d
LAB_0018195d:
XOR EAX,EAX
CALL 0x00119b50
LAB_00181964:
LEA RDI,[0x1b148e]
LEA RDX,[0x1afc69]
LEA RCX,[0x1b4249]
MOV ESI,0x4431
JMP 0x0018195d
LAB_00181980:
LEA RDI,[0x1b148e]
LEA RDX,[0x1afc69]
LEA RCX,[0x1b4252]
MOV ESI,0x4432
JMP 0x0018195d
LAB_0018199c:
LEA RDI,[0x1b148e]
LEA RDX,[0x1afc69]
LEA RCX,[0x1b4260]
MOV ESI,0x4433
JMP 0x0018195d
LAB_001819b8:
LEA RDI,[0x1b148e]
LEA RDX,[0x1afc69]
LEA RCX,[0x1b426e]
MOV ESI,0x4434
JMP 0x0018195d
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round(char*, int, unsigned long, unsigned
long, unsigned long, unsigned long) */
int8
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::grisu2_round
(char *param_1,int param_2,ulong param_3,ulong param_4,ulong param_5,ulong param_6)
{
int8 in_RAX;
ulong uVar1;
ulong uVar2;
char *pcVar3;
int8 uVar4;
ulong uVar5;
bool bVar6;
if (param_2 < 1) {
pcVar3 = "len >= 1";
uVar4 = 0x4431;
}
else if (param_4 < param_3) {
pcVar3 = "dist <= delta";
uVar4 = 0x4432;
}
else if (param_4 < param_5) {
pcVar3 = "rest <= delta";
uVar4 = 0x4433;
}
else {
if (param_6 != 0) {
uVar1 = param_3 - param_5;
if (param_6 <= param_4 - param_5 && (param_5 <= param_3 && uVar1 != 0)) {
uVar5 = param_5 + param_6;
uVar2 = param_4 - uVar5;
do {
if ((param_3 <= uVar5) && (uVar1 <= uVar5 - param_3)) {
return in_RAX;
}
if (param_1[(ulong)(uint)param_2 - 1] == '0') {
pcVar3 = "buf[len - 1] != \'0\'";
uVar4 = 0x444d;
goto LAB_0018195d;
}
param_1[(ulong)(uint)param_2 - 1] = param_1[(ulong)(uint)param_2 - 1] + -1;
bVar6 = param_6 <= uVar2;
uVar2 = uVar2 - param_6;
if (param_3 <= uVar5) {
return in_RAX;
}
uVar1 = uVar1 - param_6;
uVar5 = uVar5 + param_6;
} while (bVar6);
}
return in_RAX;
}
pcVar3 = "ten_k > 0";
uVar4 = 0x4434;
}
LAB_0018195d:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar4,
"GGML_ASSERT(%s) failed",pcVar3);
}
| |
23,653 | my_casedn_8bit | eloqsql/strings/ctype-simple.c | size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O0 | c | my_casedn_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x538a2
jmp 0x538a4
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x538db
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x538a4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casedn_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_38], rax
jmp short $+2
loc_538A2:
jmp short $+2
loc_538A4:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jz short loc_538DB
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_538A4
loc_538DB:
mov rax, [rbp+var_18]
pop rbp
retn
| long long my_casedn_8bit(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4)
{
_BYTE *v4; // rax
long long v6; // [rsp+0h] [rbp-38h]
unsigned __int8 *v8; // [rsp+28h] [rbp-10h]
v8 = a2;
v6 = *(_QWORD *)(a1 + 72);
while ( v8 != &a2[a3] )
{
v4 = a4++;
*v4 = *(_BYTE *)(v6 + *v8++);
}
return a3;
}
| my_casedn_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x001538a2
LAB_001538a2:
JMP 0x001538a4
LAB_001538a4:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x001538db
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001538a4
LAB_001538db:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long my_casedn_8bit(long param_1,byte *param_2,long param_3,int1 *param_4)
{
long lVar1;
int1 *local_28;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_28 = param_4;
for (local_18 = param_2; local_18 != param_2 + param_3; local_18 = local_18 + 1) {
*local_28 = *(int1 *)(lVar1 + (ulong)*local_18);
local_28 = local_28 + 1;
}
return param_3;
}
| |
23,654 | my_casedn_8bit | eloqsql/strings/ctype-simple.c | size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_casedn_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0x3eeac
pushq %rbp
movq %rsp, %rbp
movq 0x48(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0x3ee96
popq %rbp
retq
| my_casedn_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_3EEAC
push rbp
mov rbp, rsp
mov rdx, [rdi+48h]
xor edi, edi
loc_3EE96:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_3EE96
pop rbp
locret_3EEAC:
retn
| long long my_casedn_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 72);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_casedn_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x0013eeac
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x48]
XOR EDI,EDI
LAB_0013ee96:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x0013ee96
POP RBP
LAB_0013eeac:
RET
|
void my_casedn_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x48);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
| |
23,655 | nglog::InstallFailureSignalHandler() | ng-log[P]ng-log/src/signalhandler.cc | void InstallFailureSignalHandler() {
#ifdef HAVE_SIGACTION
// Build the sigaction struct.
struct sigaction sig_action;
memset(&sig_action, 0, sizeof(sig_action));
sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags |= SA_SIGINFO;
sig_action.sa_sigaction = &FailureSignalHandler;
for (auto kFailureSignal : kFailureSignals) {
CHECK_ERR(sigaction(kFailureSignal.number, &sig_action, nullptr));
}
kFailureSignalHandlerInstalled = true;
#elif defined(NGLOG_OS_WINDOWS)
for (size_t i = 0; i < ARRAYSIZE(kFailureSignals); ++i) {
CHECK_NE(signal(kFailureSignals[i].number, &FailureSignalHandler), SIG_ERR);
}
kFailureSignalHandlerInstalled = true;
#endif // HAVE_SIGACTION
} | O0 | cpp | nglog::InstallFailureSignalHandler():
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp # imm = 0x180
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x93a0
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x9910
movl -0x10(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x10(%rbp)
leaq -0x7e(%rip), %rax # 0x4a250
movq %rax, -0x98(%rbp)
leaq 0x289b4(%rip), %rax # 0x72c90
movq %rax, -0xa0(%rbp)
leaq 0x289a6(%rip), %rax # 0x72c90
movq %rax, -0xa8(%rbp)
leaq 0x28998(%rip), %rax # 0x72c90
addq $0x60, %rax
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rax
cmpq -0xb0(%rbp), %rax
je 0x4a453
movq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0xc0(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0xb8(%rbp)
movl -0xc0(%rbp), %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x9920
movb $0x0, -0x139(%rbp)
cmpl $-0x1, %eax
je 0x4a35a
jmp 0x4a3f4
leaq -0x39781(%rip), %rax # 0x10be0
movq %rax, -0x138(%rbp)
movq $0x0, -0x130(%rbp)
movups -0x138(%rbp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq 0x6d6c(%rip), %rsi # 0x510f3
xorl %eax, %eax
movl %eax, %r8d
leaq -0x128(%rbp), %rdi
movq %rdi, -0x160(%rbp)
movl $0x18b, %edx # imm = 0x18B
movl $0x3, %ecx
callq 0x12410
movq -0x160(%rbp), %rdi
movb $0x1, -0x139(%rbp)
callq 0x11060
movq %rax, -0x158(%rbp)
jmp 0x4a3c5
movq -0x158(%rbp), %rdi
leaq 0x6d6d(%rip), %rsi # 0x51140
callq 0x96f0
movq %rax, -0x168(%rbp)
jmp 0x4a3e1
movq -0x168(%rbp), %rsi
leaq -0xc1(%rbp), %rdi
callq 0x1a870
testb $0x1, -0x139(%rbp)
jne 0x4a3ff
jmp 0x4a40b
leaq -0x128(%rbp), %rdi
callq 0x124a0
jmp 0x4a40d
movq -0xa8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa8(%rbp)
jmp 0x4a303
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x148(%rbp)
movl %eax, -0x14c(%rbp)
testb $0x1, -0x139(%rbp)
jne 0x4a441
jmp 0x4a451
leaq -0x128(%rbp), %rdi
callq 0x124a0
jmp 0x4a44f
jmp 0x4a451
jmp 0x4a463
movb $0x1, 0x3a8a2(%rip) # 0x84cfc
addq $0x180, %rsp # imm = 0x180
popq %rbp
retq
movq -0x148(%rbp), %rdi
callq 0x9cf0
movq %rax, %rdi
callq 0xcbc0
nopw (%rax,%rax)
| _ZN5nglog27InstallFailureSignalHandlerEv:
push rbp
mov rbp, rsp
sub rsp, 180h
lea rdi, [rbp+var_98]
xor esi, esi
mov edx, 98h
call _memset
lea rdi, [rbp+var_98]
add rdi, 8
call _sigemptyset
mov eax, [rbp+var_10]
or eax, 4
mov [rbp+var_10], eax
lea rax, _ZN5nglog12_GLOBAL__N_120FailureSignalHandlerEiP9siginfo_tPv; nglog::`anonymous namespace'::FailureSignalHandler(int,siginfo_t *,void *)
mov [rbp+var_98], rax
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
mov [rbp+var_A0], rax
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
mov [rbp+var_A8], rax
lea rax, _ZN5nglog12_GLOBAL__N_115kFailureSignalsE; nglog::`anonymous namespace'::kFailureSignals
add rax, 60h ; '`'
mov [rbp+var_B0], rax
loc_4A303:
mov rax, [rbp+var_A8]
cmp rax, [rbp+var_B0]
jz loc_4A453
mov rax, [rbp+var_A8]
mov rcx, [rax]
mov [rbp+var_C0], rcx
mov rax, [rax+8]
mov [rbp+var_B8], rax
mov edi, dword ptr [rbp+var_C0]
lea rsi, [rbp+var_98]
xor eax, eax
mov edx, eax
call _sigaction
mov [rbp+var_139], 0
cmp eax, 0FFFFFFFFh
jz short loc_4A35A
jmp loc_4A3F4
loc_4A35A:
lea rax, _ZN5nglog10LogMessage9SendToLogEv; nglog::LogMessage::SendToLog(void)
mov qword ptr [rbp+var_138], rax
mov qword ptr [rbp+var_138+8], 0
movups xmm0, [rbp+var_138]
mov rax, rsp
movups xmmword ptr [rax], xmm0
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
xor eax, eax
mov r8d, eax
lea rdi, [rbp+var_128]
mov [rbp+var_160], rdi
mov edx, 18Bh
mov ecx, 3
call _ZN5nglog15ErrnoLogMessageC2EPKciNS_11LogSeverityElMNS_10LogMessageEFvvE; nglog::ErrnoLogMessage::ErrnoLogMessage(char const*,int,nglog::LogSeverity,long,void (nglog::LogMessage::*)(void))
mov rdi, [rbp+var_160]; this
mov [rbp+var_139], 1
call _ZN5nglog10LogMessage6streamEv; nglog::LogMessage::stream(void)
mov [rbp+var_158], rax
jmp short $+2
loc_4A3C5:
mov rdi, [rbp+var_158]
lea rsi, aSigactionKfail; "sigaction(kFailureSignal.number, &sig_a"...
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
mov [rbp+var_168], rax
jmp short $+2
loc_4A3E1:
mov rsi, [rbp+var_168]
lea rdi, [rbp+var_C1]
call _ZNK5nglog8internal17LogMessageVoidifyanERSo; nglog::internal::LogMessageVoidify::operator&(std::ostream &)
loc_4A3F4:
test [rbp+var_139], 1
jnz short loc_4A3FF
jmp short loc_4A40B
loc_4A3FF:
lea rdi, [rbp+var_128]; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
loc_4A40B:
jmp short $+2
loc_4A40D:
mov rax, [rbp+var_A8]
add rax, 10h
mov [rbp+var_A8], rax
jmp loc_4A303
mov rcx, rax
mov eax, edx
mov [rbp+var_148], rcx
mov [rbp+var_14C], eax
test [rbp+var_139], 1
jnz short loc_4A441
jmp short loc_4A451
loc_4A441:
lea rdi, [rbp+var_128]; this
call _ZN5nglog15ErrnoLogMessageD2Ev; nglog::ErrnoLogMessage::~ErrnoLogMessage()
jmp short $+2
loc_4A44F:
jmp short $+2
loc_4A451:
jmp short loc_4A463
loc_4A453:
mov cs:_ZN5nglog12_GLOBAL__N_130kFailureSignalHandlerInstalledE, 1; nglog::`anonymous namespace'::kFailureSignalHandlerInstalled
add rsp, 180h
pop rbp
retn
loc_4A463:
mov rdi, [rbp+var_148]
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| char * nglog::InstallFailureSignalHandler(nglog *this)
{
char *result; // rax
long long v2; // r9
long long v3; // [rsp+28h] [rbp-158h]
char v4; // [rsp+47h] [rbp-139h]
_QWORD v5[12]; // [rsp+58h] [rbp-128h] BYREF
long long v6; // [rsp+C0h] [rbp-C0h]
long long v7; // [rsp+C8h] [rbp-B8h]
char *v8; // [rsp+D0h] [rbp-B0h]
char *v9; // [rsp+D8h] [rbp-A8h]
void *v10; // [rsp+E0h] [rbp-A0h]
long long ( *v11)(int, long long, long long); // [rsp+E8h] [rbp-98h] BYREF
long long v12; // [rsp+F0h] [rbp-90h] BYREF
int v13; // [rsp+170h] [rbp-10h]
memset(&v11, 0LL, 152LL);
sigemptyset(&v12);
v13 |= 4u;
v11 = nglog::`anonymous namespace'::FailureSignalHandler;
v10 = &nglog::`anonymous namespace'::kFailureSignals;
v9 = (char *)&nglog::`anonymous namespace'::kFailureSignals;
v8 = (char *)&nglog::`anonymous namespace'::kFailureSignals + 96;
while ( 1 )
{
result = v9;
if ( v9 == v8 )
break;
v6 = *(_QWORD *)v9;
v7 = *((_QWORD *)v9 + 1);
v4 = 0;
if ( (unsigned int)sigaction((unsigned int)v6, &v11, 0LL) == -1 )
{
nglog::ErrnoLogMessage::ErrnoLogMessage(
v5,
(long long)"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
0x18Bu,
3u,
0LL,
v2,
(long long)nglog::LogMessage::SendToLog,
0LL);
v4 = 1;
v3 = nglog::LogMessage::stream((nglog::LogMessage *)v5);
std::operator<<<std::char_traits<char>>(v3, "sigaction(kFailureSignal.number, &sig_action, nullptr)");
nglog::internal::LogMessageVoidify::operator&();
}
if ( (v4 & 1) != 0 )
nglog::ErrnoLogMessage::~ErrnoLogMessage((nglog::ErrnoLogMessage *)v5);
v9 += 16;
}
nglog::`anonymous namespace'::kFailureSignalHandlerInstalled = 1;
return result;
}
| InstallFailureSignalHandler:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x180
LEA RDI,[RBP + -0x98]
XOR ESI,ESI
MOV EDX,0x98
CALL 0x001093a0
LEA RDI,[RBP + -0x98]
ADD RDI,0x8
CALL 0x00109910
MOV EAX,dword ptr [RBP + -0x10]
OR EAX,0x4
MOV dword ptr [RBP + -0x10],EAX
LEA RAX,[0x14a250]
MOV qword ptr [RBP + -0x98],RAX
LEA RAX,[0x172c90]
MOV qword ptr [RBP + -0xa0],RAX
LEA RAX,[0x172c90]
MOV qword ptr [RBP + -0xa8],RAX
LEA RAX,[0x172c90]
ADD RAX,0x60
MOV qword ptr [RBP + -0xb0],RAX
LAB_0014a303:
MOV RAX,qword ptr [RBP + -0xa8]
CMP RAX,qword ptr [RBP + -0xb0]
JZ 0x0014a453
MOV RAX,qword ptr [RBP + -0xa8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBP + -0xc0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0xb8],RAX
MOV EDI,dword ptr [RBP + -0xc0]
LEA RSI,[RBP + -0x98]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00109920
MOV byte ptr [RBP + -0x139],0x0
CMP EAX,-0x1
JZ 0x0014a35a
JMP 0x0014a3f4
LAB_0014a35a:
LEA RAX,[0x110be0]
MOV qword ptr [RBP + -0x138],RAX
MOV qword ptr [RBP + -0x130],0x0
MOVUPS XMM0,xmmword ptr [RBP + -0x138]
MOV RAX,RSP
MOVUPS xmmword ptr [RAX],XMM0
LEA RSI,[0x1510f3]
XOR EAX,EAX
MOV R8D,EAX
LEA RDI,[RBP + -0x128]
MOV qword ptr [RBP + -0x160],RDI
MOV EDX,0x18b
MOV ECX,0x3
CALL 0x00112410
MOV RDI,qword ptr [RBP + -0x160]
MOV byte ptr [RBP + -0x139],0x1
LAB_0014a3b7:
CALL 0x00111060
MOV qword ptr [RBP + -0x158],RAX
JMP 0x0014a3c5
LAB_0014a3c5:
MOV RDI,qword ptr [RBP + -0x158]
LEA RSI,[0x151140]
CALL 0x001096f0
LAB_0014a3d8:
MOV qword ptr [RBP + -0x168],RAX
JMP 0x0014a3e1
LAB_0014a3e1:
MOV RSI,qword ptr [RBP + -0x168]
LEA RDI,[RBP + -0xc1]
CALL 0x0011a870
LAB_0014a3f4:
TEST byte ptr [RBP + -0x139],0x1
JNZ 0x0014a3ff
JMP 0x0014a40b
LAB_0014a3ff:
LEA RDI,[RBP + -0x128]
CALL 0x001124a0
LAB_0014a40b:
JMP 0x0014a40d
LAB_0014a40d:
MOV RAX,qword ptr [RBP + -0xa8]
ADD RAX,0x10
MOV qword ptr [RBP + -0xa8],RAX
JMP 0x0014a303
LAB_0014a453:
MOV byte ptr [0x00184cfc],0x1
ADD RSP,0x180
POP RBP
RET
|
/* nglog::InstallFailureSignalHandler() */
void nglog::InstallFailureSignalHandler(void)
{
int iVar1;
ostream *poVar2;
int8 in_R9;
ErrnoLogMessage local_130 [103];
LogMessageVoidify local_c9;
Elf64_DynTag local_c8;
qword local_c0;
Elf64_Dyn *local_b8;
Elf64_Dyn *local_b0;
int8 *local_a8;
sigaction local_a0;
memset(&local_a0,0,0x98);
sigemptyset(&local_a0.sa_mask);
local_a0.sa_flags = local_a0.sa_flags | 4;
local_a0.__sigaction_handler.sa_handler = (anonymous_namespace)::FailureSignalHandler;
local_a8 = &(anonymous_namespace)::kFailureSignals;
local_b8 = _DYNAMIC;
for (local_b0 = (Elf64_Dyn *)&(anonymous_namespace)::kFailureSignals; local_b0 != local_b8;
local_b0 = local_b0 + 1) {
local_c8 = local_b0->d_tag;
local_c0 = local_b0->d_val;
iVar1 = sigaction((int4)local_c8,&local_a0,(sigaction *)0x0);
if (iVar1 == -1) {
ErrnoLogMessage::ErrnoLogMessage
(local_130,
"/workspace/llm4binary/github/2025_star3/ng-log[P]ng-log/src/signalhandler.cc",
0x18b,3,0,in_R9,0x110be0,0);
/* try { // try from 0014a3b7 to 0014a3d7 has its CatchHandler @ 0014a424 */
poVar2 = (ostream *)LogMessage::stream((LogMessage *)local_130);
poVar2 = std::operator<<(poVar2,"sigaction(kFailureSignal.number, &sig_action, nullptr)");
internal::LogMessageVoidify::operator&(&local_c9,poVar2);
ErrnoLogMessage::~ErrnoLogMessage(local_130);
}
}
(anonymous_namespace)::kFailureSignalHandlerInstalled = 1;
return;
}
| |
23,656 | my_mb_wc_utf8mb4_quick | eloqsql/strings/ctype-utf8.h | static inline int
my_mb_wc_utf8mb4_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0x80)
{
*pwc= c;
return 1;
}
else if (c < 0xc2)
return MY_CS_ILSEQ;
else if (c < 0xe0)
{
if (s + 2 > e) /* We need 2 characters */
return MY_CS_TOOSMALL2;
if (!(IS_CONTINUATION_BYTE(s[1])))
return MY_CS_ILSEQ;
*pwc= UTF8MB2_CODE(c, s[1]);
return 2;
}
else if (c < 0xf0)
{
if (s + 3 > e) /* We need 3 characters */
return MY_CS_TOOSMALL3;
if (!IS_UTF8MB3_STEP2(c, s[1], s[2]))
return MY_CS_ILSEQ;
*pwc= UTF8MB3_CODE(c, s[1], s[2]);
return 3;
}
else if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
*pwc= UTF8MB4_CODE(c, s[1], s[2], s[3]);
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_utf8mb4_quick:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0xd1eac
movzbl (%rsi), %ecx
testb %cl, %cl
js 0xd1ea5
movl $0x1, %eax
movq %rcx, (%rdi)
jmp 0xd1eac
cmpb $-0x3e, %cl
jae 0xd1eae
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %cl
ja 0xd1ee4
leaq 0x2(%rsi), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %r8
ja 0xd1eac
movzbl 0x1(%rsi), %edx
xorl $0x80, %edx
movl $0x0, %eax
cmpb $0x3f, %dl
ja 0xd1eac
andl $0x1f, %ecx
shll $0x6, %ecx
orl %edx, %ecx
movl $0x2, %eax
jmp 0xd1ea0
cmpb $-0x11, %cl
ja 0xd1f46
leaq 0x3(%rsi), %r8
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %r8
ja 0xd1eac
movzbl 0x1(%rsi), %edx
cmpb $-0x41, %dl
jg 0xd1eaa
movzbl 0x2(%rsi), %esi
cmpb $-0x41, %sil
jg 0xd1eaa
cmpl $0xe0, %ecx
sete %r8b
cmpb $-0x60, %dl
setb %r9b
movl $0x0, %eax
testb %r9b, %r8b
jne 0xd1eac
shll $0xc, %ecx
movzwl %cx, %eax
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x3, %eax
movq %rsi, %rcx
jmp 0xd1ea0
cmpb $-0xc, %cl
ja 0xd1eaa
leaq 0x4(%rsi), %r8
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %r8
ja 0xd1eac
movzbl 0x1(%rsi), %r8d
cmpb $-0x41, %r8b
jg 0xd1eaa
movzbl 0x2(%rsi), %edx
cmpb $-0x41, %dl
jg 0xd1eaa
movzbl 0x3(%rsi), %esi
cmpb $-0x41, %sil
jg 0xd1eaa
cmpl $0xf0, %ecx
sete %al
cmpb $-0x70, %r8b
setb %r9b
testb %r9b, %al
jne 0xd1eaa
cmpl $0xf4, %ecx
sete %r9b
cmpb $-0x70, %r8b
setae %r10b
movl $0x0, %eax
testb %r10b, %r9b
jne 0xd1eac
andl $0x7, %ecx
shll $0x12, %ecx
andl $0x3f, %r8d
shll $0xc, %r8d
orl %ecx, %r8d
andl $0x3f, %edx
shll $0x6, %edx
orl %r8d, %edx
andl $0x3f, %esi
orq %rdx, %rsi
movl $0x4, %eax
jmp 0xd1f3e
| my_mb_wc_utf8mb4_quick_0:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb short loc_D1EAC
movzx ecx, byte ptr [rsi]
test cl, cl
js short loc_D1EA5
mov eax, 1
loc_D1EA0:
mov [rdi], rcx
jmp short loc_D1EAC
loc_D1EA5:
cmp cl, 0C2h
jnb short loc_D1EAE
loc_D1EAA:
xor eax, eax
loc_D1EAC:
pop rbp
retn
loc_D1EAE:
cmp cl, 0DFh
ja short loc_D1EE4
lea r8, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp r8, rdx
ja short loc_D1EAC
movzx edx, byte ptr [rsi+1]
xor edx, 80h
mov eax, 0
cmp dl, 3Fh ; '?'
ja short loc_D1EAC
and ecx, 1Fh
shl ecx, 6
or ecx, edx
mov eax, 2
jmp short loc_D1EA0
loc_D1EE4:
cmp cl, 0EFh
ja short loc_D1F46
lea r8, [rsi+3]
mov eax, 0FFFFFF99h
cmp r8, rdx
ja short loc_D1EAC
movzx edx, byte ptr [rsi+1]
cmp dl, 0BFh
jg short loc_D1EAA
movzx esi, byte ptr [rsi+2]
cmp sil, 0BFh
jg short loc_D1EAA
cmp ecx, 0E0h
setz r8b
cmp dl, 0A0h
setb r9b
mov eax, 0
test r8b, r9b
jnz short loc_D1EAC
shl ecx, 0Ch
movzx eax, cx
and edx, 3Fh
shl edx, 6
or edx, eax
and esi, 3Fh
or rsi, rdx
mov eax, 3
loc_D1F3E:
mov rcx, rsi
jmp loc_D1EA0
loc_D1F46:
cmp cl, 0F4h
ja loc_D1EAA
lea r8, [rsi+4]
mov eax, 0FFFFFF98h
cmp r8, rdx
ja loc_D1EAC
movzx r8d, byte ptr [rsi+1]
cmp r8b, 0BFh
jg loc_D1EAA
movzx edx, byte ptr [rsi+2]
cmp dl, 0BFh
jg loc_D1EAA
movzx esi, byte ptr [rsi+3]
cmp sil, 0BFh
jg loc_D1EAA
cmp ecx, 0F0h
setz al
cmp r8b, 90h
setb r9b
test al, r9b
jnz loc_D1EAA
cmp ecx, 0F4h
setz r9b
cmp r8b, 90h
setnb r10b
mov eax, 0
test r9b, r10b
jnz loc_D1EAC
and ecx, 7
shl ecx, 12h
and r8d, 3Fh
shl r8d, 0Ch
or r8d, ecx
and edx, 3Fh
shl edx, 6
or edx, r8d
and esi, 3Fh
or rsi, rdx
mov eax, 4
jmp loc_D1F3E
| long long my_mb_wc_utf8mb4_quick_0(unsigned long long *a1, unsigned __int8 *a2, unsigned long long a3)
{
long long result; // rax
unsigned long long v4; // rcx
char v5; // dl
char v6; // si
unsigned long long v7; // rsi
char v8; // r8
char v9; // dl
char v10; // si
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (v4 & 0x80u) == 0LL )
{
result = 1LL;
LABEL_4:
*a1 = v4;
return result;
}
if ( (unsigned __int8)v4 < 0xC2u )
return 0LL;
if ( (unsigned __int8)v4 > 0xDFu )
{
if ( (unsigned __int8)v4 > 0xEFu )
{
if ( (unsigned __int8)v4 <= 0xF4u )
{
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v8 = a2[1];
if ( v8 <= -65 )
{
v9 = a2[2];
if ( v9 <= -65 )
{
v10 = a2[3];
if ( v10 <= -65 && ((unsigned __int8)v8 >= 0x90u || (_DWORD)v4 != 240) )
{
result = 0LL;
if ( (unsigned __int8)v8 >= 0x90u && (_DWORD)v4 == 244 )
return result;
v7 = ((v4 & 7) << 18) | ((unsigned __int8)(v8 & 0x3F) << 12) | ((unsigned __int8)(v9 & 0x3F) << 6) | v10 & 0x3F;
result = 4LL;
LABEL_18:
v4 = v7;
goto LABEL_4;
}
}
}
}
}
else
{
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v5 = a2[1];
if ( v5 <= -65 )
{
v6 = a2[2];
if ( v6 <= -65 )
{
result = 0LL;
if ( (unsigned __int8)v5 < 0xA0u && (_DWORD)v4 == 224 )
return result;
v7 = (unsigned __int16)((_WORD)v4 << 12) | ((unsigned __int8)(v5 & 0x3F) << 6) | (unsigned long long)(v6 & 0x3F);
result = 3LL;
goto LABEL_18;
}
}
}
return 0LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
{
result = 0LL;
if ( (a2[1] ^ 0x80u) <= 0x3F )
{
v4 = a2[1] ^ 0x80 | ((unsigned __int8)(v4 & 0x1F) << 6);
result = 2LL;
goto LABEL_4;
}
}
return result;
}
| my_mb_wc_utf8mb4_quick:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001d1eac
MOVZX ECX,byte ptr [RSI]
TEST CL,CL
JS 0x001d1ea5
MOV EAX,0x1
LAB_001d1ea0:
MOV qword ptr [RDI],RCX
JMP 0x001d1eac
LAB_001d1ea5:
CMP CL,0xc2
JNC 0x001d1eae
LAB_001d1eaa:
XOR EAX,EAX
LAB_001d1eac:
POP RBP
RET
LAB_001d1eae:
CMP CL,0xdf
JA 0x001d1ee4
LEA R8,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP R8,RDX
JA 0x001d1eac
MOVZX EDX,byte ptr [RSI + 0x1]
XOR EDX,0x80
MOV EAX,0x0
CMP DL,0x3f
JA 0x001d1eac
AND ECX,0x1f
SHL ECX,0x6
OR ECX,EDX
MOV EAX,0x2
JMP 0x001d1ea0
LAB_001d1ee4:
CMP CL,0xef
JA 0x001d1f46
LEA R8,[RSI + 0x3]
MOV EAX,0xffffff99
CMP R8,RDX
JA 0x001d1eac
MOVZX EDX,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001d1eaa
MOVZX ESI,byte ptr [RSI + 0x2]
CMP SIL,0xbf
JG 0x001d1eaa
CMP ECX,0xe0
SETZ R8B
CMP DL,0xa0
SETC R9B
MOV EAX,0x0
TEST R8B,R9B
JNZ 0x001d1eac
SHL ECX,0xc
MOVZX EAX,CX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,EAX
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x3
LAB_001d1f3e:
MOV RCX,RSI
JMP 0x001d1ea0
LAB_001d1f46:
CMP CL,0xf4
JA 0x001d1eaa
LEA R8,[RSI + 0x4]
MOV EAX,0xffffff98
CMP R8,RDX
JA 0x001d1eac
MOVZX R8D,byte ptr [RSI + 0x1]
CMP R8B,0xbf
JG 0x001d1eaa
MOVZX EDX,byte ptr [RSI + 0x2]
CMP DL,0xbf
JG 0x001d1eaa
MOVZX ESI,byte ptr [RSI + 0x3]
CMP SIL,0xbf
JG 0x001d1eaa
CMP ECX,0xf0
SETZ AL
CMP R8B,0x90
SETC R9B
TEST AL,R9B
JNZ 0x001d1eaa
CMP ECX,0xf4
SETZ R9B
CMP R8B,0x90
SETNC R10B
MOV EAX,0x0
TEST R9B,R10B
JNZ 0x001d1eac
AND ECX,0x7
SHL ECX,0x12
AND R8D,0x3f
SHL R8D,0xc
OR R8D,ECX
AND EDX,0x3f
SHL EDX,0x6
OR EDX,R8D
AND ESI,0x3f
OR RSI,RDX
MOV EAX,0x4
JMP 0x001d1f3e
|
int8 my_mb_wc_utf8mb4_quick(ulong *param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
ulong uVar5;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
uVar5 = (ulong)bVar1;
if ((char)bVar1 < '\0') {
if (0xc1 < bVar1) {
uVar4 = (uint)bVar1;
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
if (0x3f < (byte)(param_2[1] ^ 0x80)) {
return 0;
}
uVar5 = (ulong)((uVar4 & 0x1f) << 6 | param_2[1] ^ 0x80);
uVar3 = 2;
goto LAB_001d1ea0;
}
if (bVar1 < 0xf0) {
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
bVar2 = param_2[1];
if (((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) {
if (uVar4 == 0xe0 && bVar2 < 0xa0) {
return 0;
}
uVar4 = param_2[2] & 0x3f | (bVar2 & 0x3f) << 6 | (bVar1 & 0xf) << 0xc;
uVar3 = 3;
LAB_001d1f3e:
uVar5 = (ulong)uVar4;
goto LAB_001d1ea0;
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar1 = param_2[1];
if (((((char)bVar1 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) &&
(uVar4 != 0xf0 || 0x8f < bVar1)) {
if (uVar4 == 0xf4 && 0x8f < bVar1) {
return 0;
}
uVar4 = param_2[3] & 0x3f |
(param_2[2] & 0x3f) << 6 | (bVar1 & 0x3f) << 0xc | (uVar4 & 7) << 0x12;
uVar3 = 4;
goto LAB_001d1f3e;
}
}
}
uVar3 = 0;
}
else {
uVar3 = 1;
LAB_001d1ea0:
*param_1 = uVar5;
}
return uVar3;
}
| |
23,657 | minja::Parser::parseLogicalOr() | monkey531[P]llama/common/./minja.hpp | std::shared_ptr<Expression> parseLogicalOr() {
auto left = parseLogicalAnd();
if (!left) throw std::runtime_error("Expected left side of 'logical or' expression");
static std::regex or_tok(R"(or\b)");
auto location = get_location();
while (!consumeToken(or_tok).empty()) {
auto right = parseLogicalAnd();
if (!right) throw std::runtime_error("Expected right side of 'or' expression");
left = std::make_shared<BinaryOpExpr>(location, std::move(left), std::move(right), BinaryOpExpr::Op::Or);
}
return left;
} | O0 | cpp | minja::Parser::parseLogicalOr():
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x9d6f0
movq 0x28(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x9d068
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x12f773(%rip), %rsi # 0x1cc77b
callq 0x50340
jmp 0x9d00f
movq 0x10(%rsp), %rdi
movq 0x1b6f95(%rip), %rsi # 0x253fb0
movq 0x1b6f56(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9d2a1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x50c40
jmp 0x9d28a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d28a
cmpb $0x0, 0x1b7ed1(%rip) # 0x254f40
jne 0x9d0c2
leaq 0x1b7ec8(%rip), %rdi # 0x254f40
callq 0x504b0
cmpl $0x0, %eax
je 0x9d0c2
leaq 0x1b7e97(%rip), %rdi # 0x254f20
leaq 0x12f719(%rip), %rsi # 0x1cc7a9
movl $0x10, %edx
callq 0x76c30
jmp 0x9d09c
leaq -0x263c3(%rip), %rdi # 0x76ce0
leaq 0x1b7e76(%rip), %rsi # 0x254f20
leaq 0x1b77b7(%rip), %rdx # 0x254868
callq 0x50c20
leaq 0x1b7e83(%rip), %rdi # 0x254f40
callq 0x50820
movq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x76db0
jmp 0x9d0d3
jmp 0x9d0d5
movq 0x20(%rsp), %rsi
leaq 0x1b7e3f(%rip), %rdx # 0x254f20
leaq 0x58(%rsp), %rdi
movl $0x1, %ecx
callq 0x778a0
jmp 0x9d0f2
leaq 0x58(%rsp), %rdi
callq 0x503b0
xorb $-0x1, %al
movb %al, 0xf(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x510c0
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x9d119
jmp 0x9d249
movq 0x20(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x9d6f0
jmp 0x9d12a
leaq 0x48(%rsp), %rdi
callq 0x77a80
testb $0x1, %al
jne 0x9d1ed
movl $0x10, %edi
callq 0x50540
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x12f657(%rip), %rsi # 0x1cc7ae
callq 0x50340
jmp 0x9d15e
movq (%rsp), %rdi
movq 0x1b6e47(%rip), %rsi # 0x253fb0
movq 0x1b6e08(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0x9d2a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x1b7dab(%rip), %rdi # 0x254f40
callq 0x505d0
jmp 0x9d28a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d267
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x50c40
jmp 0x9d23d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9d23d
movq 0x28(%rsp), %rdx
movl $0xf, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x48(%rsp), %rcx
leaq 0x34(%rsp), %r8
callq 0x9da00
jmp 0x9d215
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9daa0
leaq 0x38(%rsp), %rdi
callq 0x9dad0
leaq 0x48(%rsp), %rdi
callq 0x77890
jmp 0x9d0d5
leaq 0x48(%rsp), %rdi
callq 0x77890
jmp 0x9d267
movb $0x1, 0xa7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7a6d0
testb $0x1, 0xa7(%rsp)
jne 0x9d27d
jmp 0x9d273
leaq 0x78(%rsp), %rdi
callq 0x7a6d0
jmp 0x9d28a
movq 0x28(%rsp), %rdi
callq 0x77890
movq 0x18(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x77890
movq 0x98(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| _ZN5minja6Parser14parseLogicalOrEv:
sub rsp, 0B8h
mov [rsp+0B8h+var_90], rdi
mov rax, rdi
mov [rsp+0B8h+var_A0], rax
mov [rsp+0B8h+var_8], rdi
mov [rsp+0B8h+var_10], rsi
mov rsi, [rsp+0B8h+var_10]
mov [rsp+0B8h+var_98], rsi
mov [rsp+0B8h+var_11], 0
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
mov rdi, [rsp+0B8h+var_90]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_9D068
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_A8], rax
lea rsi, aExpectedLeftSi; "Expected left side of 'logical or' expr"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9D00F:
mov rdi, [rsp+0B8h+var_A8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_9D2A1
mov rdi, [rsp+arg_8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp loc_9D28A
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_9D28A
loc_9D068:
cmp cs:_ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11, 0; `guard variable for'minja::Parser::parseLogicalOr(void)::or_tok
jnz short loc_9D0C2
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_9D0C2
lea rdi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rsi, aOrB; "or\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_9D09C:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_release
loc_9D0C2:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_40]; this
call _ZNK5minja6Parser12get_locationEv; minja::Parser::get_location(void)
jmp short $+2
loc_9D0D3:
jmp short $+2
loc_9D0D5:
mov rsi, [rsp+0B8h+var_98]
lea rdx, _ZZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; minja::Parser::parseLogicalOr(void)::or_tok
lea rdi, [rsp+0B8h+var_60]
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
jmp short $+2
loc_9D0F2:
lea rdi, [rsp+0B8h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
mov [rsp+0B8h+var_A9], al
lea rdi, [rsp+0B8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rsp+0B8h+var_A9]
test al, 1
jnz short loc_9D119
jmp loc_9D249
loc_9D119:
mov rsi, [rsp+0B8h+var_98]
lea rdi, [rsp+0B8h+var_70]; this
call _ZN5minja6Parser15parseLogicalAndEv; minja::Parser::parseLogicalAnd(void)
jmp short $+2
loc_9D12A:
lea rdi, [rsp+0B8h+var_70]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_9D1ED
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0B8h+var_B8], rax
lea rsi, aExpectedRightS; "Expected right side of 'or' expression"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_9D15E:
mov rdi, [rsp+0B8h+var_B8]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_9D2A1
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
lea rdi, _ZGVZN5minja6Parser14parseLogicalOrEvE6or_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp loc_9D28A
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp loc_9D267
mov rdi, [rsp+0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
call ___cxa_free_exception
jmp short loc_9D23D
mov rcx, rax
mov eax, edx
mov [rsp+arg_90], rcx
mov [rsp+arg_8C], eax
jmp short loc_9D23D
loc_9D1ED:
mov rdx, [rsp+0B8h+var_90]
mov [rsp+0B8h+var_84], 0Fh
lea rdi, [rsp+0B8h+var_80]
lea rsi, [rsp+0B8h+var_40]
lea rcx, [rsp+0B8h+var_70]
lea r8, [rsp+0B8h+var_84]
call _ZSt11make_sharedIN5minja12BinaryOpExprEJRNS0_8LocationESt10shared_ptrINS0_10ExpressionEES6_NS1_2OpEEES4_IT_EDpOT0_; std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op &&)
jmp short $+2
loc_9D215:
mov rdi, [rsp+0B8h+var_90]
lea rsi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja10ExpressionEEaSINS0_12BinaryOpExprEEENSt9enable_ifIXsr13is_assignableIRSt12__shared_ptrIS1_LN9__gnu_cxx12_Lock_policyE2EES_IT_EEE5valueERS2_E4typeEOSC_
lea rdi, [rsp+0B8h+var_80]
call _ZNSt10shared_ptrIN5minja12BinaryOpExprEED2Ev; std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr()
lea rdi, [rsp+0B8h+var_70]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp loc_9D0D5
loc_9D23D:
lea rdi, [rsp+arg_40]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
jmp short loc_9D267
loc_9D249:
mov [rsp+0B8h+var_11], 1
lea rdi, [rsp+0B8h+var_40]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
test [rsp+0B8h+var_11], 1
jnz short loc_9D27D
jmp short loc_9D273
loc_9D267:
lea rdi, [rsp+arg_70]; this
call _ZN5minja8LocationD2Ev; minja::Location::~Location()
jmp short loc_9D28A
loc_9D273:
mov rdi, [rsp+0B8h+var_90]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
loc_9D27D:
mov rax, [rsp+0B8h+var_A0]
add rsp, 0B8h
retn
loc_9D28A:
mov rdi, [rsp+arg_20]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
mov rdi, [rsp+arg_90]
call __Unwind_Resume
loc_9D2A1:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax+rax+00h]
| minja::Parser * minja::Parser::parseLogicalOr(minja::Parser *this, long long a2)
{
int v2; // r9d
int v4; // [rsp+0h] [rbp-B8h]
std::runtime_error *v5; // [rsp+0h] [rbp-B8h]
int v6; // [rsp+8h] [rbp-B0h]
char v7; // [rsp+Fh] [rbp-A9h]
int v8; // [rsp+10h] [rbp-A8h]
std::runtime_error *exception; // [rsp+10h] [rbp-A8h]
minja::Parser *v10; // [rsp+18h] [rbp-A0h]
long long v11; // [rsp+20h] [rbp-98h]
int v12; // [rsp+34h] [rbp-84h] BYREF
_BYTE v13[16]; // [rsp+38h] [rbp-80h] BYREF
_QWORD v14[2]; // [rsp+48h] [rbp-70h] BYREF
_BYTE v15[32]; // [rsp+58h] [rbp-60h] BYREF
_BYTE v16[47]; // [rsp+78h] [rbp-40h] BYREF
char v17; // [rsp+A7h] [rbp-11h]
long long v18; // [rsp+A8h] [rbp-10h]
minja::Parser *v19; // [rsp+B0h] [rbp-8h]
v10 = this;
v19 = this;
v18 = a2;
v11 = a2;
v17 = 0;
minja::Parser::parseLogicalAnd(this);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(this) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected left side of 'logical or' expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
(long long)"or\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11]);
}
minja::Parser::get_location((minja::Parser *)v16, a2);
while ( 1 )
{
minja::Parser::consumeToken((long long)v15, v11, (long long)&minja::Parser::parseLogicalOr(void)::or_tok[abi:cxx11], 1u);
v7 = ~(unsigned __int8)std::string::empty(v15);
std::string::~string(v15);
if ( (v7 & 1) == 0 )
break;
minja::Parser::parseLogicalAnd((minja::Parser *)v14);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v14) )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected right side of 'or' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v12 = 15;
std::make_shared<minja::BinaryOpExpr,minja::Location &,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>(
(unsigned int)v13,
(unsigned int)v16,
(_DWORD)this,
(unsigned int)v14,
(unsigned int)&v12,
v2,
v4,
v6,
v8,
(long long)v10,
v11);
std::shared_ptr<minja::Expression>::operator=<minja::BinaryOpExpr>(this, v13);
std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr(v13);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v14);
}
v17 = 1;
minja::Location::~Location((minja::Location *)v16);
if ( (v17 & 1) == 0 )
std::shared_ptr<minja::Expression>::~shared_ptr((long long)this);
return v10;
}
| parseLogicalOr:
SUB RSP,0xb8
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,RDI
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0xb0],RDI
MOV qword ptr [RSP + 0xa8],RSI
MOV RSI,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x20],RSI
MOV byte ptr [RSP + 0xa7],0x0
CALL 0x0019d6f0
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00177a80
TEST AL,0x1
JNZ 0x0019d068
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x10],RAX
LAB_0019d001:
LEA RSI,[0x2cc77b]
CALL 0x00150340
JMP 0x0019d00f
LAB_0019d00f:
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019d068:
CMP byte ptr [0x00354f40],0x0
JNZ 0x0019d0c2
LEA RDI,[0x354f40]
CALL 0x001504b0
CMP EAX,0x0
JZ 0x0019d0c2
LAB_0019d082:
LEA RDI,[0x354f20]
LEA RSI,[0x2cc7a9]
MOV EDX,0x10
CALL 0x00176c30
JMP 0x0019d09c
LAB_0019d09c:
LEA RDI,[0x176ce0]
LEA RSI,[0x354f20]
LEA RDX,[0x354868]
CALL 0x00150c20
LEA RDI,[0x354f40]
CALL 0x00150820
LAB_0019d0c2:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDI,[RSP + 0x78]
CALL 0x00176db0
JMP 0x0019d0d3
LAB_0019d0d3:
JMP 0x0019d0d5
LAB_0019d0d5:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDX,[0x354f20]
LEA RDI,[RSP + 0x58]
MOV ECX,0x1
CALL 0x001778a0
JMP 0x0019d0f2
LAB_0019d0f2:
LEA RDI,[RSP + 0x58]
CALL 0x001503b0
XOR AL,0xff
MOV byte ptr [RSP + 0xf],AL
LEA RDI,[RSP + 0x58]
CALL 0x001510c0
MOV AL,byte ptr [RSP + 0xf]
TEST AL,0x1
JNZ 0x0019d119
JMP 0x0019d249
LAB_0019d119:
MOV RSI,qword ptr [RSP + 0x20]
LEA RDI,[RSP + 0x48]
CALL 0x0019d6f0
LAB_0019d128:
JMP 0x0019d12a
LAB_0019d12a:
LEA RDI,[RSP + 0x48]
CALL 0x00177a80
TEST AL,0x1
JNZ 0x0019d1ed
MOV EDI,0x10
CALL 0x00150540
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP],RAX
LAB_0019d150:
LEA RSI,[0x2cc7ae]
CALL 0x00150340
JMP 0x0019d15e
LAB_0019d15e:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
LAB_0019d1ed:
MOV RDX,qword ptr [RSP + 0x28]
MOV dword ptr [RSP + 0x34],0xf
LAB_0019d1fa:
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x78]
LEA RCX,[RSP + 0x48]
LEA R8,[RSP + 0x34]
CALL 0x0019da00
LAB_0019d213:
JMP 0x0019d215
LAB_0019d215:
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[RSP + 0x38]
CALL 0x0019daa0
LEA RDI,[RSP + 0x38]
CALL 0x0019dad0
LEA RDI,[RSP + 0x48]
CALL 0x00177890
JMP 0x0019d0d5
LAB_0019d249:
MOV byte ptr [RSP + 0xa7],0x1
LEA RDI,[RSP + 0x78]
CALL 0x0017a6d0
TEST byte ptr [RSP + 0xa7],0x1
JNZ 0x0019d27d
JMP 0x0019d273
LAB_0019d273:
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00177890
LAB_0019d27d:
MOV RAX,qword ptr [RSP + 0x18]
ADD RSP,0xb8
RET
|
/* minja::Parser::parseLogicalOr() */
__shared_ptr * minja::Parser::parseLogicalOr(void)
{
bool bVar1;
byte bVar2;
int iVar3;
runtime_error *prVar4;
int8 in_RSI;
__shared_ptr *in_RDI;
Location local_80 [16];
__shared_ptr local_70 [16];
string local_60 [32];
shared_ptr local_40 [47];
byte local_11;
local_11 = 0;
parseLogicalAnd();
bVar1 = std::__shared_ptr::operator_cast_to_bool(in_RDI);
if (!bVar1) {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019d001 to 0019d00c has its CatchHandler @ 0019d02c */
std::runtime_error::runtime_error(prVar4,"Expected left side of \'logical or\' expression");
/* try { // try from 0019d00f to 0019d026 has its CatchHandler @ 0019d04f */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
if (parseLogicalOr()::or_tok_abi_cxx11_ == '\0') {
iVar3 = __cxa_guard_acquire(&parseLogicalOr()::or_tok_abi_cxx11_);
if (iVar3 != 0) {
/* try { // try from 0019d082 to 0019d099 has its CatchHandler @ 0019d17a */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
(parseLogicalOr()::or_tok_abi_cxx11_,&DAT_002cc7a9,0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseLogicalOr()::or_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseLogicalOr()::or_tok_abi_cxx11_);
}
}
/* try { // try from 0019d0c2 to 0019d0d0 has its CatchHandler @ 0019d04f */
get_location();
while( true ) {
/* try { // try from 0019d0d5 to 0019d127 has its CatchHandler @ 0019d19f */
consumeToken(local_60,in_RSI,parseLogicalOr()::or_tok_abi_cxx11_,1);
bVar2 = std::__cxx11::string::empty();
std::__cxx11::string::~string(local_60);
if (((bVar2 ^ 0xff) & 1) == 0) {
local_11 = 1;
Location::~Location((Location *)local_40);
if ((local_11 & 1) == 0) {
std::shared_ptr<minja::Expression>::~shared_ptr((shared_ptr<minja::Expression> *)in_RDI);
}
return in_RDI;
}
parseLogicalAnd();
bVar1 = std::__shared_ptr::operator_cast_to_bool(local_70);
if (!bVar1) break;
/* try { // try from 0019d1fa to 0019d212 has its CatchHandler @ 0019d1d7 */
std::
make_shared<minja::BinaryOpExpr,minja::Location&,std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>,minja::BinaryOpExpr::Op>
(local_80,local_40,(shared_ptr *)in_RDI,(Op *)local_70);
std::shared_ptr<minja::Expression>::operator=
((shared_ptr<minja::Expression> *)in_RDI,(shared_ptr *)local_80);
std::shared_ptr<minja::BinaryOpExpr>::~shared_ptr((shared_ptr<minja::BinaryOpExpr> *)local_80);
std::shared_ptr<minja::Expression>::~shared_ptr((shared_ptr<minja::Expression> *)local_70);
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019d150 to 0019d15b has its CatchHandler @ 0019d1b8 */
std::runtime_error::runtime_error(prVar4,"Expected right side of \'or\' expression");
/* try { // try from 0019d15e to 0019d174 has its CatchHandler @ 0019d1d7 */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
| |
23,658 | common_sampler_accept(common_sampler*, int, bool) | monkey531[P]llama/common/sampling.cpp | void common_sampler_accept(struct common_sampler * gsmpl, llama_token token, bool accept_grammar) {
if (accept_grammar) {
llama_sampler_accept(gsmpl->grmr, token);
}
llama_sampler_accept(gsmpl->chain, token);
gsmpl->prev.push_back(token);
} | O1 | cpp | common_sampler_accept(common_sampler*, int, bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0xcf661
movq 0x138(%rbx), %rdi
movl %ebp, %esi
callq 0x1b4e0
movq 0x140(%rbx), %rdi
movl %ebp, %esi
callq 0x1b4e0
movq 0x148(%rbx), %rcx
movq 0x150(%rbx), %rax
cmpq %rcx, %rax
jne 0xcf69a
movq 0x158(%rbx), %rax
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x158(%rbx)
jmp 0xcf6a4
incq %rax
movq %rax, 0x150(%rbx)
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rdx
movl %ebp, (%rdx,%rax,4)
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _Z21common_sampler_acceptP14common_samplerib:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
test edx, edx
jz short loc_CF661
mov rdi, [rbx+138h]
mov esi, ebp
call _llama_sampler_accept
loc_CF661:
mov rdi, [rbx+140h]
mov esi, ebp
call _llama_sampler_accept
mov rcx, [rbx+148h]
mov rax, [rbx+150h]
cmp rax, rcx
jnz short loc_CF69A
mov rax, [rbx+158h]
inc rax
xor edx, edx
div rcx
mov [rbx+158h], rdx
jmp short loc_CF6A4
loc_CF69A:
inc rax
mov [rbx+150h], rax
loc_CF6A4:
mov rax, [rbx+160h]
mov rdx, [rbx+168h]
mov [rdx+rax*4], ebp
inc rax
xor edx, edx
div rcx
mov [rbx+160h], rdx
add rsp, 8
pop rbx
pop rbp
retn
| unsigned long long common_sampler_accept(_QWORD *a1, unsigned int a2, int a3)
{
unsigned long long v3; // rcx
long long v4; // rax
long long v5; // rax
unsigned long long result; // rax
unsigned long long v7; // rtt
if ( a3 )
llama_sampler_accept(a1[39], a2);
llama_sampler_accept(a1[40], a2);
v3 = a1[41];
v4 = a1[42];
if ( v4 == v3 )
a1[43] = (a1[43] + 1LL) % v3;
else
a1[42] = v4 + 1;
v5 = a1[44];
*(_DWORD *)(a1[45] + 4 * v5) = a2;
v7 = v5 + 1;
result = (v5 + 1) / v3;
a1[44] = v7 % v3;
return result;
}
| common_sampler_accept:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
TEST EDX,EDX
JZ 0x001cf661
MOV RDI,qword ptr [RBX + 0x138]
MOV ESI,EBP
CALL 0x0011b4e0
LAB_001cf661:
MOV RDI,qword ptr [RBX + 0x140]
MOV ESI,EBP
CALL 0x0011b4e0
MOV RCX,qword ptr [RBX + 0x148]
MOV RAX,qword ptr [RBX + 0x150]
CMP RAX,RCX
JNZ 0x001cf69a
MOV RAX,qword ptr [RBX + 0x158]
INC RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x158],RDX
JMP 0x001cf6a4
LAB_001cf69a:
INC RAX
MOV qword ptr [RBX + 0x150],RAX
LAB_001cf6a4:
MOV RAX,qword ptr [RBX + 0x160]
MOV RDX,qword ptr [RBX + 0x168]
MOV dword ptr [RDX + RAX*0x4],EBP
INC RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x160],RDX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* common_sampler_accept(common_sampler*, int, bool) */
ulong common_sampler_accept(common_sampler *param_1,int param_2,bool param_3)
{
ulong uVar1;
long lVar2;
ulong uVar3;
int7 in_register_00000011;
if ((int)CONCAT71(in_register_00000011,param_3) != 0) {
llama_sampler_accept(*(int8 *)(param_1 + 0x138),param_2);
}
llama_sampler_accept(*(int8 *)(param_1 + 0x140),param_2);
uVar1 = *(ulong *)(param_1 + 0x148);
if (*(ulong *)(param_1 + 0x150) == uVar1) {
*(ulong *)(param_1 + 0x158) = (*(long *)(param_1 + 0x158) + 1U) % uVar1;
}
else {
*(ulong *)(param_1 + 0x150) = *(ulong *)(param_1 + 0x150) + 1;
}
lVar2 = *(long *)(param_1 + 0x160);
*(int *)(*(long *)(param_1 + 0x168) + lVar2 * 4) = param_2;
uVar3 = lVar2 + 1;
*(ulong *)(param_1 + 0x160) = uVar3 % uVar1;
return uVar3 / uVar1;
}
| |
23,659 | common_sampler_accept(common_sampler*, int, bool) | monkey531[P]llama/common/sampling.cpp | void common_sampler_accept(struct common_sampler * gsmpl, llama_token token, bool accept_grammar) {
if (accept_grammar) {
llama_sampler_accept(gsmpl->grmr, token);
}
llama_sampler_accept(gsmpl->chain, token);
gsmpl->prev.push_back(token);
} | O3 | cpp | common_sampler_accept(common_sampler*, int, bool):
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %edx, %edx
je 0xcdb9d
movq 0x138(%rbx), %rdi
movl %ebp, %esi
callq 0x1a4e0
movq 0x140(%rbx), %rdi
movl %ebp, %esi
callq 0x1a4e0
movq 0x148(%rbx), %rcx
movq 0x150(%rbx), %rsi
cmpq %rcx, %rsi
jne 0xcdbd6
movq 0x158(%rbx), %rax
incq %rax
xorl %edx, %edx
divq %rsi
movq %rdx, 0x158(%rbx)
jmp 0xcdbe0
incq %rsi
movq %rsi, 0x150(%rbx)
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rdx
movl %ebp, (%rdx,%rax,4)
incq %rax
xorl %edx, %edx
divq %rcx
movq %rdx, 0x160(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| _Z21common_sampler_acceptP14common_samplerib:
push rbp
push rbx
push rax
mov ebp, esi
mov rbx, rdi
test edx, edx
jz short loc_CDB9D
mov rdi, [rbx+138h]
mov esi, ebp
call _llama_sampler_accept
loc_CDB9D:
mov rdi, [rbx+140h]
mov esi, ebp
call _llama_sampler_accept
mov rcx, [rbx+148h]
mov rsi, [rbx+150h]
cmp rsi, rcx
jnz short loc_CDBD6
mov rax, [rbx+158h]
inc rax
xor edx, edx
div rsi
mov [rbx+158h], rdx
jmp short loc_CDBE0
loc_CDBD6:
inc rsi
mov [rbx+150h], rsi
loc_CDBE0:
mov rax, [rbx+160h]
mov rdx, [rbx+168h]
mov [rdx+rax*4], ebp
inc rax
xor edx, edx
div rcx
mov [rbx+160h], rdx
add rsp, 8
pop rbx
pop rbp
retn
| unsigned long long common_sampler_accept(_QWORD *a1, unsigned int a2, int a3)
{
unsigned long long v4; // rcx
unsigned long long v5; // rsi
long long v6; // rax
unsigned long long result; // rax
unsigned long long v8; // rtt
if ( a3 )
llama_sampler_accept(a1[39], a2);
llama_sampler_accept(a1[40], a2);
v4 = a1[41];
v5 = a1[42];
if ( v5 == v4 )
a1[43] = (a1[43] + 1LL) % v5;
else
a1[42] = v5 + 1;
v6 = a1[44];
*(_DWORD *)(a1[45] + 4 * v6) = a2;
v8 = v6 + 1;
result = (v6 + 1) / v4;
a1[44] = v8 % v4;
return result;
}
| common_sampler_accept:
PUSH RBP
PUSH RBX
PUSH RAX
MOV EBP,ESI
MOV RBX,RDI
TEST EDX,EDX
JZ 0x001cdb9d
MOV RDI,qword ptr [RBX + 0x138]
MOV ESI,EBP
CALL 0x0011a4e0
LAB_001cdb9d:
MOV RDI,qword ptr [RBX + 0x140]
MOV ESI,EBP
CALL 0x0011a4e0
MOV RCX,qword ptr [RBX + 0x148]
MOV RSI,qword ptr [RBX + 0x150]
CMP RSI,RCX
JNZ 0x001cdbd6
MOV RAX,qword ptr [RBX + 0x158]
INC RAX
XOR EDX,EDX
DIV RSI
MOV qword ptr [RBX + 0x158],RDX
JMP 0x001cdbe0
LAB_001cdbd6:
INC RSI
MOV qword ptr [RBX + 0x150],RSI
LAB_001cdbe0:
MOV RAX,qword ptr [RBX + 0x160]
MOV RDX,qword ptr [RBX + 0x168]
MOV dword ptr [RDX + RAX*0x4],EBP
INC RAX
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBX + 0x160],RDX
ADD RSP,0x8
POP RBX
POP RBP
RET
|
/* common_sampler_accept(common_sampler*, int, bool) */
ulong common_sampler_accept(common_sampler *param_1,int param_2,bool param_3)
{
ulong uVar1;
long lVar2;
ulong uVar3;
int7 in_register_00000011;
if ((int)CONCAT71(in_register_00000011,param_3) != 0) {
llama_sampler_accept(*(int8 *)(param_1 + 0x138),param_2);
}
llama_sampler_accept(*(int8 *)(param_1 + 0x140),param_2);
uVar1 = *(ulong *)(param_1 + 0x148);
uVar3 = *(ulong *)(param_1 + 0x150);
if (uVar3 == uVar1) {
*(ulong *)(param_1 + 0x158) = (*(long *)(param_1 + 0x158) + 1U) % uVar3;
}
else {
*(ulong *)(param_1 + 0x150) = uVar3 + 1;
}
lVar2 = *(long *)(param_1 + 0x160);
*(int *)(*(long *)(param_1 + 0x168) + lVar2 * 4) = param_2;
uVar3 = lVar2 + 1;
*(ulong *)(param_1 + 0x160) = uVar3 % uVar1;
return uVar3 / uVar1;
}
| |
23,660 | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/./json.hpp | basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value = *other.m_data.m_value.object;
break;
}
case value_t::array:
{
m_data.m_value = *other.m_data.m_value.array;
break;
}
case value_t::string:
{
m_data.m_value = *other.m_data.m_value.string;
break;
}
case value_t::boolean:
{
m_data.m_value = other.m_data.m_value.boolean;
break;
}
case value_t::number_integer:
{
m_data.m_value = other.m_data.m_value.number_integer;
break;
}
case value_t::number_unsigned:
{
m_data.m_value = other.m_data.m_value.number_unsigned;
break;
}
case value_t::number_float:
{
m_data.m_value = other.m_data.m_value.number_float;
break;
}
case value_t::binary:
{
m_data.m_value = *other.m_data.m_value.binary;
break;
}
case value_t::null:
case value_t::discarded:
default:
break;
}
set_parents();
assert_invariant();
} | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3eca6
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x4f3ac
leaq 0xa0eec(%rip), %rcx # 0xf0254
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
jmp 0x4f3a8
movq 0x8(%r14), %rdi
callq 0x4f73c
jmp 0x4f3a8
movq 0x8(%r14), %rdi
callq 0x4f7be
jmp 0x4f3a8
movzbl 0x8(%r14), %eax
jmp 0x4f3a8
movq 0x8(%r14), %rdi
callq 0x4f3d8
jmp 0x4f3a8
movq 0x8(%r14), %rdi
callq 0x4f5ce
movq %rax, 0x8(%rbx)
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3eca6
jmp 0x4f3c4
jmp 0x4f3c4
jmp 0x4f3c4
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f736
movq %r14, %rdi
callq 0x293c0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov al, [rsi]
mov [rdi], al
push 1
pop rsi
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
movzx eax, byte ptr [rbx]
dec eax; switch 8 cases
cmp eax, 7
ja short def_4F36F; jumptable 000000000004F36F default case
lea rcx, jpt_4F36F
movsxd rax, ds:(jpt_4F36F - 0F0254h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_4F371:
mov rax, [r14+8]; jumptable 000000000004F36F cases 5-7
jmp short loc_4F3A8
loc_4F377:
mov rdi, [r14+8]; jumptable 000000000004F36F case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_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::string,std::string const&>(std::string const&)
jmp short loc_4F3A8
loc_4F382:
mov rdi, [r14+8]; jumptable 000000000004F36F case 8
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS0_27byte_container_with_subtypeISC_EEJRKSG_EEEPT_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<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&>(nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&)
jmp short loc_4F3A8
loc_4F38D:
movzx eax, byte ptr [r14+8]; jumptable 000000000004F36F case 4
jmp short loc_4F3A8
loc_4F394:
mov rdi, [r14+8]; jumptable 000000000004F36F case 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJRKSL_EEEPT_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<nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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&>(nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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&)
jmp short loc_4F3A8
loc_4F39F:
mov rdi, [r14+8]; jumptable 000000000004F36F case 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJRKSG_EEEPT_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>>,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>> const&>(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>> const&)
loc_4F3A8:
mov [rbx+8], rax
def_4F36F:
push 1; jumptable 000000000004F36F default case
pop rsi
mov rdi, rbx
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)
jmp short loc_4F3C4
jmp short loc_4F3C4
jmp short $+2
loc_4F3C4:
mov r14, rax
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, 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>::basic_json(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
int v2; // eax
int v3; // edx
int v4; // ecx
int v5; // r8d
int v6; // r9d
long long result; // rax
int v8; // [rsp-8h] [rbp-18h]
v8 = v2;
*(_OWORD *)a1 = 0LL;
*a1 = *a2;
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 *)a2);
result = (unsigned int)*a1 - 1;
switch ( *a1 )
{
case 1u:
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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 2u:
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>::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>>,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>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 3u:
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>::create<std::string,std::string const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
goto LABEL_8;
case 4u:
result = a2[8];
goto LABEL_8;
case 5u:
case 6u:
case 7u:
result = *((_QWORD *)a2 + 1);
goto LABEL_8;
case 8u:
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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>> const&>(
*((_QWORD *)a2 + 1),
1,
v3,
v4,
v5,
v6,
v8);
LABEL_8:
*((_QWORD *)a1 + 1) = result;
break;
default:
break;
}
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;
}
| basic_json:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV AL,byte ptr [RSI]
MOV byte ptr [RDI],AL
PUSH 0x1
POP RSI
MOV RDI,R14
CALL 0x0013eca6
MOVZX EAX,byte ptr [RBX]
DEC EAX
CMP EAX,0x7
JA 0x0014f3ac
LEA RCX,[0x1f0254]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x0014f3a8
caseD_3:
MOV RDI,qword ptr [R14 + 0x8]
LAB_0014f37b:
CALL 0x0014f73c
JMP 0x0014f3a8
caseD_8:
MOV RDI,qword ptr [R14 + 0x8]
LAB_0014f386:
CALL 0x0014f7be
JMP 0x0014f3a8
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x0014f3a8
caseD_1:
MOV RDI,qword ptr [R14 + 0x8]
LAB_0014f398:
CALL 0x0014f3d8
JMP 0x0014f3a8
caseD_2:
MOV RDI,qword ptr [R14 + 0x8]
LAB_0014f3a3:
CALL 0x0014f5ce
LAB_0014f3a8:
MOV qword ptr [RBX + 0x8],RAX
default:
PUSH 0x1
POP RSI
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0013eca6
|
/* 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::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&) */
void __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>
::basic_json(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
string *psVar1;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*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>
)*param_1;
assert_invariant(SUB81(param_1,0));
switch(*this) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1:
/* try { // try from 0014f398 to 0014f39c has its CatchHandler @ 0014f3c0 */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,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::less<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,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::less<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>>>>const&>
(*(ordered_map **)(param_1 + 8));
break;
case (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:
/* try { // try from 0014f3a3 to 0014f3a7 has its CatchHandler @ 0014f3be */
psVar1 = (string *)
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>>>,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>>>const&>
(*(vector **)(param_1 + 8));
break;
case (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>
)0x3:
/* try { // try from 0014f37b to 0014f37f has its CatchHandler @ 0014f3c4 */
psVar1 = create<std::__cxx11::string,std::__cxx11::string_const&>(*(string **)(param_1 + 8));
break;
case (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>
)0x4:
psVar1 = (string *)(ulong)(byte)param_1[8];
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
psVar1 = *(string **)(param_1 + 8);
break;
case (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:
/* try { // try from 0014f386 to 0014f38a has its CatchHandler @ 0014f3c2 */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>const&>
(*(byte_container_with_subtype **)(param_1 + 8));
break;
default:
goto switchD_0014f36f_default;
}
*(string **)(this + 8) = psVar1;
switchD_0014f36f_default:
assert_invariant(SUB81(this,0));
return;
}
| |
23,661 | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&) | monkey531[P]llama/common/./json.hpp | basic_json(const basic_json& other)
: json_base_class_t(other)
{
m_data.m_type = other.m_data.m_type;
// check of passed value is valid
other.assert_invariant();
switch (m_data.m_type)
{
case value_t::object:
{
m_data.m_value = *other.m_data.m_value.object;
break;
}
case value_t::array:
{
m_data.m_value = *other.m_data.m_value.array;
break;
}
case value_t::string:
{
m_data.m_value = *other.m_data.m_value.string;
break;
}
case value_t::boolean:
{
m_data.m_value = other.m_data.m_value.boolean;
break;
}
case value_t::number_integer:
{
m_data.m_value = other.m_data.m_value.number_integer;
break;
}
case value_t::number_unsigned:
{
m_data.m_value = other.m_data.m_value.number_unsigned;
break;
}
case value_t::number_float:
{
m_data.m_value = other.m_data.m_value.number_float;
break;
}
case value_t::binary:
{
m_data.m_value = *other.m_data.m_value.binary;
break;
}
case value_t::null:
case value_t::discarded:
default:
break;
}
set_parents();
assert_invariant();
} | 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>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movb (%rsi), %al
movb %al, (%rdi)
movq %rsi, %rdi
movl $0x1, %esi
callq 0x438fc
movzbl (%rbx), %eax
decl %eax
cmpl $0x7, %eax
ja 0x569bc
leaq 0xed940(%rip), %rcx # 0x1442b8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rax
jmp 0x569b8
movq 0x8(%r14), %rdi
callq 0x56cfc
jmp 0x569b8
movq 0x8(%r14), %rdi
callq 0x56d4c
jmp 0x569b8
movzbl 0x8(%r14), %eax
jmp 0x569b8
movq 0x8(%r14), %rdi
callq 0x569ea
jmp 0x569b8
movq 0x8(%r14), %rdi
callq 0x56bba
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x438fc
jmp 0x569d6
jmp 0x569d6
jmp 0x569d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x44196
movq %r14, %rdi
callq 0x20380
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov al, [rsi]
mov [rdi], al
mov rdi, rsi
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
movzx eax, byte ptr [rbx]
dec eax; switch 8 cases
cmp eax, 7
ja short def_5697F; jumptable 000000000005697F default case
lea rcx, jpt_5697F
movsxd rax, ds:(jpt_5697F - 1442B8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_56981:
mov rax, [r14+8]; jumptable 000000000005697F cases 5-7
jmp short loc_569B8
loc_56987:
mov rdi, [r14+8]; jumptable 000000000005697F case 3
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS9_JRKS9_EEEPT_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::string,std::string const&>(std::string const&)
jmp short loc_569B8
loc_56992:
mov rdi, [r14+8]; jumptable 000000000005697F case 8
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS0_27byte_container_with_subtypeISC_EEJRKSG_EEEPT_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<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&>(nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> const&)
jmp short loc_569B8
loc_5699D:
movzx eax, byte ptr [r14+8]; jumptable 000000000005697F case 4
jmp short loc_569B8
loc_569A4:
mov rdi, [r14+8]; jumptable 000000000005697F case 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createINS2_IS9_SD_St4lessIvESaISt4pairIKS9_SD_EEEEJRKSL_EEEPT_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<nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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&>(nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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&)
jmp short loc_569B8
loc_569AF:
mov rdi, [r14+8]; jumptable 000000000005697F case 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJRKSG_EEEPT_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>>,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>> const&>(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>> const&)
loc_569B8:
mov [rbx+8], rax
def_5697F:
mov rdi, rbx; jumptable 000000000005697F default case
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)
jmp short loc_569D6
jmp short loc_569D6
jmp short $+2
loc_569D6:
mov r14, rax
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, 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>::basic_json(
unsigned __int8 *a1,
unsigned __int8 *a2)
{
long long result; // rax
*(_OWORD *)a1 = 0LL;
*a1 = *a2;
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 *)a2);
result = (unsigned int)*a1 - 1;
switch ( *a1 )
{
case 1u:
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>::create<nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::string,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::less<void>,std::allocator<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>>>> const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 2u:
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>::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>>,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>> const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 3u:
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>::create<std::string,std::string const&>(
*((_QWORD *)a2 + 1),
1LL);
goto LABEL_8;
case 4u:
result = a2[8];
goto LABEL_8;
case 5u:
case 6u:
case 7u:
result = *((_QWORD *)a2 + 1);
goto LABEL_8;
case 8u:
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>::create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>> const&>(
*((_QWORD *)a2 + 1),
1LL);
LABEL_8:
*((_QWORD *)a1 + 1) = result;
break;
default:
break;
}
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;
}
| basic_json:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV AL,byte ptr [RSI]
MOV byte ptr [RDI],AL
MOV RDI,RSI
MOV ESI,0x1
CALL 0x001438fc
MOVZX EAX,byte ptr [RBX]
DEC EAX
CMP EAX,0x7
JA 0x001569bc
LEA RCX,[0x2442b8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_5:
MOV RAX,qword ptr [R14 + 0x8]
JMP 0x001569b8
caseD_3:
MOV RDI,qword ptr [R14 + 0x8]
LAB_0015698b:
CALL 0x00156cfc
JMP 0x001569b8
caseD_8:
MOV RDI,qword ptr [R14 + 0x8]
LAB_00156996:
CALL 0x00156d4c
JMP 0x001569b8
caseD_4:
MOVZX EAX,byte ptr [R14 + 0x8]
JMP 0x001569b8
caseD_1:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001569a8:
CALL 0x001569ea
JMP 0x001569b8
caseD_2:
MOV RDI,qword ptr [R14 + 0x8]
LAB_001569b3:
CALL 0x00156bba
LAB_001569b8:
MOV qword ptr [RBX + 0x8],RAX
default:
MOV RDI,RBX
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x001438fc
|
/* 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::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&) */
void __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>
::basic_json(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,basic_json *param_1)
{
string *psVar1;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*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>
)*param_1;
assert_invariant(SUB81(param_1,0));
switch(*this) {
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1:
/* try { // try from 001569a8 to 001569ac has its CatchHandler @ 001569d2 */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,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::less<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>>>>,nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::string,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::less<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>>>>const&>
(*(ordered_map **)(param_1 + 8));
break;
case (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:
/* try { // try from 001569b3 to 001569b7 has its CatchHandler @ 001569d0 */
psVar1 = (string *)
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>>>,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>>>const&>
(*(vector **)(param_1 + 8));
break;
case (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>
)0x3:
/* try { // try from 0015698b to 0015698f has its CatchHandler @ 001569d6 */
psVar1 = create<std::__cxx11::string,std::__cxx11::string_const&>(*(string **)(param_1 + 8));
break;
case (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>
)0x4:
psVar1 = (string *)(ulong)(byte)param_1[8];
break;
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x5:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x6:
case (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x7:
psVar1 = *(string **)(param_1 + 8);
break;
case (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:
/* try { // try from 00156996 to 0015699a has its CatchHandler @ 001569d4 */
psVar1 = (string *)
create<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>const&>
(*(byte_container_with_subtype **)(param_1 + 8));
break;
default:
goto switchD_0015697f_default;
}
*(string **)(this + 8) = psVar1;
switchD_0015697f_default:
assert_invariant(SUB81(this,0));
return;
}
| |
23,662 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O3 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $0xffffff, %rdx # imm = 0xFFFFFF
jb 0x31290
leaq -0x34(%rbp), %r12
movl $0x1, %r13d
movw $0xffff, -0x34(%rbp) # imm = 0xFFFF
movb $-0x1, -0x32(%rbp)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, -0x31(%rbp)
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x312fd
testl %eax, %eax
jne 0x312d7
movl $0xffffff, %edx # imm = 0xFFFFFF
movq %r15, %rdi
movq %r14, %rsi
callq 0x312fd
testl %eax, %eax
jne 0x312d7
addq $0xffffff, %r14 # imm = 0xFFFFFF
addq $-0xffffff, %rbx # imm = 0xFF000001
cmpq $0xfffffe, %rbx # imm = 0xFFFFFE
ja 0x31239
leaq -0x34(%rbp), %rsi
movb %bl, (%rsi)
movb %bh, -0x33(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x312fd
movl $0x1, %r13d
testl %eax, %eax
jne 0x312d7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x312fd
movl %eax, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x312f8
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp rdx, 0FFFFFFh
jb short loc_31290
lea r12, [rbp+var_34]
mov r13d, 1
loc_31239:
mov [rbp+var_34], 0FFFFh
mov [rbp+var_32], 0FFh
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rbp+var_31], al
mov edx, 4
mov rdi, r15
mov rsi, r12
call ma_net_write_buff
test eax, eax
jnz short loc_312D7
mov edx, 0FFFFFFh
mov rdi, r15
mov rsi, r14
call ma_net_write_buff
test eax, eax
jnz short loc_312D7
add r14, 0FFFFFFh
add rbx, 0FFFFFFFFFF000001h
cmp rbx, 0FFFFFEh
ja short loc_31239
loc_31290:
lea rsi, [rbp+var_34]
mov [rsi], bl
mov byte ptr [rbp+var_34+1], bh
mov eax, ebx
shr eax, 10h
mov [rsi+2], al
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rsi+3], al
mov edx, 4
mov rdi, r15
call ma_net_write_buff
mov r13d, 1
test eax, eax
jnz short loc_312D7
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ma_net_write_buff
mov r13d, eax
loc_312D7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_312F8
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_312F8:
call ___stack_chk_fail
| long long ma_net_write(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rbx
unsigned int v5; // r13d
int v6; // eax
int v7; // eax
__int16 v9; // [rsp+Ch] [rbp-34h] BYREF
char v10; // [rsp+Eh] [rbp-32h]
char v11; // [rsp+Fh] [rbp-31h]
unsigned long long v12; // [rsp+10h] [rbp-30h]
v3 = a3;
v12 = __readfsqword(0x28u);
if ( a3 < 0xFFFFFF )
{
LABEL_6:
v9 = v3;
v10 = BYTE2(v3);
v7 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v7 + 1;
v11 = v7;
v5 = 1;
if ( !(unsigned int)ma_net_write_buff(a1, &v9, 4LL) )
return (unsigned int)ma_net_write_buff(a1, a2, v3);
}
else
{
v5 = 1;
while ( 1 )
{
v9 = -1;
v10 = -1;
v6 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v6 + 1;
v11 = v6;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
break;
a2 += 0xFFFFFFLL;
v3 -= 0xFFFFFFLL;
if ( v3 <= 0xFFFFFE )
goto LABEL_6;
}
}
return v5;
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP RDX,0xffffff
JC 0x00131290
LEA R12,[RBP + -0x34]
MOV R13D,0x1
LAB_00131239:
MOV word ptr [RBP + -0x34],0xffff
MOV byte ptr [RBP + -0x32],0xff
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RBP + -0x31],AL
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x001312fd
TEST EAX,EAX
JNZ 0x001312d7
MOV EDX,0xffffff
MOV RDI,R15
MOV RSI,R14
CALL 0x001312fd
TEST EAX,EAX
JNZ 0x001312d7
ADD R14,0xffffff
ADD RBX,-0xffffff
CMP RBX,0xfffffe
JA 0x00131239
LAB_00131290:
LEA RSI,[RBP + -0x34]
MOV byte ptr [RSI],BL
MOV byte ptr [RBP + -0x33],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RSI + 0x2],AL
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RSI + 0x3],AL
MOV EDX,0x4
MOV RDI,R15
CALL 0x001312fd
MOV R13D,0x1
TEST EAX,EAX
JNZ 0x001312d7
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001312fd
MOV R13D,EAX
LAB_001312d7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001312f8
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001312f8:
CALL 0x00113500
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
int2 local_3c;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (0xfffffe < param_3) {
uVar2 = 1;
do {
local_3c = 0xffff;
local_3a = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
if (iVar1 != 0) goto LAB_001312d7;
iVar1 = ma_net_write_buff(param_1,param_2,0xffffff);
if (iVar1 != 0) goto LAB_001312d7;
param_2 = param_2 + 0xffffff;
param_3 = param_3 - 0xffffff;
} while (0xfffffe < param_3);
}
local_3c = (int2)param_3;
local_3a = (int1)(param_3 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
uVar2 = 1;
if (iVar1 == 0) {
uVar2 = ma_net_write_buff(param_1,param_2,param_3);
}
LAB_001312d7:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,663 | LefDefParser::lefwMacroPinPulldownres(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMacroPinPulldownres(double resistance)
{
lefwObsoleteNum = LEFW_MACRO_PULLDOWNRES;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (versionNum >= 5.4)
return LEFW_OBSOLETE;
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " PULLDOWNRES %.11g ;\n", resistance);
else
fprintf(lefwFile, " PULLDOWNRES %.11g ;\n", resistance);
lefwLines++;
lefwState = LEFW_MACRO;
return LEFW_OK;
} | O3 | cpp | LefDefParser::lefwMacroPinPulldownres(double):
movl $0x30, 0x10923(%rip) # 0x24d48
leaq 0x109d4(%rip), %rax # 0x24e00
movq (%rax), %rdi
testq %rdi, %rdi
je 0x14482
leaq 0x10c19(%rip), %rax # 0x25054
cmpl $0x0, (%rax)
movl $0x2, %eax
je 0x144b2
leaq 0x10c54(%rip), %rcx # 0x250a0
cmpl $0x0, (%rcx)
je 0x144b2
movsd 0x108e7(%rip), %xmm1 # 0x24d40
movl $0x7, %eax
ucomisd 0x4cb2(%rip), %xmm1 # 0x19118
jae 0x144b2
pushq %rax
cmpb $0x1, 0x10c7c(%rip) # 0x250ec
jne 0x14488
leaq 0x7694(%rip), %rsi # 0x1bb0d
movb $0x1, %al
callq 0x18c35
jmp 0x14496
movl $0x1, %eax
retq
leaq 0x767e(%rip), %rsi # 0x1bb0d
movb $0x1, %al
callq 0x10f0
leaq 0x10baf(%rip), %rax # 0x2504c
incl (%rax)
leaq 0x10baa(%rip), %rax # 0x25050
movl $0x21, (%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
| _ZN12LefDefParser23lefwMacroPinPulldownresEd:
mov cs:_ZN12LefDefParserL15lefwObsoleteNumE, 30h ; '0'; LefDefParser::lefwObsoleteNum
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
test rdi, rdi
jz short loc_14482
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
mov eax, 2
jz short locret_144B2
lea rcx, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rcx], 0
jz short locret_144B2
movsd xmm1, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
mov eax, 7
ucomisd xmm1, cs:dbl_19118
jnb short locret_144B2
push rax
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 1; LefDefParser::lefwWriteEncrypt
jnz short loc_14488
lea rsi, aPulldownres11g; " PULLDOWNRES %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_14496
loc_14482:
mov eax, 1
retn
loc_14488:
lea rsi, aPulldownres11g; " PULLDOWNRES %.11g ;\n"
mov al, 1
call _fprintf
loc_14496:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
inc dword ptr [rax]
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
xor eax, eax
add rsp, 8
locret_144B2:
retn
| long long LefDefParser::lefwMacroPinPulldownres(
LefDefParser *this,
double a2,
long long a3,
int a4,
long long a5,
int a6,
int a7)
{
long long result; // rax
LefDefParser::lefwObsoleteNum = 48;
if ( !*(_QWORD *)&LefDefParser::lefwFile )
return 1LL;
result = 2LL;
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
result = 7LL;
if ( *(double *)&LefDefParser::versionNum < 5.4 )
{
if ( LefDefParser::lefwWriteEncrypt == 1 )
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" PULLDOWNRES %.11g ;\n",
a4,
(unsigned int)&LefDefParser::lefwIsMacroPin,
a6,
a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " PULLDOWNRES %.11g ;\n", a2);
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
return 0LL;
}
}
}
return result;
}
| lefwMacroPinPulldownres:
MOV dword ptr [0x00124d48],0x30
LEA RAX,[0x124e00]
MOV RDI,qword ptr [RAX]
TEST RDI,RDI
JZ 0x00114482
LEA RAX,[0x125054]
CMP dword ptr [RAX],0x0
MOV EAX,0x2
JZ 0x001144b2
LEA RCX,[0x1250a0]
CMP dword ptr [RCX],0x0
JZ 0x001144b2
MOVSD XMM1,qword ptr [0x00124d40]
MOV EAX,0x7
UCOMISD XMM1,qword ptr [0x00119118]
JNC 0x001144b2
PUSH RAX
CMP byte ptr [0x001250ec],0x1
JNZ 0x00114488
LEA RSI,[0x11bb0d]
MOV AL,0x1
CALL 0x00118c35
JMP 0x00114496
LAB_00114482:
MOV EAX,0x1
RET
LAB_00114488:
LEA RSI,[0x11bb0d]
MOV AL,0x1
CALL 0x001010f0
LAB_00114496:
LEA RAX,[0x12504c]
INC dword ptr [RAX]
LEA RAX,[0x125050]
MOV dword ptr [RAX],0x21
XOR EAX,EAX
ADD RSP,0x8
LAB_001144b2:
RET
|
/* LefDefParser::lefwMacroPinPulldownres(double) */
int8 LefDefParser::lefwMacroPinPulldownres(double param_1)
{
int8 uVar1;
lefwObsoleteNum = 0x30;
if (lefwFile != (_IO_FILE *)0x0) {
uVar1 = 2;
if ((lefwDidInit != 0) && (lefwIsMacroPin != 0)) {
uVar1 = 7;
if (versionNum < DAT_00119118) {
if (lefwWriteEncrypt == '\x01') {
encPrint(lefwFile," PULLDOWNRES %.11g ;\n");
}
else {
fprintf(lefwFile," PULLDOWNRES %.11g ;\n");
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
uVar1 = 0;
}
}
return uVar1;
}
return 1;
}
| |
23,664 | ma_read | eloqsql/libmariadb/libmariadb/ma_io.c | size_t ma_read(void *ptr, size_t size, size_t nmemb, MA_FILE *file)
{
size_t s= 0;
if (!file)
return -1;
switch (file->type) {
case MA_FILE_LOCAL:
s= fread(ptr, size, nmemb, (FILE *)file->ptr);
return s;
break;
#ifdef HAVE_REMOTEIO
case MA_FILE_REMOTE:
return rio_plugin->methods->mread(ptr, size, nmemb, file);
break;
#endif
default:
return -1;
}
} | O0 | c | ma_read:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x50f21
movq $-0x1, -0x8(%rbp)
jmp 0x50f94
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x1, %eax
je 0x50f3b
jmp 0x50f31
movl -0x34(%rbp), %eax
subl $0x2, %eax
je 0x50f62
jmp 0x50f8c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x14690
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x50f94
leaq 0x31d67(%rip), %rax # 0x82cd0
movq (%rax), %rax
movq 0x58(%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
jmp 0x50f94
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| ma_read:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], 0
cmp [rbp+var_28], 0
jnz short loc_50F21
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_50F94
loc_50F21:
mov rax, [rbp+var_28]
mov eax, [rax]
mov [rbp+var_34], eax
sub eax, 1
jz short loc_50F3B
jmp short $+2
loc_50F31:
mov eax, [rbp+var_34]
sub eax, 2
jz short loc_50F62
jmp short loc_50F8C
loc_50F3B:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rax, [rbp+var_28]
mov rcx, [rax+8]
call _fread
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
jmp short loc_50F94
loc_50F62:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax+18h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call rax
mov [rbp+var_8], rax
jmp short loc_50F94
loc_50F8C:
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
loc_50F94:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long ma_read(long long a1, long long a2, long long a3, long long a4)
{
if ( !a4 )
return -1LL;
if ( *(_DWORD *)a4 == 1 )
return fread(a1, a2, a3, *(_QWORD *)(a4 + 8));
if ( *(_DWORD *)a4 == 2 )
return (*(long long ( **)(long long, long long, long long, long long))(*(_QWORD *)(rio_plugin + 88LL) + 24LL))(
a1,
a2,
a3,
a4);
return -1LL;
}
| ma_read:
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 qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],0x0
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x00150f21
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x00150f94
LAB_00150f21:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
SUB EAX,0x1
JZ 0x00150f3b
JMP 0x00150f31
LAB_00150f31:
MOV EAX,dword ptr [RBP + -0x34]
SUB EAX,0x2
JZ 0x00150f62
JMP 0x00150f8c
LAB_00150f3b:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RAX + 0x8]
CALL 0x00114690
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00150f94
LAB_00150f62:
LEA RAX,[0x182cd0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL RAX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00150f94
LAB_00150f8c:
MOV qword ptr [RBP + -0x8],-0x1
LAB_00150f94:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
size_t ma_read(void *param_1,size_t param_2,size_t param_3,int *param_4)
{
size_t local_10;
if (param_4 == (int *)0x0) {
local_10 = 0xffffffffffffffff;
}
else if (*param_4 == 1) {
local_10 = fread(param_1,param_2,param_3,*(FILE **)(param_4 + 2));
}
else if (*param_4 == 2) {
local_10 = (**(code **)(*(long *)(rio_plugin + 0x58) + 0x18))(param_1,param_2,param_3,param_4);
}
else {
local_10 = 0xffffffffffffffff;
}
return local_10;
}
| |
23,665 | ft_free_stopwords | eloqsql/storage/myisam/ft_stopwords.c | void ft_free_stopwords()
{
DBUG_ENTER("ft_free_stopwords");
if (stopwords3)
{
delete_tree(stopwords3, 0); /* purecov: inspected */
my_free(stopwords3);
stopwords3=0;
}
ft_stopword_file= 0;
DBUG_VOID_RETURN;
} | O3 | c | ft_free_stopwords:
pushq %rbp
movq %rsp, %rbp
movq 0xb8e4e0(%rip), %rdi # 0xbff930
testq %rdi, %rdi
je 0x71473
xorl %esi, %esi
callq 0xa4336
movq 0xb8e4cd(%rip), %rdi # 0xbff930
callq 0x9fbaa
movq $0x0, 0xb8e4bd(%rip) # 0xbff930
leaq 0xb8e4ae(%rip), %rax # 0xbff928
movq $0x0, (%rax)
popq %rbp
retq
nop
| ft_free_stopwords:
push rbp
mov rbp, rsp
mov rdi, cs:stopwords3
test rdi, rdi
jz short loc_71473
xor esi, esi
call delete_tree
mov rdi, cs:stopwords3
call my_free
mov cs:stopwords3, 0
loc_71473:
lea rax, ft_stopword_file
mov qword ptr [rax], 0
pop rbp
retn
| _BYTE **ft_free_stopwords()
{
_BYTE **result; // rax
if ( stopwords3 )
{
delete_tree(stopwords3, 0LL);
my_free(stopwords3);
stopwords3 = 0LL;
}
result = &ft_stopword_file;
ft_stopword_file = 0LL;
return result;
}
| ft_free_stopwords:
PUSH RBP
MOV RBP,RSP
MOV RDI,qword ptr [0x00cff930]
TEST RDI,RDI
JZ 0x00171473
XOR ESI,ESI
CALL 0x001a4336
MOV RDI,qword ptr [0x00cff930]
CALL 0x0019fbaa
MOV qword ptr [0x00cff930],0x0
LAB_00171473:
LEA RAX,[0xcff928]
MOV qword ptr [RAX],0x0
POP RBP
RET
|
void ft_free_stopwords(void)
{
if (stopwords3 != 0) {
delete_tree(stopwords3,0);
my_free(stopwords3);
stopwords3 = 0;
}
ft_stopword_file = 0;
return;
}
| |
23,666 | 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 | monkey531[P]llama/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 0xb2621
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x1b440
movq %rax, %rbx
movq %r14, %rdi
callq 0x5f5fc
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x40a07(%rip), %rsi # 0xf304c
leaq 0x10(%rsp), %rdi
callq 0x86fb9
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x86dea
xorl %ebp, %ebp
leaq 0x798c8(%rip), %rsi # 0x12bf38
leaq -0x56e45(%rip), %rdx # 0x5b832
movq %rbx, %rdi
callq 0x1bf00
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb269d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8c0
testb %bpl, %bpl
jne 0xb26a7
jmp 0xb26af
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b660
movq %r14, %rdi
callq 0x1bf90
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10get_binaryEv:
push rbp; char
push r14; int
push rbx; __int64
sub rsp, 30h
mov r14, rdi
cmp byte ptr [rdi], 8
jnz short loc_B2621
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_B2621:
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_B269D
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B269D:
test bpl, bpl
jnz short loc_B26A7
jmp short loc_B26AF
mov r14, rax
loc_B26A7:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_B26AF:
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 0x001b2621
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_001b2621:
MOV EDI,0x20
CALL 0x0011b440
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015f5fc
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_001b263e:
LEA RSI,[0x1f304c]
LEA RDI,[RSP + 0x10]
CALL 0x00186fb9
MOV BPL,0x1
LAB_001b2652:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x00186dea
XOR EBP,EBP
LEA RSI,[0x22bf38]
LEA RDX,[0x15b832]
MOV RDI,RBX
CALL 0x0011bf00
|
/* 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 001b263e to 001b264e has its CatchHandler @ 001b26a4 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 001b2652 to 001b267e has its CatchHandler @ 001b267f */
_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);
}
| |
23,667 | patricia_to_nibbles | corpus-core[P]colibri-stateless/src/chains/eth/verifier/patricia.c | static uint8_t* patricia_to_nibbles(bytes_t p, bool prefix) {
size_t count = 0;
uint8_t* nibbles = safe_calloc(1 + (p.len << 1), 1);
for (size_t i = 0; i < p.len; i++) {
nibbles[count++] = p.data[i] >> 4;
nibbles[count++] = p.data[i] & 0x0F;
if (prefix && i == 0)
nibbles[0] = nibbles[(count = nibbles[0] & 1 ? 1 : 0)];
}
nibbles[count] = 0xFF;
return nibbles;
} | O0 | c | patricia_to_nibbles:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movl -0x10(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x9dad0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x10(%rbp), %ecx
cmpq %rcx, %rax
jae 0x35cb9
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x20(%rbp)
movb %dl, (%rax,%rcx)
testb $0x1, -0x11(%rbp)
je 0x35ca6
cmpq $0x0, -0x30(%rbp)
jne 0x35ca6
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %esi
andl $0x1, %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
movslq %ecx, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
jmp 0x35ca8
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x35c10
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| patricia_to_nibbles:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, dl
mov [rbp+var_10], edi
mov [rbp+var_8], rsi
and al, 1
mov [rbp+var_11], al
mov [rbp+var_20], 0
mov eax, [rbp+var_10]
shl eax, 1
add eax, 1
mov eax, eax
mov edi, eax
mov esi, 1
call safe_calloc
mov [rbp+var_28], rax
mov [rbp+var_30], 0
loc_35C10:
mov rax, [rbp+var_30]
mov ecx, [rbp+var_10]
cmp rax, rcx
jnb loc_35CB9
mov rax, [rbp+var_8]
mov rcx, [rbp+var_30]
movzx eax, byte ptr [rax+rcx]
sar eax, 4
mov dl, al
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
mov rsi, rcx
add rsi, 1
mov [rbp+var_20], rsi
mov [rax+rcx], dl
mov rax, [rbp+var_8]
mov rcx, [rbp+var_30]
movzx eax, byte ptr [rax+rcx]
and eax, 0Fh
mov dl, al
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
mov rsi, rcx
add rsi, 1
mov [rbp+var_20], rsi
mov [rax+rcx], dl
test [rbp+var_11], 1
jz short loc_35CA6
cmp [rbp+var_30], 0
jnz short loc_35CA6
mov rax, [rbp+var_28]
mov rcx, [rbp+var_28]
movzx esi, byte ptr [rcx]
and esi, 1
xor ecx, ecx
mov edx, 1
cmp esi, 0
cmovnz ecx, edx
movsxd rcx, ecx
mov [rbp+var_20], rcx
mov cl, [rax+rcx]
mov rax, [rbp+var_28]
mov [rax], cl
loc_35CA6:
jmp short $+2
loc_35CA8:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp loc_35C10
loc_35CB9:
mov rax, [rbp+var_28]
mov rcx, [rbp+var_20]
mov byte ptr [rax+rcx], 0FFh
mov rax, [rbp+var_28]
add rsp, 30h
pop rbp
retn
| _BYTE * patricia_to_nibbles(unsigned int a1, long long a2, char a3)
{
long long v3; // rcx
unsigned long long i; // [rsp+0h] [rbp-30h]
_BYTE *v6; // [rsp+8h] [rbp-28h]
long long v7; // [rsp+10h] [rbp-20h]
char v8; // [rsp+1Fh] [rbp-11h]
v8 = a3 & 1;
v7 = 0LL;
v6 = (_BYTE *)safe_calloc(2 * a1 + 1, 1LL);
for ( i = 0LL; i < a1; ++i )
{
v6[v7] = (int)*(unsigned __int8 *)(a2 + i) >> 4;
v3 = v7 + 1;
v7 += 2LL;
v6[v3] = *(_BYTE *)(a2 + i) & 0xF;
if ( (v8 & 1) != 0 && !i )
{
v7 = (*v6 & 1) != 0;
*v6 = v6[v7];
}
}
v6[v7] = -1;
return v6;
}
| patricia_to_nibbles:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,DL
MOV dword ptr [RBP + -0x10],EDI
MOV qword ptr [RBP + -0x8],RSI
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV qword ptr [RBP + -0x20],0x0
MOV EAX,dword ptr [RBP + -0x10]
SHL EAX,0x1
ADD EAX,0x1
MOV EAX,EAX
MOV EDI,EAX
MOV ESI,0x1
CALL 0x0019dad0
MOV qword ptr [RBP + -0x28],RAX
MOV qword ptr [RBP + -0x30],0x0
LAB_00135c10:
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x10]
CMP RAX,RCX
JNC 0x00135cb9
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
SAR EAX,0x4
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x20],RSI
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RBP + -0x30]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
AND EAX,0xf
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV RSI,RCX
ADD RSI,0x1
MOV qword ptr [RBP + -0x20],RSI
MOV byte ptr [RAX + RCX*0x1],DL
TEST byte ptr [RBP + -0x11],0x1
JZ 0x00135ca6
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00135ca6
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ESI,byte ptr [RCX]
AND ESI,0x1
XOR ECX,ECX
MOV EDX,0x1
CMP ESI,0x0
CMOVNZ ECX,EDX
MOVSXD RCX,ECX
MOV qword ptr [RBP + -0x20],RCX
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX],CL
LAB_00135ca6:
JMP 0x00135ca8
LAB_00135ca8:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00135c10
LAB_00135cb9:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + RCX*0x1],0xff
MOV RAX,qword ptr [RBP + -0x28]
ADD RSP,0x30
POP RBP
RET
|
byte * patricia_to_nibbles(uint param_1,long param_2,byte param_3)
{
byte *pbVar1;
long lVar2;
ulong local_38;
long local_28;
local_28 = 0;
pbVar1 = (byte *)safe_calloc(param_1 * 2 + 1,1);
for (local_38 = 0; local_38 < param_1; local_38 = local_38 + 1) {
lVar2 = local_28 + 1;
pbVar1[local_28] = (byte)((int)(uint)*(byte *)(param_2 + local_38) >> 4);
local_28 = local_28 + 2;
pbVar1[lVar2] = *(byte *)(param_2 + local_38) & 0xf;
if (((param_3 & 1) != 0) && (local_38 == 0)) {
local_28 = (long)(int)(uint)((*pbVar1 & 1) != 0);
*pbVar1 = pbVar1[local_28];
}
}
pbVar1[local_28] = 0xff;
return pbVar1;
}
| |
23,668 | js_promise_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_promise_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue executor;
JSValue obj;
JSPromiseData *s;
JSValue args[2], ret;
int i;
executor = argv[0];
if (check_function(ctx, executor))
return JS_EXCEPTION;
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_PROMISE);
if (JS_IsException(obj))
return JS_EXCEPTION;
s = js_mallocz(ctx, sizeof(*s));
if (!s)
goto fail;
s->promise_state = JS_PROMISE_PENDING;
s->is_handled = FALSE;
for(i = 0; i < 2; i++)
init_list_head(&s->promise_reactions[i]);
s->promise_result = JS_UNDEFINED;
JS_SetOpaqueInternal(obj, s);
if (js_create_resolving_functions(ctx, args, obj))
goto fail;
ret = JS_Call(ctx, executor, JS_UNDEFINED, 2, args);
if (JS_IsException(ret)) {
JSValue ret2, error;
error = JS_GetException(ctx);
ret2 = JS_Call(ctx, args[1], JS_UNDEFINED, 1, &error);
JS_FreeValue(ctx, error);
if (JS_IsException(ret2))
goto fail1;
JS_FreeValue(ctx, ret2);
}
JS_FreeValue(ctx, ret);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
return obj;
fail1:
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
} | O0 | c | js_promise_constructor:
subq $0x138, %rsp # imm = 0x138
movq %rsi, 0x118(%rsp)
movq %rdx, 0x120(%rsp)
movq %rdi, 0x110(%rsp)
movl %ecx, 0x10c(%rsp)
movq %r8, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xf0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xf8(%rsp)
movq 0x110(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
callq 0x6da80
cmpl $0x0, %eax
je 0x5444b
movl $0x0, 0x128(%rsp)
movq $0x6, 0x130(%rsp)
jmp 0x54829
movq 0x110(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rdx
movl $0x31, %ecx
callq 0x54e00
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x544d3
movl $0x0, 0x128(%rsp)
movq $0x6, 0x130(%rsp)
jmp 0x54829
movq 0x110(%rsp), %rdi
movl $0x40, %esi
callq 0x21d30
movq %rax, 0xd8(%rsp)
cmpq $0x0, 0xd8(%rsp)
jne 0x544fd
jmp 0x547f5
movq 0xd8(%rsp), %rax
movl $0x0, (%rax)
movq 0xd8(%rsp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, 0x9c(%rsp)
cmpl $0x2, 0x9c(%rsp)
jge 0x54562
movq 0xd8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x9c(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x22390
movl 0x9c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x9c(%rsp)
jmp 0x54525
movq 0xd8(%rsp), %rax
movl $0x0, 0x78(%rsp)
movq $0x3, 0x80(%rsp)
movq 0x78(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x80(%rsp), %rcx
movq %rcx, 0x38(%rax)
movq 0xd8(%rsp), %rdx
movq 0xe0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0x2a9a0
movq 0x110(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
movq 0xe0(%rsp), %rdx
movq 0xe8(%rsp), %rcx
callq 0x92420
cmpl $0x0, %eax
je 0x545df
jmp 0x547f5
movq 0x110(%rsp), %rdi
movl $0x0, 0x58(%rsp)
movq $0x3, 0x60(%rsp)
leaq 0xb0(%rsp), %rax
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %r8
movl $0x2, %r9d
movq %rax, (%rsp)
callq 0x3a050
movq %rax, 0x68(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x54742
movq 0x110(%rsp), %rdi
callq 0x2cf70
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x110(%rsp), %rdi
movl $0x0, 0x8(%rsp)
movq $0x3, 0x10(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movl $0x1, %r9d
leaq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x3a050
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x110(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x23c90
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0x5472b
jmp 0x547bb
movq 0x110(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x23c90
movq 0x110(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
callq 0x23c90
movq 0x110(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x23c90
movq 0x110(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x23c90
movq 0xe0(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x130(%rsp)
jmp 0x54829
movq 0x110(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
callq 0x23c90
movq 0x110(%rsp), %rdi
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
callq 0x23c90
movq 0x110(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
callq 0x23c90
movl $0x0, 0x128(%rsp)
movq $0x6, 0x130(%rsp)
movq 0x128(%rsp), %rax
movq 0x130(%rsp), %rdx
addq $0x138, %rsp # imm = 0x138
retq
nopw %cs:(%rax,%rax)
| js_promise_constructor:
sub rsp, 138h
mov [rsp+138h+var_20], rsi
mov [rsp+138h+var_18], rdx
mov [rsp+138h+var_28], rdi
mov [rsp+138h+var_2C], ecx
mov [rsp+138h+var_38], r8
mov rax, [rsp+138h+var_38]
mov rcx, [rax]
mov [rsp+138h+var_48], rcx
mov rax, [rax+8]
mov [rsp+138h+var_40], rax
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_48]
mov rdx, [rsp+138h+var_40]
call check_function
cmp eax, 0
jz short loc_5444B
mov dword ptr [rsp+138h+var_10], 0
mov [rsp+138h+var_8], 6
jmp loc_54829
loc_5444B:
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_20]
mov rdx, [rsp+138h+var_18]
mov ecx, 31h ; '1'
call js_create_from_ctor
mov [rsp+138h+var_B0], rax
mov [rsp+138h+var_A8], rdx
mov rax, [rsp+138h+var_B0]
mov [rsp+138h+var_58], rax
mov rax, [rsp+138h+var_A8]
mov [rsp+138h+var_50], rax
mov rdi, [rsp+138h+var_58]
mov rsi, [rsp+138h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_544D3
mov dword ptr [rsp+138h+var_10], 0
mov [rsp+138h+var_8], 6
jmp loc_54829
loc_544D3:
mov rdi, [rsp+138h+var_28]
mov esi, 40h ; '@'
call js_mallocz
mov [rsp+138h+var_60], rax
cmp [rsp+138h+var_60], 0
jnz short loc_544FD
jmp loc_547F5
loc_544FD:
mov rax, [rsp+138h+var_60]
mov dword ptr [rax], 0
mov rax, [rsp+138h+var_60]
mov dword ptr [rax+28h], 0
mov [rsp+138h+var_9C], 0
loc_54525:
cmp [rsp+138h+var_9C], 2
jge short loc_54562
mov rdi, [rsp+138h+var_60]
add rdi, 8
movsxd rax, [rsp+138h+var_9C]
shl rax, 4
add rdi, rax
call init_list_head_0
mov eax, [rsp+138h+var_9C]
add eax, 1
mov [rsp+138h+var_9C], eax
jmp short loc_54525
loc_54562:
mov rax, [rsp+138h+var_60]
mov dword ptr [rsp+138h+var_C0], 0
mov [rsp+138h+var_B8], 3
mov rcx, [rsp+138h+var_C0]
mov [rax+30h], rcx
mov rcx, [rsp+138h+var_B8]
mov [rax+38h], rcx
mov rdx, [rsp+138h+var_60]
mov rdi, [rsp+138h+var_58]
mov rsi, [rsp+138h+var_50]
call JS_SetOpaqueInternal
mov rdi, [rsp+138h+var_28]
lea rsi, [rsp+138h+var_88]
mov rdx, [rsp+138h+var_58]
mov rcx, [rsp+138h+var_50]
call js_create_resolving_functions
cmp eax, 0
jz short loc_545DF
jmp loc_547F5
loc_545DF:
mov rdi, [rsp+138h+var_28]
mov dword ptr [rsp+138h+var_E0], 0
mov [rsp+138h+var_D8], 3
lea rax, [rsp+138h+var_88]
mov rsi, [rsp+138h+var_48]
mov rdx, [rsp+138h+var_40]
mov rcx, [rsp+138h+var_E0]
mov r8, [rsp+138h+var_D8]
mov r9d, 2
mov [rsp+138h+var_138], rax
call JS_Call
mov [rsp+138h+var_D0], rax
mov [rsp+138h+var_C8], rdx
mov rax, [rsp+138h+var_D0]
mov [rsp+138h+var_98], rax
mov rax, [rsp+138h+var_C8]
mov [rsp+138h+var_90], rax
mov rdi, [rsp+138h+var_98]
mov rsi, [rsp+138h+var_90]
call JS_IsException_1
cmp eax, 0
jz loc_54742
mov rdi, [rsp+138h+var_28]
call JS_GetException
mov [rsp+138h+var_110], rax
mov [rsp+138h+var_108], rdx
mov rax, [rsp+138h+var_110]
mov [rsp+138h+var_100], rax
mov rax, [rsp+138h+var_108]
mov [rsp+138h+var_F8], rax
mov rdi, [rsp+138h+var_28]
mov dword ptr [rsp+138h+var_130], 0
mov [rsp+138h+var_128], 3
mov rsi, [rsp+138h+var_78]
mov rdx, [rsp+138h+var_70]
mov rcx, [rsp+138h+var_130]
mov r8, [rsp+138h+var_128]
mov r9d, 1
lea rax, [rsp+138h+var_100]
mov [rsp+138h+var_138], rax
call JS_Call
mov [rsp+138h+var_120], rax
mov [rsp+138h+var_118], rdx
mov rax, [rsp+138h+var_120]
mov [rsp+138h+var_F0], rax
mov rax, [rsp+138h+var_118]
mov [rsp+138h+var_E8], rax
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_100]
mov rdx, [rsp+138h+var_F8]
call JS_FreeValue
mov rdi, [rsp+138h+var_F0]
mov rsi, [rsp+138h+var_E8]
call JS_IsException_1
cmp eax, 0
jz short loc_5472B
jmp loc_547BB
loc_5472B:
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_F0]
mov rdx, [rsp+138h+var_E8]
call JS_FreeValue
loc_54742:
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_98]
mov rdx, [rsp+138h+var_90]
call JS_FreeValue
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_88]
mov rdx, [rsp+138h+var_80]
call JS_FreeValue
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_78]
mov rdx, [rsp+138h+var_70]
call JS_FreeValue
mov rax, [rsp+138h+var_58]
mov [rsp+138h+var_10], rax
mov rax, [rsp+138h+var_50]
mov [rsp+138h+var_8], rax
jmp short loc_54829
loc_547BB:
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_88]
mov rdx, [rsp+138h+var_80]
call JS_FreeValue
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_78]
mov rdx, [rsp+138h+var_70]
call JS_FreeValue
loc_547F5:
mov rdi, [rsp+138h+var_28]
mov rsi, [rsp+138h+var_58]
mov rdx, [rsp+138h+var_50]
call JS_FreeValue
mov dword ptr [rsp+138h+var_10], 0
mov [rsp+138h+var_8], 6
loc_54829:
mov rax, [rsp+138h+var_10]
mov rdx, [rsp+138h+var_8]
add rsp, 138h
retn
| long long js_promise_constructor(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v5; // rdx
long long v6; // rax
long long v7; // rdx
long long v8; // rdx
long long v9; // rdx
long long Exception; // [rsp+38h] [rbp-100h] BYREF
long long v12; // [rsp+40h] [rbp-F8h]
long long v13; // [rsp+48h] [rbp-F0h]
long long v14; // [rsp+50h] [rbp-E8h]
long long v15; // [rsp+58h] [rbp-E0h]
long long v16; // [rsp+60h] [rbp-D8h]
long long v17; // [rsp+68h] [rbp-D0h]
long long v18; // [rsp+70h] [rbp-C8h]
long long v19; // [rsp+78h] [rbp-C0h]
long long v20; // [rsp+80h] [rbp-B8h]
long long v21; // [rsp+88h] [rbp-B0h]
long long v22; // [rsp+90h] [rbp-A8h]
int i; // [rsp+9Ch] [rbp-9Ch]
long long v24; // [rsp+A0h] [rbp-98h]
long long v25; // [rsp+A8h] [rbp-90h]
long long v26; // [rsp+B0h] [rbp-88h] BYREF
long long v27; // [rsp+B8h] [rbp-80h]
long long v28; // [rsp+C0h] [rbp-78h]
long long v29; // [rsp+C8h] [rbp-70h]
long long v30; // [rsp+D8h] [rbp-60h]
long long v31; // [rsp+E0h] [rbp-58h]
long long v32; // [rsp+E8h] [rbp-50h]
long long v33; // [rsp+F0h] [rbp-48h]
long long v34; // [rsp+F8h] [rbp-40h]
_QWORD *v35; // [rsp+100h] [rbp-38h]
int v36; // [rsp+10Ch] [rbp-2Ch]
long long v37; // [rsp+110h] [rbp-28h]
long long v38; // [rsp+118h] [rbp-20h]
long long v39; // [rsp+120h] [rbp-18h]
long long v40; // [rsp+128h] [rbp-10h]
long long v41; // [rsp+130h] [rbp-8h]
v38 = a2;
v39 = a3;
v37 = a1;
v36 = a4;
v35 = a5;
v33 = *a5;
v34 = a5[1];
if ( !(unsigned int)check_function(a1, v33, v34) )
{
v21 = js_create_from_ctor(v37, v38, v39, 49LL);
v22 = v5;
v31 = v21;
v32 = v5;
if ( JS_IsException_1(v21, v5) )
{
LODWORD(v40) = 0;
v41 = 6LL;
return v40;
}
v30 = js_mallocz(v37, 0x40uLL);
if ( v30 )
{
*(_DWORD *)v30 = 0;
*(_DWORD *)(v30 + 40) = 0;
for ( i = 0; i < 2; ++i )
init_list_head_0((_QWORD *)(16LL * i + v30 + 8));
v6 = v30;
LODWORD(v19) = 0;
v20 = 3LL;
*(_QWORD *)(v30 + 48) = v19;
*(_QWORD *)(v6 + 56) = v20;
JS_SetOpaqueInternal(v31, v32, v30);
if ( !(unsigned int)js_create_resolving_functions(v37, &v26, v31, v32) )
{
LODWORD(v15) = 0;
v16 = 3LL;
v17 = JS_Call(v37, v33, v34, 0, 3, 2, (long long)&v26);
v18 = v7;
v24 = v17;
v25 = v7;
if ( !JS_IsException_1(v17, v7) )
{
LABEL_13:
JS_FreeValue(v37, v24, v25);
JS_FreeValue(v37, v26, v27);
JS_FreeValue(v37, v28, v29);
v40 = v31;
v41 = v32;
return v40;
}
Exception = JS_GetException(v37);
v12 = v8;
v13 = JS_Call(v37, v28, v29, 0, 3, 1, (long long)&Exception);
v14 = v9;
JS_FreeValue(v37, Exception, v12);
if ( !JS_IsException_1(v13, v14) )
{
JS_FreeValue(v37, v13, v14);
goto LABEL_13;
}
JS_FreeValue(v37, v26, v27);
JS_FreeValue(v37, v28, v29);
}
}
JS_FreeValue(v37, v31, v32);
LODWORD(v40) = 0;
v41 = 6LL;
return v40;
}
LODWORD(v40) = 0;
v41 = 6LL;
return v40;
}
| js_promise_constructor:
SUB RSP,0x138
MOV qword ptr [RSP + 0x118],RSI
MOV qword ptr [RSP + 0x120],RDX
MOV qword ptr [RSP + 0x110],RDI
MOV dword ptr [RSP + 0x10c],ECX
MOV qword ptr [RSP + 0x100],R8
MOV RAX,qword ptr [RSP + 0x100]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RSP + 0xf0],RCX
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0xf8],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
CALL 0x0016da80
CMP EAX,0x0
JZ 0x0015444b
MOV dword ptr [RSP + 0x128],0x0
MOV qword ptr [RSP + 0x130],0x6
JMP 0x00154829
LAB_0015444b:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x118]
MOV RDX,qword ptr [RSP + 0x120]
MOV ECX,0x31
CALL 0x00154e00
MOV qword ptr [RSP + 0x88],RAX
MOV qword ptr [RSP + 0x90],RDX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xe0],RAX
MOV RAX,qword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0xe8],RAX
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001544d3
MOV dword ptr [RSP + 0x128],0x0
MOV qword ptr [RSP + 0x130],0x6
JMP 0x00154829
LAB_001544d3:
MOV RDI,qword ptr [RSP + 0x110]
MOV ESI,0x40
CALL 0x00121d30
MOV qword ptr [RSP + 0xd8],RAX
CMP qword ptr [RSP + 0xd8],0x0
JNZ 0x001544fd
JMP 0x001547f5
LAB_001544fd:
MOV RAX,qword ptr [RSP + 0xd8]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RSP + 0xd8]
MOV dword ptr [RAX + 0x28],0x0
MOV dword ptr [RSP + 0x9c],0x0
LAB_00154525:
CMP dword ptr [RSP + 0x9c],0x2
JGE 0x00154562
MOV RDI,qword ptr [RSP + 0xd8]
ADD RDI,0x8
MOVSXD RAX,dword ptr [RSP + 0x9c]
SHL RAX,0x4
ADD RDI,RAX
CALL 0x00122390
MOV EAX,dword ptr [RSP + 0x9c]
ADD EAX,0x1
MOV dword ptr [RSP + 0x9c],EAX
JMP 0x00154525
LAB_00154562:
MOV RAX,qword ptr [RSP + 0xd8]
MOV dword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x3
MOV RCX,qword ptr [RSP + 0x78]
MOV qword ptr [RAX + 0x30],RCX
MOV RCX,qword ptr [RSP + 0x80]
MOV qword ptr [RAX + 0x38],RCX
MOV RDX,qword ptr [RSP + 0xd8]
MOV RDI,qword ptr [RSP + 0xe0]
MOV RSI,qword ptr [RSP + 0xe8]
CALL 0x0012a9a0
MOV RDI,qword ptr [RSP + 0x110]
LEA RSI,[RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xe0]
MOV RCX,qword ptr [RSP + 0xe8]
CALL 0x00192420
CMP EAX,0x0
JZ 0x001545df
JMP 0x001547f5
LAB_001545df:
MOV RDI,qword ptr [RSP + 0x110]
MOV dword ptr [RSP + 0x58],0x0
MOV qword ptr [RSP + 0x60],0x3
LEA RAX,[RSP + 0xb0]
MOV RSI,qword ptr [RSP + 0xf0]
MOV RDX,qword ptr [RSP + 0xf8]
MOV RCX,qword ptr [RSP + 0x58]
MOV R8,qword ptr [RSP + 0x60]
MOV R9D,0x2
MOV qword ptr [RSP],RAX
CALL 0x0013a050
MOV qword ptr [RSP + 0x68],RAX
MOV qword ptr [RSP + 0x70],RDX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x70]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x00154742
MOV RDI,qword ptr [RSP + 0x110]
CALL 0x0012cf70
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RDX
MOV RAX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x40],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP + 0x10],0x3
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,qword ptr [RSP + 0x10]
MOV R9D,0x1
LEA RAX,[RSP + 0x38]
MOV qword ptr [RSP],RAX
CALL 0x0013a050
MOV qword ptr [RSP + 0x18],RAX
MOV qword ptr [RSP + 0x20],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x48],RAX
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x50],RAX
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x48]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x0015472b
JMP 0x001547bb
LAB_0015472b:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0x48]
MOV RDX,qword ptr [RSP + 0x50]
CALL 0x00123c90
LAB_00154742:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xa0]
MOV RDX,qword ptr [RSP + 0xa8]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0xe0]
MOV qword ptr [RSP + 0x128],RAX
MOV RAX,qword ptr [RSP + 0xe8]
MOV qword ptr [RSP + 0x130],RAX
JMP 0x00154829
LAB_001547bb:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xb0]
MOV RDX,qword ptr [RSP + 0xb8]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xc0]
MOV RDX,qword ptr [RSP + 0xc8]
CALL 0x00123c90
LAB_001547f5:
MOV RDI,qword ptr [RSP + 0x110]
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xe8]
CALL 0x00123c90
MOV dword ptr [RSP + 0x128],0x0
MOV qword ptr [RSP + 0x130],0x6
LAB_00154829:
MOV RAX,qword ptr [RSP + 0x128]
MOV RDX,qword ptr [RSP + 0x130]
ADD RSP,0x138
RET
|
int1 [16]
js_promise_constructor
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 *param_5)
{
int1 auVar1 [16];
int iVar2;
uint uStack_12c;
int1 local_100 [16];
int1 local_f0 [16];
int4 local_e0;
uint uStack_dc;
int8 local_d8;
int1 local_d0 [16];
int4 local_c0;
uint uStack_bc;
int8 local_b8;
int1 local_b0 [16];
int local_9c;
int1 local_98 [16];
int8 local_88;
int8 local_80;
int8 local_78;
int8 local_70;
int4 *local_60;
int1 local_58 [16];
int8 local_48;
int8 local_40;
int8 *local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_48 = *param_5;
local_40 = param_5[1];
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar2 = check_function(param_1,local_48,local_40);
if (iVar2 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_00154829;
}
local_b0 = js_create_from_ctor(local_28,local_20,local_18,0x31);
local_58 = local_b0;
iVar2 = JS_IsException(local_b0._0_8_,local_b0._8_8_);
if (iVar2 != 0) {
local_10 = 0;
local_8 = 6;
goto LAB_00154829;
}
local_60 = (int4 *)js_mallocz(local_28,0x40);
if (local_60 != (int4 *)0x0) {
*local_60 = 0;
local_60[10] = 0;
local_9c = 0;
while( true ) {
if (1 < local_9c) break;
init_list_head(local_60 + (long)local_9c * 4 + 2);
local_9c = local_9c + 1;
}
local_c0 = 0;
local_b8 = 3;
*(ulong *)(local_60 + 0xc) = (ulong)uStack_bc << 0x20;
*(int8 *)(local_60 + 0xe) = 3;
JS_SetOpaqueInternal(local_58._0_8_,local_58._8_8_,local_60);
iVar2 = js_create_resolving_functions(local_28,&local_88,local_58._0_8_,local_58._8_8_);
if (iVar2 == 0) {
local_e0 = 0;
local_d8 = 3;
local_d0 = JS_Call(local_28,local_48,local_40,(ulong)uStack_dc << 0x20,3,2,&local_88);
local_98 = local_d0;
iVar2 = JS_IsException(local_d0._0_8_,local_d0._8_8_);
if (iVar2 != 0) {
local_100 = JS_GetException(local_28);
local_f0 = JS_Call(local_28,local_78,local_70,(ulong)uStack_12c << 0x20,3,1,local_100);
JS_FreeValue(local_28,local_100._0_8_,local_100._8_8_);
iVar2 = JS_IsException(local_f0._0_8_,local_f0._8_8_);
if (iVar2 != 0) {
JS_FreeValue(local_28,local_88,local_80);
JS_FreeValue(local_28,local_78,local_70);
goto LAB_001547f5;
}
JS_FreeValue(local_28,local_f0._0_8_,local_f0._8_8_);
}
JS_FreeValue(local_28,local_98._0_8_,local_98._8_8_);
JS_FreeValue(local_28,local_88,local_80);
JS_FreeValue(local_28,local_78,local_70);
local_10 = local_58._0_4_;
uStack_c = local_58._4_4_;
local_8 = local_58._8_8_;
goto LAB_00154829;
}
}
LAB_001547f5:
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = 0;
local_8 = 6;
LAB_00154829:
auVar1._4_4_ = uStack_c;
auVar1._0_4_ = local_10;
auVar1._8_8_ = local_8;
return auVar1;
}
| |
23,669 | js_promise_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_promise_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue executor;
JSValue obj;
JSPromiseData *s;
JSValue args[2], ret;
int i;
executor = argv[0];
if (check_function(ctx, executor))
return JS_EXCEPTION;
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_PROMISE);
if (JS_IsException(obj))
return JS_EXCEPTION;
s = js_mallocz(ctx, sizeof(*s));
if (!s)
goto fail;
s->promise_state = JS_PROMISE_PENDING;
s->is_handled = FALSE;
for(i = 0; i < 2; i++)
init_list_head(&s->promise_reactions[i]);
s->promise_result = JS_UNDEFINED;
JS_SetOpaqueInternal(obj, s);
if (js_create_resolving_functions(ctx, args, obj))
goto fail;
ret = JS_Call(ctx, executor, JS_UNDEFINED, 2, args);
if (JS_IsException(ret)) {
JSValue ret2, error;
error = JS_GetException(ctx);
ret2 = JS_Call(ctx, args[1], JS_UNDEFINED, 1, &error);
JS_FreeValue(ctx, error);
if (JS_IsException(ret2))
goto fail1;
JS_FreeValue(ctx, ret2);
}
JS_FreeValue(ctx, ret);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
return obj;
fail1:
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
} | O1 | c | js_promise_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%r8), %r13
movq 0x8(%r8), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0x415b1
movl $0x6, %ebx
testl %eax, %eax
jne 0x3675c
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x31, %ecx
callq 0x36d56
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x36775
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %rbx, %rdx
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl $0x40, %esi
movq %r14, %rdi
callq 0xee06
testq %rax, %rax
jne 0x3679b
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1d8c6
jmp 0x3675c
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, 0x28(%rax)
movq %rax, %rcx
addq $0x8, %rcx
movl $0x1, %edx
movq %rcx, (%rcx)
movq %rcx, 0x8(%rcx)
addq $0x10, %rcx
decq %rdx
je 0x367ae
movl $0x0, 0x30(%rax)
movq $0x3, 0x38(%rax)
movq %rax, 0x30(%r12)
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x11821
testl %eax, %eax
jne 0x3678a
movl $0x0, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
movl $0x2, %r9d
callq 0x284ca
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x368f4
movq %rax, 0x58(%rsp)
movq 0x18(%r14), %rax
movups 0xf0(%rax), %xmm0
xorl %ecx, %ecx
movl %ecx, 0xf0(%rax)
movq $0x4, 0xf8(%rax)
leaq 0x60(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl %ecx, 0x40(%rsp)
movq $0x3, 0x48(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movl $0x3, %r8d
movq %r14, %rdi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x284ca
movq %rax, 0x50(%rsp)
movq %rdx, %r13
leaq 0x60(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
movl $0x6, %eax
cmpl $0x6, %r13d
je 0x368e6
movq 0x18(%r14), %rdi
movq 0x50(%rsp), %rsi
movq %r13, %rdx
callq 0x1d8c6
xorl %eax, %eax
cmpl $0x6, %eax
je 0x36944
testl %eax, %eax
movq 0x58(%rsp), %rax
jne 0x3696f
movq 0x18(%r14), %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x1d8c6
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r12, %rcx
andq %rax, %rcx
movl %r12d, %eax
movq %r15, %rbx
jmp 0x36760
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x18(%r14), %rdi
callq 0x1d8c6
jmp 0x3678a
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x36760
| js_promise_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov r13, [r8]
mov rbp, [r8+8]
mov rsi, r13
mov rdx, rbp
call check_function
mov ebx, 6
test eax, eax
jnz short loc_3675C
mov rdi, r14
mov rsi, r12
mov rdx, r15
mov ecx, 31h ; '1'
call js_create_from_ctor
mov r15, rdx
cmp r15d, 6
jnz short loc_36775
loc_3675C:
xor eax, eax
xor ecx, ecx
loc_36760:
or rax, rcx
mov rdx, rbx
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_36775:
mov r12, rax
mov esi, 40h ; '@'
mov rdi, r14
call js_mallocz
test rax, rax
jnz short loc_3679B
loc_3678A:
mov rdi, [r14+18h]
mov rsi, r12
mov rdx, r15
call JS_FreeValueRT
jmp short loc_3675C
loc_3679B:
xor ecx, ecx
mov [rax], ecx
mov [rax+28h], ecx
mov rcx, rax
add rcx, 8
mov edx, 1
loc_367AE:
mov [rcx], rcx
mov [rcx+8], rcx
add rcx, 10h
dec rdx
jz short loc_367AE
mov dword ptr [rax+30h], 0
mov qword ptr [rax+38h], 3
mov [r12+30h], rax
lea rsi, [rsp+0A8h+var_88]
mov rdi, r14
mov rdx, r12
mov rcx, r15
call js_create_resolving_functions
test eax, eax
jnz short loc_3678A
mov dword ptr [rsp+0A8h+var_68], 0
mov qword ptr [rsp+0A8h+var_68+8], 3
movups xmm0, [rsp+0A8h+var_68]
movups [rsp+0A8h+var_A8], xmm0
lea rax, [rsp+0A8h+var_88]
mov [rsp+0A8h+var_98], rax
mov [rsp+0A8h+var_90], 2
mov r8d, 3
mov rdi, r14
mov rsi, r13
mov rdx, rbp
xor ecx, ecx
mov r9d, 2
call JS_CallInternal
mov rbp, rdx
cmp ebp, 6
jnz loc_368F4
mov [rsp+0A8h+var_50], rax
mov rax, [r14+18h]
movups xmm0, xmmword ptr [rax+0F0h]
xor ecx, ecx
mov [rax+0F0h], ecx
mov qword ptr [rax+0F8h], 4
lea rax, [rsp+0A8h+var_48]
movaps xmmword ptr [rax], xmm0
mov rsi, [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_70]
mov dword ptr [rsp+0A8h+var_68], ecx
mov qword ptr [rsp+0A8h+var_68+8], 3
movups xmm0, [rsp+0A8h+var_68]
movups [rsp+0A8h+var_A8], xmm0
mov [rsp+0A8h+var_98], rax
mov [rsp+0A8h+var_90], 2
mov r8d, 3
mov rdi, r14
xor ecx, ecx
mov r9d, 1
call JS_CallInternal
mov [rsp+0A8h+var_58], rax
mov r13, rdx
lea rax, [rsp+0A8h+var_48]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov eax, 6
cmp r13d, 6
jz short loc_368E6
mov rdi, [r14+18h]
mov rsi, [rsp+0A8h+var_58]
mov rdx, r13
call JS_FreeValueRT
xor eax, eax
loc_368E6:
cmp eax, 6
jz short loc_36944
test eax, eax
mov rax, [rsp+0A8h+var_50]
jnz short loc_3696F
loc_368F4:
mov rdi, [r14+18h]
mov rsi, rax
mov rdx, rbp
call JS_FreeValueRT
mov rsi, [rsp+0A8h+var_88]
mov rdx, [rsp+0A8h+var_80]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_70]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rax, 0FFFFFFFF00000000h
mov rcx, r12
and rcx, rax
mov eax, r12d
mov rbx, r15
jmp loc_36760
loc_36944:
mov rsi, [rsp+0A8h+var_88]
mov rdx, [rsp+0A8h+var_80]
mov rdi, [r14+18h]
call JS_FreeValueRT
mov rsi, [rsp+0A8h+var_78]
mov rdx, [rsp+0A8h+var_70]
mov rdi, [r14+18h]
call JS_FreeValueRT
jmp loc_3678A
loc_3696F:
xor eax, eax
xor ecx, ecx
jmp loc_36760
| unsigned long long js_promise_constructor(
_QWORD *a1,
long long a2,
long long a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long *a13)
{
long long v14; // r13
long long v15; // rbp
long long v16; // rax
long long v17; // rdx
long long v18; // r15
long long v19; // rax
unsigned long long v20; // rcx
long long v22; // r12
long long v23; // rax
_QWORD *v24; // rcx
long long v25; // rdx
__m128 v26; // xmm4
__m128 v27; // xmm5
_DWORD *v28; // rax
__m128 v29; // xmm4
__m128 v30; // xmm5
long long v31; // rdx
long long v32; // rbp
long long v33; // rax
__int128 v34; // xmm0
long long v35; // rdx
long long v36; // r13
int v37; // eax
bool v38; // zf
_DWORD *v39; // [rsp+20h] [rbp-88h] BYREF
long long v40; // [rsp+28h] [rbp-80h]
_DWORD *v41; // [rsp+30h] [rbp-78h]
long long v42; // [rsp+38h] [rbp-70h]
__m128 v43; // [rsp+40h] [rbp-68h]
_DWORD *v44; // [rsp+50h] [rbp-58h]
_DWORD *v45; // [rsp+58h] [rbp-50h]
__int128 v46; // [rsp+60h] [rbp-48h] BYREF
v14 = *a13;
v15 = a13[1];
if ( (unsigned int)check_function(a1, *a13, v15) )
goto LABEL_3;
v16 = js_create_from_ctor(a1, a2, a3, 49LL);
v18 = v17;
if ( (_DWORD)v17 == 6 )
goto LABEL_3;
v22 = v16;
v23 = js_mallocz((long long)a1, 0x40uLL);
if ( v23 )
{
*(_DWORD *)v23 = 0;
*(_DWORD *)(v23 + 40) = 0;
v24 = (_QWORD *)(v23 + 8);
v25 = 1LL;
do
{
*v24 = v24;
v24[1] = v24;
v24 += 2;
--v25;
}
while ( !v25 );
*(_DWORD *)(v23 + 48) = 0;
*(_QWORD *)(v23 + 56) = 3LL;
*(_QWORD *)(v22 + 48) = v23;
if ( !(unsigned int)js_create_resolving_functions(a1, &v39, (_DWORD *)v22, v18) )
{
v43.m128_i32[0] = 0;
v43.m128_u64[1] = 3LL;
v28 = (_DWORD *)JS_CallInternal(
(long long)a1,
v14,
v15,
0LL,
3LL,
2LL,
v43,
a5,
a6,
a7,
v26,
v27,
a10,
a11,
0,
3,
(long long)&v39,
2u);
v32 = v31;
if ( (_DWORD)v31 != 6 )
{
LABEL_15:
JS_FreeValueRT(a1[3], v28, v32);
JS_FreeValueRT(a1[3], v39, v40);
JS_FreeValueRT(a1[3], v41, v42);
v20 = v22 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v22;
return v20 | v19;
}
v45 = v28;
v33 = a1[3];
v34 = *(_OWORD *)(v33 + 240);
*(_DWORD *)(v33 + 240) = 0;
*(_QWORD *)(v33 + 248) = 4LL;
v46 = v34;
v43.m128_i32[0] = 0;
v43.m128_u64[1] = 3LL;
v44 = (_DWORD *)JS_CallInternal(
(long long)a1,
(long long)v41,
v42,
0LL,
3LL,
1LL,
v43,
a5,
a6,
a7,
v29,
v30,
a10,
a11,
0,
3,
(long long)&v46,
2u);
v36 = v35;
JS_FreeValueRT(a1[3], (_DWORD *)v46, *((long long *)&v46 + 1));
v37 = 6;
if ( (_DWORD)v36 != 6 )
{
JS_FreeValueRT(a1[3], v44, v36);
v37 = 0;
}
if ( v37 != 6 )
{
v38 = v37 == 0;
v28 = v45;
if ( !v38 )
{
v19 = 0LL;
v20 = 0LL;
return v20 | v19;
}
goto LABEL_15;
}
JS_FreeValueRT(a1[3], v39, v40);
JS_FreeValueRT(a1[3], v41, v42);
}
}
JS_FreeValueRT(a1[3], (_DWORD *)v22, v18);
LABEL_3:
v19 = 0LL;
v20 = 0LL;
return v20 | v19;
}
| |||
23,670 | js_promise_constructor | bluesky950520[P]quickjs/quickjs.c | static JSValue js_promise_constructor(JSContext *ctx, JSValue new_target,
int argc, JSValue *argv)
{
JSValue executor;
JSValue obj;
JSPromiseData *s;
JSValue args[2], ret;
int i;
executor = argv[0];
if (check_function(ctx, executor))
return JS_EXCEPTION;
obj = js_create_from_ctor(ctx, new_target, JS_CLASS_PROMISE);
if (JS_IsException(obj))
return JS_EXCEPTION;
s = js_mallocz(ctx, sizeof(*s));
if (!s)
goto fail;
s->promise_state = JS_PROMISE_PENDING;
s->is_handled = FALSE;
for(i = 0; i < 2; i++)
init_list_head(&s->promise_reactions[i]);
s->promise_result = JS_UNDEFINED;
JS_SetOpaqueInternal(obj, s);
if (js_create_resolving_functions(ctx, args, obj))
goto fail;
ret = JS_Call(ctx, executor, JS_UNDEFINED, 2, args);
if (JS_IsException(ret)) {
JSValue ret2, error;
error = JS_GetException(ctx);
ret2 = JS_Call(ctx, args[1], JS_UNDEFINED, 1, &error);
JS_FreeValue(ctx, error);
if (JS_IsException(ret2))
goto fail1;
JS_FreeValue(ctx, ret2);
}
JS_FreeValue(ctx, ret);
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
return obj;
fail1:
JS_FreeValue(ctx, args[0]);
JS_FreeValue(ctx, args[1]);
fail:
JS_FreeValue(ctx, obj);
return JS_EXCEPTION;
} | O2 | c | js_promise_constructor:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%r8), %r13
movq 0x8(%r8), %rbp
movq %r13, %rsi
movq %rbp, %rdx
callq 0x3949a
pushq $0x6
popq %r14
testl %eax, %eax
jne 0x30002
pushq $0x31
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3045a
movq %rdx, %r15
cmpl $0x6, %r15d
je 0x30002
movq %rax, %r12
pushq $0x40
popq %rsi
movq %rbx, %rdi
callq 0x17241
testq %rax, %rax
je 0x2fff4
andl $0x0, (%rax)
andl $0x0, 0x28(%rax)
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
andl $0x0, 0x30(%rax)
movq $0x3, 0x38(%rax)
movq %rax, 0x30(%r12)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x47340
testl %eax, %eax
je 0x3001b
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1801e
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r14, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
pushq $0x3
popq %r8
pushq $0x2
popq %r9
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x21eb6
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x300f2
movq %rax, 0x38(%rsp)
movq 0x18(%rbx), %rax
movups 0xf0(%rax), %xmm0
andl $0x0, 0xf0(%rax)
movq $0x4, 0xf8(%rax)
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, (%rsp)
pushq $0x3
popq %r8
pushq $0x1
popq %r9
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x21eb6
movq %rax, 0x30(%rsp)
movq %rdx, %r13
leaq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x1801e
cmpl $0x6, %r13d
jne 0x300dd
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
jmp 0x2fff4
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %r13, %rdx
callq 0x1801e
movq 0x38(%rsp), %rax
movq %rbx, %rdi
movq %rax, %rsi
movq %rbp, %rdx
callq 0x1801e
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1801e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %r12, %rcx
andq %rax, %rcx
movl %r12d, %eax
movq %r15, %r14
jmp 0x30006
| js_promise_constructor:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov r13, [r8]
mov rbp, [r8+8]
mov rsi, r13
mov rdx, rbp
call check_function
push 6
pop r14
test eax, eax
jnz loc_30002
push 31h ; '1'
pop rcx
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call js_create_from_ctor
mov r15, rdx
cmp r15d, 6
jz short loc_30002
mov r12, rax
push 40h ; '@'
pop rsi
mov rdi, rbx
call js_mallocz
test rax, rax
jz short loc_2FFF4
and dword ptr [rax], 0
and dword ptr [rax+28h], 0
lea rcx, [rax+8]
mov [rax+8], rcx
mov [rax+10h], rcx
mov rcx, rax
add rcx, 18h
mov [rax+18h], rcx
mov [rax+20h], rcx
and dword ptr [rax+30h], 0
mov qword ptr [rax+38h], 3
mov [r12+30h], rax
lea rsi, [rsp+88h+var_78]
mov rdi, rbx
mov rdx, r12
mov rcx, r15
call js_create_resolving_functions
test eax, eax
jz short loc_3001B
loc_2FFF4:
mov rdi, rbx
mov rsi, r12
mov rdx, r15
call JS_FreeValue
loc_30002:
xor eax, eax
xor ecx, ecx
loc_30006:
or rax, rcx
mov rdx, r14
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3001B:
lea rax, [rsp+88h+var_78]
mov [rsp+88h+var_88], rax
push 3
pop r8
push 2
pop r9
mov rdi, rbx
mov rsi, r13
mov rdx, rbp
xor ecx, ecx
call JS_Call
mov rbp, rdx
cmp ebp, 6
jnz loc_300F2
mov [rsp+88h+var_50], rax
mov rax, [rbx+18h]
movups xmm0, xmmword ptr [rax+0F0h]
and dword ptr [rax+0F0h], 0
mov qword ptr [rax+0F8h], 4
lea rax, [rsp+88h+var_48]
movaps xmmword ptr [rax], xmm0
mov rsi, [rsp+88h+var_68]
mov rdx, [rsp+88h+var_60]
mov [rsp+88h+var_88], rax
push 3
pop r8
push 1
pop r9
mov rdi, rbx
xor ecx, ecx
call JS_Call
mov [rsp+88h+var_58], rax
mov r13, rdx
lea rax, [rsp+88h+var_48]
mov rsi, [rax]
mov rdx, [rax+8]
mov rdi, rbx
call JS_FreeValue
cmp r13d, 6
jnz short loc_300DD
mov rsi, [rsp+88h+var_78]
mov rdx, [rsp+88h+var_70]
mov rdi, rbx
call JS_FreeValue
mov rsi, [rsp+88h+var_68]
mov rdx, [rsp+88h+var_60]
mov rdi, rbx
call JS_FreeValue
jmp loc_2FFF4
loc_300DD:
mov rdi, rbx
mov rsi, [rsp+88h+var_58]
mov rdx, r13
call JS_FreeValue
mov rax, [rsp+88h+var_50]
loc_300F2:
mov rdi, rbx
mov rsi, rax
mov rdx, rbp
call JS_FreeValue
mov rsi, [rsp+88h+var_78]
mov rdx, [rsp+88h+var_70]
mov rdi, rbx
call JS_FreeValue
mov rsi, [rsp+88h+var_68]
mov rdx, [rsp+88h+var_60]
mov rdi, rbx
call JS_FreeValue
mov rax, 0FFFFFFFF00000000h
mov rcx, r12
and rcx, rax
mov eax, r12d
mov r14, r15
jmp loc_30006
| unsigned long long js_promise_constructor(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v6; // r13
long long v7; // rbp
long long v8; // rax
long long v9; // rdx
long long v10; // r15
long long v11; // r12
long long v12; // rax
long long v13; // rax
unsigned long long v14; // rcx
long long v16; // rax
long long v17; // rdx
long long v18; // rbp
long long v19; // rax
__int128 v20; // xmm0
long long v21; // rdx
long long v22; // r13
long long v23; // [rsp+10h] [rbp-78h] BYREF
long long v24; // [rsp+18h] [rbp-70h]
long long v25; // [rsp+20h] [rbp-68h]
long long v26; // [rsp+28h] [rbp-60h]
long long v27; // [rsp+30h] [rbp-58h]
long long v28; // [rsp+38h] [rbp-50h]
__int128 v29; // [rsp+40h] [rbp-48h] BYREF
v6 = *a5;
v7 = a5[1];
if ( (unsigned int)check_function(a1, *a5, v7) )
goto LABEL_6;
v8 = js_create_from_ctor(a1, a2, a3, 49LL);
v10 = v9;
if ( (_DWORD)v9 == 6 )
goto LABEL_6;
v11 = v8;
v12 = js_mallocz(a1, 0x40uLL);
if ( v12 )
{
*(_DWORD *)v12 = 0;
*(_DWORD *)(v12 + 40) = 0;
*(_QWORD *)(v12 + 8) = v12 + 8;
*(_QWORD *)(v12 + 16) = v12 + 8;
*(_QWORD *)(v12 + 24) = v12 + 24;
*(_QWORD *)(v12 + 32) = v12 + 24;
*(_DWORD *)(v12 + 48) = 0;
*(_QWORD *)(v12 + 56) = 3LL;
*(_QWORD *)(v11 + 48) = v12;
if ( !(unsigned int)js_create_resolving_functions(a1, &v23, v11, v10) )
{
v16 = JS_Call(a1, v6, v7, 0, 3, 2, (long long)&v23);
v18 = v17;
if ( (_DWORD)v17 == 6 )
{
v28 = v16;
v19 = *(_QWORD *)(a1 + 24);
v20 = *(_OWORD *)(v19 + 240);
*(_DWORD *)(v19 + 240) = 0;
*(_QWORD *)(v19 + 248) = 4LL;
v29 = v20;
v27 = JS_Call(a1, v25, v26, 0, 3, 1, (long long)&v29);
v22 = v21;
JS_FreeValue(a1, v29, *((long long *)&v29 + 1));
if ( (_DWORD)v22 == 6 )
{
JS_FreeValue(a1, v23, v24);
JS_FreeValue(a1, v25, v26);
goto LABEL_5;
}
JS_FreeValue(a1, v27, v22);
v16 = v28;
}
JS_FreeValue(a1, v16, v18);
JS_FreeValue(a1, v23, v24);
JS_FreeValue(a1, v25, v26);
v14 = v11 & 0xFFFFFFFF00000000LL;
v13 = (unsigned int)v11;
return v14 | v13;
}
}
LABEL_5:
JS_FreeValue(a1, v11, v10);
LABEL_6:
v13 = 0LL;
v14 = 0LL;
return v14 | v13;
}
| js_promise_constructor:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV R13,qword ptr [R8]
MOV RBP,qword ptr [R8 + 0x8]
MOV RSI,R13
MOV RDX,RBP
CALL 0x0013949a
PUSH 0x6
POP R14
TEST EAX,EAX
JNZ 0x00130002
PUSH 0x31
POP RCX
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL 0x0013045a
MOV R15,RDX
CMP R15D,0x6
JZ 0x00130002
MOV R12,RAX
PUSH 0x40
POP RSI
MOV RDI,RBX
CALL 0x00117241
TEST RAX,RAX
JZ 0x0012fff4
AND dword ptr [RAX],0x0
AND dword ptr [RAX + 0x28],0x0
LEA RCX,[RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RAX + 0x10],RCX
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],RCX
AND dword ptr [RAX + 0x30],0x0
MOV qword ptr [RAX + 0x38],0x3
MOV qword ptr [R12 + 0x30],RAX
LEA RSI,[RSP + 0x10]
MOV RDI,RBX
MOV RDX,R12
MOV RCX,R15
CALL 0x00147340
TEST EAX,EAX
JZ 0x0013001b
LAB_0012fff4:
MOV RDI,RBX
MOV RSI,R12
MOV RDX,R15
CALL 0x0011801e
LAB_00130002:
XOR EAX,EAX
XOR ECX,ECX
LAB_00130006:
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013001b:
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
PUSH 0x3
POP R8
PUSH 0x2
POP R9
MOV RDI,RBX
MOV RSI,R13
MOV RDX,RBP
XOR ECX,ECX
CALL 0x00121eb6
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x001300f2
MOV qword ptr [RSP + 0x38],RAX
MOV RAX,qword ptr [RBX + 0x18]
MOVUPS XMM0,xmmword ptr [RAX + 0xf0]
AND dword ptr [RAX + 0xf0],0x0
MOV qword ptr [RAX + 0xf8],0x4
LEA RAX,[RSP + 0x40]
MOVAPS xmmword ptr [RAX],XMM0
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV qword ptr [RSP],RAX
PUSH 0x3
POP R8
PUSH 0x1
POP R9
MOV RDI,RBX
XOR ECX,ECX
CALL 0x00121eb6
MOV qword ptr [RSP + 0x30],RAX
MOV R13,RDX
LEA RAX,[RSP + 0x40]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
MOV RDI,RBX
CALL 0x0011801e
CMP R13D,0x6
JNZ 0x001300dd
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RDI,RBX
CALL 0x0011801e
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,RBX
CALL 0x0011801e
JMP 0x0012fff4
LAB_001300dd:
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x30]
MOV RDX,R13
CALL 0x0011801e
MOV RAX,qword ptr [RSP + 0x38]
LAB_001300f2:
MOV RDI,RBX
MOV RSI,RAX
MOV RDX,RBP
CALL 0x0011801e
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x18]
MOV RDI,RBX
CALL 0x0011801e
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
MOV RDI,RBX
CALL 0x0011801e
MOV RAX,-0x100000000
MOV RCX,R12
AND RCX,RAX
MOV EAX,R12D
MOV R14,R15
JMP 0x00130006
|
int1 [16]
js_promise_constructor
(long param_1,int8 param_2,int8 param_3,int8 param_4,int8 *param_5
)
{
int8 uVar1;
long lVar2;
int iVar3;
int4 *puVar4;
ulong uVar5;
int8 uVar6;
ulong uVar7;
int8 uVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 local_58;
int8 local_50;
int4 local_48;
int4 uStack_44;
int4 uStack_40;
int4 uStack_3c;
uVar6 = *param_5;
uVar1 = param_5[1];
iVar3 = check_function(param_1,uVar6,uVar1);
if (iVar3 == 0) {
auVar9 = js_create_from_ctor(param_1,param_2,param_3,0x31);
uVar8 = auVar9._8_8_;
uVar5 = auVar9._0_8_;
if (auVar9._8_4_ != 6) {
puVar4 = (int4 *)js_mallocz(param_1,0x40);
if (puVar4 != (int4 *)0x0) {
*puVar4 = 0;
puVar4[10] = 0;
*(int4 **)(puVar4 + 2) = puVar4 + 2;
*(int4 **)(puVar4 + 4) = puVar4 + 2;
*(int4 **)(puVar4 + 6) = puVar4 + 6;
*(int4 **)(puVar4 + 8) = puVar4 + 6;
puVar4[0xc] = 0;
*(int8 *)(puVar4 + 0xe) = 3;
*(int4 **)(uVar5 + 0x30) = puVar4;
iVar3 = js_create_resolving_functions(param_1,&local_78,uVar5,uVar8);
if (iVar3 == 0) {
auVar9 = JS_Call(param_1,uVar6,uVar1,0,3,2,&local_78);
uVar6 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
lVar2 = *(long *)(param_1 + 0x18);
local_48 = *(int4 *)(lVar2 + 0xf0);
uStack_44 = *(int4 *)(lVar2 + 0xf4);
uStack_40 = *(int4 *)(lVar2 + 0xf8);
uStack_3c = *(int4 *)(lVar2 + 0xfc);
*(int4 *)(lVar2 + 0xf0) = 0;
*(int8 *)(lVar2 + 0xf8) = 4;
local_50 = auVar9._0_8_;
auVar10 = JS_Call(param_1,local_68,local_60,0,3,1,&local_48);
local_58 = auVar10._0_8_;
JS_FreeValue(param_1,CONCAT44(uStack_44,local_48),CONCAT44(uStack_3c,uStack_40));
if (auVar10._8_4_ == 6) {
JS_FreeValue(param_1,local_78,local_70);
JS_FreeValue(param_1,local_68,local_60);
goto LAB_0012fff4;
}
JS_FreeValue(param_1,local_58,auVar10._8_8_);
uVar6 = local_50;
}
JS_FreeValue(param_1,uVar6,auVar9._8_8_);
JS_FreeValue(param_1,local_78,local_70);
JS_FreeValue(param_1,local_68,local_60);
uVar7 = uVar5 & 0xffffffff00000000;
uVar5 = uVar5 & 0xffffffff;
goto LAB_00130006;
}
}
LAB_0012fff4:
JS_FreeValue(param_1,uVar5,uVar8);
}
}
uVar5 = 0;
uVar7 = 0;
uVar8 = 6;
LAB_00130006:
auVar9._0_8_ = uVar5 | uVar7;
auVar9._8_8_ = uVar8;
return auVar9;
}
| |
23,671 | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&) | monkey531[P]llama/common/minja.hpp | static void destructuring_assign(const std::vector<std::string> & var_names, const std::shared_ptr<Context> & context, Value& item) {
if (var_names.size() == 1) {
Value name(var_names[0]);
context->set(name, item);
} else {
if (!item.is_array() || item.size() != var_names.size()) {
throw std::runtime_error("Mismatched number of variables and items in destructuring assignment");
}
for (size_t i = 0; i < var_names.size(); ++i) {
context->set(var_names[i], item.at(i));
}
}
} | O0 | cpp | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&):
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x100(%rsp), %rdi
callq 0x6bc00
cmpq $0x1, %rax
jne 0x1067fc
movq 0x100(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6bc20
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x12a5b0
movq 0xf8(%rsp), %rdi
callq 0x13bf40
movq 0x30(%rsp), %rsi
movq %rax, %rdi
movq 0xf0(%rsp), %rdx
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
jmp 0x1067c4
leaq 0xa0(%rsp), %rdi
callq 0x122e40
jmp 0x10697f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x122e40
jmp 0x106987
movq 0xf0(%rsp), %rdi
callq 0x124eb0
testb $0x1, %al
jne 0x10680f
jmp 0x10683b
movq 0xf0(%rsp), %rdi
callq 0x13bbc0
movq %rax, 0x28(%rsp)
movq 0x100(%rsp), %rdi
callq 0x6bc00
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
je 0x106899
movl $0x10, %edi
callq 0x5e6b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
leaq 0x119f08(%rip), %rsi # 0x22075f
callq 0x5e490
jmp 0x10685e
movq 0x20(%rsp), %rdi
movq 0x1ac746(%rip), %rsi # 0x2b2fb0
movq 0x1ac707(%rip), %rdx # 0x2b2f78
callq 0x5eb30
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x5efd0
jmp 0x106987
movq $0x0, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x100(%rsp), %rdi
callq 0x6bc00
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x10697d
movq 0xf8(%rsp), %rdi
callq 0x13bf40
movq %rax, 0x8(%rsp)
movq 0x100(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x6bc20
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x12a5b0
movq 0xf0(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x13bd70
movq %rax, 0x10(%rsp)
jmp 0x106920
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq 0x38(%rsp), %rsi
callq *%rax
jmp 0x10693a
leaq 0x38(%rsp), %rdi
callq 0x122e40
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
jmp 0x1068a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x122e40
jmp 0x106987
jmp 0x10697f
addq $0x108, %rsp # imm = 0x108
retq
movq 0x98(%rsp), %rdi
callq 0x5ebf0
nopw %cs:(%rax,%rax)
| _ZN5minjaL20destructuring_assignERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EERKSt10shared_ptrINS_7ContextEERNS_5ValueE:
sub rsp, 108h
mov [rsp+108h+var_8], rdi
mov [rsp+108h+var_10], rsi
mov [rsp+108h+var_18], rdx
mov rdi, [rsp+108h+var_8]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
cmp rax, 1
jnz loc_1067FC
mov rdi, [rsp+108h+var_8]
xor eax, eax
mov esi, eax
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
lea rdi, [rsp+108h+var_68]
mov [rsp+108h+var_D8], rdi
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rsp+108h+var_10]
call _ZNKSt19__shared_ptr_accessIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov rsi, [rsp+108h+var_D8]
mov rdi, rax
mov rdx, [rsp+108h+var_18]
mov rax, [rdi]
mov rax, [rax+28h]
call rax
jmp short $+2
loc_1067C4:
lea rdi, [rsp+108h+var_68]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_10697F
mov rcx, rax
mov eax, edx
mov [rsp+108h+var_70], rcx
mov [rsp+108h+var_74], eax
lea rdi, [rsp+108h+var_68]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp loc_106987
loc_1067FC:
mov rdi, [rsp+108h+var_18]; this
call _ZNK5minja5Value8is_arrayEv; minja::Value::is_array(void)
test al, 1
jnz short loc_10680F
jmp short loc_10683B
loc_10680F:
mov rdi, [rsp+108h+var_18]; this
call _ZNK5minja5Value4sizeEv; minja::Value::size(void)
mov [rsp+108h+var_E0], rax
mov rdi, [rsp+108h+var_8]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+108h+var_E0]
cmp rax, rcx
jz short loc_106899
loc_10683B:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+108h+var_E8], rax
lea rsi, aMismatchedNumb; "Mismatched number of variables and item"...
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_10685E:
mov rdi, [rsp+108h+var_E8]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+108h+var_E8]; void *
mov rcx, rax
mov eax, edx
mov [rsp+108h+var_70], rcx
mov [rsp+108h+var_74], eax
call ___cxa_free_exception
jmp loc_106987
loc_106899:
mov [rsp+108h+var_80], 0
loc_1068A5:
mov rax, [rsp+108h+var_80]
mov [rsp+108h+var_F0], rax
mov rdi, [rsp+108h+var_8]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE4sizeEv; std::vector<std::string>::size(void)
mov rcx, rax
mov rax, [rsp+108h+var_F0]
cmp rax, rcx
jnb loc_10697D
mov rdi, [rsp+108h+var_10]
call _ZNKSt19__shared_ptr_accessIN5minja7ContextELN9__gnu_cxx12_Lock_policyE2ELb0ELb0EEptEv; std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(void)
mov [rsp+108h+var_100], rax
mov rdi, [rsp+108h+var_8]
mov rsi, [rsp+108h+var_80]
call _ZNKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EEixEm; std::vector<std::string>::operator[](ulong)
mov rsi, rax
lea rdi, [rsp+108h+var_D0]
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rsp+108h+var_18]; this
mov rsi, [rsp+108h+var_80]; unsigned __int64
call _ZN5minja5Value2atEm; minja::Value::at(ulong)
mov [rsp+108h+var_F8], rax
jmp short $+2
loc_106920:
mov rdx, [rsp+108h+var_F8]
mov rdi, [rsp+108h+var_100]
mov rax, [rdi]
mov rax, [rax+28h]
lea rsi, [rsp+108h+var_D0]
call rax
jmp short $+2
loc_10693A:
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
mov rax, [rsp+108h+var_80]
add rax, 1
mov [rsp+108h+var_80], rax
jmp loc_1068A5
mov rcx, rax
mov eax, edx
mov [rsp+108h+var_70], rcx
mov [rsp+108h+var_74], eax
lea rdi, [rsp+108h+var_D0]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
jmp short loc_106987
loc_10697D:
jmp short $+2
loc_10697F:
add rsp, 108h
retn
loc_106987:
mov rdi, [rsp+108h+var_70]
call __Unwind_Resume
| void minja::destructuring_assign(_QWORD *a1, long long a2, minja::Value *a3)
{
int v3; // eax
int v4; // edx
int v5; // ecx
int v6; // r8d
int v7; // r9d
long long v8; // rax
int v9; // eax
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
long long v14; // [rsp+8h] [rbp-100h]
long long v15; // [rsp+10h] [rbp-F8h]
unsigned long long v16; // [rsp+18h] [rbp-F0h]
std::runtime_error *exception; // [rsp+20h] [rbp-E8h]
long long v18; // [rsp+28h] [rbp-E0h]
_BYTE v19[80]; // [rsp+38h] [rbp-D0h] BYREF
unsigned long long i; // [rsp+88h] [rbp-80h]
_BYTE v21[80]; // [rsp+A0h] [rbp-68h] BYREF
minja::Value *v22; // [rsp+F0h] [rbp-18h]
long long v23; // [rsp+F8h] [rbp-10h]
_QWORD *v24; // [rsp+100h] [rbp-8h]
v24 = a1;
v23 = a2;
v22 = a3;
if ( std::vector<std::string>::size(a1) == 1 )
{
v3 = std::vector<std::string>::operator[](v24, 0LL);
minja::Value::Value((unsigned int)v21, v3, v4, v5, v6, v7);
v8 = std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v23);
(*(void ( **)(long long, _BYTE *, minja::Value *))(*(_QWORD *)v8 + 40LL))(v8, v21, v22);
minja::Value::~Value((minja::Value *)v21);
}
else
{
if ( (minja::Value::is_array(v22) & 1) == 0
|| (v18 = minja::Value::size(v22), v18 != std::vector<std::string>::size(v24)) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(
exception,
"Mismatched number of variables and items in destructuring assignment");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
for ( i = 0LL; ; ++i )
{
v16 = i;
if ( v16 >= std::vector<std::string>::size(v24) )
break;
v14 = std::__shared_ptr_access<minja::Context,(__gnu_cxx::_Lock_policy)2,false,false>::operator->(v23);
v9 = std::vector<std::string>::operator[](v24, i);
minja::Value::Value((unsigned int)v19, v9, v10, v11, v12, v13);
v15 = minja::Value::at(v22, i);
(*(void ( **)(long long, _BYTE *, long long))(*(_QWORD *)v14 + 40LL))(v14, v19, v15);
minja::Value::~Value((minja::Value *)v19);
}
}
}
| |||
23,672 | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&) | monkey531[P]llama/common/minja.hpp | static void destructuring_assign(const std::vector<std::string> & var_names, const std::shared_ptr<Context> & context, Value& item) {
if (var_names.size() == 1) {
Value name(var_names[0]);
context->set(name, item);
} else {
if (!item.is_array() || item.size() != var_names.size()) {
throw std::runtime_error("Mismatched number of variables and items in destructuring assignment");
}
for (size_t i = 0; i < var_names.size(); ++i) {
context->set(var_names[i], item.at(i));
}
}
} | O3 | cpp | minja::destructuring_assign(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::shared_ptr<minja::Context> const&, minja::Value&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdi), %rsi
movq 0x8(%rdi), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x7dbaf
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x8fdec
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r12, %rdx
callq *0x28(%rax)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6b800
movq %rbx, %rdi
callq 0x70bac
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7db65
callq 0x33c02
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7db74
callq 0x33c02
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7db83
callq 0x33c02
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7dcd1
movq 0xb33e8(%rip), %rax # 0x130f80
cmpb $0x0, (%rax)
je 0x7dcbc
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x7dcc6
movq %rbx, (%rsp)
cmpq $0x0, 0x10(%r12)
je 0x7dce0
movq %rdi, %r15
movq %r12, %rdi
callq 0x95e36
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rax
jne 0x7dce0
cmpq %rsi, %rcx
je 0x7dcd1
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
xorl %ebp, %ebp
movq (%rsp), %rax
movq (%rax), %r14
addq %rbx, %rsi
movq %r13, %rdi
callq 0x8fdec
movq %r12, %rdi
movq %rbp, %rsi
callq 0x95f96
movq (%r14), %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq *0x28(%rcx)
leaq 0x48(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x6b800
movq %r14, %rdi
callq 0x70bac
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7dc48
callq 0x33c02
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x7dc57
callq 0x33c02
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x7dc66
callq 0x33c02
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7dc9c
movq 0xb3309(%rip), %rax # 0x130f80
cmpb $0x0, (%rax)
je 0x7dc87
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x7dc91
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x7dc9c
movq (%rdi), %rax
callq *0x18(%rax)
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbx
cmpq %rax, %rbp
jb 0x7dbf6
jmp 0x7dcd1
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x7dcd1
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1b450
movq %rax, %r14
leaq 0x7805c(%rip), %rsi # 0xf5d50
movq %rax, %rdi
callq 0x1b330
movq 0xb32e5(%rip), %rsi # 0x130fe8
movq 0xb324e(%rip), %rdx # 0x130f58
movq %r14, %rdi
callq 0x1bf60
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b690
jmp 0x7dd2e
jmp 0x7dd21
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8bd8e
movq %rbx, %rdi
callq 0x1bff0
| _ZN5minjaL20destructuring_assignERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EERKSt10shared_ptrINS_7ContextEERNS_5ValueE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov r12, rdx
mov rbx, rsi
mov rsi, [rdi]
mov rax, [rdi+8]
sub rax, rsi
cmp rax, 20h ; ' '
jnz loc_7DBAF
lea r14, [rsp+88h+var_80]
mov rdi, r14
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, [rbx]
mov rax, [rdi]
mov rsi, r14
mov rdx, r12
call qword ptr [rax+28h]
lea rbx, [rsp+88h+var_40]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_7DB65
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB65:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_7DB74
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB74:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_7DB83
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB83:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz loc_7DCD1
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz loc_7DCBC
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp loc_7DCC6
loc_7DBAF:
mov [rsp+88h+var_88], rbx
cmp qword ptr [r12+10h], 0
jz loc_7DCE0
mov r15, rdi
mov rdi, r12; this
call _ZNK5minja5Value4sizeEv; minja::Value::size(void)
mov rsi, [r15]
mov rcx, [r15+8]
mov rdx, rcx
sub rdx, rsi
sar rdx, 5
cmp rax, rdx
jnz loc_7DCE0
cmp rcx, rsi
jz loc_7DCD1
xor ebx, ebx
lea r13, [rsp+88h+var_80]
xor ebp, ebp
loc_7DBF6:
mov rax, [rsp+88h+var_88]
mov r14, [rax]
add rsi, rbx
mov rdi, r13
call _ZN5minja5ValueC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; minja::Value::Value(std::string const&)
mov rdi, r12; this
mov rsi, rbp; unsigned __int64
call _ZN5minja5Value2atEm; minja::Value::at(ulong)
mov rcx, [r14]
mov rdi, r14
mov rsi, r13
mov rdx, rax
call qword ptr [rcx+28h]
lea r14, [rsp+88h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+88h+var_48]
test rdi, rdi
jz short loc_7DC48
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DC48:
mov rdi, [rsp+88h+var_58]
test rdi, rdi
jz short loc_7DC57
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DC57:
mov rdi, [rsp+88h+var_68]
test rdi, rdi
jz short loc_7DC66
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DC66:
mov rdi, [rsp+88h+var_78]
test rdi, rdi
jz short loc_7DC9C
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_7DC87
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_7DC91
loc_7DC87:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_7DC91:
cmp eax, 1
jnz short loc_7DC9C
mov rax, [rdi]
call qword ptr [rax+18h]
loc_7DC9C:
inc rbp
mov rsi, [r15]
mov rax, [r15+8]
sub rax, rsi
sar rax, 5
add rbx, 20h ; ' '
cmp rbp, rax
jb loc_7DBF6
jmp short loc_7DCD1
loc_7DCBC:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_7DCC6:
cmp eax, 1
jnz short loc_7DCD1
mov rax, [rdi]
call qword ptr [rax+18h]
loc_7DCD1:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7DCE0:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aMismatchedNumb; "Mismatched number of variables and item"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7DD2E
jmp short $+2
loc_7DD21:
mov rbx, rax
lea rdi, [rsp+88h+var_80]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_7DD2E:
mov rdi, rbx
call __Unwind_Resume
| unsigned long long minja::destructuring_assign(_QWORD *a1, _QWORD *a2, minja::Value *a3)
{
unsigned long long result; // rax
long long v5; // rdi
long long v7; // rsi
long long v8; // rbx
unsigned long long v9; // rbp
long long v10; // r14
long long v11; // rax
long long v12; // rdi
signed __int32 v13; // eax
std::runtime_error *exception; // r14
_BYTE v16[8]; // [rsp+8h] [rbp-80h] BYREF
long long v17; // [rsp+10h] [rbp-78h]
volatile signed __int32 *v18; // [rsp+20h] [rbp-68h]
volatile signed __int32 *v19; // [rsp+30h] [rbp-58h]
volatile signed __int32 *v20; // [rsp+40h] [rbp-48h]
char v21[64]; // [rsp+48h] [rbp-40h] BYREF
if ( a1[1] - *a1 == 32LL )
{
minja::Value::Value(v16, *a1);
(*(void ( **)(_QWORD, _BYTE *, minja::Value *))(*(_QWORD *)*a2 + 40LL))(*a2, v16, a3);
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(v21);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v21);
if ( v20 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
if ( v18 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
v5 = v17;
if ( v17 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v17 + 12);
*(_DWORD *)(v17 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v17 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)v5 + 24LL))(v5, 0LL);
}
}
else
{
if ( !*((_QWORD *)a3 + 2) || (result = minja::Value::size(a3), v7 = *a1, result != (long long)(a1[1] - *a1) >> 5) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(
exception,
"Mismatched number of variables and items in destructuring assignment");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( a1[1] != v7 )
{
v8 = 0LL;
v9 = 0LL;
do
{
v10 = *a2;
minja::Value::Value(v16, v8 + v7);
v11 = minja::Value::at(a3, v9);
(*(void ( **)(long long, _BYTE *, long long))(*(_QWORD *)v10 + 40LL))(v10, v16, v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(v21);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v21);
if ( v20 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
if ( v18 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v18);
v12 = v17;
if ( v17 )
{
if ( _libc_single_threaded )
{
v13 = *(_DWORD *)(v17 + 12);
*(_DWORD *)(v17 + 12) = v13 - 1;
}
else
{
v13 = _InterlockedExchangeAdd((volatile signed __int32 *)(v17 + 12), 0xFFFFFFFF);
}
if ( v13 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v12 + 24LL))(v12, 0LL);
}
++v9;
v7 = *a1;
result = (long long)(a1[1] - *a1) >> 5;
v8 += 32LL;
}
while ( v9 < result );
}
}
return result;
}
| destructuring_assign:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12,RDX
MOV RBX,RSI
MOV RSI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,RSI
CMP RAX,0x20
JNZ 0x0017dbaf
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x0018fdec
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
LAB_0017db37:
MOV RSI,R14
MOV RDX,R12
CALL qword ptr [RAX + 0x28]
LAB_0017db40:
LEA RBX,[RSP + 0x48]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0016b800
MOV RDI,RBX
CALL 0x00170bac
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x0017db65
CALL 0x00133c02
LAB_0017db65:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0017db74
CALL 0x00133c02
LAB_0017db74:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0017db83
CALL 0x00133c02
LAB_0017db83:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0017dcd1
MOV RAX,qword ptr [0x00230f80]
CMP byte ptr [RAX],0x0
JZ 0x0017dcbc
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0017dcc6
LAB_0017dbaf:
MOV qword ptr [RSP],RBX
CMP qword ptr [R12 + 0x10],0x0
JZ 0x0017dce0
MOV R15,RDI
MOV RDI,R12
CALL 0x00195e36
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RDX,RCX
SUB RDX,RSI
SAR RDX,0x5
CMP RAX,RDX
JNZ 0x0017dce0
CMP RCX,RSI
JZ 0x0017dcd1
XOR EBX,EBX
LEA R13,[RSP + 0x8]
XOR EBP,EBP
LAB_0017dbf6:
MOV RAX,qword ptr [RSP]
MOV R14,qword ptr [RAX]
ADD RSI,RBX
MOV RDI,R13
CALL 0x0018fdec
LAB_0017dc08:
MOV RDI,R12
MOV RSI,RBP
CALL 0x00195f96
MOV RCX,qword ptr [R14]
MOV RDI,R14
MOV RSI,R13
MOV RDX,RAX
CALL qword ptr [RCX + 0x28]
LAB_0017dc22:
LEA R14,[RSP + 0x48]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0016b800
MOV RDI,R14
CALL 0x00170bac
MOV RDI,qword ptr [RSP + 0x40]
TEST RDI,RDI
JZ 0x0017dc48
CALL 0x00133c02
LAB_0017dc48:
MOV RDI,qword ptr [RSP + 0x30]
TEST RDI,RDI
JZ 0x0017dc57
CALL 0x00133c02
LAB_0017dc57:
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x0017dc66
CALL 0x00133c02
LAB_0017dc66:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x0017dc9c
MOV RAX,qword ptr [0x00230f80]
CMP byte ptr [RAX],0x0
JZ 0x0017dc87
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0017dc91
LAB_0017dc87:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0017dc91:
CMP EAX,0x1
JNZ 0x0017dc9c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0017dc9c:
INC RBP
MOV RSI,qword ptr [R15]
MOV RAX,qword ptr [R15 + 0x8]
SUB RAX,RSI
SAR RAX,0x5
ADD RBX,0x20
CMP RBP,RAX
JC 0x0017dbf6
JMP 0x0017dcd1
LAB_0017dcbc:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0017dcc6:
CMP EAX,0x1
JNZ 0x0017dcd1
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0017dcd1:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017dce0:
MOV EDI,0x10
CALL 0x0011b450
MOV R14,RAX
LAB_0017dced:
LEA RSI,[0x1f5d50]
MOV RDI,RAX
CALL 0x0011b330
LAB_0017dcfc:
MOV RSI,qword ptr [0x00230fe8]
MOV RDX,qword ptr [0x00230f58]
MOV RDI,R14
CALL 0x0011bf60
|
/* minja::destructuring_assign(std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string
> > const&, std::shared_ptr<minja::Context> const&, minja::Value&) */
void minja::destructuring_assign(vector *param_1,shared_ptr *param_2,Value *param_3)
{
int *piVar1;
long *plVar2;
int iVar3;
long lVar4;
int8 uVar5;
runtime_error *this;
ulong uVar6;
long lVar7;
Value local_80 [8];
long *local_78;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
data local_40 [16];
if (*(long *)(param_1 + 8) - (long)*(string **)param_1 == 0x20) {
Value::Value(local_80,*(string **)param_1);
/* try { // try from 0017db37 to 0017db3f has its CatchHandler @ 0017dd1f */
(**(code **)(**(long **)param_2 + 0x28))(*(long **)param_2,local_80,param_3);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_00230f80 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
return;
}
if (*(long *)(param_3 + 0x10) != 0) {
lVar4 = Value::size(param_3);
lVar7 = *(long *)param_1;
if (lVar4 == *(long *)(param_1 + 8) - lVar7 >> 5) {
if (*(long *)(param_1 + 8) == lVar7) {
return;
}
lVar4 = 0;
uVar6 = 0;
do {
plVar2 = *(long **)param_2;
Value::Value(local_80,(string *)(lVar7 + lVar4));
/* try { // try from 0017dc08 to 0017dc21 has its CatchHandler @ 0017dd21 */
uVar5 = Value::at(param_3,uVar6);
(**(code **)(*plVar2 + 0x28))(plVar2,local_80,uVar5);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_40,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
if (local_78 != (long *)0x0) {
if (*PTR___libc_single_threaded_00230f80 == '\0') {
LOCK();
piVar1 = (int *)((long)local_78 + 0xc);
iVar3 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar3 = *(int *)((long)local_78 + 0xc);
*(int *)((long)local_78 + 0xc) = iVar3 + -1;
}
if (iVar3 == 1) {
(**(code **)(*local_78 + 0x18))();
}
}
uVar6 = uVar6 + 1;
lVar7 = *(long *)param_1;
lVar4 = lVar4 + 0x20;
} while (uVar6 < (ulong)(*(long *)(param_1 + 8) - lVar7 >> 5));
return;
}
}
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017dced to 0017dcfb has its CatchHandler @ 0017dd12 */
std::runtime_error::runtime_error
(this,"Mismatched number of variables and items in destructuring assignment");
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00230fe8,PTR__runtime_error_00230f58);
}
| |
23,673 | madb_reset_stmt | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static my_bool madb_reset_stmt(MYSQL_STMT *stmt, unsigned int flags)
{
MYSQL *mysql= stmt->mysql;
my_bool ret= 0;
if (!stmt->mysql)
{
SET_CLIENT_STMT_ERROR(stmt, CR_SERVER_LOST, SQLSTATE_UNKNOWN, 0);
return(1);
}
/* clear error */
if (flags & MADB_RESET_ERROR)
{
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
}
if (stmt->stmt_id)
{
/* free buffered resultset, previously allocated
* by mysql_stmt_store_result
*/
if (flags & MADB_RESET_STORED &&
stmt->result_cursor)
{
ma_free_root(&stmt->result.alloc, MYF(MY_KEEP_PREALLOC));
stmt->result.data= NULL;
stmt->result.rows= 0;
stmt->result_cursor= NULL;
stmt->mysql->status= MYSQL_STATUS_READY;
stmt->state= MYSQL_STMT_FETCH_DONE;
}
/* if there is a pending result set, we will flush it */
if (flags & MADB_RESET_BUFFER)
{
if (stmt->state == MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
stmt->state = MYSQL_STMT_USER_FETCHING;
}
if (stmt->mysql->status!= MYSQL_STATUS_READY && stmt->field_count)
{
mysql->methods->db_stmt_flush_unbuffered(stmt);
mysql->status= MYSQL_STATUS_READY;
}
}
if (flags & MADB_RESET_SERVER)
{
/* reset statement on server side */
if (stmt->mysql && stmt->mysql->status == MYSQL_STATUS_READY &&
stmt->mysql->net.pvio)
{
unsigned char cmd_buf[STMT_ID_LENGTH];
int4store(cmd_buf, stmt->stmt_id);
if ((ret= stmt->mysql->methods->db_command(mysql,COM_STMT_RESET, (char *)cmd_buf,
sizeof(cmd_buf), 0, stmt)))
{
UPDATE_STMT_ERROR(stmt);
return(ret);
}
}
}
if (flags & MADB_RESET_LONGDATA)
{
if (stmt->params)
{
ulonglong i;
for (i=0; i < stmt->param_count; i++)
if (stmt->params[i].long_data_used)
stmt->params[i].long_data_used= 0;
}
}
}
return(ret);
} | O3 | c | madb_reset_stmt:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
movq 0x38(%rdi), %r15
testq %r15, %r15
je 0x208ad
movl %esi, %r14d
testb $0x1, %r14b
je 0x207b3
movl $0x0, 0x90(%r15)
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), %rax
testq %rax, %rax
je 0x2078f
movl $0x0, 0x4(%rax)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
cmpq $0x0, 0x40(%rbx)
je 0x208a8
testb $0x10, %r14b
je 0x2080b
cmpq $0x0, 0xe0(%rbx)
je 0x2080b
leaq 0x90(%rbx), %rdi
movl $0x1, %esi
callq 0x1dc3f
xorl %eax, %eax
movq %rax, 0x80(%rbx)
movq %rax, 0xc8(%rbx)
movq %rax, 0xe0(%rbx)
movq 0x38(%rbx), %rax
movl $0x0, 0x488(%rax)
movl $0x6, 0x50(%rbx)
testb $0x8, %r14b
je 0x20852
cmpl $0x3, 0x50(%rbx)
jne 0x20827
movq %rbx, %rdi
callq *0x358(%rbx)
movl $0x5, 0x50(%rbx)
movq 0x38(%rbx), %rax
cmpl $0x0, 0x488(%rax)
je 0x20852
cmpl $0x0, 0x60(%rbx)
je 0x20852
movq 0x4d0(%r15), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movl $0x0, 0x488(%r15)
testb $0x4, %r14b
je 0x2086e
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x2086e
cmpl $0x0, 0x488(%rax)
je 0x20923
testb $0x2, %r14b
je 0x208a8
cmpq $0x0, 0x70(%rbx)
je 0x208a8
movl 0x64(%rbx), %eax
testl %eax, %eax
je 0x208a8
movl $0x66, %ecx
xorl %edx, %edx
movq 0x70(%rbx), %rsi
cmpb $0x0, (%rsi,%rcx)
je 0x2089a
movb $0x0, (%rsi,%rcx)
movl 0x64(%rbx), %eax
incq %rdx
movl %eax, %esi
addq $0x70, %rcx
cmpq %rsi, %rdx
jb 0x20889
xorl %r15d, %r15d
jmp 0x20902
movl $0x7dd, 0x108(%rbx) # imm = 0x7DD
leaq 0x30d(%rbx), %rdi
leaq 0x2816b(%rip), %rax # 0x48a30
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x28156(%rip), %rax # 0x48a40
movq 0x68(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13220
movb %r14b, 0x30b(%rbx)
movb $0x1, %r15b
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x209b7
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x0, (%rax)
je 0x2086e
movl 0x40(%rbx), %ecx
leaq -0x24(%rbp), %rdx
movl %ecx, (%rdx)
movq 0x4d0(%rax), %rax
movl $0x4, %ecx
movq %r15, %rdi
movl $0x1a, %esi
xorl %r8d, %r8d
movq %rbx, %r9
callq *0x10(%rax)
movl %eax, %r15d
testb %r15b, %r15b
je 0x2086e
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)
jmp 0x20902
callq 0x13500
| madb_reset_stmt:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 18h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_20], rax
mov r15, [rdi+38h]
test r15, r15
jz loc_208AD
mov r14d, esi
test r14b, 1
jz short loc_207B3
mov dword ptr [r15+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 rax, [rax+2A0h]
test rax, rax
jz short loc_2078F
mov dword ptr [rax+4], 0
loc_2078F:
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
loc_207B3:
cmp qword ptr [rbx+40h], 0
jz loc_208A8
test r14b, 10h
jz short loc_2080B
cmp qword ptr [rbx+0E0h], 0
jz short loc_2080B
lea rdi, [rbx+90h]
mov esi, 1
call ma_free_root
xor eax, eax
mov [rbx+80h], rax
mov [rbx+0C8h], rax
mov [rbx+0E0h], rax
mov rax, [rbx+38h]
mov dword ptr [rax+488h], 0
mov dword ptr [rbx+50h], 6
loc_2080B:
test r14b, 8
jz short loc_20852
cmp dword ptr [rbx+50h], 3
jnz short loc_20827
mov rdi, rbx
call qword ptr [rbx+358h]
mov dword ptr [rbx+50h], 5
loc_20827:
mov rax, [rbx+38h]
cmp dword ptr [rax+488h], 0
jz short loc_20852
cmp dword ptr [rbx+60h], 0
jz short loc_20852
mov rax, [r15+4D0h]
mov rdi, rbx
call qword ptr [rax+78h]
mov dword ptr [r15+488h], 0
loc_20852:
test r14b, 4
jz short loc_2086E
mov rax, [rbx+38h]
test rax, rax
jz short loc_2086E
cmp dword ptr [rax+488h], 0
jz loc_20923
loc_2086E:
test r14b, 2
jz short loc_208A8
cmp qword ptr [rbx+70h], 0
jz short loc_208A8
mov eax, [rbx+64h]
test eax, eax
jz short loc_208A8
mov ecx, 66h ; 'f'
xor edx, edx
loc_20889:
mov rsi, [rbx+70h]
cmp byte ptr [rsi+rcx], 0
jz short loc_2089A
mov byte ptr [rsi+rcx], 0
mov eax, [rbx+64h]
loc_2089A:
inc rdx
mov esi, eax
add rcx, 70h ; 'p'
cmp rdx, rsi
jb short loc_20889
loc_208A8:
xor r15d, r15d
jmp short loc_20902
loc_208AD:
mov dword ptr [rbx+108h], 7DDh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+68h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r15b, 1
loc_20902:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz loc_209B7
mov eax, r15d
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_20923:
cmp qword ptr [rax], 0
jz loc_2086E
mov ecx, [rbx+40h]
lea rdx, [rbp+var_24]
mov [rdx], ecx
mov rax, [rax+4D0h]
mov ecx, 4
mov rdi, r15
mov esi, 1Ah
xor r8d, r8d
mov r9, rbx
call qword ptr [rax+10h]
mov r15d, eax
test r15b, r15b
jz loc_2086E
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
jmp loc_20902
loc_209B7:
call ___stack_chk_fail
| long long madb_reset_stmt(long long a1, char a2)
{
long long v2; // r15
long long v3; // rax
long long v4; // rax
unsigned int v5; // eax
long long v6; // rcx
unsigned long long i; // rdx
long long v8; // rsi
unsigned int v9; // r15d
long long v11; // rsi
int v12; // [rsp+Ch] [rbp-24h] BYREF
unsigned long long v13; // [rsp+10h] [rbp-20h]
v13 = __readfsqword(0x28u);
v2 = *(_QWORD *)(a1 + 56);
if ( v2 )
{
if ( (a2 & 1) != 0 )
{
*(_DWORD *)(v2 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v3 )
*(_DWORD *)(v3 + 4) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
}
if ( *(_QWORD *)(a1 + 64) )
{
if ( (a2 & 0x10) != 0 && *(_QWORD *)(a1 + 224) )
{
ma_free_root(a1 + 144, 1);
*(_QWORD *)(a1 + 128) = 0LL;
*(_QWORD *)(a1 + 200) = 0LL;
*(_QWORD *)(a1 + 224) = 0LL;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
*(_DWORD *)(a1 + 80) = 6;
}
if ( (a2 & 8) != 0 )
{
if ( *(_DWORD *)(a1 + 80) == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
*(_DWORD *)(a1 + 80) = 5;
}
if ( *(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) && *(_DWORD *)(a1 + 96) )
{
(*(void ( **)(long long))(*(_QWORD *)(v2 + 1232) + 120LL))(a1);
*(_DWORD *)(v2 + 1160) = 0;
}
}
if ( (a2 & 4) != 0 )
{
v4 = *(_QWORD *)(a1 + 56);
if ( v4 )
{
if ( !*(_DWORD *)(v4 + 1160) )
{
if ( *(_QWORD *)v4 )
{
v12 = *(_DWORD *)(a1 + 64);
v9 = (*(long long ( **)(long long, long long, int *, long long, _QWORD, long long))(*(_QWORD *)(v4 + 1232)
+ 16LL))(
v2,
26LL,
&v12,
4LL,
0LL,
a1);
if ( (_BYTE)v9 )
{
v11 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v11 + 144);
strncpy(a1 + 781, v11 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
return v9;
}
}
}
}
}
if ( (a2 & 2) != 0 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v5 = *(_DWORD *)(a1 + 100);
if ( v5 )
{
v6 = 102LL;
for ( i = 0LL; i < v5; ++i )
{
v8 = *(_QWORD *)(a1 + 112);
if ( *(_BYTE *)(v8 + v6) )
{
*(_BYTE *)(v8 + v6) = 0;
v5 = *(_DWORD *)(a1 + 100);
}
v6 += 112LL;
}
}
}
}
}
return 0;
}
else
{
*(_DWORD *)(a1 + 264) = 2013;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[13], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
}
| madb_reset_stmt:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV R15,qword ptr [RDI + 0x38]
TEST R15,R15
JZ 0x001208ad
MOV R14D,ESI
TEST R14B,0x1
JZ 0x001207b3
MOV dword ptr [R15 + 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 RAX,qword ptr [RAX + 0x2a0]
TEST RAX,RAX
JZ 0x0012078f
MOV dword ptr [RAX + 0x4],0x0
LAB_0012078f:
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
LAB_001207b3:
CMP qword ptr [RBX + 0x40],0x0
JZ 0x001208a8
TEST R14B,0x10
JZ 0x0012080b
CMP qword ptr [RBX + 0xe0],0x0
JZ 0x0012080b
LEA RDI,[RBX + 0x90]
MOV ESI,0x1
CALL 0x0011dc3f
XOR EAX,EAX
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0xc8],RAX
MOV qword ptr [RBX + 0xe0],RAX
MOV RAX,qword ptr [RBX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
MOV dword ptr [RBX + 0x50],0x6
LAB_0012080b:
TEST R14B,0x8
JZ 0x00120852
CMP dword ptr [RBX + 0x50],0x3
JNZ 0x00120827
MOV RDI,RBX
CALL qword ptr [RBX + 0x358]
MOV dword ptr [RBX + 0x50],0x5
LAB_00120827:
MOV RAX,qword ptr [RBX + 0x38]
CMP dword ptr [RAX + 0x488],0x0
JZ 0x00120852
CMP dword ptr [RBX + 0x60],0x0
JZ 0x00120852
MOV RAX,qword ptr [R15 + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x78]
MOV dword ptr [R15 + 0x488],0x0
LAB_00120852:
TEST R14B,0x4
JZ 0x0012086e
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x0012086e
CMP dword ptr [RAX + 0x488],0x0
JZ 0x00120923
LAB_0012086e:
TEST R14B,0x2
JZ 0x001208a8
CMP qword ptr [RBX + 0x70],0x0
JZ 0x001208a8
MOV EAX,dword ptr [RBX + 0x64]
TEST EAX,EAX
JZ 0x001208a8
MOV ECX,0x66
XOR EDX,EDX
LAB_00120889:
MOV RSI,qword ptr [RBX + 0x70]
CMP byte ptr [RSI + RCX*0x1],0x0
JZ 0x0012089a
MOV byte ptr [RSI + RCX*0x1],0x0
MOV EAX,dword ptr [RBX + 0x64]
LAB_0012089a:
INC RDX
MOV ESI,EAX
ADD RCX,0x70
CMP RDX,RSI
JC 0x00120889
LAB_001208a8:
XOR R15D,R15D
JMP 0x00120902
LAB_001208ad:
MOV dword ptr [RBX + 0x108],0x7dd
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x148a30]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x148a40]
MOV RSI,qword ptr [RAX + 0x68]
MOV EDX,0x200
CALL 0x00113220
MOV byte ptr [RBX + 0x30b],R14B
MOV R15B,0x1
LAB_00120902:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001209b7
MOV EAX,R15D
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00120923:
CMP qword ptr [RAX],0x0
JZ 0x0012086e
MOV ECX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x24]
MOV dword ptr [RDX],ECX
MOV RAX,qword ptr [RAX + 0x4d0]
MOV ECX,0x4
MOV RDI,R15
MOV ESI,0x1a
XOR R8D,R8D
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
MOV R15D,EAX
TEST R15B,R15B
JZ 0x0012086e
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
JMP 0x00120902
LAB_001209b7:
CALL 0x00113500
|
int4 madb_reset_stmt(long param_1,uint param_2)
{
long lVar1;
long *plVar2;
uint uVar3;
int4 uVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
int4 local_2c;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
lVar5 = *(long *)(param_1 + 0x38);
if (lVar5 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7dd;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Lost_connection_to_server_during_00148aa8,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
}
else {
if ((param_2 & 1) != 0) {
*(int4 *)(lVar5 + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
}
if (*(long *)(param_1 + 0x40) != 0) {
if (((param_2 & 0x10) != 0) && (*(long *)(param_1 + 0xe0) != 0)) {
ma_free_root(param_1 + 0x90,1);
*(int8 *)(param_1 + 0x80) = 0;
*(int8 *)(param_1 + 200) = 0;
*(int8 *)(param_1 + 0xe0) = 0;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
*(int4 *)(param_1 + 0x50) = 6;
}
if ((param_2 & 8) != 0) {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
*(int4 *)(param_1 + 0x50) = 5;
}
if ((*(int *)(*(long *)(param_1 + 0x38) + 0x488) != 0) && (*(int *)(param_1 + 0x60) != 0)) {
(**(code **)(*(long *)(lVar5 + 0x4d0) + 0x78))(param_1);
*(int4 *)(lVar5 + 0x488) = 0;
}
}
if (((((param_2 & 4) != 0) && (plVar2 = *(long **)(param_1 + 0x38), plVar2 != (long *)0x0)) &&
((int)plVar2[0x91] == 0)) && (*plVar2 != 0)) {
local_2c = *(int4 *)(param_1 + 0x40);
uVar4 = (**(code **)(plVar2[0x9a] + 0x10))(lVar5,0x1a,&local_2c,4,0,param_1);
if ((char)uVar4 != '\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;
goto LAB_00120902;
}
}
if (((param_2 & 2) != 0) && (*(long *)(param_1 + 0x70) != 0)) {
uVar3 = *(uint *)(param_1 + 100);
if (uVar3 != 0) {
lVar5 = 0x66;
uVar6 = 0;
do {
if (*(char *)(*(long *)(param_1 + 0x70) + lVar5) != '\0') {
*(int1 *)(*(long *)(param_1 + 0x70) + lVar5) = 0;
uVar3 = *(uint *)(param_1 + 100);
}
uVar6 = uVar6 + 1;
lVar5 = lVar5 + 0x70;
} while (uVar6 < uVar3);
}
}
}
uVar4 = 0;
}
LAB_00120902:
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
23,674 | SET_top_port | xtate/src/xconf.c | static ConfRes SET_top_port(void *conf, const char *name, const char *value) {
XConf *xconf = (XConf *)conf;
if (xconf->echo) {
/*echo in SET_target_output*/
return 0;
}
unsigned maxports = conf_parse_int(value);
if (!maxports) {
LOG(LEVEL_ERROR, "fail %s: value of top-port must > 0.\n", name);
return Conf_ERR;
}
struct RangeList *ports = &xconf->targets.ports;
static const unsigned max_tcp_ports = ARRAY_SIZE(top_tcp_ports);
static const unsigned max_udp_ports = ARRAY_SIZE(top_udp_ports);
unsigned i;
if (name[0] == 'u') {
LOG(LEVEL_DETAIL, "adding UDP top-ports = %u\n", maxports);
for (i = 0; i < maxports && i < max_udp_ports; i++)
rangelist_add_range_udp(ports, top_udp_ports[i], top_udp_ports[i]);
} else {
LOG(LEVEL_DETAIL, "adding TCP top-ports = %u\n", maxports);
for (i = 0; i < maxports && i < max_tcp_ports; i++)
rangelist_add_range_tcp(ports, top_tcp_ports[i], top_tcp_ports[i]);
}
/* Targets must be sorted after every change, before being used */
rangelist_sort(ports);
return Conf_OK;
} | O3 | c | SET_top_port:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq $0x0, 0x2a8(%rdi)
jne 0x58502
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rdi
callq 0x523a0
movq %rax, %r15
testl %r15d, %r15d
je 0x5849c
addq $0x1d0, %r14 # imm = 0x1D0
cmpb $0x75, (%r12)
jne 0x584b9
leaq 0x264dc(%rip), %rsi # 0x7e93b
movl $0x3, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x536da
cmpl $0x1f, %r15d
movl $0x1f, %r12d
cmovbl %r15d, %r12d
leaq 0x28abd(%rip), %r15 # 0x80f40
movzwl (%r15), %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x4633d
addq $0x2, %r15
decq %r12
jne 0x58483
jmp 0x584fa
leaq 0x26472(%rip), %rsi # 0x7e915
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movq %r12, %rdx
xorl %eax, %eax
callq 0x536da
movl $0x1, %ebx
jmp 0x58502
leaq 0x26496(%rip), %rsi # 0x7e956
movl $0x3, %edi
movl %r15d, %edx
xorl %eax, %eax
callq 0x536da
movl $0x3f0, %r12d # imm = 0x3F0
cmpl %r12d, %r15d
cmovbl %r15d, %r12d
leaq 0x28a9d(%rip), %r15 # 0x80f80
movzwl (%r15), %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x46338
addq $0x2, %r15
decq %r12
jne 0x584e3
movq %r14, %rdi
callq 0x46a9c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| SET_top_port:
push r15
push r14
push r12
push rbx
push rax
xor ebx, ebx
cmp qword ptr [rdi+2A8h], 0
jnz loc_58502
mov r12, rsi
mov r14, rdi
mov rdi, rdx
call conf_parse_int
mov r15, rax
test r15d, r15d
jz short loc_5849C
add r14, 1D0h
cmp byte ptr [r12], 75h ; 'u'
jnz short loc_584B9
lea rsi, aAddingUdpTopPo; "adding UDP top-ports = %u\n"
mov edi, 3
mov edx, r15d
xor eax, eax
call LOG
cmp r15d, 1Fh
mov r12d, 1Fh
cmovb r12d, r15d
lea r15, top_udp_ports
loc_58483:
movzx edx, word ptr [r15]
mov rdi, r14
mov esi, edx
call rangelist_add_range_udp
add r15, 2
dec r12
jnz short loc_58483
jmp short loc_584FA
loc_5849C:
lea rsi, aFailSValueOfTo; "fail %s: value of top-port must > 0.\n"
mov edi, 0FFFFFFFFh
mov rdx, r12
xor eax, eax
call LOG
mov ebx, 1
jmp short loc_58502
loc_584B9:
lea rsi, aAddingTcpTopPo; "adding TCP top-ports = %u\n"
mov edi, 3
mov edx, r15d
xor eax, eax
call LOG
mov r12d, 3F0h
cmp r15d, r12d
cmovb r12d, r15d
lea r15, top_tcp_ports
loc_584E3:
movzx edx, word ptr [r15]
mov rdi, r14
mov esi, edx
call rangelist_add_range_tcp
add r15, 2
dec r12
jnz short loc_584E3
loc_584FA:
mov rdi, r14
call rangelist_sort
loc_58502:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long SET_top_port(
long long a1,
_BYTE *a2,
unsigned __int8 *a3,
long long a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
char v13; // al
unsigned int v14; // ebx
unsigned int v15; // eax
long long v16; // rcx
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
unsigned int v21; // r15d
long long v22; // r14
long long v23; // r12
unsigned __int16 *v24; // r15
long long v25; // rsi
int v26; // edx
int v27; // ecx
int v28; // r8d
int v29; // r9d
long long v30; // r12
unsigned __int16 *v31; // r15
char v33; // [rsp-8h] [rbp-28h]
v33 = v13;
v14 = 0;
if ( !*(_QWORD *)(a1 + 680) )
{
v15 = conf_parse_int(a3, (long long)a2, (long long)a3, a4, a5);
v21 = v15;
if ( v15 )
{
v22 = a1 + 464;
if ( *a2 == 117 )
{
LOG(3, (long long)"adding UDP top-ports = %u\n", v15, v16, v17, v18, a6, a7, a8, a9, v19, v20, a12, a13, v33);
v23 = 31LL;
if ( v21 < 0x1F )
v23 = v21;
v24 = (unsigned __int16 *)&top_udp_ports;
do
{
v25 = *v24;
rangelist_add_range_udp(v22, v25, *v24++);
--v23;
}
while ( v23 );
}
else
{
LOG(3, (long long)"adding TCP top-ports = %u\n", v15, v16, v17, v18, a6, a7, a8, a9, v19, v20, a12, a13, v33);
v30 = 1008LL;
if ( v21 < 0x3F0 )
v30 = v21;
v31 = (unsigned __int16 *)&top_tcp_ports;
do
{
v25 = *v31;
rangelist_add_range_tcp(v22, v25, v25);
++v31;
--v30;
}
while ( v30 );
}
rangelist_sort(v22, v25, v26, v27, v28, v29);
}
else
{
LOG(
-1,
(long long)"fail %s: value of top-port must > 0.\n",
(long long)a2,
v16,
v17,
v18,
a6,
a7,
a8,
a9,
v19,
v20,
a12,
a13,
v33);
return 1;
}
}
return v14;
}
| SET_top_port:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
XOR EBX,EBX
CMP qword ptr [RDI + 0x2a8],0x0
JNZ 0x00158502
MOV R12,RSI
MOV R14,RDI
MOV RDI,RDX
CALL 0x001523a0
MOV R15,RAX
TEST R15D,R15D
JZ 0x0015849c
ADD R14,0x1d0
CMP byte ptr [R12],0x75
JNZ 0x001584b9
LEA RSI,[0x17e93b]
MOV EDI,0x3
MOV EDX,R15D
XOR EAX,EAX
CALL 0x001536da
CMP R15D,0x1f
MOV R12D,0x1f
CMOVC R12D,R15D
LEA R15,[0x180f40]
LAB_00158483:
MOVZX EDX,word ptr [R15]
MOV RDI,R14
MOV ESI,EDX
CALL 0x0014633d
ADD R15,0x2
DEC R12
JNZ 0x00158483
JMP 0x001584fa
LAB_0015849c:
LEA RSI,[0x17e915]
MOV EDI,0xffffffff
MOV RDX,R12
XOR EAX,EAX
CALL 0x001536da
MOV EBX,0x1
JMP 0x00158502
LAB_001584b9:
LEA RSI,[0x17e956]
MOV EDI,0x3
MOV EDX,R15D
XOR EAX,EAX
CALL 0x001536da
MOV R12D,0x3f0
CMP R15D,R12D
CMOVC R12D,R15D
LEA R15,[0x180f80]
LAB_001584e3:
MOVZX EDX,word ptr [R15]
MOV RDI,R14
MOV ESI,EDX
CALL 0x00146338
ADD R15,0x2
DEC R12
JNZ 0x001584e3
LAB_001584fa:
MOV RDI,R14
CALL 0x00146a9c
LAB_00158502:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8 SET_top_port(long param_1,char *param_2,int8 param_3)
{
uint uVar1;
int8 uVar2;
ulong uVar3;
int2 *puVar4;
uVar2 = 0;
if (*(long *)(param_1 + 0x2a8) == 0) {
uVar1 = conf_parse_int(param_3);
if (uVar1 == 0) {
LOG(0xffffffff,"fail %s: value of top-port must > 0.\n",param_2);
uVar2 = 1;
}
else {
param_1 = param_1 + 0x1d0;
if (*param_2 == 'u') {
LOG(3,"adding UDP top-ports = %u\n",uVar1);
uVar3 = 0x1f;
if (uVar1 < 0x1f) {
uVar3 = (ulong)uVar1;
}
puVar4 = &top_udp_ports;
do {
rangelist_add_range_udp(param_1,*puVar4);
puVar4 = puVar4 + 1;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
}
else {
LOG(3,"adding TCP top-ports = %u\n",uVar1);
uVar3 = 0x3f0;
if (uVar1 < 0x3f0) {
uVar3 = (ulong)uVar1;
}
puVar4 = &top_tcp_ports;
do {
rangelist_add_range_tcp(param_1,*puVar4);
puVar4 = puVar4 + 1;
uVar3 = uVar3 - 1;
} while (uVar3 != 0);
}
rangelist_sort(param_1);
}
}
return uVar2;
}
| |
23,675 | parse_time | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static int parse_time(const char *str, size_t length, const char **end_ptr, MYSQL_TIME *tm)
{
int err= 0;
const char *p = str;
const char *end = str + length;
size_t frac_len;
int ret=1;
tm->hour = my_strtoui(p, end-p, &p, &err);
if (err || tm->hour > 838 || p == end || *p != ':' )
goto end;
p++;
tm->minute = my_strtoui(p, end-p, &p, &err);
if (err || tm->minute > 59 || p == end || *p != ':')
goto end;
p++;
tm->second = my_strtoui(p, end-p, &p, &err);
if (err || tm->second > 59)
goto end;
ret = 0;
tm->second_part = 0;
if (p == end)
goto end;
/* Check for fractional part*/
if (*p != '.')
goto end;
p++;
frac_len = MIN(6,end-p);
tm->second_part = my_strtoui(p, frac_len, &p, &err);
if (err)
goto end;
if (frac_len < 6)
tm->second_part *= frac_mul[frac_len];
ret = 0;
/* Consume whole fractional part, even after 6 digits.*/
p += frac_len;
while(p < *end_ptr)
{
if (*p < '0' || *p > '9')
break;
p++;
}
end:
*end_ptr = p;
return ret;
} | O0 | c | parse_time:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x44(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x342a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x32f08
movq -0x20(%rbp), %rax
cmpl $0x346, 0xc(%rax) # imm = 0x346
ja 0x32f08
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x32f08
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x32f0d
jmp 0x330bc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x342a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x32f64
movq -0x20(%rbp), %rax
cmpl $0x3b, 0x10(%rax)
ja 0x32f64
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x32f64
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x32f69
jmp 0x330bc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x342a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x32faa
movq -0x20(%rbp), %rax
cmpl $0x3b, 0x14(%rax)
jbe 0x32faf
jmp 0x330bc
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x32fd1
jmp 0x330bc
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x32fe2
jmp 0x330bc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movl $0x6, %eax
cmpq %rcx, %rax
jge 0x3300e
movl $0x6, %eax
movq %rax, -0x50(%rbp)
jmp 0x3301d
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x342a0
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x3304e
jmp 0x330bc
cmpq $0x6, -0x40(%rbp)
jae 0x33072
movq -0x40(%rbp), %rcx
leaq 0x22610(%rip), %rax # 0x55670
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
imulq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x330ba
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x330aa
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x330ac
jmp 0x330ba
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x33085
jmp 0x330bc
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
| parse_time:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
mov [rbp+var_44], 1
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+0Ch], ecx
cmp [rbp+var_24], 0
jnz short loc_32F08
mov rax, [rbp+var_20]
cmp dword ptr [rax+0Ch], 346h
ja short loc_32F08
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_32F08
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 3Ah ; ':'
jz short loc_32F0D
loc_32F08:
jmp loc_330BC
loc_32F0D:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+10h], ecx
cmp [rbp+var_24], 0
jnz short loc_32F64
mov rax, [rbp+var_20]
cmp dword ptr [rax+10h], 3Bh ; ';'
ja short loc_32F64
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_32F64
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 3Ah ; ':'
jz short loc_32F69
loc_32F64:
jmp loc_330BC
loc_32F69:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+14h], ecx
cmp [rbp+var_24], 0
jnz short loc_32FAA
mov rax, [rbp+var_20]
cmp dword ptr [rax+14h], 3Bh ; ';'
jbe short loc_32FAF
loc_32FAA:
jmp loc_330BC
loc_32FAF:
mov [rbp+var_44], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnz short loc_32FD1
jmp loc_330BC
loc_32FD1:
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jz short loc_32FE2
jmp loc_330BC
loc_32FE2:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
sub rcx, rax
mov eax, 6
cmp rax, rcx
jge short loc_3300E
mov eax, 6
mov [rbp+var_50], rax
jmp short loc_3301D
loc_3300E:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_50], rax
loc_3301D:
mov rax, [rbp+var_50]
mov [rbp+var_40], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_40]
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+18h], rcx
cmp [rbp+var_24], 0
jz short loc_3304E
jmp short loc_330BC
loc_3304E:
cmp [rbp+var_40], 6
jnb short loc_33072
mov rcx, [rbp+var_40]
lea rax, frac_mul
mov eax, [rax+rcx*4]
mov ecx, eax
mov rax, [rbp+var_20]
imul rcx, [rax+18h]
mov [rax+18h], rcx
loc_33072:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
add rax, [rbp+var_30]
mov [rbp+var_30], rax
loc_33085:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
cmp rax, [rcx]
jnb short loc_330BA
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jl short loc_330AA
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 39h ; '9'
jle short loc_330AC
loc_330AA:
jmp short loc_330BA
loc_330AC:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_33085
loc_330BA:
jmp short $+2
loc_330BC:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
| long long parse_time(_BYTE *a1, long long a2, _QWORD *a3, long long a4)
{
int v4; // eax
int v5; // eax
int v6; // eax
unsigned int v7; // eax
unsigned long long v9; // [rsp+0h] [rbp-50h]
unsigned int v10; // [rsp+Ch] [rbp-44h]
_BYTE *v11; // [rsp+18h] [rbp-38h]
_BYTE *v12; // [rsp+20h] [rbp-30h] BYREF
int v13; // [rsp+2Ch] [rbp-24h] BYREF
long long v14; // [rsp+30h] [rbp-20h]
_QWORD *v15; // [rsp+38h] [rbp-18h]
long long v16; // [rsp+40h] [rbp-10h]
_BYTE *v17; // [rsp+48h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = 0;
v12 = a1;
v11 = &a1[a2];
v10 = 1;
v4 = my_strtoui(a1, a2, &v12, &v13);
*(_DWORD *)(v14 + 12) = v4;
if ( !v13 && *(_DWORD *)(v14 + 12) <= 0x346u && v12 != v11 && *v12 == 58 )
{
++v12;
v5 = my_strtoui(v12, v11 - v12, &v12, &v13);
*(_DWORD *)(v14 + 16) = v5;
if ( !v13 && *(_DWORD *)(v14 + 16) <= 0x3Bu && v12 != v11 && *v12 == 58 )
{
++v12;
v6 = my_strtoui(v12, v11 - v12, &v12, &v13);
*(_DWORD *)(v14 + 20) = v6;
if ( !v13 && *(_DWORD *)(v14 + 20) <= 0x3Bu )
{
v10 = 0;
*(_QWORD *)(v14 + 24) = 0LL;
if ( v12 != v11 && *v12 == 46 )
{
++v12;
v9 = v11 - v12 <= 6 ? v11 - v12 : 6LL;
v7 = my_strtoui(v12, v9, &v12, &v13);
*(_QWORD *)(v14 + 24) = v7;
if ( !v13 )
{
if ( v9 < 6 )
*(_QWORD *)(v14 + 24) *= frac_mul[v9];
v10 = 0;
for ( v12 += v9; (unsigned long long)v12 < *v15 && (char)*v12 >= 48 && (char)*v12 <= 57; ++v12 )
;
}
}
}
}
}
*v15 = v12;
return v10;
}
| parse_time:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x44],0x1
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x001342a0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xc],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00132f08
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0xc],0x346
JA 0x00132f08
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00132f08
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3a
JZ 0x00132f0d
LAB_00132f08:
JMP 0x001330bc
LAB_00132f0d:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x001342a0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x10],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00132f64
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x10],0x3b
JA 0x00132f64
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00132f64
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3a
JZ 0x00132f69
LAB_00132f64:
JMP 0x001330bc
LAB_00132f69:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x001342a0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00132faa
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x14],0x3b
JBE 0x00132faf
LAB_00132faa:
JMP 0x001330bc
LAB_00132faf:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x00132fd1
JMP 0x001330bc
LAB_00132fd1:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JZ 0x00132fe2
JMP 0x001330bc
LAB_00132fe2:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV EAX,0x6
CMP RAX,RCX
JGE 0x0013300e
MOV EAX,0x6
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0013301d
LAB_0013300e:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_0013301d:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x40]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x001342a0
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x0013304e
JMP 0x001330bc
LAB_0013304e:
CMP qword ptr [RBP + -0x40],0x6
JNC 0x00133072
MOV RCX,qword ptr [RBP + -0x40]
LEA RAX,[0x155670]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
IMUL RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_00133072:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
LAB_00133085:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX]
JNC 0x001330ba
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JL 0x001330aa
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x39
JLE 0x001330ac
LAB_001330aa:
JMP 0x001330ba
LAB_001330ac:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00133085
LAB_001330ba:
JMP 0x001330bc
LAB_001330bc:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4 parse_time(char *param_1,long param_2,int8 *param_3,long param_4)
{
int4 uVar1;
uint uVar2;
char *pcVar3;
ulong local_58;
int4 local_4c;
char *local_38;
int local_2c;
long local_28;
int8 *local_20;
long local_18;
char *local_10;
local_2c = 0;
pcVar3 = param_1 + param_2;
local_4c = 1;
local_38 = param_1;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = my_strtoui(param_1,(long)pcVar3 - (long)param_1,&local_38,&local_2c);
*(int4 *)(local_28 + 0xc) = uVar1;
if ((((local_2c == 0) && (*(uint *)(local_28 + 0xc) < 0x347)) && (local_38 != pcVar3)) &&
(*local_38 == ':')) {
local_38 = local_38 + 1;
uVar1 = my_strtoui(local_38,(long)pcVar3 - (long)local_38,&local_38,&local_2c);
*(int4 *)(local_28 + 0x10) = uVar1;
if (((local_2c == 0) && (*(uint *)(local_28 + 0x10) < 0x3c)) &&
((local_38 != pcVar3 && (*local_38 == ':')))) {
local_38 = local_38 + 1;
uVar1 = my_strtoui(local_38,(long)pcVar3 - (long)local_38,&local_38,&local_2c);
*(int4 *)(local_28 + 0x14) = uVar1;
if ((local_2c == 0) && (*(uint *)(local_28 + 0x14) < 0x3c)) {
local_4c = 0;
*(int8 *)(local_28 + 0x18) = 0;
if ((local_38 != pcVar3) && (*local_38 == '.')) {
local_38 = local_38 + 1;
if ((long)pcVar3 - (long)local_38 < 7) {
local_58 = (long)pcVar3 - (long)local_38;
}
else {
local_58 = 6;
}
uVar2 = my_strtoui(local_38,local_58,&local_38,&local_2c);
*(ulong *)(local_28 + 0x18) = (ulong)uVar2;
if (local_2c == 0) {
if (local_58 < 6) {
*(ulong *)(local_28 + 0x18) =
(ulong)*(uint *)(frac_mul + local_58 * 4) * *(long *)(local_28 + 0x18);
}
local_4c = 0;
for (local_38 = local_38 + local_58;
((local_38 < (char *)*local_20 && ('/' < *local_38)) && (*local_38 < ':'));
local_38 = local_38 + 1) {
}
}
}
}
}
}
*local_20 = local_38;
return local_4c;
}
| |
23,676 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<unsigned long&>(unsigned long&, bool) | llama.cpp/common/json.hpp | std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
{
JSON_ASSERT(!keep_stack.empty());
// do not handle this value if we know it would be added to a discarded
// container
if (!keep_stack.back())
{
return {false, nullptr};
}
// create value
auto value = BasicJsonType(std::forward<Value>(v));
// check callback
const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
// do not handle this value if we just learnt it shall be discarded
if (!keep)
{
return {false, nullptr};
}
if (ref_stack.empty())
{
root = std::move(value);
return {true, & root};
}
// skip this value if we already decided to skip the parent
// (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
if (!ref_stack.back())
{
return {false, nullptr};
}
// we now only expect arrays and objects
JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
// array
if (ref_stack.back()->is_array())
{
ref_stack.back()->m_data.m_value.array->emplace_back(std::move(value));
return {true, & (ref_stack.back()->m_data.m_value.array->back())};
}
// object
JSON_ASSERT(ref_stack.back()->is_object());
// check if we should store an element for the current key
JSON_ASSERT(!key_keep_stack.empty());
const bool store_element = key_keep_stack.back();
key_keep_stack.pop_back();
if (!store_element)
{
return {false, nullptr};
}
JSON_ASSERT(object_element);
*object_element = std::move(value);
return {true, object_element};
} | O3 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>::handle_value<unsigned long&>(unsigned long&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl 0x38(%rdi), %ecx
cmpq %rax, 0x20(%rdi)
sete %dl
testl %ecx, %ecx
sete %dil
andb %dl, %dil
cmpb $0x1, %dil
je 0x8c84c
movl %ecx, %ecx
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq -0x1(%rcx), %rdx
addq $0x3e, %rcx
testq %rdx, %rdx
cmovnsq %rdx, %rcx
sarq $0x6, %rcx
leaq (%rax,%rcx,8), %rax
leaq 0x3f(%r15), %rcx
andq %rdx, %rcx
xorl %edi, %edi
cmpq %r15, %rcx
setbe %dil
movq -0x8(%rax,%rdi,8), %rax
btq %rdx, %rax
jae 0x8c6df
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x8c8e6
movq %r14, %rdi
movl $0x1, %esi
callq 0x851c0
testb %bpl, %bpl
jne 0x8c68c
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x8c86d
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x8c820
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x8c6e9
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x8c820
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x8c743
cmpl $0x2, %ecx
jne 0x8c872
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x896dc
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x8c81c
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x8c83c
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x851c0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x851c0
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x87a52
movq %r15, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r15, %rdi
callq 0x89fae
movq (%rbx), %r14
jmp 0x8c81c
movq 0x58(%rbx), %rax
movl 0x60(%rbx), %ecx
cmpq %rax, 0x48(%rbx)
sete %dl
testl %ecx, %ecx
sete %sil
andb %dl, %sil
cmpb $0x1, %sil
je 0x8c880
movl %ecx, %esi
leaq -0x1(%rsi), %rcx
movq %rsi, %rdx
addq $0x3e, %rdx
testq %rcx, %rcx
cmovnsq %rcx, %rdx
sarq $0x6, %rdx
leaq (%rax,%rdx,8), %rdi
leaq 0x3f(%r15), %rdx
andq %rcx, %rdx
xorl %r8d, %r8d
cmpq %r15, %rdx
setbe %r8b
movl $0x1, %edx
shlq %cl, %rdx
andq -0x8(%rdi,%r8,8), %rdx
subl $0x1, %esi
movl %esi, 0x60(%rbx)
jae 0x8c7b5
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x8c820
cmpq $0x0, 0x70(%rbx)
je 0x8c8a1
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x851c0
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x851c0
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x87a52
movq %r15, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r15, %rdi
callq 0x89fae
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x8c825
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r15, %rdi
callq 0x89fae
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x98a53(%rip), %rdi # 0x1252a6
leaq 0x8fba6(%rip), %rdx # 0x11c400
leaq 0x98cf0(%rip), %rcx # 0x125551
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x21ec0
callq 0x22310
leaq 0x98cec(%rip), %rcx # 0x125565
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x8c88c
leaq 0x98d1c(%rip), %rcx # 0x1255a3
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x98a13(%rip), %rdi # 0x1252a6
leaq 0x8fb66(%rip), %rdx # 0x11c400
xorl %eax, %eax
callq 0x21ec0
leaq 0x989fe(%rip), %rdi # 0x1252a6
leaq 0x8fb51(%rip), %rdx # 0x11c400
leaq 0x98d05(%rip), %rcx # 0x1255bb
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x21ec0
jmp 0x8c8c4
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r14, %rdi
callq 0x89fae
movq %rbx, %rdi
callq 0x21b20
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRmEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 48h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+30h]
mov ecx, [rdi+38h]
cmp [rdi+20h], rax
setz dl
test ecx, ecx
setz dil
and dil, dl
cmp dil, 1
jz loc_8C84C
mov ecx, ecx
mov r15, 8000000000000000h
lea rdx, [rcx-1]
add rcx, 3Eh ; '>'
test rdx, rdx
cmovns rcx, rdx
sar rcx, 6
lea rax, [rax+rcx*8]
lea rcx, [r15+3Fh]
and rcx, rdx
xor edi, edi
cmp rcx, r15
setbe dil
mov rax, [rax+rdi*8-8]
bt rax, rdx
jnb loc_8C6DF
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
mov rsi, [rsi]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE6EE9constructINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_17number_unsigned_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::number_unsigned_t)
mov rdi, r14
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
test bpl, bpl
jnz short loc_8C68C
mov rax, [rbx+10h]
sub rax, [rbx+8]
shr rax, 3
mov [rsp+68h+var_5C], eax
mov [rsp+68h+var_5D], 5
cmp qword ptr [rbx+90h], 0
jz loc_8C86D
lea rdi, [rbx+80h]
lea rsi, [rsp+68h+var_5C]
lea rdx, [rsp+68h+var_5D]
lea rcx, [rsp+68h+var_58]
call qword ptr [rbx+98h]
test al, al
jz loc_8C820
loc_8C68C:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_8C6E9
mov rax, [rax-8]
test rax, rax
jz loc_8C820
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_8C743
cmp ecx, 2
jnz loc_8C872
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapS_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_8C81C
loc_8C6DF:
xor ebx, ebx
xor r14d, r14d
jmp loc_8C83C
loc_8C6E9:
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_38]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_8C81C
loc_8C743:
mov rax, [rbx+58h]
mov ecx, [rbx+60h]
cmp [rbx+48h], rax
setz dl
test ecx, ecx
setz sil
and sil, dl
cmp sil, 1
jz loc_8C880
mov esi, ecx
lea rcx, [rsi-1]
mov rdx, rsi
add rdx, 3Eh ; '>'
test rcx, rcx
cmovns rdx, rcx
sar rdx, 6
lea rdi, [rax+rdx*8]
lea rdx, [r15+3Fh]
and rdx, rcx
xor r8d, r8d
cmp rdx, r15
setbe r8b
mov edx, 1
shl rdx, cl
and rdx, [rdi+r8*8-8]
sub esi, 1
mov [rbx+60h], esi
jnb short loc_8C7B5
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_8C7B5:
test rdx, rdx
jz short loc_8C820
cmp qword ptr [rbx+70h], 0
jz loc_8C8A1
lea r14, [rsp+68h+var_58]
movaps xmm0, xmmword ptr [r14]
lea r15, [rsp+68h+var_48]
movaps xmmword ptr [r15], xmm0
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_8C81C:
mov bl, 1
jmp short loc_8C825
loc_8C820:
xor ebx, ebx
xor r14d, r14d
loc_8C825:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_8C83C:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_8C84C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_8C86D:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_8C872:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_8C88C
loc_8C880:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_8C88C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_8C8A1:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/llama."...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_8C8C4:
mov rbx, rax
lea r14, [rsp+68h+var_58]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::handle_value<unsigned long &>(
long long a1,
_QWORD *a2,
char a3)
{
unsigned int v4; // ebx
long long v5; // rax
unsigned int v6; // ecx
signed long long v7; // rdx
long long v8; // rcx
long long v9; // rax
long long v10; // rax
unsigned __int8 *v11; // rax
int v12; // ecx
long long v13; // rax
unsigned int v14; // ecx
long long v15; // rsi
long long v16; // rcx
long long v17; // rdx
long long v18; // rdx
const char *v20; // rcx
long long v21; // rsi
long long v22; // rbx
char v23; // [rsp+Bh] [rbp-5Dh] BYREF
int v24; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v25; // [rsp+10h] [rbp-58h] BYREF
__int128 v26; // [rsp+20h] [rbp-48h] BYREF
_OWORD v27[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
{
ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
goto LABEL_28;
}
v7 = v6 - 1LL;
v8 = v6 + 62LL;
if ( v7 >= 0 )
v8 = v7;
v9 = *(_QWORD *)(v5 + 8 * (v8 >> 6) + 8LL * ((v7 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8);
if ( _bittest64(&v9, v7) )
{
v25 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
*a2);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
if ( a3 )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v27[0] = v25;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)a1,
(long long)v27);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v27);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v27);
goto LABEL_23;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
return v4;
}
v20 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v21 = 7243LL;
goto LABEL_31;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
{
v20 = "!key_keep_stack.empty()";
v21 = 7255LL;
LABEL_31:
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp", v21, "GGML_ASSERT(%s) failed", v20);
goto LABEL_32;
}
v15 = v14;
v16 = v14 - 1LL;
v17 = v15 + 62;
if ( v16 >= 0 )
v17 = v16;
v18 = *(_QWORD *)(v13 + 8 * (v17 >> 6) + 8LL * ((v16 & 0x800000000000003FLL) <= 0x8000000000000000LL) - 8) & (1LL << v16);
*(_DWORD *)(a1 + 96) = v15 - 1;
if ( !(_DWORD)v15 )
{
*(_DWORD *)(a1 + 96) = 63;
*(_QWORD *)(a1 + 88) = v13 - 8;
}
if ( v18 )
{
if ( *(_QWORD *)(a1 + 112) )
{
v26 = v25;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v26);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v26);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v25);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v25);
_Unwind_Resume(v22);
}
}
LABEL_24:
v4 = 0;
goto LABEL_25;
}
v24 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v23 = 5;
if ( *(_QWORD *)(a1 + 144) )
{
if ( !(*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(
a1 + 128,
&v24,
&v23,
&v25) )
goto LABEL_24;
goto LABEL_8;
}
LABEL_28:
std::__throw_bad_function_call();
}
return 0;
}
| handle_value<unsigned_long&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV EBP,EDX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x30]
MOV ECX,dword ptr [RDI + 0x38]
CMP qword ptr [RDI + 0x20],RAX
SETZ DL
TEST ECX,ECX
SETZ DIL
AND DIL,DL
CMP DIL,0x1
JZ 0x0018c84c
MOV ECX,ECX
MOV R15,-0x8000000000000000
LEA RDX,[RCX + -0x1]
ADD RCX,0x3e
TEST RDX,RDX
CMOVNS RCX,RDX
SAR RCX,0x6
LEA RAX,[RAX + RCX*0x8]
LEA RCX,[R15 + 0x3f]
AND RCX,RDX
XOR EDI,EDI
CMP RCX,R15
SETBE DIL
MOV RAX,qword ptr [RAX + RDI*0x8 + -0x8]
BT RAX,RDX
JNC 0x0018c6df
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x0018c8e6
MOV RDI,R14
MOV ESI,0x1
CALL 0x001851c0
TEST BPL,BPL
JNZ 0x0018c68c
MOV RAX,qword ptr [RBX + 0x10]
SUB RAX,qword ptr [RBX + 0x8]
SHR RAX,0x3
MOV dword ptr [RSP + 0xc],EAX
MOV byte ptr [RSP + 0xb],0x5
CMP qword ptr [RBX + 0x90],0x0
JZ 0x0018c86d
LEA RDI,[RBX + 0x80]
LAB_0018c66f:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0018c820
LAB_0018c68c:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0018c6e9
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0018c820
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0018c743
CMP ECX,0x2
JNZ 0x0018c872
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x001896dc
LAB_0018c6c6:
MOV RAX,qword ptr [RBX + 0x10]
MOV RAX,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV R14,qword ptr [RAX + 0x8]
ADD R14,-0x10
JMP 0x0018c81c
LAB_0018c6df:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0018c83c
LAB_0018c6e9:
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x30]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001851c0
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001851c0
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00187a52
MOV RDI,R15
XOR ESI,ESI
CALL 0x001851c0
MOV RDI,R15
CALL 0x00189fae
MOV R14,qword ptr [RBX]
JMP 0x0018c81c
LAB_0018c743:
MOV RAX,qword ptr [RBX + 0x58]
MOV ECX,dword ptr [RBX + 0x60]
CMP qword ptr [RBX + 0x48],RAX
SETZ DL
TEST ECX,ECX
SETZ SIL
AND SIL,DL
CMP SIL,0x1
JZ 0x0018c880
MOV ESI,ECX
LEA RCX,[RSI + -0x1]
MOV RDX,RSI
ADD RDX,0x3e
TEST RCX,RCX
CMOVNS RDX,RCX
SAR RDX,0x6
LEA RDI,[RAX + RDX*0x8]
LEA RDX,[R15 + 0x3f]
AND RDX,RCX
XOR R8D,R8D
CMP RDX,R15
SETBE R8B
MOV EDX,0x1
SHL RDX,CL
AND RDX,qword ptr [RDI + R8*0x8 + -0x8]
SUB ESI,0x1
MOV dword ptr [RBX + 0x60],ESI
JNC 0x0018c7b5
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0018c7b5:
TEST RDX,RDX
JZ 0x0018c820
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0018c8a1
LEA R14,[RSP + 0x10]
MOVAPS XMM0,xmmword ptr [R14]
LEA R15,[RSP + 0x20]
MOVAPS xmmword ptr [R15],XMM0
MOV RDI,R14
XOR ESI,ESI
CALL 0x001851c0
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x001851c0
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00187a52
MOV RDI,R15
XOR ESI,ESI
CALL 0x001851c0
MOV RDI,R15
CALL 0x00189fae
MOV R14,qword ptr [RBX + 0x70]
LAB_0018c81c:
MOV BL,0x1
JMP 0x0018c825
LAB_0018c820:
XOR EBX,EBX
XOR R14D,R14D
LAB_0018c825:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x001851c0
MOV RDI,R15
CALL 0x00189fae
LAB_0018c83c:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0018c84c:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x225551]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00121ec0
LAB_0018c86d:
CALL 0x00122310
LAB_0018c872:
LEA RCX,[0x225565]
MOV ESI,0x1c4b
JMP 0x0018c88c
LAB_0018c880:
LEA RCX,[0x2255a3]
MOV ESI,0x1c57
LAB_0018c88c:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
XOR EAX,EAX
CALL 0x00121ec0
LAB_0018c8a1:
LEA RDI,[0x2252a6]
LEA RDX,[0x21c400]
LEA RCX,[0x2255bb]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00121ec0
|
/* std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>*>
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::handle_value<unsigned long&>(unsigned long&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,ulong *param_1,bool param_2)
{
uint uVar1;
char cVar2;
ulong uVar3;
char *pcVar4;
ulong uVar5;
int8 uVar6;
bool bVar7;
long lVar8;
int1 auVar9 [16];
int1 local_5d;
int4 local_5c;
ulong local_58;
int8 uStack_50;
ulong local_48;
int8 uStack_40;
ulong local_38;
int8 uStack_30;
uVar1 = *(uint *)(this + 0x38);
if (uVar1 == 0 && *(long *)(this + 0x20) == *(long *)(this + 0x30)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar8 = 0;
goto LAB_0018c83c;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)6>::
construct<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(&local_58,*param_1);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_0018c68c:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)this,(data *)&local_38);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0018c820;
if (*pcVar4 == '\x01') {
lVar8 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar8) {
pcVar4 = "!key_keep_stack.empty()";
uVar6 = 0x1c57;
goto LAB_0018c88c;
}
uVar5 = (ulong)uVar1 - 1;
uVar3 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar3 = uVar5;
}
uVar3 = *(ulong *)(lVar8 + ((long)uVar3 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar8 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar3) == 0) goto LAB_0018c820;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0018c8a1 to 0018c8c1 has its CatchHandler @ 0018c8c2 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",0x1c60,
"GGML_ASSERT(%s) failed","object_element");
}
local_48 = local_58;
uStack_40 = uStack_50;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)(this + 0x70),(data *)&local_48);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(bVar7);
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0018c88c:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github2025/llama.cpp/common/json.hpp",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(pcVar4 + 8),(basic_json *)&local_58);
lVar8 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar5 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
local_5c = (int4)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3);
local_5d = 5;
if (*(long *)(this + 0x90) == 0) {
/* WARNING: Subroutine does not return */
/* try { // try from 0018c86d to 0018c8a0 has its CatchHandler @ 0018c8c4 */
std::__throw_bad_function_call();
}
/* try { // try from 0018c66f to 0018c6c5 has its CatchHandler @ 0018c8c4 */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_0018c68c;
LAB_0018c820:
uVar5 = 0;
lVar8 = 0;
}
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81((data *)&local_58,0));
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0018c83c:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
23,677 | ma_duplicate_resultset_metadata | eloqsql/libmariadb/libmariadb/mariadb_lib.c | MYSQL_FIELD *ma_duplicate_resultset_metadata(MYSQL_FIELD *fields, size_t count,
MA_MEM_ROOT *memroot)
{
size_t i;
MYSQL_FIELD *result=
(MYSQL_FIELD *) ma_alloc_root(memroot, sizeof(MYSQL_FIELD) * count);
if (!result)
return NULL;
for (i= 0; i < count; i++)
{
if (ma_deep_copy_field(&fields[i], &result[i], memroot))
return NULL;
}
return result;
} | O3 | c | ma_duplicate_resultset_metadata:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
shlq $0x7, %rsi
movq %rdx, %rdi
callq 0x7b36f
testq %rax, %rax
je 0x78750
movq %rax, %rbx
testq %r15, %r15
je 0x78752
xorl %r13d, %r13d
movq 0x28(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x785a2
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x28(%rbx,%r13)
testq %rax, %rax
jne 0x785ab
jmp 0x78750
movq $0x0, 0x28(%rbx,%r13)
movq 0x20(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x785cc
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x20(%rbx,%r13)
testq %rax, %rax
jne 0x785d5
jmp 0x78750
movq $0x0, 0x20(%rbx,%r13)
movq 0x30(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x785f6
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x30(%rbx,%r13)
testq %rax, %rax
jne 0x785ff
jmp 0x78750
movq $0x0, 0x30(%rbx,%r13)
movq (%r12,%r13), %rsi
testq %rsi, %rsi
je 0x7861e
movq %r14, %rdi
callq 0x7b512
movq %rax, (%rbx,%r13)
testq %rax, %rax
jne 0x78626
jmp 0x78750
movq $0x0, (%rbx,%r13)
movq 0x8(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x78647
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x8(%rbx,%r13)
testq %rax, %rax
jne 0x78650
jmp 0x78750
movq $0x0, 0x8(%rbx,%r13)
movq 0x18(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x78671
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x18(%rbx,%r13)
testq %rax, %rax
jne 0x7867a
jmp 0x78750
movq $0x0, 0x18(%rbx,%r13)
movq 0x10(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x7869b
movq %r14, %rdi
callq 0x7b512
movq %rax, 0x10(%rbx,%r13)
testq %rax, %rax
jne 0x786a4
jmp 0x78750
movq $0x0, 0x10(%rbx,%r13)
movl 0x5c(%r12,%r13), %eax
movl %eax, 0x5c(%rbx,%r13)
movl 0x6c(%r12,%r13), %eax
movl %eax, 0x6c(%rbx,%r13)
movl 0x58(%r12,%r13), %eax
movl %eax, 0x58(%rbx,%r13)
movl 0x68(%r12,%r13), %eax
movl %eax, 0x68(%rbx,%r13)
movl 0x60(%r12,%r13), %eax
movl %eax, 0x60(%rbx,%r13)
movq 0x78(%r12,%r13), %rsi
testq %rsi, %rsi
je 0x786ea
movq %r14, %rdi
callq 0x75001
jmp 0x786ec
xorl %eax, %eax
movq %rax, 0x78(%rbx,%r13)
movl 0x64(%r12,%r13), %eax
movl %eax, 0x64(%rbx,%r13)
movq 0x38(%r12,%r13), %rax
movq %rax, 0x38(%rbx,%r13)
movq 0x40(%r12,%r13), %rax
movq %rax, 0x40(%rbx,%r13)
movl 0x48(%r12,%r13), %eax
movl %eax, 0x48(%rbx,%r13)
movl 0x4c(%r12,%r13), %eax
movl %eax, 0x4c(%rbx,%r13)
movl 0x54(%r12,%r13), %eax
movl %eax, 0x54(%rbx,%r13)
movl 0x50(%r12,%r13), %eax
movl %eax, 0x50(%rbx,%r13)
movl 0x70(%r12,%r13), %eax
movl %eax, 0x70(%rbx,%r13)
subq $-0x80, %r13
decq %r15
jne 0x78581
jmp 0x78752
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| ma_duplicate_resultset_metadata:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov r12, rdi
shl rsi, 7
mov rdi, rdx
call ma_alloc_root
test rax, rax
jz loc_78750
mov rbx, rax
test r15, r15
jz loc_78752
xor r13d, r13d
loc_78581:
mov rsi, [r12+r13+28h]
test rsi, rsi
jz short loc_785A2
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+28h], rax
test rax, rax
jnz short loc_785AB
jmp loc_78750
loc_785A2:
mov qword ptr [rbx+r13+28h], 0
loc_785AB:
mov rsi, [r12+r13+20h]
test rsi, rsi
jz short loc_785CC
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+20h], rax
test rax, rax
jnz short loc_785D5
jmp loc_78750
loc_785CC:
mov qword ptr [rbx+r13+20h], 0
loc_785D5:
mov rsi, [r12+r13+30h]
test rsi, rsi
jz short loc_785F6
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+30h], rax
test rax, rax
jnz short loc_785FF
jmp loc_78750
loc_785F6:
mov qword ptr [rbx+r13+30h], 0
loc_785FF:
mov rsi, [r12+r13]
test rsi, rsi
jz short loc_7861E
mov rdi, r14
call ma_strdup_root
mov [rbx+r13], rax
test rax, rax
jnz short loc_78626
jmp loc_78750
loc_7861E:
mov qword ptr [rbx+r13], 0
loc_78626:
mov rsi, [r12+r13+8]
test rsi, rsi
jz short loc_78647
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+8], rax
test rax, rax
jnz short loc_78650
jmp loc_78750
loc_78647:
mov qword ptr [rbx+r13+8], 0
loc_78650:
mov rsi, [r12+r13+18h]
test rsi, rsi
jz short loc_78671
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+18h], rax
test rax, rax
jnz short loc_7867A
jmp loc_78750
loc_78671:
mov qword ptr [rbx+r13+18h], 0
loc_7867A:
mov rsi, [r12+r13+10h]
test rsi, rsi
jz short loc_7869B
mov rdi, r14
call ma_strdup_root
mov [rbx+r13+10h], rax
test rax, rax
jnz short loc_786A4
jmp loc_78750
loc_7869B:
mov qword ptr [rbx+r13+10h], 0
loc_786A4:
mov eax, [r12+r13+5Ch]
mov [rbx+r13+5Ch], eax
mov eax, [r12+r13+6Ch]
mov [rbx+r13+6Ch], eax
mov eax, [r12+r13+58h]
mov [rbx+r13+58h], eax
mov eax, [r12+r13+68h]
mov [rbx+r13+68h], eax
mov eax, [r12+r13+60h]
mov [rbx+r13+60h], eax
mov rsi, [r12+r13+78h]
test rsi, rsi
jz short loc_786EA
mov rdi, r14
call ma_field_extension_deep_dup
jmp short loc_786EC
loc_786EA:
xor eax, eax
loc_786EC:
mov [rbx+r13+78h], rax
mov eax, [r12+r13+64h]
mov [rbx+r13+64h], eax
mov rax, [r12+r13+38h]
mov [rbx+r13+38h], rax
mov rax, [r12+r13+40h]
mov [rbx+r13+40h], rax
mov eax, [r12+r13+48h]
mov [rbx+r13+48h], eax
mov eax, [r12+r13+4Ch]
mov [rbx+r13+4Ch], eax
mov eax, [r12+r13+54h]
mov [rbx+r13+54h], eax
mov eax, [r12+r13+50h]
mov [rbx+r13+50h], eax
mov eax, [r12+r13+70h]
mov [rbx+r13+70h], eax
sub r13, 0FFFFFFFFFFFFFF80h
dec r15
jnz loc_78581
jmp short loc_78752
loc_78750:
xor ebx, ebx
loc_78752:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_duplicate_resultset_metadata(long long a1, long long a2, long long a3)
{
long long v4; // r15
long long v5; // rax
long long v6; // rbx
long long v7; // r13
long long v8; // rax
long long v9; // rax
long long v10; // rax
long long v11; // rax
long long v12; // rax
long long v13; // rax
long long v14; // rax
long long *v15; // rsi
long long *v16; // rax
v4 = a2;
v5 = ma_alloc_root(a3, a2 << 7);
if ( !v5 )
return 0LL;
v6 = v5;
if ( a2 )
{
v7 = 0LL;
do
{
if ( *(_QWORD *)(a1 + v7 + 40) )
{
v8 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 40) = v8;
if ( !v8 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 40) = 0LL;
}
if ( *(_QWORD *)(a1 + v7 + 32) )
{
v9 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 32) = v9;
if ( !v9 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 32) = 0LL;
}
if ( *(_QWORD *)(a1 + v7 + 48) )
{
v10 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 48) = v10;
if ( !v10 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 48) = 0LL;
}
if ( *(_QWORD *)(a1 + v7) )
{
v11 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7) = v11;
if ( !v11 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7) = 0LL;
}
if ( *(_QWORD *)(a1 + v7 + 8) )
{
v12 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 8) = v12;
if ( !v12 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 8) = 0LL;
}
if ( *(_QWORD *)(a1 + v7 + 24) )
{
v13 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 24) = v13;
if ( !v13 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 24) = 0LL;
}
if ( *(_QWORD *)(a1 + v7 + 16) )
{
v14 = ma_strdup_root(a3);
*(_QWORD *)(v6 + v7 + 16) = v14;
if ( !v14 )
return 0LL;
}
else
{
*(_QWORD *)(v6 + v7 + 16) = 0LL;
}
*(_DWORD *)(v6 + v7 + 92) = *(_DWORD *)(a1 + v7 + 92);
*(_DWORD *)(v6 + v7 + 108) = *(_DWORD *)(a1 + v7 + 108);
*(_DWORD *)(v6 + v7 + 88) = *(_DWORD *)(a1 + v7 + 88);
*(_DWORD *)(v6 + v7 + 104) = *(_DWORD *)(a1 + v7 + 104);
*(_DWORD *)(v6 + v7 + 96) = *(_DWORD *)(a1 + v7 + 96);
v15 = *(long long **)(a1 + v7 + 120);
if ( v15 )
v16 = ma_field_extension_deep_dup(a3, v15);
else
v16 = 0LL;
*(_QWORD *)(v6 + v7 + 120) = v16;
*(_DWORD *)(v6 + v7 + 100) = *(_DWORD *)(a1 + v7 + 100);
*(_QWORD *)(v6 + v7 + 56) = *(_QWORD *)(a1 + v7 + 56);
*(_QWORD *)(v6 + v7 + 64) = *(_QWORD *)(a1 + v7 + 64);
*(_DWORD *)(v6 + v7 + 72) = *(_DWORD *)(a1 + v7 + 72);
*(_DWORD *)(v6 + v7 + 76) = *(_DWORD *)(a1 + v7 + 76);
*(_DWORD *)(v6 + v7 + 84) = *(_DWORD *)(a1 + v7 + 84);
*(_DWORD *)(v6 + v7 + 80) = *(_DWORD *)(a1 + v7 + 80);
*(_DWORD *)(v6 + v7 + 112) = *(_DWORD *)(a1 + v7 + 112);
v7 += 128LL;
--v4;
}
while ( v4 );
}
return v6;
}
| ma_duplicate_resultset_metadata:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV R12,RDI
SHL RSI,0x7
MOV RDI,RDX
CALL 0x0017b36f
TEST RAX,RAX
JZ 0x00178750
MOV RBX,RAX
TEST R15,R15
JZ 0x00178752
XOR R13D,R13D
LAB_00178581:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x28]
TEST RSI,RSI
JZ 0x001785a2
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x28],RAX
TEST RAX,RAX
JNZ 0x001785ab
JMP 0x00178750
LAB_001785a2:
MOV qword ptr [RBX + R13*0x1 + 0x28],0x0
LAB_001785ab:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x20]
TEST RSI,RSI
JZ 0x001785cc
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x20],RAX
TEST RAX,RAX
JNZ 0x001785d5
JMP 0x00178750
LAB_001785cc:
MOV qword ptr [RBX + R13*0x1 + 0x20],0x0
LAB_001785d5:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x30]
TEST RSI,RSI
JZ 0x001785f6
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x30],RAX
TEST RAX,RAX
JNZ 0x001785ff
JMP 0x00178750
LAB_001785f6:
MOV qword ptr [RBX + R13*0x1 + 0x30],0x0
LAB_001785ff:
MOV RSI,qword ptr [R12 + R13*0x1]
TEST RSI,RSI
JZ 0x0017861e
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1],RAX
TEST RAX,RAX
JNZ 0x00178626
JMP 0x00178750
LAB_0017861e:
MOV qword ptr [RBX + R13*0x1],0x0
LAB_00178626:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x8]
TEST RSI,RSI
JZ 0x00178647
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x8],RAX
TEST RAX,RAX
JNZ 0x00178650
JMP 0x00178750
LAB_00178647:
MOV qword ptr [RBX + R13*0x1 + 0x8],0x0
LAB_00178650:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x18]
TEST RSI,RSI
JZ 0x00178671
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x18],RAX
TEST RAX,RAX
JNZ 0x0017867a
JMP 0x00178750
LAB_00178671:
MOV qword ptr [RBX + R13*0x1 + 0x18],0x0
LAB_0017867a:
MOV RSI,qword ptr [R12 + R13*0x1 + 0x10]
TEST RSI,RSI
JZ 0x0017869b
MOV RDI,R14
CALL 0x0017b512
MOV qword ptr [RBX + R13*0x1 + 0x10],RAX
TEST RAX,RAX
JNZ 0x001786a4
JMP 0x00178750
LAB_0017869b:
MOV qword ptr [RBX + R13*0x1 + 0x10],0x0
LAB_001786a4:
MOV EAX,dword ptr [R12 + R13*0x1 + 0x5c]
MOV dword ptr [RBX + R13*0x1 + 0x5c],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x6c]
MOV dword ptr [RBX + R13*0x1 + 0x6c],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x58]
MOV dword ptr [RBX + R13*0x1 + 0x58],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x68]
MOV dword ptr [RBX + R13*0x1 + 0x68],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x60]
MOV dword ptr [RBX + R13*0x1 + 0x60],EAX
MOV RSI,qword ptr [R12 + R13*0x1 + 0x78]
TEST RSI,RSI
JZ 0x001786ea
MOV RDI,R14
CALL 0x00175001
JMP 0x001786ec
LAB_001786ea:
XOR EAX,EAX
LAB_001786ec:
MOV qword ptr [RBX + R13*0x1 + 0x78],RAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x64]
MOV dword ptr [RBX + R13*0x1 + 0x64],EAX
MOV RAX,qword ptr [R12 + R13*0x1 + 0x38]
MOV qword ptr [RBX + R13*0x1 + 0x38],RAX
MOV RAX,qword ptr [R12 + R13*0x1 + 0x40]
MOV qword ptr [RBX + R13*0x1 + 0x40],RAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x48]
MOV dword ptr [RBX + R13*0x1 + 0x48],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x4c]
MOV dword ptr [RBX + R13*0x1 + 0x4c],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x54]
MOV dword ptr [RBX + R13*0x1 + 0x54],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x50]
MOV dword ptr [RBX + R13*0x1 + 0x50],EAX
MOV EAX,dword ptr [R12 + R13*0x1 + 0x70]
MOV dword ptr [RBX + R13*0x1 + 0x70],EAX
SUB R13,-0x80
DEC R15
JNZ 0x00178581
JMP 0x00178752
LAB_00178750:
XOR EBX,EBX
LAB_00178752:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long ma_duplicate_resultset_metadata(long param_1,long param_2,int8 param_3)
{
long lVar1;
long lVar2;
int8 uVar3;
long lVar4;
lVar1 = ma_alloc_root(param_3,param_2 << 7);
if (lVar1 == 0) {
LAB_00178750:
lVar1 = 0;
}
else if (param_2 != 0) {
lVar4 = 0;
do {
if (*(long *)(param_1 + 0x28 + lVar4) == 0) {
*(int8 *)(lVar1 + 0x28 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 0x28 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + 0x20 + lVar4) == 0) {
*(int8 *)(lVar1 + 0x20 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 0x20 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + 0x30 + lVar4) == 0) {
*(int8 *)(lVar1 + 0x30 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 0x30 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + lVar4) == 0) {
*(int8 *)(lVar1 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + 8 + lVar4) == 0) {
*(int8 *)(lVar1 + 8 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 8 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + 0x18 + lVar4) == 0) {
*(int8 *)(lVar1 + 0x18 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 0x18 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
if (*(long *)(param_1 + 0x10 + lVar4) == 0) {
*(int8 *)(lVar1 + 0x10 + lVar4) = 0;
}
else {
lVar2 = ma_strdup_root(param_3);
*(long *)(lVar1 + 0x10 + lVar4) = lVar2;
if (lVar2 == 0) goto LAB_00178750;
}
*(int4 *)(lVar1 + 0x5c + lVar4) = *(int4 *)(param_1 + 0x5c + lVar4);
*(int4 *)(lVar1 + 0x6c + lVar4) = *(int4 *)(param_1 + 0x6c + lVar4);
*(int4 *)(lVar1 + 0x58 + lVar4) = *(int4 *)(param_1 + 0x58 + lVar4);
*(int4 *)(lVar1 + 0x68 + lVar4) = *(int4 *)(param_1 + 0x68 + lVar4);
*(int4 *)(lVar1 + 0x60 + lVar4) = *(int4 *)(param_1 + 0x60 + lVar4);
if (*(long *)(param_1 + 0x78 + lVar4) == 0) {
uVar3 = 0;
}
else {
uVar3 = ma_field_extension_deep_dup(param_3);
}
*(int8 *)(lVar1 + 0x78 + lVar4) = uVar3;
*(int4 *)(lVar1 + 100 + lVar4) = *(int4 *)(param_1 + 100 + lVar4);
*(int8 *)(lVar1 + 0x38 + lVar4) = *(int8 *)(param_1 + 0x38 + lVar4);
*(int8 *)(lVar1 + 0x40 + lVar4) = *(int8 *)(param_1 + 0x40 + lVar4);
*(int4 *)(lVar1 + 0x48 + lVar4) = *(int4 *)(param_1 + 0x48 + lVar4);
*(int4 *)(lVar1 + 0x4c + lVar4) = *(int4 *)(param_1 + 0x4c + lVar4);
*(int4 *)(lVar1 + 0x54 + lVar4) = *(int4 *)(param_1 + 0x54 + lVar4);
*(int4 *)(lVar1 + 0x50 + lVar4) = *(int4 *)(param_1 + 0x50 + lVar4);
*(int4 *)(lVar1 + 0x70 + lVar4) = *(int4 *)(param_1 + 0x70 + lVar4);
lVar4 = lVar4 + 0x80;
param_2 = param_2 + -1;
} while (param_2 != 0);
}
return lVar1;
}
| |
23,678 | common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&) | monkey531[P]llama/common/common.cpp | void common_set_adapter_lora(struct llama_context * ctx, std::vector<common_adapter_lora_info> & lora) {
llama_clear_adapter_lora(ctx);
for (auto & la : lora) {
if (la.scale != 0.0f) {
llama_set_adapter_lora(ctx, la.ptr, la.scale);
}
}
} | O1 | cpp | common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info, std::allocator<common_adapter_lora_info>>&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1a800
movq (%r14), %r15
movq 0x8(%r14), %r14
cmpq %r14, %r15
je 0x266f2
movss 0x20(%r15), %xmm0
ucomiss 0x89c8c(%rip), %xmm0 # 0xb0368
jne 0x266e0
jnp 0x266ec
movq 0x28(%r15), %rsi
movq %rbx, %rdi
callq 0x1a7e0
addq $0x30, %r15
jmp 0x266ca
popq %rbx
popq %r14
popq %r15
retq
| _Z23common_set_adapter_loraP13llama_contextRSt6vectorI24common_adapter_lora_infoSaIS2_EE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
call _llama_clear_adapter_lora
mov r15, [r14]
mov r14, [r14+8]
loc_266CA:
cmp r15, r14
jz short loc_266F2
movss xmm0, dword ptr [r15+20h]
ucomiss xmm0, cs:dword_B0368
jnz short loc_266E0
jnp short loc_266EC
loc_266E0:
mov rsi, [r15+28h]
mov rdi, rbx
call _llama_set_adapter_lora
loc_266EC:
add r15, 30h ; '0'
jmp short loc_266CA
loc_266F2:
pop rbx
pop r14
pop r15
retn
| long long common_set_adapter_lora(long long a1, long long *a2)
{
long long result; // rax
long long v3; // r15
long long v4; // r14
result = llama_clear_adapter_lora();
v3 = *a2;
v4 = a2[1];
while ( v3 != v4 )
{
if ( *(float *)(v3 + 32) != 0.0 )
result = llama_set_adapter_lora(a1, *(_QWORD *)(v3 + 40));
v3 += 48LL;
}
return result;
}
| common_set_adapter_lora:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
CALL 0x0011a800
MOV R15,qword ptr [R14]
MOV R14,qword ptr [R14 + 0x8]
LAB_001266ca:
CMP R15,R14
JZ 0x001266f2
MOVSS XMM0,dword ptr [R15 + 0x20]
UCOMISS XMM0,dword ptr [0x001b0368]
JNZ 0x001266e0
JNP 0x001266ec
LAB_001266e0:
MOV RSI,qword ptr [R15 + 0x28]
MOV RDI,RBX
CALL 0x0011a7e0
LAB_001266ec:
ADD R15,0x30
JMP 0x001266ca
LAB_001266f2:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_set_adapter_lora(llama_context*, std::vector<common_adapter_lora_info,
std::allocator<common_adapter_lora_info> >&) */
void common_set_adapter_lora(llama_context *param_1,vector *param_2)
{
long lVar1;
long lVar2;
llama_clear_adapter_lora();
lVar1 = *(long *)(param_2 + 8);
for (lVar2 = *(long *)param_2; lVar2 != lVar1; lVar2 = lVar2 + 0x30) {
if ((*(float *)(lVar2 + 0x20) != _DAT_001b0368) ||
(NAN(*(float *)(lVar2 + 0x20)) || NAN(_DAT_001b0368))) {
llama_set_adapter_lora(param_1,*(int8 *)(lVar2 + 0x28));
}
}
return;
}
| |
23,679 | nglog::LogDestination::~LogDestination() | ng-log[P]ng-log/src/logging.cc | void LogDestination::SetLoggerImpl(base::Logger* logger) {
if (logger_ == logger) {
// Prevent releasing currently held sink on reset
return;
}
if (logger_ && logger_ != &fileobject_) {
// Delete user-specified logger set via SetLogger().
delete logger_;
}
logger_ = logger;
} | O3 | cpp | nglog::LogDestination::~LogDestination():
pushq %rbx
movq %rdi, %rbx
movq 0xc8(%rdi), %rdi
cmpq %rbx, %rdi
je 0xa196
testq %rdi, %rdi
je 0xa18f
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, 0xc8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xa19c
| _ZN5nglog14LogDestinationD2Ev:
push rbx; Alternative name is 'nglog::LogDestination::~LogDestination()'
mov rbx, rdi
mov rdi, [rdi+0C8h]
cmp rdi, rbx
jz short loc_A196
test rdi, rdi
jz short loc_A18F
mov rax, [rdi]
call qword ptr [rax+8]
loc_A18F:
mov [rbx+0C8h], rbx
loc_A196:
mov rdi, rbx; this
pop rbx
jmp short $+2; nglog::`anonymous namespace'::LogFileObject::~LogFileObject()
| void nglog::LogDestination::~LogDestination(nglog::LogDestination *this)
{
nglog::LogDestination *v2; // rdi
v2 = (nglog::LogDestination *)*((_QWORD *)this + 25);
if ( v2 != this )
{
if ( v2 )
(*(void ( **)(nglog::LogDestination *))(*(_QWORD *)v2 + 8LL))(v2);
*((_QWORD *)this + 25) = this;
}
nglog::`anonymous namespace'::LogFileObject::~LogFileObject(this);
}
| ~LogDestination:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0xc8]
CMP RDI,RBX
JZ 0x0010a196
TEST RDI,RDI
JZ 0x0010a18f
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010a18f:
MOV qword ptr [RBX + 0xc8],RBX
LAB_0010a196:
MOV RDI,RBX
POP RBX
JMP 0x0010a19c
|
/* nglog::LogDestination::~LogDestination() */
void __thiscall nglog::LogDestination::~LogDestination(LogDestination *this)
{
LogDestination *pLVar1;
pLVar1 = *(LogDestination **)(this + 200);
if (pLVar1 != this) {
if (pLVar1 != (LogDestination *)0x0) {
(**(code **)(*(long *)pLVar1 + 8))();
}
*(LogDestination **)(this + 200) = this;
}
(anonymous_namespace)::LogFileObject::~LogFileObject((LogFileObject *)this);
return;
}
| |
23,680 | hi0bits | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static int hi0bits(register ULong x)
{
register int k= 0;
if (!(x & 0xffff0000))
{
k= 16;
x<<= 16;
}
if (!(x & 0xff000000))
{
k+= 8;
x<<= 8;
}
if (!(x & 0xf0000000))
{
k+= 4;
x<<= 4;
}
if (!(x & 0xc0000000))
{
k+= 2;
x<<= 2;
}
if (!(x & 0x80000000))
{
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | O3 | c | hi0bits:
pushq %rbp
movq %rsp, %rbp
movl %edi, %eax
shll $0x10, %eax
xorl %ecx, %ecx
cmpl $0x10000, %edi # imm = 0x10000
setb %cl
cmovael %edi, %eax
shll $0x4, %ecx
movl %eax, %edx
shll $0x8, %edx
cmpl $0x1000000, %eax # imm = 0x1000000
cmovael %eax, %edx
leal 0x8(%rcx), %eax
cmovael %ecx, %eax
movl %edx, %ecx
shll $0x4, %ecx
cmpl $0x10000000, %edx # imm = 0x10000000
cmovael %edx, %ecx
leal 0x4(%rax), %edx
cmovael %eax, %edx
leal (,%rcx,4), %esi
movl $0x40000000, %eax # imm = 0x40000000
cmpl %eax, %ecx
cmovael %ecx, %esi
leal 0x2(%rdx), %ecx
cmovael %edx, %ecx
leal 0x1(%rcx), %edx
cmpl %eax, %esi
movl $0x20, %eax
cmovael %edx, %eax
testl %esi, %esi
cmovsl %ecx, %eax
popq %rbp
retq
| hi0bits:
push rbp
mov rbp, rsp
mov eax, edi
shl eax, 10h
xor ecx, ecx
cmp edi, 10000h
setb cl
cmovnb eax, edi
shl ecx, 4
mov edx, eax
shl edx, 8
cmp eax, 1000000h
cmovnb edx, eax
lea eax, [rcx+8]
cmovnb eax, ecx
mov ecx, edx
shl ecx, 4
cmp edx, 10000000h
cmovnb ecx, edx
lea edx, [rax+4]
cmovnb edx, eax
lea esi, ds:0[rcx*4]
mov eax, 40000000h
cmp ecx, eax
cmovnb esi, ecx
lea ecx, [rdx+2]
cmovnb ecx, edx
lea edx, [rcx+1]
cmp esi, eax
mov eax, 20h ; ' '
cmovnb eax, edx
test esi, esi
cmovs eax, ecx
pop rbp
retn
| long long hi0bits(unsigned int a1)
{
unsigned int v1; // eax
unsigned int v2; // edx
bool v3; // cf
int v4; // eax
unsigned int v5; // ecx
bool v6; // cf
int v7; // edx
int v8; // esi
bool v9; // cf
unsigned int v10; // ecx
long long result; // rax
v1 = a1 << 16;
if ( a1 >= 0x10000 )
v1 = a1;
v2 = v1 << 8;
v3 = v1 < 0x1000000;
if ( v1 >= 0x1000000 )
v2 = v1;
v4 = 16 * (a1 < 0x10000) + 8;
if ( !v3 )
v4 = 16 * (a1 < 0x10000);
v5 = 16 * v2;
v6 = v2 < 0x10000000;
if ( v2 >= 0x10000000 )
v5 = v2;
v7 = v4 + 4;
if ( !v6 )
v7 = v4;
v8 = 4 * v5;
v9 = v5 < 0x40000000;
if ( v5 >= 0x40000000 )
v8 = v5;
v10 = v7 + 2;
if ( !v9 )
v10 = v7;
result = 32LL;
if ( (unsigned int)v8 >= 0x40000000 )
result = v10 + 1;
if ( v8 < 0 )
return v10;
return result;
}
| hi0bits:
PUSH RBP
MOV RBP,RSP
MOV EAX,EDI
SHL EAX,0x10
XOR ECX,ECX
CMP EDI,0x10000
SETC CL
CMOVNC EAX,EDI
SHL ECX,0x4
MOV EDX,EAX
SHL EDX,0x8
CMP EAX,0x1000000
CMOVNC EDX,EAX
LEA EAX,[RCX + 0x8]
CMOVNC EAX,ECX
MOV ECX,EDX
SHL ECX,0x4
CMP EDX,0x10000000
CMOVNC ECX,EDX
LEA EDX,[RAX + 0x4]
CMOVNC EDX,EAX
LEA ESI,[RCX*0x4]
MOV EAX,0x40000000
CMP ECX,EAX
CMOVNC ESI,ECX
LEA ECX,[RDX + 0x2]
CMOVNC ECX,EDX
LEA EDX,[RCX + 0x1]
CMP ESI,EAX
MOV EAX,0x20
CMOVNC EAX,EDX
TEST ESI,ESI
CMOVS EAX,ECX
POP RBP
RET
|
int hi0bits(uint param_1)
{
uint uVar1;
uint uVar2;
int iVar3;
int iVar4;
uVar2 = param_1 << 0x10;
if (param_1 >= 0x10000) {
uVar2 = param_1;
}
iVar4 = (uint)(param_1 < 0x10000) * 0x10;
uVar1 = uVar2 << 8;
if (0xffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 8;
if (0xffffff < uVar2) {
iVar3 = iVar4;
}
uVar2 = uVar1 << 4;
if (0xfffffff < uVar1) {
uVar2 = uVar1;
}
iVar4 = iVar3 + 4;
if (0xfffffff < uVar1) {
iVar4 = iVar3;
}
uVar1 = uVar2 * 4;
if (0x3fffffff < uVar2) {
uVar1 = uVar2;
}
iVar3 = iVar4 + 2;
if (0x3fffffff < uVar2) {
iVar3 = iVar4;
}
iVar4 = 0x20;
if (0x3fffffff < uVar1) {
iVar4 = iVar3 + 1;
}
if ((int)uVar1 < 0) {
iVar4 = iVar3;
}
return iVar4;
}
| |
23,681 | rec_get_nth_field_offs_old(unsigned char const*, unsigned long, unsigned long*) | eloqsql/storage/innobase/rem/rem0rec.cc | ulint
rec_get_nth_field_offs_old(
/*=======================*/
const rec_t* rec, /*!< in: record */
ulint n, /*!< in: index of the field */
ulint* len) /*!< out: length of the field;
UNIV_SQL_NULL if SQL null */
{
ulint os;
ulint next_os;
ut_a(n < rec_get_n_fields_old(rec));
if (rec_get_1byte_offs_flag(rec)) {
os = rec_1_get_field_start_offs(rec, n);
next_os = rec_1_get_field_end_info(rec, n);
if (next_os & REC_1BYTE_SQL_NULL_MASK) {
*len = UNIV_SQL_NULL;
return(os);
}
next_os = next_os & ~REC_1BYTE_SQL_NULL_MASK;
} else {
os = rec_2_get_field_start_offs(rec, n);
next_os = rec_2_get_field_end_info(rec, n);
if (next_os & REC_2BYTE_SQL_NULL_MASK) {
*len = UNIV_SQL_NULL;
return(os);
}
next_os = next_os & ~(REC_2BYTE_SQL_NULL_MASK
| REC_2BYTE_EXTERN_MASK);
}
*len = next_os - os;
ut_ad(*len < srv_page_size);
return(os);
} | O0 | cpp | rec_get_nth_field_offs_old(unsigned char const*, unsigned long, unsigned long*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x108eaf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
setb %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x108fb9a
jmp 0x108fbb2
leaq 0x390faf(%rip), %rdi # 0x1420b50
leaq 0x390f5f(%rip), %rsi # 0x1420b07
movl $0x442, %edx # imm = 0x442
callq 0x113f2c0
jmp 0x108fbb4
movq -0x10(%rbp), %rdi
callq 0x108fca0
cmpq $0x0, %rax
je 0x108fc21
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x108fcd0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x108fd20
movzbl %al, %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x108fc11
movq -0x20(%rbp), %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x108fc93
movq -0x30(%rbp), %rax
andq $-0x81, %rax
movq %rax, -0x30(%rbp)
jmp 0x108fc7a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x108fd60
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x108fdb0
movzwl %ax, %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
andq $0x8000, %rax # imm = 0x8000
cmpq $0x0, %rax
je 0x108fc6c
movq -0x20(%rbp), %rax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x108fc93
movq -0x30(%rbp), %rax
andq $-0xc001, %rax # imm = 0xFFFF3FFF
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
subq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x108fc8b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| _Z26rec_get_nth_field_offs_oldPKhmPm:
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_18]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]; unsigned __int8 *
call _ZL20rec_get_n_fields_oldPKh_1; rec_get_n_fields_old(uchar const*)
mov rcx, rax
mov rax, [rbp+var_38]
cmp rax, rcx
setb al
xor al, 0FFh
test al, 1
jnz short loc_108FB9A
jmp short loc_108FBB2
loc_108FB9A:
lea rdi, aNRecGetNFields; "n < rec_get_n_fields_old(rec)"
lea rsi, aWorkspaceLlm4b_229; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 442h; unsigned int
call _Z23ut_dbg_assertion_failedPKcS0_j; ut_dbg_assertion_failed(char const*,char const*,uint)
loc_108FBB2:
jmp short $+2
loc_108FBB4:
mov rdi, [rbp+var_10]; unsigned __int8 *
call _ZL23rec_get_1byte_offs_flagPKh_2; rec_get_1byte_offs_flag(uchar const*)
cmp rax, 0
jz short loc_108FC21
mov rdi, [rbp+var_10]; unsigned __int8 *
mov rsi, [rbp+var_18]; unsigned __int64
call _ZL26rec_1_get_field_start_offsPKhm_0; rec_1_get_field_start_offs(uchar const*,ulong)
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]; unsigned __int8 *
mov rsi, [rbp+var_18]; unsigned __int64
call _ZL24rec_1_get_field_end_infoPKhm_1; rec_1_get_field_end_info(uchar const*,ulong)
movzx eax, al
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
and rax, 80h
cmp rax, 0
jz short loc_108FC11
mov rax, [rbp+var_20]
mov ecx, 0FFFFFFFFh
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp loc_108FC93
loc_108FC11:
mov rax, [rbp+var_30]
and rax, 0FFFFFFFFFFFFFF7Fh
mov [rbp+var_30], rax
jmp short loc_108FC7A
loc_108FC21:
mov rdi, [rbp+var_10]; unsigned __int8 *
mov rsi, [rbp+var_18]; unsigned __int64
call _ZL26rec_2_get_field_start_offsPKhm_0; rec_2_get_field_start_offs(uchar const*,ulong)
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]; unsigned __int8 *
mov rsi, [rbp+var_18]; unsigned __int64
call _ZL24rec_2_get_field_end_infoPKhm_1; rec_2_get_field_end_info(uchar const*,ulong)
movzx eax, ax
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
and rax, 8000h
cmp rax, 0
jz short loc_108FC6C
mov rax, [rbp+var_20]
mov ecx, 0FFFFFFFFh
mov [rax], rcx
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
jmp short loc_108FC93
loc_108FC6C:
mov rax, [rbp+var_30]
and rax, 0FFFFFFFFFFFF3FFFh
mov [rbp+var_30], rax
loc_108FC7A:
mov rcx, [rbp+var_30]
sub rcx, [rbp+var_28]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short $+2
loc_108FC8B:
mov rax, [rbp+var_28]
mov [rbp+var_8], rax
loc_108FC93:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long rec_get_nth_field_offs_old(const unsigned __int8 *a1, unsigned long long a2, unsigned long long *a3)
{
char v3; // al
__int16 field_end_info; // ax
long long v6; // [rsp+10h] [rbp-30h]
long long field_start_offs; // [rsp+18h] [rbp-28h]
if ( a2 >= rec_get_n_fields_old(a1) )
ut_dbg_assertion_failed(
"n < rec_get_n_fields_old(rec)",
"/workspace/llm4binary/github2025/eloqsql/storage/innobase/rem/rem0rec.cc",
0x442u);
if ( !rec_get_1byte_offs_flag(a1) )
{
field_start_offs = rec_2_get_field_start_offs(a1, a2);
field_end_info = rec_2_get_field_end_info(a1, a2);
if ( field_end_info < 0 )
{
*a3 = 0xFFFFFFFFLL;
return field_start_offs;
}
v6 = field_end_info & 0x3FFF;
LABEL_10:
*a3 = v6 - field_start_offs;
return field_start_offs;
}
field_start_offs = rec_1_get_field_start_offs(a1, a2);
v3 = rec_1_get_field_end_info(a1, a2);
if ( (v3 & 0x80) == 0 )
{
v6 = v3 & 0x7F;
goto LABEL_10;
}
*a3 = 0xFFFFFFFFLL;
return field_start_offs;
}
| ~_Vector_base:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
MOV RSI,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x10]
SUB RDX,RSI
LAB_0108fb7e:
CALL 0x0108fbe0
JMP 0x0108fb85
LAB_0108fb85:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0108fc40
ADD RSP,0x10
POP RBP
RET
|
/* std::_Vector_base<unsigned char, std::allocator<unsigned char> >::~_Vector_base() */
void __thiscall
std::_Vector_base<unsigned_char,std::allocator<unsigned_char>>::~_Vector_base
(_Vector_base<unsigned_char,std::allocator<unsigned_char>> *this)
{
/* try { // try from 0108fb7e to 0108fb82 has its CatchHandler @ 0108fb94 */
_M_deallocate(this,*(uchar **)this,*(long *)(this + 0x10) - (long)*(uchar **)this);
_Vector_impl::~_Vector_impl((_Vector_impl *)this);
return;
}
| |
23,682 | minja::Parser::parseIdentifier() | llama.cpp/common/minja/minja.hpp | std::shared_ptr<VariableExpr> parseIdentifier() {
static std::regex ident_regex(R"((?!(?:not|is|and|or|del)\b)[a-zA-Z_]\w*)");
auto location = get_location();
auto ident = consumeToken(ident_regex);
if (ident.empty())
return nullptr;
return std::make_shared<VariableExpr>(location, ident);
} | O3 | cpp | minja::Parser::parseIdentifier():
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x84f62(%rip), %rax # 0x167838
movb (%rax), %al
testb %al, %al
je 0xe2997
movq (%r15), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
je 0xe290b
movq 0x83693(%rip), %rcx # 0x165f90
cmpb $0x0, (%rcx)
je 0xe2907
incl 0x8(%rax)
jmp 0xe290b
lock
incl 0x8(%rax)
leaq 0x30(%rsp), %r14
movq 0x20(%r15), %rax
subq 0x10(%r15), %rax
movq %rax, 0x8(%r14)
leaq 0x84ef5(%rip), %rdx # 0x167818
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movl $0x1, %ecx
callq 0xe21ae
cmpq $0x0, 0x10(%rsp)
je 0xe2961
movq $0x0, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x7(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rsi
callq 0xf1ac6
jmp 0xe2967
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe2982
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x211a0
movq %r14, %rdi
callq 0x74104
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x84e9a(%rip), %rdi # 0x167838
callq 0x21640
testl %eax, %eax
je 0xe28e0
leaq 0x84e66(%rip), %rdi # 0x167818
leaq 0x42655(%rip), %rsi # 0x12500e
movl $0x10, %edx
callq 0x69a1e
leaq -0x78f00(%rip), %rdi # 0x69aca
leaq 0x84e47(%rip), %rsi # 0x167818
leaq 0x84200(%rip), %rdx # 0x166bd8
callq 0x22070
leaq 0x84e54(%rip), %rdi # 0x167838
callq 0x21a40
jmp 0xe28e0
movq %rax, %rbx
leaq 0x84e40(%rip), %rdi # 0x167838
callq 0x217b0
jmp 0xe2a2a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xe2a22
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x211a0
jmp 0xe2a22
movq %rax, %rbx
movq %r14, %rdi
callq 0x74104
movq %rbx, %rdi
callq 0x21c10
| _ZN5minja6Parser15parseIdentifierEv:
push r15
push r14
push rbx
sub rsp, 40h
mov r15, rsi
mov rbx, rdi
lea rax, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; `guard variable for'minja::Parser::parseIdentifier(void)::ident_regex
mov al, [rax]
test al, al
jz loc_E2997
loc_E28E0:
mov rax, [r15]
mov [rsp+58h+var_30], rax
mov rax, [r15+8]
mov [rsp+58h+var_28], rax
test rax, rax
jz short loc_E290B
mov rcx, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rcx], 0
jz short loc_E2907
inc dword ptr [rax+8]
jmp short loc_E290B
loc_E2907:
lock inc dword ptr [rax+8]
loc_E290B:
lea r14, [rsp+58h+var_28]
mov rax, [r15+20h]
sub rax, [r15+10h]
mov [r14+8], rax
lea rdx, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; int
lea rdi, [rsp+58h+var_50]; int
mov rsi, r15; int
mov ecx, 1; int
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
cmp [rsp+58h+var_48], 0
jz short loc_E2961
mov qword ptr [rbx], 0
lea rdi, [rbx+8]
lea rdx, [rsp+58h+var_51]
lea rcx, [rsp+58h+var_30]
lea r8, [rsp+58h+var_50]
mov rsi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5minja12VariableExprESaIvEJRNS4_8LocationERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::VariableExpr,std::allocator<void>,minja::Location &,std::string &>(minja::VariableExpr *&,std::_Sp_alloc_shared_tag<std::allocator<void>>,minja::Location &,std::string &)
jmp short loc_E2967
loc_E2961:
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
loc_E2967:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E2982
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E2982:
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop r15
retn
loc_E2997:
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_E28E0
lea rdi, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; minja::Parser::parseIdentifier(void)::ident_regex
lea rsi, aNotIsAndOrDelB; "(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\"...
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_E28E0
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser15parseIdentifierEvE11ident_regexB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_E2A2A
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_E2A22
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_E2A22
mov rbx, rax
loc_E2A22:
mov rdi, r14
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
loc_E2A2A:
mov rdi, rbx
call __Unwind_Resume
| minja::Parser * minja::Parser::parseIdentifier(minja::Parser *this, long long *a2)
{
volatile signed __int32 *v2; // rax
char v4; // [rsp+7h] [rbp-51h] BYREF
void *v5[2]; // [rsp+8h] [rbp-50h] BYREF
long long v6; // [rsp+18h] [rbp-40h] BYREF
long long v7; // [rsp+28h] [rbp-30h] BYREF
volatile signed __int32 *v8[5]; // [rsp+30h] [rbp-28h] BYREF
if ( !(_BYTE)`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
(long long)"(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\w*",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11]);
}
v7 = *a2;
v2 = (volatile signed __int32 *)a2[1];
v8[0] = v2;
if ( v2 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v2 + 2);
else
_InterlockedIncrement(v2 + 2);
}
v8[1] = (volatile signed __int32 *)(a2[4] - a2[2]);
minja::Parser::consumeToken(
v5,
(long long)a2,
(long long)&minja::Parser::parseIdentifier(void)::ident_regex[abi:cxx11],
1u);
if ( v5[1] )
{
*(_QWORD *)this = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<minja::VariableExpr,std::allocator<void>,minja::Location &,std::string &>(
(char *)this + 8,
this,
&v4,
&v7,
v5);
}
else
{
*(_OWORD *)this = 0LL;
}
if ( v5[0] != &v6 )
operator delete(v5[0], v6 + 1);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v8);
return this;
}
| parseIdentifier:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[0x267838]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x001e2997
LAB_001e28e0:
MOV RAX,qword ptr [R15]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [R15 + 0x8]
MOV qword ptr [RSP + 0x30],RAX
TEST RAX,RAX
JZ 0x001e290b
MOV RCX,qword ptr [0x00265f90]
CMP byte ptr [RCX],0x0
JZ 0x001e2907
INC dword ptr [RAX + 0x8]
JMP 0x001e290b
LAB_001e2907:
INC.LOCK dword ptr [RAX + 0x8]
LAB_001e290b:
LEA R14,[RSP + 0x30]
MOV RAX,qword ptr [R15 + 0x20]
SUB RAX,qword ptr [R15 + 0x10]
MOV qword ptr [R14 + 0x8],RAX
LAB_001e291c:
LEA RDX,[0x267818]
LEA RDI,[RSP + 0x8]
MOV RSI,R15
MOV ECX,0x1
CALL 0x001e21ae
CMP qword ptr [RSP + 0x10],0x0
JZ 0x001e2961
MOV qword ptr [RBX],0x0
LEA RDI,[RBX + 0x8]
LAB_001e2948:
LEA RDX,[RSP + 0x7]
LEA RCX,[RSP + 0x28]
LEA R8,[RSP + 0x8]
MOV RSI,RBX
CALL 0x001f1ac6
JMP 0x001e2967
LAB_001e2961:
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_001e2967:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001e2982
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001211a0
LAB_001e2982:
MOV RDI,R14
CALL 0x00174104
MOV RAX,RBX
ADD RSP,0x40
POP RBX
POP R14
POP R15
RET
LAB_001e2997:
LEA RDI,[0x267838]
CALL 0x00121640
TEST EAX,EAX
JZ 0x001e28e0
LAB_001e29ab:
LEA RDI,[0x267818]
LEA RSI,[0x22500e]
MOV EDX,0x10
CALL 0x00169a1e
LAB_001e29c3:
LEA RDI,[0x169aca]
LEA RSI,[0x267818]
LEA RDX,[0x266bd8]
CALL 0x00122070
LEA RDI,[0x267838]
CALL 0x00121a40
JMP 0x001e28e0
|
/* minja::Parser::parseIdentifier() */
void minja::Parser::parseIdentifier(void)
{
int iVar1;
int8 *in_RSI;
int8 *in_RDI;
long *local_50;
long local_48;
long local_40 [2];
int8 local_30;
long local_28;
long local_20;
if (parseIdentifier()::ident_regex_abi_cxx11_ == '\0') {
iVar1 = __cxa_guard_acquire(&parseIdentifier()::ident_regex_abi_cxx11_);
if (iVar1 != 0) {
/* try { // try from 001e29ab to 001e29c2 has its CatchHandler @ 001e29ee */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIdentifier()::ident_regex_abi_cxx11_,
"(?!(?:not|is|and|or|del)\\b)[a-zA-Z_]\\w*",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIdentifier()::ident_regex_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIdentifier()::ident_regex_abi_cxx11_);
}
}
local_30 = *in_RSI;
local_28 = in_RSI[1];
if (local_28 != 0) {
if (*PTR___libc_single_threaded_00265f90 == '\0') {
LOCK();
*(int *)(local_28 + 8) = *(int *)(local_28 + 8) + 1;
UNLOCK();
}
else {
*(int *)(local_28 + 8) = *(int *)(local_28 + 8) + 1;
}
}
local_20 = in_RSI[4] - in_RSI[2];
/* try { // try from 001e291c to 001e2934 has its CatchHandler @ 001e2a1f */
consumeToken(&local_50);
if (local_48 == 0) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
*in_RDI = 0;
/* try { // try from 001e2948 to 001e295e has its CatchHandler @ 001e29ff */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<minja::VariableExpr,std::allocator<void>,minja::Location&,std::__cxx11::string&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)(in_RDI + 1));
}
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
}
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_28);
return;
}
| |
23,683 | ftxui::separator(ftxui::Pixel) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/separator.cpp | Element separator(Pixel pixel) {
return std::make_shared<SeparatorWithPixel>(std::move(pixel));
} | O2 | cpp | ftxui::separator(ftxui::Pixel):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movl $0xa0, %edi
callq 0xc450
movq %rax, %r14
leaq 0x7(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x3113f(%rip), %rax # 0x506b0
movq %rax, (%r14)
leaq 0x10(%r14), %r15
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x1da30
movq %r15, %rdi
xorl %esi, %esi
callq 0x1f854
leaq 0x50(%rsp), %r12
leaq 0x31165(%rip), %rax # 0x50700
movq %rax, 0x10(%r14)
movq %r14, %rdi
addq $0x70, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1da30
orb $-0x80, 0x70(%r14)
leaq 0x20(%rsp), %rdi
callq 0xc8c8
leaq 0x8(%rsp), %rdi
andq $0x0, 0x8(%rdi)
callq 0x1fa84
movq %r15, (%rbx)
andq $0x0, (%r12)
movq %r14, 0x8(%rbx)
andq $0x0, -0x8(%r12)
movq %r12, %rdi
callq 0x13452
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xc8c8
leaq 0x8(%rsp), %rdi
callq 0x1fa84
movq %rbx, %rdi
callq 0xc7f0
| _ZN5ftxui9separatorENS_5PixelE:
push r15
push r14
push r12
push rbx
sub rsp, 58h
mov r12, rsi
mov rbx, rdi
mov edi, 0A0h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rax, [rsp+78h+var_71]
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_68], r14
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_506B0
mov [r14], rax
lea r15, [r14+10h]
lea rdi, [rsp+78h+var_60]
mov rsi, r12
call _ZN5ftxui5PixelC2EOS0_; ftxui::Pixel::Pixel(ftxui::Pixel&&)
mov rdi, r15
xor esi, esi
call _ZN5ftxui12_GLOBAL__N_113SeparatorAutoC2ENS_11BorderStyleE; ftxui::`anonymous namespace'::SeparatorAuto::SeparatorAuto(ftxui::BorderStyle)
lea r12, [rsp+78h+var_28]
lea rax, off_50700
mov [r14+10h], rax
mov rdi, r14
add rdi, 70h ; 'p'
lea rsi, [rsp+78h+var_60]
call _ZN5ftxui5PixelC2EOS0_; ftxui::Pixel::Pixel(ftxui::Pixel&&)
or byte ptr [r14+70h], 80h
lea rdi, [rsp+78h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+78h+var_70]
and qword ptr [rdi+8], 0
call _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceIN5ftxui12_GLOBAL__N_118SeparatorWithPixelESaIS3_ELN9__gnu_cxx12_Lock_policyE2EEEED2Ev; std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::SeparatorWithPixel,std::allocator<ftxui::`anonymous namespace'::SeparatorWithPixel>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr()
mov [rbx], r15
and qword ptr [r12], 0
mov [rbx+8], r14
and qword ptr [r12-8], 0
mov rdi, r12
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+arg_0]
call _ZNSt15__allocated_ptrISaISt23_Sp_counted_ptr_inplaceIN5ftxui12_GLOBAL__N_118SeparatorWithPixelESaIS3_ELN9__gnu_cxx12_Lock_policyE2EEEED2Ev; std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::SeparatorWithPixel,std::allocator<ftxui::`anonymous namespace'::SeparatorWithPixel>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr()
mov rdi, rbx
call __Unwind_Resume
| _QWORD * ftxui::separator(_QWORD *a1, long long a2)
{
long long v2; // r14
char v4; // [rsp+7h] [rbp-71h] BYREF
char *v5; // [rsp+8h] [rbp-70h]
long long v6; // [rsp+10h] [rbp-68h]
_BYTE v7[8]; // [rsp+18h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+20h] [rbp-58h] BYREF
long long v9; // [rsp+48h] [rbp-30h]
_QWORD v10[5]; // [rsp+50h] [rbp-28h] BYREF
v2 = operator new(0xA0uLL);
v5 = &v4;
v6 = v2;
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = off_506B0;
ftxui::Pixel::Pixel((long long)v7, a2);
ftxui::`anonymous namespace'::SeparatorAuto::SeparatorAuto(v2 + 16, 0LL);
*(_QWORD *)(v2 + 16) = off_50700;
ftxui::Pixel::Pixel(v2 + 112, (long long)v7);
*(_BYTE *)(v2 + 112) |= 0x80u;
std::string::~string(v8);
v6 = 0LL;
std::__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::`anonymous namespace'::SeparatorWithPixel,std::allocator<ftxui::`anonymous namespace'::SeparatorWithPixel>,(__gnu_cxx::_Lock_policy)2>>>::~__allocated_ptr();
*a1 = v2 + 16;
v10[0] = 0LL;
a1[1] = v2;
v9 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v10);
return a1;
}
| separator:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV R12,RSI
MOV RBX,RDI
MOV EDI,0xa0
CALL 0x0010c450
MOV R14,RAX
LEA RAX,[RSP + 0x7]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],R14
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x1506b0]
MOV qword ptr [R14],RAX
LEA R15,[R14 + 0x10]
LEA RDI,[RSP + 0x18]
MOV RSI,R12
CALL 0x0011da30
LAB_0011f585:
MOV RDI,R15
XOR ESI,ESI
CALL 0x0011f854
LAB_0011f58f:
LEA R12,[RSP + 0x50]
LEA RAX,[0x150700]
MOV qword ptr [R14 + 0x10],RAX
MOV RDI,R14
ADD RDI,0x70
LEA RSI,[RSP + 0x18]
CALL 0x0011da30
OR byte ptr [R14 + 0x70],0x80
LEA RDI,[RSP + 0x20]
CALL 0x0010c8c8
LEA RDI,[RSP + 0x8]
AND qword ptr [RDI + 0x8],0x0
CALL 0x0011fa84
MOV qword ptr [RBX],R15
AND qword ptr [R12],0x0
MOV qword ptr [RBX + 0x8],R14
AND qword ptr [R12 + -0x8],0x0
MOV RDI,R12
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::separator(ftxui::Pixel) */
ftxui * __thiscall ftxui::separator(ftxui *this,Pixel *param_2)
{
int8 *puVar1;
int1 local_71;
int1 *local_70;
int8 *local_68;
Pixel local_60 [8];
string local_58 [40];
int8 local_30;
int8 local_28;
puVar1 = (int8 *)operator_new(0xa0);
local_70 = &local_71;
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_001506b0;
local_68 = puVar1;
Pixel::Pixel(local_60,param_2);
/* try { // try from 0011f585 to 0011f58e has its CatchHandler @ 0011f5f7 */
(anonymous_namespace)::SeparatorAuto::SeparatorAuto((SeparatorAuto *)(puVar1 + 2),0);
puVar1[2] = &PTR__SeparatorWithPixel_00150700;
Pixel::Pixel((Pixel *)(puVar1 + 0xe),local_60);
*(byte *)(puVar1 + 0xe) = *(byte *)(puVar1 + 0xe) | 0x80;
std::__cxx11::string::~string(local_58);
local_68 = (int8 *)0x0;
std::
__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::(anonymous_namespace)::SeparatorWithPixel,std::allocator<ftxui::(anonymous_namespace)::SeparatorWithPixel>,(__gnu_cxx::_Lock_policy)2>>>
::~__allocated_ptr((__allocated_ptr<std::allocator<std::_Sp_counted_ptr_inplace<ftxui::(anonymous_namespace)::SeparatorWithPixel,std::allocator<ftxui::(anonymous_namespace)::SeparatorWithPixel>,(__gnu_cxx::_Lock_policy)2>>>
*)&local_70);
*(SeparatorAuto **)this = (SeparatorAuto *)(puVar1 + 2);
local_28 = 0;
*(int8 **)(this + 8) = puVar1;
local_30 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&local_28);
return this;
}
| |
23,684 | test_bug8722 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_bug8722(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int rc;
const char *stmt_text;
/* Prepare test data */
stmt_text= "drop table if exists t1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "drop view if exists v1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10),"
" c4 varchar(10), c5 varchar(10), c6 varchar(10),"
" c7 varchar(10), c8 varchar(10), c9 varchar(10),"
"c10 varchar(10))";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "CREATE VIEW v1 AS SELECT * FROM t1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
stmt_text= "select * from v1";
rc= mysql_stmt_prepare(stmt, SL(stmt_text));
check_stmt_rc(rc, stmt);
mysql_stmt_close(stmt);
stmt_text= "drop table if exists t1, v1";
rc= mysql_query(mysql, "DROP TABLE t1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "DROP VIEW v1");
check_mysql_rc(rc, mysql);
return OK;
} | O0 | c | test_bug8722:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
leaq 0x3c6dc(%rip), %rax # 0x664d2
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29e78
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x44(%rbp), %esi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b87d(%rip), %rdi # 0x656d5
leaq 0x3c20e(%rip), %r8 # 0x6606d
movl $0xd11, %r9d # imm = 0xD11
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x29e7a
leaq 0x3ff53(%rip), %rax # 0x69dd4
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29f03
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x64(%rbp), %esi
movq -0x60(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b7f2(%rip), %rdi # 0x656d5
leaq 0x3c183(%rip), %r8 # 0x6606d
movl $0xd14, %r9d # imm = 0xD14
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x29f05
leaq 0x3fedf(%rip), %rax # 0x69deb
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x29f94
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b761(%rip), %rdi # 0x656d5
leaq 0x3c0f2(%rip), %r8 # 0x6606d
movl $0xd1a, %r9d # imm = 0xD1A
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x29f96
leaq 0x3feff(%rip), %rax # 0x69e9c
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a037
movl -0x1c(%rbp), %eax
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0xa4(%rbp), %esi
movq -0xa0(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b6be(%rip), %rdi # 0x656d5
leaq 0x3c04f(%rip), %r8 # 0x6606d
movl $0xd1d, %r9d # imm = 0xD1D
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x2a039
leaq 0x3fe89(%rip), %rax # 0x69ec9
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq %rax, %rdx
callq 0x377f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a0da
movl -0x1c(%rbp), %eax
movl %eax, -0xc4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0xc4(%rbp), %esi
movq -0xc0(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b61b(%rip), %rdi # 0x656d5
leaq 0x3bfac(%rip), %r8 # 0x6606d
movl $0xd20, %r9d # imm = 0xD20
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x2a0dc
movq -0x10(%rbp), %rdi
callq 0x44950
movq %rax, -0x18(%rbp)
leaq 0x3fdfc(%rip), %rax # 0x69eec
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rdi
callq 0x141a0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq %rax, %rdx
callq 0x45070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a164
movq -0x18(%rbp), %rdi
callq 0x43fd0
movq %rax, %rsi
leaq 0x3b44b(%rip), %rdi # 0x65590
leaq 0x3bf21(%rip), %rdx # 0x6606d
movl $0xd25, %ecx # imm = 0xD25
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x2a166
movq -0x18(%rbp), %rdi
callq 0x43eb0
leaq 0x3fd87(%rip), %rax # 0x69efd
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x3c3c5(%rip), %rsi # 0x6654a
callq 0x38a70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a1e8
movl -0x1c(%rbp), %eax
movl %eax, -0xe4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0xe4(%rbp), %esi
movq -0xe0(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b50a(%rip), %rdi # 0x656d5
leaq 0x3be9b(%rip), %r8 # 0x6606d
movl $0xd29, %r9d # imm = 0xD29
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x2a1ea
movq -0x10(%rbp), %rdi
leaq 0x3fd24(%rip), %rsi # 0x69f19
callq 0x38a70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x2a258
movl -0x1c(%rbp), %eax
movl %eax, -0xf4(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3f0
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3c3c0
movl -0xf4(%rbp), %esi
movq -0xf0(%rbp), %rdx
movl %eax, %ecx
leaq 0x3b49a(%rip), %rdi # 0x656d5
leaq 0x3be2b(%rip), %r8 # 0x6606d
movl $0xd2b, %r9d # imm = 0xD2B
movb $0x0, %al
callq 0x2fc40
movl $0x1, -0x4(%rbp)
jmp 0x2a261
jmp 0x2a25a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopl (%rax)
| test_bug8722:
push rbp
mov rbp, rsp
sub rsp, 100h
mov [rbp+var_10], rdi
lea rax, aDropTableIfExi; "drop table if exists t1"
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_30]
mov rdx, rax
call mysql_real_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_29E78
mov eax, [rbp+var_1C]
mov [rbp+var_44], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_40], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_44]
mov rdx, [rbp+var_40]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D11h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_29E78:
jmp short $+2
loc_29E7A:
lea rax, aDropViewIfExis; "drop view if exists v1"
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_50]
mov rdx, rax
call mysql_real_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_29F03
mov eax, [rbp+var_1C]
mov [rbp+var_64], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_60], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_64]
mov rdx, [rbp+var_60]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D14h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_29F03:
jmp short $+2
loc_29F05:
lea rax, aCreateTableT1C_1; "CREATE TABLE t1 (c1 varchar(10), c2 var"...
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_78], rax
mov rax, [rbp+var_28]
mov [rbp+var_70], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_78]
mov rsi, [rbp+var_70]
mov rdx, rax
call mysql_real_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_29F94
mov eax, [rbp+var_1C]
mov [rbp+var_84], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_80], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_84]
mov rdx, [rbp+var_80]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D1Ah
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_29F94:
jmp short $+2
loc_29F96:
lea rax, aInsertIntoT1Va_19; "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,"...
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
mov rax, [rbp+var_28]
mov [rbp+var_90], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_98]
mov rsi, [rbp+var_90]
mov rdx, rax
call mysql_real_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_2A037
mov eax, [rbp+var_1C]
mov [rbp+var_A4], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_A0], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_A4]
mov rdx, [rbp+var_A0]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D1Dh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_2A037:
jmp short $+2
loc_2A039:
lea rax, aCreateViewV1As; "CREATE VIEW v1 AS SELECT * FROM t1"
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
mov [rbp+var_B8], rax
mov rax, [rbp+var_28]
mov [rbp+var_B0], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_B8]
mov rsi, [rbp+var_B0]
mov rdx, rax
call mysql_real_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_2A0DA
mov eax, [rbp+var_1C]
mov [rbp+var_C4], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_C0], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_C4]
mov rdx, [rbp+var_C0]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D20h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_2A0DA:
jmp short $+2
loc_2A0DC:
mov rdi, [rbp+var_10]
call mysql_stmt_init
mov [rbp+var_18], rax
lea rax, aSelectFromV1; "select * from v1"
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
mov [rbp+var_D8], rax
mov rax, [rbp+var_28]
mov [rbp+var_D0], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_D8]
mov rsi, [rbp+var_D0]
mov rdx, rax
call mysql_stmt_prepare
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_2A164
mov rdi, [rbp+var_18]
call mysql_stmt_error
mov rsi, rax
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 0D25h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp loc_2A261
loc_2A164:
jmp short $+2
loc_2A166:
mov rdi, [rbp+var_18]
call mysql_stmt_close
lea rax, aDropTableIfExi_15; "drop table if exists t1, v1"
mov [rbp+var_28], rax
mov rdi, [rbp+var_10]
lea rsi, aDropTableT1; "DROP TABLE t1"
call mysql_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_2A1E8
mov eax, [rbp+var_1C]
mov [rbp+var_E4], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_E0], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_E4]
mov rdx, [rbp+var_E0]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D29h
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_2A261
loc_2A1E8:
jmp short $+2
loc_2A1EA:
mov rdi, [rbp+var_10]
lea rsi, aDropViewV1; "DROP VIEW v1"
call mysql_query
mov [rbp+var_1C], eax
cmp [rbp+var_1C], 0
jz short loc_2A258
mov eax, [rbp+var_1C]
mov [rbp+var_F4], eax
mov rdi, [rbp+var_10]
call mysql_error
mov [rbp+var_F0], rax
mov rdi, [rbp+var_10]
call mysql_errno
mov esi, [rbp+var_F4]
mov rdx, [rbp+var_F0]
mov ecx, eax
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov r9d, 0D2Bh
mov al, 0
call diag
mov [rbp+var_4], 1
jmp short loc_2A261
loc_2A258:
jmp short $+2
loc_2A25A:
mov [rbp+var_4], 0
loc_2A261:
mov eax, [rbp+var_4]
add rsp, 100h
pop rbp
retn
| long long test_bug8722(long long a1)
{
long long v1; // rax
int v2; // eax
long long v3; // rax
int v4; // eax
long long v5; // rax
int v6; // eax
long long v7; // rax
int v8; // eax
long long v9; // rax
int v10; // eax
long long v11; // rax
int v12; // eax
int v13; // r8d
int v14; // r9d
int v15; // eax
int v16; // eax
int v18; // [rsp+10h] [rbp-F0h]
int v19; // [rsp+20h] [rbp-E0h]
int v20; // [rsp+40h] [rbp-C0h]
int v21; // [rsp+60h] [rbp-A0h]
int v22; // [rsp+80h] [rbp-80h]
int v23; // [rsp+A0h] [rbp-60h]
int v24; // [rsp+C0h] [rbp-40h]
int v25; // [rsp+E4h] [rbp-1Ch]
int v26; // [rsp+E4h] [rbp-1Ch]
int v27; // [rsp+E4h] [rbp-1Ch]
int v28; // [rsp+E4h] [rbp-1Ch]
int v29; // [rsp+E4h] [rbp-1Ch]
int v30; // [rsp+E4h] [rbp-1Ch]
int v31; // [rsp+E4h] [rbp-1Ch]
long long v32; // [rsp+E8h] [rbp-18h]
v1 = strlen("drop table if exists t1");
v25 = mysql_real_query(a1, "drop table if exists t1", v1);
if ( v25 )
{
v24 = mysql_error(a1);
v2 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v25,
v24,
v2,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3345);
return 1;
}
else
{
v3 = strlen("drop view if exists v1");
v26 = mysql_real_query(a1, "drop view if exists v1", v3);
if ( v26 )
{
v23 = mysql_error(a1);
v4 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v26,
v23,
v4,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3348);
return 1;
}
else
{
v5 = strlen(
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varchar"
"(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))");
v27 = mysql_real_query(
a1,
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varcha"
"r(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))",
v5);
if ( v27 )
{
v22 = mysql_error(a1);
v6 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v27,
v22,
v6,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3354);
return 1;
}
else
{
v7 = strlen("INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)");
v28 = mysql_real_query(a1, "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)", v7);
if ( v28 )
{
v21 = mysql_error(a1);
v8 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v28,
v21,
v8,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3357);
return 1;
}
else
{
v9 = strlen("CREATE VIEW v1 AS SELECT * FROM t1");
v29 = mysql_real_query(a1, "CREATE VIEW v1 AS SELECT * FROM t1", v9);
if ( v29 )
{
v20 = mysql_error(a1);
v10 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v29,
v20,
v10,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3360);
return 1;
}
else
{
v32 = mysql_stmt_init(a1);
v11 = strlen("select * from v1");
if ( (unsigned int)mysql_stmt_prepare(v32, "select * from v1", v11) )
{
v12 = mysql_stmt_error(v32);
diag(
(unsigned int)"Error: %s (%s: %d)",
v12,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3365,
v13,
v14);
return 1;
}
else
{
mysql_stmt_close(v32);
v30 = mysql_query(a1, "DROP TABLE t1");
if ( v30 )
{
v19 = mysql_error(a1);
v15 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v30,
v19,
v15,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3369);
return 1;
}
else
{
v31 = mysql_query(a1, "DROP VIEW v1");
if ( v31 )
{
v18 = mysql_error(a1);
v16 = mysql_errno(a1);
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v31,
v18,
v16,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3371);
return 1;
}
else
{
return 0;
}
}
}
}
}
}
}
}
}
| test_bug8722:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0x1664d2]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x00129e78
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x44],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x44]
MOV RDX,qword ptr [RBP + -0x40]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd11
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_00129e78:
JMP 0x00129e7a
LAB_00129e7a:
LEA RAX,[0x169dd4]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x00129f03
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x64],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x64]
MOV RDX,qword ptr [RBP + -0x60]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd14
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_00129f03:
JMP 0x00129f05
LAB_00129f05:
LEA RAX,[0x169deb]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x70],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x78]
MOV RSI,qword ptr [RBP + -0x70]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x00129f94
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x84],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0x80],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0x84]
MOV RDX,qword ptr [RBP + -0x80]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd1a
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_00129f94:
JMP 0x00129f96
LAB_00129f96:
LEA RAX,[0x169e9c]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x90],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0x98]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012a037
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xa4],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xa0],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xa4]
MOV RDX,qword ptr [RBP + -0xa0]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd1d
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_0012a037:
JMP 0x0012a039
LAB_0012a039:
LEA RAX,[0x169ec9]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xb0],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0xb8]
MOV RSI,qword ptr [RBP + -0xb0]
MOV RDX,RAX
CALL 0x001377f0
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012a0da
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xc4],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xc0],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xc4]
MOV RDX,qword ptr [RBP + -0xc0]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd20
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_0012a0da:
JMP 0x0012a0dc
LAB_0012a0dc:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00144950
MOV qword ptr [RBP + -0x18],RAX
LEA RAX,[0x169eec]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0xd8],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0xd0],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001141a0
MOV RDI,qword ptr [RBP + -0xd8]
MOV RSI,qword ptr [RBP + -0xd0]
MOV RDX,RAX
CALL 0x00145070
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012a164
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143fd0
MOV RSI,RAX
LEA RDI,[0x165590]
LEA RDX,[0x16606d]
MOV ECX,0xd25
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_0012a164:
JMP 0x0012a166
LAB_0012a166:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00143eb0
LEA RAX,[0x169efd]
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x16654a]
CALL 0x00138a70
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012a1e8
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xe4],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xe0],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xe4]
MOV RDX,qword ptr [RBP + -0xe0]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd29
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_0012a1e8:
JMP 0x0012a1ea
LAB_0012a1ea:
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[0x169f19]
CALL 0x00138a70
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x0
JZ 0x0012a258
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0xf4],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3f0
MOV qword ptr [RBP + -0xf0],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013c3c0
MOV ESI,dword ptr [RBP + -0xf4]
MOV RDX,qword ptr [RBP + -0xf0]
MOV ECX,EAX
LEA RDI,[0x1656d5]
LEA R8,[0x16606d]
MOV R9D,0xd2b
MOV AL,0x0
CALL 0x0012fc40
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0012a261
LAB_0012a258:
JMP 0x0012a25a
LAB_0012a25a:
MOV dword ptr [RBP + -0x4],0x0
LAB_0012a261:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x100
POP RBP
RET
|
int4 test_bug8722(int8 param_1)
{
int iVar1;
int4 uVar2;
size_t sVar3;
int8 uVar4;
int4 local_c;
sVar3 = strlen("drop table if exists t1");
iVar1 = mysql_real_query(param_1,"drop table if exists t1",sVar3);
if (iVar1 == 0) {
sVar3 = strlen("drop view if exists v1");
iVar1 = mysql_real_query(param_1,"drop view if exists v1",sVar3);
if (iVar1 == 0) {
sVar3 = strlen(
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varchar(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))"
);
iVar1 = mysql_real_query(param_1,
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varchar(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))"
,sVar3);
if (iVar1 == 0) {
sVar3 = strlen("INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)");
iVar1 = mysql_real_query(param_1,"INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)",sVar3);
if (iVar1 == 0) {
sVar3 = strlen("CREATE VIEW v1 AS SELECT * FROM t1");
iVar1 = mysql_real_query(param_1,"CREATE VIEW v1 AS SELECT * FROM t1",sVar3);
if (iVar1 == 0) {
uVar4 = mysql_stmt_init(param_1);
sVar3 = strlen("select * from v1");
iVar1 = mysql_stmt_prepare(uVar4,"select * from v1",sVar3);
if (iVar1 == 0) {
mysql_stmt_close(uVar4);
iVar1 = mysql_query(param_1,"DROP TABLE t1");
if (iVar1 == 0) {
iVar1 = mysql_query(param_1,"DROP VIEW v1");
if (iVar1 == 0) {
local_c = 0;
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xd2b);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xd29);
local_c = 1;
}
}
else {
uVar4 = mysql_stmt_error(uVar4);
diag("Error: %s (%s: %d)",uVar4,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xd25);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xd20);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xd1d);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
0xd1a);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xd14
);
local_c = 1;
}
}
else {
uVar4 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar4,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",0xd11);
local_c = 1;
}
return local_c;
}
| |
23,685 | test_bug8722 | eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c | static int test_bug8722(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int rc;
const char *stmt_text;
/* Prepare test data */
stmt_text= "drop table if exists t1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "drop view if exists v1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10),"
" c4 varchar(10), c5 varchar(10), c6 varchar(10),"
" c7 varchar(10), c8 varchar(10), c9 varchar(10),"
"c10 varchar(10))";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt_text= "CREATE VIEW v1 AS SELECT * FROM t1";
rc= mysql_real_query(mysql, SL(stmt_text));
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
stmt_text= "select * from v1";
rc= mysql_stmt_prepare(stmt, SL(stmt_text));
check_stmt_rc(rc, stmt);
mysql_stmt_close(stmt);
stmt_text= "drop table if exists t1, v1";
rc= mysql_query(mysql, "DROP TABLE t1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "DROP VIEW v1");
check_mysql_rc(rc, mysql);
return OK;
} | O3 | c | test_bug8722:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x24788(%rip), %rsi # 0x47122
movl $0x17, %edx
callq 0x2af62
testl %eax, %eax
je 0x229df
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x23960(%rip), %rdi # 0x46325
leaq 0x242f1(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd11, %r9d # imm = 0xD11
jmp 0x22b13
leaq 0x2801c(%rip), %rsi # 0x4aa02
movl $0x16, %edx
movq %rbx, %rdi
callq 0x2af62
testl %eax, %eax
je 0x22a2e
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x23911(%rip), %rdi # 0x46325
leaq 0x242a2(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd14, %r9d # imm = 0xD14
jmp 0x22b13
leaq 0x27fe4(%rip), %rsi # 0x4aa19
movl $0xb0, %edx
movq %rbx, %rdi
callq 0x2af62
testl %eax, %eax
je 0x22a7d
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x238c2(%rip), %rdi # 0x46325
leaq 0x24253(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd1a, %r9d # imm = 0xD1A
jmp 0x22b13
leaq 0x28046(%rip), %rsi # 0x4aaca
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x2af62
testl %eax, %eax
je 0x22ac9
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x23873(%rip), %rdi # 0x46325
leaq 0x24204(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd1d, %r9d # imm = 0xD1D
jmp 0x22b13
leaq 0x28027(%rip), %rsi # 0x4aaf7
movl $0x22, %edx
movq %rbx, %rdi
callq 0x2af62
testl %eax, %eax
je 0x22b2a
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x23827(%rip), %rdi # 0x46325
leaq 0x241b8(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd20, %r9d # imm = 0xD20
xorl %eax, %eax
callq 0x264ef
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x322b8
movq %rax, %r14
leaq 0x27fde(%rip), %rsi # 0x4ab1a
movl $0x10, %edx
movq %rax, %rdi
callq 0x3267c
movq %r14, %rdi
testl %eax, %eax
je 0x22b74
callq 0x31d58
leaq 0x23684(%rip), %rdi # 0x461e0
leaq 0x2415a(%rip), %rdx # 0x46cbd
movq %rax, %rsi
movl $0xd25, %ecx # imm = 0xD25
xorl %eax, %eax
callq 0x264ef
jmp 0x22b1a
callq 0x31cc9
leaq 0x2461a(%rip), %rsi # 0x4719a
movq %rbx, %rdi
callq 0x2bbf9
testl %eax, %eax
je 0x22bc3
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x2377c(%rip), %rdi # 0x46325
leaq 0x2410d(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd29, %r9d # imm = 0xD29
jmp 0x22b13
leaq 0x27f61(%rip), %rsi # 0x4ab2b
movq %rbx, %rdi
callq 0x2bbf9
testl %eax, %eax
je 0x22c0d
movl %eax, %r14d
movq %rbx, %rdi
callq 0x2dc72
movq %rax, %r15
movq %rbx, %rdi
callq 0x2dc5d
leaq 0x23732(%rip), %rdi # 0x46325
leaq 0x240c3(%rip), %r8 # 0x46cbd
movl %r14d, %esi
movq %r15, %rdx
movl %eax, %ecx
movl $0xd2b, %r9d # imm = 0xD2B
jmp 0x22b13
xorl %eax, %eax
jmp 0x22b1f
| test_bug8722:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
lea rsi, aDropTableIfExi; "drop table if exists t1"
mov edx, 17h
call mysql_real_query
test eax, eax
jz short loc_229DF
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D11h
jmp loc_22B13
loc_229DF:
lea rsi, aDropViewIfExis; "drop view if exists v1"
mov edx, 16h
mov rdi, rbx
call mysql_real_query
test eax, eax
jz short loc_22A2E
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D14h
jmp loc_22B13
loc_22A2E:
lea rsi, aCreateTableT1C_1; "CREATE TABLE t1 (c1 varchar(10), c2 var"...
mov edx, 0B0h
mov rdi, rbx
call mysql_real_query
test eax, eax
jz short loc_22A7D
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D1Ah
jmp loc_22B13
loc_22A7D:
lea rsi, aInsertIntoT1Va_18; "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,"...
mov edx, 2Ch ; ','
mov rdi, rbx
call mysql_real_query
test eax, eax
jz short loc_22AC9
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D1Dh
jmp short loc_22B13
loc_22AC9:
lea rsi, aCreateViewV1As; "CREATE VIEW v1 AS SELECT * FROM t1"
mov edx, 22h ; '"'
mov rdi, rbx
call mysql_real_query
test eax, eax
jz short loc_22B2A
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D20h
loc_22B13:
xor eax, eax
call diag
loc_22B1A:
mov eax, 1
loc_22B1F:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_22B2A:
mov rdi, rbx
call mysql_stmt_init
mov r14, rax
lea rsi, aSelectFromV1; "select * from v1"
mov edx, 10h
mov rdi, rax
call mysql_stmt_prepare
mov rdi, r14
test eax, eax
jz short loc_22B74
call mysql_stmt_error
lea rdi, aErrorSSD; "Error: %s (%s: %d)"
lea rdx, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov rsi, rax
mov ecx, 0D25h
xor eax, eax
call diag
jmp short loc_22B1A
loc_22B74:
call mysql_stmt_close
lea rsi, aDropTableT1; "DROP TABLE t1"
mov rdi, rbx
call mysql_query
test eax, eax
jz short loc_22BC3
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D29h
jmp loc_22B13
loc_22BC3:
lea rsi, aDropViewV1; "DROP VIEW v1"
mov rdi, rbx
call mysql_query
test eax, eax
jz short loc_22C0D
mov r14d, eax
mov rdi, rbx
call mysql_error
mov r15, rax
mov rdi, rbx
call mysql_errno
lea rdi, aErrorDSDInSLin; "Error (%d): %s (%d) in %s line %d"
lea r8, aWorkspaceLlm4b_0; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, r14d
mov rdx, r15
mov ecx, eax
mov r9d, 0D2Bh
jmp loc_22B13
loc_22C0D:
xor eax, eax
jmp loc_22B1F
| long long test_bug8722(long long a1)
{
int v2; // eax
int v3; // r14d
int v4; // r15d
int v5; // eax
int v6; // esi
int v7; // edx
int v8; // ecx
int v9; // r9d
int v10; // eax
int v11; // r14d
int v12; // r15d
int v13; // eax
int v14; // eax
int v15; // r14d
int v16; // r15d
int v17; // eax
int v18; // eax
int v19; // r14d
int v20; // r15d
int v21; // eax
int v22; // eax
int v23; // r14d
int v24; // r15d
int v25; // eax
long long v27; // rdi
int v28; // eax
int v29; // r8d
int v30; // r9d
int v31; // eax
int v32; // r14d
int v33; // r15d
int v34; // eax
int v35; // eax
int v36; // r14d
int v37; // r15d
int v38; // eax
v2 = mysql_real_query(a1, "drop table if exists t1", 23LL);
if ( v2 )
{
v3 = v2;
v4 = mysql_error(a1);
v5 = mysql_errno(a1);
v6 = v3;
v7 = v4;
v8 = v5;
v9 = 3345;
}
else
{
v10 = mysql_real_query(a1, "drop view if exists v1", 22LL);
if ( v10 )
{
v11 = v10;
v12 = mysql_error(a1);
v13 = mysql_errno(a1);
v6 = v11;
v7 = v12;
v8 = v13;
v9 = 3348;
}
else
{
v14 = mysql_real_query(
a1,
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varcha"
"r(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))",
176LL);
if ( v14 )
{
v15 = v14;
v16 = mysql_error(a1);
v17 = mysql_errno(a1);
v6 = v15;
v7 = v16;
v8 = v17;
v9 = 3354;
}
else
{
v18 = mysql_real_query(a1, "INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)", 44LL);
if ( v18 )
{
v19 = v18;
v20 = mysql_error(a1);
v21 = mysql_errno(a1);
v6 = v19;
v7 = v20;
v8 = v21;
v9 = 3357;
}
else
{
v22 = mysql_real_query(a1, "CREATE VIEW v1 AS SELECT * FROM t1", 34LL);
if ( v22 )
{
v23 = v22;
v24 = mysql_error(a1);
v25 = mysql_errno(a1);
v6 = v23;
v7 = v24;
v8 = v25;
v9 = 3360;
}
else
{
v27 = mysql_stmt_init(a1);
if ( (unsigned int)mysql_stmt_prepare(v27, "select * from v1", 16LL) )
{
v28 = mysql_stmt_error(v27);
diag(
(unsigned int)"Error: %s (%s: %d)",
v28,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
3365,
v29,
v30);
return 1LL;
}
mysql_stmt_close(v27);
v31 = mysql_query(a1, "DROP TABLE t1");
if ( v31 )
{
v32 = v31;
v33 = mysql_error(a1);
v34 = mysql_errno(a1);
v6 = v32;
v7 = v33;
v8 = v34;
v9 = 3369;
}
else
{
v35 = mysql_query(a1, "DROP VIEW v1");
if ( !v35 )
return 0LL;
v36 = v35;
v37 = mysql_error(a1);
v38 = mysql_errno(a1);
v6 = v36;
v7 = v37;
v8 = v38;
v9 = 3371;
}
}
}
}
}
}
diag(
(unsigned int)"Error (%d): %s (%d) in %s line %d",
v6,
v7,
v8,
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",
v9);
return 1LL;
}
| test_bug8722:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RSI,[0x147122]
MOV EDX,0x17
CALL 0x0012af62
TEST EAX,EAX
JZ 0x001229df
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd11
JMP 0x00122b13
LAB_001229df:
LEA RSI,[0x14aa02]
MOV EDX,0x16
MOV RDI,RBX
CALL 0x0012af62
TEST EAX,EAX
JZ 0x00122a2e
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd14
JMP 0x00122b13
LAB_00122a2e:
LEA RSI,[0x14aa19]
MOV EDX,0xb0
MOV RDI,RBX
CALL 0x0012af62
TEST EAX,EAX
JZ 0x00122a7d
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd1a
JMP 0x00122b13
LAB_00122a7d:
LEA RSI,[0x14aaca]
MOV EDX,0x2c
MOV RDI,RBX
CALL 0x0012af62
TEST EAX,EAX
JZ 0x00122ac9
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd1d
JMP 0x00122b13
LAB_00122ac9:
LEA RSI,[0x14aaf7]
MOV EDX,0x22
MOV RDI,RBX
CALL 0x0012af62
TEST EAX,EAX
JZ 0x00122b2a
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd20
LAB_00122b13:
XOR EAX,EAX
CALL 0x001264ef
LAB_00122b1a:
MOV EAX,0x1
LAB_00122b1f:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00122b2a:
MOV RDI,RBX
CALL 0x001322b8
MOV R14,RAX
LEA RSI,[0x14ab1a]
MOV EDX,0x10
MOV RDI,RAX
CALL 0x0013267c
MOV RDI,R14
TEST EAX,EAX
JZ 0x00122b74
CALL 0x00131d58
LEA RDI,[0x1461e0]
LEA RDX,[0x146cbd]
MOV RSI,RAX
MOV ECX,0xd25
XOR EAX,EAX
CALL 0x001264ef
JMP 0x00122b1a
LAB_00122b74:
CALL 0x00131cc9
LEA RSI,[0x14719a]
MOV RDI,RBX
CALL 0x0012bbf9
TEST EAX,EAX
JZ 0x00122bc3
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd29
JMP 0x00122b13
LAB_00122bc3:
LEA RSI,[0x14ab2b]
MOV RDI,RBX
CALL 0x0012bbf9
TEST EAX,EAX
JZ 0x00122c0d
MOV R14D,EAX
MOV RDI,RBX
CALL 0x0012dc72
MOV R15,RAX
MOV RDI,RBX
CALL 0x0012dc5d
LEA RDI,[0x146325]
LEA R8,[0x146cbd]
MOV ESI,R14D
MOV RDX,R15
MOV ECX,EAX
MOV R9D,0xd2b
JMP 0x00122b13
LAB_00122c0d:
XOR EAX,EAX
JMP 0x00122b1f
|
int8 test_bug8722(int8 param_1)
{
int iVar1;
int4 uVar2;
int8 uVar3;
int8 uVar4;
iVar1 = mysql_real_query(param_1,"drop table if exists t1",0x17);
if (iVar1 == 0) {
iVar1 = mysql_real_query(param_1,"drop view if exists v1",0x16);
if (iVar1 == 0) {
iVar1 = mysql_real_query(param_1,
"CREATE TABLE t1 (c1 varchar(10), c2 varchar(10), c3 varchar(10), c4 varchar(10), c5 varchar(10), c6 varchar(10), c7 varchar(10), c8 varchar(10), c9 varchar(10),c10 varchar(10))"
,0xb0);
if (iVar1 == 0) {
iVar1 = mysql_real_query(param_1,"INSERT INTO t1 VALUES (1,2,3,4,5,6,7,8,9,10)",0x2c);
if (iVar1 == 0) {
iVar1 = mysql_real_query(param_1,"CREATE VIEW v1 AS SELECT * FROM t1",0x22);
if (iVar1 == 0) {
uVar3 = mysql_stmt_init(param_1);
iVar1 = mysql_stmt_prepare(uVar3,"select * from v1",0x10);
if (iVar1 != 0) {
uVar3 = mysql_stmt_error();
diag("Error: %s (%s: %d)",uVar3,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c"
,0xd25);
return 1;
}
mysql_stmt_close(uVar3);
iVar1 = mysql_query(param_1,"DROP TABLE t1");
if (iVar1 == 0) {
iVar1 = mysql_query(param_1,"DROP VIEW v1");
if (iVar1 == 0) {
return 0;
}
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd2b;
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd29;
}
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd20;
}
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd1d;
}
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd1a;
}
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd14;
}
}
else {
uVar3 = mysql_error(param_1);
uVar2 = mysql_errno(param_1);
uVar4 = 0xd11;
}
diag("Error (%d): %s (%d) in %s line %d",iVar1,uVar3,uVar2,
"/workspace/llm4binary/github2025/eloqsql/libmariadb/unittest/libmariadb/ps_bugs.c",uVar4);
return 1;
}
| |
23,686 | pvio_socket_fast_send | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | int pvio_socket_fast_send(MARIADB_PVIO *pvio)
{
int r= 0;
struct st_pvio_socket *csock= NULL;
if (!pvio || !pvio->data)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
/* Setting IP_TOS is not recommended on Windows. See
http://msdn.microsoft.com/en-us/library/windows/desktop/ms738586(v=vs.85).aspx
*/
#if !defined(_WIN32) && defined(IPTOS_THROUGHPUT)
{
int tos = IPTOS_THROUGHPUT;
r= setsockopt(csock->socket, IPPROTO_IP, IP_TOS,
(const void *)&tos, sizeof(tos));
}
#endif /* !_WIN32 && IPTOS_THROUGHPUT */
if (!r)
{
int opt = 1;
/* turn off nagle algorithm */
r= setsockopt(csock->socket, IPPROTO_TCP, TCP_NODELAY,
#ifdef _WIN32
(const char *)&opt, (int)sizeof(opt));
#else
(const void *)&opt, sizeof(opt));
#endif
}
return r;
} | O0 | c | pvio_socket_fast_send:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x73d8c
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x73d95
movl $0x1, -0x4(%rbp)
jmp 0x73dfb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x8, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
xorl %esi, %esi
movl $0x1, %edx
leaq -0x24(%rbp), %rcx
movl $0x4, %r8d
callq 0x38130
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x73df5
movl $0x1, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq -0x28(%rbp), %rcx
movl $0x4, %r8d
callq 0x38130
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| read_user_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
call _geteuid
cmp eax, 0
jnz short loc_73D8B
mov rdi, [rbp+var_8]
lea rsi, aRoot; "root"
call _strcpy
jmp loc_73E20
loc_73D8B:
call _geteuid
mov edi, eax
call _getpwuid
mov [rbp+var_10], rax
cmp rax, 0
jz short loc_73DAE
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_73E0E
loc_73DAE:
call _getlogin
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_73E0C
lea rdi, aSystemUser+7; "USER"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_73E0A
lea rdi, aLogname; "LOGNAME"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_73E0A
lea rdi, aLogin; "LOGIN"
call _getenv
mov [rbp+var_18], rax
cmp rax, 0
jnz short loc_73E0A
lea rax, aUnknownUser; "UNKNOWN_USER"
mov [rbp+var_18], rax
loc_73E0A:
jmp short $+2
loc_73E0C:
jmp short $+2
loc_73E0E:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
mov edx, 200h
call ma_strmake
loc_73E20:
add rsp, 20h
pop rbp
retn
| long long read_user_name(long long a1)
{
unsigned int v2; // eax
const char *v3; // [rsp+8h] [rbp-18h]
_QWORD *v4; // [rsp+10h] [rbp-10h]
if ( !(unsigned int)geteuid() )
return strcpy(a1, "root");
v2 = geteuid();
v4 = (_QWORD *)getpwuid(v2);
if ( v4 )
return ma_strmake(a1, *v4, 512LL);
v3 = (const char *)getlogin();
if ( !v3 )
{
v3 = (const char *)getenv("USER");
if ( !v3 )
{
v3 = (const char *)getenv("LOGNAME");
if ( !v3 )
{
v3 = (const char *)getenv("LOGIN");
if ( !v3 )
v3 = "UNKNOWN_USER";
}
}
}
return ma_strmake(a1, v3, 512LL);
}
| read_user_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
CALL 0x00162300
CMP EAX,0x0
JNZ 0x00173d8b
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x22df8f]
CALL 0x001624e0
JMP 0x00173e20
LAB_00173d8b:
CALL 0x00162300
MOV EDI,EAX
CALL 0x00162260
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JZ 0x00173dae
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x00173e0e
LAB_00173dae:
CALL 0x00162720
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00173e0c
LEA RDI,[0x22b3aa]
CALL 0x00162980
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00173e0a
LEA RDI,[0x22df94]
CALL 0x00162980
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00173e0a
LEA RDI,[0x22df9c]
CALL 0x00162980
MOV qword ptr [RBP + -0x18],RAX
CMP RAX,0x0
JNZ 0x00173e0a
LEA RAX,[0x22dfa2]
MOV qword ptr [RBP + -0x18],RAX
LAB_00173e0a:
JMP 0x00173e0c
LAB_00173e0c:
JMP 0x00173e0e
LAB_00173e0e:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,0x200
CALL 0x0018ebe0
LAB_00173e20:
ADD RSP,0x20
POP RBP
RET
|
void read_user_name(char *param_1)
{
__uid_t _Var1;
passwd *ppVar2;
char *local_20;
_Var1 = geteuid();
if (_Var1 == 0) {
strcpy(param_1,"root");
}
else {
_Var1 = geteuid();
ppVar2 = getpwuid(_Var1);
if (ppVar2 == (passwd *)0x0) {
local_20 = getlogin();
if ((((local_20 == (char *)0x0) && (local_20 = getenv("USER"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGNAME"), local_20 == (char *)0x0)) &&
(local_20 = getenv("LOGIN"), local_20 == (char *)0x0)) {
local_20 = "UNKNOWN_USER";
}
}
else {
local_20 = ppVar2->pw_name;
}
ma_strmake(param_1,local_20,0x200);
}
return;
}
| |
23,687 | ssz_len | corpus-core[P]colibri-stateless/src/util/ssz.c | uint32_t ssz_len(ssz_ob_t ob) {
switch (ob.def->type) {
case SSZ_TYPE_VECTOR: return ob.def->def.vector.len;
case SSZ_TYPE_LIST: {
int fixed_length = ssz_fixed_length(ob.def->def.vector.type);
if (fixed_length == 0) return 0;
return ob.bytes.len > 4 && ssz_is_dynamic(ob.def->def.vector.type)
? uint32_from_le(ob.bytes.data) / 4
: ob.bytes.len / fixed_length;
}
case SSZ_TYPE_BIT_VECTOR:
return ob.bytes.len * 8;
case SSZ_TYPE_BIT_LIST: {
uint8_t last_bit = ob.bytes.data[ob.bytes.len - 1];
if (last_bit == 1) return ob.bytes.len * 8 - 8;
for (int i = 7; i >= 0; i--) {
if (last_bit & (1 << i))
return ((ob.bytes.len - 1) * 8) + i;
}
return ob.bytes.len * 8; // this should never happen, since the spec requires to set a bit in the last byte
}
default: return 0;
}
} | O1 | c | ssz_len:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %ebx, %ebx
addl $-0x3, %ecx
cmpl $0x3, %ecx
ja 0x14397
leaq 0x30(%rsp), %r12
leaq 0x2ad60(%rip), %rdx # 0x3f04c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x18(%rax), %ebx
jmp 0x14397
movl (%r12), %ebx
shll $0x3, %ebx
jmp 0x14397
movq 0x8(%r12), %rax
movl (%r12), %ebx
leal -0x1(%rbx), %ecx
movzbl (%rax,%rcx), %edx
cmpl $0x1, %edx
jne 0x14361
leal -0x8(,%rbx,8), %ebx
jmp 0x14397
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x13690
movq %rax, %r14
testl %r14d, %r14d
je 0x14397
movl (%r12), %ebx
cmpl $0x5, %ebx
jb 0x1437a
movq %r15, %rdi
callq 0x135f8
testb %al, %al
je 0x1437a
movq 0x8(%r12), %rdi
callq 0x128bd
movl %eax, %ebx
shrl $0x2, %ebx
jmp 0x14397
movl $0x7, %ecx
testb %dl, %dl
js 0x14385
testl %ecx, %ecx
sete %al
je 0x1438f
decl %ecx
btl %ecx, %edx
jae 0x1436a
jmp 0x14387
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %ebx
jmp 0x14397
xorl %eax, %eax
leal (%rcx,%rbx,8), %ecx
addl $-0x8, %ecx
jmp 0x1438f
shll $0x3, %ebx
testb %al, %al
cmovel %ecx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ssz_len:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rsp+28h+arg_10]
mov ecx, [rax+8]
xor ebx, ebx
add ecx, 0FFFFFFFDh; switch 4 cases
cmp ecx, 3
ja def_142F3; jumptable 00000000000142F3 default case
lea r12, [rsp+28h+arg_0]
lea rdx, jpt_142F3
movsxd rcx, ds:(jpt_142F3 - 3F04Ch)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_142F5:
mov ebx, [rax+18h]; jumptable 00000000000142F3 case 3
jmp def_142F3; jumptable 00000000000142F3 default case
loc_142FD:
mov ebx, [r12]; jumptable 00000000000142F3 case 5
shl ebx, 3
jmp def_142F3; jumptable 00000000000142F3 default case
loc_14309:
mov rax, [r12+8]; jumptable 00000000000142F3 case 6
mov ebx, [r12]
lea ecx, [rbx-1]
movzx edx, byte ptr [rax+rcx]
cmp edx, 1
jnz short loc_14361
lea ebx, ds:0FFFFFFFFFFFFFFF8h[rbx*8]
jmp short def_142F3; jumptable 00000000000142F3 default case
loc_14327:
mov r15, [rax+10h]; jumptable 00000000000142F3 case 4
mov rdi, r15
call ssz_fixed_length
mov r14, rax
test r14d, r14d
jz short def_142F3; jumptable 00000000000142F3 default case
mov ebx, [r12]
cmp ebx, 5
jb short loc_1437A
mov rdi, r15
call ssz_is_dynamic
test al, al
jz short loc_1437A
mov rdi, [r12+8]
call uint32_from_le
mov ebx, eax
shr ebx, 2
jmp short def_142F3; jumptable 00000000000142F3 default case
loc_14361:
mov ecx, 7
test dl, dl
js short loc_14385
loc_1436A:
test ecx, ecx
setz al
jz short loc_1438F
dec ecx
bt edx, ecx
jnb short loc_1436A
jmp short loc_14387
loc_1437A:
mov eax, ebx
xor edx, edx
div r14d
mov ebx, eax
jmp short def_142F3; jumptable 00000000000142F3 default case
loc_14385:
xor eax, eax
loc_14387:
lea ecx, [rcx+rbx*8]
add ecx, 0FFFFFFF8h
jmp short $+2
loc_1438F:
shl ebx, 3
test al, al
cmovz ebx, ecx
def_142F3:
mov eax, ebx; jumptable 00000000000142F3 default case
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ssz_len(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
unsigned int a7,
unsigned int *a8,
long long a9)
{
unsigned int v9; // ebx
int v10; // edx
long long v11; // r15
unsigned int v12; // r14d
int v13; // ecx
bool v14; // al
v9 = 0;
switch ( *(_DWORD *)(a9 + 8) )
{
case 3:
v9 = *(_DWORD *)(a9 + 24);
break;
case 4:
v11 = *(_QWORD *)(a9 + 16);
v12 = ssz_fixed_length(v11);
if ( v12 )
{
if ( a7 >= 5 && (unsigned __int8)ssz_is_dynamic(v11) )
v9 = (unsigned int)uint32_from_le(a8) >> 2;
else
v9 = a7 / v12;
}
break;
case 5:
v9 = 8 * a7;
break;
case 6:
v10 = *((unsigned __int8 *)a8 + a7 - 1);
if ( v10 == 1 )
{
v9 = 8 * a7 - 8;
}
else
{
v13 = 7;
if ( (v10 & 0x80u) != 0 )
{
v14 = 0;
LABEL_16:
v13 = v13 + 8 * a7 - 8;
}
else
{
while ( 1 )
{
v14 = v13 == 0;
if ( !v13 )
break;
if ( _bittest(&v10, --v13) )
goto LABEL_16;
}
}
v9 = 8 * a7;
if ( !v14 )
v9 = v13;
}
break;
default:
return v9;
}
return v9;
}
| ssz_len:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
XOR EBX,EBX
ADD ECX,-0x3
CMP ECX,0x3
JA 0x00114397
LEA R12,[RSP + 0x30]
LEA RDX,[0x13f04c]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_3:
MOV EBX,dword ptr [RAX + 0x18]
JMP 0x00114397
caseD_5:
MOV EBX,dword ptr [R12]
SHL EBX,0x3
JMP 0x00114397
caseD_6:
MOV RAX,qword ptr [R12 + 0x8]
MOV EBX,dword ptr [R12]
LEA ECX,[RBX + -0x1]
MOVZX EDX,byte ptr [RAX + RCX*0x1]
CMP EDX,0x1
JNZ 0x00114361
LEA EBX,[-0x8 + RBX*0x8]
JMP 0x00114397
caseD_4:
MOV R15,qword ptr [RAX + 0x10]
MOV RDI,R15
CALL 0x00113690
MOV R14,RAX
TEST R14D,R14D
JZ 0x00114397
MOV EBX,dword ptr [R12]
CMP EBX,0x5
JC 0x0011437a
MOV RDI,R15
CALL 0x001135f8
TEST AL,AL
JZ 0x0011437a
MOV RDI,qword ptr [R12 + 0x8]
CALL 0x001128bd
MOV EBX,EAX
SHR EBX,0x2
JMP 0x00114397
LAB_00114361:
MOV ECX,0x7
TEST DL,DL
JS 0x00114385
LAB_0011436a:
TEST ECX,ECX
SETZ AL
JZ 0x0011438f
DEC ECX
BT EDX,ECX
JNC 0x0011436a
JMP 0x00114387
LAB_0011437a:
MOV EAX,EBX
XOR EDX,EDX
DIV R14D
MOV EBX,EAX
JMP 0x00114397
LAB_00114385:
XOR EAX,EAX
LAB_00114387:
LEA ECX,[RCX + RBX*0x8]
ADD ECX,-0x8
JMP 0x0011438f
LAB_0011438f:
SHL EBX,0x3
TEST AL,AL
CMOVZ EBX,ECX
default:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
uint ssz_len(void)
{
byte bVar1;
int8 uVar2;
char cVar3;
uint uVar4;
uint uVar5;
bool bVar6;
uint in_stack_00000008;
long in_stack_00000010;
long in_stack_00000018;
uVar4 = 0;
switch(*(int4 *)(in_stack_00000018 + 8)) {
case 3:
uVar4 = *(uint *)(in_stack_00000018 + 0x18);
break;
case 4:
uVar2 = *(int8 *)(in_stack_00000018 + 0x10);
uVar5 = ssz_fixed_length(uVar2);
uVar4 = 0;
if (uVar5 != 0) {
if ((in_stack_00000008 < 5) || (cVar3 = ssz_is_dynamic(uVar2), cVar3 == '\0')) {
uVar4 = in_stack_00000008 / uVar5;
}
else {
uVar4 = uint32_from_le(in_stack_00000010);
uVar4 = uVar4 >> 2;
}
}
break;
case 5:
uVar4 = in_stack_00000008 << 3;
break;
case 6:
bVar1 = *(byte *)(in_stack_00000010 + (ulong)(in_stack_00000008 - 1));
if (bVar1 == 1) {
uVar4 = in_stack_00000008 * 8 - 8;
}
else {
uVar5 = 7;
if ((char)bVar1 < '\0') {
bVar6 = false;
}
else {
do {
bVar6 = uVar5 == 0;
if (bVar6) goto LAB_0011438f;
uVar5 = uVar5 - 1;
} while ((bVar1 >> (uVar5 & 0x1f) & 1) == 0);
}
uVar5 = (uVar5 + in_stack_00000008 * 8) - 8;
LAB_0011438f:
uVar4 = in_stack_00000008 << 3;
if (!bVar6) {
uVar4 = uVar5;
}
}
}
return uVar4;
}
| |
23,688 | ssz_len | corpus-core[P]colibri-stateless/src/util/ssz.c | uint32_t ssz_len(ssz_ob_t ob) {
switch (ob.def->type) {
case SSZ_TYPE_VECTOR: return ob.def->def.vector.len;
case SSZ_TYPE_LIST: {
int fixed_length = ssz_fixed_length(ob.def->def.vector.type);
if (fixed_length == 0) return 0;
return ob.bytes.len > 4 && ssz_is_dynamic(ob.def->def.vector.type)
? uint32_from_le(ob.bytes.data) / 4
: ob.bytes.len / fixed_length;
}
case SSZ_TYPE_BIT_VECTOR:
return ob.bytes.len * 8;
case SSZ_TYPE_BIT_LIST: {
uint8_t last_bit = ob.bytes.data[ob.bytes.len - 1];
if (last_bit == 1) return ob.bytes.len * 8 - 8;
for (int i = 7; i >= 0; i--) {
if (last_bit & (1 << i))
return ((ob.bytes.len - 1) * 8) + i;
}
return ob.bytes.len * 8; // this should never happen, since the spec requires to set a bit in the last byte
}
default: return 0;
}
} | O2 | c | ssz_len:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %ebx, %ebx
addl $-0x3, %ecx
cmpl $0x3, %ecx
ja 0x13052
leaq 0x30(%rsp), %r12
leaq 0x27094(%rip), %rdx # 0x3a048
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x18(%rax), %ebx
jmp 0x13052
movl (%r12), %ebx
shll $0x3, %ebx
jmp 0x13052
movq 0x8(%r12), %rcx
movl (%r12), %eax
leal -0x1(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x1, %ecx
jne 0x13029
leal -0x8(,%rax,8), %ebx
jmp 0x13052
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x125af
movq %rax, %r14
testl %r14d, %r14d
je 0x13052
movl (%r12), %ebx
cmpl $0x5, %ebx
jb 0x13042
movq %r15, %rdi
callq 0x12554
testb %al, %al
je 0x13042
movq 0x8(%r12), %rdi
callq 0x11961
movl %eax, %ebx
shrl $0x2, %ebx
jmp 0x13052
leal -0x1(,%rax,8), %ebx
pushq $0x7
popq %rdx
testl %edx, %edx
js 0x1304d
btl %edx, %ecx
jb 0x13052
decl %edx
decl %ebx
jmp 0x13033
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %ebx
jmp 0x13052
shll $0x3, %eax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ssz_len:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rsp+28h+arg_10]
mov ecx, [rax+8]
xor ebx, ebx
add ecx, 0FFFFFFFDh; switch 4 cases
cmp ecx, 3
ja def_12FBB; jumptable 0000000000012FBB default case
lea r12, [rsp+28h+arg_0]
lea rdx, jpt_12FBB
movsxd rcx, ds:(jpt_12FBB - 3A048h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_12FBD:
mov ebx, [rax+18h]; jumptable 0000000000012FBB case 3
jmp def_12FBB; jumptable 0000000000012FBB default case
loc_12FC5:
mov ebx, [r12]; jumptable 0000000000012FBB case 5
shl ebx, 3
jmp def_12FBB; jumptable 0000000000012FBB default case
loc_12FD1:
mov rcx, [r12+8]; jumptable 0000000000012FBB case 6
mov eax, [r12]
lea edx, [rax-1]
movzx ecx, byte ptr [rcx+rdx]
cmp ecx, 1
jnz short loc_13029
lea ebx, ds:0FFFFFFFFFFFFFFF8h[rax*8]
jmp short def_12FBB; jumptable 0000000000012FBB default case
loc_12FEF:
mov r15, [rax+10h]; jumptable 0000000000012FBB case 4
mov rdi, r15
call ssz_fixed_length
mov r14, rax
test r14d, r14d
jz short def_12FBB; jumptable 0000000000012FBB default case
mov ebx, [r12]
cmp ebx, 5
jb short loc_13042
mov rdi, r15
call ssz_is_dynamic
test al, al
jz short loc_13042
mov rdi, [r12+8]
call uint32_from_le
mov ebx, eax
shr ebx, 2
jmp short def_12FBB; jumptable 0000000000012FBB default case
loc_13029:
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rax*8]
push 7
pop rdx
loc_13033:
test edx, edx
js short loc_1304D
bt ecx, edx
jb short def_12FBB; jumptable 0000000000012FBB default case
dec edx
dec ebx
jmp short loc_13033
loc_13042:
mov eax, ebx
xor edx, edx
div r14d
mov ebx, eax
jmp short def_12FBB; jumptable 0000000000012FBB default case
loc_1304D:
shl eax, 3
mov ebx, eax
def_12FBB:
mov eax, ebx; jumptable 0000000000012FBB default case
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ssz_len(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
unsigned int a7,
unsigned int *a8,
long long a9)
{
unsigned int v9; // ebx
int v10; // ecx
_DWORD *v11; // r15
unsigned int v12; // r14d
signed int i; // edx
v9 = 0;
switch ( *(_DWORD *)(a9 + 8) )
{
case 3:
v9 = *(_DWORD *)(a9 + 24);
break;
case 4:
v11 = *(_DWORD **)(a9 + 16);
v12 = ssz_fixed_length(v11);
if ( v12 )
{
if ( a7 >= 5 && (unsigned __int8)ssz_is_dynamic((long long)v11) )
v9 = (unsigned int)uint32_from_le(a8) >> 2;
else
v9 = a7 / v12;
}
break;
case 5:
v9 = 8 * a7;
break;
case 6:
v10 = *((unsigned __int8 *)a8 + a7 - 1);
if ( v10 == 1 )
{
v9 = 8 * a7 - 8;
}
else
{
v9 = 8 * a7 - 1;
for ( i = 7; i >= 0; --i )
{
if ( _bittest(&v10, i) )
return v9;
--v9;
}
v9 = 8 * a7;
}
break;
default:
return v9;
}
return v9;
}
| ssz_len:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
XOR EBX,EBX
ADD ECX,-0x3
CMP ECX,0x3
JA 0x00113052
LEA R12,[RSP + 0x30]
LEA RDX,[0x13a048]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_3:
MOV EBX,dword ptr [RAX + 0x18]
JMP 0x00113052
caseD_5:
MOV EBX,dword ptr [R12]
SHL EBX,0x3
JMP 0x00113052
caseD_6:
MOV RCX,qword ptr [R12 + 0x8]
MOV EAX,dword ptr [R12]
LEA EDX,[RAX + -0x1]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP ECX,0x1
JNZ 0x00113029
LEA EBX,[-0x8 + RAX*0x8]
JMP 0x00113052
caseD_4:
MOV R15,qword ptr [RAX + 0x10]
MOV RDI,R15
CALL 0x001125af
MOV R14,RAX
TEST R14D,R14D
JZ 0x00113052
MOV EBX,dword ptr [R12]
CMP EBX,0x5
JC 0x00113042
MOV RDI,R15
CALL 0x00112554
TEST AL,AL
JZ 0x00113042
MOV RDI,qword ptr [R12 + 0x8]
CALL 0x00111961
MOV EBX,EAX
SHR EBX,0x2
JMP 0x00113052
LAB_00113029:
LEA EBX,[-0x1 + RAX*0x8]
PUSH 0x7
POP RDX
LAB_00113033:
TEST EDX,EDX
JS 0x0011304d
BT ECX,EDX
JC 0x00113052
DEC EDX
DEC EBX
JMP 0x00113033
LAB_00113042:
MOV EAX,EBX
XOR EDX,EDX
DIV R14D
MOV EBX,EAX
JMP 0x00113052
LAB_0011304d:
SHL EAX,0x3
MOV EBX,EAX
default:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
uint ssz_len(void)
{
byte bVar1;
int8 uVar2;
char cVar3;
uint uVar4;
uint uVar5;
uint in_stack_00000008;
long in_stack_00000010;
long in_stack_00000018;
uVar4 = 0;
switch(*(int4 *)(in_stack_00000018 + 8)) {
case 3:
uVar4 = *(uint *)(in_stack_00000018 + 0x18);
break;
case 4:
uVar2 = *(int8 *)(in_stack_00000018 + 0x10);
uVar5 = ssz_fixed_length(uVar2);
uVar4 = 0;
if (uVar5 != 0) {
if ((in_stack_00000008 < 5) || (cVar3 = ssz_is_dynamic(uVar2), cVar3 == '\0')) {
uVar4 = in_stack_00000008 / uVar5;
}
else {
uVar4 = uint32_from_le(in_stack_00000010);
uVar4 = uVar4 >> 2;
}
}
break;
case 5:
uVar4 = in_stack_00000008 << 3;
break;
case 6:
bVar1 = *(byte *)(in_stack_00000010 + (ulong)(in_stack_00000008 - 1));
if (bVar1 == 1) {
uVar4 = in_stack_00000008 * 8 - 8;
}
else {
uVar4 = in_stack_00000008 * 8;
for (uVar5 = 7; uVar4 = uVar4 - 1, -1 < (int)uVar5; uVar5 = uVar5 - 1) {
if ((bVar1 >> (uVar5 & 0x1f) & 1) != 0) {
return uVar4;
}
}
uVar4 = in_stack_00000008 << 3;
}
}
return uVar4;
}
| |
23,689 | ssz_len | corpus-core[P]colibri-stateless/src/util/ssz.c | uint32_t ssz_len(ssz_ob_t ob) {
switch (ob.def->type) {
case SSZ_TYPE_VECTOR: return ob.def->def.vector.len;
case SSZ_TYPE_LIST: {
int fixed_length = ssz_fixed_length(ob.def->def.vector.type);
if (fixed_length == 0) return 0;
return ob.bytes.len > 4 && ssz_is_dynamic(ob.def->def.vector.type)
? uint32_from_le(ob.bytes.data) / 4
: ob.bytes.len / fixed_length;
}
case SSZ_TYPE_BIT_VECTOR:
return ob.bytes.len * 8;
case SSZ_TYPE_BIT_LIST: {
uint8_t last_bit = ob.bytes.data[ob.bytes.len - 1];
if (last_bit == 1) return ob.bytes.len * 8 - 8;
for (int i = 7; i >= 0; i--) {
if (last_bit & (1 << i))
return ((ob.bytes.len - 1) * 8) + i;
}
return ob.bytes.len * 8; // this should never happen, since the spec requires to set a bit in the last byte
}
default: return 0;
}
} | O3 | c | ssz_len:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsp), %rax
movl 0x8(%rax), %ecx
xorl %ebx, %ebx
addl $-0x3, %ecx
cmpl $0x3, %ecx
ja 0x13ea7
leaq 0x30(%rsp), %r12
leaq 0x2b23e(%rip), %rdx # 0x3f048
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl 0x18(%rax), %ebx
jmp 0x13ea7
movl (%r12), %ebx
shll $0x3, %ebx
jmp 0x13ea7
movq 0x8(%r12), %rcx
movl (%r12), %eax
leal -0x1(%rax), %edx
movzbl (%rcx,%rdx), %ecx
cmpl $0x1, %ecx
jne 0x13e7f
leal -0x8(,%rax,8), %ebx
jmp 0x13ea7
movq 0x10(%rax), %r15
movq %r15, %rdi
callq 0x13330
movq %rax, %r14
testl %r14d, %r14d
je 0x13ea7
movl (%r12), %ebx
cmpl $0x5, %ebx
jb 0x13e9e
movq %r15, %rdi
callq 0x132e8
testb %al, %al
je 0x13e9e
movq 0x8(%r12), %rdi
callq 0x125c5
movl %eax, %ebx
shrl $0x2, %ebx
jmp 0x13ea7
leal -0x1(,%rax,8), %ebx
movl $0x7, %edx
btl %edx, %ecx
jb 0x13ea7
decl %ebx
addl $-0x1, %edx
jb 0x13e8b
shll $0x3, %eax
movl %eax, %ebx
jmp 0x13ea7
movl %ebx, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| ssz_len:
push r15
push r14
push r12
push rbx
push rax
mov rax, [rsp+28h+arg_10]
mov ecx, [rax+8]
xor ebx, ebx
add ecx, 0FFFFFFFDh; switch 4 cases
cmp ecx, 3
ja def_13E11; jumptable 0000000000013E11 default case
lea r12, [rsp+28h+arg_0]
lea rdx, jpt_13E11
movsxd rcx, ds:(jpt_13E11 - 3F048h)[rdx+rcx*4]
add rcx, rdx
jmp rcx; switch jump
loc_13E13:
mov ebx, [rax+18h]; jumptable 0000000000013E11 case 3
jmp def_13E11; jumptable 0000000000013E11 default case
loc_13E1B:
mov ebx, [r12]; jumptable 0000000000013E11 case 5
shl ebx, 3
jmp def_13E11; jumptable 0000000000013E11 default case
loc_13E27:
mov rcx, [r12+8]; jumptable 0000000000013E11 case 6
mov eax, [r12]
lea edx, [rax-1]
movzx ecx, byte ptr [rcx+rdx]
cmp ecx, 1
jnz short loc_13E7F
lea ebx, ds:0FFFFFFFFFFFFFFF8h[rax*8]
jmp short def_13E11; jumptable 0000000000013E11 default case
loc_13E45:
mov r15, [rax+10h]; jumptable 0000000000013E11 case 4
mov rdi, r15
call ssz_fixed_length
mov r14, rax
test r14d, r14d
jz short def_13E11; jumptable 0000000000013E11 default case
mov ebx, [r12]
cmp ebx, 5
jb short loc_13E9E
mov rdi, r15
call ssz_is_dynamic
test al, al
jz short loc_13E9E
mov rdi, [r12+8]
call uint32_from_le
mov ebx, eax
shr ebx, 2
jmp short def_13E11; jumptable 0000000000013E11 default case
loc_13E7F:
lea ebx, ds:0FFFFFFFFFFFFFFFFh[rax*8]
mov edx, 7
loc_13E8B:
bt ecx, edx
jb short def_13E11; jumptable 0000000000013E11 default case
dec ebx
add edx, 0FFFFFFFFh
jb short loc_13E8B
shl eax, 3
mov ebx, eax
jmp short def_13E11; jumptable 0000000000013E11 default case
loc_13E9E:
mov eax, ebx
xor edx, edx
div r14d
mov ebx, eax
def_13E11:
mov eax, ebx; jumptable 0000000000013E11 default case
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long ssz_len(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
unsigned int a7,
unsigned int *a8,
long long a9)
{
unsigned int v9; // ebx
int v10; // ecx
long long v11; // r15
unsigned int v12; // r14d
unsigned int v13; // edx
v9 = 0;
switch ( *(_DWORD *)(a9 + 8) )
{
case 3:
v9 = *(_DWORD *)(a9 + 24);
break;
case 4:
v11 = *(_QWORD *)(a9 + 16);
v12 = ssz_fixed_length(v11);
if ( v12 )
{
if ( a7 >= 5 && (unsigned __int8)ssz_is_dynamic(v11) )
v9 = (unsigned int)uint32_from_le(a8) >> 2;
else
v9 = a7 / v12;
}
break;
case 5:
v9 = 8 * a7;
break;
case 6:
v10 = *((unsigned __int8 *)a8 + a7 - 1);
if ( v10 == 1 )
{
v9 = 8 * a7 - 8;
}
else
{
v9 = 8 * a7 - 1;
v13 = 7;
while ( !_bittest(&v10, v13) )
{
--v9;
if ( v13-- == 0 )
return 8 * a7;
}
}
break;
default:
return v9;
}
return v9;
}
| ssz_len:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,dword ptr [RAX + 0x8]
XOR EBX,EBX
ADD ECX,-0x3
CMP ECX,0x3
JA 0x00113ea7
LEA R12,[RSP + 0x30]
LEA RDX,[0x13f048]
MOVSXD RCX,dword ptr [RDX + RCX*0x4]
ADD RCX,RDX
switchD:
JMP RCX
caseD_3:
MOV EBX,dword ptr [RAX + 0x18]
JMP 0x00113ea7
caseD_5:
MOV EBX,dword ptr [R12]
SHL EBX,0x3
JMP 0x00113ea7
caseD_6:
MOV RCX,qword ptr [R12 + 0x8]
MOV EAX,dword ptr [R12]
LEA EDX,[RAX + -0x1]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP ECX,0x1
JNZ 0x00113e7f
LEA EBX,[-0x8 + RAX*0x8]
JMP 0x00113ea7
caseD_4:
MOV R15,qword ptr [RAX + 0x10]
MOV RDI,R15
CALL 0x00113330
MOV R14,RAX
TEST R14D,R14D
JZ 0x00113ea7
MOV EBX,dword ptr [R12]
CMP EBX,0x5
JC 0x00113e9e
MOV RDI,R15
CALL 0x001132e8
TEST AL,AL
JZ 0x00113e9e
MOV RDI,qword ptr [R12 + 0x8]
CALL 0x001125c5
MOV EBX,EAX
SHR EBX,0x2
JMP 0x00113ea7
LAB_00113e7f:
LEA EBX,[-0x1 + RAX*0x8]
MOV EDX,0x7
LAB_00113e8b:
BT ECX,EDX
JC 0x00113ea7
DEC EBX
ADD EDX,-0x1
JC 0x00113e8b
SHL EAX,0x3
MOV EBX,EAX
JMP 0x00113ea7
LAB_00113e9e:
MOV EAX,EBX
XOR EDX,EDX
DIV R14D
MOV EBX,EAX
default:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
uint ssz_len(void)
{
byte bVar1;
int8 uVar2;
char cVar3;
uint uVar4;
uint uVar5;
bool bVar6;
uint in_stack_00000008;
long in_stack_00000010;
long in_stack_00000018;
uVar4 = 0;
switch(*(int4 *)(in_stack_00000018 + 8)) {
case 3:
uVar4 = *(uint *)(in_stack_00000018 + 0x18);
break;
case 4:
uVar2 = *(int8 *)(in_stack_00000018 + 0x10);
uVar5 = ssz_fixed_length(uVar2);
uVar4 = 0;
if (uVar5 != 0) {
if ((in_stack_00000008 < 5) || (cVar3 = ssz_is_dynamic(uVar2), cVar3 == '\0')) {
uVar4 = in_stack_00000008 / uVar5;
}
else {
uVar4 = uint32_from_le(in_stack_00000010);
uVar4 = uVar4 >> 2;
}
}
break;
case 5:
uVar4 = in_stack_00000008 << 3;
break;
case 6:
bVar1 = *(byte *)(in_stack_00000010 + (ulong)(in_stack_00000008 - 1));
if (bVar1 == 1) {
uVar4 = in_stack_00000008 * 8 - 8;
}
else {
uVar4 = in_stack_00000008 * 8;
uVar5 = 7;
do {
uVar4 = uVar4 - 1;
if ((bVar1 >> (uVar5 & 0x1f) & 1) != 0) {
return uVar4;
}
bVar6 = uVar5 != 0;
uVar5 = uVar5 - 1;
} while (bVar6);
uVar4 = in_stack_00000008 << 3;
}
}
return uVar4;
}
| |
23,690 | inline_mysql_file_pread | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_pread(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, uchar *buffer, size_t count, my_off_t offset, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_read;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_READ);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_pread(file, buffer, count, offset, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_read= (result == 0) ? count : 0;
else
bytes_read= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_read);
return result;
}
#endif
result= my_pread(file, buffer, count, offset, flags);
return result;
} | O0 | c | inline_mysql_file_pread:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
leaq 0x20a324(%rip), %rax # 0x23cfc0
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x6, %edx
callq *%rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x32daf
leaq 0x20a2da(%rip), %rax # 0x23cfc0
movq (%rax), %rax
movq 0x210(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq *%rax
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x84700
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0x32d5a
cmpq $0x0, -0x38(%rbp)
jne 0x32d3f
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0x32d4a
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x32d4a
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x32d87
cmpq $-0x1, -0x38(%rbp)
je 0x32d6e
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x32d79
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x32d79
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x20a232(%rip), %rax # 0x23cfc0
movq (%rax), %rax
movq 0x218(%rax), %rax
movq -0x40(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq *%rax
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x32dd3
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x84700
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
| inline_mysql_file_pread:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_18], edx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+158h]
mov esi, [rbp+var_18]
lea rdi, [rbp+var_88]
mov edx, 6
call rax
mov [rbp+var_40], rax
cmp [rbp+var_40], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_32DAF
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+210h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_10]
mov ecx, [rbp+var_14]
call rax
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
and rax, 6
cmp rax, 0
jz short loc_32D5A
cmp [rbp+var_38], 0
jnz short loc_32D3F
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_32D4A
loc_32D3F:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_32D4A:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_32D87
loc_32D5A:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_32D6E
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_32D79
loc_32D6E:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_32D79:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_32D87:
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+218h]
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_90]
call rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
jmp short loc_32DD3
loc_32DAF:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
mov r8, [rbp+arg_0]
call my_pread
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_32DD3:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_pread(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6,
long long a7)
{
long long v8; // [rsp+0h] [rbp-A0h]
long long v9; // [rsp+8h] [rbp-98h]
_BYTE v10[72]; // [rsp+18h] [rbp-88h] BYREF
long long v11; // [rsp+60h] [rbp-40h]
long long v12; // [rsp+68h] [rbp-38h]
long long v13; // [rsp+70h] [rbp-30h]
long long v14; // [rsp+78h] [rbp-28h]
long long v15; // [rsp+80h] [rbp-20h]
unsigned int v16; // [rsp+88h] [rbp-18h]
unsigned int v17; // [rsp+8Ch] [rbp-14h]
long long v18; // [rsp+90h] [rbp-10h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14 = a5;
v13 = a6;
v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v10, a3, 6LL);
if ( v11 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v11, v14, v18, v17);
v12 = my_pread(v16, v15, v14, v13, a7);
if ( (a7 & 6) != 0 )
{
if ( v12 )
v9 = 0LL;
else
v9 = v14;
((void ( *)(long long, long long))PSI_server[67])(v11, v9);
}
else
{
if ( v12 == -1 )
v8 = 0LL;
else
v8 = v12;
((void ( *)(long long, long long))PSI_server[67])(v11, v8);
}
return v12;
}
else
{
return my_pread(v16, v15, v14, v13, a7);
}
}
| inline_mysql_file_pread:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV dword ptr [RBP + -0x18],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
LEA RAX,[0x33cfc0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x6
CALL RAX
MOV qword ptr [RBP + -0x40],RAX
CMP qword ptr [RBP + -0x40],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x00132daf
LEA RAX,[0x33cfc0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x210]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RBP + -0x14]
CALL RAX
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x00184700
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
AND RAX,0x6
CMP RAX,0x0
JZ 0x00132d5a
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00132d3f
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00132d4a
LAB_00132d3f:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x00132d4a
LAB_00132d4a:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00132d87
LAB_00132d5a:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x00132d6e
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x00132d79
LAB_00132d6e:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x00132d79
LAB_00132d79:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_00132d87:
LEA RAX,[0x33cfc0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV RDI,qword ptr [RBP + -0x40]
MOV RSI,qword ptr [RBP + -0x90]
CALL RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00132dd3
LAB_00132daf:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + 0x10]
CALL 0x00184700
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_00132dd3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_pread
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,int8 param_6,ulong param_7)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
int8 local_38;
long local_30;
int8 local_28;
int4 local_20;
int4 local_1c;
int8 local_18;
long local_10;
local_38 = param_6;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_1c = param_2;
local_18 = param_1;
local_48 = (**(code **)(PSI_server + 0x158))(local_90,param_3,6);
if (local_48 == 0) {
local_10 = my_pread(local_20,local_28,local_30,local_38,param_7);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_pread(local_20,local_28,local_30,local_38,param_7);
if ((param_7 & 6) == 0) {
local_a8 = local_40;
if (local_40 == -1) {
local_a8 = 0;
}
local_98 = local_a8;
}
else {
if (local_40 == 0) {
local_a0 = local_30;
}
else {
local_a0 = 0;
}
local_98 = local_a0;
}
(**(code **)(PSI_server + 0x218))(local_48,local_98);
local_10 = local_40;
}
return local_10;
}
| |
23,691 | patricia_to_nibbles | corpus-core[P]colibri-stateless/src/chains/eth/verifier/patricia.c | static uint8_t* patricia_to_nibbles(bytes_t p, bool prefix) {
size_t count = 0;
uint8_t* nibbles = safe_calloc(1 + (p.len << 1), 1);
for (size_t i = 0; i < p.len; i++) {
nibbles[count++] = p.data[i] >> 4;
nibbles[count++] = p.data[i] & 0x0F;
if (prefix && i == 0)
nibbles[0] = nibbles[(count = nibbles[0] & 1 ? 1 : 0)];
}
nibbles[count] = 0xFF;
return nibbles;
} | O3 | c | patricia_to_nibbles:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leal 0x1(,%r15,2), %edi
movl $0x1, %esi
callq 0x50eef
testl %r15d, %r15d
je 0x2d1f9
movl %r15d, %ecx
xorl %edx, %edx
xorb $0x1, %bl
xorl %esi, %esi
movb (%r14,%rdx), %dil
shrb $0x4, %dil
movb %dil, (%rax,%rsi)
movb (%r14,%rdx), %dil
andb $0xf, %dil
movb %dil, 0x1(%rax,%rsi)
testq %rdx, %rdx
setne %dil
orb %bl, %dil
jne 0x2d1eb
movzbl (%rax), %esi
andl $0x1, %esi
movb (%rax,%rsi), %dil
movb %dil, (%rax)
jmp 0x2d1ef
addq $0x2, %rsi
incq %rdx
cmpq %rdx, %rcx
jne 0x2d1b7
jmp 0x2d1fb
xorl %esi, %esi
movb $-0x1, (%rax,%rsi)
popq %rbx
popq %r14
popq %r15
retq
| patricia_to_nibbles:
push r15
push r14
push rbx
mov ebx, edx
mov r14, rsi
mov r15d, edi
lea edi, ds:1[r15*2]
mov esi, 1
call safe_calloc
test r15d, r15d
jz short loc_2D1F9
mov ecx, r15d
xor edx, edx
xor bl, 1
xor esi, esi
loc_2D1B7:
mov dil, [r14+rdx]
shr dil, 4
mov [rax+rsi], dil
mov dil, [r14+rdx]
and dil, 0Fh
mov [rax+rsi+1], dil
test rdx, rdx
setnz dil
or dil, bl
jnz short loc_2D1EB
movzx esi, byte ptr [rax]
and esi, 1
mov dil, [rax+rsi]
mov [rax], dil
jmp short loc_2D1EF
loc_2D1EB:
add rsi, 2
loc_2D1EF:
inc rdx
cmp rcx, rdx
jnz short loc_2D1B7
jmp short loc_2D1FB
loc_2D1F9:
xor esi, esi
loc_2D1FB:
mov byte ptr [rax+rsi], 0FFh
pop rbx
pop r14
pop r15
retn
| _BYTE * patricia_to_nibbles(int a1, long long a2, char a3)
{
_BYTE *result; // rax
long long v6; // rdx
unsigned __int8 v7; // bl
long long v8; // rsi
result = (_BYTE *)safe_calloc((unsigned int)(2 * a1 + 1), 1LL);
if ( a1 )
{
v6 = 0LL;
v7 = a3 ^ 1;
v8 = 0LL;
do
{
result[v8] = *(_BYTE *)(a2 + v6) >> 4;
result[v8 + 1] = *(_BYTE *)(a2 + v6) & 0xF;
if ( v7 | (v6 != 0) )
{
v8 += 2LL;
}
else
{
v8 = *result & 1;
*result = result[v8];
}
++v6;
}
while ( a1 != v6 );
}
else
{
v8 = 0LL;
}
result[v8] = -1;
return result;
}
| patricia_to_nibbles:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R14,RSI
MOV R15D,EDI
LEA EDI,[0x1 + R15*0x2]
MOV ESI,0x1
CALL 0x00150eef
TEST R15D,R15D
JZ 0x0012d1f9
MOV ECX,R15D
XOR EDX,EDX
XOR BL,0x1
XOR ESI,ESI
LAB_0012d1b7:
MOV DIL,byte ptr [R14 + RDX*0x1]
SHR DIL,0x4
MOV byte ptr [RAX + RSI*0x1],DIL
MOV DIL,byte ptr [R14 + RDX*0x1]
AND DIL,0xf
MOV byte ptr [RAX + RSI*0x1 + 0x1],DIL
TEST RDX,RDX
SETNZ DIL
OR DIL,BL
JNZ 0x0012d1eb
MOVZX ESI,byte ptr [RAX]
AND ESI,0x1
MOV DIL,byte ptr [RAX + RSI*0x1]
MOV byte ptr [RAX],DIL
JMP 0x0012d1ef
LAB_0012d1eb:
ADD RSI,0x2
LAB_0012d1ef:
INC RDX
CMP RCX,RDX
JNZ 0x0012d1b7
JMP 0x0012d1fb
LAB_0012d1f9:
XOR ESI,ESI
LAB_0012d1fb:
MOV byte ptr [RAX + RSI*0x1],0xff
POP RBX
POP R14
POP R15
RET
|
void patricia_to_nibbles(uint param_1,long param_2,char param_3)
{
byte *pbVar1;
ulong uVar2;
ulong uVar3;
pbVar1 = (byte *)safe_calloc(param_1 * 2 + 1);
if (param_1 == 0) {
uVar3 = 0;
}
else {
uVar2 = 0;
uVar3 = 0;
do {
pbVar1[uVar3] = *(byte *)(param_2 + uVar2) >> 4;
pbVar1[uVar3 + 1] = *(byte *)(param_2 + uVar2) & 0xf;
if (uVar2 == 0 && param_3 == '\x01') {
uVar3 = (ulong)(*pbVar1 & 1);
*pbVar1 = pbVar1[uVar3];
}
else {
uVar3 = uVar3 + 2;
}
uVar2 = uVar2 + 1;
} while (param_1 != uVar2);
}
pbVar1[uVar3] = 0xff;
return;
}
| |
23,692 | build_prefix(st_mysql_const_lex_string const*, char const*, char*, unsigned long*) | eloqsql/storage/perfschema/pfs.cc | static int build_prefix(const LEX_CSTRING *prefix, const char *category,
char *output, size_t *output_length)
{
size_t len= strlen(category);
char *out_ptr= output;
size_t prefix_length= prefix->length;
if (unlikely((prefix_length + len + 1) >=
PFS_MAX_FULL_PREFIX_NAME_LENGTH))
{
pfs_print_error("build_prefix: prefix+category is too long <%s> <%s>\n",
prefix->str, category);
return 1;
}
if (unlikely(strchr(category, '/') != NULL))
{
pfs_print_error("build_prefix: invalid category <%s>\n",
category);
return 1;
}
/* output = prefix + category + '/' */
memcpy(out_ptr, prefix->str, prefix_length);
out_ptr+= prefix_length;
if (len > 0)
{
memcpy(out_ptr, category, len);
out_ptr+= len;
*out_ptr= '/';
out_ptr++;
}
*output_length= int(out_ptr - output);
return 0;
} | O0 | cpp | build_prefix(st_mysql_const_lex_string const*, char const*, char*, unsigned long*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x26150
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
addq $0x1, %rax
cmpq $0x20, %rax
setae %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4465b
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
leaq 0x6abfc(%rip), %rdi # 0xaf244
movb $0x0, %al
callq 0x29c10
movl $0x1, -0x4(%rbp)
jmp 0x44708
movq -0x18(%rbp), %rdi
movl $0x2f, %esi
callq 0x26120
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x44695
movq -0x18(%rbp), %rsi
leaq 0x6abf4(%rip), %rdi # 0xaf279
movb $0x0, %al
callq 0x29c10
movl $0x1, -0x4(%rbp)
jmp 0x44708
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x40(%rbp), %rdx
callq 0x26280
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x446ec
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x26280
movq -0x30(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x2f, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movslq %eax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZL12build_prefixPK25st_mysql_const_lex_stringPKcPcPm:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rdi, [rbp+var_18]
call _strlen
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
add rax, [rbp+var_30]
add rax, 1
cmp rax, 20h ; ' '
setnb al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4465B
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rdx, [rbp+var_18]
lea rdi, aBuildPrefixPre; "build_prefix: prefix+category is too lo"...
mov al, 0
call _Z15pfs_print_errorPKcz; pfs_print_error(char const*,...)
mov [rbp+var_4], 1
jmp loc_44708
loc_4465B:
mov rdi, [rbp+var_18]
mov esi, 2Fh ; '/'
call _strchr
cmp rax, 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_44695
mov rsi, [rbp+var_18]
lea rdi, aBuildPrefixInv; "build_prefix: invalid category <%s>\n"
mov al, 0
call _Z15pfs_print_errorPKcz; pfs_print_error(char const*,...)
mov [rbp+var_4], 1
jmp short loc_44708
loc_44695:
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rsi, [rax]
mov rdx, [rbp+var_40]
call _memcpy
mov rax, [rbp+var_40]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
cmp [rbp+var_30], 0
jbe short loc_446EC
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_30]
call _memcpy
mov rax, [rbp+var_30]
add rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax], 2Fh ; '/'
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
loc_446EC:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_20]
sub rax, rcx
movsxd rcx, eax
mov rax, [rbp+var_28]
mov [rax], rcx
mov [rbp+var_4], 0
loc_44708:
mov eax, [rbp+var_4]
add rsp, 40h
pop rbp
retn
| long long build_prefix(_QWORD *a1, long long a2, long long a3, _QWORD *a4)
{
long long v5; // [rsp+0h] [rbp-40h]
_BYTE *v6; // [rsp+8h] [rbp-38h]
long long v7; // [rsp+10h] [rbp-30h]
v7 = strlen(a2);
v5 = a1[1];
if ( (unsigned long long)(v7 + v5 + 1) < 0x20 )
{
if ( strchr(a2, 47LL) )
{
pfs_print_error("build_prefix: invalid category <%s>\n");
return 1;
}
else
{
memcpy(a3, *a1, v5);
v6 = (_BYTE *)(a3 + v5);
if ( v7 )
{
memcpy(v6, a2, v7);
v6 += v7;
*v6 = 47;
LODWORD(v6) = (_DWORD)v6 + 1;
}
*a4 = (int)v6 - (int)a3;
return 0;
}
}
else
{
pfs_print_error("build_prefix: prefix+category is too long <%s> <%s>\n");
return 1;
}
}
| build_prefix:
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 qword ptr [RBP + -0x28],RCX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00126150
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
CMP RAX,0x20
SETNC AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014465b
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
LEA RDI,[0x1af244]
MOV AL,0x0
CALL 0x00129c10
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00144708
LAB_0014465b:
MOV RDI,qword ptr [RBP + -0x18]
MOV ESI,0x2f
CALL 0x00126120
CMP RAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x00144695
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x1af279]
MOV AL,0x0
CALL 0x00129c10
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00144708
LAB_00144695:
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x00126280
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x30],0x0
JBE 0x001446ec
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x30]
CALL 0x00126280
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x2f
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
LAB_001446ec:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_00144708:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x40
POP RBP
RET
|
/* build_prefix(st_mysql_const_lex_string const*, char const*, char*, unsigned long*) */
int4
build_prefix(st_mysql_const_lex_string *param_1,char *param_2,char *param_3,ulong *param_4)
{
size_t __n;
size_t __n_00;
char *pcVar1;
char *local_40;
int4 local_c;
__n_00 = strlen(param_2);
__n = *(size_t *)(param_1 + 8);
if (__n + __n_00 + 1 < 0x20) {
pcVar1 = strchr(param_2,0x2f);
if (pcVar1 == (char *)0x0) {
memcpy(param_3,*(void **)param_1,__n);
local_40 = param_3 + __n;
if (__n_00 != 0) {
memcpy(local_40,param_2,__n_00);
local_40[__n_00] = '/';
local_40 = local_40 + __n_00 + 1;
}
*param_4 = (long)((int)local_40 - (int)param_3);
local_c = 0;
}
else {
pfs_print_error("build_prefix: invalid category <%s>\n",param_2);
local_c = 1;
}
}
else {
pfs_print_error("build_prefix: prefix+category is too long <%s> <%s>\n",*(int8 *)param_1,
param_2);
local_c = 1;
}
return local_c;
}
| |
23,693 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/./minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O0 | cpp | bool minja::Value::get<bool>() const:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9fe30
testb $0x1, %al
jne 0xd41ee
jmp 0xd4201
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0xd43c0
addq $0x68, %rsp
retq
movb $0x1, 0x13(%rsp)
movl $0x10, %edi
callq 0x50540
movq 0x8(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x9feb0
jmp 0xd422c
leaq 0xf89ad(%rip), %rsi # 0x1ccbe0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x7a6e0
jmp 0xd4244
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x50390
jmp 0xd4254
movq (%rsp), %rdi
movb $0x0, 0x13(%rsp)
movq 0x17fd4c(%rip), %rsi # 0x253fb0
movq 0x17fd0d(%rip), %rdx # 0x253f78
callq 0x508f0
jmp 0xd42d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xd42b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0xd42aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x510c0
leaq 0x20(%rsp), %rdi
callq 0x510c0
testb $0x1, 0x13(%rsp)
jne 0xd42bd
jmp 0xd42c6
movq (%rsp), %rdi
callq 0x50c40
jmp 0xd42c8
movq 0x18(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZNK5minja5Value3getIiEET_v:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov rdi, [rsp+68h+var_8]; this
mov [rsp+68h+var_60], rdi
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, 1
jnz short loc_D41EE
jmp short loc_D4201
loc_D41EE:
mov rdi, [rsp+68h+var_60]
add rdi, 40h ; '@'
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3getIiiEEDTcldtclL_ZSt7declvalIRKSD_EDTcl9__declvalIT_ELi0EEEvEE8get_implIT0_EtlNS0_6detail12priority_tagILj4EEEEEEv
add rsp, 68h
retn
loc_D4201:
mov [rsp+68h+var_55], 1
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rsi, [rsp+68h+var_60]
mov [rsp+68h+var_68], rax
lea rdi, [rsp+68h+var_48]
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
jmp short $+2
loc_D422C:
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+68h+var_28]
lea rdx, [rsp+68h+var_48]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
jmp short $+2
loc_D4244:
mov rdi, [rsp+68h+var_68]
lea rsi, [rsp+68h+var_28]
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
jmp short $+2
loc_D4254:
mov rdi, [rsp+68h+var_68]; void *
mov [rsp+68h+var_55], 0
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
| long long minja::Value::get<int>(minja::Value *a1)
{
void *exception; // [rsp+0h] [rbp-68h]
_BYTE v3[32]; // [rsp+20h] [rbp-48h] BYREF
_BYTE v4[32]; // [rsp+40h] [rbp-28h] BYREF
minja::Value *v5; // [rsp+60h] [rbp-8h]
v5 = a1;
if ( (minja::Value::is_primitive(a1) & 1) == 0 )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v3, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v4, (long long)"get<T> not defined for this value type: ", (long long)v3);
std::runtime_error::runtime_error(exception, v4);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get<int,int>((char *)a1 + 64);
}
| get<int>:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV RDI,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x0019fe30
TEST AL,0x1
JNZ 0x001d41ee
JMP 0x001d4201
LAB_001d41ee:
MOV RDI,qword ptr [RSP + 0x8]
ADD RDI,0x40
CALL 0x001d43c0
ADD RSP,0x68
RET
LAB_001d4201:
MOV byte ptr [RSP + 0x13],0x1
MOV EDI,0x10
CALL 0x00150540
MOV RSI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP],RAX
LAB_001d4219:
LEA RDI,[RSP + 0x20]
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0019feb0
JMP 0x001d422c
LAB_001d422c:
LEA RSI,[0x2ccbe0]
LEA RDI,[RSP + 0x40]
LEA RDX,[RSP + 0x20]
CALL 0x0017a6e0
JMP 0x001d4244
LAB_001d4244:
MOV RDI,qword ptr [RSP]
LEA RSI,[RSP + 0x40]
CALL 0x00150390
JMP 0x001d4254
LAB_001d4254:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x13],0x0
MOV RSI,qword ptr [0x00353fb0]
MOV RDX,qword ptr [0x00353f78]
CALL 0x001508f0
|
/* int minja::Value::get<int>() const */
int __thiscall minja::Value::get<int>(Value *this)
{
runtime_error *this_00;
uint uVar1;
int iVar2;
int1 local_48 [32];
string local_28 [32];
Value *local_8;
local_8 = this;
uVar1 = is_primitive(this);
if ((uVar1 & 1) == 0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001d4219 to 001d4229 has its CatchHandler @ 001d4272 */
dump_abi_cxx11_((int)local_48,SUB81(this,0));
/* try { // try from 001d422c to 001d4241 has its CatchHandler @ 001d4282 */
std::operator+((char *)local_28,(string *)"get<T> not defined for this value type: ");
/* try { // try from 001d4244 to 001d426f has its CatchHandler @ 001d4292 */
std::runtime_error::runtime_error(this_00,local_28);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00353fb0,PTR__runtime_error_00353f78);
}
iVar2 = 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<int,int>((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 + 0x40));
return iVar2;
}
| |
23,694 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/./minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O1 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x53833
cmpq $0x0, 0x20(%r14)
jne 0x53833
cmpq $0x0, 0x30(%r14)
jne 0x53833
addq $0x40, %r14
movq %rsp, %rbx
movl $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x538ec
movl (%rbx), %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3f31a
leaq 0x67897(%rip), %rsi # 0xbb0f2
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x322c7
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0x9f771(%rip), %rsi # 0xf2ff0
movq 0x9f6fa(%rip), %rdx # 0xf2f80
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x538b4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x538b4
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x538d7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x538d7
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x538e4
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
| _ZNK5minja5Value3getIiEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_53833
cmp qword ptr [r14+20h], 0
jnz short loc_53833
cmp qword ptr [r14+30h], 0
jnz short loc_53833
add r14, 40h ; '@'
mov rbx, rsp
mov dword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
mov eax, [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_53833:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+58h+var_38]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
mov rdi, rsp
lea rdx, [rsp+58h+var_38]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
mov rsi, rsp
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
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_538B4
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_538B4
mov r14, rax
mov bpl, 1
loc_538B4:
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_538D7
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_538D7
mov r14, rax
mov bpl, 1
loc_538D7:
test bpl, bpl
jz short loc_538E4
mov rdi, rbx; void *
call ___cxa_free_exception
loc_538E4:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<int>(_QWORD *a1)
{
void *exception; // rbx
_DWORD v3[4]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v4[16]; // [rsp+20h] [rbp-38h] BYREF
if ( a1[2] || a1[4] || a1[6] )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v4, (long long)a1, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v3, (long long)"get<T> not defined for this value type: ", (long long)v4);
std::runtime_error::runtime_error(exception, v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v3[0] = 0;
ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_(
a1 + 8,
v3);
return v3[0];
}
| get<int>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x00153833
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x00153833
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x00153833
ADD R14,0x40
MOV RBX,RSP
MOV dword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x001538ec
MOV EAX,dword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_00153833:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_00153840:
LEA RDI,[RSP + 0x20]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013f31a
LAB_00153854:
LEA RSI,[0x1bb0f2]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x001322c7
MOV BPL,0x1
LAB_0015386b:
MOV RSI,RSP
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001f2ff0]
MOV RDX,qword ptr [0x001f2f80]
MOV RDI,RBX
CALL 0x00118b30
|
/* int minja::Value::get<int>() const */
int __thiscall minja::Value::get<int>(Value *this)
{
runtime_error *this_00;
int local_58 [8];
int1 local_38 [32];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_58[0] = 0;
_ZN8nlohmann16json_abi_v3_11_36detail9from_jsonINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEiTnNSt9enable_ifIXaaaaaaaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_17number_unsigned_tEEE5valuentsr3std7is_sameISH_NSI_16number_integer_tEEE5valuentsr3std7is_sameISH_NSI_14number_float_tEEE5valuentsr3std7is_sameISH_NSI_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(this + 0x40,local_58);
return local_58[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00153840 to 00153853 has its CatchHandler @ 001538d1 */
dump_abi_cxx11_((int)local_38,SUB81(this,0));
/* try { // try from 00153854 to 00153867 has its CatchHandler @ 001538ae */
std::operator+((char *)local_58,(string *)"get<T> not defined for this value type: ");
/* try { // try from 0015386b to 0015388d has its CatchHandler @ 0015388e */
std::runtime_error::runtime_error(this_00,(string *)local_58);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001f2ff0,PTR__runtime_error_001f2f80);
}
| |
23,695 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/./minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O2 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3b604
testb %al, %al
je 0x3cc0f
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ce70
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %rbx
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x3b614
leaq 0x5d4c1(%rip), %rsi # 0x9a0f2
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30398
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0xa5391(%rip), %rsi # 0xe1fe8
movq 0xa5312(%rip), %rdx # 0xe1f70
movq %rbx, %rdi
callq 0x20b30
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20d78
jmp 0x3cc7b
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x20d78
testb %bpl, %bpl
jne 0x3cc8d
jmp 0x3cc95
movq %rax, %r14
movq %rbx, %rdi
callq 0x20520
movq %r14, %rdi
callq 0x20b90
nop
| _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rsi
mov rbx, rdi
mov rdi, rsi; this
call _ZNK5minja5Value12is_primitiveEv; minja::Value::is_primitive(void)
test al, al
jz short loc_3CC0F
add r14, 40h ; '@'
mov rdi, rbx
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE
mov rax, rbx
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_3CC0F:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
push 0FFFFFFFFFFFFFFFFh
pop rdx
mov rsi, r14
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
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
lea rdi, [rsp+58h+var_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_3CC7B
mov r14, rax
mov bpl, 1
loc_3CC7B:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_3CC8D
jmp short loc_3CC95
mov r14, rax
loc_3CC8D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_3CC95:
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::get<std::string>(long long a1, minja::Value *a2)
{
void *exception; // rbx
_BYTE v4[32]; // [rsp+0h] [rbp-58h] BYREF
_BYTE v5[56]; // [rsp+20h] [rbp-38h] BYREF
if ( !minja::Value::is_primitive(a2) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v4, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v5, (long long)"get<T> not defined for this value type: ", (long long)v4);
std::runtime_error::runtime_error(exception, v5);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8get_implIS9_TnNSt9enable_ifIXaasr6detail24is_default_constructibleIT_EE5valuesr6detail13has_from_jsonISD_SG_EE5valueEiE4typeELi0EEESG_NS0_6detail12priority_tagILj0EEE(
a1,
(char *)a2 + 64);
return a1;
}
| |||
23,696 | bool minja::Value::get<bool>() const | monkey531[P]llama/common/./minja.hpp | T get() const {
if (is_primitive()) return primitive_.get<T>();
throw std::runtime_error("get<T> not defined for this value type: " + dump());
} | O3 | cpp | bool minja::Value::get<bool>() const:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x3dbd8
cmpq $0x0, 0x20(%r14)
jne 0x3dbd8
cmpq $0x0, 0x30(%r14)
jne 0x3dbd8
addq $0x40, %r14
leaq 0x20(%rsp), %rbx
movq $0x0, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f485
movsd (%rbx), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x18360
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3dcdc
leaq 0x7936c(%rip), %rsi # 0xb6f6a
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x30c3b
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x18a80
xorl %ebp, %ebp
movq 0xb23cc(%rip), %rsi # 0xefff0
movq 0xb2355(%rip), %rdx # 0xeff80
movq %rbx, %rdi
callq 0x18b30
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dc51
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x186a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dc6c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x3dc96
jmp 0x3dc9e
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dc96
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x186a0
jmp 0x3dc96
movq %rax, %r14
movq %rbx, %rdi
callq 0x18500
movq %r14, %rdi
callq 0x18b90
| _ZNK5minja5Value3getIdEET_v:
push rbp
push r14
push rbx
sub rsp, 40h
mov r14, rdi
cmp qword ptr [rdi+10h], 0
jnz short loc_3DBD8
cmp qword ptr [r14+20h], 0
jnz short loc_3DBD8
cmp qword ptr [r14+30h], 0
jnz short loc_3DBD8
add r14, 40h ; '@'
lea rbx, [rsp+58h+var_38]
mov qword ptr [rbx], 0
mov rdi, r14
mov rsi, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
movsd xmm0, qword ptr [rbx]
add rsp, 40h
pop rbx
pop r14
pop rbp
retn
loc_3DBD8:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, rsp
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aGetTNotDefined; "get<T> not defined for this value type:"...
lea rdi, [rsp+58h+var_38]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+58h+var_38]
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
lea rax, [rsp+58h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3DC51
mov rsi, [rsp+58h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3DC51:
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3DC6C
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3DC6C:
test bpl, bpl
jnz short loc_3DC96
jmp short loc_3DC9E
mov r14, rax
lea rax, [rsp+58h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_3DC96
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_3DC96
mov r14, rax
loc_3DC96:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_3DC9E:
mov rdi, r14
call __Unwind_Resume
| get<double>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP qword ptr [RDI + 0x10],0x0
JNZ 0x0013dbd8
CMP qword ptr [R14 + 0x20],0x0
JNZ 0x0013dbd8
CMP qword ptr [R14 + 0x30],0x0
JNZ 0x0013dbd8
ADD R14,0x40
LEA RBX,[RSP + 0x20]
MOV qword ptr [RBX],0x0
MOV RDI,R14
MOV RSI,RBX
CALL 0x0013f485
MOVSD XMM0,qword ptr [RBX]
ADD RSP,0x40
POP RBX
POP R14
POP RBP
RET
LAB_0013dbd8:
MOV EDI,0x10
CALL 0x00118360
MOV RBX,RAX
LAB_0013dbe5:
MOV RDI,RSP
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013dcdc
LAB_0013dbf7:
LEA RSI,[0x1b6f6a]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x00130c3b
MOV BPL,0x1
LAB_0013dc0e:
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x00118a80
XOR EBP,EBP
MOV RSI,qword ptr [0x001efff0]
MOV RDX,qword ptr [0x001eff80]
MOV RDI,RBX
CALL 0x00118b30
|
/* double minja::Value::get<double>() const */
double __thiscall minja::Value::get<double>(Value *this)
{
runtime_error *this_00;
int1 auStack_58 [32];
double local_38 [4];
if (((*(long *)(this + 0x10) == 0) && (*(long *)(this + 0x20) == 0)) &&
(*(long *)(this + 0x30) == 0)) {
local_38[0] = 0.0;
_ZN8nlohmann16json_abi_v3_11_36detail20get_arithmetic_valueINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEdTnNSt9enable_ifIXaasr3std13is_arithmeticIT0_EE5valuentsr3std7is_sameISH_NT_9boolean_tEEE5valueEiE4typeELi0EEEvRKSI_RSH_
(this + 0x40,local_38);
return local_38[0];
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0013dbe5 to 0013dbf6 has its CatchHandler @ 0013dc93 */
dump_abi_cxx11_((int)auStack_58,SUB81(this,0));
/* try { // try from 0013dbf7 to 0013dc0a has its CatchHandler @ 0013dc73 */
std::operator+((char *)local_38,(string *)"get<T> not defined for this value type: ");
/* try { // try from 0013dc0e to 0013dc32 has its CatchHandler @ 0013dc33 */
std::runtime_error::runtime_error(this_00,(string *)local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001efff0,PTR__runtime_error_001eff80);
}
| ||
23,697 | LefDefParser::lefwMacroPinAntennaMaxAreaCar(double, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwMacroPinAntennaMaxAreaCar(double value,
const char *layerName)
{
lefw54Num = LEFW_ANTENNAMAXAREACAR;
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (!lefwDidInit)
return LEFW_BAD_ORDER;
if (!lefwIsMacroPin)
return LEFW_BAD_ORDER;
if (lefwAMaxAreaCar)
return LEFW_BAD_DATA; // ANTENNAMAXAREACAR has defined
// more than once
if (versionNum < 5.4)
return LEFW_WRONG_VERSION;
if (lefwAntenna53)
return LEFW_MIX_VERSION_DATA;
if (lefwWriteEncrypt) {
encPrint(lefwFile, (char*) " ANTENNAMAXAREACAR %.11g ", value);
if (layerName)
encPrint(lefwFile, (char*) "LAYER %s ", layerName);
encPrint(lefwFile, (char*) ";\n");
} else {
fprintf(lefwFile, " ANTENNAMAXAREACAR %.11g ", value);
if (layerName)
fprintf(lefwFile, "LAYER %s ", layerName);
fprintf(lefwFile, ";\n");
}
lefwLines++;
lefwState = LEFW_MACRO;
lefwAntenna54 = 1;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwMacroPinAntennaMaxAreaCar(double, char const*):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, (%rsp)
movl $0x77, 0x95fd4(%rip) # 0xc4f1c
leaq 0x96301(%rip), %rax # 0xc5250
cmpq $0x0, (%rax)
jne 0x2ef62
movl $0x1, 0x14(%rsp)
jmp 0x2f0d0
leaq 0x9653b(%rip), %rax # 0xc54a4
cmpl $0x0, (%rax)
jne 0x2ef7b
movl $0x2, 0x14(%rsp)
jmp 0x2f0d0
leaq 0x9656e(%rip), %rax # 0xc54f0
cmpl $0x0, (%rax)
jne 0x2ef94
movl $0x2, 0x14(%rsp)
jmp 0x2f0d0
cmpl $0x0, 0x965c1(%rip) # 0xc555c
je 0x2efaa
movl $0x3, 0x14(%rsp)
jmp 0x2f0d0
movsd 0x73c8e(%rip), %xmm0 # 0xa2c40
ucomisd 0x95f56(%rip), %xmm0 # 0xc4f10
jbe 0x2efc9
movl $0x5, 0x14(%rsp)
jmp 0x2f0d0
cmpl $0x0, 0x9659c(%rip) # 0xc556c
je 0x2efdf
movl $0x6, 0x14(%rsp)
jmp 0x2f0d0
cmpl $0x0, 0x96556(%rip) # 0xc553c
je 0x2f043
leaq 0x96261(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x6530b(%rip), %rsi # 0x9430a
movb $0x1, %al
callq 0x8bf50
cmpq $0x0, (%rsp)
je 0x2f029
leaq 0x9623c(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x6537a(%rip), %rsi # 0x9439c
movb $0x0, %al
callq 0x8bf50
leaq 0x96220(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x637df(%rip), %rsi # 0x92819
movb $0x0, %al
callq 0x8bf50
jmp 0x2f09c
leaq 0x96206(%rip), %rax # 0xc5250
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x652b0(%rip), %rsi # 0x9430a
movb $0x1, %al
callq 0x2370
cmpq $0x0, (%rsp)
je 0x2f084
leaq 0x961e1(%rip), %rax # 0xc5250
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x6531f(%rip), %rsi # 0x9439c
movb $0x0, %al
callq 0x2370
leaq 0x961c5(%rip), %rax # 0xc5250
movq (%rax), %rdi
leaq 0x63784(%rip), %rsi # 0x92819
movb $0x0, %al
callq 0x2370
leaq 0x963f9(%rip), %rax # 0xc549c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x963ed(%rip), %rax # 0xc549c
movl %ecx, (%rax)
leaq 0x963e8(%rip), %rax # 0xc54a0
movl $0x21, (%rax)
movl $0x1, 0x964a0(%rip) # 0xc5568
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser29lefwMacroPinAntennaMaxAreaCarEdPKc:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
mov [rsp+18h+var_18], rdi
mov cs:_ZN12LefDefParserL9lefw54NumE, 77h ; 'w'; LefDefParser::lefw54Num
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_2EF62
mov [rsp+18h+var_4], 1
jmp loc_2F0D0
loc_2EF62:
lea rax, _ZN12LefDefParser11lefwDidInitE; LefDefParser::lefwDidInit
cmp dword ptr [rax], 0
jnz short loc_2EF7B
mov [rsp+18h+var_4], 2
jmp loc_2F0D0
loc_2EF7B:
lea rax, _ZN12LefDefParser14lefwIsMacroPinE; LefDefParser::lefwIsMacroPin
cmp dword ptr [rax], 0
jnz short loc_2EF94
mov [rsp+18h+var_4], 2
jmp loc_2F0D0
loc_2EF94:
cmp cs:_ZN12LefDefParserL15lefwAMaxAreaCarE, 0; LefDefParser::lefwAMaxAreaCar
jz short loc_2EFAA
mov [rsp+18h+var_4], 3
jmp loc_2F0D0
loc_2EFAA:
movsd xmm0, cs:qword_A2C40
ucomisd xmm0, cs:_ZN12LefDefParserL10versionNumE; LefDefParser::versionNum
jbe short loc_2EFC9
mov [rsp+18h+var_4], 5
jmp loc_2F0D0
loc_2EFC9:
cmp cs:_ZN12LefDefParserL13lefwAntenna53E, 0; LefDefParser::lefwAntenna53
jz short loc_2EFDF
mov [rsp+18h+var_4], 6
jmp loc_2F0D0
loc_2EFDF:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_2F043
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aAntennamaxarea_0; " ANTENNAMAXAREACAR %.11g "
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
cmp [rsp+18h+var_18], 0
jz short loc_2F029
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_18]
lea rsi, aLayerS_2+9; "LAYER %s "
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
loc_2F029:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_2F09C
loc_2F043:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aAntennamaxarea_0; " ANTENNAMAXAREACAR %.11g "
mov al, 1
call _fprintf
cmp [rsp+18h+var_18], 0
jz short loc_2F084
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
mov rdx, [rsp+18h+var_18]
lea rsi, aLayerS_2+9; "LAYER %s "
mov al, 0
call _fprintf
loc_2F084:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _fprintf
loc_2F09C:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
mov dword ptr [rax], 21h ; '!'
mov cs:_ZN12LefDefParserL13lefwAntenna54E, 1; LefDefParser::lefwAntenna54
mov [rsp+18h+var_4], 0
loc_2F0D0:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwMacroPinAntennaMaxAreaCar(
LefDefParser *this,
double a2,
const char *a3,
int a4,
int a5,
int a6,
int a7)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
LefDefParser::lefw54Num = 119;
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwDidInit )
{
if ( LefDefParser::lefwIsMacroPin )
{
if ( LefDefParser::lefwAMaxAreaCar )
{
return 3;
}
else if ( *(double *)&LefDefParser::versionNum >= 5.4 )
{
if ( LefDefParser::lefwAntenna53 )
{
return 6;
}
else
{
if ( LefDefParser::lefwWriteEncrypt )
{
LefDefParser::encPrint(
LefDefParser::lefwFile,
(unsigned int)" ANTENNAMAXAREACAR %.11g ",
a4,
a5,
a6,
a7);
if ( this )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)"LAYER %s ", (_DWORD)this, v8, v9, v10);
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\n", v7, v8, v9, v10);
}
else
{
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " ANTENNAMAXAREACAR %.11g ", a2);
if ( this )
fprintf(*(_QWORD *)&LefDefParser::lefwFile, "LAYER %s ", (const char *)this);
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\n");
}
++LefDefParser::lefwLines;
LefDefParser::lefwState = 33;
LefDefParser::lefwAntenna54 = 1;
return 0;
}
}
else
{
return 5;
}
}
else
{
return 2;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwMacroPinAntennaMaxAreaCar:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
MOV qword ptr [RSP],RDI
MOV dword ptr [0x001c4f1c],0x77
LEA RAX,[0x1c5250]
CMP qword ptr [RAX],0x0
JNZ 0x0012ef62
MOV dword ptr [RSP + 0x14],0x1
JMP 0x0012f0d0
LAB_0012ef62:
LEA RAX,[0x1c54a4]
CMP dword ptr [RAX],0x0
JNZ 0x0012ef7b
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012f0d0
LAB_0012ef7b:
LEA RAX,[0x1c54f0]
CMP dword ptr [RAX],0x0
JNZ 0x0012ef94
MOV dword ptr [RSP + 0x14],0x2
JMP 0x0012f0d0
LAB_0012ef94:
CMP dword ptr [0x001c555c],0x0
JZ 0x0012efaa
MOV dword ptr [RSP + 0x14],0x3
JMP 0x0012f0d0
LAB_0012efaa:
MOVSD XMM0,qword ptr [0x001a2c40]
UCOMISD XMM0,qword ptr [0x001c4f10]
JBE 0x0012efc9
MOV dword ptr [RSP + 0x14],0x5
JMP 0x0012f0d0
LAB_0012efc9:
CMP dword ptr [0x001c556c],0x0
JZ 0x0012efdf
MOV dword ptr [RSP + 0x14],0x6
JMP 0x0012f0d0
LAB_0012efdf:
CMP dword ptr [0x001c553c],0x0
JZ 0x0012f043
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x19430a]
MOV AL,0x1
CALL 0x0018bf50
CMP qword ptr [RSP],0x0
JZ 0x0012f029
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP]
LEA RSI,[0x19439c]
MOV AL,0x0
CALL 0x0018bf50
LAB_0012f029:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x192819]
MOV AL,0x0
CALL 0x0018bf50
JMP 0x0012f09c
LAB_0012f043:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x19430a]
MOV AL,0x1
CALL 0x00102370
CMP qword ptr [RSP],0x0
JZ 0x0012f084
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RSP]
LEA RSI,[0x19439c]
MOV AL,0x0
CALL 0x00102370
LAB_0012f084:
LEA RAX,[0x1c5250]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x192819]
MOV AL,0x0
CALL 0x00102370
LAB_0012f09c:
LEA RAX,[0x1c549c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x1c549c]
MOV dword ptr [RAX],ECX
LEA RAX,[0x1c54a0]
MOV dword ptr [RAX],0x21
MOV dword ptr [0x001c5568],0x1
MOV dword ptr [RSP + 0x14],0x0
LAB_0012f0d0:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwMacroPinAntennaMaxAreaCar(double, char const*) */
int4 LefDefParser::lefwMacroPinAntennaMaxAreaCar(double param_1,char *param_2)
{
int4 local_4;
lefw54Num = 0x77;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if (lefwDidInit == 0) {
local_4 = 2;
}
else if (lefwIsMacroPin == 0) {
local_4 = 2;
}
else if (lefwAMaxAreaCar == 0) {
if (DAT_001a2c40 <= versionNum) {
if (lefwAntenna53 == 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," ANTENNAMAXAREACAR %.11g ",param_1);
if (param_2 != (char *)0x0) {
fprintf(lefwFile,"LAYER %s ",param_2);
}
fprintf(lefwFile,";\n");
}
else {
encPrint(lefwFile," ANTENNAMAXAREACAR %.11g ",param_1);
if (param_2 != (char *)0x0) {
encPrint(lefwFile,"LAYER %s ",param_2);
}
encPrint(lefwFile,";\n");
}
lefwLines = lefwLines + 1;
lefwState = 0x21;
lefwAntenna54 = 1;
local_4 = 0;
}
else {
local_4 = 6;
}
}
else {
local_4 = 5;
}
}
else {
local_4 = 3;
}
return local_4;
}
| |
23,698 | tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>, tbb::detail::r1::thread_dispatcher_client>::push_front(tbb::detail::r1::thread_dispatcher_client&) | aimrt_mujoco_sim/_deps/tbb-src/src/tbb/intrusive_list.h | void push_front ( T& val ) {
__TBB_ASSERT( node(val).my_prev_node == &node(val) && node(val).my_next_node == &node(val),
"Object with intrusive list node can be part of only one intrusive list simultaneously" );
// An object can be part of only one intrusive list at the given moment via the given node member
node(val).my_prev_node = &my_head;
node(val).my_next_node = my_head.my_next_node;
my_head.my_next_node->my_prev_node = &node(val);
my_head.my_next_node = &node(val);
++my_size;
assert_ok();
} | O0 | c | tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>, tbb::detail::r1::thread_dispatcher_client>::push_front(tbb::detail::r1::thread_dispatcher_client&):
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6d63c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x6d63c0
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
callq 0x6d63c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
callq 0x6d63c0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq 0x10(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x10(%rdi)
callq 0x6d63d0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| _ZN3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E10push_frontERS4_:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_10], rsi
mov rax, [rsp+28h+var_8]
mov [rsp+28h+var_18], rax
mov rdi, [rsp+28h+var_10]
call _ZN3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E4nodeERS4_; tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(tbb::detail::r1::thread_dispatcher_client&)
mov rcx, rax
mov rax, [rsp+28h+var_18]
mov [rcx], rax
mov rax, [rax+8]
mov [rsp+28h+var_20], rax
mov rdi, [rsp+28h+var_10]
call _ZN3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E4nodeERS4_; tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(tbb::detail::r1::thread_dispatcher_client&)
mov rcx, [rsp+28h+var_20]
mov [rax+8], rcx
mov rdi, [rsp+28h+var_10]
call _ZN3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E4nodeERS4_; tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(tbb::detail::r1::thread_dispatcher_client&)
mov rcx, rax
mov rax, [rsp+28h+var_18]
mov rax, [rax+8]
mov [rax], rcx
mov rdi, [rsp+28h+var_10]
call _ZN3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E4nodeERS4_; tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(tbb::detail::r1::thread_dispatcher_client&)
mov rdi, [rsp+28h+var_18]
mov [rdi+8], rax
mov rax, [rdi+10h]
add rax, 1
mov [rdi+10h], rax
call _ZNK3tbb6detail2r119intrusive_list_baseINS1_14intrusive_listINS1_24thread_dispatcher_clientEEES4_E9assert_okEv; tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::assert_ok(void)
add rsp, 28h
retn
| long long tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::push_front(
long long a1,
long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
*(_QWORD *)tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(a2) = a1;
v3 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(a2)
+ 8) = v3;
**(_QWORD **)(a1 + 8) = tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(a2);
*(_QWORD *)(a1 + 8) = tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::node(a2);
++*(_QWORD *)(a1 + 16);
return tbb::detail::r1::intrusive_list_base<tbb::detail::r1::intrusive_list<tbb::detail::r1::thread_dispatcher_client>,tbb::detail::r1::thread_dispatcher_client>::assert_ok();
}
| executor_function<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::{lambda()#1}>,std::allocator<void>>:
SUB RSP,0x58
MOV qword ptr [RSP + 0x8],RSI
MOV qword ptr [RSP + 0x50],RDI
MOV qword ptr [RSP + 0x48],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP],RAX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x40]
CALL 0x006d5af0
MOV RSI,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],0x0
MOV RDI,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RDI
MOV RDX,qword ptr [RSP + 0x40]
LAB_006d58d7:
CALL 0x006d5b30
LAB_006d58dc:
JMP 0x006d58de
LAB_006d58de:
MOV RAX,qword ptr [RSP]
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],RCX
MOV qword ptr [RSP + 0x30],0x0
LEA RDI,[RSP + 0x28]
CALL 0x006d5b70
ADD RSP,0x58
RET
|
/* boost::asio::detail::executor_function::executor_function<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,
boost::asio::any_io_executor,
aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options
const&)::{lambda()#1}, boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,
std::__exception_ptr::exception_ptr, std::shared_ptr<aimrt::common::net::AsioUdpClient> >
>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,
boost::asio::any_io_executor>*, boost::asio::any_io_executor,
aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options
const&)::{lambda()#1}, boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,
std::__exception_ptr::exception_ptr, std::shared_ptr<aimrt::common::net::AsioUdpClient>
>)::{lambda()#1}>, std::allocator<void>
>(boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,
boost::asio::any_io_executor,
aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options
const&)::{lambda()#1}, boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,
std::__exception_ptr::exception_ptr, std::shared_ptr<aimrt::common::net::AsioUdpClient> >
>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,
boost::asio::any_io_executor>*, boost::asio::any_io_executor,
aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options
const&)::{lambda()#1}, boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,
std::__exception_ptr::exception_ptr, std::shared_ptr<aimrt::common::net::AsioUdpClient>
>)::{lambda()#1}>, std::allocator<void> const&) */
void __thiscall
boost::asio::detail::executor_function::
executor_function<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::_lambda()_1_,boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::_lambda()_1_,boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::_lambda()_1_>,std::allocator<void>>
(executor_function *this,allocator *param_2,allocator *param_3)
{
binder0 *pbVar1;
allocator *local_30;
binder0 *local_28;
int8 local_20;
allocator *local_18;
allocator *local_10;
executor_function *local_8;
local_30 = param_3;
local_18 = param_3;
local_10 = param_2;
local_8 = this;
pbVar1 = (binder0 *)
impl<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::{lambda()#1}>,std::allocator<void>>
::ptr::allocate(param_3);
local_20 = 0;
local_28 = pbVar1;
/* try { // try from 006d58d7 to 006d58db has its CatchHandler @ 006d5902 */
impl<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::{lambda()#1}>,std::allocator<void>>
::
impl<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::_lambda()_1_,boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::_lambda()_1_,boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::_lambda()_1_>>
(pbVar1,param_2);
*(binder0 **)this = pbVar1;
local_28 = (binder0 *)0x0;
impl<boost::asio::detail::binder0<boost::asio::detail::co_spawn_entry_point<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>>(boost::asio::awaitable<std::shared_ptr<aimrt::common::net::AsioUdpClient>,boost::asio::any_io_executor>*,boost::asio::any_io_executor,aimrt::common::net::AsioUdpClientPool::GetClient(aimrt::common::net::AsioUdpClient::Options_const&)::{lambda()#1},boost::asio::detail::awaitable_handler<boost::asio::any_io_executor,std::__exception_ptr::exception_ptr,std::shared_ptr<aimrt::common::net::AsioUdpClient>>)::{lambda()#1}>,std::allocator<void>>
::ptr::~ptr((ptr *)&local_30);
return;
}
| |
23,699 | mi_pack_get_block_info | eloqsql/storage/myisam/mi_packrec.c | uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
MI_BLOCK_INFO *info, uchar **rec_buff_p,
File file, my_off_t filepos)
{
uchar *header=info->header;
uint head_length, UNINIT_VAR(ref_length);
if (file >= 0)
{
ref_length=myisam->s->pack.ref_length;
/*
We can't use mysql_file_pread() here because mi_read_rnd_pack_record
assumes position is ok
*/
mysql_file_seek(file, filepos, MY_SEEK_SET, MYF(0));
if (mysql_file_read(file, header, ref_length, MYF(MY_NABP)))
return BLOCK_FATAL_ERROR;
DBUG_DUMP("header",(uchar*) header,ref_length);
}
head_length= read_pack_length((uint) myisam->s->pack.version, header,
&info->rec_len);
if (myisam->s->base.blobs)
{
head_length+= read_pack_length((uint) myisam->s->pack.version,
header + head_length, &info->blob_len);
/*
Ensure that the record buffer is big enough for the compressed
record plus all expanded blobs. [We do not have an extra buffer
for the resulting blobs. Sigh.]
*/
if (!(mi_alloc_rec_buff(myisam,info->rec_len + info->blob_len,
rec_buff_p)))
return BLOCK_FATAL_ERROR; /* not enough memory */
bit_buff->blob_pos= (uchar*) *rec_buff_p + info->rec_len;
bit_buff->blob_end= bit_buff->blob_pos + info->blob_len;
myisam->blob_length=info->blob_len;
}
info->filepos=filepos+head_length;
if (file > 0)
{
info->offset=MY_MIN(info->rec_len, ref_length - head_length);
memcpy(*rec_buff_p, header + head_length, info->offset);
}
return 0;
} | O3 | c | mi_pack_get_block_info:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %r12d
movq %rdx, %rbx
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
testl %r8d, %r8d
movq %r9, -0x48(%rbp)
js 0x84b23
movq %r9, %r15
movq %rcx, -0x30(%rbp)
movq (%r14), %rax
movl 0x240(%rax), %r13d
leaq 0x3045c4(%rip), %rax # 0x389060
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x8, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x84c85
movl %r12d, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xa3954
leaq 0x30458d(%rip), %rax # 0x389060
movq (%rax), %rax
leaq -0x90(%rbp), %rdi
movl %r12d, %esi
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
movq %r13, -0x38(%rbp)
jne 0x84c98
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa3618
movq %rax, %r13
movl $0x20, %r15d
testq %r13, %r13
movq -0x30(%rbp), %rcx
jne 0x84c73
jmp 0x84b27
movq %rax, -0x38(%rbp)
movzbl (%rbx), %esi
cmpq $0xfd, %rsi
ja 0x84b3f
movl $0x1, %r15d
movq -0x38(%rbp), %rdi
jmp 0x84b82
cmpl $0xfe, %esi
movq -0x38(%rbp), %rdi
jne 0x84b57
movzwl 0x1(%rbx), %esi
movl $0x3, %r15d
jmp 0x84b82
movq (%r14), %rax
cmpb $0x1, 0x244(%rax)
jne 0x84b79
movzwl 0x1(%rbx), %eax
movzbl 0x3(%rbx), %esi
shll $0x10, %esi
orq %rax, %rsi
movl $0x4, %r15d
jmp 0x84b82
movl 0x1(%rbx), %esi
movl $0x5, %r15d
movq %rsi, 0x18(%rbx)
movq (%r14), %rdx
cmpl $0x0, 0x188(%rdx)
je 0x84c38
movl %r15d, %edi
movzbl (%rbx,%rdi), %eax
cmpq $0xfd, %rax
ja 0x84bae
movl $0x1, -0x30(%rbp)
jmp 0x84bf0
cmpl $0xfe, %eax
jne 0x84bc3
movzwl 0x1(%rbx,%rdi), %eax
movl $0x3, -0x30(%rbp)
jmp 0x84bf0
cmpb $0x1, 0x244(%rdx)
jne 0x84be5
movzwl 0x1(%rbx,%rdi), %edx
movzbl 0x3(%rbx,%rdi), %eax
shll $0x10, %eax
orq %rdx, %rax
movl $0x4, -0x30(%rbp)
jmp 0x84bf0
movl 0x1(%rbx,%rdi), %eax
movl $0x5, -0x30(%rbp)
movq %rax, 0x30(%rbx)
addq %rax, %rsi
movq %r14, %rdi
movq %rcx, %rdx
movq %rcx, %r13
callq 0x82dc9
testq %rax, %rax
je 0x84c6d
movq (%r13), %rax
addq 0x18(%rbx), %rax
movq -0x40(%rbp), %rcx
movq %rax, 0x18(%rcx)
addq 0x30(%rbx), %rax
addl -0x30(%rbp), %r15d
movq %rax, 0x20(%rcx)
movq 0x30(%rbx), %rax
movq %rax, 0x1b8(%r14)
movq %r13, %rcx
movq -0x38(%rbp), %rdi
movl %r15d, %eax
movq -0x48(%rbp), %rdx
addq %rax, %rdx
movq %rdx, 0x38(%rbx)
xorl %r15d, %r15d
testl %r12d, %r12d
jle 0x84c73
movq 0x18(%rbx), %rdx
subl %eax, %edi
cmpq %rdi, %rdx
cmovael %edi, %edx
movl %edx, 0x54(%rbx)
movq (%rcx), %rdi
addq %rax, %rbx
movq %rbx, %rsi
callq 0x29090
jmp 0x84c73
movl $0x20, %r15d
movl %r15d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x2e5f4
jmp 0x84acc
movq %rax, %r15
leaq 0x3043be(%rip), %rax # 0x389060
movq (%rax), %rax
leaq 0x592ad(%rip), %rdx # 0xddf59
movq %r15, %rdi
movq %r13, %rsi
movl $0x566, %ecx # imm = 0x566
callq *0x210(%rax)
movl $0x4, %ecx
movl %r12d, %edi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xa3618
movq %r13, %rcx
movq %rax, %r13
xorl %esi, %esi
testq %rax, %rax
cmoveq %rcx, %rsi
leaq 0x30437a(%rip), %rax # 0x389060
movq (%rax), %rax
movq %r15, %rdi
callq *0x218(%rax)
jmp 0x84b0e
| _mi_pack_get_block_info:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r12d, r8d
mov rbx, rdx
mov [rbp+var_40], rsi
mov r14, rdi
test r8d, r8d
mov [rbp+var_48], r9
js loc_84B23
mov r15, r9
mov [rbp+var_30], rcx
mov rax, [r14]
mov r13d, [rax+240h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 8
call qword ptr [rax+158h]
test rax, rax
jnz loc_84C85
mov edi, r12d
mov rsi, r15
xor edx, edx
xor ecx, ecx
call my_seek
loc_84ACC:
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_90]
mov esi, r12d
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
mov [rbp+var_38], r13
jnz loc_84C98
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov r13, rax
loc_84B0E:
mov r15d, 20h ; ' '
test r13, r13
mov rcx, [rbp+var_30]
jnz loc_84C73
jmp short loc_84B27
loc_84B23:
mov [rbp+var_38], rax
loc_84B27:
movzx esi, byte ptr [rbx]
cmp rsi, 0FDh
ja short loc_84B3F
mov r15d, 1
mov rdi, [rbp+var_38]
jmp short loc_84B82
loc_84B3F:
cmp esi, 0FEh
mov rdi, [rbp+var_38]
jnz short loc_84B57
movzx esi, word ptr [rbx+1]
mov r15d, 3
jmp short loc_84B82
loc_84B57:
mov rax, [r14]
cmp byte ptr [rax+244h], 1
jnz short loc_84B79
movzx eax, word ptr [rbx+1]
movzx esi, byte ptr [rbx+3]
shl esi, 10h
or rsi, rax
mov r15d, 4
jmp short loc_84B82
loc_84B79:
mov esi, [rbx+1]
mov r15d, 5
loc_84B82:
mov [rbx+18h], rsi
mov rdx, [r14]
cmp dword ptr [rdx+188h], 0
jz loc_84C38
mov edi, r15d
movzx eax, byte ptr [rbx+rdi]
cmp rax, 0FDh
ja short loc_84BAE
mov dword ptr [rbp+var_30], 1
jmp short loc_84BF0
loc_84BAE:
cmp eax, 0FEh
jnz short loc_84BC3
movzx eax, word ptr [rbx+rdi+1]
mov dword ptr [rbp+var_30], 3
jmp short loc_84BF0
loc_84BC3:
cmp byte ptr [rdx+244h], 1
jnz short loc_84BE5
movzx edx, word ptr [rbx+rdi+1]
movzx eax, byte ptr [rbx+rdi+3]
shl eax, 10h
or rax, rdx
mov dword ptr [rbp+var_30], 4
jmp short loc_84BF0
loc_84BE5:
mov eax, [rbx+rdi+1]
mov dword ptr [rbp+var_30], 5
loc_84BF0:
mov [rbx+30h], rax
add rsi, rax
mov rdi, r14
mov rdx, rcx
mov r13, rcx
call mi_alloc_rec_buff
test rax, rax
jz short loc_84C6D
mov rax, [r13+0]
add rax, [rbx+18h]
mov rcx, [rbp+var_40]
mov [rcx+18h], rax
add rax, [rbx+30h]
add r15d, dword ptr [rbp+var_30]
mov [rcx+20h], rax
mov rax, [rbx+30h]
mov [r14+1B8h], rax
mov rcx, r13
mov rdi, [rbp+var_38]
loc_84C38:
mov eax, r15d
mov rdx, [rbp+var_48]
add rdx, rax
mov [rbx+38h], rdx
xor r15d, r15d
test r12d, r12d
jle short loc_84C73
mov rdx, [rbx+18h]
sub edi, eax
cmp rdx, rdi
cmovnb edx, edi
mov [rbx+54h], edx
mov rdi, [rcx]
add rbx, rax
mov rsi, rbx
call _memcpy
jmp short loc_84C73
loc_84C6D:
mov r15d, 20h ; ' '
loc_84C73:
mov eax, r15d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_84C85:
mov rdi, rax
mov esi, r12d
mov rdx, r15
call _mi_pack_get_block_info_cold_1
jmp loc_84ACC
loc_84C98:
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_19; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r15
mov rsi, r13
mov ecx, 566h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, r12d
mov rsi, rbx
mov rdx, r13
call my_read
mov rcx, r13
mov r13, rax
xor esi, esi
test rax, rax
cmovz rsi, rcx
lea rax, PSI_server
mov rax, [rax]
mov rdi, r15
call qword ptr [rax+218h]
jmp loc_84B0E
| long long mi_pack_get_block_info(
long long *a1,
long long a2,
unsigned __int8 *a3,
_QWORD *a4,
unsigned int a5,
long long a6)
{
long long v6; // rax
long long v11; // r13
long long v12; // rax
long long v13; // rax
long long v14; // r13
unsigned int v15; // r15d
unsigned long long v16; // rsi
unsigned int v17; // r15d
int v18; // edi
unsigned long long v19; // rax
_QWORD *v20; // r13
long long v21; // rax
long long v22; // rcx
long long v23; // rax
unsigned long long v24; // rdx
unsigned long long v25; // rdi
long long v27; // r15
long long v28; // rax
long long v29; // rcx
long long v30; // rsi
_BYTE v31[72]; // [rsp+0h] [rbp-90h] BYREF
long long v32; // [rsp+48h] [rbp-48h]
long long v33; // [rsp+50h] [rbp-40h]
long long v34; // [rsp+58h] [rbp-38h]
_QWORD *v35; // [rsp+60h] [rbp-30h]
v33 = a2;
v32 = a6;
if ( (a5 & 0x80000000) != 0 )
{
v34 = v6;
}
else
{
v35 = a4;
v11 = *(unsigned int *)(*a1 + 576);
v12 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, a5, 8LL);
if ( v12 )
mi_pack_get_block_info_cold_1(v12, a5, a6);
else
my_seek(a5, a6, 0LL, 0LL);
v13 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v31, a5, 6LL);
v34 = v11;
if ( v13 )
{
v27 = v13;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v13,
v11,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
1382LL);
v28 = my_read(a5, a3, v11, 4LL);
v29 = v11;
v14 = v28;
v30 = 0LL;
if ( !v28 )
v30 = v29;
((void ( *)(long long, long long))PSI_server[67])(v27, v30);
}
else
{
v14 = my_read(a5, a3, v11, 4LL);
}
v15 = 32;
a4 = v35;
if ( v14 )
return v15;
}
v16 = *a3;
if ( v16 > 0xFD )
{
v18 = v34;
if ( (_DWORD)v16 == 254 )
{
v16 = *(unsigned __int16 *)(a3 + 1);
v17 = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v16 = *(unsigned __int16 *)(a3 + 1) | (unsigned long long)(a3[3] << 16);
v17 = 4;
}
else
{
v16 = *(unsigned int *)(a3 + 1);
v17 = 5;
}
}
else
{
v17 = 1;
v18 = v34;
}
*((_QWORD *)a3 + 3) = v16;
if ( *(_DWORD *)(*a1 + 392) )
{
v19 = a3[v17];
if ( v19 > 0xFD )
{
if ( (_DWORD)v19 == 254 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1];
LODWORD(v35) = 3;
}
else if ( *(_BYTE *)(*a1 + 580) == 1 )
{
v19 = *(unsigned __int16 *)&a3[v17 + 1] | (unsigned long long)(a3[v17 + 3] << 16);
LODWORD(v35) = 4;
}
else
{
v19 = *(unsigned int *)&a3[v17 + 1];
LODWORD(v35) = 5;
}
}
else
{
LODWORD(v35) = 1;
}
*((_QWORD *)a3 + 6) = v19;
v20 = a4;
if ( !mi_alloc_rec_buff(a1, v19 + v16, a4) )
return 32;
v21 = *((_QWORD *)a3 + 3) + *v20;
v22 = v33;
*(_QWORD *)(v33 + 24) = v21;
v17 += (unsigned int)v35;
*(_QWORD *)(v22 + 32) = *((_QWORD *)a3 + 6) + v21;
a1[55] = *((_QWORD *)a3 + 6);
a4 = v20;
v18 = v34;
}
v23 = v17;
*((_QWORD *)a3 + 7) = v17 + v32;
v15 = 0;
if ( (int)a5 > 0 )
{
v24 = *((_QWORD *)a3 + 3);
v25 = (unsigned int)(v18 - v23);
if ( v24 >= v25 )
v24 = (unsigned int)v25;
*((_DWORD *)a3 + 21) = v24;
memcpy(*a4, &a3[v23], v24);
}
return v15;
}
| _mi_pack_get_block_info:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R12D,R8D
MOV RBX,RDX
MOV qword ptr [RBP + -0x40],RSI
MOV R14,RDI
TEST R8D,R8D
MOV qword ptr [RBP + -0x48],R9
JS 0x00184b23
MOV R15,R9
MOV qword ptr [RBP + -0x30],RCX
MOV RAX,qword ptr [R14]
MOV R13D,dword ptr [RAX + 0x240]
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x8
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x00184c85
MOV EDI,R12D
MOV RSI,R15
XOR EDX,EDX
XOR ECX,ECX
CALL 0x001a3954
LAB_00184acc:
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x90]
MOV ESI,R12D
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
MOV qword ptr [RBP + -0x38],R13
JNZ 0x00184c98
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a3618
MOV R13,RAX
LAB_00184b0e:
MOV R15D,0x20
TEST R13,R13
MOV RCX,qword ptr [RBP + -0x30]
JNZ 0x00184c73
JMP 0x00184b27
LAB_00184b23:
MOV qword ptr [RBP + -0x38],RAX
LAB_00184b27:
MOVZX ESI,byte ptr [RBX]
CMP RSI,0xfd
JA 0x00184b3f
MOV R15D,0x1
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x00184b82
LAB_00184b3f:
CMP ESI,0xfe
MOV RDI,qword ptr [RBP + -0x38]
JNZ 0x00184b57
MOVZX ESI,word ptr [RBX + 0x1]
MOV R15D,0x3
JMP 0x00184b82
LAB_00184b57:
MOV RAX,qword ptr [R14]
CMP byte ptr [RAX + 0x244],0x1
JNZ 0x00184b79
MOVZX EAX,word ptr [RBX + 0x1]
MOVZX ESI,byte ptr [RBX + 0x3]
SHL ESI,0x10
OR RSI,RAX
MOV R15D,0x4
JMP 0x00184b82
LAB_00184b79:
MOV ESI,dword ptr [RBX + 0x1]
MOV R15D,0x5
LAB_00184b82:
MOV qword ptr [RBX + 0x18],RSI
MOV RDX,qword ptr [R14]
CMP dword ptr [RDX + 0x188],0x0
JZ 0x00184c38
MOV EDI,R15D
MOVZX EAX,byte ptr [RBX + RDI*0x1]
CMP RAX,0xfd
JA 0x00184bae
MOV dword ptr [RBP + -0x30],0x1
JMP 0x00184bf0
LAB_00184bae:
CMP EAX,0xfe
JNZ 0x00184bc3
MOVZX EAX,word ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x3
JMP 0x00184bf0
LAB_00184bc3:
CMP byte ptr [RDX + 0x244],0x1
JNZ 0x00184be5
MOVZX EDX,word ptr [RBX + RDI*0x1 + 0x1]
MOVZX EAX,byte ptr [RBX + RDI*0x1 + 0x3]
SHL EAX,0x10
OR RAX,RDX
MOV dword ptr [RBP + -0x30],0x4
JMP 0x00184bf0
LAB_00184be5:
MOV EAX,dword ptr [RBX + RDI*0x1 + 0x1]
MOV dword ptr [RBP + -0x30],0x5
LAB_00184bf0:
MOV qword ptr [RBX + 0x30],RAX
ADD RSI,RAX
MOV RDI,R14
MOV RDX,RCX
MOV R13,RCX
CALL 0x00182dc9
TEST RAX,RAX
JZ 0x00184c6d
MOV RAX,qword ptr [R13]
ADD RAX,qword ptr [RBX + 0x18]
MOV RCX,qword ptr [RBP + -0x40]
MOV qword ptr [RCX + 0x18],RAX
ADD RAX,qword ptr [RBX + 0x30]
ADD R15D,dword ptr [RBP + -0x30]
MOV qword ptr [RCX + 0x20],RAX
MOV RAX,qword ptr [RBX + 0x30]
MOV qword ptr [R14 + 0x1b8],RAX
MOV RCX,R13
MOV RDI,qword ptr [RBP + -0x38]
LAB_00184c38:
MOV EAX,R15D
MOV RDX,qword ptr [RBP + -0x48]
ADD RDX,RAX
MOV qword ptr [RBX + 0x38],RDX
XOR R15D,R15D
TEST R12D,R12D
JLE 0x00184c73
MOV RDX,qword ptr [RBX + 0x18]
SUB EDI,EAX
CMP RDX,RDI
CMOVNC EDX,EDI
MOV dword ptr [RBX + 0x54],EDX
MOV RDI,qword ptr [RCX]
ADD RBX,RAX
MOV RSI,RBX
CALL 0x00129090
JMP 0x00184c73
LAB_00184c6d:
MOV R15D,0x20
LAB_00184c73:
MOV EAX,R15D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00184c85:
MOV RDI,RAX
MOV ESI,R12D
MOV RDX,R15
CALL 0x0012e5f4
JMP 0x00184acc
LAB_00184c98:
MOV R15,RAX
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1ddf59]
MOV RDI,R15
MOV RSI,R13
MOV ECX,0x566
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,R12D
MOV RSI,RBX
MOV RDX,R13
CALL 0x001a3618
MOV RCX,R13
MOV R13,RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,RCX
LEA RAX,[0x489060]
MOV RAX,qword ptr [RAX]
MOV RDI,R15
CALL qword ptr [RAX + 0x218]
JMP 0x00184b0e
|
int8
_mi_pack_get_block_info
(long *param_1,long param_2,byte *param_3,long *param_4,int param_5,long param_6)
{
ulong in_RAX;
long lVar1;
long lVar2;
ulong uVar3;
ulong uVar4;
int iVar5;
ulong uVar6;
int1 local_98 [72];
long local_50;
long local_48;
ulong local_40;
long *local_38;
local_50 = param_6;
local_48 = param_2;
local_40 = in_RAX;
if (-1 < param_5) {
uVar4 = (ulong)*(uint *)(*param_1 + 0x240);
local_38 = param_4;
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,8);
if (lVar1 == 0) {
my_seek(param_5,param_6,0,0);
}
else {
_mi_pack_get_block_info_cold_1(lVar1,param_5,param_6);
}
lVar1 = (**(code **)(PSI_server + 0x158))(local_98,param_5,6);
local_40 = uVar4;
if (lVar1 == 0) {
lVar2 = my_read(param_5,param_3,uVar4,4);
}
else {
(**(code **)(PSI_server + 0x210))
(lVar1,uVar4,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_packrec.c",
0x566);
lVar2 = my_read(param_5,param_3,uVar4,4);
uVar6 = 0;
if (lVar2 == 0) {
uVar6 = uVar4;
}
(**(code **)(PSI_server + 0x218))(lVar1,uVar6);
}
param_4 = local_38;
if (lVar2 != 0) {
return 0x20;
}
}
uVar4 = (ulong)*param_3;
if (uVar4 < 0xfe) {
uVar6 = 1;
}
else if (*param_3 == 0xfe) {
uVar4 = (ulong)*(ushort *)(param_3 + 1);
uVar6 = 3;
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar4 = (ulong)*(uint3 *)(param_3 + 1);
uVar6 = 4;
}
else {
uVar4 = (ulong)*(uint *)(param_3 + 1);
uVar6 = 5;
}
iVar5 = (int)local_40;
*(ulong *)(param_3 + 0x18) = uVar4;
if (*(int *)(*param_1 + 0x188) != 0) {
uVar3 = (ulong)param_3[uVar6];
if (uVar3 < 0xfe) {
local_38 = (long *)CONCAT44(local_38._4_4_,1);
}
else if (param_3[uVar6] == 0xfe) {
uVar3 = (ulong)*(ushort *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,3);
}
else if (*(char *)(*param_1 + 0x244) == '\x01') {
uVar3 = (ulong)CONCAT12(param_3[uVar6 + 3],*(int2 *)(param_3 + uVar6 + 1));
local_38 = (long *)CONCAT44(local_38._4_4_,4);
}
else {
uVar3 = (ulong)*(uint *)(param_3 + uVar6 + 1);
local_38 = (long *)CONCAT44(local_38._4_4_,5);
}
*(ulong *)(param_3 + 0x30) = uVar3;
lVar1 = mi_alloc_rec_buff(param_1,uVar4 + uVar3,param_4);
if (lVar1 == 0) {
return 0x20;
}
lVar1 = *param_4;
lVar2 = *(long *)(param_3 + 0x18);
*(long *)(local_48 + 0x18) = lVar1 + lVar2;
uVar6 = (ulong)(uint)((int)uVar6 + (int)local_38);
*(long *)(local_48 + 0x20) = lVar1 + lVar2 + *(long *)(param_3 + 0x30);
param_1[0x37] = *(long *)(param_3 + 0x30);
iVar5 = (int)local_40;
}
*(ulong *)(param_3 + 0x38) = local_50 + uVar6;
if (0 < param_5) {
uVar3 = (ulong)(uint)(iVar5 - (int)uVar6);
uVar4 = *(ulong *)(param_3 + 0x18) & 0xffffffff;
if (uVar3 <= *(ulong *)(param_3 + 0x18)) {
uVar4 = uVar3;
}
*(int *)(param_3 + 0x54) = (int)uVar4;
memcpy((void *)*param_4,param_3 + uVar6,uVar4);
}
return 0;
}
|
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.