index int64 0 66.5k | func_name stringlengths 2 5.36k | func_dep stringlengths 16 2.19k | func stringlengths 8 55.3k | test stringlengths 0 7.07k | opt stringclasses 4 values | language stringclasses 2 values | asm stringlengths 0 45.4k | ida_asm stringlengths 0 44.7k | ida_pseudo stringlengths 0 44.3k | ghidra_asm stringlengths 0 49.1k | ghidra_pseudo stringlengths 0 64.7k |
|---|---|---|---|---|---|---|---|---|---|---|---|
24,900 | stbi__decode_jpeg_image(stbi__jpeg*) | 7CodeWizard[P]stablediffusion/thirdparty/stb_image.h | static int stbi__decode_jpeg_image(stbi__jpeg *j)
{
int m;
for (m = 0; m < 4; m++) {
j->img_comp[m].raw_data = NULL;
j->img_comp[m].raw_coeff = NULL;
}
j->restart_interval = 0;
if (!stbi__decode_jpeg_header(j, STBI__SCAN_load)) return 0;
m = stbi__get_marker(j);
while (!stbi__EOI(m)) {
if (stbi__SOS(m)) {
if (!stbi__process_scan_header(j)) return 0;
if (!stbi__parse_entropy_coded_data(j)) return 0;
if (j->marker == STBI__MARKER_none ) {
j->marker = stbi__skip_jpeg_junk_at_end(j);
// if we reach eof without hitting a marker, stbi__get_marker() below will fail and we'll eventually return 0
}
m = stbi__get_marker(j);
if (STBI__RESTART(m))
m = stbi__get_marker(j);
} else if (stbi__DNL(m)) {
int Ld = stbi__get16be(j->s);
stbi__uint32 NL = stbi__get16be(j->s);
if (Ld != 4) return stbi__err("bad DNL len", "Corrupt JPEG");
if (NL != j->s->img_y) return stbi__err("bad DNL height", "Corrupt JPEG");
m = stbi__get_marker(j);
} else {
if (!stbi__process_marker(j, m)) return 1;
m = stbi__get_marker(j);
}
}
if (j->progressive)
stbi__jpeg_finish(j);
return 1;
} | O0 | c | stbi__decode_jpeg_image(stbi__jpeg*):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x28253
movq 0x18(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x14(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x38(%rax)
movq 0x18(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x14(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x40(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x28201
movq 0x18(%rsp), %rax
movl $0x0, 0x4868(%rax)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1eea0
cmpl $0x0, %eax
jne 0x28280
movl $0x0, 0x24(%rsp)
jmp 0x28425
movq 0x18(%rsp), %rdi
callq 0x259d0
movzbl %al, %eax
movl %eax, 0x14(%rsp)
cmpl $0xd9, 0x14(%rsp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x282a7
jmp 0x28405
cmpl $0xda, 0x14(%rsp)
jne 0x28352
movq 0x18(%rsp), %rdi
callq 0x28770
cmpl $0x0, %eax
jne 0x282d1
movl $0x0, 0x24(%rsp)
jmp 0x28425
movq 0x18(%rsp), %rdi
callq 0x28ae0
cmpl $0x0, %eax
jne 0x282ed
movl $0x0, 0x24(%rsp)
jmp 0x28425
movq 0x18(%rsp), %rax
movzbl 0x4828(%rax), %eax
cmpl $0xff, %eax
jne 0x28317
movq 0x18(%rsp), %rdi
callq 0x297a0
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0x4828(%rax)
movq 0x18(%rsp), %rdi
callq 0x259d0
movzbl %al, %eax
movl %eax, 0x14(%rsp)
cmpl $0xd0, 0x14(%rsp)
jl 0x2834d
cmpl $0xd7, 0x14(%rsp)
jg 0x2834d
movq 0x18(%rsp), %rdi
callq 0x259d0
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x28400
cmpl $0xdc, 0x14(%rsp)
jne 0x283d0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x19ee0
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x19ee0
movl %eax, 0xc(%rsp)
cmpl $0x4, 0x10(%rsp)
je 0x2839a
leaq 0x156a6b(%rip), %rdi # 0x17edf7
callq 0xddd0
movl %eax, 0x24(%rsp)
jmp 0x28425
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x4(%rcx), %eax
je 0x283bd
leaq 0x156a51(%rip), %rdi # 0x17ee03
callq 0xddd0
movl %eax, 0x24(%rsp)
jmp 0x28425
movq 0x18(%rsp), %rdi
callq 0x259d0
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x283fe
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x25a70
cmpl $0x0, %eax
jne 0x283ed
movl $0x1, 0x24(%rsp)
jmp 0x28425
movq 0x18(%rsp), %rdi
callq 0x259d0
movzbl %al, %eax
movl %eax, 0x14(%rsp)
jmp 0x28400
jmp 0x28291
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4830(%rax)
je 0x2841d
movq 0x18(%rsp), %rdi
callq 0x29850
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
| _ZL23stbi__decode_jpeg_imageP10stbi__jpeg:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_14], 0
loc_28201:
cmp [rsp+28h+var_14], 4
jge short loc_28253
mov rax, [rsp+28h+var_10]
add rax, 46A0h
movsxd rcx, [rsp+28h+var_14]
imul rcx, 60h ; '`'
add rax, rcx
mov qword ptr [rax+38h], 0
mov rax, [rsp+28h+var_10]
add rax, 46A0h
movsxd rcx, [rsp+28h+var_14]
imul rcx, 60h ; '`'
add rax, rcx
mov qword ptr [rax+40h], 0
mov eax, [rsp+28h+var_14]
add eax, 1
mov [rsp+28h+var_14], eax
jmp short loc_28201
loc_28253:
mov rax, [rsp+28h+var_10]
mov dword ptr [rax+4868h], 0
mov rdi, [rsp+28h+var_10]
xor esi, esi
call _ZL24stbi__decode_jpeg_headerP10stbi__jpegi; stbi__decode_jpeg_header(stbi__jpeg *,int)
cmp eax, 0
jnz short loc_28280
mov [rsp+28h+var_4], 0
jmp loc_28425
loc_28280:
mov rdi, [rsp+28h+var_10]
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
movzx eax, al
mov [rsp+28h+var_14], eax
loc_28291:
cmp [rsp+28h+var_14], 0D9h
setz al
xor al, 0FFh
test al, 1
jnz short loc_282A7
jmp loc_28405
loc_282A7:
cmp [rsp+28h+var_14], 0DAh
jnz loc_28352
mov rdi, [rsp+28h+var_10]
call _ZL25stbi__process_scan_headerP10stbi__jpeg; stbi__process_scan_header(stbi__jpeg *)
cmp eax, 0
jnz short loc_282D1
mov [rsp+28h+var_4], 0
jmp loc_28425
loc_282D1:
mov rdi, [rsp+28h+var_10]
call _ZL30stbi__parse_entropy_coded_dataP10stbi__jpeg; stbi__parse_entropy_coded_data(stbi__jpeg *)
cmp eax, 0
jnz short loc_282ED
mov [rsp+28h+var_4], 0
jmp loc_28425
loc_282ED:
mov rax, [rsp+28h+var_10]
movzx eax, byte ptr [rax+4828h]
cmp eax, 0FFh
jnz short loc_28317
mov rdi, [rsp+28h+var_10]
call _ZL27stbi__skip_jpeg_junk_at_endP10stbi__jpeg; stbi__skip_jpeg_junk_at_end(stbi__jpeg *)
mov cl, al
mov rax, [rsp+28h+var_10]
mov [rax+4828h], cl
loc_28317:
mov rdi, [rsp+28h+var_10]
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
movzx eax, al
mov [rsp+28h+var_14], eax
cmp [rsp+28h+var_14], 0D0h
jl short loc_2834D
cmp [rsp+28h+var_14], 0D7h
jg short loc_2834D
mov rdi, [rsp+28h+var_10]
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
movzx eax, al
mov [rsp+28h+var_14], eax
loc_2834D:
jmp loc_28400
loc_28352:
cmp [rsp+28h+var_14], 0DCh
jnz short loc_283D0
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
call _ZL13stbi__get16beP13stbi__context; stbi__get16be(stbi__context *)
mov [rsp+28h+var_18], eax
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
call _ZL13stbi__get16beP13stbi__context; stbi__get16be(stbi__context *)
mov [rsp+28h+var_1C], eax
cmp [rsp+28h+var_18], 4
jz short loc_2839A
lea rdi, aBadDnlLen; "bad DNL len"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+28h+var_4], eax
jmp loc_28425
loc_2839A:
mov eax, [rsp+28h+var_1C]
mov rcx, [rsp+28h+var_10]
mov rcx, [rcx]
cmp eax, [rcx+4]
jz short loc_283BD
lea rdi, aBadDnlHeight; "bad DNL height"
call _ZL9stbi__errPKc; stbi__err(char const*)
mov [rsp+28h+var_4], eax
jmp short loc_28425
loc_283BD:
mov rdi, [rsp+28h+var_10]
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
movzx eax, al
mov [rsp+28h+var_14], eax
jmp short loc_283FE
loc_283D0:
mov rdi, [rsp+28h+var_10]
mov esi, [rsp+28h+var_14]
call _ZL20stbi__process_markerP10stbi__jpegi; stbi__process_marker(stbi__jpeg *,int)
cmp eax, 0
jnz short loc_283ED
mov [rsp+28h+var_4], 1
jmp short loc_28425
loc_283ED:
mov rdi, [rsp+28h+var_10]
call _ZL16stbi__get_markerP10stbi__jpeg; stbi__get_marker(stbi__jpeg *)
movzx eax, al
mov [rsp+28h+var_14], eax
loc_283FE:
jmp short $+2
loc_28400:
jmp loc_28291
loc_28405:
mov rax, [rsp+28h+var_10]
cmp dword ptr [rax+4830h], 0
jz short loc_2841D
mov rdi, [rsp+28h+var_10]
call _ZL17stbi__jpeg_finishP10stbi__jpeg; stbi__jpeg_finish(stbi__jpeg *)
loc_2841D:
mov [rsp+28h+var_4], 1
loc_28425:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long stbi__decode_jpeg_image(long long a1)
{
int v2; // [rsp+Ch] [rbp-1Ch]
int v3; // [rsp+10h] [rbp-18h]
int i; // [rsp+14h] [rbp-14h]
int marker; // [rsp+14h] [rbp-14h]
for ( i = 0; i < 4; ++i )
{
*(_QWORD *)(96LL * i + a1 + 18080 + 56) = 0LL;
*(_QWORD *)(96LL * i + a1 + 18080 + 64) = 0LL;
}
*(_DWORD *)(a1 + 18536) = 0;
if ( (unsigned int)stbi__decode_jpeg_header(a1, 0) )
{
while ( 2 )
{
while ( 1 )
{
marker = (unsigned __int8)stbi__get_marker(a1);
while ( 1 )
{
if ( marker == 217 )
{
if ( *(_DWORD *)(a1 + 18480) )
stbi__jpeg_finish(a1);
return 1;
}
if ( marker != 218 )
break;
if ( !(unsigned int)stbi__process_scan_header(a1) )
return 0;
if ( !(unsigned int)stbi__parse_entropy_coded_data(a1) )
return 0;
if ( *(unsigned __int8 *)(a1 + 18472) == 255 )
*(_BYTE *)(a1 + 18472) = stbi__skip_jpeg_junk_at_end(a1);
marker = (unsigned __int8)stbi__get_marker(a1);
if ( (unsigned int)marker >= 0xD0 && marker <= 215 )
marker = (unsigned __int8)stbi__get_marker(a1);
}
if ( marker != 220 )
break;
v3 = stbi__get16be(*(_QWORD *)a1);
v2 = stbi__get16be(*(_QWORD *)a1);
if ( v3 != 4 )
return (unsigned int)stbi__err("bad DNL len");
if ( v2 != *(_DWORD *)(*(_QWORD *)a1 + 4LL) )
return (unsigned int)stbi__err("bad DNL height");
}
if ( (unsigned int)stbi__process_marker(a1, marker) )
continue;
break;
}
return 1;
}
else
{
return 0;
}
}
| stbi__decode_jpeg_image:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV dword ptr [RSP + 0x14],0x0
LAB_00128201:
CMP dword ptr [RSP + 0x14],0x4
JGE 0x00128253
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x46a0
MOVSXD RCX,dword ptr [RSP + 0x14]
IMUL RCX,RCX,0x60
ADD RAX,RCX
MOV qword ptr [RAX + 0x38],0x0
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x46a0
MOVSXD RCX,dword ptr [RSP + 0x14]
IMUL RCX,RCX,0x60
ADD RAX,RCX
MOV qword ptr [RAX + 0x40],0x0
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x00128201
LAB_00128253:
MOV RAX,qword ptr [RSP + 0x18]
MOV dword ptr [RAX + 0x4868],0x0
MOV RDI,qword ptr [RSP + 0x18]
XOR ESI,ESI
CALL 0x0011eea0
CMP EAX,0x0
JNZ 0x00128280
MOV dword ptr [RSP + 0x24],0x0
JMP 0x00128425
LAB_00128280:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001259d0
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
LAB_00128291:
CMP dword ptr [RSP + 0x14],0xd9
SETZ AL
XOR AL,0xff
TEST AL,0x1
JNZ 0x001282a7
JMP 0x00128405
LAB_001282a7:
CMP dword ptr [RSP + 0x14],0xda
JNZ 0x00128352
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00128770
CMP EAX,0x0
JNZ 0x001282d1
MOV dword ptr [RSP + 0x24],0x0
JMP 0x00128425
LAB_001282d1:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00128ae0
CMP EAX,0x0
JNZ 0x001282ed
MOV dword ptr [RSP + 0x24],0x0
JMP 0x00128425
LAB_001282ed:
MOV RAX,qword ptr [RSP + 0x18]
MOVZX EAX,byte ptr [RAX + 0x4828]
CMP EAX,0xff
JNZ 0x00128317
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001297a0
MOV CL,AL
MOV RAX,qword ptr [RSP + 0x18]
MOV byte ptr [RAX + 0x4828],CL
LAB_00128317:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001259d0
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
CMP dword ptr [RSP + 0x14],0xd0
JL 0x0012834d
CMP dword ptr [RSP + 0x14],0xd7
JG 0x0012834d
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001259d0
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
LAB_0012834d:
JMP 0x00128400
LAB_00128352:
CMP dword ptr [RSP + 0x14],0xdc
JNZ 0x001283d0
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
CALL 0x00119ee0
MOV dword ptr [RSP + 0x10],EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
CALL 0x00119ee0
MOV dword ptr [RSP + 0xc],EAX
CMP dword ptr [RSP + 0x10],0x4
JZ 0x0012839a
LEA RDI,[0x27edf7]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00128425
LAB_0012839a:
MOV EAX,dword ptr [RSP + 0xc]
MOV RCX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RCX]
CMP EAX,dword ptr [RCX + 0x4]
JZ 0x001283bd
LEA RDI,[0x27ee03]
CALL 0x0010ddd0
MOV dword ptr [RSP + 0x24],EAX
JMP 0x00128425
LAB_001283bd:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001259d0
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
JMP 0x001283fe
LAB_001283d0:
MOV RDI,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x00125a70
CMP EAX,0x0
JNZ 0x001283ed
MOV dword ptr [RSP + 0x24],0x1
JMP 0x00128425
LAB_001283ed:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x001259d0
MOVZX EAX,AL
MOV dword ptr [RSP + 0x14],EAX
LAB_001283fe:
JMP 0x00128400
LAB_00128400:
JMP 0x00128291
LAB_00128405:
MOV RAX,qword ptr [RSP + 0x18]
CMP dword ptr [RAX + 0x4830],0x0
JZ 0x0012841d
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00129850
LAB_0012841d:
MOV dword ptr [RSP + 0x24],0x1
LAB_00128425:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
/* stbi__decode_jpeg_image(stbi__jpeg*) */
int4 stbi__decode_jpeg_image(stbi__jpeg *param_1)
{
byte bVar1;
stbi__jpeg sVar2;
int iVar3;
int iVar4;
int4 uVar5;
uint local_14;
int4 local_4;
for (local_14 = 0; (int)local_14 < 4; local_14 = local_14 + 1) {
*(int8 *)(param_1 + (long)(int)local_14 * 0x60 + 0x46d8) = 0;
*(int8 *)(param_1 + (long)(int)local_14 * 0x60 + 0x46e0) = 0;
}
*(int4 *)(param_1 + 0x4868) = 0;
iVar3 = stbi__decode_jpeg_header(param_1,0);
if (iVar3 == 0) {
local_4 = 0;
}
else {
bVar1 = stbi__get_marker(param_1);
local_14 = (uint)bVar1;
while (local_14 != 0xd9) {
if (local_14 == 0xda) {
iVar3 = stbi__process_scan_header(param_1);
if (iVar3 == 0) {
return 0;
}
iVar3 = stbi__parse_entropy_coded_data(param_1);
if (iVar3 == 0) {
return 0;
}
if (param_1[0x4828] == (stbi__jpeg)0xff) {
sVar2 = (stbi__jpeg)stbi__skip_jpeg_junk_at_end(param_1);
param_1[0x4828] = sVar2;
}
bVar1 = stbi__get_marker(param_1);
local_14 = (uint)bVar1;
if ((0xcf < local_14) && (local_14 < 0xd8)) {
bVar1 = stbi__get_marker(param_1);
local_14 = (uint)bVar1;
}
}
else {
if (local_14 == 0xdc) {
iVar3 = stbi__get16be(*(stbi__context **)param_1);
iVar4 = stbi__get16be(*(stbi__context **)param_1);
if (iVar3 != 4) {
uVar5 = stbi__err("bad DNL len");
return uVar5;
}
if (iVar4 != *(int *)(*(long *)param_1 + 4)) {
uVar5 = stbi__err("bad DNL height");
return uVar5;
}
bVar1 = stbi__get_marker(param_1);
}
else {
iVar3 = stbi__process_marker(param_1,local_14);
if (iVar3 == 0) {
return 1;
}
bVar1 = stbi__get_marker(param_1);
}
local_14 = (uint)bVar1;
}
}
if (*(int *)(param_1 + 0x4830) != 0) {
stbi__jpeg_finish(param_1);
}
local_4 = 1;
}
return local_4;
}
| |
24,901 | aimrt::executor::ExecutorRef::ThreadSafe() const | aimrt_mujoco_sim/_deps/aimrt-src/src/interface/aimrt_module_cpp_interface/../aimrt_module_cpp_interface/executor/executor.h | bool ThreadSafe() const {
AIMRT_ASSERT(base_ptr_, "Reference is null.");
return base_ptr_->is_thread_safe(base_ptr_->impl);
} | O3 | c | aimrt::executor::ExecutorRef::ThreadSafe() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq (%rdi), %rax
testq %rax, %rax
je 0x5e459
movq 0x40(%rax), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x10(%rax)
movl $0x28, %edi
callq 0x1e7e0
movq %rax, %rbx
leaq 0x2539c(%rip), %rsi # 0x83809
movq %rsp, %rdi
leaq 0x20(%rsp), %r8
movl $0x12, %edx
xorl %ecx, %ecx
callq 0x25059
leaq 0x4ffc8(%rip), %rax # 0xae450
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x18, %rax
movq %rax, 0x8(%rbx)
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rcx
cmpq %r15, %rcx
jne 0x5e4ad
movups (%r15), %xmm0
movups %xmm0, (%rax)
jmp 0x5e4ba
movq %rcx, 0x8(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rbx)
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x4fea4(%rip), %rsi # 0xae380
leaq -0x3a7af(%rip), %rdx # 0x23d34
movq %rbx, %rdi
callq 0x1fec0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x5e511
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1f250
jmp 0x5e511
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ebc0
movq %r14, %rdi
callq 0x1ffd0
nop
| _ZNK5aimrt8executor11ExecutorRef10ThreadSafeEv:
push r15
push r14
push rbx
sub rsp, 30h
mov rax, [rdi]
test rax, rax
jz short loc_5E459
mov rdi, [rax+40h]
add rsp, 30h
pop rbx
pop r14
pop r15
jmp qword ptr [rax+10h]
loc_5E459:
mov edi, 28h ; '('; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aReferenceIsNul; "Reference is null."
mov rdi, rsp; int
lea r8, [rsp+48h+var_28]; int
mov edx, 12h; int
xor ecx, ecx; int
call _ZN3fmt3v107vformatB5cxx11ENS0_17basic_string_viewIcEENS0_17basic_format_argsINS0_20basic_format_contextINS0_8appenderEcEEEE; fmt::v10::vformat(fmt::v10::basic_string_view<char>,fmt::v10::basic_format_args<fmt::v10::basic_format_context<fmt::v10::appender,char>>)
lea rax, off_AE450
mov [rbx], rax
mov rax, rbx
add rax, 18h
mov [rbx+8], rax
lea r15, [rsp+48h+var_38]
mov rcx, [r15-10h]
cmp rcx, r15
jnz short loc_5E4AD
movups xmm0, xmmword ptr [r15]
movups xmmword ptr [rax], xmm0
jmp short loc_5E4BA
loc_5E4AD:
mov [rbx+8], rcx
mov rax, [rsp+48h+var_38]
mov [rbx+18h], rax
loc_5E4BA:
mov rax, [rsp+48h+var_40]
mov [rbx+10h], rax
mov [rsp+48h+var_48], r15
mov [rsp+48h+var_40], 0
mov byte ptr [rsp+48h+var_38], 0
lea rsi, _ZTIN5aimrt6common4util14AimRTExceptionE; lptinfo
lea rdx, _ZN5aimrt6common4util14AimRTExceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, [rsp+48h+var_48]; void *
cmp rdi, r15
jz short loc_5E511
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_5E511
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
loc_5E511:
mov rdi, r14
call __Unwind_Resume
| long long aimrt::executor::ExecutorRef::ThreadSafe(aimrt::executor::ExecutorRef *this)
{
char *exception; // rbx
void *v3; // [rsp+0h] [rbp-48h] BYREF
long long v4; // [rsp+8h] [rbp-40h]
__int128 v5; // [rsp+10h] [rbp-38h] BYREF
if ( !*(_QWORD *)this )
{
exception = (char *)__cxa_allocate_exception(0x28uLL);
fmt::v10::vformat[abi:cxx11](&v3);
*(_QWORD *)exception = off_AE450;
*((_QWORD *)exception + 1) = exception + 24;
if ( v3 == &v5 )
{
*(_OWORD *)(exception + 24) = v5;
}
else
{
*((_QWORD *)exception + 1) = v3;
*((_QWORD *)exception + 3) = v5;
}
*((_QWORD *)exception + 2) = v4;
v3 = &v5;
v4 = 0LL;
LOBYTE(v5) = 0;
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'aimrt::common::util::AimRTException,
(void (*)(void *))aimrt::common::util::AimRTException::~AimRTException);
}
return (*(long long ( **)(_QWORD))(*(_QWORD *)this + 16LL))(*(_QWORD *)(*(_QWORD *)this + 64LL));
}
| ThreadSafe:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0015e459
MOV RDI,qword ptr [RAX + 0x40]
ADD RSP,0x30
POP RBX
POP R14
POP R15
JMP qword ptr [RAX + 0x10]
LAB_0015e459:
MOV EDI,0x28
CALL 0x0011e7e0
MOV RBX,RAX
LAB_0015e466:
LEA RSI,[0x183809]
MOV RDI,RSP
LEA R8,[RSP + 0x20]
MOV EDX,0x12
XOR ECX,ECX
CALL 0x00125059
LEA RAX,[0x1ae450]
MOV qword ptr [RBX],RAX
MOV RAX,RBX
ADD RAX,0x18
MOV qword ptr [RBX + 0x8],RAX
LEA R15,[RSP + 0x10]
MOV RCX,qword ptr [R15 + -0x10]
CMP RCX,R15
JNZ 0x0015e4ad
MOVUPS XMM0,xmmword ptr [R15]
MOVUPS xmmword ptr [RAX],XMM0
JMP 0x0015e4ba
LAB_0015e4ad:
MOV qword ptr [RBX + 0x8],RCX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LAB_0015e4ba:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RSP],R15
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LAB_0015e4d5:
LEA RSI,[0x1ae380]
LEA RDX,[0x123d34]
MOV RDI,RBX
CALL 0x0011fec0
|
/* aimrt::executor::ExecutorRef::ThreadSafe() const */
void __thiscall aimrt::executor::ExecutorRef::ThreadSafe(ExecutorRef *this)
{
long lVar1;
int8 *puVar2;
uint *local_48;
int8 local_40;
uint local_38;
int4 uStack_34;
int4 uStack_30;
int4 uStack_2c;
int1 local_28 [16];
lVar1 = *(long *)this;
if (lVar1 != 0) {
/* WARNING: Could not recover jumptable at 0x0015e456. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(lVar1 + 0x10))(*(int8 *)(lVar1 + 0x40));
return;
}
puVar2 = (int8 *)__cxa_allocate_exception(0x28);
/* try { // try from 0015e466 to 0015e480 has its CatchHandler @ 0015e506 */
fmt::v10::vformat_abi_cxx11_(&local_48,"Reference is null.",0x12,0,local_28);
*puVar2 = &PTR__AimRTException_001ae450;
puVar2[1] = puVar2 + 3;
if (local_48 == &local_38) {
*(uint *)(puVar2 + 3) = local_38;
*(int4 *)((long)puVar2 + 0x1c) = uStack_34;
*(int4 *)(puVar2 + 4) = uStack_30;
*(int4 *)((long)puVar2 + 0x24) = uStack_2c;
}
else {
puVar2[1] = local_48;
puVar2[3] = CONCAT44(uStack_34,local_38);
}
puVar2[2] = local_40;
local_40 = 0;
local_38 = local_38 & 0xffffff00;
local_48 = &local_38;
/* try { // try from 0015e4d5 to 0015e4ea has its CatchHandler @ 0015e4eb */
/* WARNING: Subroutine does not return */
__cxa_throw(puVar2,&common::util::AimRTException::typeinfo,
common::util::AimRTException::~AimRTException);
}
| |
24,902 | mysql_stmt_data_seek | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | void STDCALL mysql_stmt_data_seek(MYSQL_STMT *stmt, unsigned long long offset)
{
unsigned long long i= offset;
MYSQL_ROWS *ptr= stmt->result.data;
while(i-- && ptr)
ptr= ptr->next;
stmt->result_cursor= ptr;
stmt->state= MYSQL_STMT_USER_FETCHING;
return;
} | O3 | c | mysql_stmt_data_seek:
pushq %rbp
movq %rsp, %rbp
leaq 0x80(%rdi), %rax
movq (%rax), %rax
addq $-0x1, %rsi
jae 0x23388
testq %rax, %rax
jne 0x2337a
movq %rax, 0xe0(%rdi)
movl $0x5, 0x50(%rdi)
popq %rbp
retq
| mysql_stmt_data_seek:
push rbp
mov rbp, rsp
lea rax, [rdi+80h]
loc_2337A:
mov rax, [rax]
add rsi, 0FFFFFFFFFFFFFFFFh
jnb short loc_23388
test rax, rax
jnz short loc_2337A
loc_23388:
mov [rdi+0E0h], rax
mov dword ptr [rdi+50h], 5
pop rbp
retn
| _QWORD * mysql_stmt_data_seek(long long a1, long long a2)
{
_QWORD *result; // rax
bool v3; // cf
result = (_QWORD *)(a1 + 128);
do
{
result = (_QWORD *)*result;
v3 = a2-- != 0;
}
while ( v3 && result );
*(_QWORD *)(a1 + 224) = result;
*(_DWORD *)(a1 + 80) = 5;
return result;
}
| mysql_stmt_data_seek:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x80]
LAB_0012337a:
MOV RAX,qword ptr [RAX]
ADD RSI,-0x1
JNC 0x00123388
TEST RAX,RAX
JNZ 0x0012337a
LAB_00123388:
MOV qword ptr [RDI + 0xe0],RAX
MOV dword ptr [RDI + 0x50],0x5
POP RBP
RET
|
void mysql_stmt_data_seek(long param_1,long param_2)
{
long *plVar1;
bool bVar2;
plVar1 = (long *)(param_1 + 0x80);
do {
plVar1 = (long *)*plVar1;
bVar2 = param_2 == 0;
param_2 = param_2 + -1;
if (bVar2) break;
} while (plVar1 != (long *)0x0);
*(long **)(param_1 + 0xe0) = plVar1;
*(int4 *)(param_1 + 0x50) = 5;
return;
}
| |
24,903 | qoraal_start_default | qoraal-tictactoe/build_O0/_deps/qoraal-src/src/qoraal.c | int32_t
qoraal_start_default (void)
{
if (!_qoraal_instance) {
return E_UNEXP ;
}
svc_wdt_start () ;
svc_events_start () ;
svc_tasks_start () ;
svc_logger_start () ;
svc_threads_start () ;
svc_shell_start () ;
svc_service_services_start (SVC_SERVICE_FLAGS_AUTOSTART) ;
return EOK ;
} | O0 | c | qoraal_start_default:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x33058(%rip) # 0x4e968
jne 0x1b91b
movl $0xfffff6fa, -0x4(%rbp) # imm = 0xFFFFF6FA
jmp 0x1b94a
callq 0x23930
callq 0x1de40
callq 0x22590
callq 0x1e2c0
callq 0x23500
callq 0x20c70
movl $0x1, %edi
callq 0x1f8b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| qoraal_start_default:
push rbp
mov rbp, rsp
sub rsp, 10h
cmp cs:_qoraal_instance, 0
jnz short loc_1B91B
mov [rbp+var_4], 0FFFFF6FAh
jmp short loc_1B94A
loc_1B91B:
call svc_wdt_start
call svc_events_start
call svc_tasks_start
call svc_logger_start
call svc_threads_start
call svc_shell_start
mov edi, 1
call svc_service_services_start
mov [rbp+var_4], 0
loc_1B94A:
mov eax, [rbp+var_4]
add rsp, 10h
pop rbp
retn
| long long qoraal_start_default()
{
if ( qoraal_instance )
{
svc_wdt_start();
svc_events_start();
svc_tasks_start();
svc_logger_start();
svc_threads_start();
svc_shell_start();
svc_service_services_start(1LL);
return 0;
}
else
{
return (unsigned int)-2310;
}
}
| qoraal_start_default:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
CMP qword ptr [0x0014e968],0x0
JNZ 0x0011b91b
MOV dword ptr [RBP + -0x4],0xfffff6fa
JMP 0x0011b94a
LAB_0011b91b:
CALL 0x00123930
CALL 0x0011de40
CALL 0x00122590
CALL 0x0011e2c0
CALL 0x00123500
CALL 0x00120c70
MOV EDI,0x1
CALL 0x0011f8b0
MOV dword ptr [RBP + -0x4],0x0
LAB_0011b94a:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x10
POP RBP
RET
|
int4 qoraal_start_default(void)
{
int4 local_c;
if (_qoraal_instance == 0) {
local_c = 0xfffff6fa;
}
else {
svc_wdt_start();
svc_events_start();
svc_tasks_start();
svc_logger_start();
svc_threads_start();
svc_shell_start();
svc_service_services_start(1);
local_c = 0;
}
return local_c;
}
| |
24,904 | my_casedn_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_casedn_utf8mb4(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_casedn_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x9c7ca
jmp 0x9c7cc
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x9c7fc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x9c340
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x9c805
jmp 0x9c858
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa07a0
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x9c370
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0x9c831
jmp 0x9c858
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x9c7cc
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_casedn_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_9C7CA:
jmp short $+2
loc_9C7CC:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_9C7FC
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_9C7FC:
mov al, [rbp+var_59]
test al, 1
jnz short loc_9C805
jmp short loc_9C858
loc_9C805:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_wc_mb_utf8mb4
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_9C831
jmp short loc_9C858
loc_9C831:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_9C7CC
loc_9C858:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_casedn_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_mb_wc_utf8mb4(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_tolower_utf8mb4(v8, v14);
v12 = my_wc_mb_utf8mb4(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_casedn_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0019c7ca
LAB_0019c7ca:
JMP 0x0019c7cc
LAB_0019c7cc:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x0019c7fc
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x0019c340
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_0019c7fc:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x0019c805
JMP 0x0019c858
LAB_0019c805:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x001a07a0
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x0019c370
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x0019c831
JMP 0x0019c858
LAB_0019c831:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0019c7cc
LAB_0019c858:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_utf8mb4(uVar1,&local_38);
iVar3 = my_wc_mb_utf8mb4(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
| |
24,905 | VSmileJoy::QueueTx(unsigned char) | sp1187[P]veesem/src/core/vsmile/vsmile_joy.cc | void VSmileJoy::QueueTx(uint8_t byte) {
const int new_write = (tx_buffer_write_ + 1) % tx_buffer_.size();
bool was_empty = tx_buffer_read_ == tx_buffer_write_;
if (new_write == tx_buffer_read_) {
// Send buffer is full
return;
}
tx_buffer_[tx_buffer_write_] = byte;
tx_buffer_write_ = new_write;
if (was_empty) {
joy_send_.SetRts(false);
rts_ = false;
if (cts_) {
if (!tx_busy_ && !tx_starting_) {
tx_starting_ = true;
tx_start_timer_.Reset();
}
} else {
rts_timeout_timer_.Reset();
}
}
idle_timer_.Reset();
} | O0 | cpp | VSmileJoy::QueueTx(unsigned char):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x3c(%rdi), %eax
addl $0x1, %eax
cltq
movq %rax, -0x20(%rbp)
addq $0x2c, %rdi
callq 0x111b0
movq -0x28(%rbp), %rcx
movq %rax, %rsi
movq -0x20(%rbp), %rax
xorl %edx, %edx
divq %rsi
movl %edx, %eax
movl %eax, -0x10(%rbp)
movl 0x40(%rcx), %eax
cmpl 0x3c(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x40(%rcx), %eax
jne 0x1083f
jmp 0x108d1
movq -0x28(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, -0x29(%rbp)
movq %rax, %rdi
addq $0x2c, %rdi
movslq 0x3c(%rax), %rsi
callq 0x111c0
movb -0x29(%rbp), %dl
movq %rax, %rcx
movq -0x28(%rbp), %rax
movb %dl, (%rcx)
movl -0x10(%rbp), %ecx
movl %ecx, 0x3c(%rax)
testb $0x1, -0x11(%rbp)
je 0x108c4
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x10(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x4d(%rax)
testb $0x1, 0x4c(%rax)
je 0x108b5
movq -0x28(%rbp), %rax
testb $0x1, 0x4e(%rax)
jne 0x108b3
movq -0x28(%rbp), %rax
testb $0x1, 0x50(%rax)
jne 0x108b3
movq -0x28(%rbp), %rdi
movb $0x1, 0x50(%rdi)
addq $0x28, %rdi
callq 0x110a0
jmp 0x108c2
movq -0x28(%rbp), %rdi
addq $0x24, %rdi
callq 0x11080
jmp 0x108c4
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x11060
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ZN9VSmileJoy7QueueTxEh:
push rbp
mov rbp, rsp
sub rsp, 30h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov rdi, [rbp+var_8]
mov [rbp+var_28], rdi
mov eax, [rdi+3Ch]
add eax, 1
cdqe
mov [rbp+var_20], rax
add rdi, 2Ch ; ','
call _ZNKSt5arrayIhLm16EE4sizeEv; std::array<uchar,16ul>::size(void)
mov rcx, [rbp+var_28]
mov rsi, rax
mov rax, [rbp+var_20]
xor edx, edx
div rsi
mov eax, edx
mov [rbp+var_10], eax
mov eax, [rcx+40h]
cmp eax, [rcx+3Ch]
setz al
and al, 1
mov [rbp+var_11], al
mov eax, [rbp+var_10]
cmp eax, [rcx+40h]
jnz short loc_1083F
jmp loc_108D1
loc_1083F:
mov rax, [rbp+var_28]
mov cl, [rbp+var_9]
mov [rbp+var_29], cl
mov rdi, rax
add rdi, 2Ch ; ','
movsxd rsi, dword ptr [rax+3Ch]
call _ZNSt5arrayIhLm16EEixEm; std::array<uchar,16ul>::operator[](ulong)
mov dl, [rbp+var_29]
mov rcx, rax
mov rax, [rbp+var_28]
mov [rcx], dl
mov ecx, [rbp+var_10]
mov [rax+3Ch], ecx
test [rbp+var_11], 1
jz short loc_108C4
mov rax, [rbp+var_28]
mov rdi, [rax]
mov rax, [rdi]
xor esi, esi
call qword ptr [rax+10h]
mov rax, [rbp+var_28]
mov byte ptr [rax+4Dh], 0
test byte ptr [rax+4Ch], 1
jz short loc_108B5
mov rax, [rbp+var_28]
test byte ptr [rax+4Eh], 1
jnz short loc_108B3
mov rax, [rbp+var_28]
test byte ptr [rax+50h], 1
jnz short loc_108B3
mov rdi, [rbp+var_28]
mov byte ptr [rdi+50h], 1
add rdi, 28h ; '('
call _ZN11SimpleClockILi97200ELi1EE5ResetEv; SimpleClock<97200,1>::Reset(void)
loc_108B3:
jmp short loc_108C2
loc_108B5:
mov rdi, [rbp+var_28]
add rdi, 24h ; '$'
call _ZN11SimpleClockILi13500000ELi1EE5ResetEv; SimpleClock<13500000,1>::Reset(void)
loc_108C2:
jmp short $+2
loc_108C4:
mov rdi, [rbp+var_28]
add rdi, 20h ; ' '
call _ZN11SimpleClockILi27000000ELi1EE5ResetEv; SimpleClock<27000000,1>::Reset(void)
loc_108D1:
add rsp, 30h
pop rbp
retn
| long long VSmileJoy::QueueTx(VSmileJoy *this, char a2)
{
long long result; // rax
unsigned long long v3; // [rsp+10h] [rbp-20h]
bool v4; // [rsp+1Fh] [rbp-11h]
unsigned int v5; // [rsp+20h] [rbp-10h]
v3 = *((_DWORD *)this + 15) + 1;
v5 = v3 % std::array<unsigned char,16ul>::size((char *)this + 44);
v4 = *((_DWORD *)this + 16) == *((_DWORD *)this + 15);
result = v5;
if ( v5 != *((_DWORD *)this + 16) )
{
*(_BYTE *)std::array<unsigned char,16ul>::operator[]((char *)this + 44, *((int *)this + 15)) = a2;
*((_DWORD *)this + 15) = v5;
if ( v4 )
{
(*(void ( **)(_QWORD, _QWORD))(**(_QWORD **)this + 16LL))(*(_QWORD *)this, 0LL);
*((_BYTE *)this + 77) = 0;
if ( (*((_BYTE *)this + 76) & 1) != 0 )
{
if ( (*((_BYTE *)this + 78) & 1) == 0 && (*((_BYTE *)this + 80) & 1) == 0 )
{
*((_BYTE *)this + 80) = 1;
SimpleClock<97200,1>::Reset((char *)this + 40);
}
}
else
{
SimpleClock<13500000,1>::Reset((char *)this + 36);
}
}
return SimpleClock<27000000,1>::Reset((char *)this + 32);
}
return result;
}
| QueueTx:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RDI
MOV EAX,dword ptr [RDI + 0x3c]
ADD EAX,0x1
CDQE
MOV qword ptr [RBP + -0x20],RAX
ADD RDI,0x2c
CALL 0x001111b0
MOV RCX,qword ptr [RBP + -0x28]
MOV RSI,RAX
MOV RAX,qword ptr [RBP + -0x20]
XOR EDX,EDX
DIV RSI
MOV EAX,EDX
MOV dword ptr [RBP + -0x10],EAX
MOV EAX,dword ptr [RCX + 0x40]
CMP EAX,dword ptr [RCX + 0x3c]
SETZ AL
AND AL,0x1
MOV byte ptr [RBP + -0x11],AL
MOV EAX,dword ptr [RBP + -0x10]
CMP EAX,dword ptr [RCX + 0x40]
JNZ 0x0011083f
JMP 0x001108d1
LAB_0011083f:
MOV RAX,qword ptr [RBP + -0x28]
MOV CL,byte ptr [RBP + -0x9]
MOV byte ptr [RBP + -0x29],CL
MOV RDI,RAX
ADD RDI,0x2c
MOVSXD RSI,dword ptr [RAX + 0x3c]
CALL 0x001111c0
MOV DL,byte ptr [RBP + -0x29]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RCX],DL
MOV ECX,dword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x3c],ECX
TEST byte ptr [RBP + -0x11],0x1
JZ 0x001108c4
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RDI]
XOR ESI,ESI
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RAX + 0x4d],0x0
TEST byte ptr [RAX + 0x4c],0x1
JZ 0x001108b5
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x4e],0x1
JNZ 0x001108b3
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x50],0x1
JNZ 0x001108b3
MOV RDI,qword ptr [RBP + -0x28]
MOV byte ptr [RDI + 0x50],0x1
ADD RDI,0x28
CALL 0x001110a0
LAB_001108b3:
JMP 0x001108c2
LAB_001108b5:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x24
CALL 0x00111080
LAB_001108c2:
JMP 0x001108c4
LAB_001108c4:
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x20
CALL 0x00111060
LAB_001108d1:
ADD RSP,0x30
POP RBP
RET
|
/* VSmileJoy::QueueTx(unsigned char) */
void __thiscall VSmileJoy::QueueTx(VSmileJoy *this,uchar param_1)
{
int iVar1;
int iVar2;
int iVar3;
ulong uVar4;
uchar *puVar5;
iVar1 = *(int *)(this + 0x3c);
uVar4 = std::array<unsigned_char,16ul>::size();
iVar3 = (int)((ulong)(long)(iVar1 + 1) % uVar4);
iVar2 = *(int *)(this + 0x40);
iVar1 = *(int *)(this + 0x3c);
if (iVar3 != *(int *)(this + 0x40)) {
puVar5 = (uchar *)std::array<unsigned_char,16ul>::operator[]
((array<unsigned_char,16ul> *)(this + 0x2c),
(long)*(int *)(this + 0x3c));
*puVar5 = param_1;
*(int *)(this + 0x3c) = iVar3;
if (iVar2 == iVar1) {
(**(code **)(**(long **)this + 0x10))(*(long **)this,0);
this[0x4d] = (VSmileJoy)0x0;
if (((byte)this[0x4c] & 1) == 0) {
SimpleClock<13500000,1>::Reset((SimpleClock<13500000,1> *)(this + 0x24));
}
else if ((((byte)this[0x4e] & 1) == 0) && (((byte)this[0x50] & 1) == 0)) {
this[0x50] = (VSmileJoy)0x1;
SimpleClock<97200,1>::Reset((SimpleClock<97200,1> *)(this + 0x28));
}
}
SimpleClock<27000000,1>::Reset((SimpleClock<27000000,1> *)(this + 0x20));
}
return;
}
| |
24,906 | VSmileJoy::QueueTx(unsigned char) | sp1187[P]veesem/src/core/vsmile/vsmile_joy.cc | void VSmileJoy::QueueTx(uint8_t byte) {
const int new_write = (tx_buffer_write_ + 1) % tx_buffer_.size();
bool was_empty = tx_buffer_read_ == tx_buffer_write_;
if (new_write == tx_buffer_read_) {
// Send buffer is full
return;
}
tx_buffer_[tx_buffer_write_] = byte;
tx_buffer_write_ = new_write;
if (was_empty) {
joy_send_.SetRts(false);
rts_ = false;
if (cts_) {
if (!tx_busy_ && !tx_starting_) {
tx_starting_ = true;
tx_start_timer_.Reset();
}
} else {
rts_timeout_timer_.Reset();
}
}
idle_timer_.Reset();
} | O1 | cpp | VSmileJoy::QueueTx(unsigned char):
movslq 0x3c(%rdi), %rax
leal 0x1(%rax), %ecx
andl $0xf, %ecx
movl 0x40(%rdi), %edx
cmpl %ecx, %edx
je 0xa714
pushq %rbx
movq %rdi, %rbx
movb %sil, 0x2c(%rdi,%rax)
movl %ecx, 0x3c(%rdi)
cmpl %eax, %edx
jne 0xa70c
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x10(%rax)
movb $0x0, 0x4d(%rbx)
cmpb $0x1, 0x4c(%rbx)
jne 0xa705
cmpb $0x0, 0x4e(%rbx)
jne 0xa70c
cmpb $0x0, 0x50(%rbx)
jne 0xa70c
movb $0x1, 0x50(%rbx)
movl $0x17bb0, 0x28(%rbx) # imm = 0x17BB0
jmp 0xa70c
movl $0xcdfe60, 0x24(%rbx) # imm = 0xCDFE60
movl $0x19bfcc0, 0x20(%rbx) # imm = 0x19BFCC0
popq %rbx
retq
nop
| _ZN9VSmileJoy7QueueTxEh:
movsxd rax, dword ptr [rdi+3Ch]
lea ecx, [rax+1]
and ecx, 0Fh
mov edx, [rdi+40h]
cmp edx, ecx
jz short locret_A714
push rbx
mov rbx, rdi
mov [rdi+rax+2Ch], sil
mov [rdi+3Ch], ecx
cmp edx, eax
jnz short loc_A70C
mov rdi, [rbx]
mov rax, [rdi]
xor esi, esi
call qword ptr [rax+10h]
mov byte ptr [rbx+4Dh], 0
cmp byte ptr [rbx+4Ch], 1
jnz short loc_A705
cmp byte ptr [rbx+4Eh], 0
jnz short loc_A70C
cmp byte ptr [rbx+50h], 0
jnz short loc_A70C
mov byte ptr [rbx+50h], 1
mov dword ptr [rbx+28h], 17BB0h
jmp short loc_A70C
loc_A705:
mov dword ptr [rbx+24h], 0CDFE60h
loc_A70C:
mov dword ptr [rbx+20h], 19BFCC0h
pop rbx
locret_A714:
retn
| long long VSmileJoy::QueueTx(VSmileJoy *this, char a2)
{
long long result; // rax
int v3; // ecx
int v4; // edx
result = *((int *)this + 15);
v3 = ((_BYTE)result + 1) & 0xF;
v4 = *((_DWORD *)this + 16);
if ( v4 != v3 )
{
*((_BYTE *)this + result + 44) = a2;
*((_DWORD *)this + 15) = v3;
if ( v4 == (_DWORD)result )
{
result = (*(long long ( **)(_QWORD, _QWORD))(**(_QWORD **)this + 16LL))(*(_QWORD *)this, 0LL);
*((_BYTE *)this + 77) = 0;
if ( *((_BYTE *)this + 76) == 1 )
{
if ( !*((_BYTE *)this + 78) && !*((_BYTE *)this + 80) )
{
*((_BYTE *)this + 80) = 1;
*((_DWORD *)this + 10) = 97200;
}
}
else
{
*((_DWORD *)this + 9) = 13500000;
}
}
*((_DWORD *)this + 8) = 27000000;
}
return result;
}
| QueueTx:
MOVSXD RAX,dword ptr [RDI + 0x3c]
LEA ECX,[RAX + 0x1]
AND ECX,0xf
MOV EDX,dword ptr [RDI + 0x40]
CMP EDX,ECX
JZ 0x0010a714
PUSH RBX
MOV RBX,RDI
MOV byte ptr [RDI + RAX*0x1 + 0x2c],SIL
MOV dword ptr [RDI + 0x3c],ECX
CMP EDX,EAX
JNZ 0x0010a70c
MOV RDI,qword ptr [RBX]
MOV RAX,qword ptr [RDI]
XOR ESI,ESI
CALL qword ptr [RAX + 0x10]
MOV byte ptr [RBX + 0x4d],0x0
CMP byte ptr [RBX + 0x4c],0x1
JNZ 0x0010a705
CMP byte ptr [RBX + 0x4e],0x0
JNZ 0x0010a70c
CMP byte ptr [RBX + 0x50],0x0
JNZ 0x0010a70c
MOV byte ptr [RBX + 0x50],0x1
MOV dword ptr [RBX + 0x28],0x17bb0
JMP 0x0010a70c
LAB_0010a705:
MOV dword ptr [RBX + 0x24],0xcdfe60
LAB_0010a70c:
MOV dword ptr [RBX + 0x20],0x19bfcc0
POP RBX
LAB_0010a714:
RET
|
/* VSmileJoy::QueueTx(unsigned char) */
void __thiscall VSmileJoy::QueueTx(VSmileJoy *this,uchar param_1)
{
uint uVar1;
uint uVar2;
uint uVar3;
uVar1 = *(uint *)(this + 0x3c);
uVar3 = uVar1 + 1 & 0xf;
uVar2 = *(uint *)(this + 0x40);
if (uVar2 != uVar3) {
this[(long)(int)uVar1 + 0x2c] = (VSmileJoy)param_1;
*(uint *)(this + 0x3c) = uVar3;
if (uVar2 == uVar1) {
(**(code **)(**(long **)this + 0x10))(*(long **)this,0);
this[0x4d] = (VSmileJoy)0x0;
if (this[0x4c] == (VSmileJoy)0x1) {
if ((this[0x4e] == (VSmileJoy)0x0) && (this[0x50] == (VSmileJoy)0x0)) {
this[0x50] = (VSmileJoy)0x1;
*(int4 *)(this + 0x28) = 0x17bb0;
}
}
else {
*(int4 *)(this + 0x24) = 13500000;
}
}
*(int4 *)(this + 0x20) = 27000000;
}
return;
}
| |
24,907 | mult | eloqsql/strings/dtoa.c | static Bigint *mult(Bigint *a, Bigint *b, Stack_alloc *alloc)
{
Bigint *c;
int k, wa, wb, wc;
ULong *x, *xa, *xae, *xb, *xbe, *xc, *xc0;
ULong y;
ULLong carry, z;
if (a->wds < b->wds)
{
c= a;
a= b;
b= c;
}
k= a->k;
wa= a->wds;
wb= b->wds;
wc= wa + wb;
if (wc > a->maxwds)
k++;
c= Balloc(k, alloc);
for (x= c->p.x, xa= x + wc; x < xa; x++)
*x= 0;
xa= a->p.x;
xae= xa + wa;
xb= b->p.x;
xbe= xb + wb;
xc0= c->p.x;
for (; xb < xbe; xc0++)
{
if ((y= *xb++))
{
x= xa;
xc= xc0;
carry= 0;
do
{
z= *x++ * (ULLong)y + *xc + carry;
carry= z >> 32;
*xc++= (ULong) (z & FFFFFFFF);
}
while (x < xae);
*xc= (ULong) carry;
}
}
for (xc0= c->p.x, xc= xc0 + wc; wc > 0 && !*--xc; --wc) ;
c->wds= wc;
return c;
} | O3 | c | mult:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
movq %rsi, %r12
cmovlq %rdi, %r12
cmovlq %rsi, %r14
movslq 0x14(%r14), %rax
movslq 0x14(%r12), %r13
movq %rax, -0x30(%rbp)
leaq (%rax,%r13), %r15
xorl %edi, %edi
cmpl 0xc(%r14), %r15d
setg %dil
addl 0x8(%r14), %edi
movq %rdx, %rsi
callq 0x582dc
movq %rax, %rbx
movq (%rax), %rdi
testl %r15d, %r15d
jle 0x58631
leaq (%rdi,%r15,4), %rax
leaq 0x4(%rdi), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rdi, %rdx
notq %rdx
addq %rcx, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
xorl %esi, %esi
callq 0x24190
movq (%rbx), %rdi
testl %r13d, %r13d
jle 0x58699
movq (%r14), %rax
movq -0x30(%rbp), %rcx
leaq (%rax,%rcx,4), %rcx
movq (%r12), %rdx
leaq (%rdx,%r13,4), %rsi
movl (%rdx), %r8d
testq %r8, %r8
je 0x58689
xorl %r9d, %r9d
xorl %r10d, %r10d
leaq (%rax,%r9), %r11
addq $0x4, %r11
movl -0x4(%r11), %r14d
imulq %r8, %r14
movl (%rdi,%r9), %r12d
addq %r10, %r12
addq %r14, %r12
movq %r12, %r10
shrq $0x20, %r10
movl %r12d, (%rdi,%r9)
addq $0x4, %r9
cmpq %rcx, %r11
jb 0x58657
movl %r10d, (%rdi,%r9)
addq $0x4, %rdx
addq $0x4, %rdi
cmpq %rsi, %rdx
jb 0x58649
movq (%rbx), %rdi
testl %r15d, %r15d
jle 0x586bf
leaq (%rdi,%r15,4), %rax
addq $-0x4, %rax
cmpl $0x0, (%rax)
jne 0x586bf
leal -0x1(%r15), %ecx
addq $-0x4, %rax
cmpl $0x1, %r15d
movl %ecx, %r15d
jg 0x586a6
xorl %r15d, %r15d
movl %r15d, 0x14(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| mult:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, rdi
mov eax, [rdi+14h]
cmp eax, [rsi+14h]
mov r12, rsi
cmovl r12, rdi
cmovl r14, rsi
movsxd rax, dword ptr [r14+14h]
movsxd r13, dword ptr [r12+14h]
mov [rbp+var_30], rax
lea r15, [rax+r13]
xor edi, edi
cmp r15d, [r14+0Ch]
setnle dil
add edi, [r14+8]
mov rsi, rdx
call Balloc
mov rbx, rax
mov rdi, [rax]
test r15d, r15d
jle short loc_58631
lea rax, [rdi+r15*4]
lea rcx, [rdi+4]
cmp rax, rcx
cmova rcx, rax
mov rdx, rdi
not rdx
add rdx, rcx
and rdx, 0FFFFFFFFFFFFFFFCh
add rdx, 4
xor esi, esi
call _memset
mov rdi, [rbx]
loc_58631:
test r13d, r13d
jle short loc_58699
mov rax, [r14]
mov rcx, [rbp+var_30]
lea rcx, [rax+rcx*4]
mov rdx, [r12]
lea rsi, [rdx+r13*4]
loc_58649:
mov r8d, [rdx]
test r8, r8
jz short loc_58689
xor r9d, r9d
xor r10d, r10d
loc_58657:
lea r11, [rax+r9]
add r11, 4
mov r14d, [r11-4]
imul r14, r8
mov r12d, [rdi+r9]
add r12, r10
add r12, r14
mov r10, r12
shr r10, 20h
mov [rdi+r9], r12d
add r9, 4
cmp r11, rcx
jb short loc_58657
mov [rdi+r9], r10d
loc_58689:
add rdx, 4
add rdi, 4
cmp rdx, rsi
jb short loc_58649
mov rdi, [rbx]
loc_58699:
test r15d, r15d
jle short loc_586BF
lea rax, [rdi+r15*4]
add rax, 0FFFFFFFFFFFFFFFCh
loc_586A6:
cmp dword ptr [rax], 0
jnz short loc_586BF
lea ecx, [r15-1]
add rax, 0FFFFFFFFFFFFFFFCh
cmp r15d, 1
mov r15d, ecx
jg short loc_586A6
xor r15d, r15d
loc_586BF:
mov [rbx+14h], r15d
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long mult(long long *a1, long long *a2, long long a3)
{
long long *v3; // r14
long long *v4; // r12
long long v5; // r13
long long v6; // r15
long long v7; // rbx
long long v8; // rdi
long long v9; // rcx
long long v10; // rax
unsigned long long v11; // rcx
_DWORD *v12; // rdx
unsigned long long v13; // rsi
long long v14; // r8
long long v15; // r9
unsigned long long v16; // r10
unsigned long long v17; // r11
unsigned long long v18; // r12
_DWORD *v19; // rax
bool v20; // cc
long long v22; // [rsp+0h] [rbp-30h]
v3 = a1;
v4 = a2;
if ( *((_DWORD *)a1 + 5) < *((_DWORD *)a2 + 5) )
{
v4 = a1;
v3 = a2;
}
v5 = *((int *)v4 + 5);
v22 = *((int *)v3 + 5);
v6 = v22 + v5;
v7 = Balloc(*((_DWORD *)v3 + 2) + (unsigned int)((int)v22 + (int)v5 > *((_DWORD *)v3 + 3)), a3);
v8 = *(_QWORD *)v7;
if ( (int)v22 + (int)v5 > 0 )
{
v9 = v8 + 4;
if ( v8 + 4 * v6 > (unsigned long long)(v8 + 4) )
v9 = v8 + 4 * v6;
memset(v8, 0LL, ((v9 + ~v8) & 0xFFFFFFFFFFFFFFFCLL) + 4);
v8 = *(_QWORD *)v7;
}
if ( (int)v5 > 0 )
{
v10 = *v3;
v11 = *v3 + 4 * v22;
v12 = (_DWORD *)*v4;
v13 = *v4 + 4 * v5;
do
{
v14 = (unsigned int)*v12;
if ( *v12 )
{
v15 = 0LL;
v16 = 0LL;
do
{
v17 = v10 + v15 + 4;
v18 = v14 * *(unsigned int *)(v10 + v15) + v16 + *(unsigned int *)(v8 + v15);
v16 = HIDWORD(v18);
*(_DWORD *)(v8 + v15) = v18;
v15 += 4LL;
}
while ( v17 < v11 );
*(_DWORD *)(v8 + v15) = HIDWORD(v18);
}
++v12;
v8 += 4LL;
}
while ( (unsigned long long)v12 < v13 );
v8 = *(_QWORD *)v7;
}
if ( (int)v6 > 0 )
{
v19 = (_DWORD *)(v8 + 4 * v6 - 4);
while ( !*v19 )
{
--v19;
v20 = (int)v6 <= 1;
LODWORD(v6) = v6 - 1;
if ( v20 )
{
LODWORD(v6) = 0;
break;
}
}
}
*(_DWORD *)(v7 + 20) = v6;
return v7;
}
| mult:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EAX,dword ptr [RDI + 0x14]
CMP EAX,dword ptr [RSI + 0x14]
MOV R12,RSI
CMOVL R12,RDI
CMOVL R14,RSI
MOVSXD RAX,dword ptr [R14 + 0x14]
MOVSXD R13,dword ptr [R12 + 0x14]
MOV qword ptr [RBP + -0x30],RAX
LEA R15,[RAX + R13*0x1]
XOR EDI,EDI
CMP R15D,dword ptr [R14 + 0xc]
SETG DIL
ADD EDI,dword ptr [R14 + 0x8]
MOV RSI,RDX
CALL 0x001582dc
MOV RBX,RAX
MOV RDI,qword ptr [RAX]
TEST R15D,R15D
JLE 0x00158631
LEA RAX,[RDI + R15*0x4]
LEA RCX,[RDI + 0x4]
CMP RAX,RCX
CMOVA RCX,RAX
MOV RDX,RDI
NOT RDX
ADD RDX,RCX
AND RDX,-0x4
ADD RDX,0x4
XOR ESI,ESI
CALL 0x00124190
MOV RDI,qword ptr [RBX]
LAB_00158631:
TEST R13D,R13D
JLE 0x00158699
MOV RAX,qword ptr [R14]
MOV RCX,qword ptr [RBP + -0x30]
LEA RCX,[RAX + RCX*0x4]
MOV RDX,qword ptr [R12]
LEA RSI,[RDX + R13*0x4]
LAB_00158649:
MOV R8D,dword ptr [RDX]
TEST R8,R8
JZ 0x00158689
XOR R9D,R9D
XOR R10D,R10D
LAB_00158657:
LEA R11,[RAX + R9*0x1]
ADD R11,0x4
MOV R14D,dword ptr [R11 + -0x4]
IMUL R14,R8
MOV R12D,dword ptr [RDI + R9*0x1]
ADD R12,R10
ADD R12,R14
MOV R10,R12
SHR R10,0x20
MOV dword ptr [RDI + R9*0x1],R12D
ADD R9,0x4
CMP R11,RCX
JC 0x00158657
MOV dword ptr [RDI + R9*0x1],R10D
LAB_00158689:
ADD RDX,0x4
ADD RDI,0x4
CMP RDX,RSI
JC 0x00158649
MOV RDI,qword ptr [RBX]
LAB_00158699:
TEST R15D,R15D
JLE 0x001586bf
LEA RAX,[RDI + R15*0x4]
ADD RAX,-0x4
LAB_001586a6:
CMP dword ptr [RAX],0x0
JNZ 0x001586bf
LEA ECX,[R15 + -0x1]
ADD RAX,-0x4
CMP R15D,0x1
MOV R15D,ECX
JG 0x001586a6
XOR R15D,R15D
LAB_001586bf:
MOV dword ptr [RBX + 0x14],R15D
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * mult(long *param_1,long *param_2)
{
void *pvVar1;
uint *puVar2;
uint *puVar3;
int iVar4;
int iVar5;
uint uVar6;
long lVar7;
int8 *puVar8;
int *piVar9;
void *pvVar10;
uint *puVar11;
void *__s;
long lVar12;
ulong uVar13;
ulong uVar14;
long *plVar15;
int iVar16;
ulong uVar17;
plVar15 = param_1;
if (*(int *)((long)param_1 + 0x14) < *(int *)((long)param_2 + 0x14)) {
plVar15 = param_2;
param_2 = param_1;
}
iVar4 = *(int *)((long)plVar15 + 0x14);
iVar5 = *(int *)((long)param_2 + 0x14);
uVar17 = (long)iVar4 + (long)iVar5;
iVar16 = (int)uVar17;
puVar8 = (int8 *)Balloc((uint)(*(int *)((long)plVar15 + 0xc) < iVar16) + (int)plVar15[1]);
__s = (void *)*puVar8;
if (0 < iVar16) {
pvVar1 = (void *)((long)__s + uVar17 * 4);
pvVar10 = (void *)((long)__s + 4U);
if ((void *)((long)__s + 4U) < pvVar1) {
pvVar10 = pvVar1;
}
memset(__s,0,(~(ulong)__s + (long)pvVar10 & 0xfffffffffffffffc) + 4);
__s = (void *)*puVar8;
}
if (0 < iVar5) {
lVar7 = *plVar15;
puVar11 = (uint *)*param_2;
puVar2 = puVar11 + iVar5;
do {
uVar6 = *puVar11;
if ((ulong)uVar6 != 0) {
lVar12 = 0;
uVar13 = 0;
do {
puVar3 = (uint *)(lVar7 + lVar12);
uVar14 = *(uint *)((long)__s + lVar12) + uVar13 + (ulong)*puVar3 * (ulong)uVar6;
uVar13 = uVar14 >> 0x20;
*(int *)((long)__s + lVar12) = (int)uVar14;
lVar12 = lVar12 + 4;
} while (puVar3 + 1 < (uint *)(lVar7 + (long)iVar4 * 4));
*(int *)((long)__s + lVar12) = (int)(uVar14 >> 0x20);
}
puVar11 = puVar11 + 1;
__s = (void *)((long)__s + 4);
} while (puVar11 < puVar2);
__s = (void *)*puVar8;
}
if (0 < iVar16) {
piVar9 = (int *)((long)__s + uVar17 * 4);
do {
piVar9 = piVar9 + -1;
if (*piVar9 != 0) goto LAB_001586bf;
iVar4 = (int)uVar17;
uVar17 = (ulong)(iVar4 - 1);
} while (1 < iVar4);
uVar17 = 0;
}
LAB_001586bf:
*(int *)((long)puVar8 + 0x14) = (int)uVar17;
return puVar8;
}
| |
24,908 | nglog::SetEmailLogging(nglog::LogSeverity, char const*) | ng-log[P]ng-log/src/logging.cc | void SetEmailLogging(LogSeverity min_severity, const char* addresses) {
LogDestination::SetEmailLogging(min_severity, addresses);
} | O3 | cpp | nglog::SetEmailLogging(nglog::LogSeverity, char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x3551c(%rip), %rdi # 0x41d38
callq 0x77f0
testl %eax, %eax
jne 0xc86a
movl %ebp, 0x24d25(%rip) # 0x31550
movq 0x263c6(%rip), %r14 # 0x32bf8
leaq 0x263b7(%rip), %r15 # 0x32bf0
movq %rbx, %rdi
callq 0x7200
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x7850
leaq 0x354dd(%rip), %rdi # 0x41d38
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x73f0
movl %eax, %edi
callq 0x7350
movq %rax, %rbx
leaq 0x354bd(%rip), %rdi # 0x41d38
callq 0x73f0
movq %rbx, %rdi
callq 0x7950
| _ZN5nglog15SetEmailLoggingENS_11LogSeverityEPKc:
push rbp
push r15
push r14
push rbx
push rax
mov rbx, rsi
mov ebp, edi
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_lock
test eax, eax
jnz short loc_C86A
mov cs:_ZN5nglog14LogDestination23email_logging_severity_E, ebp; nglog::LogDestination::email_logging_severity_
mov r14, cs:qword_32BF8
lea r15, _ZN5nglog14LogDestination10addresses_B5cxx11E; nglog::LogDestination::addresses_
mov rdi, rbx
call _strlen
mov rdi, r15
xor esi, esi
mov rdx, r14
mov rcx, rbx
mov r8, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE10_M_replaceEmmPKcm; std::string::_M_replace(ulong,ulong,char const*,ulong)
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_C86A:
mov edi, eax; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
mov rbx, rax
lea rdi, _ZN5nglogL9log_mutexE; nglog::log_mutex
call _pthread_mutex_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::SetEmailLogging(int a1, long long a2)
{
int v2; // eax
long long v3; // r14
long long v4; // rax
v2 = pthread_mutex_lock(&nglog::log_mutex);
if ( v2 )
std::__throw_system_error(v2);
nglog::LogDestination::email_logging_severity_ = a1;
v3 = qword_32BF8;
v4 = strlen(a2);
std::string::_M_replace(&nglog::LogDestination::addresses_[abi:cxx11], 0LL, v3, a2, v4);
return pthread_mutex_unlock(&nglog::log_mutex);
}
| SetEmailLogging:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV EBP,EDI
LEA RDI,[0x141d38]
CALL 0x001077f0
TEST EAX,EAX
JNZ 0x0010c86a
MOV dword ptr [0x00131550],EBP
MOV R14,qword ptr [0x00132bf8]
LEA R15,[0x132bf0]
MOV RDI,RBX
CALL 0x00107200
LAB_0010c841:
MOV RDI,R15
XOR ESI,ESI
MOV RDX,R14
MOV RCX,RBX
MOV R8,RAX
CALL 0x00107850
LAB_0010c854:
LEA RDI,[0x141d38]
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x001073f0
LAB_0010c86a:
MOV EDI,EAX
CALL 0x00107350
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* nglog::SetEmailLogging(nglog::LogSeverity, char const*) */
void nglog::SetEmailLogging(int4 param_1,char *param_2)
{
char *pcVar1;
int iVar2;
iVar2 = pthread_mutex_lock((pthread_mutex_t *)log_mutex);
pcVar1 = _DAT_00132bf8;
if (iVar2 == 0) {
LogDestination::email_logging_severity_ = param_1;
strlen(param_2);
/* try { // try from 0010c841 to 0010c853 has its CatchHandler @ 0010c871 */
std::__cxx11::string::_M_replace(0x132bf0,0,pcVar1,(ulong)param_2);
pthread_mutex_unlock((pthread_mutex_t *)log_mutex);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(iVar2);
}
| |
24,909 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) | monkey531[P]llama/common/json.hpp | inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
{
// LCOV_EXCL_START
if (n >= 1000000000)
{
pow10 = 1000000000;
return 10;
}
// LCOV_EXCL_STOP
if (n >= 100000000)
{
pow10 = 100000000;
return 9;
}
if (n >= 10000000)
{
pow10 = 10000000;
return 8;
}
if (n >= 1000000)
{
pow10 = 1000000;
return 7;
}
if (n >= 100000)
{
pow10 = 100000;
return 6;
}
if (n >= 10000)
{
pow10 = 10000;
return 5;
}
if (n >= 1000)
{
pow10 = 1000;
return 4;
}
if (n >= 100)
{
pow10 = 100;
return 3;
}
if (n >= 10)
{
pow10 = 10;
return 2;
}
pow10 = 1;
return 1;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&):
cmpl $0x3b9ac9ff, %edi # imm = 0x3B9AC9FF
jbe 0x88205
pushq $0xa
popq %rax
movl $0x3b9aca00, %ecx # imm = 0x3B9ACA00
jmp 0x8828d
cmpl $0x5f5e0ff, %edi # imm = 0x5F5E0FF
jbe 0x88217
pushq $0x9
popq %rax
movl $0x5f5e100, %ecx # imm = 0x5F5E100
jmp 0x8828d
cmpl $0x98967f, %edi # imm = 0x98967F
jbe 0x88229
pushq $0x8
popq %rax
movl $0x989680, %ecx # imm = 0x989680
jmp 0x8828d
cmpl $0xf423f, %edi # imm = 0xF423F
jbe 0x8823b
pushq $0x7
popq %rax
movl $0xf4240, %ecx # imm = 0xF4240
jmp 0x8828d
cmpl $0x1869f, %edi # imm = 0x1869F
jbe 0x8824d
pushq $0x6
popq %rax
movl $0x186a0, %ecx # imm = 0x186A0
jmp 0x8828d
cmpl $0x270f, %edi # imm = 0x270F
jbe 0x8825f
pushq $0x5
popq %rax
movl $0x2710, %ecx # imm = 0x2710
jmp 0x8828d
cmpl $0x3e7, %edi # imm = 0x3E7
jbe 0x88271
pushq $0x4
popq %rax
movl $0x3e8, %ecx # imm = 0x3E8
jmp 0x8828d
cmpl $0x63, %edi
jbe 0x8827e
pushq $0x3
popq %rax
pushq $0x64
popq %rcx
jmp 0x8828d
xorl %eax, %eax
cmpl $0xa, %edi
setae %al
leal (%rax,%rax,8), %ecx
incl %ecx
incl %eax
movl %ecx, (%rsi)
retq
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18find_largest_pow10EjRj:
cmp edi, 3B9AC9FFh
jbe short loc_88205
push 0Ah
pop rax
mov ecx, 3B9ACA00h
jmp loc_8828D
loc_88205:
cmp edi, 5F5E0FFh
jbe short loc_88217
push 9
pop rax
mov ecx, 5F5E100h
jmp short loc_8828D
loc_88217:
cmp edi, 98967Fh
jbe short loc_88229
push 8
pop rax
mov ecx, 989680h
jmp short loc_8828D
loc_88229:
cmp edi, offset unk_F423F
jbe short loc_8823B
push 7
pop rax
mov ecx, offset unk_F4240
jmp short loc_8828D
loc_8823B:
cmp edi, 1869Fh
jbe short loc_8824D
push 6
pop rax
mov ecx, 186A0h
jmp short loc_8828D
loc_8824D:
cmp edi, 270Fh
jbe short loc_8825F
push 5
pop rax
mov ecx, 2710h
jmp short loc_8828D
loc_8825F:
cmp edi, 3E7h
jbe short loc_88271
push 4
pop rax
mov ecx, 3E8h
jmp short loc_8828D
loc_88271:
cmp edi, 63h ; 'c'
jbe short loc_8827E
push 3
pop rax
push 64h ; 'd'
pop rcx
jmp short loc_8828D
loc_8827E:
xor eax, eax
cmp edi, 0Ah
setnb al
lea ecx, [rax+rax*8]
inc ecx
inc eax
loc_8828D:
mov [rsi], ecx
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(
nlohmann::json_abi_v3_11_3::detail::dtoa_impl *this,
_DWORD *a2,
unsigned int *a3)
{
long long result; // rax
void *v4; // rcx
BOOL v5; // eax
if ( (unsigned int)this <= 0x3B9AC9FF )
{
if ( (unsigned int)this <= 0x5F5E0FF )
{
if ( (unsigned int)this <= 0x98967F )
{
if ( (unsigned int)this <= (unsigned int)&unk_F423F )
{
if ( (unsigned int)this <= 0x1869F )
{
if ( (unsigned int)this <= 0x270F )
{
if ( (unsigned int)this <= 0x3E7 )
{
if ( (unsigned int)this <= 0x63 )
{
v5 = (unsigned int)this >= 0xA;
LODWORD(v4) = 9 * v5 + 1;
result = (unsigned int)(v5 + 1);
}
else
{
result = 3LL;
LODWORD(v4) = 100;
}
}
else
{
result = 4LL;
LODWORD(v4) = 1000;
}
}
else
{
result = 5LL;
LODWORD(v4) = 10000;
}
}
else
{
result = 6LL;
LODWORD(v4) = 100000;
}
}
else
{
result = 7LL;
v4 = &unk_F4240;
}
}
else
{
result = 8LL;
LODWORD(v4) = 10000000;
}
}
else
{
result = 9LL;
LODWORD(v4) = 100000000;
}
}
else
{
result = 10LL;
LODWORD(v4) = 1000000000;
}
*a2 = (_DWORD)v4;
return result;
}
| find_largest_pow10:
CMP EDI,0x3b9ac9ff
JBE 0x00188205
PUSH 0xa
POP RAX
MOV ECX,0x3b9aca00
JMP 0x0018828d
LAB_00188205:
CMP EDI,0x5f5e0ff
JBE 0x00188217
PUSH 0x9
POP RAX
MOV ECX,0x5f5e100
JMP 0x0018828d
LAB_00188217:
CMP EDI,0x98967f
JBE 0x00188229
PUSH 0x8
POP RAX
MOV ECX,0x989680
JMP 0x0018828d
LAB_00188229:
CMP EDI,0xf423f
JBE 0x0018823b
PUSH 0x7
POP RAX
MOV ECX,0xf4240
JMP 0x0018828d
LAB_0018823b:
CMP EDI,0x1869f
JBE 0x0018824d
PUSH 0x6
POP RAX
MOV ECX,0x186a0
JMP 0x0018828d
LAB_0018824d:
CMP EDI,0x270f
JBE 0x0018825f
PUSH 0x5
POP RAX
MOV ECX,0x2710
JMP 0x0018828d
LAB_0018825f:
CMP EDI,0x3e7
JBE 0x00188271
PUSH 0x4
POP RAX
MOV ECX,0x3e8
JMP 0x0018828d
LAB_00188271:
CMP EDI,0x63
JBE 0x0018827e
PUSH 0x3
POP RAX
PUSH 0x64
POP RCX
JMP 0x0018828d
LAB_0018827e:
XOR EAX,EAX
CMP EDI,0xa
SETNC AL
LEA ECX,[RAX + RAX*0x8]
INC ECX
INC EAX
LAB_0018828d:
MOV dword ptr [RSI],ECX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(unsigned int, unsigned int&) */
char nlohmann::json_abi_v3_11_3::detail::dtoa_impl::find_largest_pow10(uint param_1,uint *param_2)
{
char cVar1;
uint uVar2;
if (param_1 < 1000000000) {
if (param_1 < 100000000) {
if (param_1 < 10000000) {
if (param_1 < 1000000) {
if (param_1 < 100000) {
if (param_1 < 10000) {
if (param_1 < 1000) {
if (param_1 < 100) {
uVar2 = (uint)(9 < param_1) * 9 + 1;
cVar1 = (9 < param_1) + '\x01';
}
else {
cVar1 = '\x03';
uVar2 = 100;
}
}
else {
cVar1 = '\x04';
uVar2 = 1000;
}
}
else {
cVar1 = '\x05';
uVar2 = 10000;
}
}
else {
cVar1 = '\x06';
uVar2 = 100000;
}
}
else {
cVar1 = '\a';
uVar2 = 1000000;
}
}
else {
cVar1 = '\b';
uVar2 = 10000000;
}
}
else {
cVar1 = '\t';
uVar2 = 100000000;
}
}
else {
cVar1 = '\n';
uVar2 = 1000000000;
}
*param_2 = uVar2;
return cVar1;
}
| |
24,910 | my_casedn_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O0 | c | my_casedn_ucs2:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x62dc2
jmp 0x62dc4
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x51(%rbp)
jae 0x62df4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x62bf0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x62dfd
jmp 0x62e57
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x67b80
movl -0x34(%rbp), %eax
movl %eax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x62c20
movl %eax, %ecx
movl -0x58(%rbp), %eax
cmpl %ecx, %eax
je 0x62e30
jmp 0x62e57
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x62dc4
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casedn_ucs2:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_50], rax
jmp short $+2
loc_62DC2:
jmp short $+2
loc_62DC4:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_51], al
jnb short loc_62DF4
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_ucs2_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_51], al
loc_62DF4:
mov al, [rbp+var_51]
test al, 1
jnz short loc_62DFD
jmp short loc_62E57
loc_62DFD:
mov rdi, [rbp+var_50]
lea rsi, [rbp+var_30]
call my_tolower_ucs2
mov eax, [rbp+var_34]
mov [rbp+var_58], eax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_ucs2
mov ecx, eax
mov eax, [rbp+var_58]
cmp eax, ecx
jz short loc_62E30
jmp short loc_62E57
loc_62E30:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_62DC4
loc_62E57:
mov rax, [rbp+var_18]
add rsp, 60h
pop rbp
retn
| long long my_casedn_ucs2(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+Fh] [rbp-51h]
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v9; // [rsp+18h] [rbp-48h]
unsigned long long v10; // [rsp+20h] [rbp-40h]
int v11; // [rsp+2Ch] [rbp-34h]
unsigned long long v12[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v13; // [rsp+40h] [rbp-20h]
long long v14; // [rsp+48h] [rbp-18h]
unsigned long long v15; // [rsp+50h] [rbp-10h]
long long v16; // [rsp+58h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
v13 = a4;
v12[1] = a5;
v10 = a3 + a2;
v9 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v15 < v10 )
{
v11 = my_ucs2_uni(v16, (long long)v12, v15, v10, a5, a6);
v7 = v11 > 0;
}
if ( !v7 )
break;
my_tolower_ucs2(v8, v12);
if ( v11 != (unsigned int)my_uni_ucs2(v16, v12[0], v13, v9) )
break;
v15 += v11;
v13 += v11;
}
return v14;
}
| my_casedn_ucs2:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00162dc2
LAB_00162dc2:
JMP 0x00162dc4
LAB_00162dc4:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x51],AL
JNC 0x00162df4
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00162bf0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x51],AL
LAB_00162df4:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x00162dfd
JMP 0x00162e57
LAB_00162dfd:
MOV RDI,qword ptr [RBP + -0x50]
LEA RSI,[RBP + -0x30]
CALL 0x00167b80
MOV EAX,dword ptr [RBP + -0x34]
MOV dword ptr [RBP + -0x58],EAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x00162c20
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x58]
CMP EAX,ECX
JZ 0x00162e30
JMP 0x00162e57
LAB_00162e30:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00162dc4
LAB_00162e57:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_ucs2(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_ucs2_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_ucs2(uVar1,&local_38);
iVar3 = my_uni_ucs2(local_10,local_38,local_28,param_4 + param_5);
if (local_3c != iVar3) {
return local_20;
}
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + local_3c;
}
return local_20;
}
| |
24,911 | inline_mysql_file_write | eloqsql/include/mysql/psi/mysql_file.h | static inline size_t
inline_mysql_file_write(
#ifdef HAVE_PSI_FILE_INTERFACE
const char *src_file, uint src_line,
#endif
File file, const uchar *buffer, size_t count, myf flags)
{
size_t result;
#ifdef HAVE_PSI_FILE_INTERFACE
struct PSI_file_locker *locker;
PSI_file_locker_state state;
size_t bytes_written;
locker= PSI_FILE_CALL(get_thread_file_descriptor_locker)(&state, file, PSI_FILE_WRITE);
if (psi_likely(locker != NULL))
{
PSI_FILE_CALL(start_file_wait)(locker, count, src_file, src_line);
result= my_write(file, buffer, count, flags);
if (flags & (MY_NABP | MY_FNABP))
bytes_written= (result == 0) ? count : 0;
else
bytes_written= (result != MY_FILE_ERROR) ? result : 0;
PSI_FILE_CALL(end_file_wait)(locker, bytes_written);
return result;
}
#endif
result= my_write(file, buffer, count, flags);
return result;
} | O0 | c | inline_mysql_file_write:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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 0x1e7688(%rip), %rax # 0x2ceb20
movq (%rax), %rax
movq 0x158(%rax), %rax
movl -0x18(%rbp), %esi
leaq -0x88(%rbp), %rdi
movl $0x7, %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 0xe75a7
leaq 0x1e763e(%rip), %rax # 0x2ceb20
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
callq 0xfff20
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x6, %rax
cmpq $0x0, %rax
je 0xe7552
cmpq $0x0, -0x38(%rbp)
jne 0xe7537
movq -0x28(%rbp), %rax
movq %rax, -0x98(%rbp)
jmp 0xe7542
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0xe7542
movq -0x98(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0xe757f
cmpq $-0x1, -0x38(%rbp)
je 0xe7566
movq -0x38(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0xe7571
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0xe7571
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq 0x1e759a(%rip), %rax # 0x2ceb20
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 0xe75c7
movl -0x18(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xfff20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_file_write_3:
push rbp
mov rbp, rsp
sub rsp, 0A0h
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, 7
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_E75A7
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]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
and rax, 6
cmp rax, 0
jz short loc_E7552
cmp [rbp+var_38], 0
jnz short loc_E7537
mov rax, [rbp+var_28]
mov [rbp+var_98], rax
jmp short loc_E7542
loc_E7537:
xor eax, eax
mov [rbp+var_98], rax
jmp short $+2
loc_E7542:
mov rax, [rbp+var_98]
mov [rbp+var_90], rax
jmp short loc_E757F
loc_E7552:
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jz short loc_E7566
mov rax, [rbp+var_38]
mov [rbp+var_A0], rax
jmp short loc_E7571
loc_E7566:
xor eax, eax
mov [rbp+var_A0], rax
jmp short $+2
loc_E7571:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_E757F:
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_E75C7
loc_E75A7:
mov edi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rcx, [rbp+var_30]
call my_write
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_E75C7:
mov rax, [rbp+var_8]
add rsp, 0A0h
pop rbp
retn
| long long inline_mysql_file_write_3(
long long a1,
unsigned int a2,
unsigned int a3,
long long a4,
long long a5,
long long a6)
{
long long v7; // [rsp+0h] [rbp-A0h]
long long v8; // [rsp+8h] [rbp-98h]
_BYTE v9[72]; // [rsp+18h] [rbp-88h] BYREF
long long v10; // [rsp+60h] [rbp-40h]
long long v11; // [rsp+68h] [rbp-38h]
long long v12; // [rsp+70h] [rbp-30h]
long long v13; // [rsp+78h] [rbp-28h]
long long v14; // [rsp+80h] [rbp-20h]
unsigned int v15; // [rsp+88h] [rbp-18h]
unsigned int v16; // [rsp+8Ch] [rbp-14h]
long long v17; // [rsp+90h] [rbp-10h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = a5;
v12 = a6;
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v9, a3, 7LL);
if ( v10 )
{
((void ( *)(long long, long long, long long, _QWORD))PSI_server[66])(v10, v13, v17, v16);
v11 = my_write(v15, v14, v13, v12);
if ( (v12 & 6) != 0 )
{
if ( v11 )
v8 = 0LL;
else
v8 = v13;
((void ( *)(long long, long long))PSI_server[67])(v10, v8);
}
else
{
if ( v11 == -1 )
v7 = 0LL;
else
v7 = v11;
((void ( *)(long long, long long))PSI_server[67])(v10, v7);
}
return v11;
}
else
{
return my_write(v15, v14, v13, v12);
}
}
| inline_mysql_file_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
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,[0x3ceb20]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x158]
MOV ESI,dword ptr [RBP + -0x18]
LEA RDI,[RBP + -0x88]
MOV EDX,0x7
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 0x001e75a7
LEA RAX,[0x3ceb20]
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]
CALL 0x001fff20
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
AND RAX,0x6
CMP RAX,0x0
JZ 0x001e7552
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x001e7537
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e7542
LAB_001e7537:
XOR EAX,EAX
MOV qword ptr [RBP + -0x98],RAX
JMP 0x001e7542
LAB_001e7542:
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x001e757f
LAB_001e7552:
CMP qword ptr [RBP + -0x38],-0x1
JZ 0x001e7566
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e7571
LAB_001e7566:
XOR EAX,EAX
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x001e7571
LAB_001e7571:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_001e757f:
LEA RAX,[0x3ceb20]
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 0x001e75c7
LAB_001e75a7:
MOV EDI,dword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
CALL 0x001fff20
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001e75c7:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0xa0
POP RBP
RET
|
long inline_mysql_file_write
(int8 param_1,int4 param_2,int4 param_3,int8 param_4,
long param_5,ulong param_6)
{
long local_a8;
long local_a0;
long local_98;
int1 local_90 [72];
long local_48;
long local_40;
ulong 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,7);
if (local_48 == 0) {
local_10 = my_write(local_20,local_28,local_30,local_38);
}
else {
(**(code **)(PSI_server + 0x210))(local_48,local_30,local_18,local_1c);
local_40 = my_write(local_20,local_28,local_30,local_38);
if ((local_38 & 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;
}
| |
24,912 | PFS_buffer_scalable_container<PFS_setup_object, 128, 1024, PFS_buffer_default_array<PFS_setup_object>, PFS_buffer_default_allocator<PFS_setup_object>>::apply(PFS_buffer_processor<PFS_setup_object>&) | eloqsql/storage/perfschema/pfs_buffer_container.h | void apply(processor_type & proc)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
if (pfs->m_lock.is_populated())
{
proc(pfs);
}
pfs++;
}
}
}
} | O0 | c | PFS_buffer_scalable_container<PFS_setup_object, 128, 1024, PFS_buffer_default_array<PFS_setup_object>, PFS_buffer_default_allocator<PFS_setup_object>>::apply(PFS_buffer_processor<PFS_setup_object>&):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jae 0x41d75
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x41d65
movq -0x20(%rbp), %rdi
callq 0x42080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x420a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x41d63
movq -0x28(%rbp), %rdi
callq 0x38ea0
testb $0x1, %al
jne 0x41d45
jmp 0x41d53
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
addq $0x1c0, %rax # imm = 0x1C0
movq %rax, -0x28(%rbp)
jmp 0x41d2c
jmp 0x41d65
jmp 0x41d67
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41cef
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI16PFS_setup_objectLi128ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE5applyER20PFS_buffer_processorIS0_E:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_14], 0
loc_41CEF:
cmp [rbp+var_14], 400h
jnb short loc_41D75
mov rax, [rbp+var_38]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8+0A8h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_41D65
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI16PFS_setup_objectE9get_firstEv; PFS_buffer_default_array<PFS_setup_object>::get_first(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI16PFS_setup_objectE8get_lastEv; PFS_buffer_default_array<PFS_setup_object>::get_last(void)
mov [rbp+var_30], rax
loc_41D2C:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_41D63
mov rdi, [rbp+var_28]; this
call _ZN8pfs_lock12is_populatedEv; pfs_lock::is_populated(void)
test al, 1
jnz short loc_41D45
jmp short loc_41D53
loc_41D45:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rax, [rdi]
call qword ptr [rax+10h]
loc_41D53:
mov rax, [rbp+var_28]
add rax, 1C0h
mov [rbp+var_28], rax
jmp short loc_41D2C
loc_41D63:
jmp short $+2
loc_41D65:
jmp short $+2
loc_41D67:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_41CEF
loc_41D75:
add rsp, 40h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_setup_object,128,1024,PFS_buffer_default_array<PFS_setup_object>,PFS_buffer_default_allocator<PFS_setup_object>>::apply(
long long a1,
unsigned int *a2)
{
long long result; // rax
unsigned long long last; // [rsp+10h] [rbp-30h]
pfs_lock *first; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
unsigned int *v7; // [rsp+30h] [rbp-10h]
v7 = a2;
result = a1;
for ( i = 0; i < 0x400; ++i )
{
v5 = *(_QWORD *)(a1 + 8LL * i + 168);
if ( v5 )
{
first = (pfs_lock *)PFS_buffer_default_array<PFS_setup_object>::get_first(v5);
last = PFS_buffer_default_array<PFS_setup_object>::get_last(v5);
while ( (unsigned long long)first < last )
{
if ( pfs_lock::is_populated(first, a2) )
{
a2 = (unsigned int *)first;
(*(void ( **)(unsigned int *, pfs_lock *))(*(_QWORD *)v7 + 16LL))(v7, first);
}
first = (pfs_lock *)((char *)first + 448);
}
}
result = i + 1;
}
return result;
}
| apply:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_00141cef:
CMP dword ptr [RBP + -0x14],0x400
JNC 0x00141d75
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00141d65
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00142080
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001420a0
MOV qword ptr [RBP + -0x30],RAX
LAB_00141d2c:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00141d63
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x00138ea0
TEST AL,0x1
JNZ 0x00141d45
JMP 0x00141d53
LAB_00141d45:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x10]
LAB_00141d53:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1c0
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00141d2c
LAB_00141d63:
JMP 0x00141d65
LAB_00141d65:
JMP 0x00141d67
LAB_00141d67:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x00141cef
LAB_00141d75:
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_setup_object, 128, 1024,
PFS_buffer_default_array<PFS_setup_object>, PFS_buffer_default_allocator<PFS_setup_object>
>::apply(PFS_buffer_processor<PFS_setup_object>&) */
void __thiscall
PFS_buffer_scalable_container<PFS_setup_object,128,1024,PFS_buffer_default_array<PFS_setup_object>,PFS_buffer_default_allocator<PFS_setup_object>>
::apply(PFS_buffer_scalable_container<PFS_setup_object,128,1024,PFS_buffer_default_array<PFS_setup_object>,PFS_buffer_default_allocator<PFS_setup_object>>
*this,PFS_buffer_processor *param_1)
{
PFS_buffer_default_array<PFS_setup_object> *this_00;
pfs_lock *ppVar1;
ulong uVar2;
pfs_lock *local_30;
uint local_1c;
for (local_1c = 0; local_1c < 0x400; local_1c = local_1c + 1) {
this_00 = *(PFS_buffer_default_array<PFS_setup_object> **)(this + (ulong)local_1c * 8 + 0xa8);
if (this_00 != (PFS_buffer_default_array<PFS_setup_object> *)0x0) {
local_30 = (pfs_lock *)PFS_buffer_default_array<PFS_setup_object>::get_first(this_00);
ppVar1 = (pfs_lock *)PFS_buffer_default_array<PFS_setup_object>::get_last(this_00);
for (; local_30 < ppVar1; local_30 = local_30 + 0x1c0) {
uVar2 = pfs_lock::is_populated(local_30);
if ((uVar2 & 1) != 0) {
(**(code **)(*(long *)param_1 + 0x10))(param_1,local_30);
}
}
}
}
return;
}
| |
24,913 | minja::ElifTemplateToken::ElifTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) | monkey531[P]llama/common/minja.hpp | ElifTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && c) : TemplateToken(Type::Elif, location, pre, post), condition(std::move(c)) {} | O2 | cpp | minja::ElifTemplateToken::ElifTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::Expression>&&):
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r14
pushq $0x4
popq %rsi
callq 0x3b6fe
leaq 0x7c00d(%rip), %rax # 0xcfb88
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x38(%r14)
movups (%rbx), %xmm0
andq $0x0, 0x8(%rbx)
movups %xmm0, 0x30(%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5minja17ElifTemplateTokenC2ERKNS_8LocationENS_13SpaceHandlingES4_OSt10shared_ptrINS_10ExpressionEE:
push r14
push rbx
push rax
mov rbx, r8
mov r8d, ecx
mov ecx, edx
mov rdx, rsi
mov r14, rdi
push 4
pop rsi
call _ZN5minja13TemplateTokenC2ENS0_4TypeERKNS_8LocationENS_13SpaceHandlingES5_; minja::TemplateToken::TemplateToken(minja::TemplateToken::Type,minja::Location const&,minja::SpaceHandling,minja::SpaceHandling)
lea rax, _ZTVN5minja17ElifTemplateTokenE; `vtable for'minja::ElifTemplateToken
add rax, 10h
mov [r14], rax
and qword ptr [r14+38h], 0
movups xmm0, xmmword ptr [rbx]
and qword ptr [rbx+8], 0
movups xmmword ptr [r14+30h], xmm0
and qword ptr [rbx], 0
add rsp, 8
pop rbx
pop r14
retn
| long long * minja::ElifTemplateToken::ElifTemplateToken(long long a1, long long a2, int a3, int a4, __int128 *a5)
{
long long *result; // rax
__int128 v7; // xmm0
minja::TemplateToken::TemplateToken(a1, 4, a2, a3, a4);
result = &`vtable for'minja::ElifTemplateToken + 2;
*(_QWORD *)a1 = &`vtable for'minja::ElifTemplateToken + 2;
*(_QWORD *)(a1 + 56) = 0LL;
v7 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 48) = v7;
*(_QWORD *)a5 = 0LL;
return result;
}
| ElifTemplateToken:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,R8
MOV R8D,ECX
MOV ECX,EDX
MOV RDX,RSI
MOV R14,RDI
PUSH 0x4
POP RSI
CALL 0x0013b6fe
LEA RAX,[0x1cfb88]
ADD RAX,0x10
MOV qword ptr [R14],RAX
AND qword ptr [R14 + 0x38],0x0
MOVUPS XMM0,xmmword ptr [RBX]
AND qword ptr [RBX + 0x8],0x0
MOVUPS xmmword ptr [R14 + 0x30],XMM0
AND qword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::ElifTemplateToken::ElifTemplateToken(minja::Location const&, minja::SpaceHandling,
minja::SpaceHandling, std::shared_ptr<minja::Expression>&&) */
void __thiscall
minja::ElifTemplateToken::ElifTemplateToken
(ElifTemplateToken *this,int8 param_1,int4 param_3,int4 param_4,
int8 *param_5)
{
int8 uVar1;
TemplateToken::TemplateToken((TemplateToken *)this,4,param_1,param_3,param_4);
*(int ***)this = &PTR__ElifTemplateToken_001cfb98;
*(int8 *)(this + 0x38) = 0;
uVar1 = param_5[1];
param_5[1] = 0;
*(int8 *)(this + 0x30) = *param_5;
*(int8 *)(this + 0x38) = uVar1;
*param_5 = 0;
return;
}
| |
24,914 | my_charset_is_ascii_compatible | eloqsql/strings/ctype-simple.c | static my_bool
my_charset_is_ascii_compatible(CHARSET_INFO *cs)
{
uint i;
if (!cs->tab_to_uni)
return 1;
for (i= 0; i < 128; i++)
{
if (cs->tab_to_uni[i] != i)
return 0;
}
return 1;
} | O0 | c | my_charset_is_ascii_compatible:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x7a089
movb $0x1, -0x1(%rbp)
jmp 0x7a0c4
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jae 0x7a0c0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movl -0x14(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
cmpl -0x14(%rbp), %eax
je 0x7a0b3
movb $0x0, -0x1(%rbp)
jmp 0x7a0c4
jmp 0x7a0b5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7a090
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
| my_charset_is_ascii_compatible:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp qword ptr [rax+68h], 0
jnz short loc_7A089
mov [rbp+var_1], 1
jmp short loc_7A0C4
loc_7A089:
mov [rbp+var_14], 0
loc_7A090:
cmp [rbp+var_14], 80h
jnb short loc_7A0C0
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov ecx, [rbp+var_14]
movzx eax, word ptr [rax+rcx*2]
cmp eax, [rbp+var_14]
jz short loc_7A0B3
mov [rbp+var_1], 0
jmp short loc_7A0C4
loc_7A0B3:
jmp short $+2
loc_7A0B5:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp short loc_7A090
loc_7A0C0:
mov [rbp+var_1], 1
loc_7A0C4:
mov al, [rbp+var_1]
pop rbp
retn
| char my_charset_is_ascii_compatible(long long a1)
{
unsigned int i; // [rsp+0h] [rbp-14h]
if ( !*(_QWORD *)(a1 + 104) )
return 1;
for ( i = 0; i < 0x80; ++i )
{
if ( *(unsigned __int16 *)(*(_QWORD *)(a1 + 104) + 2LL * i) != i )
return 0;
}
return 1;
}
| my_charset_is_ascii_compatible:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x68],0x0
JNZ 0x0017a089
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0017a0c4
LAB_0017a089:
MOV dword ptr [RBP + -0x14],0x0
LAB_0017a090:
CMP dword ptr [RBP + -0x14],0x80
JNC 0x0017a0c0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV ECX,dword ptr [RBP + -0x14]
MOVZX EAX,word ptr [RAX + RCX*0x2]
CMP EAX,dword ptr [RBP + -0x14]
JZ 0x0017a0b3
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017a0c4
LAB_0017a0b3:
JMP 0x0017a0b5
LAB_0017a0b5:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0017a090
LAB_0017a0c0:
MOV byte ptr [RBP + -0x1],0x1
LAB_0017a0c4:
MOV AL,byte ptr [RBP + -0x1]
POP RBP
RET
|
int1 my_charset_is_ascii_compatible(long param_1)
{
uint local_1c;
if (*(long *)(param_1 + 0x68) != 0) {
for (local_1c = 0; local_1c < 0x80; local_1c = local_1c + 1) {
if (*(ushort *)(*(long *)(param_1 + 0x68) + (ulong)local_1c * 2) != local_1c) {
return 0;
}
}
}
return 1;
}
| |
24,915 | get_dynamic | eloqsql/mysys/array.c | void get_dynamic(DYNAMIC_ARRAY *array, void *element, uint idx)
{
if (idx >= array->elements)
{
DBUG_PRINT("warning",("To big array idx: %d, array size is %d",
idx,array->elements));
bzero(element,array->size_of_element);
return;
}
memcpy(element,array->buffer+idx*array->size_of_element,
(size_t) array->size_of_element);
} | O0 | c | get_dynamic:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0xdc099
jmp 0xdc081
jmp 0xdc083
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2c0
jmp 0xdc0c2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x14(%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %edx
callq 0x2a0b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| get_dynamic:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
cmp eax, [rcx+8]
jb short loc_DC099
jmp short $+2
loc_DC081:
jmp short $+2
loc_DC083:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov edx, eax
xor esi, esi
call _memset
jmp short loc_DC0C2
loc_DC099:
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax]
mov eax, [rbp+var_14]
mov rcx, [rbp+var_8]
imul eax, [rcx+14h]
mov eax, eax
add rsi, rax
mov rax, [rbp+var_8]
mov eax, [rax+14h]
mov edx, eax
call _memcpy
loc_DC0C2:
add rsp, 20h
pop rbp
retn
| long long get_dynamic(long long a1, long long a2, unsigned int a3)
{
if ( a3 < *(_DWORD *)(a1 + 8) )
return memcpy(a2, *(_DWORD *)(a1 + 20) * a3 + *(_QWORD *)a1, *(unsigned int *)(a1 + 20));
else
return memset(a2, 0LL, *(unsigned int *)(a1 + 20));
}
| get_dynamic:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x8]
JC 0x001dc099
JMP 0x001dc081
LAB_001dc081:
JMP 0x001dc083
LAB_001dc083:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2c0
JMP 0x001dc0c2
LAB_001dc099:
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x14]
MOV RCX,qword ptr [RBP + -0x8]
IMUL EAX,dword ptr [RCX + 0x14]
MOV EAX,EAX
ADD RSI,RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x14]
MOV EDX,EAX
CALL 0x0012a0b0
LAB_001dc0c2:
ADD RSP,0x20
POP RBP
RET
|
void get_dynamic(long *param_1,void *param_2,uint param_3)
{
if (param_3 < *(uint *)(param_1 + 1)) {
memcpy(param_2,(void *)(*param_1 + (ulong)(param_3 * *(int *)((long)param_1 + 0x14))),
(ulong)*(uint *)((long)param_1 + 0x14));
}
else {
memset(param_2,0,(ulong)*(uint *)((long)param_1 + 0x14));
}
return;
}
| |
24,916 | string_from[abi:cxx11](bool) | monkey531[P]llama/common/common.cpp | std::string string_from(bool value) {
return value ? "true" : "false";
} | O3 | cpp | string_from[abi:cxx11](bool):
pushq %rbx
movq %rdi, %rbx
leaq 0x73f8b(%rip), %rcx # 0xe5bea
leaq 0x76c6d(%rip), %rax # 0xe88d3
testl %esi, %esi
cmovneq %rcx, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movl %esi, %edx
xorq $0x5, %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x214e2
movq %rbx, %rax
popq %rbx
retq
| _Z11string_fromB5cxx11b:
push rbx
mov rbx, rdi
lea rcx, aTrue; "true"
lea rax, aAdvancedOption+0ABh; "false"
test esi, esi
cmovnz rax, rcx
lea rcx, [rdi+10h]
mov [rdi], rcx
mov edx, esi
xor rdx, 5
add rdx, rax
mov rsi, rax
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 rax, rbx
pop rbx
retn
| _QWORD * string_from[abi:cxx11](_QWORD *a1, unsigned int a2)
{
char *v2; // rax
v2 = "false";
if ( a2 )
v2 = "true";
*a1 = a1 + 2;
std::string::_M_construct<char const*>((long long)a1, v2, (long long)&v2[a2 ^ 5LL]);
return a1;
}
| string_from[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
LEA RCX,[0x1e5bea]
LEA RAX,[0x1e88d3]
TEST ESI,ESI
CMOVNZ RAX,RCX
LEA RCX,[RDI + 0x10]
MOV qword ptr [RDI],RCX
MOV EDX,ESI
XOR RDX,0x5
ADD RDX,RAX
MOV RSI,RAX
CALL 0x001214e2
MOV RAX,RBX
POP RBX
RET
|
/* string_from[abi:cxx11](bool) */
int8 string_from_abi_cxx11_(bool param_1)
{
char *pcVar1;
uint in_ESI;
int7 in_register_00000039;
pcVar1 = "false";
if (in_ESI != 0) {
pcVar1 = "true";
}
*(long *)CONCAT71(in_register_00000039,param_1) = CONCAT71(in_register_00000039,param_1) + 0x10;
std::__cxx11::string::_M_construct<char_const*>(param_1,pcVar1,pcVar1 + ((ulong)in_ESI ^ 5));
return CONCAT71(in_register_00000039,param_1);
}
| |
24,917 | minja::CommentTemplateToken::~CommentTemplateToken() | monkey531[P]llama/common/minja.hpp | CommentTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, const std::string& t) : TemplateToken(Type::Comment, location, pre, post), text(t) {} | O1 | cpp | minja::CommentTemplateToken::~CommentTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x9ffc5(%rip), %rax # 0xdc180
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x30(%rdi), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x3c1da
movq (%rax), %rsi
incq %rsi
callq 0x186a0
leaq 0x9ffe7(%rip), %rax # 0xdc1c8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x3c1f6
callq 0x2fb64
movl $0x50, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x186a0
| _ZN5minja20CommentTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja20CommentTemplateTokenE; `vtable for'minja::CommentTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+30h]; void *
lea rax, [rbx+40h]
cmp rdi, rax
jz short loc_3C1DA
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3C1DA:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_3C1F6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3C1F6:
mov esi, 50h ; 'P'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::CommentTemplateToken::~CommentTemplateToken(minja::CommentTemplateToken *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::CommentTemplateToken + 2;
v2 = (char *)*((_QWORD *)this + 6);
if ( v2 != (char *)this + 64 )
operator delete(v2, *((_QWORD *)this + 8) + 1LL);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x50uLL);
}
| ~CommentTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1dc180]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x30]
LEA RAX,[RBX + 0x40]
CMP RDI,RAX
JZ 0x0013c1da
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x001186a0
LAB_0013c1da:
LEA RAX,[0x1dc1c8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0013c1f6
CALL 0x0012fb64
LAB_0013c1f6:
MOV ESI,0x50
MOV RDI,RBX
POP RBX
JMP 0x001186a0
|
/* minja::CommentTemplateToken::~CommentTemplateToken() */
void __thiscall minja::CommentTemplateToken::~CommentTemplateToken(CommentTemplateToken *this)
{
*(int ***)this = &PTR__CommentTemplateToken_001dc190;
if (*(CommentTemplateToken **)(this + 0x30) != this + 0x40) {
operator_delete(*(CommentTemplateToken **)(this + 0x30),*(long *)(this + 0x40) + 1);
}
*(int ***)this = &PTR__TemplateToken_001dc1d8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x50);
return;
}
| |
24,918 | link_to_changed_list | eloqsql/mysys/mf_keycache.c | static void link_to_changed_list(SIMPLE_KEY_CACHE_CB *keycache,
BLOCK_LINK *block)
{
DBUG_ASSERT(block->status & BLOCK_IN_USE);
DBUG_ASSERT(!(block->status & BLOCK_CHANGED));
DBUG_ASSERT(block->hash_link && block->hash_link->block == block);
unlink_changed(block);
link_changed(block,
&keycache->changed_blocks[FILE_HASH(block->hash_link->file, keycache)]);
block->status|=BLOCK_CHANGED;
keycache->blocks_changed++;
keycache->global_blocks_changed++;
} | O0 | c | link_to_changed_list:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xebed2
jmp 0xebed4
jmp 0xebed6
jmp 0xebed8
jmp 0xebeda
movq -0x10(%rbp), %rdi
callq 0xe9890
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rsi
callq 0xe9af0
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x138(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x138(%rax)
addq $0x10, %rsp
popq %rbp
retq
| link_to_changed_list_0:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_EBED2:
jmp short $+2
loc_EBED4:
jmp short $+2
loc_EBED6:
jmp short $+2
loc_EBED8:
jmp short $+2
loc_EBEDA:
mov rdi, [rbp+var_10]
call unlink_changed_0
mov rdi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rsi, [rax+128h]
mov rax, [rbp+var_10]
mov rax, [rax+20h]
mov eax, [rax+18h]
mov rcx, [rbp+var_8]
mov ecx, [rcx+3Ch]
sub ecx, 1
and eax, ecx
mov eax, eax
shl rax, 3
add rsi, rax
call link_changed_0
mov rax, [rbp+var_10]
mov ecx, [rax+50h]
or ecx, 20h
mov [rax+50h], ecx
mov rax, [rbp+var_8]
mov rcx, [rax+60h]
add rcx, 1
mov [rax+60h], rcx
mov rax, [rbp+var_8]
mov rcx, [rax+138h]
add rcx, 1
mov [rax+138h], rcx
add rsp, 10h
pop rbp
retn
| long long link_to_changed_list_0(long long a1, long long a2)
{
long long result; // rax
unlink_changed_0(a2);
link_changed_0(
a2,
(long long *)(8LL * ((unsigned int)(*(_DWORD *)(a1 + 60) - 1) & *(_DWORD *)(*(_QWORD *)(a2 + 32) + 24LL))
+ *(_QWORD *)(a1 + 296)));
*(_DWORD *)(a2 + 80) |= 0x20u;
++*(_QWORD *)(a1 + 96);
result = a1;
++*(_QWORD *)(a1 + 312);
return result;
}
| link_to_changed_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x001ebed2
LAB_001ebed2:
JMP 0x001ebed4
LAB_001ebed4:
JMP 0x001ebed6
LAB_001ebed6:
JMP 0x001ebed8
LAB_001ebed8:
JMP 0x001ebeda
LAB_001ebeda:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e9890
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX + 0x128]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV EAX,dword ptr [RAX + 0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x3c]
SUB ECX,0x1
AND EAX,ECX
MOV EAX,EAX
SHL RAX,0x3
ADD RSI,RAX
CALL 0x001e9af0
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x50]
OR ECX,0x20
MOV dword ptr [RAX + 0x50],ECX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x60]
ADD RCX,0x1
MOV qword ptr [RAX + 0x60],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX + 0x138]
ADD RCX,0x1
MOV qword ptr [RAX + 0x138],RCX
ADD RSP,0x10
POP RBP
RET
|
void link_to_changed_list(long param_1,long param_2)
{
unlink_changed(param_2);
link_changed(param_2,*(long *)(param_1 + 0x128) +
(ulong)(*(uint *)(*(long *)(param_2 + 0x20) + 0x18) &
*(int *)(param_1 + 0x3c) - 1U) * 8);
*(uint *)(param_2 + 0x50) = *(uint *)(param_2 + 0x50) | 0x20;
*(long *)(param_1 + 0x60) = *(long *)(param_1 + 0x60) + 1;
*(long *)(param_1 + 0x138) = *(long *)(param_1 + 0x138) + 1;
return;
}
| |
24,919 | lo0bits | eloqsql/libmariadb/libmariadb/ma_dtoa.c | static int lo0bits(ULong *y)
{
register int k;
register ULong x= *y;
if (x & 7)
{
if (x & 1)
return 0;
if (x & 2)
{
*y= x >> 1;
return 1;
}
*y= x >> 2;
return 2;
}
k= 0;
if (!(x & 0xffff))
{
k= 16;
x>>= 16;
}
if (!(x & 0xff))
{
k+= 8;
x>>= 8;
}
if (!(x & 0xf))
{
k+= 4;
x>>= 4;
}
if (!(x & 0x3))
{
k+= 2;
x>>= 2;
}
if (!(x & 1))
{
k++;
x>>= 1;
if (!x)
return 32;
}
*y= x;
return k;
} | O0 | c | lo0bits:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x7, %eax
cmpl $0x0, %eax
je 0x3a2ad
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3a273
movl $0x0, -0x4(%rbp)
jmp 0x3a366
movl -0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3a295
movl -0x18(%rbp), %ecx
shrl %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3a366
movl -0x18(%rbp), %ecx
shrl $0x2, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x3a366
movl $0x0, -0x14(%rbp)
movl -0x18(%rbp), %eax
andl $0xffff, %eax # imm = 0xFFFF
cmpl $0x0, %eax
jne 0x3a2d1
movl $0x10, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x10, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x3a2f0
movl -0x14(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x3a30d
movl -0x14(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x4, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x3a32a
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x3a357
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x3a355
movl $0x20, -0x4(%rbp)
jmp 0x3a366
jmp 0x3a357
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| lo0bits:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov eax, [rax]
mov [rbp+var_18], eax
mov eax, [rbp+var_18]
and eax, 7
cmp eax, 0
jz short loc_3A2AD
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jz short loc_3A273
mov [rbp+var_4], 0
jmp loc_3A366
loc_3A273:
mov eax, [rbp+var_18]
and eax, 2
cmp eax, 0
jz short loc_3A295
mov ecx, [rbp+var_18]
shr ecx, 1
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 1
jmp loc_3A366
loc_3A295:
mov ecx, [rbp+var_18]
shr ecx, 2
mov rax, [rbp+var_10]
mov [rax], ecx
mov [rbp+var_4], 2
jmp loc_3A366
loc_3A2AD:
mov [rbp+var_14], 0
mov eax, [rbp+var_18]
and eax, 0FFFFh
cmp eax, 0
jnz short loc_3A2D1
mov [rbp+var_14], 10h
mov eax, [rbp+var_18]
shr eax, 10h
mov [rbp+var_18], eax
loc_3A2D1:
mov eax, [rbp+var_18]
and eax, 0FFh
cmp eax, 0
jnz short loc_3A2F0
mov eax, [rbp+var_14]
add eax, 8
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 8
mov [rbp+var_18], eax
loc_3A2F0:
mov eax, [rbp+var_18]
and eax, 0Fh
cmp eax, 0
jnz short loc_3A30D
mov eax, [rbp+var_14]
add eax, 4
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 4
mov [rbp+var_18], eax
loc_3A30D:
mov eax, [rbp+var_18]
and eax, 3
cmp eax, 0
jnz short loc_3A32A
mov eax, [rbp+var_14]
add eax, 2
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 2
mov [rbp+var_18], eax
loc_3A32A:
mov eax, [rbp+var_18]
and eax, 1
cmp eax, 0
jnz short loc_3A357
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
mov eax, [rbp+var_18]
shr eax, 1
mov [rbp+var_18], eax
cmp [rbp+var_18], 0
jnz short loc_3A355
mov [rbp+var_4], 20h ; ' '
jmp short loc_3A366
loc_3A355:
jmp short $+2
loc_3A357:
mov ecx, [rbp+var_18]
mov rax, [rbp+var_10]
mov [rax], ecx
mov eax, [rbp+var_14]
mov [rbp+var_4], eax
loc_3A366:
mov eax, [rbp+var_4]
pop rbp
retn
| long long lo0bits(unsigned int *a1)
{
unsigned int v2; // [rsp+0h] [rbp-18h]
unsigned int v3; // [rsp+4h] [rbp-14h]
v2 = *a1;
if ( (*a1 & 7) != 0 )
{
if ( (v2 & 1) != 0 )
{
return 0;
}
else if ( (v2 & 2) != 0 )
{
*a1 = v2 >> 1;
return 1;
}
else
{
*a1 = v2 >> 2;
return 2;
}
}
else
{
v3 = 0;
if ( !(_WORD)v2 )
{
v3 = 16;
v2 >>= 16;
}
if ( !(_BYTE)v2 )
{
v3 += 8;
v2 >>= 8;
}
if ( (v2 & 0xF) == 0 )
{
v3 += 4;
v2 >>= 4;
}
if ( (v2 & 3) == 0 )
{
v3 += 2;
v2 >>= 2;
}
if ( (v2 & 1) != 0 || (++v3, (v2 >>= 1) != 0) )
{
*a1 = v2;
return v3;
}
else
{
return 32;
}
}
}
| lo0bits:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x18],EAX
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x7
CMP EAX,0x0
JZ 0x0013a2ad
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0013a273
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013a366
LAB_0013a273:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x2
CMP EAX,0x0
JZ 0x0013a295
MOV ECX,dword ptr [RBP + -0x18]
SHR ECX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013a366
LAB_0013a295:
MOV ECX,dword ptr [RBP + -0x18]
SHR ECX,0x2
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0013a366
LAB_0013a2ad:
MOV dword ptr [RBP + -0x14],0x0
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xffff
CMP EAX,0x0
JNZ 0x0013a2d1
MOV dword ptr [RBP + -0x14],0x10
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x10
MOV dword ptr [RBP + -0x18],EAX
LAB_0013a2d1:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xff
CMP EAX,0x0
JNZ 0x0013a2f0
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x8
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x8
MOV dword ptr [RBP + -0x18],EAX
LAB_0013a2f0:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0xf
CMP EAX,0x0
JNZ 0x0013a30d
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x4
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x4
MOV dword ptr [RBP + -0x18],EAX
LAB_0013a30d:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x3
CMP EAX,0x0
JNZ 0x0013a32a
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x2
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x2
MOV dword ptr [RBP + -0x18],EAX
LAB_0013a32a:
MOV EAX,dword ptr [RBP + -0x18]
AND EAX,0x1
CMP EAX,0x0
JNZ 0x0013a357
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x18]
SHR EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
CMP dword ptr [RBP + -0x18],0x0
JNZ 0x0013a355
MOV dword ptr [RBP + -0x4],0x20
JMP 0x0013a366
LAB_0013a355:
JMP 0x0013a357
LAB_0013a357:
MOV ECX,dword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x4],EAX
LAB_0013a366:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int lo0bits(uint *param_1)
{
uint local_20;
int local_1c;
int local_c;
local_20 = *param_1;
if ((local_20 & 7) == 0) {
local_1c = 0;
if ((local_20 & 0xffff) == 0) {
local_1c = 0x10;
local_20 = local_20 >> 0x10;
}
if ((local_20 & 0xff) == 0) {
local_1c = local_1c + 8;
local_20 = local_20 >> 8;
}
if ((local_20 & 0xf) == 0) {
local_1c = local_1c + 4;
local_20 = local_20 >> 4;
}
if ((local_20 & 3) == 0) {
local_1c = local_1c + 2;
local_20 = local_20 >> 2;
}
if ((local_20 & 1) == 0) {
local_1c = local_1c + 1;
local_20 = local_20 >> 1;
if (local_20 == 0) {
return 0x20;
}
}
*param_1 = local_20;
local_c = local_1c;
}
else if ((local_20 & 1) == 0) {
if ((local_20 & 2) == 0) {
*param_1 = local_20 >> 2;
local_c = 2;
}
else {
*param_1 = local_20 >> 1;
local_c = 1;
}
}
else {
local_c = 0;
}
return local_c;
}
| |
24,920 | JS_PromiseResult | bluesky950520[P]quickjs/quickjs.c | JSValue JS_PromiseResult(JSContext *ctx, JSValue promise)
{
JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
if (!s)
return JS_UNDEFINED;
return JS_DupValue(ctx, s->promise_result);
} | O1 | c | JS_PromiseResult:
movq %rsi, -0x8(%rsp)
cmpl $-0x1, %edx
jne 0x3627e
movq -0x8(%rsp), %rax
cmpw $0x31, 0x6(%rax)
jne 0x3627e
movq 0x30(%rax), %rcx
jmp 0x36280
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x3629f
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rdx
movq %rax, -0x8(%rsp)
cmpl $-0x9, %edx
jb 0x3629e
movq -0x8(%rsp), %rcx
incl (%rcx)
retq
movl $0x3, %edx
xorl %eax, %eax
retq
| JS_PromiseResult:
mov [rsp+var_8], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_3627E
mov rax, [rsp+var_8]
cmp word ptr [rax+6], 31h ; '1'
jnz short loc_3627E
mov rcx, [rax+30h]
jmp short loc_36280
loc_3627E:
xor ecx, ecx
loc_36280:
test rcx, rcx
jz short loc_3629F
mov rax, [rcx+30h]
mov rdx, [rcx+38h]
mov [rsp+var_8], rax
cmp edx, 0FFFFFFF7h
jb short locret_3629E
mov rcx, [rsp+var_8]
inc dword ptr [rcx]
locret_3629E:
retn
loc_3629F:
mov edx, 3
xor eax, eax
retn
| long long JS_PromiseResult(long long a1, long long a2, int a3)
{
long long v3; // rcx
long long result; // rax
if ( a3 == -1 && *(_WORD *)(a2 + 6) == 49 )
v3 = *(_QWORD *)(a2 + 48);
else
v3 = 0LL;
if ( !v3 )
return 0LL;
result = *(_QWORD *)(v3 + 48);
if ( (unsigned int)*(_QWORD *)(v3 + 56) >= 0xFFFFFFF7 )
++**(_DWORD **)(v3 + 48);
return result;
}
| |||
24,921 | JS_PromiseResult | bluesky950520[P]quickjs/quickjs.c | JSValue JS_PromiseResult(JSContext *ctx, JSValue promise)
{
JSPromiseData *s = JS_GetOpaque(promise, JS_CLASS_PROMISE);
if (!s)
return JS_UNDEFINED;
return JS_DupValue(ctx, s->promise_result);
} | O2 | c | JS_PromiseResult:
movq %rdx, %rax
pushq $0x3
popq %rdx
cmpl $-0x1, %eax
jne 0x2f95e
cmpw $0x31, 0x6(%rsi)
jne 0x2f95e
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x2f95e
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rdx
cmpl $-0x9, %edx
jb 0x2f960
incl (%rax)
retq
xorl %eax, %eax
retq
| JS_PromiseResult:
mov rax, rdx
push 3
pop rdx
cmp eax, 0FFFFFFFFh
jnz short loc_2F95E
cmp word ptr [rsi+6], 31h ; '1'
jnz short loc_2F95E
mov rcx, [rsi+30h]
test rcx, rcx
jz short loc_2F95E
mov rax, [rcx+30h]
mov rdx, [rcx+38h]
cmp edx, 0FFFFFFF7h
jb short locret_2F960
inc dword ptr [rax]
retn
loc_2F95E:
xor eax, eax
locret_2F960:
retn
| _DWORD * JS_PromiseResult(long long a1, long long a2, int a3)
{
long long v3; // rcx
_DWORD *result; // rax
if ( a3 != -1 )
return 0LL;
if ( *(_WORD *)(a2 + 6) != 49 )
return 0LL;
v3 = *(_QWORD *)(a2 + 48);
if ( !v3 )
return 0LL;
result = *(_DWORD **)(v3 + 48);
if ( (unsigned int)*(_QWORD *)(v3 + 56) >= 0xFFFFFFF7 )
++*result;
return result;
}
| JS_PromiseResult:
MOV RAX,RDX
PUSH 0x3
POP RDX
CMP EAX,-0x1
JNZ 0x0012f95e
CMP word ptr [RSI + 0x6],0x31
JNZ 0x0012f95e
MOV RCX,qword ptr [RSI + 0x30]
TEST RCX,RCX
JZ 0x0012f95e
MOV RAX,qword ptr [RCX + 0x30]
MOV RDX,qword ptr [RCX + 0x38]
CMP EDX,-0x9
JC 0x0012f960
INC dword ptr [RAX]
RET
LAB_0012f95e:
XOR EAX,EAX
LAB_0012f960:
RET
|
int1 [16] JS_PromiseResult(int8 param_1,long param_2,int param_3)
{
long lVar1;
int *piVar2;
int1 auVar4 [16];
int8 uVar3;
uVar3 = 3;
if (((param_3 == -1) && (*(short *)(param_2 + 6) == 0x31)) &&
(lVar1 = *(long *)(param_2 + 0x30), lVar1 != 0)) {
piVar2 = *(int **)*(int1 (*) [16])(lVar1 + 0x30);
uVar3 = *(int8 *)(lVar1 + 0x38);
auVar4 = *(int1 (*) [16])(lVar1 + 0x30);
if (0xfffffff6 < (uint)uVar3) {
*piVar2 = *piVar2 + 1;
return auVar4;
}
}
else {
piVar2 = (int *)0x0;
}
auVar4._8_8_ = uVar3;
auVar4._0_8_ = piVar2;
return auVar4;
}
| |
24,922 | ma_row_pos_from_key | eloqsql/storage/maria/ma_search.c | MARIA_RECORD_POS _ma_row_pos_from_key(const MARIA_KEY *key)
{
my_off_t pos;
const uchar *after_key= key->data + key->data_length;
MARIA_SHARE *share= key->keyinfo->share;
switch (share->rec_reflength) {
#if SIZEOF_OFF_T > 4
case 8: pos= (my_off_t) mi_uint8korr(after_key); break;
case 7: pos= (my_off_t) mi_uint7korr(after_key); break;
case 6: pos= (my_off_t) mi_uint6korr(after_key); break;
case 5: pos= (my_off_t) mi_uint5korr(after_key); break;
#else
case 8: pos= (my_off_t) mi_uint4korr(after_key+4); break;
case 7: pos= (my_off_t) mi_uint4korr(after_key+3); break;
case 6: pos= (my_off_t) mi_uint4korr(after_key+2); break;
case 5: pos= (my_off_t) mi_uint4korr(after_key+1); break;
#endif
case 4: pos= (my_off_t) mi_uint4korr(after_key); break;
case 3: pos= (my_off_t) mi_uint3korr(after_key); break;
case 2: pos= (my_off_t) mi_uint2korr(after_key); break;
case 0: /* NO_RECORD */
default:
pos=0L; /* Shut compiler up */
}
return (*share->keypos_to_recpos)(share, pos);
} | O3 | c | ma_row_pos_from_key:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq 0x8(%rdi), %rcx
movq (%rcx), %rdi
movl 0x740(%rdi), %edx
addl $-0x2, %edx
cmpl $0x6, %edx
ja 0x393f6
movq (%rax), %rcx
movl 0x10(%rax), %eax
leaq 0xa9cd7(%rip), %rsi # 0xe308c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movzwl (%rcx,%rax), %eax
rolw $0x8, %ax
movzwl %ax, %esi
jmp 0x3943a
movl (%rcx,%rax), %esi
movzwl 0x4(%rcx,%rax), %eax
shlq $0x30, %rax
shlq $0x10, %rsi
jmp 0x3942e
movl (%rcx,%rax), %esi
bswapl %esi
jmp 0x3943a
movl (%rcx,%rax), %esi
movzbl 0x4(%rcx,%rax), %eax
shlq $0x38, %rax
shlq $0x18, %rsi
jmp 0x3942e
xorl %esi, %esi
jmp 0x3943a
movzwl 0x1(%rcx,%rax), %edx
rolw $0x8, %dx
movzwl %dx, %edx
movzbl (%rcx,%rax), %esi
shll $0x10, %esi
orq %rdx, %rsi
jmp 0x3943a
movl (%rcx,%rax), %esi
movzwl 0x4(%rcx,%rax), %edx
movzbl 0x6(%rcx,%rax), %eax
shlq $0x38, %rax
shlq $0x28, %rdx
shlq $0x8, %rsi
orq %rdx, %rsi
orq %rax, %rsi
jmp 0x39437
movq (%rcx,%rax), %rsi
bswapq %rsi
movq 0x6c8(%rdi), %rax
popq %rbp
jmpq *%rax
| _ma_row_pos_from_key:
push rbp
mov rbp, rsp
mov rax, rdi
mov rcx, [rdi+8]
mov rdi, [rcx]
mov edx, [rdi+740h]
add edx, 0FFFFFFFEh; switch 7 cases
cmp edx, 6
ja short def_393BC; jumptable 00000000000393BC default case
mov rcx, [rax]
mov eax, [rax+10h]
lea rsi, jpt_393BC
movsxd rdx, ds:(jpt_393BC - 0E308Ch)[rsi+rdx*4]
add rdx, rsi
jmp rdx; switch jump
loc_393BE:
movzx eax, word ptr [rcx+rax]; jumptable 00000000000393BC case 2
rol ax, 8
movzx esi, ax
jmp short loc_3943A
loc_393CB:
mov esi, [rcx+rax]; jumptable 00000000000393BC case 6
movzx eax, word ptr [rcx+rax+4]
shl rax, 30h
shl rsi, 10h
jmp short loc_3942E
loc_393DD:
mov esi, [rcx+rax]; jumptable 00000000000393BC case 4
bswap esi
jmp short loc_3943A
loc_393E4:
mov esi, [rcx+rax]; jumptable 00000000000393BC case 5
movzx eax, byte ptr [rcx+rax+4]
shl rax, 38h
shl rsi, 18h
jmp short loc_3942E
def_393BC:
xor esi, esi; jumptable 00000000000393BC default case
jmp short loc_3943A
loc_393FA:
movzx edx, word ptr [rcx+rax+1]; jumptable 00000000000393BC case 3
rol dx, 8
movzx edx, dx
movzx esi, byte ptr [rcx+rax]
shl esi, 10h
or rsi, rdx
jmp short loc_3943A
loc_39412:
mov esi, [rcx+rax]; jumptable 00000000000393BC case 7
movzx edx, word ptr [rcx+rax+4]
movzx eax, byte ptr [rcx+rax+6]
shl rax, 38h
shl rdx, 28h
shl rsi, 8
or rsi, rdx
loc_3942E:
or rsi, rax
jmp short loc_39437
loc_39433:
mov rsi, [rcx+rax]; jumptable 00000000000393BC case 8
loc_39437:
bswap rsi
loc_3943A:
mov rax, [rdi+6C8h]
pop rbp
jmp rax
| long long ma_row_pos_from_key(long long *a1)
{
long long v2; // rdi
long long v3; // rcx
long long v4; // rax
unsigned long long v5; // rsi
long long v6; // rsi
unsigned long long v7; // rax
long long v8; // rsi
long long v9; // rsi
long long v10; // rsi
long long v11; // rdx
unsigned long long v12; // rsi
v2 = *(_QWORD *)a1[1];
v3 = *a1;
v4 = *((unsigned int *)a1 + 4);
switch ( *(_DWORD *)(v2 + 1856) )
{
case 2:
v5 = (unsigned __int16)__ROL2__(*(_WORD *)(v3 + v4), 8);
return (*(long long ( **)(long long, unsigned long long))(v2 + 1736))(v2, v5);
case 3:
v5 = (unsigned __int16)__ROL2__(*(_WORD *)(v3 + v4 + 1), 8) | (unsigned long long)(*(unsigned __int8 *)(v3 + v4) << 16);
return (*(long long ( **)(long long, unsigned long long))(v2 + 1736))(v2, v5);
case 4:
v5 = _byteswap_ulong(*(_DWORD *)(v3 + v4));
return (*(long long ( **)(long long, unsigned long long))(v2 + 1736))(v2, v5);
case 5:
v9 = *(unsigned int *)(v3 + v4);
v7 = (unsigned long long)*(unsigned __int8 *)(v3 + v4 + 4) << 56;
v8 = v9 << 24;
goto LABEL_9;
case 6:
v6 = *(unsigned int *)(v3 + v4);
v7 = (unsigned long long)*(unsigned __int16 *)(v3 + v4 + 4) << 48;
v8 = v6 << 16;
goto LABEL_9;
case 7:
v10 = *(unsigned int *)(v3 + v4);
v11 = *(unsigned __int16 *)(v3 + v4 + 4);
v7 = (unsigned long long)*(unsigned __int8 *)(v3 + v4 + 6) << 56;
v8 = (v11 << 40) | (v10 << 8);
LABEL_9:
v12 = v7 | v8;
goto LABEL_11;
case 8:
v12 = *(_QWORD *)(v3 + v4);
LABEL_11:
v5 = _byteswap_uint64(v12);
break;
default:
v5 = 0LL;
break;
}
return (*(long long ( **)(long long, unsigned long long))(v2 + 1736))(v2, v5);
}
| _ma_row_pos_from_key:
PUSH RBP
MOV RBP,RSP
MOV RAX,RDI
MOV RCX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RCX]
MOV EDX,dword ptr [RDI + 0x740]
ADD EDX,-0x2
CMP EDX,0x6
JA 0x001393f6
MOV RCX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
LEA RSI,[0x1e308c]
MOVSXD RDX,dword ptr [RSI + RDX*0x4]
ADD RDX,RSI
switchD:
JMP RDX
caseD_2:
MOVZX EAX,word ptr [RCX + RAX*0x1]
ROL AX,0x8
MOVZX ESI,AX
JMP 0x0013943a
caseD_6:
MOV ESI,dword ptr [RCX + RAX*0x1]
MOVZX EAX,word ptr [RCX + RAX*0x1 + 0x4]
SHL RAX,0x30
SHL RSI,0x10
JMP 0x0013942e
caseD_4:
MOV ESI,dword ptr [RCX + RAX*0x1]
BSWAP ESI
JMP 0x0013943a
caseD_5:
MOV ESI,dword ptr [RCX + RAX*0x1]
MOVZX EAX,byte ptr [RCX + RAX*0x1 + 0x4]
SHL RAX,0x38
SHL RSI,0x18
JMP 0x0013942e
LAB_001393f6:
XOR ESI,ESI
JMP 0x0013943a
caseD_3:
MOVZX EDX,word ptr [RCX + RAX*0x1 + 0x1]
ROL DX,0x8
MOVZX EDX,DX
MOVZX ESI,byte ptr [RCX + RAX*0x1]
SHL ESI,0x10
OR RSI,RDX
JMP 0x0013943a
caseD_7:
MOV ESI,dword ptr [RCX + RAX*0x1]
MOVZX EDX,word ptr [RCX + RAX*0x1 + 0x4]
MOVZX EAX,byte ptr [RCX + RAX*0x1 + 0x6]
SHL RAX,0x38
SHL RDX,0x28
SHL RSI,0x8
OR RSI,RDX
LAB_0013942e:
OR RSI,RAX
JMP 0x00139437
caseD_8:
MOV RSI,qword ptr [RCX + RAX*0x1]
LAB_00139437:
BSWAP RSI
LAB_0013943a:
MOV RAX,qword ptr [RDI + 0x6c8]
POP RBP
JMP RAX
|
void _ma_row_pos_from_key(long *param_1)
{
ushort uVar1;
uint uVar2;
long lVar3;
long lVar4;
ulong uVar5;
ulong uVar6;
lVar3 = *(long *)param_1[1];
if (6 < *(int *)(lVar3 + 0x740) - 2U) {
uVar6 = 0;
goto LAB_0013943a;
}
lVar4 = *param_1;
uVar6 = (ulong)*(uint *)(param_1 + 2);
switch(*(int *)(lVar3 + 0x740)) {
case 2:
uVar6 = (ulong)(ushort)(*(ushort *)(lVar4 + uVar6) << 8 | *(ushort *)(lVar4 + uVar6) >> 8);
goto LAB_0013943a;
case 3:
uVar1 = *(ushort *)(lVar4 + 1 + uVar6);
uVar6 = (ulong)CONCAT12(*(int1 *)(lVar4 + uVar6),uVar1 << 8 | uVar1 >> 8);
goto LAB_0013943a;
case 4:
uVar2 = *(uint *)(lVar4 + uVar6);
uVar6 = (ulong)(uVar2 >> 0x18 | (uVar2 & 0xff0000) >> 8 | (uVar2 & 0xff00) << 8 | uVar2 << 0x18)
;
goto LAB_0013943a;
case 5:
uVar5 = (ulong)*(byte *)(lVar4 + 4 + uVar6) << 0x38;
uVar6 = (ulong)*(uint *)(lVar4 + uVar6) << 0x18;
break;
case 6:
uVar5 = (ulong)*(ushort *)(lVar4 + 4 + uVar6) << 0x30;
uVar6 = (ulong)*(uint *)(lVar4 + uVar6) << 0x10;
break;
case 7:
uVar5 = (ulong)*(byte *)(lVar4 + 6 + uVar6) << 0x38;
uVar6 = (ulong)*(uint *)(lVar4 + uVar6) << 8 | (ulong)*(ushort *)(lVar4 + 4 + uVar6) << 0x28;
break;
case 8:
uVar6 = *(ulong *)(lVar4 + uVar6);
goto LAB_00139437;
}
uVar6 = uVar6 | uVar5;
LAB_00139437:
uVar6 = uVar6 >> 0x38 | (uVar6 & 0xff000000000000) >> 0x28 | (uVar6 & 0xff0000000000) >> 0x18 |
(uVar6 & 0xff00000000) >> 8 | (uVar6 & 0xff000000) << 8 | (uVar6 & 0xff0000) << 0x18 |
(uVar6 & 0xff00) << 0x28 | uVar6 << 0x38;
LAB_0013943a:
/* WARNING: Could not recover jumptable at 0x00139442. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(lVar3 + 0x6c8))(lVar3,uVar6);
return;
}
| |
24,923 | JS_GetIterator2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetIterator2(JSContext *ctx, JSValue obj,
JSValue method)
{
JSValue enum_obj;
enum_obj = JS_Call(ctx, method, obj, 0, NULL);
if (JS_IsException(enum_obj))
return enum_obj;
if (!JS_IsObject(enum_obj)) {
JS_FreeValue(ctx, enum_obj);
return JS_ThrowTypeErrorNotAnObject(ctx);
}
return enum_obj;
} | O1 | c | JS_GetIterator2:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rax
movq %rsi, %r9
movq %rdi, %rbx
movl $0x0, 0x28(%rsp)
movq $0x3, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x2, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x284ca
movq %rax, %r14
cmpl $-0x1, %edx
je 0x41af1
cmpl $0x6, %edx
je 0x41af1
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1d8c6
leaq 0x5d546(%rip), %rsi # 0x9f025
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %edx
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| JS_GetIterator2:
push r14
push rbx
sub rsp, 38h
mov rax, rdx
mov r9, rsi
mov rbx, rdi
mov dword ptr [rsp+48h+var_20], 0
mov qword ptr [rsp+48h+var_20+8], 3
movups xmm0, [rsp+48h+var_20]
movups [rsp+48h+var_48], xmm0
mov [rsp+48h+var_30], 2
mov [rsp+48h+var_38], 0
mov rsi, rcx
mov rdx, r8
mov rcx, r9
mov r8, rax
xor r9d, r9d
call JS_CallInternal
mov r14, rax
cmp edx, 0FFFFFFFFh
jz short loc_41AF1
cmp edx, 6
jz short loc_41AF1
mov rdi, [rbx+18h]
mov rsi, r14
call JS_FreeValueRT
lea rsi, aOperandPrototy+20h; "not an object"
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_41AF1:
mov rax, r14
add rsp, 38h
pop rbx
pop r14
retn
| _DWORD * JS_GetIterator2(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
double a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13)
{
_DWORD *v13; // rax
long long v14; // rdx
_DWORD *v15; // r14
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
char v23; // [rsp+0h] [rbp-48h]
__m128 v24; // [rsp+28h] [rbp-20h]
v24.m128_i32[0] = 0;
v24.m128_u64[1] = 3LL;
v13 = (_DWORD *)JS_CallInternal(
a1,
a4,
a5,
a2,
a3,
0LL,
v24,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
v24.m128_i8[0],
3,
0LL,
2u);
v15 = v13;
if ( (_DWORD)v14 != -1 && (_DWORD)v14 != 6 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v13, v14);
v15 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", v16, v17, v18, v19, v24, a7, a8, a9, v20, v21, a12, a13, v23);
}
return v15;
}
| JS_GetIterator2:
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV RAX,RDX
MOV R9,RSI
MOV RBX,RDI
MOV dword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x30],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x28]
MOVUPS xmmword ptr [RSP],XMM0
MOV dword ptr [RSP + 0x18],0x2
MOV qword ptr [RSP + 0x10],0x0
MOV RSI,RCX
MOV RDX,R8
MOV RCX,R9
MOV R8,RAX
XOR R9D,R9D
CALL 0x001284ca
MOV R14,RAX
CMP EDX,-0x1
JZ 0x00141af1
CMP EDX,0x6
JZ 0x00141af1
MOV RDI,qword ptr [RBX + 0x18]
MOV RSI,R14
CALL 0x0011d8c6
LEA RSI,[0x19f025]
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00122567
MOV EDX,0x6
LAB_00141af1:
MOV RAX,R14
ADD RSP,0x38
POP RBX
POP R14
RET
|
int8
JS_GetIterator2(long param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int8 uVar1;
int1 auVar2 [12];
auVar2 = JS_CallInternal(param_1,param_4,param_5,param_2,param_3,0,0,3,0,2);
uVar1 = auVar2._0_8_;
if ((auVar2._8_4_ != -1) && (auVar2._8_4_ != 6)) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar1);
uVar1 = 0;
JS_ThrowTypeError(param_1,"not an object");
}
return uVar1;
}
| |
24,924 | JS_GetIterator2 | bluesky950520[P]quickjs/quickjs.c | static JSValue JS_GetIterator2(JSContext *ctx, JSValue obj,
JSValue method)
{
JSValue enum_obj;
enum_obj = JS_Call(ctx, method, obj, 0, NULL);
if (JS_IsException(enum_obj))
return enum_obj;
if (!JS_IsObject(enum_obj)) {
JS_FreeValue(ctx, enum_obj);
return JS_ThrowTypeErrorNotAnObject(ctx);
}
return enum_obj;
} | O2 | c | JS_GetIterator2:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rax
movq %rsi, %r9
movq %rdi, %rbx
andq $0x0, (%rsp)
movq %rcx, %rsi
movq %r8, %rdx
movq %r9, %rcx
movq %rax, %r8
xorl %r9d, %r9d
callq 0x21eb6
cmpl $-0x1, %edx
je 0x398c6
cmpl $0x6, %edx
je 0x398c6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1801e
movq %rbx, %rdi
callq 0x1d5e1
pushq $0x6
popq %rdx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| JS_GetIterator2:
push rbx
sub rsp, 10h
mov rax, rdx
mov r9, rsi
mov rbx, rdi
and [rsp+18h+var_18], 0
mov rsi, rcx
mov rdx, r8
mov rcx, r9
mov r8, rax
xor r9d, r9d
call JS_Call
cmp edx, 0FFFFFFFFh
jz short loc_398C6
cmp edx, 6
jz short loc_398C6
mov rdi, rbx
mov rsi, rax
call JS_FreeValue
mov rdi, rbx
call JS_ThrowTypeErrorNotAnObject
push 6
pop rdx
xor eax, eax
loc_398C6:
add rsp, 10h
pop rbx
retn
| long long JS_GetIterator2(
long long a1,
int a2,
int a3,
int a4,
int a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long result; // rax
long long v14; // rdx
long long v15; // rsi
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
long long v19; // r9
__m128 v20; // xmm4
__m128 v21; // xmm5
char v22; // [rsp+0h] [rbp-18h]
result = JS_Call(a1, a4, a5, a2, a3, 0, 0LL);
if ( (_DWORD)v14 != -1 && (_DWORD)v14 != 6 )
{
v15 = result;
JS_FreeValue(a1, result, v14);
JS_ThrowTypeErrorNotAnObject(a1, a6, a7, a8, a9, v20, v21, a12, a13, v15, v16, v17, v18, v19, v22);
return 0LL;
}
return result;
}
| JS_GetIterator2:
PUSH RBX
SUB RSP,0x10
MOV RAX,RDX
MOV R9,RSI
MOV RBX,RDI
AND qword ptr [RSP],0x0
MOV RSI,RCX
MOV RDX,R8
MOV RCX,R9
MOV R8,RAX
XOR R9D,R9D
CALL 0x00121eb6
CMP EDX,-0x1
JZ 0x001398c6
CMP EDX,0x6
JZ 0x001398c6
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011801e
MOV RDI,RBX
CALL 0x0011d5e1
PUSH 0x6
POP RDX
XOR EAX,EAX
LAB_001398c6:
ADD RSP,0x10
POP RBX
RET
|
int8
JS_GetIterator2(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5)
{
int8 uVar1;
int1 auVar2 [12];
auVar2 = JS_Call(param_1,param_4,param_5,param_2,param_3,0,0);
uVar1 = auVar2._0_8_;
if ((auVar2._8_4_ != -1) && (auVar2._8_4_ != 6)) {
JS_FreeValue(param_1,uVar1);
JS_ThrowTypeErrorNotAnObject(param_1);
uVar1 = 0;
}
return uVar1;
}
| |
24,925 | DrawTriangleStrip | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color)
{
if (pointCount >= 3)
{
rlBegin(RL_TRIANGLES);
rlColor4ub(color.r, color.g, color.b, color.a);
for (int i = 2; i < pointCount; i++)
{
if ((i%2) == 0)
{
rlVertex2f(points[i].x, points[i].y);
rlVertex2f(points[i - 2].x, points[i - 2].y);
rlVertex2f(points[i - 1].x, points[i - 1].y);
}
else
{
rlVertex2f(points[i].x, points[i].y);
rlVertex2f(points[i - 1].x, points[i - 1].y);
rlVertex2f(points[i - 2].x, points[i - 2].y);
}
}
rlEnd();
}
} | O2 | c | DrawTriangleStrip:
cmpl $0x3, %esi
jl 0x66522
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, %r15d
shrl $0x18, %r15d
movl %edx, %r12d
shrl $0x10, %r12d
movl %edx, %r13d
shrl $0x8, %r13d
pushq $0x4
popq %rdi
callq 0x51283
movl $0xff, %eax
andl %eax, %r14d
andl %eax, %r13d
andl %eax, %r12d
movl %r14d, %edi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x52b4f
movl %ebp, %r14d
pushq $0x2
popq %r15
cmpq %r15, %r14
je 0x66523
xorl %r12d, %r12d
testb $0x1, %r15b
sete %r12b
leaq (%rbx,%r15,8), %r13
movss (%rbx,%r15,8), %xmm0
movss 0x4(%rbx,%r15,8), %xmm1
callq 0x529f9
leal (,%r15,8), %eax
movq %rax, %rcx
orq $-0x10, %rcx
orq $-0xc, %rax
shll $0x3, %r12d
movq %r12, %rbp
orq $-0x10, %rbp
orq $-0xc, %r12
movss (%rcx,%r13), %xmm0
movss (%rax,%r13), %xmm1
callq 0x529f9
movss (%rbp,%r13), %xmm0
movss (%r12,%r13), %xmm1
callq 0x529f9
incq %r15
jmp 0x664b2
retq
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5265a
| DrawTriangleStrip:
cmp esi, 3
jl locret_66522
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, edx
mov ebp, esi
mov rbx, rdi
mov r15d, edx
shr r15d, 18h
mov r12d, edx
shr r12d, 10h
mov r13d, edx
shr r13d, 8
push 4
pop rdi
call rlBegin
mov eax, 0FFh
and r14d, eax
and r13d, eax
and r12d, eax
mov edi, r14d
mov esi, r13d
mov edx, r12d
mov ecx, r15d
call rlColor4ub
mov r14d, ebp
push 2
pop r15
loc_664B2:
cmp r14, r15
jz short loc_66523
xor r12d, r12d
test r15b, 1
setz r12b
lea r13, [rbx+r15*8]
movss xmm0, dword ptr [rbx+r15*8]
movss xmm1, dword ptr [rbx+r15*8+4]
call rlVertex2f
lea eax, ds:0[r15*8]
mov rcx, rax
or rcx, 0FFFFFFFFFFFFFFF0h
or rax, 0FFFFFFFFFFFFFFF4h
shl r12d, 3
mov rbp, r12
or rbp, 0FFFFFFFFFFFFFFF0h
or r12, 0FFFFFFFFFFFFFFF4h
movss xmm0, dword ptr [rcx+r13]
movss xmm1, dword ptr [rax+r13]
call rlVertex2f
movss xmm0, dword ptr [rbp+r13+0]
movss xmm1, dword ptr [r12+r13]
call rlVertex2f
inc r15
jmp short loc_664B2
locret_66522:
retn
loc_66523:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rlEnd
| long long DrawTriangleStrip(long long a1, int a2, unsigned int a3)
{
char v3; // r14
unsigned int v4; // r15d
unsigned int v5; // r12d
unsigned int v6; // r13d
long long i; // r15
unsigned int *v8; // r13
long long result; // rax
if ( a2 >= 3 )
{
v3 = a3;
v4 = HIBYTE(a3);
v5 = HIWORD(a3);
v6 = a3 >> 8;
rlBegin(4);
rlColor4ub(v3, v6, v5, v4);
for ( i = 2LL; a2 != i; ++i )
{
v8 = (unsigned int *)(a1 + 8 * i);
rlVertex2f((__m128)*v8, (__m128)v8[1]);
rlVertex2f(
(__m128)*(unsigned int *)((char *)v8 + ((8 * (unsigned __int8)i) | 0xFFFFFFFFFFFFFFF0LL)),
(__m128)*(unsigned int *)((char *)v8 + ((8 * (unsigned __int8)i) | 0xFFFFFFFFFFFFFFF4LL)));
rlVertex2f(
(__m128)*(unsigned int *)((char *)v8 + ((8 * ((i & 1) == 0)) | 0xFFFFFFFFFFFFFFF0LL)),
(__m128)*(unsigned int *)((char *)v8 + ((8 * ((i & 1) == 0)) | 0xFFFFFFFFFFFFFFF4LL)));
}
return rlEnd();
}
return result;
}
| DrawTriangleStrip:
CMP ESI,0x3
JL 0x00166522
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV EBP,ESI
MOV RBX,RDI
MOV R15D,EDX
SHR R15D,0x18
MOV R12D,EDX
SHR R12D,0x10
MOV R13D,EDX
SHR R13D,0x8
PUSH 0x4
POP RDI
CALL 0x00151283
MOV EAX,0xff
AND R14D,EAX
AND R13D,EAX
AND R12D,EAX
MOV EDI,R14D
MOV ESI,R13D
MOV EDX,R12D
MOV ECX,R15D
CALL 0x00152b4f
MOV R14D,EBP
PUSH 0x2
POP R15
LAB_001664b2:
CMP R14,R15
JZ 0x00166523
XOR R12D,R12D
TEST R15B,0x1
SETZ R12B
LEA R13,[RBX + R15*0x8]
MOVSS XMM0,dword ptr [RBX + R15*0x8]
MOVSS XMM1,dword ptr [RBX + R15*0x8 + 0x4]
CALL 0x001529f9
LEA EAX,[R15*0x8]
MOV RCX,RAX
OR RCX,-0x10
OR RAX,-0xc
SHL R12D,0x3
MOV RBP,R12
OR RBP,-0x10
OR R12,-0xc
MOVSS XMM0,dword ptr [RCX + R13*0x1]
MOVSS XMM1,dword ptr [RAX + R13*0x1]
CALL 0x001529f9
MOVSS XMM0,dword ptr [RBP + R13*0x1]
MOVSS XMM1,dword ptr [R12 + R13*0x1]
CALL 0x001529f9
INC R15
JMP 0x001664b2
LAB_00166522:
RET
LAB_00166523:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0015265a
|
void DrawTriangleStrip(long param_1,uint param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
if (2 < (int)param_2) {
rlBegin(4);
rlColor4ub((uint)param_3 & 0xff,(uint)(param_3 >> 8) & 0xff,(uint)(param_3 >> 0x10) & 0xff,
param_3 >> 0x18 & 0xff);
for (uVar4 = 2; param_2 != uVar4; uVar4 = uVar4 + 1) {
lVar1 = param_1 + uVar4 * 8;
rlVertex2f(*(int4 *)(param_1 + uVar4 * 8),*(int4 *)(param_1 + 4 + uVar4 * 8));
uVar2 = (ulong)(uint)((int)uVar4 * 8);
uVar3 = (ulong)((uVar4 & 1) == 0) << 3;
rlVertex2f(*(int4 *)((uVar2 | 0xfffffffffffffff0) + lVar1),
*(int4 *)((uVar2 | 0xfffffffffffffff4) + lVar1));
rlVertex2f(*(int4 *)((uVar3 | 0xfffffffffffffff0) + lVar1),
*(int4 *)((uVar3 | 0xfffffffffffffff4) + lVar1));
}
rlEnd();
return;
}
return;
}
| |
24,926 | DrawTriangleStrip | csit-sgu[P]mit-game-2025_1/Libraries/raylib/src/rshapes.c | void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color)
{
if (pointCount >= 3)
{
rlBegin(RL_TRIANGLES);
rlColor4ub(color.r, color.g, color.b, color.a);
for (int i = 2; i < pointCount; i++)
{
if ((i%2) == 0)
{
rlVertex2f(points[i].x, points[i].y);
rlVertex2f(points[i - 2].x, points[i - 2].y);
rlVertex2f(points[i - 1].x, points[i - 1].y);
}
else
{
rlVertex2f(points[i].x, points[i].y);
rlVertex2f(points[i - 1].x, points[i - 1].y);
rlVertex2f(points[i - 2].x, points[i - 2].y);
}
}
rlEnd();
}
} | O3 | c | DrawTriangleStrip:
cmpl $0x3, %esi
jl 0x78d74
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movl %edx, %r15d
shrl $0x18, %r15d
movl %edx, %r12d
shrl $0x10, %r12d
movl %edx, %r13d
shrl $0x8, %r13d
movl $0x4, %edi
callq 0x60fc5
movl $0xff, %eax
andl %eax, %r14d
andl %eax, %r13d
andl %eax, %r12d
movl %r14d, %edi
movl %r13d, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x628b8
movl %ebp, %r14d
movl $0x2, %r15d
xorl %r12d, %r12d
testb $0x1, %r15b
sete %r12b
leaq (%rbx,%r15,8), %r13
movss (%rbx,%r15,8), %xmm0
movss 0x4(%rbx,%r15,8), %xmm1
callq 0x6275f
leal (,%r15,8), %eax
movq %rax, %rcx
orq $-0x10, %rcx
orq $-0xc, %rax
shll $0x3, %r12d
movq %r12, %rbp
orq $-0x10, %rbp
orq $-0xc, %r12
movss (%rcx,%r13), %xmm0
movss (%rax,%r13), %xmm1
callq 0x6275f
movss (%rbp,%r13), %xmm0
movss (%r12,%r13), %xmm1
callq 0x6275f
incq %r15
cmpq %r15, %r14
jne 0x78cf3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x623c4
retq
| DrawTriangleStrip:
cmp esi, 3
jl locret_78D74
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14d, edx
mov ebp, esi
mov rbx, rdi
mov r15d, edx
shr r15d, 18h
mov r12d, edx
shr r12d, 10h
mov r13d, edx
shr r13d, 8
mov edi, 4
call rlBegin
mov eax, 0FFh
and r14d, eax
and r13d, eax
and r12d, eax
mov edi, r14d
mov esi, r13d
mov edx, r12d
mov ecx, r15d
call rlColor4ub
mov r14d, ebp
mov r15d, 2
loc_78CF3:
xor r12d, r12d
test r15b, 1
setz r12b
lea r13, [rbx+r15*8]
movss xmm0, dword ptr [rbx+r15*8]
movss xmm1, dword ptr [rbx+r15*8+4]
call rlVertex2f
lea eax, ds:0[r15*8]
mov rcx, rax
or rcx, 0FFFFFFFFFFFFFFF0h
or rax, 0FFFFFFFFFFFFFFF4h
shl r12d, 3
mov rbp, r12
or rbp, 0FFFFFFFFFFFFFFF0h
or r12, 0FFFFFFFFFFFFFFF4h
movss xmm0, dword ptr [rcx+r13]
movss xmm1, dword ptr [rax+r13]
call rlVertex2f
movss xmm0, dword ptr [rbp+r13+0]
movss xmm1, dword ptr [r12+r13]
call rlVertex2f
inc r15
cmp r14, r15
jnz short loc_78CF3
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rlEnd
locret_78D74:
retn
| long long DrawTriangleStrip(long long a1, int a2, unsigned int a3)
{
char v3; // r14
unsigned int v4; // r15d
unsigned int v5; // r12d
unsigned int v6; // r13d
long long i; // r15
unsigned int *v8; // r13
long long result; // rax
if ( a2 >= 3 )
{
v3 = a3;
v4 = HIBYTE(a3);
v5 = HIWORD(a3);
v6 = a3 >> 8;
rlBegin(4);
rlColor4ub(v3, v6, v5, v4);
for ( i = 2LL; i != a2; ++i )
{
v8 = (unsigned int *)(a1 + 8 * i);
rlVertex2f((__m128)*v8, (__m128)v8[1]);
rlVertex2f(
(__m128)*(unsigned int *)((char *)v8 + ((8 * (unsigned __int8)i) | 0xFFFFFFFFFFFFFFF0LL)),
(__m128)*(unsigned int *)((char *)v8 + ((8 * (unsigned __int8)i) | 0xFFFFFFFFFFFFFFF4LL)));
rlVertex2f(
(__m128)*(unsigned int *)((char *)v8 + ((8 * ((i & 1) == 0)) | 0xFFFFFFFFFFFFFFF0LL)),
(__m128)*(unsigned int *)((char *)v8 + ((8 * ((i & 1) == 0)) | 0xFFFFFFFFFFFFFFF4LL)));
}
return rlEnd();
}
return result;
}
| DrawTriangleStrip:
CMP ESI,0x3
JL 0x00178d74
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14D,EDX
MOV EBP,ESI
MOV RBX,RDI
MOV R15D,EDX
SHR R15D,0x18
MOV R12D,EDX
SHR R12D,0x10
MOV R13D,EDX
SHR R13D,0x8
MOV EDI,0x4
CALL 0x00160fc5
MOV EAX,0xff
AND R14D,EAX
AND R13D,EAX
AND R12D,EAX
MOV EDI,R14D
MOV ESI,R13D
MOV EDX,R12D
MOV ECX,R15D
CALL 0x001628b8
MOV R14D,EBP
MOV R15D,0x2
LAB_00178cf3:
XOR R12D,R12D
TEST R15B,0x1
SETZ R12B
LEA R13,[RBX + R15*0x8]
MOVSS XMM0,dword ptr [RBX + R15*0x8]
MOVSS XMM1,dword ptr [RBX + R15*0x8 + 0x4]
CALL 0x0016275f
LEA EAX,[R15*0x8]
MOV RCX,RAX
OR RCX,-0x10
OR RAX,-0xc
SHL R12D,0x3
MOV RBP,R12
OR RBP,-0x10
OR R12,-0xc
MOVSS XMM0,dword ptr [RCX + R13*0x1]
MOVSS XMM1,dword ptr [RAX + R13*0x1]
CALL 0x0016275f
MOVSS XMM0,dword ptr [RBP + R13*0x1]
MOVSS XMM1,dword ptr [R12 + R13*0x1]
CALL 0x0016275f
INC R15
CMP R14,R15
JNZ 0x00178cf3
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001623c4
LAB_00178d74:
RET
|
void DrawTriangleStrip(long param_1,uint param_2,ulong param_3)
{
long lVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
if (2 < (int)param_2) {
rlBegin(4);
rlColor4ub((uint)param_3 & 0xff,(uint)(param_3 >> 8) & 0xff,(uint)(param_3 >> 0x10) & 0xff,
param_3 >> 0x18 & 0xff);
uVar4 = 2;
do {
lVar1 = param_1 + uVar4 * 8;
rlVertex2f(*(int4 *)(param_1 + uVar4 * 8),*(int4 *)(param_1 + 4 + uVar4 * 8));
uVar2 = (ulong)(uint)((int)uVar4 * 8);
uVar3 = (ulong)((uVar4 & 1) == 0) << 3;
rlVertex2f(*(int4 *)((uVar2 | 0xfffffffffffffff0) + lVar1),
*(int4 *)((uVar2 | 0xfffffffffffffff4) + lVar1));
rlVertex2f(*(int4 *)((uVar3 | 0xfffffffffffffff0) + lVar1),
*(int4 *)((uVar3 | 0xfffffffffffffff4) + lVar1));
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
rlEnd();
return;
}
return;
}
| |
24,927 | LefDefParser::lefiViaLayer::xh(int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiVia.cpp | double
lefiViaLayer::xh(int index)
{
char msg[160];
if (index < 0 || index >= numRects_) {
sprintf(msg, "ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d", index, numRects_);
lefiError(0, 1420, msg);
return 0;
}
return xh_[index];
} | O0 | cpp | LefDefParser::lefiViaLayer::xh(int):
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x14a7e
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x18(%rcx), %eax
jl 0x14abf
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x18(%rax), %ecx
leaq 0x7d961(%rip), %rsi # 0x923fa
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x58c, %esi # imm = 0x58C
callq 0x59060
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x14ade
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movslq 0xb4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nop
| _ZN12LefDefParser12lefiViaLayer2xhEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_14A7E
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+18h]
jl short loc_14ABF
loc_14A7E:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+18h]
lea rsi, aErrorLefpars14; "ERROR (LEFPARS-1420): The index number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 58Ch; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
movsd [rsp+0C8h+var_8], xmm0
jmp short loc_14ADE
loc_14ABF:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+30h]
movsxd rcx, [rsp+0C8h+var_14]
movsd xmm0, qword ptr [rax+rcx*8]
movsd [rsp+0C8h+var_8], xmm0
loc_14ADE:
movsd xmm0, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| double LefDefParser::lefiViaLayer::xh(LefDefParser::lefiViaLayer *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiViaLayer *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 6) )
return *(double *)(*((_QWORD *)this + 6) + 8LL * v5);
sprintf(
v4,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\n"
"Valid index is from 0 to %d",
v5,
*((_DWORD *)this + 6));
LefDefParser::lefiError(0LL, 1420, (int)v4, v2);
return 0.0;
}
| xh:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x00114a7e
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x18]
JL 0x00114abf
LAB_00114a7e:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x18]
LEA RSI,[0x1923fa]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x58c
CALL 0x00159060
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0xc0],XMM0
JMP 0x00114ade
LAB_00114abf:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOVSD qword ptr [RSP + 0xc0],XMM0
LAB_00114ade:
MOVSD XMM0,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiViaLayer::xh(int) */
int8 __thiscall LefDefParser::lefiViaLayer::xh(lefiViaLayer *this,int param_1)
{
char local_b8 [164];
int local_14;
lefiViaLayer *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x18) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1420): The index number %d given for the VIA LAYER RECTANGLE is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x18));
lefiError(0,0x58c,local_b8);
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x30) + (long)param_1 * 8);
}
return local_8;
}
| |
24,928 | TestLoggingLevels() | ng-log[P]ng-log/src/logging_unittest.cc | void TestLoggingLevels() {
LogWithLevels(0, NGLOG_INFO, false, false);
LogWithLevels(1, NGLOG_INFO, false, false);
LogWithLevels(-1, NGLOG_INFO, false, false);
LogWithLevels(0, NGLOG_WARNING, false, false);
LogWithLevels(0, NGLOG_ERROR, false, false);
LogWithLevels(0, NGLOG_FATAL, false, false);
LogWithLevels(0, NGLOG_FATAL, true, false);
LogWithLevels(0, NGLOG_FATAL, false, true);
LogWithLevels(1, NGLOG_WARNING, false, false);
LogWithLevels(1, NGLOG_FATAL, false, true);
} | O1 | cpp | TestLoggingLevels():
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
xorl %edi, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
xorl %edi, %edi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
xorl %edi, %edi
movl $0x3, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xdac0
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xdac0
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xdac0
movl $0x1, %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
popq %rax
jmp 0xdac0
| _ZL17TestLoggingLevelsv:
push rax
xor edi, edi; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 0FFFFFFFFh; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 1; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 2; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
mov edx, 1; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
xor edx, edx; bool
mov ecx, 1; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
mov esi, 1; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
mov esi, 3; int
xor edx, edx; bool
mov ecx, 1; bool
pop rax
jmp _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
| void TestLoggingLevels(void)
{
LogWithLevels(0, 0, 0, 0);
LogWithLevels(1, 0, 0, 0);
LogWithLevels(-1, 0, 0, 0);
LogWithLevels(0, 1, 0, 0);
LogWithLevels(0, 2, 0, 0);
LogWithLevels(0, 3, 0, 0);
LogWithLevels(0, 3, 1, 0);
LogWithLevels(0, 3, 0, 1);
LogWithLevels(1, 1, 0, 0);
LogWithLevels(1, 3, 0, 1);
}
| TestLoggingLevels:
PUSH RAX
XOR EDI,EDI
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
MOV EDI,0x1
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
MOV EDI,0xffffffff
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
XOR EDI,EDI
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
XOR EDI,EDI
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
XOR EDI,EDI
MOV ESI,0x3
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
XOR EDI,EDI
MOV ESI,0x3
MOV EDX,0x1
XOR ECX,ECX
CALL 0x0010dac0
XOR EDI,EDI
MOV ESI,0x3
XOR EDX,EDX
MOV ECX,0x1
CALL 0x0010dac0
MOV EDI,0x1
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010dac0
MOV EDI,0x1
MOV ESI,0x3
XOR EDX,EDX
MOV ECX,0x1
POP RAX
JMP 0x0010dac0
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* TestLoggingLevels() */
void TestLoggingLevels(void)
{
LogWithLevels(0,0,false,false);
LogWithLevels(1,0,false,false);
LogWithLevels(-1,0,false,false);
LogWithLevels(0,1,false,false);
LogWithLevels(0,2,false,false);
LogWithLevels(0,3,false,false);
LogWithLevels(0,3,true,false);
LogWithLevels(0,3,false,true);
LogWithLevels(1,1,false,false);
LogWithLevels(1,3,false,true);
return;
}
| |
24,929 | TestLoggingLevels() | ng-log[P]ng-log/src/logging_unittest.cc | void TestLoggingLevels() {
LogWithLevels(0, NGLOG_INFO, false, false);
LogWithLevels(1, NGLOG_INFO, false, false);
LogWithLevels(-1, NGLOG_INFO, false, false);
LogWithLevels(0, NGLOG_WARNING, false, false);
LogWithLevels(0, NGLOG_ERROR, false, false);
LogWithLevels(0, NGLOG_FATAL, false, false);
LogWithLevels(0, NGLOG_FATAL, true, false);
LogWithLevels(0, NGLOG_FATAL, false, true);
LogWithLevels(1, NGLOG_WARNING, false, false);
LogWithLevels(1, NGLOG_FATAL, false, true);
} | O2 | cpp | TestLoggingLevels():
pushq %rbp
pushq %rbx
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
pushq $0x1
popq %rbx
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
pushq $-0x1
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
xorl %edi, %edi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
pushq $0x2
popq %rsi
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
pushq $0x3
popq %rbp
xorl %edi, %edi
movl %ebp, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
xorl %edi, %edi
movl %ebp, %esi
movl %ebx, %edx
xorl %ecx, %ecx
callq 0xc2ac
xorl %edi, %edi
movl %ebp, %esi
xorl %edx, %edx
movl %ebx, %ecx
callq 0xc2ac
movl %ebx, %edi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xc2ac
movl %ebx, %edi
movl %ebp, %esi
xorl %edx, %edx
movl %ebx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc2ac
| _ZL17TestLoggingLevelsv:
push rbp
push rbx
push rax
xor edi, edi; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
push 1
pop rbx
mov edi, ebx; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
push 0FFFFFFFFFFFFFFFFh
pop rdi; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, ebx; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
push 2
pop rsi; int
xor edi, edi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
push 3
pop rbp
xor edi, edi; int
mov esi, ebp; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, ebp; int
mov edx, ebx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, ebp; int
xor edx, edx; bool
mov ecx, ebx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, ebx; int
mov esi, ebx; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, ebx; int
mov esi, ebp; int
xor edx, edx; bool
mov ecx, ebx; bool
add rsp, 8
pop rbx
pop rbp
jmp _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
| void TestLoggingLevels(void)
{
LogWithLevels(0, 0, 0, 0);
LogWithLevels(1, 0, 0, 0);
LogWithLevels(-1, 0, 0, 0);
LogWithLevels(0, 1, 0, 0);
LogWithLevels(0, 2, 0, 0);
LogWithLevels(0, 3, 0, 0);
LogWithLevels(0, 3, 1, 0);
LogWithLevels(0, 3, 0, 1);
LogWithLevels(1, 1, 0, 0);
LogWithLevels(1, 3, 0, 1);
}
| TestLoggingLevels:
PUSH RBP
PUSH RBX
PUSH RAX
XOR EDI,EDI
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
PUSH 0x1
POP RBX
MOV EDI,EBX
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
PUSH -0x1
POP RDI
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
XOR EDI,EDI
MOV ESI,EBX
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
PUSH 0x2
POP RSI
XOR EDI,EDI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
PUSH 0x3
POP RBP
XOR EDI,EDI
MOV ESI,EBP
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
XOR EDI,EDI
MOV ESI,EBP
MOV EDX,EBX
XOR ECX,ECX
CALL 0x0010c2ac
XOR EDI,EDI
MOV ESI,EBP
XOR EDX,EDX
MOV ECX,EBX
CALL 0x0010c2ac
MOV EDI,EBX
MOV ESI,EBX
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010c2ac
MOV EDI,EBX
MOV ESI,EBP
XOR EDX,EDX
MOV ECX,EBX
ADD RSP,0x8
POP RBX
POP RBP
JMP 0x0010c2ac
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* TestLoggingLevels() */
void TestLoggingLevels(void)
{
LogWithLevels(0,0,false,false);
LogWithLevels(1,0,false,false);
LogWithLevels(-1,0,false,false);
LogWithLevels(0,1,false,false);
LogWithLevels(0,2,false,false);
LogWithLevels(0,3,false,false);
LogWithLevels(0,3,true,false);
LogWithLevels(0,3,false,true);
LogWithLevels(1,1,false,false);
LogWithLevels(1,3,false,true);
return;
}
| |
24,930 | TestLoggingLevels() | ng-log[P]ng-log/src/logging_unittest.cc | void TestLoggingLevels() {
LogWithLevels(0, NGLOG_INFO, false, false);
LogWithLevels(1, NGLOG_INFO, false, false);
LogWithLevels(-1, NGLOG_INFO, false, false);
LogWithLevels(0, NGLOG_WARNING, false, false);
LogWithLevels(0, NGLOG_ERROR, false, false);
LogWithLevels(0, NGLOG_FATAL, false, false);
LogWithLevels(0, NGLOG_FATAL, true, false);
LogWithLevels(0, NGLOG_FATAL, false, true);
LogWithLevels(1, NGLOG_WARNING, false, false);
LogWithLevels(1, NGLOG_FATAL, false, true);
} | O3 | cpp | TestLoggingLevels():
pushq %rax
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
xorl %edi, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
xorl %edi, %edi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
xorl %edi, %edi
movl $0x3, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0xd42e
xorl %edi, %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0xd42e
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0xd42e
movl $0x1, %edi
movl $0x3, %esi
xorl %edx, %edx
movl $0x1, %ecx
popq %rax
jmp 0xd42e
| _ZL17TestLoggingLevelsv:
push rax
xor edi, edi; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 0FFFFFFFFh; int
xor esi, esi; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 1; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 2; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
mov edx, 1; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
xor edi, edi; int
mov esi, 3; int
xor edx, edx; bool
mov ecx, 1; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
mov esi, 1; int
xor edx, edx; bool
xor ecx, ecx; bool
call _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
mov edi, 1; int
mov esi, 3; int
xor edx, edx; bool
mov ecx, 1; bool
pop rax
jmp _ZL13LogWithLevelsiibb; LogWithLevels(int,int,bool,bool)
| void TestLoggingLevels(void)
{
LogWithLevels(0, 0, 0, 0);
LogWithLevels(1, 0, 0, 0);
LogWithLevels(-1, 0, 0, 0);
LogWithLevels(0, 1, 0, 0);
LogWithLevels(0, 2, 0, 0);
LogWithLevels(0, 3, 0, 0);
LogWithLevels(0, 3, 1, 0);
LogWithLevels(0, 3, 0, 1);
LogWithLevels(1, 1, 0, 0);
LogWithLevels(1, 3, 0, 1);
}
| TestLoggingLevels:
PUSH RAX
XOR EDI,EDI
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
MOV EDI,0x1
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
MOV EDI,0xffffffff
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
XOR EDI,EDI
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
XOR EDI,EDI
MOV ESI,0x2
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
XOR EDI,EDI
MOV ESI,0x3
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
XOR EDI,EDI
MOV ESI,0x3
MOV EDX,0x1
XOR ECX,ECX
CALL 0x0010d42e
XOR EDI,EDI
MOV ESI,0x3
XOR EDX,EDX
MOV ECX,0x1
CALL 0x0010d42e
MOV EDI,0x1
MOV ESI,0x1
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0010d42e
MOV EDI,0x1
MOV ESI,0x3
XOR EDX,EDX
MOV ECX,0x1
POP RAX
JMP 0x0010d42e
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* TestLoggingLevels() */
void TestLoggingLevels(void)
{
LogWithLevels(0,0,false,false);
LogWithLevels(1,0,false,false);
LogWithLevels(-1,0,false,false);
LogWithLevels(0,1,false,false);
LogWithLevels(0,2,false,false);
LogWithLevels(0,3,false,false);
LogWithLevels(0,3,true,false);
LogWithLevels(0,3,false,true);
LogWithLevels(1,1,false,false);
LogWithLevels(1,3,false,true);
return;
}
| |
24,931 | JS_NewUint8ArrayCopy | bluesky950520[P]quickjs/quickjs.c | JSValue JS_NewUint8ArrayCopy(JSContext *ctx, const uint8_t *buf, size_t len)
{
JSValue buffer = js_array_buffer_constructor3(ctx, JS_UNDEFINED, len, NULL,
JS_CLASS_ARRAY_BUFFER,
(uint8_t *)buf,
js_array_buffer_free, NULL,
TRUE);
return js_new_uint8array(ctx, buffer);
} | O2 | c | JS_NewUint8ArrayCopy:
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
leaq -0x9ce(%rip), %rax # 0x35bf5
movq %rax, 0x8(%rsp)
movq %rsi, (%rsp)
movl $0x1, 0x18(%rsp)
andq $0x0, 0x10(%rsp)
pushq $0x3
popq %rdx
pushq $0x13
popq %r9
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x35961
movq %rbx, %rdi
movq %rax, %rsi
addq $0x20, %rsp
popq %rbx
jmp 0x36519
| JS_NewUint8ArrayCopy:
push rbx
sub rsp, 20h
mov rcx, rdx
mov rbx, rdi
lea rax, js_array_buffer_free
mov [rsp+28h+var_20], rax
mov [rsp+28h+var_28], rsi
mov [rsp+28h+var_10], 1
and [rsp+28h+var_18], 0
push 3
pop rdx
push 13h
pop r9
xor esi, esi
xor r8d, r8d
call js_array_buffer_constructor3
mov rdi, rbx
mov rsi, rax
add rsp, 20h
pop rbx
jmp js_new_uint8array
| unsigned long long JS_NewUint8ArrayCopy(
long long a1,
long long a2,
unsigned long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11)
{
unsigned long long v11; // rax
long long v12; // rdx
v11 = js_array_buffer_constructor3(
a1,
0LL,
3LL,
a3,
0LL,
19LL,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a2,
(long long ( *)())js_array_buffer_free,
0LL,
1);
return js_new_uint8array(a1, v11, v12);
}
| JS_NewUint8ArrayCopy:
PUSH RBX
SUB RSP,0x20
MOV RCX,RDX
MOV RBX,RDI
LEA RAX,[0x135bf5]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP],RSI
MOV dword ptr [RSP + 0x18],0x1
AND qword ptr [RSP + 0x10],0x0
PUSH 0x3
POP RDX
PUSH 0x13
POP R9
XOR ESI,ESI
XOR R8D,R8D
CALL 0x00135961
MOV RDI,RBX
MOV RSI,RAX
ADD RSP,0x20
POP RBX
JMP 0x00136519
|
void JS_NewUint8ArrayCopy(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
uVar1 = js_array_buffer_constructor3(param_1,0,3,param_3,0,0x13,param_2,js_array_buffer_free,0,1);
js_new_uint8array(param_1,uVar1);
return;
}
| |
24,932 | JS_AddIntrinsicProxy | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicProxy(JSContext *ctx)
{
JSRuntime *rt = ctx->rt;
JSValue obj1;
if (!JS_IsRegisteredClass(rt, JS_CLASS_PROXY)) {
init_class_range(rt, js_proxy_class_def, JS_CLASS_PROXY,
countof(js_proxy_class_def));
rt->class_array[JS_CLASS_PROXY].exotic = &js_proxy_exotic_methods;
rt->class_array[JS_CLASS_PROXY].call = js_proxy_call;
}
obj1 = JS_NewCFunction2(ctx, js_proxy_constructor, "Proxy", 2,
JS_CFUNC_constructor, 0);
JS_SetConstructorBit(ctx, obj1, TRUE);
JS_SetPropertyFunctionList(ctx, obj1, js_proxy_funcs,
countof(js_proxy_funcs));
JS_DefinePropertyValueStr(ctx, ctx->global_obj, "Proxy",
obj1, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
} | O0 | c | JS_AddIntrinsicProxy:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x30, %esi
callq 0x27f70
cmpl $0x0, %eax
jne 0x2500a
movq 0x28(%rsp), %rdi
leaq 0x109d59(%rip), %rsi # 0x12ed20
movl $0x30, %edx
movl $0x1, %ecx
callq 0x21230
movq 0x28(%rsp), %rax
movq 0x80(%rax), %rax
leaq 0x109d4f(%rip), %rcx # 0x12ed38
movq %rcx, 0x7a0(%rax)
movq 0x28(%rsp), %rax
movq 0x80(%rax), %rax
leaq 0x2c21d(%rip), %rcx # 0x51220
movq %rcx, 0x798(%rax)
movq 0x30(%rsp), %rdi
leaq 0x2c57a(%rip), %rsi # 0x51590
leaq 0xe76d1(%rip), %rdx # 0x10c6ee
movl $0x2, %r8d
xorl %r9d, %r9d
movl %r8d, %ecx
callq 0x292f0
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movl $0x1, %ecx
callq 0x36e80
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
leaq 0x109cf5(%rip), %rcx # 0x12ed70
movl $0x1, %r8d
callq 0x4b840
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x1a0(%rax), %rsi
movq 0x1a8(%rax), %rdx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
leaq 0xe763f(%rip), %rcx # 0x10c6ee
movl $0x3, (%rsp)
callq 0x36220
addq $0x38, %rsp
retq
| JS_AddIntrinsicProxy:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rax, [rsp+38h+var_8]
mov rax, [rax+18h]
mov [rsp+38h+var_10], rax
mov rdi, [rsp+38h+var_10]
mov esi, 30h ; '0'
call JS_IsRegisteredClass
cmp eax, 0
jnz short loc_2500A
mov rdi, [rsp+38h+var_10]
lea rsi, js_proxy_class_def
mov edx, 30h ; '0'
mov ecx, 1
call init_class_range
mov rax, [rsp+38h+var_10]
mov rax, [rax+80h]
lea rcx, js_proxy_exotic_methods
mov [rax+7A0h], rcx
mov rax, [rsp+38h+var_10]
mov rax, [rax+80h]
lea rcx, js_proxy_call
mov [rax+798h], rcx
loc_2500A:
mov rdi, [rsp+38h+var_8]
lea rsi, js_proxy_constructor
lea rdx, aProxy; "Proxy"
mov r8d, 2
xor r9d, r9d
mov ecx, r8d
call JS_NewCFunction2
mov [rsp+38h+var_30], rax
mov [rsp+38h+var_28], rdx
mov rax, [rsp+38h+var_30]
mov [rsp+38h+var_20], rax
mov rax, [rsp+38h+var_28]
mov [rsp+38h+var_18], rax
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_20]
mov rdx, [rsp+38h+var_18]
mov ecx, 1
call JS_SetConstructorBit
mov rdi, [rsp+38h+var_8]
mov rsi, [rsp+38h+var_20]
mov rdx, [rsp+38h+var_18]
lea rcx, js_proxy_funcs
mov r8d, 1
call JS_SetPropertyFunctionList
mov rdi, [rsp+38h+var_8]
mov rax, [rsp+38h+var_8]
mov rsi, [rax+1A0h]
mov rdx, [rax+1A8h]
mov r8, [rsp+38h+var_20]
mov r9, [rsp+38h+var_18]
lea rcx, aProxy; "Proxy"
mov [rsp+38h+var_38], 3
call JS_DefinePropertyValueStr
add rsp, 38h
retn
| long long JS_AddIntrinsicProxy(_QWORD *a1)
{
long long v1; // rdx
long long v3; // [rsp+8h] [rbp-30h]
long long v4; // [rsp+20h] [rbp-18h]
long long v5; // [rsp+28h] [rbp-10h]
v5 = a1[3];
if ( !(unsigned int)JS_IsRegisteredClass(v5, 48LL) )
{
init_class_range(v5, (long long)&js_proxy_class_def, 48, 1);
*(_QWORD *)(*(_QWORD *)(v5 + 128) + 1952LL) = js_proxy_exotic_methods;
*(_QWORD *)(*(_QWORD *)(v5 + 128) + 1944LL) = js_proxy_call;
}
v3 = JS_NewCFunction2(a1, js_proxy_constructor, "Proxy", 2LL, 2LL, 0LL);
v4 = v1;
JS_SetConstructorBit(a1, v3, v1, 1LL);
JS_SetPropertyFunctionList(a1, v3, v4, &js_proxy_funcs, 1LL);
return JS_DefinePropertyValueStr((_DWORD)a1, a1[52], a1[53], (unsigned int)"Proxy", v3, v4, 3);
}
| JS_AddIntrinsicProxy:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,0x30
CALL 0x00127f70
CMP EAX,0x0
JNZ 0x0012500a
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x22ed20]
MOV EDX,0x30
MOV ECX,0x1
CALL 0x00121230
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x80]
LEA RCX,[0x22ed38]
MOV qword ptr [RAX + 0x7a0],RCX
MOV RAX,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RAX + 0x80]
LEA RCX,[0x151220]
MOV qword ptr [RAX + 0x798],RCX
LAB_0012500a:
MOV RDI,qword ptr [RSP + 0x30]
LEA RSI,[0x151590]
LEA RDX,[0x20c6ee]
MOV R8D,0x2
XOR R9D,R9D
MOV ECX,R8D
CALL 0x001292f0
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
MOV ECX,0x1
CALL 0x00136e80
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
LEA RCX,[0x22ed70]
MOV R8D,0x1
CALL 0x0014b840
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RAX + 0x1a0]
MOV RDX,qword ptr [RAX + 0x1a8]
MOV R8,qword ptr [RSP + 0x18]
MOV R9,qword ptr [RSP + 0x20]
LEA RCX,[0x20c6ee]
MOV dword ptr [RSP],0x3
CALL 0x00136220
ADD RSP,0x38
RET
|
void JS_AddIntrinsicProxy(long param_1)
{
long lVar1;
int iVar2;
int8 uVar3;
int8 uVar4;
int1 auVar5 [16];
lVar1 = *(long *)(param_1 + 0x18);
iVar2 = JS_IsRegisteredClass(lVar1,0x30);
if (iVar2 == 0) {
init_class_range(lVar1,js_proxy_class_def,0x30,1);
*(int1 **)(*(long *)(lVar1 + 0x80) + 0x7a0) = js_proxy_exotic_methods;
*(code **)(*(long *)(lVar1 + 0x80) + 0x798) = js_proxy_call;
}
auVar5 = JS_NewCFunction2(param_1,js_proxy_constructor,"Proxy",2,2,0);
uVar4 = auVar5._8_8_;
uVar3 = auVar5._0_8_;
JS_SetConstructorBit(param_1,uVar3,uVar4,1);
JS_SetPropertyFunctionList(param_1,uVar3,uVar4,js_proxy_funcs,1);
JS_DefinePropertyValueStr
(param_1,*(int8 *)(param_1 + 0x1a0),*(int8 *)(param_1 + 0x1a8),"Proxy",uVar3
,uVar4,3);
return;
}
| |
24,933 | my_casedn_ucs2 | eloqsql/strings/ctype-ucs2.c | static size_t my_casedn_ucs2(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int res;
const char *srcend= src + srclen;
char *dstend= dst + dstlen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(srclen <= dstlen);
while ((src < srcend) &&
(res= my_ucs2_uni(cs, &wc, (uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_ucs2(uni_plane, &wc);
if (res != my_uni_ucs2(cs, wc, (uchar*) dst, (uchar*) dstend))
break;
src+= res;
dst+= res;
}
return srclen;
} | O3 | c | my_casedn_ucs2:
movq %rdx, %rax
cmpq $0x2, %rdx
jl 0x68132
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rax), %rdx
addq %rcx, %r8
movq 0x78(%rdi), %rdi
addq $0x2, %rcx
movzbl (%rsi), %r9d
movzbl 0x1(%rsi), %r10d
movq 0x8(%rdi), %r11
movq (%r11,%r9,8), %r11
testq %r11, %r11
je 0x680f9
leaq (%r10,%r10,2), %r9
movl 0x4(%r11,%r9,4), %r9d
jmp 0x68100
shll $0x8, %r9d
orq %r10, %r9
cmpq %r8, %rcx
ja 0x68131
cmpl $0xffff, %r9d # imm = 0xFFFF
ja 0x68131
rolw $0x8, %r9w
movw %r9w, -0x2(%rcx)
leaq 0x2(%rsi), %r9
cmpq %rdx, %r9
jae 0x68131
addq $0x4, %rsi
addq $0x2, %rcx
cmpq %rdx, %rsi
movq %r9, %rsi
jbe 0x680d8
popq %rbp
retq
| my_casedn_ucs2:
mov rax, rdx
cmp rdx, 2
jl short locret_68132
push rbp
mov rbp, rsp
lea rdx, [rsi+rax]
add r8, rcx
mov rdi, [rdi+78h]
add rcx, 2
loc_680D8:
movzx r9d, byte ptr [rsi]
movzx r10d, byte ptr [rsi+1]
mov r11, [rdi+8]
mov r11, [r11+r9*8]
test r11, r11
jz short loc_680F9
lea r9, [r10+r10*2]
mov r9d, [r11+r9*4+4]
jmp short loc_68100
loc_680F9:
shl r9d, 8
or r9, r10
loc_68100:
cmp rcx, r8
ja short loc_68131
cmp r9d, 0FFFFh
ja short loc_68131
rol r9w, 8
mov [rcx-2], r9w
lea r9, [rsi+2]
cmp r9, rdx
jnb short loc_68131
add rsi, 4
add rcx, 2
cmp rsi, rdx
mov rsi, r9
jbe short loc_680D8
loc_68131:
pop rbp
locret_68132:
retn
| long long my_casedn_ucs2(long long a1, unsigned __int8 *a2, long long a3, long long a4, long long a5)
{
long long result; // rax
unsigned long long v6; // rdx
unsigned long long v7; // r8
long long v8; // rdi
unsigned long long v9; // rcx
long long v10; // r9
long long v11; // r10
long long v12; // r11
unsigned int v13; // r9d
bool v14; // cc
result = a3;
if ( a3 >= 2 )
{
v6 = (unsigned long long)&a2[a3];
v7 = a4 + a5;
v8 = *(_QWORD *)(a1 + 120);
v9 = a4 + 2;
do
{
v10 = *a2;
v11 = a2[1];
v12 = *(_QWORD *)(*(_QWORD *)(v8 + 8) + 8 * v10);
if ( v12 )
v13 = *(_DWORD *)(v12 + 12 * v11 + 4);
else
v13 = v11 | ((_DWORD)v10 << 8);
if ( v9 > v7 )
break;
if ( v13 > 0xFFFF )
break;
*(_WORD *)(v9 - 2) = __ROL2__(v13, 8);
if ( (unsigned long long)(a2 + 2) >= v6 )
break;
v9 += 2LL;
v14 = (unsigned long long)(a2 + 4) <= v6;
a2 += 2;
}
while ( v14 );
}
return result;
}
| my_casedn_ucs2:
MOV RAX,RDX
CMP RDX,0x2
JL 0x00168132
PUSH RBP
MOV RBP,RSP
LEA RDX,[RSI + RAX*0x1]
ADD R8,RCX
MOV RDI,qword ptr [RDI + 0x78]
ADD RCX,0x2
LAB_001680d8:
MOVZX R9D,byte ptr [RSI]
MOVZX R10D,byte ptr [RSI + 0x1]
MOV R11,qword ptr [RDI + 0x8]
MOV R11,qword ptr [R11 + R9*0x8]
TEST R11,R11
JZ 0x001680f9
LEA R9,[R10 + R10*0x2]
MOV R9D,dword ptr [R11 + R9*0x4 + 0x4]
JMP 0x00168100
LAB_001680f9:
SHL R9D,0x8
OR R9,R10
LAB_00168100:
CMP RCX,R8
JA 0x00168131
CMP R9D,0xffff
JA 0x00168131
ROL R9W,0x8
MOV word ptr [RCX + -0x2],R9W
LEA R9,[RSI + 0x2]
CMP R9,RDX
JNC 0x00168131
ADD RSI,0x4
ADD RCX,0x2
CMP RSI,RDX
MOV RSI,R9
JBE 0x001680d8
LAB_00168131:
POP RBP
LAB_00168132:
RET
|
void my_casedn_ucs2(long param_1,byte *param_2,long param_3,long param_4,long param_5)
{
long lVar1;
long lVar2;
ulong uVar3;
byte *pbVar4;
byte *pbVar5;
uint uVar6;
if (1 < param_3) {
lVar1 = *(long *)(param_1 + 0x78);
uVar3 = param_4 + 2;
pbVar4 = param_2;
while( true ) {
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (ulong)*pbVar4 * 8);
if (lVar2 == 0) {
uVar6 = (uint)CONCAT11(*pbVar4,pbVar4[1]);
}
else {
uVar6 = *(uint *)(lVar2 + 4 + (ulong)pbVar4[1] * 0xc);
}
if (((ulong)(param_5 + param_4) < uVar3) || (0xffff < uVar6)) break;
*(ushort *)(uVar3 - 2) = (ushort)uVar6 << 8 | (ushort)uVar6 >> 8;
if (param_2 + param_3 <= pbVar4 + 2) {
return;
}
pbVar5 = pbVar4 + 4;
uVar3 = uVar3 + 2;
pbVar4 = pbVar4 + 2;
if (param_2 + param_3 < pbVar5) {
return;
}
}
}
return;
}
| |
24,934 | safe_hash_search | eloqsql/mysys/my_safehash.c | uchar *safe_hash_search(SAFE_HASH *hash, const uchar *key, uint length,
uchar *def)
{
uchar *result;
DBUG_ENTER("safe_hash_search");
mysql_rwlock_rdlock(&hash->mutex);
result= my_hash_search(&hash->hash, key, length);
mysql_rwlock_unlock(&hash->mutex);
if (!result)
result= def;
else
result= ((SAFE_HASH_ENTRY*) result)->data;
DBUG_PRINT("exit",("data: %p", result));
DBUG_RETURN(result);
} | O0 | c | safe_hash_search:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55a22(%rip), %rsi # 0x154504
movl $0xa7, %edx
callq 0xfeb50
movq -0x8(%rbp), %rdi
addq $0x98, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xddfe0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0xfebc0
cmpq $0x0, -0x28(%rbp)
jne 0xfeb23
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xfeb2f
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfeb31
jmp 0xfeb33
jmp 0xfeb35
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| safe_hash_search:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov rdi, [rbp+var_8]
lea rsi, aWorkspaceLlm4b_40; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0A7h
call inline_mysql_rwlock_rdlock_4
mov rdi, [rbp+var_8]
add rdi, 98h
mov rsi, [rbp+var_10]
mov eax, [rbp+var_14]
mov edx, eax
call my_hash_search
mov [rbp+var_28], rax
mov rdi, [rbp+var_8]
call inline_mysql_rwlock_unlock_8
cmp [rbp+var_28], 0
jnz short loc_FEB23
mov rax, [rbp+var_20]
mov [rbp+var_28], rax
jmp short loc_FEB2F
loc_FEB23:
mov rax, [rbp+var_28]
mov rax, [rax+10h]
mov [rbp+var_28], rax
loc_FEB2F:
jmp short $+2
loc_FEB31:
jmp short $+2
loc_FEB33:
jmp short $+2
loc_FEB35:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long safe_hash_search(long long a1, long long a2, unsigned int a3, long long a4)
{
long long v5; // [rsp+8h] [rbp-28h]
inline_mysql_rwlock_rdlock_4(a1, "/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c", 167LL);
v5 = my_hash_search(a1 + 152, a2, a3);
inline_mysql_rwlock_unlock_8(a1);
if ( v5 )
return *(_QWORD *)(v5 + 16);
else
return a4;
}
| safe_hash_search:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV qword ptr [RBP + -0x20],RCX
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x254504]
MOV EDX,0xa7
CALL 0x001feb50
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x98
MOV RSI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x14]
MOV EDX,EAX
CALL 0x001ddfe0
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001febc0
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x001feb23
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001feb2f
LAB_001feb23:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
LAB_001feb2f:
JMP 0x001feb31
LAB_001feb31:
JMP 0x001feb33
LAB_001feb33:
JMP 0x001feb35
LAB_001feb35:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
int8 safe_hash_search(long param_1,int8 param_2,int4 param_3,int8 param_4)
{
long lVar1;
int8 local_30;
inline_mysql_rwlock_rdlock
(param_1,"/workspace/llm4binary/github2025/eloqsql/mysys/my_safehash.c",0xa7);
lVar1 = my_hash_search(param_1 + 0x98,param_2,param_3);
inline_mysql_rwlock_unlock(param_1);
local_30 = param_4;
if (lVar1 != 0) {
local_30 = *(int8 *)(lVar1 + 0x10);
}
return local_30;
}
| |
24,935 | my_hash_sort_8bit_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_8bit_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
/*
Remove trailing spaces. We have to do this to be able to compare
'A ' and 'A' as identical
*/
const uchar *end= skip_trailing_space(key, len);
my_hash_sort_bin(cs, key, end - key, nr1, nr2);
} | O3 | c | my_hash_sort_8bit_bin:
pushq %rbp
movq %rsp, %rbp
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0x67744
movq %r9, %rdi
andq $-0x4, %rdi
cmpq %rsi, %rdi
jbe 0x67744
leaq 0x3(%rsi), %rdx
andq $-0x4, %rdx
movq %r9, %rax
movb -0x1(%r9), %r10b
cmpq %rdi, %r9
jbe 0x677a4
leaq -0x1(%rax), %r9
cmpb $0x20, %r10b
je 0x6772c
jmp 0x67747
movq %r9, %rax
movq %rax, %rdi
subq %rsi, %rdi
movq %rax, %rdx
movq %rdi, %r9
cmpq %rsi, %rax
jbe 0x67766
leaq -0x1(%rdx), %rax
leaq -0x1(%r9), %rdi
cmpb $0x20, -0x1(%rdx)
je 0x6774d
movq (%rcx), %rax
movq (%r8), %rdi
testq %r9, %r9
jle 0x6779c
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x67771
movq %rax, (%rcx)
movq %rdi, (%r8)
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdi, %rdx
setae %dil
orb %r9b, %dil
jne 0x67747
movq %rax, %rdi
movq %rdi, %rax
cmpq %rdx, %rdi
jbe 0x67747
leaq -0x4(%rax), %rdi
cmpl $0x20202020, -0x4(%rax) # imm = 0x20202020
je 0x677bb
jmp 0x67747
| my_hash_sort_8bit_bin:
push rbp
mov rbp, rsp
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_67744
mov rdi, r9
and rdi, 0FFFFFFFFFFFFFFFCh
cmp rdi, rsi
jbe short loc_67744
lea rdx, [rsi+3]
and rdx, 0FFFFFFFFFFFFFFFCh
loc_6772C:
mov rax, r9
mov r10b, [r9-1]
cmp r9, rdi
jbe short loc_677A4
lea r9, [rax-1]
cmp r10b, 20h ; ' '
jz short loc_6772C
jmp short loc_67747
loc_67744:
mov rax, r9
loc_67747:
mov rdi, rax
sub rdi, rsi
loc_6774D:
mov rdx, rax
mov r9, rdi
cmp rax, rsi
jbe short loc_67766
lea rax, [rdx-1]
lea rdi, [r9-1]
cmp byte ptr [rdx-1], 20h ; ' '
jz short loc_6774D
loc_67766:
mov rax, [rcx]
mov rdi, [r8]
test r9, r9
jle short loc_6779C
loc_67771:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_67771
loc_6779C:
mov [rcx], rax
mov [r8], rdi
pop rbp
retn
loc_677A4:
cmp r10b, 20h ; ' '
setnz r9b
cmp rdx, rdi
setnb dil
or dil, r9b
jnz short loc_67747
mov rdi, rax
loc_677BB:
mov rax, rdi
cmp rdi, rdx
jbe short loc_67747
lea rdi, [rax-4]
cmp dword ptr [rax-4], 20202020h
jz short loc_677BB
jmp loc_67747
| long long my_hash_sort_8bit_bin(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdi
unsigned long long v7; // rdx
unsigned __int8 *v8; // rax
char v9; // r10
long long v10; // rdi
unsigned long long v11; // rdx
long long v12; // r9
long long result; // rax
long long v14; // rdi
unsigned long long v15; // rdi
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = &a2[a3];
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = (unsigned __int8 *)v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v15 = v5;
do
{
v8 = (unsigned __int8 *)v15;
if ( v15 <= v7 )
break;
v15 -= 4LL;
}
while ( *((_DWORD *)v8 - 1) == 538976288 );
}
}
LABEL_8:
v10 = v8 - a2;
do
{
v11 = (unsigned long long)v8;
v12 = v10;
if ( v8 <= a2 )
break;
--v8;
--v10;
}
while ( *(_BYTE *)(v11 - 1) == 32 );
result = *a4;
v14 = *a5;
if ( v12 > 0 )
{
do
{
result ^= (v14 + (result & 0x3F)) * *a2 + (result << 8);
v14 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v11 );
}
*a4 = result;
*a5 = v14;
return result;
}
| my_hash_sort_8bit_bin:
PUSH RBP
MOV RBP,RSP
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x00167744
MOV RDI,R9
AND RDI,-0x4
CMP RDI,RSI
JBE 0x00167744
LEA RDX,[RSI + 0x3]
AND RDX,-0x4
LAB_0016772c:
MOV RAX,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDI
JBE 0x001677a4
LEA R9,[RAX + -0x1]
CMP R10B,0x20
JZ 0x0016772c
JMP 0x00167747
LAB_00167744:
MOV RAX,R9
LAB_00167747:
MOV RDI,RAX
SUB RDI,RSI
LAB_0016774d:
MOV RDX,RAX
MOV R9,RDI
CMP RAX,RSI
JBE 0x00167766
LEA RAX,[RDX + -0x1]
LEA RDI,[R9 + -0x1]
CMP byte ptr [RDX + -0x1],0x20
JZ 0x0016774d
LAB_00167766:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST R9,R9
JLE 0x0016779c
LAB_00167771:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00167771
LAB_0016779c:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
POP RBP
RET
LAB_001677a4:
CMP R10B,0x20
SETNZ R9B
CMP RDX,RDI
SETNC DIL
OR DIL,R9B
JNZ 0x00167747
MOV RDI,RAX
LAB_001677bb:
MOV RAX,RDI
CMP RDI,RDX
JBE 0x00167747
LEA RDI,[RAX + -0x4]
CMP dword ptr [RAX + -0x4],0x20202020
JZ 0x001677bb
JMP 0x00167747
|
void my_hash_sort_8bit_bin
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
byte *pbVar2;
ulong uVar3;
byte *pbVar4;
long lVar5;
long lVar6;
pbVar2 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar2 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar2;
do {
pbVar2 = pbVar1;
if (pbVar2 <= pbVar4) {
pbVar1 = pbVar2;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar2[-1] == 0x20)
goto LAB_001677bb;
break;
}
pbVar1 = pbVar2 + -1;
} while (pbVar2[-1] == 0x20);
}
goto LAB_00167747;
while (pbVar1 = pbVar2 + -4, *(int *)(pbVar2 + -4) == 0x20202020) {
LAB_001677bb:
pbVar2 = pbVar1;
if (pbVar2 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_00167747:
lVar6 = (long)pbVar2 - (long)param_2;
do {
lVar5 = lVar6;
pbVar4 = pbVar2;
if (pbVar4 <= param_2) break;
pbVar2 = pbVar4 + -1;
lVar6 = lVar5 + -1;
} while (pbVar4[-1] == 0x20);
uVar3 = *param_4;
lVar6 = *param_5;
if (0 < lVar5) {
do {
uVar3 = uVar3 ^ uVar3 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar3 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar4);
}
*param_4 = uVar3;
*param_5 = lVar6;
return;
}
| |
24,936 | find_blob | eloqsql/storage/maria/ma_bitmap.c | static my_bool find_blob(MARIA_HA *info, ulong length)
{
MARIA_FILE_BITMAP *bitmap= &info->s->bitmap;
uint full_page_size= FULL_PAGE_SIZE(info->s);
ulong pages;
uint rest_length, used;
uint UNINIT_VAR(first_block_pos);
MARIA_BITMAP_BLOCK *first_block= 0;
DBUG_ENTER("find_blob");
DBUG_PRINT("enter", ("length: %lu", length));
pages= length / full_page_size;
rest_length= (uint) (length - pages * full_page_size);
if (rest_length >= MAX_TAIL_SIZE(info->s->block_size))
{
pages++;
rest_length= 0;
}
first_block_pos= info->bitmap_blocks.elements;
if (pages)
{
MARIA_BITMAP_BLOCK *block;
if (allocate_dynamic(&info->bitmap_blocks,
info->bitmap_blocks.elements +
pages / BLOB_SEGMENT_MIN_SIZE + 2))
DBUG_RETURN(1);
block= dynamic_element(&info->bitmap_blocks, info->bitmap_blocks.elements,
MARIA_BITMAP_BLOCK*);
do
{
/*
We use 0x3fff here as the two upmost bits are reserved for
TAIL_BIT and START_EXTENT_BIT
*/
used= allocate_full_pages(bitmap,
(pages >= 0x3fff ? 0x3fff : (uint) pages),
block, 0);
if (!used)
{
if (move_to_next_bitmap(info, bitmap))
DBUG_RETURN(1);
}
else
{
pages-= used;
info->bitmap_blocks.elements++;
block++;
}
} while (pages != 0);
}
if (rest_length && find_tail(info, rest_length,
info->bitmap_blocks.elements++))
DBUG_RETURN(1);
first_block= dynamic_element(&info->bitmap_blocks, first_block_pos,
MARIA_BITMAP_BLOCK*);
first_block->sub_blocks= info->bitmap_blocks.elements - first_block_pos;
DBUG_RETURN(0);
} | O0 | c | find_blob:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x7bc(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movl 0xc18(%rcx), %ecx
addl $0x8, %ecx
subl %ecx, %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
jmp 0x44cd6
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %edx
imulq %rdx, %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
imull $0x3, 0x7bc(%rcx), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jb 0x44d26
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c8(%rax), %eax
movl %eax, -0x3c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x44e36
movq -0x10(%rbp), %rdi
addq $0x2c0, %rdi # imm = 0x2C0
movq -0x10(%rbp), %rax
movl 0x2c8(%rax), %eax
movq -0x30(%rbp), %rcx
shrq $0x7, %rcx
addq %rcx, %rax
addq $0x2, %rax
movl %eax, %esi
callq 0xdac50
cmpb $0x0, %al
je 0x44d78
jmp 0x44d6f
movb $0x1, -0x1(%rbp)
jmp 0x44e9e
movq -0x10(%rbp), %rax
movq 0x2c0(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x2c8(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x3fff, -0x30(%rbp) # imm = 0x3FFF
jb 0x44db4
movl $0x3fff, %eax # imm = 0x3FFF
movl %eax, -0x5c(%rbp)
jmp 0x44dbb
movq -0x30(%rbp), %rax
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
movq -0x50(%rbp), %rdx
xorl %ecx, %ecx
callq 0x44eb0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jne 0x44df8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x44a30
cmpb $0x0, %al
je 0x44df6
jmp 0x44ded
movb $0x1, -0x1(%rbp)
jmp 0x44e9e
jmp 0x44e27
movl -0x38(%rbp), %eax
movl %eax, %ecx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x2c8(%rax)
movq -0x50(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x50(%rbp)
jmp 0x44e29
cmpq $0x0, -0x30(%rbp)
jne 0x44d98
jmp 0x44e36
cmpl $0x0, -0x34(%rbp)
je 0x44e6d
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x10(%rbp), %rax
movl 0x2c8(%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, 0x2c8(%rax)
callq 0x45400
movsbl %al, %eax
cmpl $0x0, %eax
je 0x44e6d
jmp 0x44e67
movb $0x1, -0x1(%rbp)
jmp 0x44e9e
movq -0x10(%rbp), %rax
movq 0x2c0(%rax), %rax
movl -0x3c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl 0x2c8(%rax), %ecx
subl -0x3c(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x10(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| find_blob:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
add rax, 0A10h
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+7BCh]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
mov ecx, [rcx+0C18h]
add ecx, 8
sub eax, ecx
sub eax, 4
mov [rbp+var_24], eax
mov eax, [rbp+var_3C]
mov [rbp+var_3C], eax
mov [rbp+var_48], 0
jmp short $+2
loc_44CD6:
mov rax, [rbp+var_18]
mov ecx, [rbp+var_24]
xor edx, edx
div rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
mov edx, [rbp+var_24]
imul rcx, rdx
sub rax, rcx
mov [rbp+var_34], eax
mov eax, [rbp+var_34]
mov rcx, [rbp+var_10]
mov rcx, [rcx]
imul ecx, [rcx+7BCh], 3
shr ecx, 2
cmp eax, ecx
jb short loc_44D26
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov [rbp+var_34], 0
loc_44D26:
mov rax, [rbp+var_10]
mov eax, [rax+2C8h]
mov [rbp+var_3C], eax
cmp [rbp+var_30], 0
jz loc_44E36
mov rdi, [rbp+var_10]
add rdi, 2C0h
mov rax, [rbp+var_10]
mov eax, [rax+2C8h]
mov rcx, [rbp+var_30]
shr rcx, 7
add rax, rcx
add rax, 2
mov esi, eax
call allocate_dynamic
cmp al, 0
jz short loc_44D78
jmp short $+2
loc_44D6F:
mov [rbp+var_1], 1
jmp loc_44E9E
loc_44D78:
mov rax, [rbp+var_10]
mov rax, [rax+2C0h]
mov rcx, [rbp+var_10]
mov ecx, [rcx+2C8h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_50], rax
loc_44D98:
mov rax, [rbp+var_20]
mov [rbp+var_58], rax
cmp [rbp+var_30], 3FFFh
jb short loc_44DB4
mov eax, 3FFFh
mov [rbp+var_5C], eax
jmp short loc_44DBB
loc_44DB4:
mov rax, [rbp+var_30]
mov [rbp+var_5C], eax
loc_44DBB:
mov rdi, [rbp+var_58]
mov eax, [rbp+var_5C]
mov eax, eax
mov esi, eax
mov rdx, [rbp+var_50]
xor ecx, ecx
call allocate_full_pages
mov [rbp+var_38], eax
cmp [rbp+var_38], 0
jnz short loc_44DF8
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_20]
call move_to_next_bitmap
cmp al, 0
jz short loc_44DF6
jmp short $+2
loc_44DED:
mov [rbp+var_1], 1
jmp loc_44E9E
loc_44DF6:
jmp short loc_44E27
loc_44DF8:
mov eax, [rbp+var_38]
mov ecx, eax
mov rax, [rbp+var_30]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov ecx, [rax+2C8h]
add ecx, 1
mov [rax+2C8h], ecx
mov rax, [rbp+var_50]
add rax, 18h
mov [rbp+var_50], rax
loc_44E27:
jmp short $+2
loc_44E29:
cmp [rbp+var_30], 0
jnz loc_44D98
jmp short $+2
loc_44E36:
cmp [rbp+var_34], 0
jz short loc_44E6D
mov rdi, [rbp+var_10]
mov esi, [rbp+var_34]
mov rax, [rbp+var_10]
mov edx, [rax+2C8h]
mov ecx, edx
add ecx, 1
mov [rax+2C8h], ecx
call find_tail
movsx eax, al
cmp eax, 0
jz short loc_44E6D
jmp short $+2
loc_44E67:
mov [rbp+var_1], 1
jmp short loc_44E9E
loc_44E6D:
mov rax, [rbp+var_10]
mov rax, [rax+2C0h]
mov ecx, [rbp+var_3C]
imul rcx, 18h
add rax, rcx
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
mov ecx, [rax+2C8h]
sub ecx, [rbp+var_3C]
mov rax, [rbp+var_48]
mov [rax+10h], ecx
mov [rbp+var_1], 0
loc_44E9E:
mov al, [rbp+var_1]
add rsp, 60h
pop rbp
retn
| char find_blob(long long a1, unsigned long long a2)
{
long long v2; // rdx
unsigned int v4; // [rsp+4h] [rbp-5Ch]
long long v5; // [rsp+10h] [rbp-50h]
unsigned int v6; // [rsp+24h] [rbp-3Ch]
unsigned int full_pages; // [rsp+28h] [rbp-38h]
unsigned int v8; // [rsp+2Ch] [rbp-34h]
unsigned long long v9; // [rsp+30h] [rbp-30h]
unsigned int v10; // [rsp+3Ch] [rbp-24h]
long long v11; // [rsp+40h] [rbp-20h]
v11 = *(_QWORD *)a1 + 2576LL;
v10 = *(_DWORD *)(*(_QWORD *)a1 + 1980LL) - (*(_DWORD *)(*(_QWORD *)a1 + 3096LL) + 8) - 4;
v9 = a2 / v10;
v8 = a2 % v10;
if ( v8 >= (unsigned int)(3 * *(_DWORD *)(*(_QWORD *)a1 + 1980LL)) >> 2 )
{
++v9;
v8 = 0;
}
v6 = *(_DWORD *)(a1 + 712);
if ( v9 )
{
if ( !(unsigned __int8)allocate_dynamic(a1 + 704, (unsigned int)(v9 >> 7) + *(_DWORD *)(a1 + 712) + 2) )
{
v5 = 24LL * *(unsigned int *)(a1 + 712) + *(_QWORD *)(a1 + 704);
while ( 1 )
{
if ( v9 < 0x3FFF )
v4 = v9;
else
v4 = 0x3FFF;
full_pages = allocate_full_pages(v11, v4, v5, 0LL);
if ( full_pages )
{
v9 -= full_pages;
++*(_DWORD *)(a1 + 712);
v5 += 24LL;
}
else if ( move_to_next_bitmap((long long *)a1, v11) )
{
return 1;
}
if ( !v9 )
goto LABEL_16;
}
}
return 1;
}
else
{
LABEL_16:
if ( v8 && (v2 = *(unsigned int *)(a1 + 712), ++*(_DWORD *)(a1 + 712), (unsigned __int8)find_tail(a1, v8, v2)) )
{
return 1;
}
else
{
*(_DWORD *)(24LL * v6 + *(_QWORD *)(a1 + 704) + 16) = *(_DWORD *)(a1 + 712) - v6;
return 0;
}
}
}
| find_blob:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
ADD RAX,0xa10
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0xc18]
ADD ECX,0x8
SUB EAX,ECX
SUB EAX,0x4
MOV dword ptr [RBP + -0x24],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x3c],EAX
MOV qword ptr [RBP + -0x48],0x0
JMP 0x00144cd6
LAB_00144cd6:
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x24]
IMUL RCX,RDX
SUB RAX,RCX
MOV dword ptr [RBP + -0x34],EAX
MOV EAX,dword ptr [RBP + -0x34]
MOV RCX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RCX]
IMUL ECX,dword ptr [RCX + 0x7bc],0x3
SHR ECX,0x2
CMP EAX,ECX
JC 0x00144d26
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV dword ptr [RBP + -0x34],0x0
LAB_00144d26:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c8]
MOV dword ptr [RBP + -0x3c],EAX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x00144e36
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2c0
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x2c8]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x7
ADD RAX,RCX
ADD RAX,0x2
MOV ESI,EAX
CALL 0x001dac50
CMP AL,0x0
JZ 0x00144d78
JMP 0x00144d6f
LAB_00144d6f:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00144e9e
LAB_00144d78:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x2c8]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_00144d98:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x58],RAX
CMP qword ptr [RBP + -0x30],0x3fff
JC 0x00144db4
MOV EAX,0x3fff
MOV dword ptr [RBP + -0x5c],EAX
JMP 0x00144dbb
LAB_00144db4:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RBP + -0x5c],EAX
LAB_00144dbb:
MOV RDI,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RBP + -0x5c]
MOV EAX,EAX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x50]
XOR ECX,ECX
CALL 0x00144eb0
MOV dword ptr [RBP + -0x38],EAX
CMP dword ptr [RBP + -0x38],0x0
JNZ 0x00144df8
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x00144a30
CMP AL,0x0
JZ 0x00144df6
JMP 0x00144ded
LAB_00144ded:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00144e9e
LAB_00144df6:
JMP 0x00144e27
LAB_00144df8:
MOV EAX,dword ptr [RBP + -0x38]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2c8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x2c8],ECX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,0x18
MOV qword ptr [RBP + -0x50],RAX
LAB_00144e27:
JMP 0x00144e29
LAB_00144e29:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00144d98
JMP 0x00144e36
LAB_00144e36:
CMP dword ptr [RBP + -0x34],0x0
JZ 0x00144e6d
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x2c8]
MOV ECX,EDX
ADD ECX,0x1
MOV dword ptr [RAX + 0x2c8],ECX
CALL 0x00145400
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x00144e6d
JMP 0x00144e67
LAB_00144e67:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00144e9e
LAB_00144e6d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2c0]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x2c8]
SUB ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX + 0x10],ECX
MOV byte ptr [RBP + -0x1],0x0
LAB_00144e9e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x60
POP RBP
RET
|
int1 find_blob(long *param_1,ulong param_2)
{
long lVar1;
char cVar2;
uint uVar3;
uint uVar4;
int4 local_64;
long local_58;
uint local_3c;
ulong local_38;
lVar1 = *param_1;
uVar3 = (*(int *)(*param_1 + 0x7bc) - (*(int *)(*param_1 + 0xc18) + 8)) - 4;
local_38 = param_2 / uVar3;
local_3c = (int)param_2 - (int)local_38 * uVar3;
if ((uint)(*(int *)(*param_1 + 0x7bc) * 3) >> 2 <= local_3c) {
local_38 = local_38 + 1;
local_3c = 0;
}
uVar3 = *(uint *)(param_1 + 0x59);
if (local_38 != 0) {
cVar2 = allocate_dynamic(param_1 + 0x58,(int)param_1[0x59] + (int)(local_38 >> 7) + 2);
if (cVar2 != '\0') {
return 1;
}
local_58 = param_1[0x58] + (ulong)*(uint *)(param_1 + 0x59) * 0x18;
do {
if (local_38 < 0x3fff) {
local_64 = (int4)local_38;
}
else {
local_64 = 0x3fff;
}
uVar4 = allocate_full_pages(lVar1 + 0xa10,local_64,local_58,0);
if (uVar4 == 0) {
cVar2 = move_to_next_bitmap(param_1,lVar1 + 0xa10);
if (cVar2 != '\0') {
return 1;
}
}
else {
local_38 = local_38 - uVar4;
*(int *)(param_1 + 0x59) = (int)param_1[0x59] + 1;
local_58 = local_58 + 0x18;
}
} while (local_38 != 0);
}
if (local_3c != 0) {
*(int *)(param_1 + 0x59) = (int)param_1[0x59] + 1;
cVar2 = find_tail(param_1,local_3c);
if (cVar2 != '\0') {
return 1;
}
}
*(uint *)(param_1[0x58] + (ulong)uVar3 * 0x18 + 0x10) = (int)param_1[0x59] - uVar3;
return 0;
}
| |
24,937 | mysql_close_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_close_cont(MYSQL *sock, int ready_status)
{
int res;
res= mysql_close_slow_part_cont(sock, ready_status);
if (res)
return res;
mysql_close(sock);
return 0;
} | O3 | c | mysql_close_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a67b
movl %eax, %r14d
testl %eax, %eax
jne 0x2a7b1
movq %rbx, %rdi
callq 0x1a94c
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
| mysql_close_cont:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call mysql_close_slow_part_cont
mov r14d, eax
test eax, eax
jnz short loc_2A7B1
mov rdi, rbx
call mysql_close
loc_2A7B1:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
| long long mysql_close_cont(long long a1, unsigned int a2)
{
unsigned int v2; // r14d
v2 = mysql_close_slow_part_cont(a1, a2);
if ( !v2 )
mysql_close(a1);
return v2;
}
| mysql_close_cont:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x0012a67b
MOV R14D,EAX
TEST EAX,EAX
JNZ 0x0012a7b1
MOV RDI,RBX
CALL 0x0011a94c
LAB_0012a7b1:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int mysql_close_cont(int8 param_1)
{
int iVar1;
iVar1 = mysql_close_slow_part_cont();
if (iVar1 == 0) {
mysql_close(param_1);
}
return iVar1;
}
| |
24,938 | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type) | monkey531[P]llama/common/json.hpp | static const char* token_type_name(const token_type t) noexcept
{
switch (t)
{
case token_type::uninitialized:
return "<uninitialized>";
case token_type::literal_true:
return "true literal";
case token_type::literal_false:
return "false literal";
case token_type::literal_null:
return "null literal";
case token_type::value_string:
return "string literal";
case token_type::value_unsigned:
case token_type::value_integer:
case token_type::value_float:
return "number literal";
case token_type::begin_array:
return "'['";
case token_type::begin_object:
return "'{'";
case token_type::end_array:
return "']'";
case token_type::end_object:
return "'}'";
case token_type::name_separator:
return "':'";
case token_type::value_separator:
return "','";
case token_type::parse_error:
return "<parse error>";
case token_type::end_of_input:
return "end of input";
case token_type::literal_or_value:
return "'[', '{', or a literal";
// LCOV_EXCL_START
default: // catch non-enum values
return "unknown token";
// LCOV_EXCL_STOP
}
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type):
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x10, %rax
ja 0xbcb70
movq -0x18(%rsp), %rax
leaq 0x14c5a9(%rip), %rcx # 0x20902c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x152c7a(%rip), %rax # 0x20f70d
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c79(%rip), %rax # 0x20f71d
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c75(%rip), %rax # 0x20f72a
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c72(%rip), %rax # 0x20f738
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c6e(%rip), %rax # 0x20f745
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c6c(%rip), %rax # 0x20f754
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c6a(%rip), %rax # 0x20f763
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c60(%rip), %rax # 0x20f767
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c56(%rip), %rax # 0x20f76b
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c4c(%rip), %rax # 0x20f76f
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c42(%rip), %rax # 0x20f773
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c38(%rip), %rax # 0x20f777
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c2e(%rip), %rax # 0x20f77b
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x15e6de(%rip), %rax # 0x21b239
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c20(%rip), %rax # 0x20f789
movq %rax, -0x8(%rsp)
jmp 0xbcb7c
leaq 0x152c29(%rip), %rax # 0x20f7a0
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
mov [rsp+var_C], edi
mov eax, [rsp+var_C]
mov [rsp+var_18], rax
sub rax, 10h; switch 17 cases
ja def_BCA8A; jumptable 00000000000BCA8A default case
mov rax, [rsp+var_18]
lea rcx, jpt_BCA8A
movsxd rax, ds:(jpt_BCA8A - 20902Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_BCA8C:
lea rax, aUninitialized; jumptable 00000000000BCA8A case 0
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCA9D:
lea rax, aTrueLiteral; jumptable 00000000000BCA8A case 1
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCAAE:
lea rax, aFalseLiteral; jumptable 00000000000BCA8A case 2
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCABF:
lea rax, aNullLiteral; jumptable 00000000000BCA8A case 3
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCAD0:
lea rax, aStringLiteral; jumptable 00000000000BCA8A case 4
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCAE1:
lea rax, aNumberLiteral; jumptable 00000000000BCA8A cases 5-7
mov [rsp+var_8], rax
jmp loc_BCB7C
loc_BCAF2:
lea rax, asc_20F763; jumptable 00000000000BCA8A case 8
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB00:
lea rax, asc_20F767; jumptable 00000000000BCA8A case 9
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB0E:
lea rax, asc_20F76B; jumptable 00000000000BCA8A case 10
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB1C:
lea rax, asc_20F76F; jumptable 00000000000BCA8A case 11
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB2A:
lea rax, asc_20F773; jumptable 00000000000BCA8A case 12
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB38:
lea rax, asc_20F777; jumptable 00000000000BCA8A case 13
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB46:
lea rax, aParseError_1; jumptable 00000000000BCA8A case 14
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB54:
lea rax, aUnexpectedEndO_7+0Bh; jumptable 00000000000BCA8A case 15
mov [rsp+var_8], rax
jmp short loc_BCB7C
loc_BCB62:
lea rax, aOrALiteral; jumptable 00000000000BCA8A case 16
mov [rsp+var_8], rax
jmp short loc_BCB7C
def_BCA8A:
lea rax, aUnknownToken; jumptable 00000000000BCA8A default case
mov [rsp+var_8], rax
loc_BCB7C:
mov rax, [rsp+var_8]
retn
| char * nlohmann::json_abi_v3_11_3::detail::lexer_base<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>>::token_type_name(
int a1)
{
char *v2; // [rsp+10h] [rbp-8h]
switch ( a1 )
{
case 0:
v2 = "<uninitialized>";
break;
case 1:
v2 = "true literal";
break;
case 2:
v2 = "false literal";
break;
case 3:
v2 = "null literal";
break;
case 4:
v2 = "string literal";
break;
case 5:
case 6:
case 7:
v2 = "number literal";
break;
case 8:
v2 = "'['";
break;
case 9:
v2 = "'{'";
break;
case 10:
v2 = "']'";
break;
case 11:
v2 = "'}'";
break;
case 12:
v2 = "':'";
break;
case 13:
v2 = "','";
break;
case 14:
v2 = "<parse error>";
break;
case 15:
v2 = "end of input";
break;
case 16:
v2 = "'[', '{', or a literal";
break;
default:
v2 = "unknown token";
break;
}
return v2;
}
| token_type_name:
MOV dword ptr [RSP + -0xc],EDI
MOV EAX,dword ptr [RSP + -0xc]
MOV qword ptr [RSP + -0x18],RAX
SUB RAX,0x10
JA 0x001bcb70
MOV RAX,qword ptr [RSP + -0x18]
LEA RCX,[0x30902c]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RAX,[0x30f70d]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_1:
LEA RAX,[0x30f71d]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_2:
LEA RAX,[0x30f72a]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_3:
LEA RAX,[0x30f738]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_4:
LEA RAX,[0x30f745]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_5:
LEA RAX,[0x30f754]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_8:
LEA RAX,[0x30f763]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_9:
LEA RAX,[0x30f767]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_a:
LEA RAX,[0x30f76b]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_b:
LEA RAX,[0x30f76f]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_c:
LEA RAX,[0x30f773]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_d:
LEA RAX,[0x30f777]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_e:
LEA RAX,[0x30f77b]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_f:
LEA RAX,[0x31b239]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
caseD_10:
LEA RAX,[0x30f789]
MOV qword ptr [RSP + -0x8],RAX
JMP 0x001bcb7c
default:
LEA RAX,[0x30f7a0]
MOV qword ptr [RSP + -0x8],RAX
LAB_001bcb7c:
MOV RAX,qword ptr [RSP + -0x8]
RET
|
/* nlohmann::json_abi_v3_11_3::detail::lexer_base<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>
>::token_type_name(nlohmann::json_abi_v3_11_3::detail::lexer_base<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> >::token_type) */
char * nlohmann::json_abi_v3_11_3::detail::
lexer_base<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>>
::token_type_name(int4 param_1)
{
char *local_8;
switch(param_1) {
case 0:
local_8 = "<uninitialized>";
break;
case 1:
local_8 = "true literal";
break;
case 2:
local_8 = "false literal";
break;
case 3:
local_8 = "null literal";
break;
case 4:
local_8 = "string literal";
break;
case 5:
case 6:
case 7:
local_8 = "number literal";
break;
case 8:
local_8 = "\'[\'";
break;
case 9:
local_8 = "\'{\'";
break;
case 10:
local_8 = "\']\'";
break;
case 0xb:
local_8 = "\'}\'";
break;
case 0xc:
local_8 = "\':\'";
break;
case 0xd:
local_8 = "\',\'";
break;
case 0xe:
local_8 = "<parse error>";
break;
case 0xf:
local_8 = "end of input";
break;
case 0x10:
local_8 = "\'[\', \'{\', or a literal";
break;
default:
local_8 = "unknown token";
}
return local_8;
}
| |
24,939 | sp_update_stmt_used_routines(THD*, Query_tables_list*, SQL_I_List<Sroutine_hash_entry>*, TABLE_LIST*) | eloqsql/sql/sp.cc | void sp_update_stmt_used_routines(THD *thd, Query_tables_list *prelocking_ctx,
SQL_I_List<Sroutine_hash_entry> *src,
TABLE_LIST *belong_to_view)
{
for (Sroutine_hash_entry *rt= src->first; rt; rt= rt->next)
(void)sp_add_used_routine(prelocking_ctx, thd->stmt_arena,
&rt->mdl_request.key, rt->m_handler,
belong_to_view);
} | O0 | cpp | sp_update_stmt_used_routines(THD*, Query_tables_list*, SQL_I_List<Sroutine_hash_entry>*, TABLE_LIST*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xa6c3a7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x3a40(%rax), %rsi
movq -0x28(%rbp), %rdx
addq $0x20, %rdx
movq -0x28(%rbp), %rax
movq 0x1d8(%rax), %rcx
movq -0x20(%rbp), %r8
callq 0xa6b5c0
movq -0x28(%rbp), %rax
movq 0x1c0(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa6c364
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| _Z28sp_update_stmt_used_routinesP3THDP17Query_tables_listP10SQL_I_ListI19Sroutine_hash_entryEP10TABLE_LIST:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_A6C364:
cmp [rbp+var_28], 0
jz short loc_A6C3A7
mov rdi, [rbp+var_10]; Query_tables_list *
mov rax, [rbp+var_8]
mov rsi, [rax+3A40h]; Query_arena *
mov rdx, [rbp+var_28]
add rdx, 20h ; ' '; MDL_key *
mov rax, [rbp+var_28]
mov rcx, [rax+1D8h]; Sp_handler *
mov r8, [rbp+var_20]; TABLE_LIST *
call _Z19sp_add_used_routineP17Query_tables_listP11Query_arenaPK7MDL_keyPK10Sp_handlerP10TABLE_LIST; sp_add_used_routine(Query_tables_list *,Query_arena *,MDL_key const*,Sp_handler const*,TABLE_LIST *)
mov rax, [rbp+var_28]
mov rax, [rax+1C0h]
mov [rbp+var_28], rax
jmp short loc_A6C364
loc_A6C3A7:
add rsp, 30h
pop rbp
retn
| long long sp_update_stmt_used_routines(long long a1, Query_tables_list *a2, long long a3, TABLE_LIST *a4)
{
long long result; // rax
long long i; // [rsp+8h] [rbp-28h]
result = *(_QWORD *)(a3 + 8);
for ( i = result; i; i = result )
{
sp_add_used_routine(
a2,
*(Query_arena **)(a1 + 14912),
(const MDL_key *)(i + 32),
*(const Sp_handler **)(i + 472),
a4);
result = *(_QWORD *)(i + 448);
}
return result;
}
| val_real:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,RDI
ADD RSI,0x28
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x108]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00a6c3b6
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x005ad5d0
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x8
CALL 0x005a84d0
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x8
CALL 0x005a84f0
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x30]
MOV EAX,EAX
MOV EDX,EAX
LEA RCX,[RBP + -0x18]
LEA R8,[RBP + -0xc]
CALL 0x005bc050
MOVSD qword ptr [RBP + -0x28],XMM0
JMP 0x00a6c3c0
LAB_00a6c3b6:
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x28],XMM0
JMP 0x00a6c3c0
LAB_00a6c3c0:
MOVSD XMM0,qword ptr [RBP + -0x28]
ADD RSP,0x40
POP RBP
RET
|
/* Item_func_udf_str::val_real() */
int8 __thiscall Item_func_udf_str::val_real(Item_func_udf_str *this)
{
uint uVar1;
Charset *this_00;
charset_info_st *this_01;
char *pcVar2;
int8 local_30;
char *local_20;
int local_14;
Item_func_udf_str *local_10;
local_10 = this;
this_00 = (Charset *)(**(code **)(*(long *)this + 0x108))(this,this + 0x28);
if (this_00 == (Charset *)0x0) {
local_30 = 0;
}
else {
this_01 = (charset_info_st *)Charset::charset(this_00);
pcVar2 = (char *)Binary_string::ptr((Binary_string *)(this_00 + 8));
uVar1 = Binary_string::length((Binary_string *)(this_00 + 8));
local_30 = charset_info_st::strntod(this_01,pcVar2,(ulong)uVar1,&local_20,&local_14);
}
return local_30;
}
| |
24,940 | ssz_is_type | corpus-core[P]colibri-stateless/src/util/ssz.c | bool ssz_is_type(ssz_ob_t* ob, const ssz_def_t* def) {
if (!ob || !ob->def || !def) return false;
if (ob->def == def) return true;
if (ob->def->type == SSZ_TYPE_UNION) {
ssz_ob_t union_ob = ssz_union(*ob);
return ssz_is_type(&union_ob, def);
}
if (ob->def->type == SSZ_TYPE_CONTAINER) return ob->def->def.container.elements == def;
if (ob->def->type == SSZ_TYPE_LIST) return ob->def->def.vector.type == def;
switch (def->type) {
case SSZ_TYPE_UINT:
return def->type == SSZ_TYPE_UINT && ob->def->def.uint.len == def->def.uint.len;
case SSZ_TYPE_BOOLEAN:
return def->type == SSZ_TYPE_BOOLEAN;
case SSZ_TYPE_BIT_LIST:
return def->type == SSZ_TYPE_BIT_LIST && ob->def->def.uint.len == def->def.uint.len;
case SSZ_TYPE_BIT_VECTOR:
return def->type == SSZ_TYPE_BIT_VECTOR && ob->def->def.uint.len == def->def.uint.len;
case SSZ_TYPE_CONTAINER:
return ob->def->def.container.elements == def;
case SSZ_TYPE_VECTOR: {
ssz_ob_t el = {.def = ob->def->def.vector.type, .bytes = ob->bytes};
return def->type == SSZ_TYPE_VECTOR && ob->def->def.uint.len == def->def.uint.len && ssz_is_type(&el, def->def.vector.type);
}
case SSZ_TYPE_LIST: {
ssz_ob_t el = {.def = ob->def->def.vector.type, .bytes = ob->bytes};
return def->type == SSZ_TYPE_LIST && ob->def->def.uint.len == def->def.uint.len && ssz_is_type(&el, def->def.vector.type);
}
default:
return false;
}
} | O3 | c | ssz_is_type:
subq $0x18, %rsp
testq %rdi, %rdi
je 0x5497e
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
sete %al
testq %rsi, %rsi
sete %dl
orb %al, %dl
jne 0x5497e
movb $0x1, %al
cmpq %rsi, %rcx
je 0x54980
movl 0x8(%rcx), %edx
cmpl $0x2, %edx
je 0x54952
cmpl $0x4, %edx
je 0x54952
cmpl $0x7, %edx
jne 0x54931
movl (%rdi), %eax
movq 0x8(%rdi), %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
testq %rdx, %rdx
setne %dil
testl %eax, %eax
setne %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x54974
movzbl (%rdx), %edi
cmpl %edi, 0x18(%rcx)
jbe 0x54974
movq 0x10(%rcx), %rcx
shll $0x5, %edi
leaq (%rcx,%rdi), %r8
movq %r8, 0x10(%rsp)
cmpl $0x8, 0x8(%rcx,%rdi)
je 0x54974
decl %eax
incq %rdx
movl %eax, (%rsp)
movq %rdx, 0x8(%rsp)
jmp 0x54974
movl 0x8(%rsi), %edx
cmpq $0x6, %rdx
ja 0x5497e
leaq 0x3787f(%rip), %r8 # 0x8c1c0
movslq (%r8,%rdx,4), %rdx
addq %r8, %rdx
jmpq *%rdx
movl 0x10(%rcx), %eax
cmpl 0x10(%rsi), %eax
jmp 0x54956
cmpq %rsi, 0x10(%rcx)
sete %al
jmp 0x54980
movups (%rdi), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rcx), %rax
movq %rax, 0x10(%rsp)
cmpl %eax, 0x10(%rsi)
jne 0x5497e
movq 0x10(%rsi), %rsi
movq %rsp, %rdi
callq 0x5488d
jmp 0x54980
xorl %eax, %eax
addq $0x18, %rsp
retq
| ssz_is_type:
sub rsp, 18h
test rdi, rdi
jz def_54948; jumptable 0000000000054948 default case
mov rcx, [rdi+10h]
test rcx, rcx
setz al
test rsi, rsi
setz dl
or dl, al
jnz def_54948; jumptable 0000000000054948 default case
mov al, 1
cmp rcx, rsi
jz loc_54980; jumptable 0000000000054948 case 1
mov edx, [rcx+8]
cmp edx, 2
jz loc_54952; jumptable 0000000000054948 case 2
cmp edx, 4
jz loc_54952; jumptable 0000000000054948 case 2
cmp edx, 7
jnz short loc_54931
mov eax, [rdi]
mov rdx, [rdi+8]
xorps xmm0, xmm0
movaps [rsp+18h+var_18], xmm0
mov [rsp+18h+var_8], 0
test rdx, rdx
setnz dil
test eax, eax
setnz r8b
and r8b, dil
cmp r8b, 1
jnz short loc_54974
movzx edi, byte ptr [rdx]
cmp [rcx+18h], edi
jbe short loc_54974
mov rcx, [rcx+10h]
shl edi, 5
lea r8, [rcx+rdi]
mov [rsp+18h+var_8], r8
cmp dword ptr [rcx+rdi+8], 8
jz short loc_54974
dec eax
inc rdx
mov dword ptr [rsp+18h+var_18], eax
mov qword ptr [rsp+18h+var_18+8], rdx
jmp short loc_54974
loc_54931:
mov edx, [rsi+8]
cmp rdx, 6; switch 7 cases
ja short def_54948; jumptable 0000000000054948 default case
lea r8, jpt_54948
movsxd rdx, ds:(jpt_54948 - 8C1C0h)[r8+rdx*4]
add rdx, r8
jmp rdx; switch jump
loc_5494A:
mov eax, [rcx+10h]; jumptable 0000000000054948 cases 0,5,6
cmp eax, [rsi+10h]
jmp short loc_54956
loc_54952:
cmp [rcx+10h], rsi; jumptable 0000000000054948 case 2
loc_54956:
setz al
jmp short loc_54980; jumptable 0000000000054948 case 1
loc_5495B:
movups xmm0, xmmword ptr [rdi]; jumptable 0000000000054948 cases 3,4
movaps [rsp+18h+var_18], xmm0
mov rax, [rcx+10h]
mov [rsp+18h+var_8], rax
cmp [rsi+10h], eax
jnz short def_54948; jumptable 0000000000054948 default case
mov rsi, [rsi+10h]
loc_54974:
mov rdi, rsp
call ssz_is_type
jmp short loc_54980; jumptable 0000000000054948 case 1
def_54948:
xor eax, eax; jumptable 0000000000054948 default case
loc_54980:
add rsp, 18h; jumptable 0000000000054948 case 1
retn
| char ssz_is_type(__int128 *a1, long long a2)
{
long long v2; // rcx
char result; // al
int v4; // edx
int v5; // eax
unsigned __int8 *v6; // rdx
unsigned int v7; // edi
__int128 v9; // [rsp+0h] [rbp-18h] BYREF
long long v10; // [rsp+10h] [rbp-8h]
if ( !a1 )
return 0;
v2 = *((_QWORD *)a1 + 2);
if ( v2 == 0 || a2 == 0 )
return 0;
result = 1;
if ( v2 != a2 )
{
v4 = *(_DWORD *)(v2 + 8);
if ( v4 == 2 || v4 == 4 )
{
return *(_QWORD *)(v2 + 16) == a2;
}
else
{
if ( v4 != 7 )
{
switch ( *(_DWORD *)(a2 + 8) )
{
case 0:
case 5:
case 6:
return *(_DWORD *)(v2 + 16) == *(_DWORD *)(a2 + 16);
case 1:
return result;
case 2:
return *(_QWORD *)(v2 + 16) == a2;
case 3:
case 4:
v9 = *a1;
v10 = *(_QWORD *)(v2 + 16);
if ( *(_DWORD *)(a2 + 16) != (_DWORD)v10 )
return 0;
a2 = *(_QWORD *)(a2 + 16);
return ssz_is_type(&v9, a2);
default:
return 0;
}
}
v5 = *(_DWORD *)a1;
v6 = (unsigned __int8 *)*((_QWORD *)a1 + 1);
v9 = 0LL;
v10 = 0LL;
if ( v6 != 0LL && v5 != 0 )
{
v7 = *v6;
if ( *(_DWORD *)(v2 + 24) > v7 )
{
v10 = *(_QWORD *)(v2 + 16) + 32 * v7;
if ( *(_DWORD *)(v10 + 8) != 8 )
{
LODWORD(v9) = v5 - 1;
*((_QWORD *)&v9 + 1) = v6 + 1;
}
}
}
return ssz_is_type(&v9, a2);
}
}
return result;
}
| ssz_is_type:
SUB RSP,0x18
TEST RDI,RDI
JZ 0x0015497e
MOV RCX,qword ptr [RDI + 0x10]
TEST RCX,RCX
SETZ AL
TEST RSI,RSI
SETZ DL
OR DL,AL
JNZ 0x0015497e
MOV AL,0x1
CMP RCX,RSI
JZ 0x00154980
MOV EDX,dword ptr [RCX + 0x8]
CMP EDX,0x2
JZ 0x00154952
CMP EDX,0x4
JZ 0x00154952
CMP EDX,0x7
JNZ 0x00154931
MOV EAX,dword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
TEST RDX,RDX
SETNZ DIL
TEST EAX,EAX
SETNZ R8B
AND R8B,DIL
CMP R8B,0x1
JNZ 0x00154974
MOVZX EDI,byte ptr [RDX]
CMP dword ptr [RCX + 0x18],EDI
JBE 0x00154974
MOV RCX,qword ptr [RCX + 0x10]
SHL EDI,0x5
LEA R8,[RCX + RDI*0x1]
MOV qword ptr [RSP + 0x10],R8
CMP dword ptr [RCX + RDI*0x1 + 0x8],0x8
JZ 0x00154974
DEC EAX
INC RDX
MOV dword ptr [RSP],EAX
MOV qword ptr [RSP + 0x8],RDX
JMP 0x00154974
LAB_00154931:
MOV EDX,dword ptr [RSI + 0x8]
CMP RDX,0x6
JA 0x0015497e
LEA R8,[0x18c1c0]
MOVSXD RDX,dword ptr [R8 + RDX*0x4]
ADD RDX,R8
switchD:
JMP RDX
caseD_0:
MOV EAX,dword ptr [RCX + 0x10]
CMP EAX,dword ptr [RSI + 0x10]
JMP 0x00154956
caseD_2:
CMP qword ptr [RCX + 0x10],RSI
LAB_00154956:
SETZ AL
JMP 0x00154980
caseD_3:
MOVUPS XMM0,xmmword ptr [RDI]
MOVAPS xmmword ptr [RSP],XMM0
MOV RAX,qword ptr [RCX + 0x10]
MOV qword ptr [RSP + 0x10],RAX
CMP dword ptr [RSI + 0x10],EAX
JNZ 0x0015497e
MOV RSI,qword ptr [RSI + 0x10]
LAB_00154974:
MOV RDI,RSP
CALL 0x0015488d
JMP 0x00154980
default:
XOR EAX,EAX
caseD_1:
ADD RSP,0x18
RET
|
bool ssz_is_type(ulong *param_1,ulong param_2)
{
int iVar1;
ulong uVar2;
byte *pbVar3;
int1 uVar4;
long lVar5;
bool bVar6;
ulong local_18;
byte *pbStack_10;
long local_8;
if ((param_1 == (ulong *)0x0) || (uVar2 = param_1[2], param_2 == 0 || uVar2 == 0))
goto switchD_00154948_default;
bVar6 = true;
if (uVar2 == param_2) {
return true;
}
iVar1 = *(int *)(uVar2 + 8);
if ((iVar1 == 2) || (iVar1 == 4)) {
switchD_00154948_caseD_2:
bVar6 = *(ulong *)(uVar2 + 0x10) == param_2;
}
else {
if (iVar1 == 7) {
pbVar3 = (byte *)param_1[1];
local_18 = 0;
pbStack_10 = (byte *)0x0;
local_8 = 0;
if ((((int)*param_1 != 0 && pbVar3 != (byte *)0x0) &&
((uint)*pbVar3 < *(uint *)(uVar2 + 0x18))) &&
(lVar5 = (ulong)*pbVar3 * 0x20, local_8 = *(long *)(uVar2 + 0x10) + lVar5,
*(int *)(*(long *)(uVar2 + 0x10) + 8 + lVar5) != 8)) {
pbStack_10 = pbVar3 + 1;
local_18 = (ulong)((int)*param_1 - 1);
}
LAB_00154974:
uVar4 = ssz_is_type(&local_18,param_2);
return (bool)uVar4;
}
switch(*(int4 *)(param_2 + 8)) {
case 0:
case 5:
case 6:
bVar6 = *(int *)(uVar2 + 0x10) == *(int *)(param_2 + 0x10);
break;
case 1:
break;
case 2:
goto switchD_00154948_caseD_2;
case 3:
case 4:
local_18 = *param_1;
pbStack_10 = (byte *)param_1[1];
local_8 = *(long *)(uVar2 + 0x10);
if (*(int *)(param_2 + 0x10) == (int)local_8) {
param_2 = *(ulong *)(param_2 + 0x10);
goto LAB_00154974;
}
default:
switchD_00154948_default:
bVar6 = false;
}
}
return bVar6;
}
| |
24,941 | mju_writeNumBytes | aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_misc.c | const char* mju_writeNumBytes(size_t nbytes) {
int i;
static mjTHREADLOCAL char message[20];
static const char suffix[] = " KMGTPE";
for (i=0; i < 6; i++) {
const size_t bits = (size_t)(1) << (10*(6-i));
if (nbytes >= bits && !(nbytes & (bits - 1))) {
break;
}
}
if (i < 6) {
mjSNPRINTF(message, "%zu%c", nbytes >> (10*(6-i)), suffix[6-i]);
} else {
mjSNPRINTF(message, "%zu", nbytes >> (10*(6-i)));
}
return message;
} | O3 | c | mju_writeNumBytes:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x12f8db(%rip), %r12 # 0x1ce6a1
movl $0x3c, %r14d
movl $0x1, %eax
movl %r14d, %ecx
shlq %cl, %rax
cmpq %rbx, %rax
ja 0x9ede4
decq %rax
testq %rbx, %rax
je 0x9ee1b
decq %r12
addq $-0xa, %r14
jne 0x9edcc
leaq 0x1d30cc(%rip), %rdi # 0x271ec0
callq 0x2df10
leaq 0x30(%rax), %r15
leaq 0x12f8a2(%rip), %rdx # 0x1ce6a9
movl $0x14, %esi
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2d250
jmp 0x9ee52
leaq 0x1d309e(%rip), %rdi # 0x271ec0
callq 0x2df10
leaq 0x30(%rax), %r15
movl %r14d, %ecx
shrq %cl, %rbx
movsbl (%r12), %r8d
leaq 0x12f863(%rip), %rdx # 0x1ce6a3
movl $0x14, %esi
movq %r15, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2d250
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| mju_writeNumBytes:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
lea r12, mju_writeNumBytes_suffix+6; "E"
mov r14d, 3Ch ; '<'
loc_9EDCC:
mov eax, 1
mov ecx, r14d
shl rax, cl
cmp rax, rbx
ja short loc_9EDE4
dec rax
test rax, rbx
jz short loc_9EE1B
loc_9EDE4:
dec r12
add r14, 0FFFFFFFFFFFFFFF6h
jnz short loc_9EDCC
lea rdi, _ZN6mujoco12_GLOBAL__N_19precisionE_tlsind
call ___tls_get_addr
lea r15, [rax+30h]
lea rdx, aZu_0; "%zu"
mov esi, 14h
mov rdi, r15
mov rcx, rbx
xor eax, eax
call _snprintf
jmp short loc_9EE52
loc_9EE1B:
lea rdi, _ZN6mujoco12_GLOBAL__N_19precisionE_tlsind
call ___tls_get_addr
lea r15, [rax+30h]
mov ecx, r14d
shr rbx, cl
movsx r8d, byte ptr [r12]
lea rdx, aZuC; "%zu%c"
mov esi, 14h
mov rdi, r15
mov rcx, rbx
xor eax, eax
call _snprintf
loc_9EE52:
mov rax, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long mju_writeNumBytes(unsigned long long a1)
{
char *v1; // r12
long long v2; // r14
long long v3; // r15
v1 = "E";
v2 = 60LL;
while ( 1LL << v2 > a1 || (a1 & ((1LL << v2) - 1)) != 0 )
{
--v1;
v2 -= 10LL;
if ( !v2 )
{
v3 = __tls_get_addr(&mujoco::`anonymous namespace'::precision) + 48;
snprintf(v3, 20LL, "%zu", a1);
return v3;
}
}
v3 = __tls_get_addr(&mujoco::`anonymous namespace'::precision) + 48;
snprintf(v3, 20LL, "%zu%c", a1 >> v2, (unsigned int)*v1);
return v3;
}
| mju_writeNumBytes:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA R12,[0x2ce6a1]
MOV R14D,0x3c
LAB_0019edcc:
MOV EAX,0x1
MOV ECX,R14D
SHL RAX,CL
CMP RAX,RBX
JA 0x0019ede4
DEC RAX
TEST RAX,RBX
JZ 0x0019ee1b
LAB_0019ede4:
DEC R12
ADD R14,-0xa
JNZ 0x0019edcc
LEA RDI,[0x371ec0]
CALL 0x0012df10
LEA R15,[RAX + 0x30]
LEA RDX,[0x2ce6a9]
MOV ESI,0x14
MOV RDI,R15
MOV RCX,RBX
XOR EAX,EAX
CALL 0x0012d250
JMP 0x0019ee52
LAB_0019ee1b:
LEA RDI,[0x371ec0]
CALL 0x0012df10
LEA R15,[RAX + 0x30]
MOV ECX,R14D
SHR RBX,CL
MOVSX R8D,byte ptr [R12]
LEA RDX,[0x2ce6a3]
MOV ESI,0x14
MOV RDI,R15
MOV RCX,RBX
XOR EAX,EAX
CALL 0x0012d250
LAB_0019ee52:
MOV RAX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
char * mju_writeNumBytes(ulong param_1)
{
ulong uVar1;
long lVar2;
char *pcVar3;
long lVar4;
pcVar3 = (char *)((long)&mju_writeNumBytes_suffix + 6);
lVar4 = 0x3c;
while( true ) {
uVar1 = 1L << ((byte)lVar4 & 0x3f);
if ((uVar1 <= param_1) && ((uVar1 - 1 & param_1) == 0)) break;
pcVar3 = pcVar3 + -1;
lVar4 = lVar4 + -10;
if (lVar4 == 0) {
lVar4 = __tls_get_addr(&PTR_00371ec0);
snprintf((char *)(lVar4 + 0x30),0x14,"%zu",param_1);
return (char *)(lVar4 + 0x30);
}
}
lVar2 = __tls_get_addr(&PTR_00371ec0);
snprintf((char *)(lVar2 + 0x30),0x14,"%zu%c",param_1 >> ((byte)lVar4 & 0x3f),
(ulong)(uint)(int)*pcVar3);
return (char *)(lVar2 + 0x30);
}
| |
24,942 | my_strnxfrm_tis620_nopad | eloqsql/strings/ctype-tis620.c | static size_t
my_strnxfrm_tis620_nopad(CHARSET_INFO *cs,
uchar *dst, size_t dstlen, uint nweights,
const uchar *src, size_t srclen, uint flags)
{
size_t len, dstlen0= dstlen;
len= MY_MIN(dstlen, srclen);
memcpy(dst, src, len);
len= thai2sortable(dst, len);
set_if_smaller(dstlen, nweights);
set_if_smaller(len, dstlen);
len= my_strxfrm_pad_desc_and_reverse_nopad(cs, dst, dst + len, dst + dstlen,
(uint)(dstlen - len), flags, 0);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && len < dstlen0)
{
size_t fill_length= dstlen0 - len;
memset(dst + len, 0x00, fill_length);
len= dstlen0;
}
return len;
} | O0 | c | my_strnxfrm_tis620_nopad:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x4e69e
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4e6a6
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x24200
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4e440
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x4e6e3
movl -0x1c(%rbp), %eax
movq %rax, -0x18(%rbp)
jmp 0x4e6e5
jmp 0x4e6e7
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x4e6f9
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x4e6fb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
addq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movl %eax, %r8d
movl 0x10(%rbp), %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x48bc0
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x4e772
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jae 0x4e772
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
xorl %esi, %esi
callq 0x24180
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_strnxfrm_tis620_nopad:
push rbp
mov rbp, rsp
sub rsp, 60h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
cmp rax, [rbp+var_30]
jnb short loc_4E69E
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
jmp short loc_4E6A6
loc_4E69E:
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
loc_4E6A6:
mov rax, [rbp+var_50]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_38]
call _memcpy
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call thai2sortable
mov [rbp+var_38], rax
mov rax, [rbp+var_18]
mov ecx, [rbp+var_1C]
cmp rax, rcx
jbe short loc_4E6E3
mov eax, [rbp+var_1C]
mov [rbp+var_18], rax
loc_4E6E3:
jmp short $+2
loc_4E6E5:
jmp short $+2
loc_4E6E7:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_18]
jbe short loc_4E6F9
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
loc_4E6F9:
jmp short $+2
loc_4E6FB:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_10]
add rdx, [rbp+var_38]
mov rcx, [rbp+var_10]
add rcx, [rbp+var_18]
mov rax, [rbp+var_18]
sub rax, [rbp+var_38]
mov r8d, eax
mov r9d, [rbp+arg_0]
xor eax, eax
mov [rsp+60h+var_60], 0
call my_strxfrm_pad_desc_and_reverse_nopad
mov [rbp+var_38], rax
mov eax, [rbp+arg_0]
and eax, 80h
cmp eax, 0
jz short loc_4E772
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jnb short loc_4E772
mov rax, [rbp+var_40]
sub rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rdi, [rbp+var_10]
add rdi, [rbp+var_38]
mov rdx, [rbp+var_48]
xor esi, esi
call _memset
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
loc_4E772:
mov rax, [rbp+var_38]
add rsp, 60h
pop rbp
retn
| unsigned long long my_strnxfrm_tis620_nopad(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned int a4,
long long a5,
unsigned long long a6,
unsigned int a7)
{
long long v8; // [rsp+10h] [rbp-50h]
unsigned long long v10; // [rsp+28h] [rbp-38h]
unsigned long long v11; // [rsp+28h] [rbp-38h]
unsigned long long v13; // [rsp+48h] [rbp-18h]
v13 = a3;
if ( a3 >= a6 )
v8 = a6;
else
v8 = a3;
memcpy(a2, a5, v8);
v10 = thai2sortable(a2, v8);
if ( v13 > a4 )
v13 = a4;
if ( v10 > v13 )
v10 = v13;
v11 = my_strxfrm_pad_desc_and_reverse_nopad(
a1,
(long long)a2,
(unsigned long long)&a2[v10],
(unsigned long long)&a2[v13],
(int)v13 - (int)v10,
a7,
0);
if ( (a7 & 0x80) != 0 && v11 < a3 )
{
memset(&a2[v11], 0LL, a3 - v11);
return a3;
}
return v11;
}
| my_strnxfrm_tis620_nopad:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x0014e69e
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0014e6a6
LAB_0014e69e:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
LAB_0014e6a6:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x00124200
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0014e440
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x1c]
CMP RAX,RCX
JBE 0x0014e6e3
MOV EAX,dword ptr [RBP + -0x1c]
MOV qword ptr [RBP + -0x18],RAX
LAB_0014e6e3:
JMP 0x0014e6e5
LAB_0014e6e5:
JMP 0x0014e6e7
LAB_0014e6e7:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x18]
JBE 0x0014e6f9
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
LAB_0014e6f9:
JMP 0x0014e6fb
LAB_0014e6fb:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x10]
ADD RDX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,qword ptr [RBP + -0x38]
MOV R8D,EAX
MOV R9D,dword ptr [RBP + 0x10]
XOR EAX,EAX
MOV dword ptr [RSP],0x0
CALL 0x00148bc0
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x80
CMP EAX,0x0
JZ 0x0014e772
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JNC 0x0014e772
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x48]
XOR ESI,ESI
CALL 0x00124180
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
LAB_0014e772:
MOV RAX,qword ptr [RBP + -0x38]
ADD RSP,0x60
POP RBP
RET
|
ulong my_strnxfrm_tis620_nopad
(int8 param_1,void *param_2,ulong param_3,uint param_4,void *param_5,
ulong param_6,uint param_7)
{
size_t local_58;
ulong local_40;
ulong local_20;
local_58 = param_6;
if (param_3 < param_6) {
local_58 = param_3;
}
memcpy(param_2,param_5,local_58);
local_40 = thai2sortable(param_2,local_58);
local_20 = param_3;
if (param_4 < param_3) {
local_20 = (ulong)param_4;
}
if (local_20 < local_40) {
local_40 = local_20;
}
local_40 = my_strxfrm_pad_desc_and_reverse_nopad
(param_1,param_2,(long)param_2 + local_40,(long)param_2 + local_20,
(int)local_20 - (int)local_40,param_7,0);
if (((param_7 & 0x80) != 0) && (local_40 < param_3)) {
memset((void *)((long)param_2 + local_40),0,param_3 - local_40);
local_40 = param_3;
}
return local_40;
}
| |
24,943 | ELFIO::elfio::clean() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio.hpp | void clean()
{
delete header;
header = 0;
std::vector<section*>::const_iterator it;
for ( it = sections_.begin(); it != sections_.end(); ++it ) {
delete *it;
}
sections_.clear();
std::vector<segment*>::const_iterator it1;
for ( it1 = segments_.begin(); it1 != segments_.end(); ++it1 ) {
delete *it1;
}
segments_.clear();
} | O0 | cpp | ELFIO::elfio::clean():
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x16c6d
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
leaq 0x58(%rsp), %rdi
callq 0x170e0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x17100
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x17130
movq 0x50(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x171b0
movq %rax, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x17170
testb $0x1, %al
jne 0x16cd8
jmp 0x16d09
leaq 0x58(%rsp), %rdi
callq 0x171e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x16cfb
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x16cfd
leaq 0x58(%rsp), %rdi
callq 0x171f0
jmp 0x16cb0
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x17210
leaq 0x38(%rsp), %rdi
callq 0x17230
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x17250
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17280
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x17300
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x172c0
testb $0x1, %al
jne 0x16d75
jmp 0x16da4
leaq 0x38(%rsp), %rdi
callq 0x17330
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x16d96
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x16d98
leaq 0x38(%rsp), %rdi
callq 0x17340
jmp 0x16d4d
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x17360
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| _ZN5ELFIO5elfio5cleanEv:
sub rsp, 68h
mov [rsp+68h+var_8], rdi
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_58], rax
mov rax, [rax+10h]
mov [rsp+68h+var_50], rax
cmp rax, 0
jz short loc_16C6D
mov rdi, [rsp+68h+var_50]
mov rax, [rdi]
call qword ptr [rax+8]
loc_16C6D:
mov rax, [rsp+68h+var_58]
mov qword ptr [rax+10h], 0
lea rdi, [rsp+68h+var_10]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7sectionESt6vectorIS3_SaIS3_EEEC2Ev; __gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::__normal_iterator(void)
mov rdi, [rsp+68h+var_58]
add rdi, 18h
call _ZNSt6vectorIPN5ELFIO7sectionESaIS2_EE5beginEv; std::vector<ELFIO::section *>::begin(void)
mov [rsp+68h+var_20], rax
lea rdi, [rsp+68h+var_18]
lea rsi, [rsp+68h+var_20]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7sectionESt6vectorIS3_SaIS3_EEEC2IPS3_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rax, [rsp+68h+var_18]
mov [rsp+68h+var_10], rax
loc_16CB0:
mov rdi, [rsp+68h+var_58]
add rdi, 18h
call _ZNSt6vectorIPN5ELFIO7sectionESaIS2_EE3endEv; std::vector<ELFIO::section *>::end(void)
mov [rsp+68h+var_28], rax
lea rdi, [rsp+68h+var_10]
lea rsi, [rsp+68h+var_28]
call _ZN9__gnu_cxxneIPKPN5ELFIO7sectionEPS3_St6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T1_EERKNSA_IT0_SC_EE; __gnu_cxx::operator!=<ELFIO::section * const*,ELFIO::section **,std::vector<ELFIO::section *>>(__gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>> const&,__gnu_cxx::__normal_iterator<ELFIO::section **,std::vector<ELFIO::section *>> const&)
test al, 1
jnz short loc_16CD8
jmp short loc_16D09
loc_16CD8:
lea rdi, [rsp+68h+var_10]
call _ZNK9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7sectionESt6vectorIS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::operator*(void)
mov rax, [rax]
mov [rsp+68h+var_60], rax
cmp rax, 0
jz short loc_16CFB
mov rdi, [rsp+68h+var_60]
mov rax, [rdi]
call qword ptr [rax+8]
loc_16CFB:
jmp short $+2
loc_16CFD:
lea rdi, [rsp+68h+var_10]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7sectionESt6vectorIS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::operator++(void)
jmp short loc_16CB0
loc_16D09:
mov rdi, [rsp+68h+var_58]
add rdi, 18h
call _ZNSt6vectorIPN5ELFIO7sectionESaIS2_EE5clearEv; std::vector<ELFIO::section *>::clear(void)
lea rdi, [rsp+68h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7segmentESt6vectorIS3_SaIS3_EEEC2Ev; __gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::__normal_iterator(void)
mov rdi, [rsp+68h+var_58]
add rdi, 30h ; '0'
call _ZNSt6vectorIPN5ELFIO7segmentESaIS2_EE5beginEv; std::vector<ELFIO::segment *>::begin(void)
mov [rsp+68h+var_40], rax
lea rdi, [rsp+68h+var_38]
lea rsi, [rsp+68h+var_40]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7segmentESt6vectorIS3_SaIS3_EEEC2IPS3_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISC_SB_EE7__valueES8_E6__typeEEE
mov rax, [rsp+68h+var_38]
mov [rsp+68h+var_30], rax
loc_16D4D:
mov rdi, [rsp+68h+var_58]
add rdi, 30h ; '0'
call _ZNSt6vectorIPN5ELFIO7segmentESaIS2_EE3endEv; std::vector<ELFIO::segment *>::end(void)
mov [rsp+68h+var_48], rax
lea rdi, [rsp+68h+var_30]
lea rsi, [rsp+68h+var_48]
call _ZN9__gnu_cxxneIPKPN5ELFIO7segmentEPS3_St6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T1_EERKNSA_IT0_SC_EE; __gnu_cxx::operator!=<ELFIO::segment * const*,ELFIO::segment **,std::vector<ELFIO::segment *>>(__gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>> const&,__gnu_cxx::__normal_iterator<ELFIO::segment **,std::vector<ELFIO::segment *>> const&)
test al, 1
jnz short loc_16D75
jmp short loc_16DA4
loc_16D75:
lea rdi, [rsp+68h+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7segmentESt6vectorIS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::operator*(void)
mov rax, [rax]
mov [rsp+68h+var_68], rax
cmp rax, 0
jz short loc_16D96
mov rdi, [rsp+68h+var_68]
mov rax, [rdi]
call qword ptr [rax+8]
loc_16D96:
jmp short $+2
loc_16D98:
lea rdi, [rsp+68h+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN5ELFIO7segmentESt6vectorIS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::operator++(void)
jmp short loc_16D4D
loc_16DA4:
mov rdi, [rsp+68h+var_58]
add rdi, 30h ; '0'
call _ZNSt6vectorIPN5ELFIO7segmentESaIS2_EE5clearEv; std::vector<ELFIO::segment *>::clear(void)
add rsp, 68h
retn
| long long ELFIO::elfio::clean(ELFIO::elfio *this)
{
long long v2; // [rsp+0h] [rbp-68h]
long long v3; // [rsp+8h] [rbp-60h]
long long v4; // [rsp+18h] [rbp-50h]
long long v5; // [rsp+20h] [rbp-48h] BYREF
long long v6; // [rsp+28h] [rbp-40h] BYREF
long long v7; // [rsp+30h] [rbp-38h] BYREF
long long i; // [rsp+38h] [rbp-30h] BYREF
long long v9; // [rsp+40h] [rbp-28h] BYREF
long long v10; // [rsp+48h] [rbp-20h] BYREF
long long v11; // [rsp+50h] [rbp-18h] BYREF
_QWORD v12[2]; // [rsp+58h] [rbp-10h] BYREF
v12[1] = this;
v4 = *((_QWORD *)this + 2);
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
*((_QWORD *)this + 2) = 0LL;
__gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::__normal_iterator(v12);
v10 = std::vector<ELFIO::section *>::begin((char *)this + 24);
__gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::__normal_iterator<ELFIO::section **>(
&v11,
&v10);
v12[0] = v11;
while ( 1 )
{
v9 = std::vector<ELFIO::section *>::end((char *)this + 24);
if ( (__gnu_cxx::operator!=<ELFIO::section * const*,ELFIO::section **,std::vector<ELFIO::section *>>(v12, &v9) & 1) == 0 )
break;
v3 = *(_QWORD *)__gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::operator*(v12);
if ( v3 )
(*(void ( **)(long long))(*(_QWORD *)v3 + 8LL))(v3);
__gnu_cxx::__normal_iterator<ELFIO::section * const*,std::vector<ELFIO::section *>>::operator++(v12);
}
std::vector<ELFIO::section *>::clear((char *)this + 24);
__gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::__normal_iterator(&i);
v6 = std::vector<ELFIO::segment *>::begin((char *)this + 48);
__gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::__normal_iterator<ELFIO::segment **>(
&v7,
&v6);
for ( i = v7; ; __gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::operator++(&i) )
{
v5 = std::vector<ELFIO::segment *>::end((char *)this + 48);
if ( (__gnu_cxx::operator!=<ELFIO::segment * const*,ELFIO::segment **,std::vector<ELFIO::segment *>>(&i, &v5) & 1) == 0 )
break;
v2 = *(_QWORD *)__gnu_cxx::__normal_iterator<ELFIO::segment * const*,std::vector<ELFIO::segment *>>::operator*(&i);
if ( v2 )
(*(void ( **)(long long))(*(_QWORD *)v2 + 8LL))(v2);
}
return std::vector<ELFIO::segment *>::clear((char *)this + 48);
}
| clean:
SUB RSP,0x68
MOV qword ptr [RSP + 0x60],RDI
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x18],RAX
CMP RAX,0x0
JZ 0x00116c6d
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00116c6d:
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x10],0x0
LEA RDI,[RSP + 0x58]
CALL 0x001170e0
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x18
CALL 0x00117100
MOV qword ptr [RSP + 0x48],RAX
LEA RDI,[RSP + 0x50]
LEA RSI,[RSP + 0x48]
CALL 0x00117130
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x58],RAX
LAB_00116cb0:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x18
CALL 0x001171b0
MOV qword ptr [RSP + 0x40],RAX
LEA RDI,[RSP + 0x58]
LEA RSI,[RSP + 0x40]
CALL 0x00117170
TEST AL,0x1
JNZ 0x00116cd8
JMP 0x00116d09
LAB_00116cd8:
LEA RDI,[RSP + 0x58]
CALL 0x001171e0
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x8],RAX
CMP RAX,0x0
JZ 0x00116cfb
MOV RDI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00116cfb:
JMP 0x00116cfd
LAB_00116cfd:
LEA RDI,[RSP + 0x58]
CALL 0x001171f0
JMP 0x00116cb0
LAB_00116d09:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x18
CALL 0x00117210
LEA RDI,[RSP + 0x38]
CALL 0x00117230
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x30
CALL 0x00117250
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x28]
CALL 0x00117280
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x38],RAX
LAB_00116d4d:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x30
CALL 0x00117300
MOV qword ptr [RSP + 0x20],RAX
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x20]
CALL 0x001172c0
TEST AL,0x1
JNZ 0x00116d75
JMP 0x00116da4
LAB_00116d75:
LEA RDI,[RSP + 0x38]
CALL 0x00117330
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
CMP RAX,0x0
JZ 0x00116d96
MOV RDI,qword ptr [RSP]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_00116d96:
JMP 0x00116d98
LAB_00116d98:
LEA RDI,[RSP + 0x38]
CALL 0x00117340
JMP 0x00116d4d
LAB_00116da4:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x30
CALL 0x00117360
ADD RSP,0x68
RET
|
/* ELFIO::elfio::clean() */
void __thiscall ELFIO::elfio::clean(elfio *this)
{
bool bVar1;
long *plVar2;
int8 local_48;
int8 local_40;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
int8 local_18;
int8 local_10;
elfio *local_8;
local_8 = this;
if (*(long **)(this + 0x10) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x10) + 8))();
}
*(int8 *)(this + 0x10) = 0;
__gnu_cxx::
__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
::__normal_iterator((__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
*)&local_10);
local_20 = std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>::begin
((vector<ELFIO::section*,std::allocator<ELFIO::section*>> *)(this + 0x18));
__gnu_cxx::
__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
::__normal_iterator<ELFIO::section**>
((__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
*)&local_18,(__normal_iterator *)&local_20);
local_10 = local_18;
while( true ) {
local_28 = std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>::end
((vector<ELFIO::section*,std::allocator<ELFIO::section*>> *)(this + 0x18));
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_10,(__normal_iterator *)&local_28);
if (!bVar1) break;
plVar2 = (long *)__gnu_cxx::
__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
::operator*((__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
*)&local_10);
if ((long *)*plVar2 != (long *)0x0) {
(**(code **)(*(long *)*plVar2 + 8))();
}
__gnu_cxx::
__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
::operator++((__normal_iterator<ELFIO::section*const*,std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>>
*)&local_10);
}
std::vector<ELFIO::section*,std::allocator<ELFIO::section*>>::clear
((vector<ELFIO::section*,std::allocator<ELFIO::section*>> *)(this + 0x18));
__gnu_cxx::
__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
::__normal_iterator((__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
*)&local_30);
local_40 = std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>::begin
((vector<ELFIO::segment*,std::allocator<ELFIO::segment*>> *)(this + 0x30));
__gnu_cxx::
__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
::__normal_iterator<ELFIO::segment**>
((__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
*)&local_38,(__normal_iterator *)&local_40);
local_30 = local_38;
while( true ) {
local_48 = std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>::end
((vector<ELFIO::segment*,std::allocator<ELFIO::segment*>> *)(this + 0x30));
bVar1 = __gnu_cxx::operator!=((__normal_iterator *)&local_30,(__normal_iterator *)&local_48);
if (!bVar1) break;
plVar2 = (long *)__gnu_cxx::
__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
::operator*((__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
*)&local_30);
if ((long *)*plVar2 != (long *)0x0) {
(**(code **)(*(long *)*plVar2 + 8))();
}
__gnu_cxx::
__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
::operator++((__normal_iterator<ELFIO::segment*const*,std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>>
*)&local_30);
}
std::vector<ELFIO::segment*,std::allocator<ELFIO::segment*>>::clear
((vector<ELFIO::segment*,std::allocator<ELFIO::segment*>> *)(this + 0x30));
return;
}
| |
24,944 | ELFIO::elfio::clean() | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/include/elfio/elfio.hpp | void clean()
{
delete header;
header = 0;
std::vector<section*>::const_iterator it;
for ( it = sections_.begin(); it != sections_.end(); ++it ) {
delete *it;
}
sections_.clear();
std::vector<segment*>::const_iterator it1;
for ( it1 = segments_.begin(); it1 != segments_.end(); ++it1 ) {
delete *it1;
}
segments_.clear();
} | O1 | cpp | ELFIO::elfio::clean():
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xc238
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rax
cmpq %rax, %r14
je 0xc261
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc25b
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xc244
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0xc26e
movq %rcx, 0x20(%rbx)
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %rax
cmpq %rax, %r14
je 0xc28f
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc289
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xc272
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0xc29c
movq %rcx, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN5ELFIO5elfio5cleanEv:
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+10h]
test rdi, rdi
jz short loc_C238
mov rax, [rdi]
call qword ptr [rax+8]
loc_C238:
mov qword ptr [rbx+10h], 0
mov r14, [rbx+18h]
loc_C244:
mov rax, [rbx+20h]
cmp r14, rax
jz short loc_C261
mov rdi, [r14]
test rdi, rdi
jz short loc_C25B
mov rax, [rdi]
call qword ptr [rax+8]
loc_C25B:
add r14, 8
jmp short loc_C244
loc_C261:
mov rcx, [rbx+18h]
cmp rax, rcx
jz short loc_C26E
mov [rbx+20h], rcx
loc_C26E:
mov r14, [rbx+30h]
loc_C272:
mov rax, [rbx+38h]
cmp r14, rax
jz short loc_C28F
mov rdi, [r14]
test rdi, rdi
jz short loc_C289
mov rax, [rdi]
call qword ptr [rax+8]
loc_C289:
add r14, 8
jmp short loc_C272
loc_C28F:
mov rcx, [rbx+30h]
cmp rax, rcx
jz short loc_C29C
mov [rbx+38h], rcx
loc_C29C:
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * ELFIO::elfio::clean(ELFIO::elfio *this)
{
long long v2; // rdi
_QWORD *i; // r14
_QWORD *v4; // rax
_QWORD *v5; // rcx
_QWORD *j; // r14
_QWORD *result; // rax
_QWORD *v8; // rcx
v2 = *((_QWORD *)this + 2);
if ( v2 )
(*(void ( **)(long long))(*(_QWORD *)v2 + 8LL))(v2);
*((_QWORD *)this + 2) = 0LL;
for ( i = (_QWORD *)*((_QWORD *)this + 3); ; ++i )
{
v4 = (_QWORD *)*((_QWORD *)this + 4);
if ( i == v4 )
break;
if ( *i )
(*(void ( **)(_QWORD))(*(_QWORD *)*i + 8LL))(*i);
}
v5 = (_QWORD *)*((_QWORD *)this + 3);
if ( v4 != v5 )
*((_QWORD *)this + 4) = v5;
for ( j = (_QWORD *)*((_QWORD *)this + 6); ; ++j )
{
result = (_QWORD *)*((_QWORD *)this + 7);
if ( j == result )
break;
if ( *j )
(*(void ( **)(_QWORD))(*(_QWORD *)*j + 8LL))(*j);
}
v8 = (_QWORD *)*((_QWORD *)this + 6);
if ( result != v8 )
*((_QWORD *)this + 7) = v8;
return result;
}
| clean:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x10]
TEST RDI,RDI
JZ 0x0010c238
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010c238:
MOV qword ptr [RBX + 0x10],0x0
MOV R14,qword ptr [RBX + 0x18]
LAB_0010c244:
MOV RAX,qword ptr [RBX + 0x20]
CMP R14,RAX
JZ 0x0010c261
MOV RDI,qword ptr [R14]
TEST RDI,RDI
JZ 0x0010c25b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010c25b:
ADD R14,0x8
JMP 0x0010c244
LAB_0010c261:
MOV RCX,qword ptr [RBX + 0x18]
CMP RAX,RCX
JZ 0x0010c26e
MOV qword ptr [RBX + 0x20],RCX
LAB_0010c26e:
MOV R14,qword ptr [RBX + 0x30]
LAB_0010c272:
MOV RAX,qword ptr [RBX + 0x38]
CMP R14,RAX
JZ 0x0010c28f
MOV RDI,qword ptr [R14]
TEST RDI,RDI
JZ 0x0010c289
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010c289:
ADD R14,0x8
JMP 0x0010c272
LAB_0010c28f:
MOV RCX,qword ptr [RBX + 0x30]
CMP RAX,RCX
JZ 0x0010c29c
MOV qword ptr [RBX + 0x38],RCX
LAB_0010c29c:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ELFIO::elfio::clean() */
void __thiscall ELFIO::elfio::clean(elfio *this)
{
long *plVar1;
if (*(long **)(this + 0x10) != (long *)0x0) {
(**(code **)(**(long **)(this + 0x10) + 8))();
}
*(int8 *)(this + 0x10) = 0;
for (plVar1 = *(long **)(this + 0x18); plVar1 != *(long **)(this + 0x20); plVar1 = plVar1 + 1) {
if ((long *)*plVar1 != (long *)0x0) {
(**(code **)(*(long *)*plVar1 + 8))();
}
}
if (*(long **)(this + 0x20) != *(long **)(this + 0x18)) {
*(long **)(this + 0x20) = *(long **)(this + 0x18);
}
for (plVar1 = *(long **)(this + 0x30); plVar1 != *(long **)(this + 0x38); plVar1 = plVar1 + 1) {
if ((long *)*plVar1 != (long *)0x0) {
(**(code **)(*(long *)*plVar1 + 8))();
}
}
if (*(long **)(this + 0x38) != *(long **)(this + 0x30)) {
*(long **)(this + 0x38) = *(long **)(this + 0x30);
}
return;
}
| |
24,945 | 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 0x5a052
jmp 0x5a02b
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x5a06f
jmp 0x5a035
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3e400
jmp 0x5a071
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3e400
jmp 0x5a071
jmp 0x5a071
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_5A052
jmp short $+2
loc_5A02B:
mov eax, [rbp+var_14]
sub eax, 1
jnz short loc_5A06F
jmp short $+2
loc_5A035:
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_5A071
loc_5A052:
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_5A071
loc_5A06F:
jmp short $+2
loc_5A071:
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 0x0015a052
JMP 0x0015a02b
LAB_0015a02b:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
JNZ 0x0015a06f
JMP 0x0015a035
LAB_0015a035:
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 0x0013e400
JMP 0x0015a071
LAB_0015a052:
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 0x0013e400
JMP 0x0015a071
LAB_0015a06f:
JMP 0x0015a071
LAB_0015a071:
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;
}
| |
24,946 | my_coll_parser_scan_reset_before | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_reset_before(MY_COLL_RULE_PARSER *p)
{
MY_COLL_LEXEM *lexem= my_coll_parser_curr(p);
if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before primary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 1]")))
{
p->rule.before_level= 1;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before secondary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 2]")))
{
p->rule.before_level= 2;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before tertiary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 3]")))
{
p->rule.before_level= 3;
}
else if (!lex_cmp(lexem, C_STRING_WITH_LEN("[before quaternary]")) ||
!lex_cmp(lexem, C_STRING_WITH_LEN("[before 4]")))
{
p->rule.before_level= 4;
}
else
{
p->rule.before_level= 0;
return 0; /* Don't scan thr next character */
}
return my_coll_parser_scan(p);
} | O0 | c | my_coll_parser_scan_reset_before:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xad010
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x2e855(%rip), %rsi # 0xdc3b9
movl $0x10, %edx
callq 0xad790
cmpl $0x0, %eax
je 0xadb8d
movq -0x18(%rbp), %rdi
leaq 0x2e84c(%rip), %rsi # 0xdc3ca
movl $0xa, %edx
callq 0xad790
cmpl $0x0, %eax
jne 0xadba1
movq -0x10(%rbp), %rax
movq $0x1, 0xe0(%rax)
jmp 0xadc91
movq -0x18(%rbp), %rdi
leaq 0x2e829(%rip), %rsi # 0xdc3d5
movl $0x12, %edx
callq 0xad790
cmpl $0x0, %eax
je 0xadbd5
movq -0x18(%rbp), %rdi
leaq 0x2e822(%rip), %rsi # 0xdc3e8
movl $0xa, %edx
callq 0xad790
cmpl $0x0, %eax
jne 0xadbe9
movq -0x10(%rbp), %rax
movq $0x2, 0xe0(%rax)
jmp 0xadc8f
movq -0x18(%rbp), %rdi
leaq 0x2e7ff(%rip), %rsi # 0xdc3f3
movl $0x11, %edx
callq 0xad790
cmpl $0x0, %eax
je 0xadc1d
movq -0x18(%rbp), %rdi
leaq 0x2e7f7(%rip), %rsi # 0xdc405
movl $0xa, %edx
callq 0xad790
cmpl $0x0, %eax
jne 0xadc2e
movq -0x10(%rbp), %rax
movq $0x3, 0xe0(%rax)
jmp 0xadc8d
movq -0x18(%rbp), %rdi
leaq 0x2e7d7(%rip), %rsi # 0xdc410
movl $0x13, %edx
callq 0xad790
cmpl $0x0, %eax
je 0xadc62
movq -0x18(%rbp), %rdi
leaq 0x2e7d1(%rip), %rsi # 0xdc424
movl $0xa, %edx
callq 0xad790
cmpl $0x0, %eax
jne 0xadc73
movq -0x10(%rbp), %rax
movq $0x4, 0xe0(%rax)
jmp 0xadc8b
movq -0x10(%rbp), %rax
movq $0x0, 0xe0(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xadc9d
jmp 0xadc8d
jmp 0xadc8f
jmp 0xadc91
movq -0x10(%rbp), %rdi
callq 0xad7f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_coll_parser_scan_reset_before:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rdi, [rbp+var_10]
call my_coll_parser_curr
mov [rbp+var_18], rax
mov rdi, [rbp+var_18]
lea rsi, aBeforePrimary; "[before primary]"
mov edx, 10h
call lex_cmp
cmp eax, 0
jz short loc_ADB8D
mov rdi, [rbp+var_18]
lea rsi, aBefore1; "[before 1]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_ADBA1
loc_ADB8D:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 1
jmp loc_ADC91
loc_ADBA1:
mov rdi, [rbp+var_18]
lea rsi, aBeforeSecondar; "[before secondary]"
mov edx, 12h
call lex_cmp
cmp eax, 0
jz short loc_ADBD5
mov rdi, [rbp+var_18]
lea rsi, aBefore2; "[before 2]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_ADBE9
loc_ADBD5:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 2
jmp loc_ADC8F
loc_ADBE9:
mov rdi, [rbp+var_18]
lea rsi, aBeforeTertiary; "[before tertiary]"
mov edx, 11h
call lex_cmp
cmp eax, 0
jz short loc_ADC1D
mov rdi, [rbp+var_18]
lea rsi, aBefore3; "[before 3]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_ADC2E
loc_ADC1D:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 3
jmp short loc_ADC8D
loc_ADC2E:
mov rdi, [rbp+var_18]
lea rsi, aBeforeQuaterna; "[before quaternary]"
mov edx, 13h
call lex_cmp
cmp eax, 0
jz short loc_ADC62
mov rdi, [rbp+var_18]
lea rsi, aBefore4; "[before 4]"
mov edx, 0Ah
call lex_cmp
cmp eax, 0
jnz short loc_ADC73
loc_ADC62:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 4
jmp short loc_ADC8B
loc_ADC73:
mov rax, [rbp+var_10]
mov qword ptr [rax+0E0h], 0
mov [rbp+var_4], 0
jmp short loc_ADC9D
loc_ADC8B:
jmp short $+2
loc_ADC8D:
jmp short $+2
loc_ADC8F:
jmp short $+2
loc_ADC91:
mov rdi, [rbp+var_10]
call my_coll_parser_scan
mov [rbp+var_4], eax
loc_ADC9D:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long my_coll_parser_scan_reset_before(long long a1)
{
long long v2; // [rsp+8h] [rbp-18h]
v2 = my_coll_parser_curr(a1);
if ( !(unsigned int)lex_cmp(v2, (long long)"[before primary]", 0x10uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 1]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 1LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before secondary]", 0x12uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 2]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 2LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before tertiary]", 0x11uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 3]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 3LL;
return (unsigned int)my_coll_parser_scan(a1);
}
if ( !(unsigned int)lex_cmp(v2, (long long)"[before quaternary]", 0x13uLL)
|| !(unsigned int)lex_cmp(v2, (long long)"[before 4]", 0xAuLL) )
{
*(_QWORD *)(a1 + 224) = 4LL;
return (unsigned int)my_coll_parser_scan(a1);
}
*(_QWORD *)(a1 + 224) = 0LL;
return 0;
}
| my_coll_parser_scan_reset_before:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ad010
MOV qword ptr [RBP + -0x18],RAX
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc3b9]
MOV EDX,0x10
CALL 0x001ad790
CMP EAX,0x0
JZ 0x001adb8d
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc3ca]
MOV EDX,0xa
CALL 0x001ad790
CMP EAX,0x0
JNZ 0x001adba1
LAB_001adb8d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x1
JMP 0x001adc91
LAB_001adba1:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc3d5]
MOV EDX,0x12
CALL 0x001ad790
CMP EAX,0x0
JZ 0x001adbd5
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc3e8]
MOV EDX,0xa
CALL 0x001ad790
CMP EAX,0x0
JNZ 0x001adbe9
LAB_001adbd5:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x2
JMP 0x001adc8f
LAB_001adbe9:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc3f3]
MOV EDX,0x11
CALL 0x001ad790
CMP EAX,0x0
JZ 0x001adc1d
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc405]
MOV EDX,0xa
CALL 0x001ad790
CMP EAX,0x0
JNZ 0x001adc2e
LAB_001adc1d:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x3
JMP 0x001adc8d
LAB_001adc2e:
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc410]
MOV EDX,0x13
CALL 0x001ad790
CMP EAX,0x0
JZ 0x001adc62
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[0x1dc424]
MOV EDX,0xa
CALL 0x001ad790
CMP EAX,0x0
JNZ 0x001adc73
LAB_001adc62:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x4
JMP 0x001adc8b
LAB_001adc73:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xe0],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001adc9d
LAB_001adc8b:
JMP 0x001adc8d
LAB_001adc8d:
JMP 0x001adc8f
LAB_001adc8f:
JMP 0x001adc91
LAB_001adc91:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001ad7f0
MOV dword ptr [RBP + -0x4],EAX
LAB_001adc9d:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 my_coll_parser_scan_reset_before(long param_1)
{
int iVar1;
int4 uVar2;
int8 uVar3;
uVar3 = my_coll_parser_curr(param_1);
iVar1 = lex_cmp(uVar3,"[before primary]",0x10);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 1]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 1;
}
else {
iVar1 = lex_cmp(uVar3,"[before secondary]",0x12);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 2]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 2;
}
else {
iVar1 = lex_cmp(uVar3,"[before tertiary]",0x11);
if ((iVar1 == 0) || (iVar1 = lex_cmp(uVar3,"[before 3]",10), iVar1 == 0)) {
*(int8 *)(param_1 + 0xe0) = 3;
}
else {
iVar1 = lex_cmp(uVar3,"[before quaternary]",0x13);
if ((iVar1 != 0) && (iVar1 = lex_cmp(uVar3,"[before 4]",10), iVar1 != 0)) {
*(int8 *)(param_1 + 0xe0) = 0;
return 0;
}
*(int8 *)(param_1 + 0xe0) = 4;
}
}
}
uVar2 = my_coll_parser_scan(param_1);
return uVar2;
}
| |
24,947 | google::protobuf::compiler::cpp::HasLazyFields(google::protobuf::Descriptor const*, google::protobuf::compiler::cpp::Options const&, google::protobuf::compiler::cpp::MessageSCCAnalyzer*) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/cpp/helpers.cc | static bool HasLazyFields(const Descriptor* descriptor, const Options& options,
MessageSCCAnalyzer* scc_analyzer) {
for (int field_idx = 0; field_idx < descriptor->field_count(); field_idx++) {
if (IsLazy(descriptor->field(field_idx), options, scc_analyzer)) {
return true;
}
}
for (int idx = 0; idx < descriptor->extension_count(); idx++) {
if (IsLazy(descriptor->extension(idx), options, scc_analyzer)) {
return true;
}
}
for (int idx = 0; idx < descriptor->nested_type_count(); idx++) {
if (HasLazyFields(descriptor->nested_type(idx), options, scc_analyzer)) {
return true;
}
}
return false;
} | O0 | cpp | google::protobuf::compiler::cpp::HasLazyFields(google::protobuf::Descriptor const*, google::protobuf::compiler::cpp::Options const&, google::protobuf::compiler::cpp::MessageSCCAnalyzer*):
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3ca80
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x55036
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x3ca90
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4def0
testb $0x1, %al
jne 0x5501d
jmp 0x55027
movb $0x1, 0x37(%rsp)
jmp 0x550f9
jmp 0x55029
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x54fdb
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
callq 0x59060
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jge 0x55096
movq 0x28(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x590a0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4def0
testb $0x1, %al
jne 0x55080
jmp 0x55087
movb $0x1, 0x37(%rsp)
jmp 0x550f9
jmp 0x55089
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5503e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x3cb40
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jge 0x550f4
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x3cb50
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x54fc0
testb $0x1, %al
jne 0x550de
jmp 0x550e5
movb $0x1, 0x37(%rsp)
jmp 0x550f9
jmp 0x550e7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5509e
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZN6google8protobuf8compiler3cppL13HasLazyFieldsEPKNS0_10DescriptorERKNS2_7OptionsEPNS2_18MessageSCCAnalyzerE:
sub rsp, 38h
mov [rsp+38h+var_10], rdi
mov [rsp+38h+var_18], rsi
mov [rsp+38h+var_20], rdx
mov [rsp+38h+var_24], 0
loc_54FDB:
mov eax, [rsp+38h+var_24]
mov [rsp+38h+var_30], eax
mov rdi, [rsp+38h+var_10]; this
call _ZNK6google8protobuf10Descriptor11field_countEv; google::protobuf::Descriptor::field_count(void)
mov ecx, eax
mov eax, [rsp+38h+var_30]
cmp eax, ecx
jge short loc_55036
mov rdi, [rsp+38h+var_10]; this
mov esi, [rsp+38h+var_24]; int
call _ZNK6google8protobuf10Descriptor5fieldEi; google::protobuf::Descriptor::field(int)
mov rdi, rax
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_20]
call _ZN6google8protobuf8compiler3cpp6IsLazyEPKNS0_15FieldDescriptorERKNS2_7OptionsEPNS2_18MessageSCCAnalyzerE; google::protobuf::compiler::cpp::IsLazy(google::protobuf::FieldDescriptor const*,google::protobuf::compiler::cpp::Options const&,google::protobuf::compiler::cpp::MessageSCCAnalyzer *)
test al, 1
jnz short loc_5501D
jmp short loc_55027
loc_5501D:
mov [rsp+38h+var_1], 1
jmp loc_550F9
loc_55027:
jmp short $+2
loc_55029:
mov eax, [rsp+38h+var_24]
add eax, 1
mov [rsp+38h+var_24], eax
jmp short loc_54FDB
loc_55036:
mov [rsp+38h+var_28], 0
loc_5503E:
mov eax, [rsp+38h+var_28]
mov [rsp+38h+var_34], eax
mov rdi, [rsp+38h+var_10]; this
call _ZNK6google8protobuf10Descriptor15extension_countEv; google::protobuf::Descriptor::extension_count(void)
mov ecx, eax
mov eax, [rsp+38h+var_34]
cmp eax, ecx
jge short loc_55096
mov rdi, [rsp+38h+var_10]; this
mov esi, [rsp+38h+var_28]; int
call _ZNK6google8protobuf10Descriptor9extensionEi; google::protobuf::Descriptor::extension(int)
mov rdi, rax
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_20]
call _ZN6google8protobuf8compiler3cpp6IsLazyEPKNS0_15FieldDescriptorERKNS2_7OptionsEPNS2_18MessageSCCAnalyzerE; google::protobuf::compiler::cpp::IsLazy(google::protobuf::FieldDescriptor const*,google::protobuf::compiler::cpp::Options const&,google::protobuf::compiler::cpp::MessageSCCAnalyzer *)
test al, 1
jnz short loc_55080
jmp short loc_55087
loc_55080:
mov [rsp+38h+var_1], 1
jmp short loc_550F9
loc_55087:
jmp short $+2
loc_55089:
mov eax, [rsp+38h+var_28]
add eax, 1
mov [rsp+38h+var_28], eax
jmp short loc_5503E
loc_55096:
mov [rsp+38h+var_2C], 0
loc_5509E:
mov eax, [rsp+38h+var_2C]
mov [rsp+38h+var_38], eax
mov rdi, [rsp+38h+var_10]; this
call _ZNK6google8protobuf10Descriptor17nested_type_countEv; google::protobuf::Descriptor::nested_type_count(void)
mov ecx, eax
mov eax, [rsp+38h+var_38]
cmp eax, ecx
jge short loc_550F4
mov rdi, [rsp+38h+var_10]; this
mov esi, [rsp+38h+var_2C]; int
call _ZNK6google8protobuf10Descriptor11nested_typeEi; google::protobuf::Descriptor::nested_type(int)
mov rdi, rax
mov rsi, [rsp+38h+var_18]
mov rdx, [rsp+38h+var_20]
call _ZN6google8protobuf8compiler3cppL13HasLazyFieldsEPKNS0_10DescriptorERKNS2_7OptionsEPNS2_18MessageSCCAnalyzerE; google::protobuf::compiler::cpp::HasLazyFields(google::protobuf::Descriptor const*,google::protobuf::compiler::cpp::Options const&,google::protobuf::compiler::cpp::MessageSCCAnalyzer *)
test al, 1
jnz short loc_550DE
jmp short loc_550E5
loc_550DE:
mov [rsp+38h+var_1], 1
jmp short loc_550F9
loc_550E5:
jmp short $+2
loc_550E7:
mov eax, [rsp+38h+var_2C]
add eax, 1
mov [rsp+38h+var_2C], eax
jmp short loc_5509E
loc_550F4:
mov [rsp+38h+var_1], 0
loc_550F9:
mov al, [rsp+38h+var_1]
and al, 1
add rsp, 38h
retn
| char google::protobuf::compiler::cpp::HasLazyFields(
google::protobuf::compiler::cpp *this,
const google::protobuf::Descriptor *a2,
const google::protobuf::compiler::cpp::Options *a3,
google::protobuf::compiler::cpp::MessageSCCAnalyzer *a4)
{
google::protobuf::compiler::cpp *v4; // rax
google::protobuf::compiler::cpp::MessageSCCAnalyzer *v5; // rcx
google::protobuf::compiler::cpp *v6; // rax
google::protobuf::compiler::cpp::MessageSCCAnalyzer *v7; // rcx
google::protobuf::compiler::cpp *v8; // rax
google::protobuf::compiler::cpp::MessageSCCAnalyzer *v9; // rcx
int k; // [rsp+Ch] [rbp-2Ch]
int j; // [rsp+10h] [rbp-28h]
int i; // [rsp+14h] [rbp-24h]
for ( i = 0; i < (int)google::protobuf::Descriptor::field_count(this); ++i )
{
v4 = (google::protobuf::compiler::cpp *)google::protobuf::Descriptor::field(this, i);
if ( (google::protobuf::compiler::cpp::IsLazy(v4, a2, a3, v5) & 1) != 0 )
return 1;
}
for ( j = 0; j < (int)google::protobuf::Descriptor::extension_count(this); ++j )
{
v6 = (google::protobuf::compiler::cpp *)google::protobuf::Descriptor::extension(this, j);
if ( (google::protobuf::compiler::cpp::IsLazy(v6, a2, a3, v7) & 1) != 0 )
return 1;
}
for ( k = 0; k < (int)google::protobuf::Descriptor::nested_type_count(this); ++k )
{
v8 = (google::protobuf::compiler::cpp *)google::protobuf::Descriptor::nested_type(this, k);
if ( (google::protobuf::compiler::cpp::HasLazyFields(v8, a2, a3, v9) & 1) != 0 )
return 1;
}
return 0;
}
| HasLazyFields:
SUB RSP,0x38
MOV qword ptr [RSP + 0x28],RDI
MOV qword ptr [RSP + 0x20],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV dword ptr [RSP + 0x14],0x0
LAB_00154fdb:
MOV EAX,dword ptr [RSP + 0x14]
MOV dword ptr [RSP + 0x8],EAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0013ca80
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x8]
CMP EAX,ECX
JGE 0x00155036
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x14]
CALL 0x0013ca90
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0014def0
TEST AL,0x1
JNZ 0x0015501d
JMP 0x00155027
LAB_0015501d:
MOV byte ptr [RSP + 0x37],0x1
JMP 0x001550f9
LAB_00155027:
JMP 0x00155029
LAB_00155029:
MOV EAX,dword ptr [RSP + 0x14]
ADD EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
JMP 0x00154fdb
LAB_00155036:
MOV dword ptr [RSP + 0x10],0x0
LAB_0015503e:
MOV EAX,dword ptr [RSP + 0x10]
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x00159060
MOV ECX,EAX
MOV EAX,dword ptr [RSP + 0x4]
CMP EAX,ECX
JGE 0x00155096
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0x10]
CALL 0x001590a0
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0014def0
TEST AL,0x1
JNZ 0x00155080
JMP 0x00155087
LAB_00155080:
MOV byte ptr [RSP + 0x37],0x1
JMP 0x001550f9
LAB_00155087:
JMP 0x00155089
LAB_00155089:
MOV EAX,dword ptr [RSP + 0x10]
ADD EAX,0x1
MOV dword ptr [RSP + 0x10],EAX
JMP 0x0015503e
LAB_00155096:
MOV dword ptr [RSP + 0xc],0x0
LAB_0015509e:
MOV EAX,dword ptr [RSP + 0xc]
MOV dword ptr [RSP],EAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0013cb40
MOV ECX,EAX
MOV EAX,dword ptr [RSP]
CMP EAX,ECX
JGE 0x001550f4
MOV RDI,qword ptr [RSP + 0x28]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x0013cb50
MOV RDI,RAX
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x00154fc0
TEST AL,0x1
JNZ 0x001550de
JMP 0x001550e5
LAB_001550de:
MOV byte ptr [RSP + 0x37],0x1
JMP 0x001550f9
LAB_001550e5:
JMP 0x001550e7
LAB_001550e7:
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0x1
MOV dword ptr [RSP + 0xc],EAX
JMP 0x0015509e
LAB_001550f4:
MOV byte ptr [RSP + 0x37],0x0
LAB_001550f9:
MOV AL,byte ptr [RSP + 0x37]
AND AL,0x1
ADD RSP,0x38
RET
|
/* google::protobuf::compiler::cpp::HasLazyFields(google::protobuf::Descriptor const*,
google::protobuf::compiler::cpp::Options const&,
google::protobuf::compiler::cpp::MessageSCCAnalyzer*) */
int1
google::protobuf::compiler::cpp::HasLazyFields
(Descriptor *param_1,Options *param_2,MessageSCCAnalyzer *param_3)
{
int iVar1;
FieldDescriptor *pFVar2;
ulong uVar3;
Descriptor *pDVar4;
int local_2c;
int local_28;
int local_24;
local_24 = 0;
while( true ) {
iVar1 = Descriptor::field_count(param_1);
if (iVar1 <= local_24) {
local_28 = 0;
while( true ) {
iVar1 = Descriptor::extension_count(param_1);
if (iVar1 <= local_28) {
local_2c = 0;
while( true ) {
iVar1 = Descriptor::nested_type_count(param_1);
if (iVar1 <= local_2c) {
return 0;
}
pDVar4 = (Descriptor *)Descriptor::nested_type(param_1,local_2c);
uVar3 = HasLazyFields(pDVar4,param_2,param_3);
if ((uVar3 & 1) != 0) break;
local_2c = local_2c + 1;
}
return 1;
}
pFVar2 = (FieldDescriptor *)Descriptor::extension(param_1,local_28);
uVar3 = IsLazy(pFVar2,param_2,param_3);
if ((uVar3 & 1) != 0) break;
local_28 = local_28 + 1;
}
return 1;
}
pFVar2 = (FieldDescriptor *)Descriptor::field(param_1,local_24);
uVar3 = IsLazy(pFVar2,param_2,param_3);
if ((uVar3 & 1) != 0) break;
local_24 = local_24 + 1;
}
return 1;
}
| |
24,948 | google::protobuf::RepeatedField<int>::Add(int const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline void RepeatedField<Element>::Add(const Element& value) {
uint32_t size = current_size_;
if (static_cast<int>(size) == total_size_) {
// value could reference an element of the array. Reserving new space will
// invalidate the reference. So we must make a copy first.
auto tmp = value;
Reserve(total_size_ + 1);
elements()[size] = std::move(tmp);
} else {
elements()[size] = value;
}
current_size_ = size + 1;
} | O0 | c | google::protobuf::RepeatedField<int>::Add(int const&):
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movl (%rcx), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x4(%rcx), %eax
jne 0x1c5e57
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x4(%rdi), %esi
addl $0x1, %esi
callq 0x1c4910
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x1c57d0
movq 0x8(%rsp), %rdx
movl 0x24(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x1c5e79
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x1c57d0
movq (%rsp), %rdx
movl 0x24(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movl 0x24(%rsp), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
| _ZN6google8protobuf13RepeatedFieldImE3AddERKm:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_10], rsi
mov rcx, [rsp+38h+var_8]
mov [rsp+38h+var_28], rcx
mov eax, [rcx]
mov [rsp+38h+var_14], eax
mov eax, [rsp+38h+var_14]
cmp eax, [rcx+4]
jnz short loc_1C5E57
mov rdi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_10]
mov rax, [rax]
mov [rsp+38h+var_20], rax
mov esi, [rdi+4]
add esi, 1
call _ZN6google8protobuf13RepeatedFieldImE7ReserveEi; google::protobuf::RepeatedField<ulong>::Reserve(int)
mov rdi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_20]
mov [rsp+38h+var_30], rax
call _ZNK6google8protobuf13RepeatedFieldImE8elementsEv; google::protobuf::RepeatedField<ulong>::elements(void)
mov rdx, [rsp+38h+var_30]
mov ecx, [rsp+38h+var_14]
mov [rax+rcx*8], rdx
jmp short loc_1C5E79
loc_1C5E57:
mov rdi, [rsp+38h+var_28]
mov rax, [rsp+38h+var_10]
mov rax, [rax]
mov [rsp+38h+var_38], rax
call _ZNK6google8protobuf13RepeatedFieldImE8elementsEv; google::protobuf::RepeatedField<ulong>::elements(void)
mov rdx, [rsp+38h+var_38]
mov ecx, [rsp+38h+var_14]
mov [rax+rcx*8], rdx
loc_1C5E79:
mov rax, [rsp+38h+var_28]
mov ecx, [rsp+38h+var_14]
add ecx, 1
mov [rax], ecx
add rsp, 38h
retn
| unsigned int * google::protobuf::RepeatedField<unsigned long>::Add(unsigned int *a1, long long *a2)
{
unsigned int *result; // rax
long long v3; // [rsp+0h] [rbp-38h]
long long v4; // [rsp+18h] [rbp-20h]
unsigned int v5; // [rsp+24h] [rbp-14h]
v5 = *a1;
if ( *a1 == a1[1] )
{
v4 = *a2;
google::protobuf::RepeatedField<unsigned long>::Reserve(a1, (google::protobuf::internal::LogMessage *)(a1[1] + 1));
*(_QWORD *)(google::protobuf::RepeatedField<unsigned long>::elements((long long)a1) + 8LL * v5) = v4;
}
else
{
v3 = *a2;
*(_QWORD *)(google::protobuf::RepeatedField<unsigned long>::elements((long long)a1) + 8LL * v5) = v3;
}
result = a1;
*a1 = v5 + 1;
return result;
}
| |||
24,949 | google::protobuf::RepeatedField<int>::Add(int const&) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/repeated_field.h | inline void RepeatedField<Element>::Add(const Element& value) {
uint32_t size = current_size_;
if (static_cast<int>(size) == total_size_) {
// value could reference an element of the array. Reserving new space will
// invalidate the reference. So we must make a copy first.
auto tmp = value;
Reserve(total_size_ + 1);
elements()[size] = std::move(tmp);
} else {
elements()[size] = value;
}
current_size_ = size + 1;
} | O3 | c | google::protobuf::RepeatedField<int>::Add(int const&):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %r14d
movsd (%rsi), %xmm0
cmpl 0x4(%rdi), %r14d
jne 0xa5517
movl %r14d, %ebp
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
movsd %xmm0, 0x8(%rsp)
callq 0xa5098
movq 0x8(%rbx), %rax
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax,%r14,8)
jmp 0xa5525
movq 0x8(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
leal 0x1(%r14), %ebp
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| _ZN6google8protobuf13RepeatedFieldIdE3AddERKd:
push rbp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov r14d, [rdi]
movsd xmm0, qword ptr [rsi]
cmp r14d, [rdi+4]
jnz short loc_A5517
mov ebp, r14d
inc ebp
mov rdi, rbx
mov esi, ebp
movsd [rsp+28h+var_20], xmm0
call _ZN6google8protobuf13RepeatedFieldIdE7ReserveEi; google::protobuf::RepeatedField<double>::Reserve(int)
mov rax, [rbx+8]
movsd xmm0, [rsp+28h+var_20]
movsd qword ptr [rax+r14*8], xmm0
jmp short loc_A5525
loc_A5517:
mov rax, [rbx+8]
movsd qword ptr [rax+r14*8], xmm0
lea ebp, [r14+1]
loc_A5525:
mov [rbx], ebp
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
| long long google::protobuf::RepeatedField<double>::Add(int *a1, long long *a2)
{
long long v2; // r14
long long v3; // xmm0_8
int v4; // ebp
long long result; // rax
v2 = (unsigned int)*a1;
v3 = *a2;
if ( (_DWORD)v2 == a1[1] )
{
v4 = v2 + 1;
google::protobuf::RepeatedField<double>::Reserve(a1, v2 + 1);
result = *((_QWORD *)a1 + 1);
*(_QWORD *)(result + 8 * v2) = v3;
}
else
{
result = *((_QWORD *)a1 + 1);
*(_QWORD *)(result + 8 * v2) = v3;
v4 = v2 + 1;
}
*a1 = v4;
return result;
}
| Add:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV R14D,dword ptr [RDI]
MOVSD XMM0,qword ptr [RSI]
CMP R14D,dword ptr [RDI + 0x4]
JNZ 0x001a5517
MOV EBP,R14D
INC EBP
MOV RDI,RBX
MOV ESI,EBP
MOVSD qword ptr [RSP + 0x8],XMM0
CALL 0x001a5098
MOV RAX,qword ptr [RBX + 0x8]
MOVSD XMM0,qword ptr [RSP + 0x8]
MOVSD qword ptr [RAX + R14*0x8],XMM0
JMP 0x001a5525
LAB_001a5517:
MOV RAX,qword ptr [RBX + 0x8]
MOVSD qword ptr [RAX + R14*0x8],XMM0
LEA EBP,[R14 + 0x1]
LAB_001a5525:
MOV dword ptr [RBX],EBP
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* google::protobuf::RepeatedField<double>::Add(double const&) */
void __thiscall
google::protobuf::RepeatedField<double>::Add(RepeatedField<double> *this,double *param_1)
{
double dVar1;
uint uVar2;
uVar2 = *(uint *)this;
dVar1 = *param_1;
if (uVar2 == *(uint *)(this + 4)) {
Reserve(this,uVar2 + 1);
*(double *)(*(long *)(this + 8) + (ulong)uVar2 * 8) = dVar1;
}
else {
*(double *)(*(long *)(this + 8) + (ulong)uVar2 * 8) = dVar1;
}
*(uint *)this = uVar2 + 1;
return;
}
| |
24,950 | my_wc_mb_gbk | eloqsql/strings/ctype-gbk.c | static int
my_wc_mb_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gbk_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O3 | c | my_wc_mb_gbk:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0xb1b26
cmpl $0x7f, %esi
ja 0xb1b27
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa4(%rsi), %eax
cmpl $0x3ad, %eax # imm = 0x3AD
ja 0xb1b42
movl %eax, %eax
leaq 0x15aa83(%rip), %rsi # 0x20c5c0
jmp 0xb1c04
leal -0x2010(%rsi), %eax
cmpl $0x302, %eax # imm = 0x302
ja 0xb1b5d
movl %eax, %eax
leaq 0x15b1c8(%rip), %rsi # 0x20cd20
jmp 0xb1c04
leal -0x2460(%rsi), %eax
cmpl $0x1e2, %eax # imm = 0x1E2
ja 0xb1b78
movl %eax, %eax
leaq 0x15b7bd(%rip), %rsi # 0x20d330
jmp 0xb1c04
leal -0x3000(%rsi), %eax
cmpl $0x129, %eax # imm = 0x129
ja 0xb1b90
movl %eax, %eax
leaq 0x15bb72(%rip), %rsi # 0x20d700
jmp 0xb1c04
leal -0x3220(%rsi), %eax
cmpl $0x83, %eax
ja 0xb1ba8
movl %eax, %eax
leaq 0x15bdba(%rip), %rsi # 0x20d960
jmp 0xb1c04
leal -0x338e(%rsi), %eax
cmpl $0x47, %eax
ja 0xb1bbe
movl %eax, %eax
leaq 0x15beb4(%rip), %rsi # 0x20da70
jmp 0xb1c04
leal -0x4e00(%rsi), %eax
cmpl $0x51a5, %eax # imm = 0x51A5
ja 0xb1bd6
movl %eax, %eax
leaq 0x15bf2c(%rip), %rsi # 0x20db00
jmp 0xb1c04
leal -0xf92c(%rsi), %eax
cmpl $0xfd, %eax
ja 0xb1bee
movl %eax, %eax
leaq 0x166264(%rip), %rsi # 0x217e50
jmp 0xb1c04
leal -0xfe30(%rsi), %eax
cmpl $0x1b5, %eax # imm = 0x1B5
ja 0xb1c34
movl %eax, %eax
leaq 0x16644c(%rip), %rsi # 0x218050
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0xb1c30
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0xb1c32
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0xb1c32
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
| my_wc_mb_gbk:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_B1B26
cmp esi, 7Fh
ja short loc_B1B27
mov [rdx], sil
mov eax, 1
locret_B1B26:
retn
loc_B1B27:
lea eax, [rsi-0A4h]
cmp eax, 3ADh
ja short loc_B1B42
mov eax, eax
lea rsi, tab_uni_gbk0
jmp loc_B1C04
loc_B1B42:
lea eax, [rsi-2010h]
cmp eax, 302h
ja short loc_B1B5D
mov eax, eax
lea rsi, tab_uni_gbk1
jmp loc_B1C04
loc_B1B5D:
lea eax, [rsi-2460h]
cmp eax, 1E2h
ja short loc_B1B78
mov eax, eax
lea rsi, tab_uni_gbk2
jmp loc_B1C04
loc_B1B78:
lea eax, [rsi-3000h]
cmp eax, 129h
ja short loc_B1B90
mov eax, eax
lea rsi, tab_uni_gbk3
jmp short loc_B1C04
loc_B1B90:
lea eax, [rsi-3220h]
cmp eax, 83h
ja short loc_B1BA8
mov eax, eax
lea rsi, tab_uni_gbk4
jmp short loc_B1C04
loc_B1BA8:
lea eax, [rsi-338Eh]
cmp eax, 47h ; 'G'
ja short loc_B1BBE
mov eax, eax
lea rsi, tab_uni_gbk5
jmp short loc_B1C04
loc_B1BBE:
lea eax, [rsi-4E00h]
cmp eax, 51A5h
ja short loc_B1BD6
mov eax, eax
lea rsi, tab_uni_gbk6
jmp short loc_B1C04
loc_B1BD6:
lea eax, [rsi-0F92Ch]
cmp eax, 0FDh
ja short loc_B1BEE
mov eax, eax
lea rsi, tab_uni_gbk7
jmp short loc_B1C04
loc_B1BEE:
lea eax, [rsi-0FE30h]
cmp eax, 1B5h
ja short loc_B1C34
mov eax, eax
lea rsi, tab_uni_gbk8
loc_B1C04:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_B1C30
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_B1C32
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_B1C32
loc_B1C30:
xor eax, eax
loc_B1C32:
pop rbp
retn
loc_B1C34:
xor eax, eax
retn
| long long my_wc_mb_gbk(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
_WORD *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 164;
if ( a2 - 164 > 0x3AD )
{
LODWORD(v5) = a2 - 8208;
if ( a2 - 8208 > 0x302 )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x1E2 )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x129 )
{
LODWORD(v5) = a2 - 12832;
if ( a2 - 12832 > 0x83 )
{
LODWORD(v5) = a2 - 13198;
if ( a2 - 13198 > 0x47 )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x51A5 )
{
LODWORD(v5) = a2 - 63788;
if ( a2 - 63788 > 0xFD )
{
LODWORD(v5) = a2 - 65072;
if ( a2 - 65072 > 0x1B5 )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk8;
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk7;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk6;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk5;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk4;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk3;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk2;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk1;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk0;
}
v7 = v6[v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_gbk:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001b1b26
CMP ESI,0x7f
JA 0x001b1b27
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_001b1b26:
RET
LAB_001b1b27:
LEA EAX,[RSI + -0xa4]
CMP EAX,0x3ad
JA 0x001b1b42
MOV EAX,EAX
LEA RSI,[0x30c5c0]
JMP 0x001b1c04
LAB_001b1b42:
LEA EAX,[RSI + -0x2010]
CMP EAX,0x302
JA 0x001b1b5d
MOV EAX,EAX
LEA RSI,[0x30cd20]
JMP 0x001b1c04
LAB_001b1b5d:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x1e2
JA 0x001b1b78
MOV EAX,EAX
LEA RSI,[0x30d330]
JMP 0x001b1c04
LAB_001b1b78:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x129
JA 0x001b1b90
MOV EAX,EAX
LEA RSI,[0x30d700]
JMP 0x001b1c04
LAB_001b1b90:
LEA EAX,[RSI + -0x3220]
CMP EAX,0x83
JA 0x001b1ba8
MOV EAX,EAX
LEA RSI,[0x30d960]
JMP 0x001b1c04
LAB_001b1ba8:
LEA EAX,[RSI + -0x338e]
CMP EAX,0x47
JA 0x001b1bbe
MOV EAX,EAX
LEA RSI,[0x30da70]
JMP 0x001b1c04
LAB_001b1bbe:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x51a5
JA 0x001b1bd6
MOV EAX,EAX
LEA RSI,[0x30db00]
JMP 0x001b1c04
LAB_001b1bd6:
LEA EAX,[RSI + -0xf92c]
CMP EAX,0xfd
JA 0x001b1bee
MOV EAX,EAX
LEA RSI,[0x317e50]
JMP 0x001b1c04
LAB_001b1bee:
LEA EAX,[RSI + -0xfe30]
CMP EAX,0x1b5
JA 0x001b1c34
MOV EAX,EAX
LEA RSI,[0x318050]
LAB_001b1c04:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x001b1c30
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x001b1c32
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x001b1c32
LAB_001b1c30:
XOR EAX,EAX
LAB_001b1c32:
POP RBP
RET
LAB_001b1c34:
XOR EAX,EAX
RET
|
int8 my_wc_mb_gbk(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa4 < 0x3ae) {
uVar3 = (ulong)(param_2 - 0xa4);
puVar4 = tab_uni_gbk0;
}
else if (param_2 - 0x2010 < 0x303) {
uVar3 = (ulong)(param_2 - 0x2010);
puVar4 = tab_uni_gbk1;
}
else if (param_2 - 0x2460 < 0x1e3) {
uVar3 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_gbk2;
}
else if (param_2 - 0x3000 < 0x12a) {
uVar3 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_gbk3;
}
else if (param_2 - 0x3220 < 0x84) {
uVar3 = (ulong)(param_2 - 0x3220);
puVar4 = tab_uni_gbk4;
}
else if (param_2 - 0x338e < 0x48) {
uVar3 = (ulong)(param_2 - 0x338e);
puVar4 = tab_uni_gbk5;
}
else if (param_2 - 0x4e00 < 0x51a6) {
uVar3 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_gbk6;
}
else if (param_2 - 0xf92c < 0xfe) {
uVar3 = (ulong)(param_2 - 0xf92c);
puVar4 = tab_uni_gbk7;
}
else {
uVar3 = (ulong)(param_2 - 0xfe30);
if (0x1b5 < param_2 - 0xfe30) {
return 0;
}
puVar4 = tab_uni_gbk8;
}
uVar1 = *(ushort *)(puVar4 + uVar3 * 2);
if (uVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar2 = 2;
}
}
return uVar2;
}
*(char *)param_3 = (char)param_2;
uVar2 = 1;
}
return uVar2;
}
| |
24,951 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O3 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x0, (%r9)
leaq (%rsi,%rdx), %r11
movq %rsi, %r10
testq %rdx, %rdx
jle 0x39335
movq 0x40(%rdi), %rax
movq %rsi, %r10
movzbl (%r10), %edx
testb $0x8, 0x1(%rax,%rdx)
je 0x39335
incq %r10
cmpq %r11, %r10
jb 0x39322
cmpq %r11, %r10
je 0x3941d
movb (%r10), %dil
leal -0x2b(%rdi), %eax
andb $-0x3, %al
cmpb $0x1, %al
adcq $0x0, %r10
movslq %ecx, %rbx
movq $-0x1, %rax
xorl %edx, %edx
movq %rbx, -0x38(%rbp)
divq %rbx
xorl %r12d, %r12d
cmpq %r11, %r10
je 0x393fa
movq %rdi, -0x30(%rbp)
movq %r10, %r14
xorl %r15d, %r15d
movq %r15, %rdi
movl %r12d, %r13d
movb (%r14), %r12b
leal -0x30(%r12), %ebx
cmpb $0xa, %bl
jb 0x393a9
leal -0x41(%r12), %ebx
cmpb $0x19, %bl
ja 0x39398
addb $-0x37, %r12b
jmp 0x393a6
leal -0x61(%r12), %ebx
cmpb $0x19, %bl
ja 0x393e8
addb $-0x57, %r12b
movl %r12d, %ebx
movzbl %bl, %ebx
cmpl %ecx, %ebx
jge 0x393e8
movl $0x1, %r12d
cmpq %rax, %rdi
jbe 0x393c0
movq %rdi, %r15
jmp 0x393d7
jne 0x393c9
movq %rax, %r15
cmpl %edx, %ebx
ja 0x393d7
imulq -0x38(%rbp), %rdi
movl %ebx, %r15d
addq %rdi, %r15
movl %r13d, %r12d
incq %r14
cmpq %r11, %r14
jne 0x39375
movq %r15, %rdi
movq %r11, %r14
movl %r12d, %r13d
testl %r13d, %r13d
sete %al
movq %rdi, %r12
movq %r14, %r11
movq -0x30(%rbp), %rdi
jmp 0x393fc
movb $0x1, %al
cmpq %r10, %r11
je 0x3941d
testq %r8, %r8
je 0x39409
movq %r11, (%r8)
testb %al, %al
je 0x39430
movq %r12, %rax
negq %rax
cmpb $0x2d, %dil
cmovneq %r12, %rax
jmp 0x3943e
movl $0x21, (%r9)
testq %r8, %r8
je 0x3942c
movq %rsi, (%r8)
xorl %eax, %eax
jmp 0x3943e
movl $0x22, (%r9)
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strntoull_8bit:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
mov dword ptr [r9], 0
lea r11, [rsi+rdx]
mov r10, rsi
test rdx, rdx
jle short loc_39335
mov rax, [rdi+40h]
mov r10, rsi
loc_39322:
movzx edx, byte ptr [r10]
test byte ptr [rax+rdx+1], 8
jz short loc_39335
inc r10
cmp r10, r11
jb short loc_39322
loc_39335:
cmp r10, r11
jz loc_3941D
mov dil, [r10]
lea eax, [rdi-2Bh]
and al, 0FDh
cmp al, 1
adc r10, 0
movsxd rbx, ecx
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
mov [rbp+var_38], rbx
div rbx
xor r12d, r12d
cmp r10, r11
jz loc_393FA
mov [rbp+var_30], rdi
mov r14, r10
xor r15d, r15d
loc_39375:
mov rdi, r15
mov r13d, r12d
mov r12b, [r14]
lea ebx, [r12-30h]
cmp bl, 0Ah
jb short loc_393A9
lea ebx, [r12-41h]
cmp bl, 19h
ja short loc_39398
add r12b, 0C9h
jmp short loc_393A6
loc_39398:
lea ebx, [r12-61h]
cmp bl, 19h
ja short loc_393E8
add r12b, 0A9h
loc_393A6:
mov ebx, r12d
loc_393A9:
movzx ebx, bl
cmp ebx, ecx
jge short loc_393E8
mov r12d, 1
cmp rdi, rax
jbe short loc_393C0
mov r15, rdi
jmp short loc_393D7
loc_393C0:
jnz short loc_393C9
mov r15, rax
cmp ebx, edx
ja short loc_393D7
loc_393C9:
imul rdi, [rbp+var_38]
mov r15d, ebx
add r15, rdi
mov r12d, r13d
loc_393D7:
inc r14
cmp r14, r11
jnz short loc_39375
mov rdi, r15
mov r14, r11
mov r13d, r12d
loc_393E8:
test r13d, r13d
setz al
mov r12, rdi
mov r11, r14
mov rdi, [rbp+var_30]
jmp short loc_393FC
loc_393FA:
mov al, 1
loc_393FC:
cmp r11, r10
jz short loc_3941D
test r8, r8
jz short loc_39409
mov [r8], r11
loc_39409:
test al, al
jz short loc_39430
mov rax, r12
neg rax
cmp dil, 2Dh ; '-'
cmovnz rax, r12
jmp short loc_3943E
loc_3941D:
mov dword ptr [r9], 21h ; '!'
test r8, r8
jz short loc_3942C
mov [r8], rsi
loc_3942C:
xor eax, eax
jmp short loc_3943E
loc_39430:
mov dword ptr [r9], 22h ; '"'
mov rax, 0FFFFFFFFFFFFFFFFh
loc_3943E:
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strntoull_8bit(
long long a1,
unsigned __int8 *a2,
long long a3,
int a4,
unsigned __int8 **a5,
_DWORD *a6)
{
unsigned __int8 *v6; // r11
unsigned __int8 *v7; // r10
unsigned __int8 v8; // di
unsigned __int8 *v9; // r10
unsigned long long v10; // rax
unsigned long long v11; // r12
unsigned __int8 *v12; // r14
unsigned long long v13; // r15
unsigned long long v14; // rdi
int v15; // r13d
unsigned __int8 v16; // r12
unsigned __int8 v17; // bl
unsigned __int8 v18; // r12
bool v19; // al
long long result; // rax
unsigned __int8 v21; // [rsp+8h] [rbp-30h]
*a6 = 0;
v6 = &a2[a3];
v7 = a2;
if ( a3 > 0 )
{
v7 = a2;
do
{
if ( (*(_BYTE *)(*(_QWORD *)(a1 + 64) + *v7 + 1LL) & 8) == 0 )
break;
++v7;
}
while ( v7 < v6 );
}
if ( v7 == v6 )
goto LABEL_30;
v8 = *v7;
v9 = &v7[((*v7 - 43) & 0xFD) == 0];
v10 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0LL;
if ( v9 == v6 )
{
v19 = 1;
}
else
{
v21 = v8;
v12 = v9;
v13 = 0LL;
while ( 1 )
{
v14 = v13;
v15 = v11;
v16 = *v12;
v17 = *v12 - 48;
if ( v17 >= 0xAu )
{
if ( (unsigned __int8)(v16 - 65) > 0x19u )
{
if ( (unsigned __int8)(v16 - 97) > 0x19u )
break;
v18 = v16 - 87;
}
else
{
v18 = v16 - 55;
}
v17 = v18;
}
if ( v17 >= a4 )
break;
LODWORD(v11) = 1;
if ( v13 <= v10 )
{
if ( v13 != v10 || (v13 = 0xFFFFFFFFFFFFFFFFLL / a4, v17 <= (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4)) )
{
v13 = a4 * v14 + v17;
LODWORD(v11) = v15;
}
}
if ( ++v12 == v6 )
{
v14 = v13;
v12 = &a2[a3];
v15 = v11;
break;
}
}
v19 = v15 == 0;
v11 = v14;
v6 = v12;
v8 = v21;
}
if ( v6 == v9 )
{
LABEL_30:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v6;
if ( v19 )
{
result = -(long long)v11;
if ( v8 != 45 )
return v11;
}
else
{
*a6 = 34;
return -1LL;
}
}
return result;
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV dword ptr [R9],0x0
LEA R11,[RSI + RDX*0x1]
MOV R10,RSI
TEST RDX,RDX
JLE 0x00139335
MOV RAX,qword ptr [RDI + 0x40]
MOV R10,RSI
LAB_00139322:
MOVZX EDX,byte ptr [R10]
TEST byte ptr [RAX + RDX*0x1 + 0x1],0x8
JZ 0x00139335
INC R10
CMP R10,R11
JC 0x00139322
LAB_00139335:
CMP R10,R11
JZ 0x0013941d
MOV DIL,byte ptr [R10]
LEA EAX,[RDI + -0x2b]
AND AL,0xfd
CMP AL,0x1
ADC R10,0x0
MOVSXD RBX,ECX
MOV RAX,-0x1
XOR EDX,EDX
MOV qword ptr [RBP + -0x38],RBX
DIV RBX
XOR R12D,R12D
CMP R10,R11
JZ 0x001393fa
MOV qword ptr [RBP + -0x30],RDI
MOV R14,R10
XOR R15D,R15D
LAB_00139375:
MOV RDI,R15
MOV R13D,R12D
MOV R12B,byte ptr [R14]
LEA EBX,[R12 + -0x30]
CMP BL,0xa
JC 0x001393a9
LEA EBX,[R12 + -0x41]
CMP BL,0x19
JA 0x00139398
ADD R12B,0xc9
JMP 0x001393a6
LAB_00139398:
LEA EBX,[R12 + -0x61]
CMP BL,0x19
JA 0x001393e8
ADD R12B,0xa9
LAB_001393a6:
MOV EBX,R12D
LAB_001393a9:
MOVZX EBX,BL
CMP EBX,ECX
JGE 0x001393e8
MOV R12D,0x1
CMP RDI,RAX
JBE 0x001393c0
MOV R15,RDI
JMP 0x001393d7
LAB_001393c0:
JNZ 0x001393c9
MOV R15,RAX
CMP EBX,EDX
JA 0x001393d7
LAB_001393c9:
IMUL RDI,qword ptr [RBP + -0x38]
MOV R15D,EBX
ADD R15,RDI
MOV R12D,R13D
LAB_001393d7:
INC R14
CMP R14,R11
JNZ 0x00139375
MOV RDI,R15
MOV R14,R11
MOV R13D,R12D
LAB_001393e8:
TEST R13D,R13D
SETZ AL
MOV R12,RDI
MOV R11,R14
MOV RDI,qword ptr [RBP + -0x30]
JMP 0x001393fc
LAB_001393fa:
MOV AL,0x1
LAB_001393fc:
CMP R11,R10
JZ 0x0013941d
TEST R8,R8
JZ 0x00139409
MOV qword ptr [R8],R11
LAB_00139409:
TEST AL,AL
JZ 0x00139430
MOV RAX,R12
NEG RAX
CMP DIL,0x2d
CMOVNZ RAX,R12
JMP 0x0013943e
LAB_0013941d:
MOV dword ptr [R9],0x21
TEST R8,R8
JZ 0x0013942c
MOV qword ptr [R8],RSI
LAB_0013942c:
XOR EAX,EAX
JMP 0x0013943e
LAB_00139430:
MOV dword ptr [R9],0x22
MOV RAX,-0x1
LAB_0013943e:
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,ulong *param_5,
int4 *param_6)
{
byte bVar1;
byte bVar2;
int1 auVar3 [16];
int1 auVar4 [16];
ulong uVar5;
ulong uVar6;
ulong uVar7;
byte *pbVar8;
byte *pbVar9;
byte bVar10;
ulong uVar11;
ulong uVar12;
int iVar13;
byte *pbVar14;
bool bVar15;
*param_6 = 0;
pbVar9 = param_2 + param_3;
pbVar8 = param_2;
if (0 < param_3) {
do {
if ((*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*pbVar8) & 8) == 0) break;
pbVar8 = pbVar8 + 1;
} while (pbVar8 < pbVar9);
}
if (pbVar8 != pbVar9) {
bVar1 = *pbVar8;
pbVar8 = pbVar8 + ((bVar1 - 0x2b & 0xfd) == 0);
auVar3._8_8_ = 0;
auVar3._0_8_ = (long)param_4;
auVar4 = ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff);
uVar6 = SUB168(auVar4 / auVar3,0);
uVar7 = 0;
if (pbVar8 == pbVar9) {
bVar15 = true;
}
else {
uVar11 = uVar7;
pbVar14 = pbVar8;
uVar7 = 0;
do {
iVar13 = (int)uVar11;
bVar2 = *pbVar14;
bVar10 = bVar2 - 0x30;
if (9 < bVar10) {
if ((byte)(bVar2 + 0xbf) < 0x1a) {
bVar10 = bVar2 - 0x37;
}
else {
if (0x19 < (byte)(bVar2 + 0x9f)) goto LAB_001393e8;
bVar10 = bVar2 + 0xa9;
}
}
if (param_4 <= (int)(uint)bVar10) goto LAB_001393e8;
uVar12 = 1;
uVar5 = uVar7;
if ((uVar7 <= uVar6) &&
((uVar7 != uVar6 || (uVar5 = uVar6, (uint)bVar10 <= SUB164(auVar4 % auVar3,0))))) {
uVar12 = uVar11;
uVar5 = (ulong)bVar10 + uVar7 * (long)param_4;
}
uVar7 = uVar5;
pbVar14 = pbVar14 + 1;
uVar11 = uVar12;
} while (pbVar14 != pbVar9);
iVar13 = (int)uVar12;
pbVar14 = pbVar9;
LAB_001393e8:
pbVar9 = pbVar14;
bVar15 = iVar13 == 0;
}
if (pbVar9 != pbVar8) {
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)pbVar9;
}
if (bVar15) {
if (bVar1 == 0x2d) {
return -uVar7;
}
return uVar7;
}
*param_6 = 0x22;
return 0xffffffffffffffff;
}
}
*param_6 = 0x21;
if (param_5 != (ulong *)0x0) {
*param_5 = (ulong)param_2;
}
return 0;
}
| |
24,952 | ma_net_real_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_real_write(NET *net, const char *packet, size_t len)
{
ssize_t length;
char *pos,*end;
if (net->error == 2)
return(-1); /* socket can't be used */
net->reading_or_writing=2;
#ifdef HAVE_COMPRESS
if (net->compress)
{
size_t complen;
uchar *b;
uint header_length=NET_HEADER_SIZE+COMP_HEADER_SIZE;
if (!(b=(uchar*) malloc(len + NET_HEADER_SIZE + COMP_HEADER_SIZE + 1)))
{
net->pvio->set_error(net->pvio->mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
net->error=2;
net->reading_or_writing=0;
return(1);
}
memcpy(b+header_length,packet,len);
if (_mariadb_compress(net, (unsigned char*) b+header_length,&len,&complen))
{
complen=0;
}
int3store(&b[NET_HEADER_SIZE],complen);
int3store(b,len);
b[3]=(uchar) (net->compress_pkt_nr++);
len+= header_length;
packet= (char*) b;
}
#endif /* HAVE_COMPRESS */
pos=(char*) packet; end=pos+len;
while (pos != end)
{
if ((length=ma_pvio_write(net->pvio,(uchar *)pos,(size_t) (end-pos))) <= 0)
{
int save_errno= errno;
char errmsg[100];
net->error=2; /* Close socket */
strerror_r(save_errno, errmsg, 100);
net->pvio->set_error(net->pvio->mysql, CR_ERR_NET_WRITE, SQLSTATE_UNKNOWN, 0,
errmsg, save_errno);
net->reading_or_writing=0;
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
return(1);
}
pos+=length;
}
#ifdef HAVE_COMPRESS
if (net->compress)
free((char*) packet);
#endif
net->reading_or_writing=0;
return(((int) (pos != end)));
} | O3 | c | ma_net_real_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rdx, -0xa8(%rbp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $0x2, 0x94(%rdi)
je 0x311d9
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0x2, 0x80(%rdi)
cmpb $0x0, 0x84(%rdi)
je 0x310aa
leaq 0x8(%rbx), %rdi
callq 0x13600
testq %rax, %rax
je 0x310af
movq %rax, %r12
movq %rax, %r13
addq $0x7, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x13390
leaq -0xa8(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
movq %r14, %rdi
movq %r13, %rsi
callq 0x1decf
testb %al, %al
jne 0x310e2
movq -0xa0(%rbp), %rax
jmp 0x310e4
movq %r15, %r12
jmp 0x3112a
movq (%r14), %r8
movq 0x40(%r8), %rdi
leaq 0x17943(%rip), %rax # 0x48a00
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %ecx, %ecx
xorl %eax, %eax
callq *0x50(%r8)
movb $0x2, 0x94(%r14)
movb $0x0, 0x80(%r14)
jmp 0x311d4
xorl %eax, %eax
movq %r12, %rdx
movb %al, 0x4(%r12)
movb %ah, 0x5(%rdx)
shrl $0x10, %eax
movb %al, 0x6(%r12)
movq -0xa8(%rbp), %rbx
movb %bl, (%r12)
movb %bh, 0x1(%rdx)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%r12)
movl 0x64(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x64(%r14)
movb %al, 0x3(%r12)
addq $0x7, %rbx
movq %rbx, -0xa8(%rbp)
testq %rbx, %rbx
je 0x31153
movq %r12, %r15
addq %r12, %rbx
movq (%r14), %rdi
movq %rbx, %rdx
subq %r15, %rdx
movq %r15, %rsi
callq 0x1d2b6
testq %rax, %rax
jle 0x31171
addq %rax, %r15
cmpq %rbx, %r15
jne 0x31135
cmpb $0x0, 0x84(%r14)
je 0x31165
movq %r12, %rdi
callq 0x13570
movb $0x0, 0x80(%r14)
xorl %eax, %eax
jmp 0x311d9
callq 0x13060
movl (%rax), %ebx
movb $0x2, 0x94(%r14)
leaq -0xa0(%rbp), %r15
movl $0x64, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x131e0
movq (%r14), %r10
movq 0x40(%r10), %rdi
leaq 0x1785c(%rip), %rax # 0x48a00
movq (%rax), %rdx
movl $0x1396, %esi # imm = 0x1396
xorl %ecx, %ecx
movq %r15, %r8
movl %ebx, %r9d
xorl %eax, %eax
callq *0x50(%r10)
movb $0x0, 0x80(%r14)
cmpb $0x0, 0x84(%r14)
je 0x311d4
movq %r12, %rdi
callq 0x13570
movl $0x1, %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x311fa
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_real_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 88h
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_A8], rdx
mov eax, 0FFFFFFFFh
cmp byte ptr [rdi+94h], 2
jz loc_311D9
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov byte ptr [rdi+80h], 2
cmp byte ptr [rdi+84h], 0
jz short loc_310AA
lea rdi, [rbx+8]
call _malloc
test rax, rax
jz short loc_310AF
mov r12, rax
mov r13, rax
add r13, 7
mov rdi, r13
mov rsi, r15
mov rdx, rbx
call _memcpy
lea rdx, [rbp+var_A8]
lea rcx, [rbp+var_A0]
mov rdi, r14
mov rsi, r13
call _mariadb_compress
test al, al
jnz short loc_310E2
mov rax, [rbp+var_A0]
jmp short loc_310E4
loc_310AA:
mov r12, r15
jmp short loc_3112A
loc_310AF:
mov r8, [r14]
mov rdi, [r8+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor ecx, ecx
xor eax, eax
call qword ptr [r8+50h]
mov byte ptr [r14+94h], 2
mov byte ptr [r14+80h], 0
jmp loc_311D4
loc_310E2:
xor eax, eax
loc_310E4:
mov rdx, r12
mov [r12+4], al
mov [rdx+5], ah
shr eax, 10h
mov [r12+6], al
mov rbx, [rbp+var_A8]
mov [r12], bl
mov [rdx+1], bh
mov eax, ebx
shr eax, 10h
mov [r12+2], al
mov eax, [r14+64h]
lea ecx, [rax+1]
mov [r14+64h], ecx
mov [r12+3], al
add rbx, 7
mov [rbp+var_A8], rbx
loc_3112A:
test rbx, rbx
jz short loc_31153
mov r15, r12
add rbx, r12
loc_31135:
mov rdi, [r14]
mov rdx, rbx
sub rdx, r15
mov rsi, r15
call ma_pvio_write
test rax, rax
jle short loc_31171
add r15, rax
cmp r15, rbx
jnz short loc_31135
loc_31153:
cmp byte ptr [r14+84h], 0
jz short loc_31165
mov rdi, r12
call _free
loc_31165:
mov byte ptr [r14+80h], 0
xor eax, eax
jmp short loc_311D9
loc_31171:
call ___errno_location
mov ebx, [rax]
mov byte ptr [r14+94h], 2
lea r15, [rbp+var_A0]
mov edx, 64h ; 'd'
mov edi, ebx
mov rsi, r15
call ___xpg_strerror_r
mov r10, [r14]
mov rdi, [r10+40h]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 1396h
xor ecx, ecx
mov r8, r15
mov r9d, ebx
xor eax, eax
call qword ptr [r10+50h]
mov byte ptr [r14+80h], 0
cmp byte ptr [r14+84h], 0
jz short loc_311D4
mov rdi, r12
call _free
loc_311D4:
mov eax, 1
loc_311D9:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_311FA
add rsp, 88h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_311FA:
call ___stack_chk_fail
| long long ma_net_real_write(_BYTE *a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rbx
long long v6; // rax
long long v7; // r12
long long v8; // r13
int v9; // eax
long long v10; // rbx
int v11; // eax
long long v12; // r15
long long v13; // rbx
long long v14; // rdi
long long v15; // rax
unsigned int v16; // ebx
long long v17; // [rsp+8h] [rbp-A8h] BYREF
_QWORD v18[20]; // [rsp+10h] [rbp-A0h] BYREF
v18[14] = __readfsqword(0x28u);
v17 = a3;
result = 0xFFFFFFFFLL;
if ( a1[148] != 2 )
{
v4 = a3;
a1[128] = 2;
if ( a1[132] )
{
v6 = malloc(a3 + 8);
if ( !v6 )
{
(*(void ( **)(_QWORD, long long, char *, _QWORD))(*(_QWORD *)a1 + 80LL))(
*(_QWORD *)(*(_QWORD *)a1 + 64LL),
2008LL,
SQLSTATE_UNKNOWN,
0LL);
a1[148] = 2;
a1[128] = 0;
return 1LL;
}
v7 = v6;
v8 = v6 + 7;
memcpy(v6 + 7, a2, v4);
if ( mariadb_compress((long long)a1, v8, &v17, v18) )
v9 = 0;
else
v9 = v18[0];
*(_WORD *)(v7 + 4) = v9;
*(_BYTE *)(v7 + 6) = BYTE2(v9);
v10 = v17;
*(_WORD *)v7 = v17;
*(_BYTE *)(v7 + 2) = BYTE2(v10);
v11 = *((_DWORD *)a1 + 25);
*((_DWORD *)a1 + 25) = v11 + 1;
*(_BYTE *)(v7 + 3) = v11;
v4 = v10 + 7;
v17 = v4;
}
else
{
v7 = a2;
}
if ( v4 )
{
v12 = v7;
v13 = v7 + v4;
while ( 1 )
{
v14 = *(_QWORD *)a1;
v15 = ma_pvio_write(*(_QWORD *)a1, v12, v13 - v12);
if ( v15 <= 0 )
break;
v12 += v15;
if ( v12 == v13 )
goto LABEL_14;
}
v16 = *(_DWORD *)__errno_location(v14);
a1[148] = 2;
__xpg_strerror_r(v16, v18, 100LL);
(*(void ( **)(_QWORD, long long, char *, _QWORD, _QWORD *, _QWORD))(*(_QWORD *)a1 + 80LL))(
*(_QWORD *)(*(_QWORD *)a1 + 64LL),
5014LL,
SQLSTATE_UNKNOWN,
0LL,
v18,
v16);
a1[128] = 0;
if ( a1[132] )
free(v7);
return 1LL;
}
LABEL_14:
if ( a1[132] )
free(v7);
a1[128] = 0;
return 0LL;
}
return result;
}
| ma_net_real_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x88
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0xa8],RDX
MOV EAX,0xffffffff
CMP byte ptr [RDI + 0x94],0x2
JZ 0x001311d9
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV byte ptr [RDI + 0x80],0x2
CMP byte ptr [RDI + 0x84],0x0
JZ 0x001310aa
LEA RDI,[RBX + 0x8]
CALL 0x00113600
TEST RAX,RAX
JZ 0x001310af
MOV R12,RAX
MOV R13,RAX
ADD R13,0x7
MOV RDI,R13
MOV RSI,R15
MOV RDX,RBX
CALL 0x00113390
LEA RDX,[RBP + -0xa8]
LEA RCX,[RBP + -0xa0]
MOV RDI,R14
MOV RSI,R13
CALL 0x0011decf
TEST AL,AL
JNZ 0x001310e2
MOV RAX,qword ptr [RBP + -0xa0]
JMP 0x001310e4
LAB_001310aa:
MOV R12,R15
JMP 0x0013112a
LAB_001310af:
MOV R8,qword ptr [R14]
MOV RDI,qword ptr [R8 + 0x40]
LEA RAX,[0x148a00]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR ECX,ECX
XOR EAX,EAX
CALL qword ptr [R8 + 0x50]
MOV byte ptr [R14 + 0x94],0x2
MOV byte ptr [R14 + 0x80],0x0
JMP 0x001311d4
LAB_001310e2:
XOR EAX,EAX
LAB_001310e4:
MOV RDX,R12
MOV byte ptr [R12 + 0x4],AL
MOV byte ptr [RDX + 0x5],AH
SHR EAX,0x10
MOV byte ptr [R12 + 0x6],AL
MOV RBX,qword ptr [RBP + -0xa8]
MOV byte ptr [R12],BL
MOV byte ptr [RDX + 0x1],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [R12 + 0x2],AL
MOV EAX,dword ptr [R14 + 0x64]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R14 + 0x64],ECX
MOV byte ptr [R12 + 0x3],AL
ADD RBX,0x7
MOV qword ptr [RBP + -0xa8],RBX
LAB_0013112a:
TEST RBX,RBX
JZ 0x00131153
MOV R15,R12
ADD RBX,R12
LAB_00131135:
MOV RDI,qword ptr [R14]
MOV RDX,RBX
SUB RDX,R15
MOV RSI,R15
CALL 0x0011d2b6
TEST RAX,RAX
JLE 0x00131171
ADD R15,RAX
CMP R15,RBX
JNZ 0x00131135
LAB_00131153:
CMP byte ptr [R14 + 0x84],0x0
JZ 0x00131165
MOV RDI,R12
CALL 0x00113570
LAB_00131165:
MOV byte ptr [R14 + 0x80],0x0
XOR EAX,EAX
JMP 0x001311d9
LAB_00131171:
CALL 0x00113060
MOV EBX,dword ptr [RAX]
MOV byte ptr [R14 + 0x94],0x2
LEA R15,[RBP + -0xa0]
MOV EDX,0x64
MOV EDI,EBX
MOV RSI,R15
CALL 0x001131e0
MOV R10,qword ptr [R14]
MOV RDI,qword ptr [R10 + 0x40]
LEA RAX,[0x148a00]
MOV RDX,qword ptr [RAX]
MOV ESI,0x1396
XOR ECX,ECX
MOV R8,R15
MOV R9D,EBX
XOR EAX,EAX
CALL qword ptr [R10 + 0x50]
MOV byte ptr [R14 + 0x80],0x0
CMP byte ptr [R14 + 0x84],0x0
JZ 0x001311d4
MOV RDI,R12
CALL 0x00113570
LAB_001311d4:
MOV EAX,0x1
LAB_001311d9:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x001311fa
ADD RSP,0x88
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001311fa:
CALL 0x00113500
|
int8 ma_net_real_write(long *param_1,int1 *param_2,size_t param_3)
{
int iVar1;
char cVar2;
int8 uVar3;
int1 *puVar4;
long lVar5;
int *piVar6;
int1 *puVar7;
long in_FS_OFFSET;
size_t local_b0;
int4 local_a8 [28];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar3 = 0xffffffff;
local_b0 = param_3;
if (*(char *)((long)param_1 + 0x94) != '\x02') {
*(int1 *)(param_1 + 0x10) = 2;
if (*(char *)((long)param_1 + 0x84) != '\0') {
puVar4 = (int1 *)malloc(param_3 + 8);
if (puVar4 == (int1 *)0x0) {
(**(code **)(*param_1 + 0x50))(*(int8 *)(*param_1 + 0x40),0x7d8,SQLSTATE_UNKNOWN,0);
*(int1 *)((long)param_1 + 0x94) = 2;
*(int1 *)(param_1 + 0x10) = 0;
LAB_001311d4:
uVar3 = 1;
goto LAB_001311d9;
}
memcpy(puVar4 + 7,param_2,param_3);
cVar2 = _mariadb_compress(param_1,puVar4 + 7,&local_b0,local_a8);
if (cVar2 != '\0') {
local_a8[0] = 0;
}
puVar4[4] = (char)local_a8[0];
puVar4[5] = (char)((uint)local_a8[0] >> 8);
puVar4[6] = (char)((uint)local_a8[0] >> 0x10);
*puVar4 = (char)local_b0;
puVar4[1] = (char)(local_b0 >> 8);
puVar4[2] = (char)(local_b0 >> 0x10);
iVar1 = *(int *)((long)param_1 + 100);
*(int *)((long)param_1 + 100) = iVar1 + 1;
puVar4[3] = (char)iVar1;
local_b0 = local_b0 + 7;
param_2 = puVar4;
}
if (local_b0 != 0) {
puVar7 = param_2 + local_b0;
puVar4 = param_2;
do {
lVar5 = ma_pvio_write(*param_1,puVar4,(long)puVar7 - (long)puVar4);
if (lVar5 < 1) {
piVar6 = __errno_location();
iVar1 = *piVar6;
*(int1 *)((long)param_1 + 0x94) = 2;
__xpg_strerror_r(iVar1,local_a8,100);
(**(code **)(*param_1 + 0x50))
(*(int8 *)(*param_1 + 0x40),0x1396,SQLSTATE_UNKNOWN,0,local_a8,iVar1);
*(int1 *)(param_1 + 0x10) = 0;
if (*(char *)((long)param_1 + 0x84) != '\0') {
free(param_2);
}
goto LAB_001311d4;
}
puVar4 = puVar4 + lVar5;
} while (puVar4 != puVar7);
}
if (*(char *)((long)param_1 + 0x84) != '\0') {
free(param_2);
}
*(int1 *)(param_1 + 0x10) = 0;
uVar3 = 0;
}
LAB_001311d9:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar3;
}
| |
24,953 | strxmov | eloqsql/strings/strxmov.c | char *strxmov(char *dst,const char *src, ...)
{
va_list pvar;
va_start(pvar,src);
while (src != NullS) {
while ((*dst++ = *src++)) ;
dst--;
src = va_arg(pvar, char *);
}
va_end(pvar);
*dst = 0; /* there might have been no sources! */
return dst;
} | O3 | c | strxmov:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %eax, %r10d
movq %rdi, %rax
leaq -0xd0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %r10b, %r10b
je 0xd7280
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movabsq $0x3000000010, %rcx # imm = 0x3000000010
movq %rcx, -0x20(%rbp)
testq %rsi, %rsi
je 0xd72ee
movq -0x10(%rbp), %rcx
movl -0x20(%rbp), %edx
movq -0x18(%rbp), %rdi
movq %rdi, %r8
movb (%rsi), %r9b
movb %r9b, (%rax)
testb %r9b, %r9b
jne 0xd72e6
cmpl $0x28, %edx
ja 0xd72ce
movq %r8, %r9
movl %edx, %r8d
addq %rcx, %r8
addl $0x8, %edx
movl %edx, -0x20(%rbp)
jmp 0xd72d9
leaq 0x8(%r8), %rdi
movq %rdi, -0x18(%rbp)
movq %rdi, %r9
movq (%r8), %rsi
movq %r9, %r8
testq %rsi, %rsi
jne 0xd72ad
jmp 0xd72ee
incq %rax
incq %rsi
jmp 0xd72aa
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nop
| strxmov:
push rbp
mov rbp, rsp
sub rsp, 50h
mov r10d, eax
mov rax, rdi
lea rdi, [rbp+var_D0]
mov [rdi+10h], rdx
mov [rdi+18h], rcx
mov [rdi+20h], r8
mov [rdi+28h], r9
test r10b, r10b
jz short loc_D7280
movaps [rbp+var_A0], xmm0
movaps [rbp+var_90], xmm1
movaps [rbp+var_80], xmm2
movaps [rbp+var_70], xmm3
movaps [rbp+var_60], xmm4
movaps [rbp+var_50], xmm5
movaps [rbp+var_40], xmm6
movaps [rbp+var_30], xmm7
loc_D7280:
mov [rbp+var_10], rdi
lea rcx, [rbp+arg_0]
mov [rbp+var_18], rcx
mov rcx, 3000000010h
mov [rbp+var_20], rcx
test rsi, rsi
jz short loc_D72EE
mov rcx, [rbp+var_10]
mov edx, dword ptr [rbp+var_20]
mov rdi, [rbp+var_18]
loc_D72AA:
mov r8, rdi
loc_D72AD:
mov r9b, [rsi]
mov [rax], r9b
test r9b, r9b
jnz short loc_D72E6
cmp edx, 28h ; '('
ja short loc_D72CE
mov r9, r8
mov r8d, edx
add r8, rcx
add edx, 8
mov dword ptr [rbp+var_20], edx
jmp short loc_D72D9
loc_D72CE:
lea rdi, [r8+8]
mov [rbp+var_18], rdi
mov r9, rdi
loc_D72D9:
mov rsi, [r8]
mov r8, r9
test rsi, rsi
jnz short loc_D72AD
jmp short loc_D72EE
loc_D72E6:
inc rax
inc rsi
jmp short loc_D72AA
loc_D72EE:
mov byte ptr [rax], 0
add rsp, 50h
pop rbp
retn
| char *strxmov(char *a1, char *a2, ...)
{
char *result; // rax
char *reg_save_area; // rcx
unsigned int gp_offset; // edx
char *overflow_arg_area; // rdi
char *v6; // r8
char v7; // r9
char *v8; // r9
va_list va; // [rsp+B0h] [rbp-20h] BYREF
result = a1;
va_start(va, a2);
if ( a2 )
{
reg_save_area = (char *)va[0].reg_save_area;
gp_offset = va[0].gp_offset;
overflow_arg_area = (char *)va[0].overflow_arg_area;
while ( 1 )
{
v6 = overflow_arg_area;
while ( 1 )
{
v7 = *a2;
*result = *a2;
if ( v7 )
break;
if ( gp_offset > 0x28 )
{
overflow_arg_area = v6 + 8;
va[0].overflow_arg_area = v6 + 8;
v8 = v6 + 8;
}
else
{
v8 = v6;
v6 = ®_save_area[gp_offset];
gp_offset += 8;
va[0].gp_offset = gp_offset;
}
a2 = *(char **)v6;
v6 = v8;
if ( !a2 )
goto LABEL_11;
}
++result;
++a2;
}
}
LABEL_11:
*result = 0;
return result;
}
| strxmov:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV R10D,EAX
MOV RAX,RDI
LEA RDI,[RBP + -0xd0]
MOV qword ptr [RDI + 0x10],RDX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],R8
MOV qword ptr [RDI + 0x28],R9
TEST R10B,R10B
JZ 0x001d7280
MOVAPS xmmword ptr [RBP + -0xa0],XMM0
MOVAPS xmmword ptr [RBP + -0x90],XMM1
MOVAPS xmmword ptr [RBP + -0x80],XMM2
MOVAPS xmmword ptr [RBP + -0x70],XMM3
MOVAPS xmmword ptr [RBP + -0x60],XMM4
MOVAPS xmmword ptr [RBP + -0x50],XMM5
MOVAPS xmmword ptr [RBP + -0x40],XMM6
MOVAPS xmmword ptr [RBP + -0x30],XMM7
LAB_001d7280:
MOV qword ptr [RBP + -0x10],RDI
LEA RCX,[RBP + 0x10]
MOV qword ptr [RBP + -0x18],RCX
MOV RCX,0x3000000010
MOV qword ptr [RBP + -0x20],RCX
TEST RSI,RSI
JZ 0x001d72ee
MOV RCX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x20]
MOV RDI,qword ptr [RBP + -0x18]
LAB_001d72aa:
MOV R8,RDI
LAB_001d72ad:
MOV R9B,byte ptr [RSI]
MOV byte ptr [RAX],R9B
TEST R9B,R9B
JNZ 0x001d72e6
CMP EDX,0x28
JA 0x001d72ce
MOV R9,R8
MOV R8D,EDX
ADD R8,RCX
ADD EDX,0x8
MOV dword ptr [RBP + -0x20],EDX
JMP 0x001d72d9
LAB_001d72ce:
LEA RDI,[R8 + 0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV R9,RDI
LAB_001d72d9:
MOV RSI,qword ptr [R8]
MOV R8,R9
TEST RSI,RSI
JNZ 0x001d72ad
JMP 0x001d72ee
LAB_001d72e6:
INC RAX
INC RSI
JMP 0x001d72aa
LAB_001d72ee:
MOV byte ptr [RAX],0x0
ADD RSP,0x50
POP RBP
RET
|
void strxmov(char *param_1,char *param_2)
{
char cVar1;
int8 *puVar2;
int8 *puVar3;
ulong uVar4;
int8 *puVar5;
int8 local_d8 [22];
uint local_28;
puVar2 = (int8 *)&stack0x00000008;
if (param_2 != (char *)0x0) {
local_28 = 0x10;
puVar3 = puVar2;
do {
for (; cVar1 = *param_2, *param_1 = cVar1, cVar1 != '\0'; param_2 = param_2 + 1) {
param_1 = param_1 + 1;
puVar3 = puVar2;
}
if (local_28 < 0x29) {
uVar4 = (ulong)local_28;
local_28 = local_28 + 8;
puVar5 = (int8 *)((long)local_d8 + uVar4);
}
else {
puVar2 = puVar3 + 1;
puVar5 = puVar3;
puVar3 = puVar2;
}
param_2 = (char *)*puVar5;
} while (param_2 != (char *)0x0);
}
*param_1 = '\0';
return;
}
| |
24,954 | my_atoll | eloqsql/libmariadb/libmariadb/ma_stmt_codec.c | static long long my_atoll(const char *str, const char *end_str, int *error)
{
const char *p=str;
const char *end;
long long ret;
while (p < end_str && isspace(*p))
p++;
ret = my_strtoll(p, end_str - p, &end, error);
while(end < end_str && isspace(*end))
end++;
if(end != end_str)
*error= 1;
return ret;
} | O0 | c | my_atoll:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0x621cf
callq 0x38120
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x621d8
jmp 0x621e6
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6219c
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
subq %rax, %rsi
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdx
callq 0x62360
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x32(%rbp)
jae 0x62239
callq 0x38120
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
testb $0x1, %al
jne 0x62242
jmp 0x62250
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x62206
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x62264
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| my_atoll:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_6219C:
mov rcx, [rbp+var_20]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_31], al
jnb short loc_621CF
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_20]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
setnz al
mov [rbp+var_31], al
loc_621CF:
mov al, [rbp+var_31]
test al, 1
jnz short loc_621D8
jmp short loc_621E6
loc_621D8:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp short loc_6219C
loc_621E6:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_20]
sub rsi, rax
mov rcx, [rbp+var_18]
lea rdx, [rbp+var_28]
call my_strtoll
mov [rbp+var_30], rax
loc_62206:
mov rcx, [rbp+var_28]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_32], al
jnb short loc_62239
call ___ctype_b_loc
mov rax, [rax]
mov rcx, [rbp+var_28]
movsx ecx, byte ptr [rcx]
movsxd rcx, ecx
movzx eax, word ptr [rax+rcx*2]
and eax, 2000h
cmp eax, 0
setnz al
mov [rbp+var_32], al
loc_62239:
mov al, [rbp+var_32]
test al, 1
jnz short loc_62242
jmp short loc_62250
loc_62242:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_62206
loc_62250:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_10]
jz short loc_62264
mov rax, [rbp+var_18]
mov dword ptr [rax], 1
loc_62264:
mov rax, [rbp+var_30]
add rsp, 40h
pop rbp
retn
| long long my_atoll(char *a1, char *a2, _DWORD *a3)
{
bool v4; // [rsp+Eh] [rbp-32h]
bool v5; // [rsp+Fh] [rbp-31h]
long long v6; // [rsp+10h] [rbp-30h]
char *v7; // [rsp+18h] [rbp-28h] BYREF
char *i; // [rsp+20h] [rbp-20h]
_DWORD *v9; // [rsp+28h] [rbp-18h]
char *v10; // [rsp+30h] [rbp-10h]
char *v11; // [rsp+38h] [rbp-8h]
v11 = a1;
v10 = a2;
v9 = a3;
for ( i = a1; ; ++i )
{
v5 = 0;
if ( i < v10 )
v5 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *i) & 0x2000) != 0;
if ( !v5 )
break;
}
v6 = my_strtoll(i, v10 - i, &v7, v9);
while ( 1 )
{
v4 = 0;
if ( v7 < v10 )
v4 = (*(_WORD *)(*(_QWORD *)__ctype_b_loc() + 2LL * *v7) & 0x2000) != 0;
if ( !v4 )
break;
++v7;
}
if ( v7 != v10 )
*v9 = 1;
return v6;
}
| my_atoll:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_0016219c:
MOV RCX,qword ptr [RBP + -0x20]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x31],AL
JNC 0x001621cf
CALL 0x00138120
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x31],AL
LAB_001621cf:
MOV AL,byte ptr [RBP + -0x31]
TEST AL,0x1
JNZ 0x001621d8
JMP 0x001621e6
LAB_001621d8:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0016219c
LAB_001621e6:
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
SUB RSI,RAX
MOV RCX,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x28]
CALL 0x00162360
MOV qword ptr [RBP + -0x30],RAX
LAB_00162206:
MOV RCX,qword ptr [RBP + -0x28]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x32],AL
JNC 0x00162239
CALL 0x00138120
MOV RAX,qword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x28]
MOVSX ECX,byte ptr [RCX]
MOVSXD RCX,ECX
MOVZX EAX,word ptr [RAX + RCX*0x2]
AND EAX,0x2000
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x32],AL
LAB_00162239:
MOV AL,byte ptr [RBP + -0x32]
TEST AL,0x1
JNZ 0x00162242
JMP 0x00162250
LAB_00162242:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00162206
LAB_00162250:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x10]
JZ 0x00162264
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX],0x1
LAB_00162264:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
int8 my_atoll(char *param_1,char *param_2,int4 *param_3)
{
ushort **ppuVar1;
int8 uVar2;
bool bVar3;
char *local_30;
char *local_28;
int4 *local_20;
char *local_18;
char *local_10;
local_28 = param_1;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar3 = false;
if (local_28 < local_18) {
ppuVar1 = __ctype_b_loc();
bVar3 = ((*ppuVar1)[(int)*local_28] & 0x2000) != 0;
}
if (!bVar3) break;
local_28 = local_28 + 1;
}
uVar2 = my_strtoll(local_28,(long)local_18 - (long)local_28,&local_30,local_20);
while( true ) {
bVar3 = false;
if (local_30 < local_18) {
ppuVar1 = __ctype_b_loc();
bVar3 = ((*ppuVar1)[(int)*local_30] & 0x2000) != 0;
}
if (!bVar3) break;
local_30 = local_30 + 1;
}
if (local_30 != local_18) {
*local_20 = 1;
}
return uVar2;
}
| |
24,955 | mysql_test_handler_read(Prepared_statement*, TABLE_LIST*) | eloqsql/sql/sql_prepare.cc | static int mysql_test_handler_read(Prepared_statement *stmt,
TABLE_LIST *tables)
{
THD *thd= stmt->thd;
LEX *lex= stmt->lex;
SQL_HANDLER *ha_table;
DBUG_ENTER("mysql_test_handler_read");
lex->first_select_lex()->context.resolve_in_select_list= TRUE;
/*
We don't have to test for permissions as this is already done during
HANDLER OPEN
*/
if (!(ha_table= mysql_ha_read_prepare(thd, tables, lex->ha_read_mode,
lex->ident.str,
lex->insert_list,
lex->ha_rkey_mode,
lex->first_select_lex()->where)))
DBUG_RETURN(1);
if (!stmt->is_sql_prepare())
{
if (!lex->result && !(lex->result= new (stmt->mem_root) select_send(thd)))
DBUG_RETURN(1);
if (send_prep_stmt(stmt, ha_table->fields.elements) ||
lex->result->send_result_set_metadata(ha_table->fields, Protocol::SEND_EOF) ||
thd->protocol->flush())
DBUG_RETURN(1);
DBUG_RETURN(2);
}
DBUG_RETURN(0);
} | O0 | cpp | mysql_test_handler_read(Prepared_statement*, TABLE_LIST*):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7fa720
movb $0x1, 0x88(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x28(%rbp), %rax
movl 0x17f0(%rax), %eax
movl %eax, -0x6c(%rbp)
movq -0x28(%rbp), %rax
movq 0xdc8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq 0xf68(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movl 0x17f4(%rax), %eax
movl %eax, -0x58(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7fa720
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movl -0x6c(%rbp), %edx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
movl -0x58(%rbp), %r9d
movq 0xc0(%rax), %rax
movq %rax, (%rsp)
callq 0x8ae810
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x9241fe
jmp 0x9241f2
movl $0x1, -0x4(%rbp)
jmp 0x924344
movq -0x10(%rbp), %rdi
callq 0x925660
testb $0x1, %al
jne 0x92433b
movq -0x28(%rbp), %rax
movq 0xdb0(%rax), %rax
movb $0x0, -0x41(%rbp)
cmpq $0x0, %rax
jne 0x9242d8
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq %rsi, -0x98(%rbp)
movl $0x28, %edi
callq 0x7dbfd0
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x92428f
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rdi, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movb $0x1, -0x41(%rbp)
movq -0x20(%rbp), %rsi
callq 0x90bca0
jmp 0x92427f
movq -0x90(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x92428f
movq -0x88(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rax, 0xdb0(%rcx)
cmpq $0x0, %rax
jne 0x9242d8
jmp 0x9242a9
movl $0x1, -0x4(%rbp)
jmp 0x924344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x9242c9
jmp 0x9242d6
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7dc010
jmp 0x924350
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x924580
testb $0x1, %al
jne 0x924325
movq -0x28(%rbp), %rax
movq 0xdb0(%rax), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq (%rdi), %rax
movl $0x2, %edx
callq *0x38(%rax)
testb $0x1, %al
jne 0x924325
movq -0x20(%rbp), %rax
movq 0x590(%rax), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
testb $0x1, %al
jne 0x924325
jmp 0x924330
jmp 0x924327
movl $0x1, -0x4(%rbp)
jmp 0x924344
jmp 0x924332
movl $0x2, -0x4(%rbp)
jmp 0x924344
jmp 0x92433d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x7589b0
nopl (%rax)
| _ZL23mysql_test_handler_readP18Prepared_statementP10TABLE_LIST:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov rax, [rax+0C0h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]; this
call _ZN3LEX16first_select_lexEv; LEX::first_select_lex(void)
mov byte ptr [rax+88h], 1
mov rax, [rbp+var_20]
mov [rbp+var_80], rax
mov rax, [rbp+var_18]
mov [rbp+var_78], rax
mov rax, [rbp+var_28]
mov eax, [rax+17F0h]
mov [rbp+var_6C], eax
mov rax, [rbp+var_28]
mov rax, [rax+0DC8h]
mov [rbp+var_68], rax
mov rax, [rbp+var_28]
mov rax, [rax+0F68h]
mov [rbp+var_60], rax
mov rax, [rbp+var_28]
mov eax, [rax+17F4h]
mov [rbp+var_58], eax
mov rdi, [rbp+var_28]; this
call _ZN3LEX16first_select_lexEv; LEX::first_select_lex(void)
mov rdi, [rbp+var_80]
mov rsi, [rbp+var_78]
mov edx, [rbp+var_6C]
mov rcx, [rbp+var_68]
mov r8, [rbp+var_60]
mov r9d, [rbp+var_58]
mov rax, [rax+0C0h]
mov [rsp+0A0h+var_A0], rax
call _Z21mysql_ha_read_prepareP3THDP10TABLE_LIST18enum_ha_read_modesPKcP4ListI4ItemE16ha_rkey_functionPS7_; mysql_ha_read_prepare(THD *,TABLE_LIST *,enum_ha_read_modes,char const*,List<Item> *,ha_rkey_function,Item*)
mov [rbp+var_30], rax
cmp rax, 0
jnz short loc_9241FE
jmp short $+2
loc_9241F2:
mov [rbp+var_4], 1
jmp loc_924344
loc_9241FE:
mov rdi, [rbp+var_10]; this
call _ZNK18Prepared_statement14is_sql_prepareEv; Prepared_statement::is_sql_prepare(void)
test al, 1
jnz loc_92433B
mov rax, [rbp+var_28]
mov rax, [rax+0DB0h]
mov [rbp+var_41], 0
cmp rax, 0
jnz loc_9242D8
mov rax, [rbp+var_10]
mov rsi, [rax+28h]
mov [rbp+var_98], rsi
mov edi, 28h ; '('
call _ZN9Sql_allocnwEmP11st_mem_root; Sql_alloc::operator new(ulong,st_mem_root *)
mov rcx, rax
mov [rbp+var_90], rcx
xor eax, eax
cmp rcx, 0
mov [rbp+var_88], rax
jz short loc_92428F
mov rdi, [rbp+var_90]; this
mov rax, [rbp+var_98]
mov [rbp+var_38], rdi
mov [rbp+var_40], rax
mov [rbp+var_41], 1
mov rsi, [rbp+var_20]; THD *
call _ZN11select_sendC2EP3THD; select_send::select_send(THD *)
jmp short $+2
loc_92427F:
mov rax, [rbp+var_90]
mov [rbp+var_88], rax
jmp short $+2
loc_92428F:
mov rax, [rbp+var_88]
mov rcx, [rbp+var_28]
mov [rcx+0DB0h], rax
cmp rax, 0
jnz short loc_9242D8
jmp short $+2
loc_9242A9:
mov [rbp+var_4], 1
jmp loc_924344
mov rcx, rax
mov eax, edx
mov [rbp+var_50], rcx
mov [rbp+var_54], eax
test [rbp+var_41], 1
jnz short loc_9242C9
jmp short loc_9242D6
loc_9242C9:
mov rdi, [rbp+var_38]
mov rsi, [rbp+var_40]
call _ZN9Sql_allocdlEPvP11st_mem_root; Sql_alloc::operator delete(void *,st_mem_root *)
loc_9242D6:
jmp short loc_924350
loc_9242D8:
mov rdi, [rbp+var_10]; Prepared_statement *
mov rax, [rbp+var_30]
mov esi, [rax+18h]; unsigned int
call _ZL14send_prep_stmtP18Prepared_statementj; send_prep_stmt(Prepared_statement *,uint)
test al, 1
jnz short loc_924325
mov rax, [rbp+var_28]
mov rdi, [rax+0DB0h]
mov rsi, [rbp+var_30]
add rsi, 8
mov rax, [rdi]
mov edx, 2
call qword ptr [rax+38h]
test al, 1
jnz short loc_924325
mov rax, [rbp+var_20]
mov rdi, [rax+590h]
mov rax, [rdi]
call qword ptr [rax+60h]
test al, 1
jnz short loc_924325
jmp short loc_924330
loc_924325:
jmp short $+2
loc_924327:
mov [rbp+var_4], 1
jmp short loc_924344
loc_924330:
jmp short $+2
loc_924332:
mov [rbp+var_4], 2
jmp short loc_924344
loc_92433B:
jmp short $+2
loc_92433D:
mov [rbp+var_4], 0
loc_924344:
mov eax, [rbp+var_4]
add rsp, 0A0h
pop rbp
retn
loc_924350:
mov rdi, [rbp+var_50]
call __Unwind_Resume
| long long mysql_test_handler_read(Prepared_statement *a1, TABLE_LIST *a2)
{
long long select_lex; // rax
select_send *v4; // [rsp+10h] [rbp-90h]
select_send *v5; // [rsp+18h] [rbp-88h]
unsigned int v6; // [rsp+34h] [rbp-6Ch]
long long v7; // [rsp+38h] [rbp-68h]
base_list *v8; // [rsp+40h] [rbp-60h]
int v9; // [rsp+48h] [rbp-58h]
long long *prepare; // [rsp+70h] [rbp-30h]
LEX *v11; // [rsp+78h] [rbp-28h]
THD *v12; // [rsp+80h] [rbp-20h]
v12 = (THD *)*((_QWORD *)a1 + 24);
v11 = (LEX *)*((_QWORD *)a1 + 11);
*(_BYTE *)(LEX::first_select_lex(v11) + 136) = 1;
v6 = *((_DWORD *)v11 + 1532);
v7 = *((_QWORD *)v11 + 441);
v8 = (base_list *)*((_QWORD *)v11 + 493);
v9 = *((_DWORD *)v11 + 1533);
select_lex = LEX::first_select_lex(v11);
prepare = mysql_ha_read_prepare(v12, (long long)a2, v6, v7, v8, v9, *(Item **)(select_lex + 192));
if ( prepare )
{
if ( (Prepared_statement::is_sql_prepare(a1) & 1) != 0 )
{
return 0;
}
else
{
if ( *((_QWORD *)v11 + 438) )
goto LABEL_11;
v4 = (select_send *)Sql_alloc::operator new(40LL, *((_QWORD *)a1 + 5));
v5 = 0LL;
if ( v4 )
{
select_send::select_send(v4, v12);
v5 = v4;
}
*((_QWORD *)v11 + 438) = v5;
if ( v5 )
{
LABEL_11:
if ( (send_prep_stmt(a1, *((_DWORD *)prepare + 6)) & 1) != 0
|| ((*(long long ( **)(_QWORD, long long *, long long))(**((_QWORD **)v11 + 438) + 56LL))(
*((_QWORD *)v11 + 438),
prepare + 1,
2LL) & 1) != 0
|| ((*(long long ( **)(_QWORD))(**((_QWORD **)v12 + 178) + 96LL))(*((_QWORD *)v12 + 178)) & 1) != 0 )
{
return 1;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
}
else
{
return 1;
}
}
| get_lex_keeper:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x58]
POP RBP
RET
|
/* sp_cursor::get_lex_keeper() */
int8 __thiscall sp_cursor::get_lex_keeper(sp_cursor *this)
{
return *(int8 *)(this + 0x58);
}
| |
24,956 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool) | monkey531[P]llama/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};
} | O0 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool):
subq $0x148, %rsp # imm = 0x148
movb %dl, %al
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
andb $0x1, %al
movb %al, 0x127(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x40(%rsp)
addq $0x20, %rdi
callq 0xcf8b0
testb $0x1, %al
jne 0xd935e
jmp 0xd937f
leaq 0x1541a2(%rip), %rdi # 0x22d507
movl $0x1c28, %esi # imm = 0x1C28
leaq 0x14d964(%rip), %rdx # 0x226cd5
leaq 0x15510f(%rip), %rcx # 0x22e487
movb $0x0, %al
callq 0x5ef80
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xcf930
movq %rax, 0x110(%rsp)
movq %rdx, 0x118(%rsp)
leaq 0x110(%rsp), %rdi
callq 0xcd920
xorb $-0x1, %al
testb $0x1, %al
jne 0xd93b2
jmp 0xd93e8
movb $0x0, 0x10f(%rsp)
movq $0x0, 0x100(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x10f(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0xd0440
jmp 0xd9851
movq 0x128(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
callq 0xd9880
movb $0x1, %al
testb $0x1, 0x127(%rsp)
movb %al, 0x3f(%rsp)
jne 0xd9450
movq 0x40(%rsp), %rdi
movq %rdi, %rax
subq $-0x80, %rax
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
callq 0xcfa30
movq 0x30(%rsp), %rdi
movl %eax, %esi
movl $0x5, %edx
leaq 0xf0(%rsp), %rcx
callq 0xcf9d0
movb %al, 0x3e(%rsp)
jmp 0xd9446
movb 0x3e(%rsp), %al
movb %al, 0x3f(%rsp)
jmp 0xd9450
movb 0x3f(%rsp), %al
andb $0x1, %al
movb %al, 0xef(%rsp)
testb $0x1, 0xef(%rsp)
jne 0xd94d0
movb $0x0, 0xdb(%rsp)
movq $0x0, 0xd0(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xdb(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0xd0440
jmp 0xd949a
movl $0x1, 0xcc(%rsp)
jmp 0xd9844
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0xc1270
jmp 0xd9868
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0470
testb $0x1, %al
jne 0xd94e4
jmp 0xd9561
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0xd04c0
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0xca450
movq 0x28(%rsp), %rdi
callq 0xc1270
movq 0x40(%rsp), %rax
movb $0x1, 0xb7(%rsp)
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xb7(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0xd0540
jmp 0xd9551
movl $0x1, 0xcc(%rsp)
jmp 0xd9844
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
cmpq $0x0, (%rax)
jne 0xd95b8
movb $0x0, 0xa7(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xa7(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xd0440
jmp 0xd95a8
movl $0x1, 0xcc(%rsp)
jmp 0xd9844
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rdi
callq 0xd0570
testb $0x1, %al
jne 0xd960f
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rdi
callq 0xd0590
testb $0x1, %al
jne 0xd960f
leaq 0x153f14(%rip), %rdi # 0x22d507
leaq 0x14d6db(%rip), %rdx # 0x226cd5
leaq 0x154e9a(%rip), %rcx # 0x22e49b
xorl %eax, %eax
movl $0x1c4b, %esi # imm = 0x1C4B
callq 0x5ef80
jmp 0xd960f
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rdi
callq 0xd0570
testb $0x1, %al
jne 0xd962b
jmp 0xd96a8
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xd05b0
jmp 0xd964f
movq 0x40(%rsp), %rdi
movb $0x1, 0x97(%rsp)
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xd0630
movq %rax, 0x88(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x97(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0xd0540
jmp 0xd9698
movl $0x1, 0xcc(%rsp)
jmp 0xd9844
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xd0020
movq (%rax), %rdi
callq 0xd0590
testb $0x1, %al
jne 0xd96e5
leaq 0x153e3e(%rip), %rdi # 0x22d507
leaq 0x14d605(%rip), %rdx # 0x226cd5
leaq 0x154de4(%rip), %rcx # 0x22e4bb
xorl %eax, %eax
movl $0x1c55, %esi # imm = 0x1C55
callq 0x5ef80
jmp 0xd96e5
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xcf8b0
testb $0x1, %al
jne 0xd96f9
jmp 0xd971c
leaq 0x153e07(%rip), %rdi # 0x22d507
leaq 0x14d5ce(%rip), %rdx # 0x226cd5
leaq 0x154dcb(%rip), %rcx # 0x22e4d9
xorl %eax, %eax
movl $0x1c57, %esi # imm = 0x1C57
callq 0x5ef80
jmp 0xd971c
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xcf930
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0xd9736
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xcd920
movq 0x40(%rsp), %rdi
movb %al, 0x87(%rsp)
addq $0x48, %rdi
callq 0xcf9b0
jmp 0xd976b
testb $0x1, 0x87(%rsp)
jne 0xd97ac
movb $0x0, 0x6f(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x6f(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xd0440
jmp 0xd979c
movl $0x1, 0xcc(%rsp)
jmp 0xd9844
movq 0x40(%rsp), %rax
cmpq $0x0, 0x70(%rax)
jne 0xd97db
leaq 0x153d48(%rip), %rdi # 0x22d507
leaq 0x14d50f(%rip), %rdx # 0x226cd5
leaq 0x154d24(%rip), %rcx # 0x22e4f1
xorl %eax, %eax
movl $0x1c60, %esi # imm = 0x1C60
callq 0x5ef80
jmp 0xd97db
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0xd04c0
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rsi
movq %rax, %rcx
addq $0x70, %rcx
movq %rcx, 0x10(%rsp)
movq 0x70(%rax), %rdi
callq 0xca450
movq 0x8(%rsp), %rdi
callq 0xc1270
movq 0x10(%rsp), %rdx
movb $0x1, 0x4f(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x4f(%rsp), %rsi
callq 0xd0670
jmp 0xd9839
movl $0x1, 0xcc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0xc1270
movb 0x138(%rsp), %al
movq 0x140(%rsp), %rdx
addq $0x148, %rsp # imm = 0x148
retq
movq 0xe0(%rsp), %rdi
callq 0x5ec30
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRdEESt4pairIbPSF_EOT_b:
sub rsp, 148h
mov al, dl
mov [rsp+148h+var_18], rdi
mov [rsp+148h+var_20], rsi
and al, 1
mov [rsp+148h+var_21], al
mov rdi, [rsp+148h+var_18]
mov [rsp+148h+var_108], rdi
add rdi, 20h ; ' '
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
test al, 1
jnz short loc_D935E
jmp short loc_D937F
loc_D935E:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1C28h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov al, 0
call _ggml_abort
loc_D937F:
mov rdi, [rsp+148h+var_108]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rsp+148h+var_38], rax
mov [rsp+148h+var_30], rdx
lea rdi, [rsp+148h+var_38]
call _ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
xor al, 0FFh
test al, 1
jnz short loc_D93B2
jmp short loc_D93E8
loc_D93B2:
mov [rsp+148h+var_39], 0
mov [rsp+148h+var_48], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_39]
lea rdx, [rsp+148h+var_48]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp loc_D9851
loc_D93E8:
mov rsi, [rsp+148h+var_20]
lea rdi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRddTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
mov al, 1
test [rsp+148h+var_21], 1
mov [rsp+148h+var_109], al
jnz short loc_D9450
mov rdi, [rsp+148h+var_108]
mov rax, rdi
sub rax, 0FFFFFFFFFFFFFF80h
mov [rsp+148h+var_118], rax
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4sizeEv; 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::allocator<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> *>>::size(void)
mov rdi, [rsp+148h+var_118]
mov esi, eax
mov edx, 5
lea rcx, [rsp+148h+var_58]
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov [rsp+148h+var_10A], al
jmp short $+2
loc_D9446:
mov al, [rsp+148h+var_10A]
mov [rsp+148h+var_109], al
jmp short $+2
loc_D9450:
mov al, [rsp+148h+var_109]
and al, 1
mov [rsp+148h+var_59], al
test [rsp+148h+var_59], 1
jnz short loc_D94D0
mov [rsp+148h+var_6D], 0
mov [rsp+148h+var_78], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_6D]
lea rdx, [rsp+148h+var_78]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_D949A:
mov [rsp+148h+var_7C], 1
jmp loc_D9844
mov rcx, rax
mov eax, edx
mov [rsp+arg_D8], rcx
mov [rsp+arg_D4], eax
lea rdi, [rsp+arg_E8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_D9868
loc_D94D0:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNKSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE5emptyEv; 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::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::empty(void)
test al, 1
jnz short loc_D94E4
jmp short loc_D9561
loc_D94E4:
lea rdi, [rsp+148h+var_90]
mov [rsp+148h+var_120], rdi
lea rsi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rsi, [rsp+148h+var_120]
mov rax, [rsp+148h+var_108]
mov rdi, [rax]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+148h+var_120]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rax, [rsp+148h+var_108]
mov [rsp+148h+var_91], 1
mov rax, [rax]
mov [rsp+148h+var_A0], rax
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_91]
lea rdx, [rsp+148h+var_A0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_D9551:
mov [rsp+148h+var_7C], 1
jmp loc_D9844
loc_D9561:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
cmp qword ptr [rax], 0
jnz short loc_D95B8
mov [rsp+148h+var_A1], 0
mov [rsp+148h+var_B0], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_A1]
lea rdx, [rsp+148h+var_B0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_D95A8:
mov [rsp+148h+var_7C], 1
jmp loc_D9844
loc_D95B8:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
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)
test al, 1
jnz short loc_D960F
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; 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_object(void)
test al, 1
jnz short loc_D960F
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
xor eax, eax
mov esi, 1C4Bh
call _ggml_abort
jmp short $+2
loc_D960F:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
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)
test al, 1
jnz short loc_D962B
jmp short loc_D96A8
loc_D962B:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
lea rsi, [rsp+148h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
jmp short $+2
loc_D964F:
mov rdi, [rsp+148h+var_108]
mov [rsp+148h+var_B1], 1
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rax, [rax]
mov rdi, [rax+8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4backEv; 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>>::back(void)
mov [rsp+148h+var_C0], rax
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_B1]
lea rdx, [rsp+148h+var_C0]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_D9698:
mov [rsp+148h+var_7C], 1
jmp loc_D9844
loc_D96A8:
mov rdi, [rsp+148h+var_108]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE4backEv; 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::allocator<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> *>>::back(void)
mov rdi, [rax]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; 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_object(void)
test al, 1
jnz short loc_D96E5
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
xor eax, eax
mov esi, 1C55h
call _ggml_abort
jmp short $+2
loc_D96E5:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
test al, 1
jnz short loc_D96F9
jmp short loc_D971C
loc_D96F9:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
xor eax, eax
mov esi, 1C57h
call _ggml_abort
jmp short $+2
loc_D971C:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rsp+148h+var_130], rdx
mov [rsp+148h+var_128], rax
jmp short $+2
loc_D9736:
mov rax, [rsp+148h+var_130]
mov rcx, [rsp+148h+var_128]
mov [rsp+148h+var_D8], rcx
mov [rsp+148h+var_D0], rax
lea rdi, [rsp+148h+var_D8]
call _ZNKSt14_Bit_referencecvbEv; std::_Bit_reference::operator bool(void)
mov rdi, [rsp+148h+var_108]
mov [rsp+148h+var_C1], al
add rdi, 48h ; 'H'
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
jmp short $+2
loc_D976B:
test [rsp+148h+var_C1], 1
jnz short loc_D97AC
mov [rsp+148h+var_D9], 0
mov [rsp+148h+var_E8], 0
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_D9]
lea rdx, [rsp+148h+var_E8]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
jmp short $+2
loc_D979C:
mov [rsp+148h+var_7C], 1
jmp loc_D9844
loc_D97AC:
mov rax, [rsp+148h+var_108]
cmp qword ptr [rax+70h], 0
jnz short loc_D97DB
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
xor eax, eax
mov esi, 1C60h
call _ggml_abort
jmp short $+2
loc_D97DB:
lea rdi, [rsp+148h+var_F8]
mov [rsp+148h+var_140], rdi
lea rsi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rax, [rsp+148h+var_108]
mov rsi, [rsp+148h+var_140]
mov rcx, rax
add rcx, 70h ; 'p'
mov [rsp+148h+var_138], rcx
mov rdi, [rax+70h]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, [rsp+148h+var_140]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdx, [rsp+148h+var_138]
mov [rsp+148h+var_F9], 1
lea rdi, [rsp+148h+var_10]
lea rsi, [rsp+148h+var_F9]
call _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
jmp short $+2
loc_D9839:
mov [rsp+148h+var_7C], 1
loc_D9844:
lea rdi, [rsp+148h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_D9851:
mov al, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_8]
add rsp, 148h
retn
loc_D9868:
mov rdi, [rsp+arg_D8]
call __Unwind_Resume
| char nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double &>(
long long a1,
long long a2,
char a3)
{
long long v3; // rdx
int v4; // eax
_BYTE **v5; // rax
_BYTE **v6; // rax
_BYTE **v7; // rax
long long v8; // rax
long long v9; // rax
_BYTE **v10; // rax
long long v11; // rdx
char v13; // [rsp+3Fh] [rbp-109h]
char v14; // [rsp+4Fh] [rbp-F9h] BYREF
__int128 v15; // [rsp+50h] [rbp-F8h] BYREF
long long v16; // [rsp+60h] [rbp-E8h]
char v17; // [rsp+6Fh] [rbp-D9h] BYREF
_QWORD v18[2]; // [rsp+70h] [rbp-D8h] BYREF
bool v19; // [rsp+87h] [rbp-C1h]
long long v20; // [rsp+88h] [rbp-C0h] BYREF
char v21; // [rsp+97h] [rbp-B1h] BYREF
long long v22; // [rsp+98h] [rbp-B0h]
char v23; // [rsp+A7h] [rbp-A1h] BYREF
long long v24; // [rsp+A8h] [rbp-A0h] BYREF
char v25; // [rsp+B7h] [rbp-91h] BYREF
__int128 v26; // [rsp+B8h] [rbp-90h] BYREF
int v27; // [rsp+CCh] [rbp-7Ch]
long long v28; // [rsp+D0h] [rbp-78h]
_BYTE v29[21]; // [rsp+DBh] [rbp-6Dh] BYREF
_BYTE v30[16]; // [rsp+F0h] [rbp-58h] BYREF
long long v31; // [rsp+100h] [rbp-48h]
char v32; // [rsp+10Fh] [rbp-39h] BYREF
_QWORD v33[2]; // [rsp+110h] [rbp-38h] BYREF
char v34; // [rsp+127h] [rbp-21h]
long long v35; // [rsp+128h] [rbp-20h]
long long v36; // [rsp+130h] [rbp-18h]
_BYTE v37[8]; // [rsp+138h] [rbp-10h] BYREF
v36 = a1;
v35 = a2;
v34 = a3 & 1;
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 32)) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
v33[0] = std::vector<bool>::back(a1 + 32);
v33[1] = v3;
if ( std::_Bit_reference::operator bool((long long)v33) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRddTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
v30,
v35);
v13 = 1;
if ( (v34 & 1) == 0 )
{
v4 = 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::allocator<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> *>>::size((_QWORD *)(a1 + 8));
v13 = std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
(std::_Function_base *)(a1 + 128),
v4,
5,
(long long)v30);
}
v29[20] = v13 & 1;
if ( (v13 & 1) != 0 )
{
if ( (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::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::empty(a1 + 8) & 1) != 0 )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
&v26,
(long long)v30);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)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>::~basic_json((long long)&v26);
v25 = 1;
v24 = *(_QWORD *)a1;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
&v25,
&v24);
v27 = 1;
}
else if ( *(_QWORD *)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::allocator<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> *>>::back(a1 + 8) )
{
v5 = (_BYTE **)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::allocator<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> *>>::back(a1 + 8);
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(*v5) )
{
v6 = (_BYTE **)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::allocator<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> *>>::back(a1 + 8);
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_object(*v6) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7243LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_array() || ref_stack.back()->is_object()");
}
v7 = (_BYTE **)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::allocator<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> *>>::back(a1 + 8);
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(*v7) )
{
v8 = 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::allocator<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> *>>::back(a1 + 8);
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(*(_QWORD *)v8 + 8LL),
(long long)v30);
v21 = 1;
v9 = 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::allocator<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> *>>::back(a1 + 8);
v20 = 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>>::back(*(_QWORD *)(*(_QWORD *)v9 + 8LL));
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
&v21,
&v20);
v27 = 1;
}
else
{
v10 = (_BYTE **)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::allocator<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> *>>::back(a1 + 8);
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_object(*v10) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7253LL,
"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_object()");
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 72)) & 1) != 0 )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7255LL,
"GGML_ASSERT(%s) failed",
"!key_keep_stack.empty()");
v18[0] = std::vector<bool>::back(a1 + 72);
v18[1] = v11;
v19 = std::_Bit_reference::operator bool((long long)v18);
std::vector<bool>::pop_back(a1 + 72);
if ( v19 )
{
if ( !*(_QWORD *)(a1 + 112) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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(
&v15,
(long long)v30);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&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>::~basic_json((long long)&v15);
v14 = 1;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_(
(long long)v37,
&v14,
(_QWORD *)(a1 + 112));
v27 = 1;
}
else
{
v17 = 0;
v16 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
&v17);
v27 = 1;
}
}
}
else
{
v23 = 0;
v22 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
&v23);
v27 = 1;
}
}
else
{
v29[0] = 0;
v28 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
v29);
v27 = 1;
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v30);
}
else
{
v32 = 0;
v31 = 0LL;
ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
(long long)v37,
&v32);
}
return v37[0];
}
| handle_value<double&>:
SUB RSP,0x148
MOV AL,DL
MOV qword ptr [RSP + 0x130],RDI
MOV qword ptr [RSP + 0x128],RSI
AND AL,0x1
MOV byte ptr [RSP + 0x127],AL
MOV RDI,qword ptr [RSP + 0x130]
MOV qword ptr [RSP + 0x40],RDI
ADD RDI,0x20
CALL 0x001cf8b0
TEST AL,0x1
JNZ 0x001d935e
JMP 0x001d937f
LAB_001d935e:
LEA RDI,[0x32d507]
MOV ESI,0x1c28
LEA RDX,[0x326cd5]
LEA RCX,[0x32e487]
MOV AL,0x0
CALL 0x0015ef80
LAB_001d937f:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001cf930
MOV qword ptr [RSP + 0x110],RAX
MOV qword ptr [RSP + 0x118],RDX
LEA RDI,[RSP + 0x110]
CALL 0x001cd920
XOR AL,0xff
TEST AL,0x1
JNZ 0x001d93b2
JMP 0x001d93e8
LAB_001d93b2:
MOV byte ptr [RSP + 0x10f],0x0
MOV qword ptr [RSP + 0x100],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x10f]
LEA RDX,[RSP + 0x100]
CALL 0x001d0440
JMP 0x001d9851
LAB_001d93e8:
MOV RSI,qword ptr [RSP + 0x128]
LEA RDI,[RSP + 0xf0]
CALL 0x001d9880
MOV AL,0x1
TEST byte ptr [RSP + 0x127],0x1
MOV byte ptr [RSP + 0x3f],AL
JNZ 0x001d9450
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,RDI
SUB RAX,-0x80
MOV qword ptr [RSP + 0x30],RAX
ADD RDI,0x8
CALL 0x001cfa30
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,EAX
LAB_001d942e:
MOV EDX,0x5
LEA RCX,[RSP + 0xf0]
CALL 0x001cf9d0
MOV byte ptr [RSP + 0x3e],AL
JMP 0x001d9446
LAB_001d9446:
MOV AL,byte ptr [RSP + 0x3e]
MOV byte ptr [RSP + 0x3f],AL
JMP 0x001d9450
LAB_001d9450:
MOV AL,byte ptr [RSP + 0x3f]
AND AL,0x1
MOV byte ptr [RSP + 0xef],AL
TEST byte ptr [RSP + 0xef],0x1
JNZ 0x001d94d0
MOV byte ptr [RSP + 0xdb],0x0
MOV qword ptr [RSP + 0xd0],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xdb]
LEA RDX,[RSP + 0xd0]
CALL 0x001d0440
JMP 0x001d949a
LAB_001d949a:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001d9844
LAB_001d94d0:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0470
TEST AL,0x1
JNZ 0x001d94e4
JMP 0x001d9561
LAB_001d94e4:
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x001d04c0
MOV RSI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RAX]
CALL 0x001ca450
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x001c1270
MOV RAX,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0xb7],0x1
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xa8],RAX
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xb7]
LEA RDX,[RSP + 0xa8]
CALL 0x001d0540
JMP 0x001d9551
LAB_001d9551:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001d9844
LAB_001d9561:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
CMP qword ptr [RAX],0x0
JNZ 0x001d95b8
MOV byte ptr [RSP + 0xa7],0x0
MOV qword ptr [RSP + 0x98],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0xa7]
LEA RDX,[RSP + 0x98]
CALL 0x001d0440
JMP 0x001d95a8
LAB_001d95a8:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001d9844
LAB_001d95b8:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
MOV RDI,qword ptr [RAX]
CALL 0x001d0570
TEST AL,0x1
JNZ 0x001d960f
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
MOV RDI,qword ptr [RAX]
CALL 0x001d0590
TEST AL,0x1
JNZ 0x001d960f
LEA RDI,[0x32d507]
LEA RDX,[0x326cd5]
LEA RCX,[0x32e49b]
XOR EAX,EAX
MOV ESI,0x1c4b
CALL 0x0015ef80
JMP 0x001d960f
LAB_001d960f:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
MOV RDI,qword ptr [RAX]
CALL 0x001d0570
TEST AL,0x1
JNZ 0x001d962b
JMP 0x001d96a8
LAB_001d962b:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xf0]
CALL 0x001d05b0
JMP 0x001d964f
LAB_001d964f:
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x97],0x1
ADD RDI,0x8
CALL 0x001d0020
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001d0630
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x97]
LEA RDX,[RSP + 0x88]
CALL 0x001d0540
JMP 0x001d9698
LAB_001d9698:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001d9844
LAB_001d96a8:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001d0020
MOV RDI,qword ptr [RAX]
CALL 0x001d0590
TEST AL,0x1
JNZ 0x001d96e5
LEA RDI,[0x32d507]
LEA RDX,[0x326cd5]
LEA RCX,[0x32e4bb]
XOR EAX,EAX
MOV ESI,0x1c55
CALL 0x0015ef80
JMP 0x001d96e5
LAB_001d96e5:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001cf8b0
TEST AL,0x1
JNZ 0x001d96f9
JMP 0x001d971c
LAB_001d96f9:
LEA RDI,[0x32d507]
LEA RDX,[0x326cd5]
LEA RCX,[0x32e4d9]
XOR EAX,EAX
MOV ESI,0x1c57
CALL 0x0015ef80
JMP 0x001d971c
LAB_001d971c:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001cf930
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001d9736
LAB_001d9736:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x70]
CALL 0x001cd920
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x87],AL
ADD RDI,0x48
CALL 0x001cf9b0
JMP 0x001d976b
LAB_001d976b:
TEST byte ptr [RSP + 0x87],0x1
JNZ 0x001d97ac
MOV byte ptr [RSP + 0x6f],0x0
MOV qword ptr [RSP + 0x60],0x0
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x6f]
LEA RDX,[RSP + 0x60]
CALL 0x001d0440
JMP 0x001d979c
LAB_001d979c:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001d9844
LAB_001d97ac:
MOV RAX,qword ptr [RSP + 0x40]
CMP qword ptr [RAX + 0x70],0x0
JNZ 0x001d97db
LEA RDI,[0x32d507]
LEA RDX,[0x326cd5]
LEA RCX,[0x32e4f1]
XOR EAX,EAX
MOV ESI,0x1c60
CALL 0x0015ef80
JMP 0x001d97db
LAB_001d97db:
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP + 0x8],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x001d04c0
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x8]
MOV RCX,RAX
ADD RCX,0x70
MOV qword ptr [RSP + 0x10],RCX
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x001ca450
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001c1270
MOV RDX,qword ptr [RSP + 0x10]
MOV byte ptr [RSP + 0x4f],0x1
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x4f]
CALL 0x001d0670
LAB_001d9837:
JMP 0x001d9839
LAB_001d9839:
MOV dword ptr [RSP + 0xcc],0x1
LAB_001d9844:
LEA RDI,[RSP + 0xf0]
CALL 0x001c1270
LAB_001d9851:
MOV AL,byte ptr [RSP + 0x138]
MOV RDX,qword ptr [RSP + 0x140]
ADD RSP,0x148
RET
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<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> >::handle_value<double&>(double&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::handle_value<double&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,double *param_1,bool param_2)
{
bool bVar1;
int4 uVar2;
ulong uVar3;
long *plVar4;
int8 *puVar5;
int8 uVar6;
int1 auVar7 [16];
byte local_109;
int1 local_f9;
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_f8 [16];
int8 local_e8;
int1 local_d9;
int1 local_d8 [16];
byte local_c1;
int8 local_c0;
int1 local_b1;
int8 local_b0;
int1 local_a1;
int8 local_a0;
int1 local_91;
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_90 [20];
int4 local_7c;
int8 local_78;
int1 local_6d [20];
byte local_59;
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_58 [16];
int8 local_48;
int1 local_39;
_Bit_reference local_38 [23];
byte local_21;
double *local_20;
json_sax_dom_callback_parser<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>>
*local_18;
int1 local_10 [8];
int8 local_8;
local_21 = param_2;
local_20 = param_1;
local_18 = this;
uVar3 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((uVar3 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
local_38._0_16_ =
std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
bVar1 = std::_Bit_reference::operator_cast_to_bool(local_38);
if (((bVar1 ^ 0xffU) & 1) == 0) {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRddTnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58,local_20);
local_109 = 1;
if ((local_21 & 1) == 0) {
uVar2 = 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>*>>
::size((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
/* try { // try from 001d942e to 001d9836 has its CatchHandler @ 001d94aa */
local_109 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()((function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
*)(this + 0x80),uVar2,5,local_58);
}
local_59 = local_109 & 1;
if (local_59 == 0) {
local_6d[0] = 0;
local_78 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,local_6d,&local_78);
}
else {
uVar3 = 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>*>>
::empty((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if ((uVar3 & 1) == 0) {
plVar4 = (long *)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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
if (*plVar4 == 0) {
local_a1 = 0;
local_b0 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_a1,&local_b0);
}
else {
puVar5 = (int8 *)
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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar3 = 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>
::is_array((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>
*)*puVar5);
if ((uVar3 & 1) == 0) {
puVar5 = (int8 *)
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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar3 = 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>
::is_object((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>
*)*puVar5);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp"
,0x1c4b,"GGML_ASSERT(%s) failed",
"ref_stack.back()->is_array() || ref_stack.back()->is_object()");
}
}
puVar5 = (int8 *)
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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar3 = 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>
::is_array((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>
*)*puVar5);
if ((uVar3 & 1) == 0) {
puVar5 = (int8 *)
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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
uVar3 = 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>
::is_object((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>
*)*puVar5);
if ((uVar3 & 1) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp"
,0x1c55,"GGML_ASSERT(%s) failed","ref_stack.back()->is_object()");
}
uVar3 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if ((uVar3 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp"
,0x1c57,"GGML_ASSERT(%s) failed","!key_keep_stack.empty()");
}
local_d8 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
local_c1 = std::_Bit_reference::operator_cast_to_bool((_Bit_reference *)local_d8);
std::vector<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if ((local_c1 & 1) == 0) {
local_d9 = 0;
local_e8 = 0;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_d9,&local_e8);
}
else {
if (*(long *)(this + 0x70) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp"
,0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
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(local_f8,local_58);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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 + 0x70),local_f8);
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(local_f8);
local_f9 = 1;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbRSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISK_SL_EEEbE4typeELb1EEEOSK_OSL_
(local_10,&local_f9,this + 0x70);
}
}
else {
plVar4 = (long *)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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(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>>>
**)(*plVar4 + 8),local_58);
local_b1 = 1;
plVar4 = (long *)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>*>>
::back((vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*>>
*)(this + 8));
local_c0 = 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>>>
::back(*(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>>>
**)(*plVar4 + 8));
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_b1,&local_c0);
}
}
}
else {
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(local_90,local_58);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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,local_90);
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(local_90);
local_91 = 1;
local_a0 = *(int8 *)this;
_ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbSF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_91,&local_a0);
}
}
local_7c = 1;
uVar6 = 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(local_58);
}
else {
local_39 = 0;
local_48 = 0;
uVar6 = _ZNSt4pairIbPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEEC2IbDnTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
(local_10,&local_39,&local_48);
}
auVar7._1_7_ = (int7)((ulong)uVar6 >> 8);
auVar7[0] = local_10[0];
auVar7._8_8_ = local_8;
return auVar7;
}
| |
24,957 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool) | monkey531[P]llama/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};
} | O1 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, 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 0x6d1e7
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 0x6d07a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movsd (%rsi), %xmm0
movq %r14, %rdi
callq 0x6d282
movq %r14, %rdi
movl $0x1, %esi
callq 0x65cc4
testb %bpl, %bpl
jne 0x6d027
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x6d208
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x6d1bb
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6d084
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x6d1bb
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x6d0de
cmpl $0x2, %ecx
jne 0x6d20d
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6aaf6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x6d1b7
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x6d1d7
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x65cc4
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x65cc4
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x68660
movq %r15, %rdi
xorl %esi, %esi
callq 0x65cc4
movq %r15, %rdi
callq 0x6b4b0
movq (%rbx), %r14
jmp 0x6d1b7
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 0x6d21b
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 0x6d150
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x6d1bb
cmpq $0x0, 0x70(%rbx)
je 0x6d23c
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x65cc4
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x65cc4
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x68660
movq %r15, %rdi
xorl %esi, %esi
callq 0x65cc4
movq %r15, %rdi
callq 0x6b4b0
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x6d1c0
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x65cc4
movq %r15, %rdi
callq 0x6b4b0
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8edb6(%rip), %rdi # 0xfbfa4
leaq 0x8894b(%rip), %rdx # 0xf5b40
leaq 0x8fd0d(%rip), %rcx # 0xfcf09
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x1bf10
callq 0x1b320
leaq 0x8fd09(%rip), %rcx # 0xfcf1d
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x6d227
leaq 0x8fd39(%rip), %rcx # 0xfcf5b
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8ed76(%rip), %rdi # 0xfbfa4
leaq 0x8890b(%rip), %rdx # 0xf5b40
xorl %eax, %eax
callq 0x1bf10
leaq 0x8ed61(%rip), %rdi # 0xfbfa4
leaq 0x888f6(%rip), %rdx # 0xf5b40
leaq 0x8fd22(%rip), %rcx # 0xfcf73
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x1bf10
jmp 0x6d25f
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x65cc4
movq %r14, %rdi
callq 0x6b4b0
movq %rbx, %rdi
callq 0x1c020
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRdEESt4pairIbPSF_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_6D1E7
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_6D07A
xorps xmm0, xmm0
lea r14, [rsp+68h+var_58]
movaps xmmword ptr [r14], xmm0
movsd xmm0, qword ptr [rsi]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail20external_constructorILNS1_7value_tE7EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_14number_float_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,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>::number_float_t)
mov rdi, r14
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)
test bpl, bpl
jnz short loc_6D027
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_6D208
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_6D1BB
loc_6D027:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_6D084
mov rax, [rax-8]
test rax, rax
jz loc_6D1BB
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_6D0DE
cmp ecx, 2
jnz loc_6D20D
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_6D1B7
loc_6D07A:
xor ebx, ebx
xor r14d, r14d
jmp loc_6D1D7
loc_6D084:
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_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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
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, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_6D1B7
loc_6D0DE:
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_6D21B
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_6D150
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_6D150:
test rdx, rdx
jz short loc_6D1BB
cmp qword ptr [rbx+70h], 0
jz loc_6D23C
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_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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
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, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_6D1B7:
mov bl, 1
jmp short loc_6D1C0
loc_6D1BB:
xor ebx, ebx
xor r14d, r14d
loc_6D1C0:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_6D1D7:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6D1E7:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_6D208:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_6D20D:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_6D227
loc_6D21B:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_6D227:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_6D23C:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
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_6D25F:
mov rbx, rax
lea r14, [rsp+68h+var_58]
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, 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<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>>::handle_value<double &>(
long long a1,
double *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/github/2025_star3/monkey531[P]llama/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)7>::construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
&v25,
*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 *)&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<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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
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 *)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>::operator=(
*(_QWORD *)a1,
(long long)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>::assert_invariant((char *)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);
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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&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);
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/github/2025_star3/monkey531[P]llama/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<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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
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 *)&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>::operator=(
*(_QWORD *)(a1 + 112),
(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((char *)&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>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&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);
_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<double&>:
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 0x0016d1e7
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 0x0016d07a
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOVSD XMM0,qword ptr [RSI]
MOV RDI,R14
CALL 0x0016d282
MOV RDI,R14
MOV ESI,0x1
CALL 0x00165cc4
TEST BPL,BPL
JNZ 0x0016d027
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 0x0016d208
LEA RDI,[RBX + 0x80]
LAB_0016d00a:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0016d1bb
LAB_0016d027:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0016d084
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0016d1bb
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0016d0de
CMP ECX,0x2
JNZ 0x0016d20d
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0016aaf6
LAB_0016d061:
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 0x0016d1b7
LAB_0016d07a:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0016d1d7
LAB_0016d084:
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 0x00165cc4
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00165cc4
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00168660
MOV RDI,R15
XOR ESI,ESI
CALL 0x00165cc4
MOV RDI,R15
CALL 0x0016b4b0
MOV R14,qword ptr [RBX]
JMP 0x0016d1b7
LAB_0016d0de:
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 0x0016d21b
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 0x0016d150
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0016d150:
TEST RDX,RDX
JZ 0x0016d1bb
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0016d23c
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 0x00165cc4
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00165cc4
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00168660
MOV RDI,R15
XOR ESI,ESI
CALL 0x00165cc4
MOV RDI,R15
CALL 0x0016b4b0
MOV R14,qword ptr [RBX + 0x70]
LAB_0016d1b7:
MOV BL,0x1
JMP 0x0016d1c0
LAB_0016d1bb:
XOR EBX,EBX
XOR R14D,R14D
LAB_0016d1c0:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00165cc4
MOV RDI,R15
CALL 0x0016b4b0
LAB_0016d1d7:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016d1e7:
LEA RDI,[0x1fbfa4]
LEA RDX,[0x1f5b40]
LEA RCX,[0x1fcf09]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x0011bf10
LAB_0016d208:
CALL 0x0011b320
LAB_0016d20d:
LEA RCX,[0x1fcf1d]
MOV ESI,0x1c4b
JMP 0x0016d227
LAB_0016d21b:
LEA RCX,[0x1fcf5b]
MOV ESI,0x1c57
LAB_0016d227:
LEA RDI,[0x1fbfa4]
LEA RDX,[0x1f5b40]
XOR EAX,EAX
CALL 0x0011bf10
LAB_0016d23c:
LEA RDI,[0x1fbfa4]
LEA RDX,[0x1f5b40]
LEA RCX,[0x1fcf73]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x0011bf10
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<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> >::handle_value<double&>(double&, bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::handle_value<double&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,double *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/github/2025_star3/monkey531[P]llama/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_0016d1d7;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)7>::
construct<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(SUB84(*param_1,0),&local_58);
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_58,0));
if (param_2) {
LAB_0016d027:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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,(data *)&local_38);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0016d1bb;
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_0016d227;
}
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_0016d1bb;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0016d23c to 0016d25c has its CatchHandler @ 0016d25d */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
local_48 = local_58;
uStack_40 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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 + 0x70),(data *)&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>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0016d227:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(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>>>
**)(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 0016d208 to 0016d23b has its CatchHandler @ 0016d25f */
std::__throw_bad_function_call();
}
/* try { // try from 0016d00a to 0016d060 has its CatchHandler @ 0016d25f */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_0016d027;
LAB_0016d1bb:
uVar5 = 0;
lVar8 = 0;
}
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((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0016d1d7:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
24,958 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool) | monkey531[P]llama/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};
} | O2 | cpp | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x4d4fa
cmpl $0x0, 0x38(%rbx)
je 0x4d653
leaq 0x20(%rbx), %rdi
callq 0x4d482
testq %rdx, (%rax)
je 0x4d596
movzbl (%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0x4bb78
testb %bpl, %bpl
jne 0x4d547
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x5
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x4d4b0
testb %al, %al
je 0x4d634
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4d5a0
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x4d634
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4d5ca
cmpl $0x2, %ecx
jne 0x4d674
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4d8e6
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x4d630
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4d643
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4d8b2
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4bb8e
movq %r14, %rdi
callq 0x49008
movq (%rbx), %r14
jmp 0x4d630
movq 0x48(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x4d5de
cmpl $0x0, 0x60(%rbx)
je 0x4d682
leaq 0x48(%rbx), %rdi
callq 0x4d482
movq %rdx, %r14
leaq 0x58(%rbx), %rdi
movq (%rax), %r15
callq 0x4cae8
testq %r14, %r15
je 0x4d634
cmpq $0x0, 0x70(%rbx)
je 0x4d6a3
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4d8b2
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x4bb8e
movq %r14, %rdi
callq 0x49008
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x4d639
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x49008
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6e8fd(%rip), %rdi # 0xbbf57
leaq 0x6848f(%rip), %rdx # 0xb5af0
leaq 0x6f863(%rip), %rcx # 0xbcecb
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x24f20
leaq 0x6f864(%rip), %rcx # 0xbcedf
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x4d68e
leaq 0x6f894(%rip), %rcx # 0xbcf1d
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x6e8c2(%rip), %rdi # 0xbbf57
leaq 0x68454(%rip), %rdx # 0xb5af0
xorl %eax, %eax
callq 0x24f20
leaq 0x6e8ad(%rip), %rdi # 0xbbf57
leaq 0x6843f(%rip), %rdx # 0xb5af0
leaq 0x6f87d(%rip), %rcx # 0xbcf35
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x24f20
jmp 0x4d6c8
jmp 0x4d6c8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x49008
movq %rbx, %rdi
callq 0x25010
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueINS1_7value_tEEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rax, [rdi+20h]
cmp rax, [rdi+30h]
jnz short loc_4D4FA
cmp dword ptr [rbx+38h], 0
jz loc_4D653
loc_4D4FA:
lea rdi, [rbx+20h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
test [rax], rdx
jz loc_4D596
movzx esi, byte ptr [r14]
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::detail::value_t)
test bpl, bpl
jnz short loc_4D547
lea rdi, [rbx+80h]
mov rsi, [rbx+10h]
sub rsi, [rbx+8]
shr rsi, 3
push 5
pop rdx
lea rcx, [rsp+58h+var_50]
call _ZNKSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEclEiS3_SH_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::operator()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,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> &)
test al, al
jz loc_4D634
loc_4D547:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_4D5A0
mov rax, [rax-8]
test rax, rax
jz loc_4D634
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz short loc_4D5CA
cmp ecx, 2
jnz loc_4D674
mov rdi, [rax+8]
lea rsi, [rsp+58h+var_50]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_4D630
loc_4D596:
xor ebx, ebx
xor r14d, r14d
jmp loc_4D643
loc_4D5A0:
lea r14, [rsp+58h+var_30]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx]
jmp short loc_4D630
loc_4D5CA:
mov rax, [rbx+48h]
cmp rax, [rbx+58h]
jnz short loc_4D5DE
cmp dword ptr [rbx+60h], 0
jz loc_4D682
loc_4D5DE:
lea rdi, [rbx+48h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov r14, rdx
lea rdi, [rbx+58h]; this
mov r15, [rax]
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
test r15, r14
jz short loc_4D634
cmp qword ptr [rbx+70h], 0
jz loc_4D6A3
lea r14, [rsp+58h+var_40]
lea rsi, [rsp+58h+var_50]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rdi, [rbx+70h]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov r14, [rbx+70h]
loc_4D630:
mov bl, 1
jmp short loc_4D639
loc_4D634:
xor ebx, ebx
xor r14d, r14d
loc_4D639:
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_4D643:
mov eax, ebx
mov rdx, r14
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4D653:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_4D674:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_4D68E
loc_4D682:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_4D68E:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_4D6A3:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aObjectElement; "object_element"
mov esi, 1C60h
xor eax, eax
call _ggml_abort
jmp short loc_4D6C8
jmp short $+2
loc_4D6C8:
mov rbx, rax
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
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<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>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(
long long a1,
char *a2,
char a3)
{
unsigned int v4; // ebx
_QWORD *v5; // rax
long long v6; // rdx
long long v7; // rax
unsigned __int8 *v8; // rax
int v9; // ecx
long long *v10; // rax
long long v11; // rdx
long long v12; // r14
long long v13; // r15
const char *v15; // rcx
long long v16; // rsi
long long v17; // rbx
char v18[16]; // [rsp+8h] [rbp-50h] BYREF
_BYTE v19[16]; // [rsp+18h] [rbp-40h] BYREF
_BYTE v20[48]; // [rsp+28h] [rbp-30h] BYREF
v4 = a1;
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7208LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
LABEL_23:
v15 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
v16 = 7243LL;
LABEL_25:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
"GGML_ASSERT(%s) failed",
v15);
goto LABEL_26;
}
v5 = (_QWORD *)std::vector<bool>::back(a1 + 32);
if ( (v6 & *v5) != 0 )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v18,
*a2);
if ( a3
|| (unsigned __int8)std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::operator()(
a1 + 128,
(*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3,
5) )
{
v7 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v7 )
{
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(
v20,
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>::operator=(
*(_QWORD *)a1,
(long long)v20);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v20);
goto LABEL_18;
}
v8 = *(unsigned __int8 **)(v7 - 8);
if ( v8 )
{
v9 = *v8;
if ( v9 != 1 )
{
if ( v9 == 2 )
{
std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v8 + 1),
v18);
LABEL_18:
LOBYTE(v4) = 1;
LABEL_20:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v18);
return v4;
}
goto LABEL_23;
}
if ( *(_QWORD *)(a1 + 72) == *(_QWORD *)(a1 + 88) && !*(_DWORD *)(a1 + 96) )
{
v15 = "!key_keep_stack.empty()";
v16 = 7255LL;
goto LABEL_25;
}
v10 = (long long *)std::vector<bool>::back(a1 + 72);
v12 = v11;
v13 = *v10;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 88));
if ( (v12 & v13) != 0 )
{
if ( *(_QWORD *)(a1 + 112) )
{
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(
v19,
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>::operator=(
*(_QWORD *)(a1 + 112),
(long long)v19);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v19);
goto LABEL_18;
}
LABEL_26:
v17 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v18);
_Unwind_Resume(v17);
}
}
}
v4 = 0;
goto LABEL_20;
}
return 0;
}
| handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x20]
CMP RAX,qword ptr [RDI + 0x30]
JNZ 0x0014d4fa
CMP dword ptr [RBX + 0x38],0x0
JZ 0x0014d653
LAB_0014d4fa:
LEA RDI,[RBX + 0x20]
CALL 0x0014d482
TEST qword ptr [RAX],RDX
JZ 0x0014d596
MOVZX ESI,byte ptr [R14]
LEA RDI,[RSP + 0x8]
CALL 0x0014bb78
TEST BPL,BPL
JNZ 0x0014d547
LEA RDI,[RBX + 0x80]
MOV RSI,qword ptr [RBX + 0x10]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
LAB_0014d532:
PUSH 0x5
POP RDX
LEA RCX,[RSP + 0x8]
CALL 0x0014d4b0
TEST AL,AL
JZ 0x0014d634
LAB_0014d547:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0014d5a0
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0014d634
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0014d5ca
CMP ECX,0x2
JNZ 0x0014d674
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x8]
CALL 0x0014d8e6
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 0x0014d630
LAB_0014d596:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0014d643
LAB_0014d5a0:
LEA R14,[RSP + 0x28]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x0014d8b2
MOV RDI,qword ptr [RBX]
MOV RSI,R14
CALL 0x0014bb8e
MOV RDI,R14
CALL 0x00149008
MOV R14,qword ptr [RBX]
JMP 0x0014d630
LAB_0014d5ca:
MOV RAX,qword ptr [RBX + 0x48]
CMP RAX,qword ptr [RBX + 0x58]
JNZ 0x0014d5de
CMP dword ptr [RBX + 0x60],0x0
JZ 0x0014d682
LAB_0014d5de:
LEA RDI,[RBX + 0x48]
CALL 0x0014d482
LAB_0014d5e7:
MOV R14,RDX
LEA RDI,[RBX + 0x58]
MOV R15,qword ptr [RAX]
CALL 0x0014cae8
TEST R15,R14
JZ 0x0014d634
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0014d6a3
LEA R14,[RSP + 0x18]
LEA RSI,[RSP + 0x8]
MOV RDI,R14
CALL 0x0014d8b2
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R14
CALL 0x0014bb8e
MOV RDI,R14
CALL 0x00149008
MOV R14,qword ptr [RBX + 0x70]
LAB_0014d630:
MOV BL,0x1
JMP 0x0014d639
LAB_0014d634:
XOR EBX,EBX
XOR R14D,R14D
LAB_0014d639:
LEA RDI,[RSP + 0x8]
CALL 0x00149008
LAB_0014d643:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014d653:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1bcecb]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x00124f20
LAB_0014d674:
LEA RCX,[0x1bcedf]
MOV ESI,0x1c4b
JMP 0x0014d68e
LAB_0014d682:
LEA RCX,[0x1bcf1d]
MOV ESI,0x1c57
LAB_0014d68e:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
XOR EAX,EAX
CALL 0x00124f20
LAB_0014d6a3:
LEA RDI,[0x1bbf57]
LEA RDX,[0x1b5af0]
LEA RCX,[0x1bcf35]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x00124f20
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<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>
>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t&&,
bool) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::detail::
json_sax_dom_callback_parser<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>>
::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,value_t *param_1,bool param_2)
{
char cVar1;
char *pcVar2;
ulong uVar3;
int8 uVar4;
long lVar5;
int1 auVar6 [16];
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_50 [16];
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 [16];
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_30 [16];
if ((*(long *)(this + 0x20) == *(long *)(this + 0x30)) && (*(int *)(this + 0x38) == 0)) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1c28,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
auVar6 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((*auVar6._0_8_ & auVar6._8_8_) == 0) {
uVar3 = 0;
lVar5 = 0;
goto LAB_0014d643;
}
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(local_50,*param_1);
if (param_2) {
LAB_0014d547:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
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(local_30,local_50);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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,local_30);
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(local_30);
lVar5 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_0014d634;
if (*pcVar2 == '\x01') {
if ((*(long *)(this + 0x48) == *(long *)(this + 0x58)) && (*(int *)(this + 0x60) == 0)) {
pcVar2 = "!key_keep_stack.empty()";
uVar4 = 0x1c57;
goto LAB_0014d68e;
}
/* try { // try from 0014d5de to 0014d5e6 has its CatchHandler @ 0014d6c6 */
auVar6 = std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x48));
uVar3 = *auVar6._0_8_;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x58));
if ((uVar3 & auVar6._8_8_) == 0) goto LAB_0014d634;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0014d6a3 to 0014d6c3 has its CatchHandler @ 0014d6c4 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
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(local_40,local_50);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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 + 0x70),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>
::~basic_json(local_40);
lVar5 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
pcVar2 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar4 = 0x1c4b;
LAB_0014d68e:
/* try { // try from 0014d68e to 0014d6a2 has its CatchHandler @ 0014d6c8 */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar4,"GGML_ASSERT(%s) failed",pcVar2);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(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>>>
**)(pcVar2 + 8),local_50);
lVar5 = *(long *)(*(long *)(*(long *)(*(long *)(this + 0x10) + -8) + 8) + 8) + -0x10;
}
}
uVar3 = CONCAT71((int7)((ulong)this >> 8),1);
}
else {
/* try { // try from 0014d532 to 0014d57c has its CatchHandler @ 0014d6c8 */
cVar1 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,(ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3,5,
local_50);
if (cVar1 != '\0') goto LAB_0014d547;
LAB_0014d634:
uVar3 = 0;
lVar5 = 0;
}
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(local_50);
LAB_0014d643:
auVar6._0_8_ = uVar3 & 0xffffffff;
auVar6._8_8_ = lVar5;
return auVar6;
}
| |
24,959 | std::pair<bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, bool) | monkey531[P]llama/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<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>*> nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<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>>::handle_value<double&>(double&, 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 0x6e986
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 0x6e819
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x6ea20
movq %r14, %rdi
movl $0x1, %esi
callq 0x66666
testb %bpl, %bpl
jne 0x6e7c6
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x6e9a7
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x6e95a
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x6e823
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x6e95a
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x6e87d
cmpl $0x2, %ecx
jne 0x6e9ac
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6b228
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x6e956
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x6e976
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x66666
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x66666
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x68e08
movq %r15, %rdi
xorl %esi, %esi
callq 0x66666
movq %r15, %rdi
callq 0x6bb54
movq (%rbx), %r14
jmp 0x6e956
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 0x6e9ba
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 0x6e8ef
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x6e95a
cmpq $0x0, 0x70(%rbx)
je 0x6e9db
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x66666
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x66666
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x68e08
movq %r15, %rdi
xorl %esi, %esi
callq 0x66666
movq %r15, %rdi
callq 0x6bb54
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x6e95f
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x66666
movq %r15, %rdi
callq 0x6bb54
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8b617(%rip), %rdi # 0xf9fa4
leaq 0x851ac(%rip), %rdx # 0xf3b40
leaq 0x8c56e(%rip), %rcx # 0xfaf09
movl $0x1c28, %esi # imm = 0x1C28
xorl %eax, %eax
callq 0x1bf10
callq 0x1b320
leaq 0x8c56a(%rip), %rcx # 0xfaf1d
movl $0x1c4b, %esi # imm = 0x1C4B
jmp 0x6e9c6
leaq 0x8c59a(%rip), %rcx # 0xfaf5b
movl $0x1c57, %esi # imm = 0x1C57
leaq 0x8b5d7(%rip), %rdi # 0xf9fa4
leaq 0x8516c(%rip), %rdx # 0xf3b40
xorl %eax, %eax
callq 0x1bf10
leaq 0x8b5c2(%rip), %rdi # 0xf9fa4
leaq 0x85157(%rip), %rdx # 0xf3b40
leaq 0x8c583(%rip), %rcx # 0xfaf73
movl $0x1c60, %esi # imm = 0x1C60
xorl %eax, %eax
callq 0x1bf10
jmp 0x6e9fe
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x66666
movq %r14, %rdi
callq 0x6bb54
movq %rbx, %rdi
callq 0x1c020
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__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_6E986
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_6E819
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_jsonINS0_11ordered_mapESt6vectorNSt7__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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &,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>::number_unsigned_t)
mov rdi, r14
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)
test bpl, bpl
jnz short loc_6E7C6
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_6E9A7
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_6E95A
loc_6E7C6:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_6E823
mov rax, [rax-8]
test rax, rax
jz loc_6E95A
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_6E87D
cmp ecx, 2
jnz loc_6E9AC
mov rdi, [rax+8]
lea rsi, [rsp+68h+var_58]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE12emplace_backIJSD_EEERSD_DpOT_; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rax, [rbx+10h]
mov rax, [rax-8]
mov rax, [rax+8]
mov r14, [rax+8]
add r14, 0FFFFFFFFFFFFFFF0h
jmp loc_6E956
loc_6E819:
xor ebx, ebx
xor r14d, r14d
jmp loc_6E976
loc_6E823:
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_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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
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, [rbx]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx]
jmp loc_6E956
loc_6E87D:
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_6E9BA
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_6E8EF
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_6E8EF:
test rdx, rdx
jz short loc_6E95A
cmp qword ptr [rbx+70h], 0
jz loc_6E9DB
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_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 byte ptr [r14], 0
mov qword ptr [r14+8], 0
mov rdi, r15
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, [rbx+70h]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov r14, [rbx+70h]
loc_6E956:
mov bl, 1
jmp short loc_6E95F
loc_6E95A:
xor ebx, ebx
xor r14d, r14d
loc_6E95F:
lea r15, [rsp+68h+var_58]
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_6E976:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_6E986:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1C28h
xor eax, eax
call _ggml_abort
loc_6E9A7:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_6E9AC:
lea rcx, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
mov esi, 1C4Bh
jmp short loc_6E9C6
loc_6E9BA:
lea rcx, aKeyKeepStackEm; "!key_keep_stack.empty()"
mov esi, 1C57h
loc_6E9C6:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
xor eax, eax
call _ggml_abort
loc_6E9DB:
lea rdi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
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_6E9FE:
mov rbx, rax
lea r14, [rsp+68h+var_58]
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, 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<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>>::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/github/2025_star3/monkey531[P]llama/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<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>>(
&v25,
*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 *)&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<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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
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 *)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>::operator=(
*(_QWORD *)a1,
(long long)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>::assert_invariant((char *)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);
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<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*((_QWORD *)v11 + 1),
(long long)&v25);
LABEL_23:
LOBYTE(v4) = 1;
LABEL_25:
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 *)&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);
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/github/2025_star3/monkey531[P]llama/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<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 *)&v25);
LOBYTE(v25) = 0;
*((_QWORD *)&v25 + 1) = 0LL;
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 *)&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>::operator=(
*(_QWORD *)(a1 + 112),
(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((char *)&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>::data::~data(&v26);
goto LABEL_23;
}
LABEL_32:
v22 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7264LL,
"GGML_ASSERT(%s) failed",
"object_element");
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 *)&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);
_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 0x0016e986
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 0x0016e819
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x0016ea20
MOV RDI,R14
MOV ESI,0x1
CALL 0x00166666
TEST BPL,BPL
JNZ 0x0016e7c6
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 0x0016e9a7
LEA RDI,[RBX + 0x80]
LAB_0016e7a9:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0016e95a
LAB_0016e7c6:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0016e823
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0016e95a
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0016e87d
CMP ECX,0x2
JNZ 0x0016e9ac
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x0016b228
LAB_0016e800:
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 0x0016e956
LAB_0016e819:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0016e976
LAB_0016e823:
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 0x00166666
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00166666
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x00168e08
MOV RDI,R15
XOR ESI,ESI
CALL 0x00166666
MOV RDI,R15
CALL 0x0016bb54
MOV R14,qword ptr [RBX]
JMP 0x0016e956
LAB_0016e87d:
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 0x0016e9ba
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 0x0016e8ef
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0016e8ef:
TEST RDX,RDX
JZ 0x0016e95a
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0016e9db
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 0x00166666
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00166666
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x00168e08
MOV RDI,R15
XOR ESI,ESI
CALL 0x00166666
MOV RDI,R15
CALL 0x0016bb54
MOV R14,qword ptr [RBX + 0x70]
LAB_0016e956:
MOV BL,0x1
JMP 0x0016e95f
LAB_0016e95a:
XOR EBX,EBX
XOR R14D,R14D
LAB_0016e95f:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x00166666
MOV RDI,R15
CALL 0x0016bb54
LAB_0016e976:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0016e986:
LEA RDI,[0x1f9fa4]
LEA RDX,[0x1f3b40]
LEA RCX,[0x1faf09]
MOV ESI,0x1c28
XOR EAX,EAX
CALL 0x0011bf10
LAB_0016e9a7:
CALL 0x0011b320
LAB_0016e9ac:
LEA RCX,[0x1faf1d]
MOV ESI,0x1c4b
JMP 0x0016e9c6
LAB_0016e9ba:
LEA RCX,[0x1faf5b]
MOV ESI,0x1c57
LAB_0016e9c6:
LEA RDI,[0x1f9fa4]
LEA RDX,[0x1f3b40]
XOR EAX,EAX
CALL 0x0011bf10
LAB_0016e9db:
LEA RDI,[0x1f9fa4]
LEA RDX,[0x1f3b40]
LEA RCX,[0x1faf73]
MOV ESI,0x1c60
XOR EAX,EAX
CALL 0x0011bf10
|
/* std::pair<bool, 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::detail::json_sax_dom_callback_parser<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> >::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<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>>
::handle_value<unsigned_long&>
(json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this,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/github/2025_star3/monkey531[P]llama/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_0016e976;
}
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<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_58,*param_1);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(&local_58,0));
if (param_2) {
LAB_0016e7c6:
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
local_38 = local_58;
uStack_30 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_38,0);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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,(data *)&local_38);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_38);
lVar8 = *(long *)this;
}
else {
pcVar4 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar4 == (char *)0x0) goto LAB_0016e95a;
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_0016e9c6;
}
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_0016e95a;
if (*(long *)(this + 0x70) == 0) {
/* try { // try from 0016e9db to 0016e9fb has its CatchHandler @ 0016e9fc */
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
0x1c60,"GGML_ASSERT(%s) failed","object_element");
}
local_48 = local_58;
uStack_40 = uStack_50;
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_58,0));
local_58 = local_58 & 0xffffffffffffff00;
uStack_50 = 0;
bVar7 = SUB81((data *)&local_48,0);
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(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=(*(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 + 0x70),(data *)&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>
::assert_invariant(bVar7);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_48);
lVar8 = *(long *)(this + 0x70);
}
else {
if (*pcVar4 != '\x02') {
pcVar4 = "ref_stack.back()->is_array() || ref_stack.back()->is_object()";
uVar6 = 0x1c4b;
LAB_0016e9c6:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
uVar6,"GGML_ASSERT(%s) failed",pcVar4);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(*(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>>>
**)(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 0016e9a7 to 0016e9da has its CatchHandler @ 0016e9fe */
std::__throw_bad_function_call();
}
/* try { // try from 0016e7a9 to 0016e7ff has its CatchHandler @ 0016e9fe */
cVar2 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar2 != '\0') goto LAB_0016e7c6;
LAB_0016e95a:
uVar5 = 0;
lVar8 = 0;
}
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((data *)&local_58,0));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data((data *)&local_58);
LAB_0016e976:
auVar9._0_8_ = uVar5 & 0xffffffff;
auVar9._8_8_ = lVar8;
return auVar9;
}
| |
24,960 | ulight::html::match_cdata(std::basic_string_view<char8_t, std::char_traits<char8_t>>) | ulight/src/main/cpp/html.cpp | Match_Result match_cdata(std::u8string_view str)
{
// https://html.spec.whatwg.org/dev/syntax.html#syntax-cdata
if (!str.starts_with(cdata_prefix)) {
return {};
}
const std::size_t result = str.find(cdata_suffix, cdata_prefix.length());
if (result == std::u8string_view::npos) {
return { .length = str.length(), .terminated = false };
}
return { .length = result + cdata_suffix.length(), .terminated = true };
} | O0 | cpp | ulight::html::match_cdata(std::basic_string_view<char8_t, std::char_traits<char8_t>>):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x190d9(%rip), %rax # 0x295e0
movq %rax, -0x30(%rbp)
movq 0x190d6(%rip), %rax # 0x295e8
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xb520
testb $0x1, %al
jne 0x10539
movq $0x0, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
jmp 0x105b3
movq 0x190b0(%rip), %rax # 0x295f0
movq %rax, -0x48(%rbp)
movq 0x190ad(%rip), %rax # 0x295f8
movq %rax, -0x40(%rbp)
leaq 0x1908a(%rip), %rdi # 0x295e0
callq 0x6d60
movq %rax, %rcx
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x121e0
movq %rax, -0x38(%rbp)
cmpq $-0x1, -0x38(%rbp)
jne 0x1058d
leaq -0x20(%rbp), %rdi
callq 0x6d60
movq %rax, -0x10(%rbp)
movb $0x0, -0x8(%rbp)
jmp 0x105b3
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x19054(%rip), %rdi # 0x295f0
callq 0x6d60
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movb $0x1, -0x8(%rbp)
movq -0x10(%rbp), %rax
movb -0x8(%rbp), %dl
addq $0x50, %rsp
popq %rbp
retq
| _ZN6ulight4html11match_cdataESt17basic_string_viewIDuSt11char_traitsIDuEE:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_20], rdi
mov [rbp+var_18], rsi
mov rax, cs:_ZN6ulight4html12_GLOBAL__N_112cdata_prefixE; ulight::html::`anonymous namespace'::cdata_prefix
mov [rbp+var_30], rax
mov rax, cs:off_295E8; "<![CDATA["
mov [rbp+var_28], rax
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_28]
lea rdi, [rbp+var_20]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE11starts_withES2_; std::u8string_view::starts_with(std::u8string_view)
test al, 1
jnz short loc_10539
mov [rbp+var_10], 0
mov [rbp+var_8], 0
jmp short loc_105B3
loc_10539:
mov rax, cs:_ZN6ulight4html12_GLOBAL__N_112cdata_suffixE; ulight::html::`anonymous namespace'::cdata_suffix
mov [rbp+var_48], rax
mov rax, cs:off_295F8; "]]>"
mov [rbp+var_40], rax
lea rdi, _ZN6ulight4html12_GLOBAL__N_112cdata_prefixE; ulight::html::`anonymous namespace'::cdata_prefix
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6lengthEv; std::u8string_view::length(void)
mov rcx, rax
mov rsi, [rbp+var_48]
mov rdx, [rbp+var_40]
lea rdi, [rbp+var_20]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE4findES2_m; std::u8string_view::find(std::u8string_view,ulong)
mov [rbp+var_38], rax
cmp [rbp+var_38], 0FFFFFFFFFFFFFFFFh
jnz short loc_1058D
lea rdi, [rbp+var_20]
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6lengthEv; std::u8string_view::length(void)
mov [rbp+var_10], rax
mov [rbp+var_8], 0
jmp short loc_105B3
loc_1058D:
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
lea rdi, _ZN6ulight4html12_GLOBAL__N_112cdata_suffixE; ulight::html::`anonymous namespace'::cdata_suffix
call _ZNKSt17basic_string_viewIDuSt11char_traitsIDuEE6lengthEv; std::u8string_view::length(void)
mov rcx, rax
mov rax, [rbp+var_50]
add rax, rcx
mov [rbp+var_10], rax
mov [rbp+var_8], 1
loc_105B3:
mov rax, [rbp+var_10]
mov dl, [rbp+var_8]
add rsp, 50h
pop rbp
retn
| long long ulight::html::match_cdata(unsigned long long a1, unsigned long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-38h]
unsigned long long v5[2]; // [rsp+30h] [rbp-20h] BYREF
long long v6; // [rsp+40h] [rbp-10h]
char v7; // [rsp+48h] [rbp-8h]
v5[0] = a1;
v5[1] = a2;
if ( std::u8string_view::starts_with(v5, (unsigned long long)byte_9, (long long)"<![CDATA[") )
{
v2 = std::u8string_view::length((long long)&ulight::html::`anonymous namespace'::cdata_prefix);
v4 = std::u8string_view::find(v5, (char *)&dword_0 + 3, "]]>", v2);
if ( v4 == -1 )
{
v6 = std::u8string_view::length((long long)v5);
v7 = 0;
}
else
{
v6 = std::u8string_view::length((long long)&ulight::html::`anonymous namespace'::cdata_suffix) + v4;
v7 = 1;
}
}
else
{
v6 = 0LL;
v7 = 0;
}
return v6;
}
| match_cdata:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [0x001295e0]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [0x001295e8]
MOV qword ptr [RBP + -0x28],RAX
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x28]
LEA RDI,[RBP + -0x20]
CALL 0x0010b520
TEST AL,0x1
JNZ 0x00110539
MOV qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x8],0x0
JMP 0x001105b3
LAB_00110539:
MOV RAX,qword ptr [0x001295f0]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [0x001295f8]
MOV qword ptr [RBP + -0x40],RAX
LEA RDI,[0x1295e0]
CALL 0x00106d60
MOV RCX,RAX
MOV RSI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x40]
LEA RDI,[RBP + -0x20]
CALL 0x001121e0
MOV qword ptr [RBP + -0x38],RAX
CMP qword ptr [RBP + -0x38],-0x1
JNZ 0x0011058d
LEA RDI,[RBP + -0x20]
CALL 0x00106d60
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x8],0x0
JMP 0x001105b3
LAB_0011058d:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
LEA RDI,[0x1295f0]
CALL 0x00106d60
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV byte ptr [RBP + -0x8],0x1
LAB_001105b3:
MOV RAX,qword ptr [RBP + -0x10]
MOV DL,byte ptr [RBP + -0x8]
ADD RSP,0x50
POP RBP
RET
|
/* ulight::html::match_cdata(std::basic_string_view<char8_t, std::char_traits<char8_t> >) */
int1 [16] __thiscall ulight::html::match_cdata(html *this,int8 param_2)
{
int1 auVar1 [16];
int8 uVar2;
int *puVar3;
int8 uVar4;
long lVar5;
int1 auVar6 [16];
int1 auVar7 [16];
html *local_28;
int8 local_20;
int8 local_18;
int1 local_10;
local_28 = this;
local_20 = param_2;
auVar6 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::starts_with
(&local_28,(anonymous_namespace)::cdata_prefix,PTR_s_<_[CDATA[_001295e8);
puVar3 = PTR_DAT_001295f8;
uVar2 = (anonymous_namespace)::cdata_suffix;
if ((auVar6 & (int1 [16])0x1) == (int1 [16])0x0) {
auVar1._8_8_ = 0;
auVar1._0_8_ = auVar6._8_8_;
auVar6 = auVar1 << 0x40;
local_10 = 0;
}
else {
uVar4 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::length
((basic_string_view<char8_t,std::char_traits<char8_t>> *)
&(anonymous_namespace)::cdata_prefix);
lVar5 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::find
(&local_28,uVar2,puVar3,uVar4);
if (lVar5 == -1) {
auVar6 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::length
((basic_string_view<char8_t,std::char_traits<char8_t>> *)&local_28);
local_10 = 0;
}
else {
auVar6 = std::basic_string_view<char8_t,std::char_traits<char8_t>>::length
((basic_string_view<char8_t,std::char_traits<char8_t>> *)
&(anonymous_namespace)::cdata_suffix);
auVar6._8_8_ = auVar6._8_8_;
auVar6._0_8_ = lVar5 + auVar6._0_8_;
local_10 = 1;
}
}
local_18 = auVar6._0_8_;
auVar7._9_7_ = auVar6._9_7_;
auVar7[8] = local_10;
auVar7._0_8_ = local_18;
return auVar7;
}
| |
24,961 | ma_hashtbl_delete | eloqsql/libmariadb/libmariadb/ma_hashtbl.c | my_bool ma_hashtbl_delete(MA_HASHTBL *hash,uchar *record)
{
uint blength,pos2,pos_hashnr,lastpos_hashnr,idx,empty_index;
MA_HASHTBL_LINK *data,*lastpos,*gpos,*pos,*pos3,*empty;
if (!hash->records)
return(1);
blength=hash->blength;
data=dynamic_element(&hash->array,0,MA_HASHTBL_LINK*);
/* Search after record with key */
pos=data+ hash_mask(rec_hashnr(hash,record),blength,hash->records);
gpos = 0;
while (pos->data != record)
{
gpos=pos;
if (pos->next == NO_RECORD)
return(1); /* Key not found */
pos=data+pos->next;
}
if ( --(hash->records) < hash->blength >> 1) hash->blength>>=1;
hash->current_record= NO_RECORD;
lastpos=data+hash->records;
/* Remove link to record */
empty=pos; empty_index=(uint) (empty-data);
if (gpos)
gpos->next=pos->next; /* unlink current ptr */
else if (pos->next != NO_RECORD)
{
empty=data+(empty_index=pos->next);
pos->data=empty->data;
pos->next=empty->next;
}
if (empty == lastpos) /* last key at wrong pos or no next link */
goto exit;
/* Move the last key (lastpos) */
lastpos_hashnr=rec_hashnr(hash,lastpos->data);
/* pos is where lastpos should be */
pos=data+hash_mask(lastpos_hashnr,hash->blength,hash->records);
if (pos == empty) /* Move to empty position. */
{
empty[0]=lastpos[0];
goto exit;
}
pos_hashnr=rec_hashnr(hash,pos->data);
/* pos3 is where the pos should be */
pos3= data+hash_mask(pos_hashnr,hash->blength,hash->records);
if (pos != pos3)
{ /* pos is on wrong posit */
empty[0]=pos[0]; /* Save it here */
pos[0]=lastpos[0]; /* This should be here */
movelink(data,(uint) (pos-data),(uint) (pos3-data),empty_index);
goto exit;
}
pos2= hash_mask(lastpos_hashnr,blength,hash->records+1);
if (pos2 == hash_mask(pos_hashnr,blength,hash->records+1))
{ /* Identical key-positions */
if (pos2 != hash->records)
{
empty[0]=lastpos[0];
movelink(data,(uint) (lastpos-data),(uint) (pos-data),empty_index);
goto exit;
}
idx= (uint) (pos-data); /* Link pos->next after lastpos */
}
else idx= NO_RECORD; /* Different positions merge */
empty[0]=lastpos[0];
movelink(data,idx,empty_index,pos->next);
pos->next=empty_index;
exit:
ma_pop_dynamic(&hash->array);
if (hash->free)
(*hash->free)((uchar*) record);
return(0);
} | O3 | c | ma_hashtbl_delete:
movb $0x1, %al
cmpl $0x0, 0x8(%rdi)
je 0x31814
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xc(%rdi), %r12d
movq 0x18(%rdi), %r13
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x315a8
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%r15), %esi
jmp 0x315b5
movl 0x4(%r14), %esi
movl %esi, -0x58(%rbp)
movl (%r14), %edi
addq %rbx, %rdi
callq *0x40(%r14)
movl %eax, %r15d
movl 0x8(%r14), %esi
leal -0x1(%r12), %r8d
andl %r8d, %eax
shrl %r12d
decl %r12d
movq %r12, -0x70(%rbp)
andl %r12d, %r15d
cmpl %esi, %eax
cmovbl %eax, %r15d
movq %r15, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %r12
cmpq %rbx, 0x8(%r13,%rax)
je 0x31612
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movl (%r12), %r15d
cmpq %rcx, %r15
je 0x31647
movq %r12, %rax
movq %r15, %rdx
shlq $0x4, %rdx
leaq (%rdx,%r13), %r12
cmpq %rbx, 0x8(%r13,%rdx)
jne 0x315f2
jmp 0x31614
xorl %eax, %eax
decl %esi
movl %esi, 0x8(%r14)
movl 0xc(%r14), %ecx
shrl %ecx
cmpl %ecx, %esi
jae 0x31628
movl %ecx, 0xc(%r14)
movl $0xffffffff, 0x10(%r14) # imm = 0xFFFFFFFF
movl %esi, %r9d
shlq $0x4, %r9
addq %r13, %r9
movl (%r12), %ecx
testq %rax, %rax
je 0x3164e
movl %ecx, (%rax)
jmp 0x31674
movb $0x1, %al
jmp 0x31806
cmpl $-0x1, %ecx
je 0x31674
movq %rcx, %rax
shlq $0x4, %rax
movq 0x8(%r13,%rax), %rdx
movq %rdx, 0x8(%r12)
movl (%r13,%rax), %edx
movl %edx, (%r12)
leaq (%rax,%r13), %r12
movl %ecx, %r15d
leaq 0x18(%r14), %rdi
cmpq %r9, %r12
je 0x317f1
movq %rdi, -0x38(%rbp)
movl %r8d, -0x54(%rbp)
movl %esi, -0x50(%rbp)
movq %r9, -0x48(%rbp)
movq 0x8(%r9), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
movq %rbx, -0x40(%rbp)
je 0x316b3
leaq -0x5c(%rbp), %rbx
movq %rbx, %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
movl (%rbx), %esi
jmp 0x316c0
movl 0x4(%r14), %esi
movl %esi, -0x5c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0xc(%r14), %ebx
leal -0x1(%rbx), %ecx
andl %eax, %ecx
shrl %ebx
decl %ebx
andl %eax, %ebx
cmpl 0x8(%r14), %ecx
cmovbl %ecx, %ebx
movq %rbx, %rcx
shlq $0x4, %rcx
addq %r13, %rcx
cmpq %r12, %rcx
je 0x31710
movl %eax, -0x4c(%rbp)
movq %rcx, -0x68(%rbp)
movq 0x8(%rcx), %rdi
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x31721
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq *%rax
movq %rax, %rdi
leaq -0x2c(%rbp), %rax
movl (%rax), %esi
jmp 0x3172e
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%r12)
jmp 0x317e9
movl 0x4(%r14), %esi
movl %esi, -0x2c(%rbp)
movl (%r14), %eax
addq %rax, %rdi
callq *0x40(%r14)
movl 0x8(%r14), %ecx
movl 0xc(%r14), %edx
leal -0x1(%rdx), %esi
andl %eax, %esi
shrl %edx
decl %edx
andl %eax, %edx
cmpl %ecx, %esi
cmovbl %esi, %edx
cmpl %edx, %ebx
jne 0x317bd
leal 0x1(%rcx), %edx
movl -0x4c(%rbp), %r9d
movl %r9d, %esi
movl -0x54(%rbp), %r8d
andl %r8d, %esi
movq -0x70(%rbp), %rdi
andl %edi, %r9d
cmpl %edx, %esi
cmovbl %esi, %r9d
andl %eax, %r8d
andl %edi, %eax
cmpl %edx, %r8d
cmovbl %r8d, %eax
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpl %eax, %r9d
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rdi
jne 0x31795
cmpl %ecx, %r9d
jne 0x31815
movl %ebx, %edx
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl (%rdi), %eax
movl %r15d, %esi
movl %esi, %ecx
shlq $0x4, %rcx
movl (%r13,%rcx), %esi
cmpl %edx, %esi
jne 0x317a2
addq %rcx, %r13
movl %eax, (%r13)
movl %r15d, (%rdi)
jmp 0x317e9
movq -0x68(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movl %edx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %edx
cmpl %ebx, %edx
jne 0x317d3
addq %rax, %r13
movl %r15d, (%r13)
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rdi
callq 0x30311
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x31804
movq %rbx, %rdi
callq *%rax
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movups (%rax), %xmm0
movups %xmm0, (%r12)
movl -0x50(%rbp), %ecx
movl %ebx, %eax
shlq $0x4, %rax
movl (%r13,%rax), %ebx
cmpl %ecx, %ebx
jne 0x31820
jmp 0x317e2
| ma_hashtbl_delete:
mov al, 1
cmp dword ptr [rdi+8], 0
jz locret_31814
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov rbx, rsi
mov r14, rdi
mov r12d, [rdi+0Ch]
mov r13, [rdi+18h]
mov rax, [rdi+30h]
test rax, rax
jz short loc_315A8
lea r15, [rbp-58h]
mov rdi, rbx
mov rsi, r15
xor edx, edx
call rax
mov rdi, rax
mov esi, [r15]
jmp short loc_315B5
loc_315A8:
mov esi, [r14+4]
mov [rbp-58h], esi
mov edi, [r14]
add rdi, rbx
loc_315B5:
call qword ptr [r14+40h]
mov r15d, eax
mov esi, [r14+8]
lea r8d, [r12-1]
and eax, r8d
shr r12d, 1
dec r12d
mov [rbp-70h], r12
and r15d, r12d
cmp eax, esi
cmovb r15d, eax
mov rax, r15
shl rax, 4
lea r12, [rax+r13]
cmp [r13+rax+8], rbx
jz short loc_31612
mov ecx, 0FFFFFFFFh
loc_315F2:
mov r15d, [r12]
cmp r15, rcx
jz short loc_31647
mov rax, r12
mov rdx, r15
shl rdx, 4
lea r12, [rdx+r13]
cmp [r13+rdx+8], rbx
jnz short loc_315F2
jmp short loc_31614
loc_31612:
xor eax, eax
loc_31614:
dec esi
mov [r14+8], esi
mov ecx, [r14+0Ch]
shr ecx, 1
cmp esi, ecx
jnb short loc_31628
mov [r14+0Ch], ecx
loc_31628:
mov dword ptr [r14+10h], 0FFFFFFFFh
mov r9d, esi
shl r9, 4
add r9, r13
mov ecx, [r12]
test rax, rax
jz short loc_3164E
mov [rax], ecx
jmp short loc_31674
loc_31647:
mov al, 1
jmp loc_31806
loc_3164E:
cmp ecx, 0FFFFFFFFh
jz short loc_31674
mov rax, rcx
shl rax, 4
mov rdx, [r13+rax+8]
mov [r12+8], rdx
mov edx, [r13+rax+0]
mov [r12], edx
lea r12, [rax+r13]
mov r15d, ecx
loc_31674:
lea rdi, [r14+18h]
cmp r12, r9
jz loc_317F1
mov [rbp-38h], rdi
mov [rbp-54h], r8d
mov [rbp-50h], esi
mov [rbp-48h], r9
mov rdi, [r9+8]
mov rax, [r14+30h]
test rax, rax
mov [rbp-40h], rbx
jz short loc_316B3
lea rbx, [rbp-5Ch]
mov rsi, rbx
xor edx, edx
call rax
mov rdi, rax
mov esi, [rbx]
jmp short loc_316C0
loc_316B3:
mov esi, [r14+4]
mov [rbp-5Ch], esi
mov eax, [r14]
add rdi, rax
loc_316C0:
call qword ptr [r14+40h]
mov ebx, [r14+0Ch]
lea ecx, [rbx-1]
and ecx, eax
shr ebx, 1
dec ebx
and ebx, eax
cmp ecx, [r14+8]
cmovb ebx, ecx
mov rcx, rbx
shl rcx, 4
add rcx, r13
cmp rcx, r12
jz short loc_31710
mov [rbp-4Ch], eax
mov [rbp-68h], rcx
mov rdi, [rcx+8]
mov rax, [r14+30h]
test rax, rax
jz short loc_31721
lea rsi, [rbp-2Ch]
xor edx, edx
call rax
mov rdi, rax
lea rax, [rbp-2Ch]
mov esi, [rax]
jmp short loc_3172E
loc_31710:
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
jmp loc_317E9
loc_31721:
mov esi, [r14+4]
mov [rbp-2Ch], esi
mov eax, [r14]
add rdi, rax
loc_3172E:
call qword ptr [r14+40h]
mov ecx, [r14+8]
mov edx, [r14+0Ch]
lea esi, [rdx-1]
and esi, eax
shr edx, 1
dec edx
and edx, eax
cmp esi, ecx
cmovb edx, esi
cmp ebx, edx
jnz short loc_317BD
lea edx, [rcx+1]
mov r9d, [rbp-4Ch]
mov esi, r9d
mov r8d, [rbp-54h]
and esi, r8d
mov rdi, [rbp-70h]
and r9d, edi
cmp esi, edx
cmovb r9d, esi
and r8d, eax
and eax, edi
cmp r8d, edx
cmovb eax, r8d
mov edx, 0FFFFFFFFh
cmp r9d, eax
mov rax, [rbp-48h]
mov rdi, [rbp-68h]
jnz short loc_31795
cmp r9d, ecx
jnz loc_31815
mov edx, ebx
loc_31795:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov eax, [rdi]
mov esi, r15d
loc_317A2:
mov ecx, esi
shl rcx, 4
mov esi, [r13+rcx+0]
cmp esi, edx
jnz short loc_317A2
add r13, rcx
mov [r13+0], eax
mov [rdi], r15d
jmp short loc_317E9
loc_317BD:
mov rcx, [rbp-68h]
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [r12], xmm0
mov rax, [rbp-48h]
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [rcx], xmm0
loc_317D3:
mov eax, edx
shl rax, 4
mov edx, [r13+rax+0]
cmp edx, ebx
jnz short loc_317D3
loc_317E2:
add r13, rax
mov [r13+0], r15d
loc_317E9:
mov rbx, [rbp-40h]
mov rdi, [rbp-38h]
loc_317F1:
call ma_pop_dynamic
mov rax, [r14+38h]
test rax, rax
jz short loc_31804
mov rdi, rbx
call rax
loc_31804:
xor eax, eax
loc_31806:
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
locret_31814:
retn
loc_31815:
movups xmm0, xmmword ptr [rax]
movups xmmword ptr [r12], xmm0
mov ecx, [rbp-50h]
loc_31820:
mov eax, ebx
shl rax, 4
mov ebx, [r13+rax+0]
cmp ebx, ecx
jnz short loc_31820
jmp short loc_317E2
| char ma_hashtbl_delete(unsigned int *a1, long long a2)
{
char result; // al
long long v3; // rbx
unsigned int v5; // r12d
long long v6; // r13
long long ( *v7)(long long, unsigned int *, _QWORD); // rax
long long v8; // rdi
long long v9; // rsi
unsigned int v10; // r15d
unsigned int v11; // esi
unsigned int v12; // r8d
unsigned int v13; // eax
long long v14; // r15
unsigned int *v15; // r12
unsigned int *v16; // rax
unsigned int v17; // esi
unsigned int v18; // ecx
long long v19; // r9
long long v20; // rcx
long long v21; // rdi
long long v22; // rdi
long long ( *v23)(long long, unsigned int *, _QWORD); // rax
long long v24; // rdi
long long v25; // rsi
unsigned int v26; // eax
unsigned int v27; // ebx
unsigned int v28; // ecx
long long v29; // rbx
long long v30; // rcx
long long v31; // rdi
long long ( *v32)(long long, unsigned int *, _QWORD); // rax
long long v33; // rdi
long long v34; // rsi
int v35; // eax
unsigned int v36; // ecx
unsigned int v37; // edx
unsigned int v38; // esi
unsigned int v39; // edx
int v40; // r9d
unsigned int v41; // r8d
int v42; // eax
int v43; // edx
unsigned int v44; // esi
long long v45; // rcx
long long v46; // rax
void ( *v47)(long long); // rax
int v48; // [rsp-78h] [rbp-78h]
_DWORD *v49; // [rsp-70h] [rbp-70h]
unsigned int v50; // [rsp-64h] [rbp-64h] BYREF
unsigned int v51; // [rsp-60h] [rbp-60h] BYREF
unsigned int v52; // [rsp-5Ch] [rbp-5Ch]
unsigned int v53; // [rsp-58h] [rbp-58h]
unsigned int v54; // [rsp-54h] [rbp-54h]
_OWORD *v55; // [rsp-50h] [rbp-50h]
long long v56; // [rsp-48h] [rbp-48h]
unsigned int *v57; // [rsp-40h] [rbp-40h]
unsigned int v58; // [rsp-34h] [rbp-34h] BYREF
result = 1;
if ( !a1[2] )
return result;
v3 = a2;
v5 = a1[3];
v6 = *((_QWORD *)a1 + 3);
v7 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v7 )
{
v8 = v7(a2, &v51, 0LL);
v9 = v51;
}
else
{
v9 = a1[1];
v51 = a1[1];
v8 = v3 + *a1;
}
v10 = (*((long long ( **)(long long, long long))a1 + 8))(v8, v9);
v11 = a1[2];
v12 = v5 - 1;
v13 = (v5 - 1) & v10;
v48 = (v5 >> 1) - 1;
v14 = v48 & v10;
if ( v13 < v11 )
v14 = v13;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
{
v16 = 0LL;
LABEL_12:
v17 = v11 - 1;
a1[2] = v17;
v18 = a1[3] >> 1;
if ( v17 < v18 )
a1[3] = v18;
a1[4] = -1;
v19 = v6 + 16LL * v17;
v20 = *v15;
if ( v16 )
{
*v16 = v20;
}
else if ( (_DWORD)v20 != -1 )
{
*((_QWORD *)v15 + 1) = *(_QWORD *)(v6 + 16 * v20 + 8);
*v15 = *(_DWORD *)(v6 + 16 * v20);
v15 = (unsigned int *)(16 * v20 + v6);
LODWORD(v14) = v20;
}
v21 = (long long)(a1 + 6);
if ( v15 == (unsigned int *)v19 )
goto LABEL_47;
v57 = a1 + 6;
v52 = v12;
v53 = v17;
v55 = (_OWORD *)(v6 + 16LL * v17);
v22 = *(_QWORD *)(v19 + 8);
v23 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
v56 = v3;
if ( v23 )
{
v24 = v23(v22, &v50, 0LL);
v25 = v50;
}
else
{
v25 = a1[1];
v50 = a1[1];
v24 = *a1 + v22;
}
v26 = (*((long long ( **)(long long, long long))a1 + 8))(v24, v25);
v27 = a1[3];
v28 = v26 & (v27 - 1);
v29 = v26 & ((v27 >> 1) - 1);
if ( v28 < a1[2] )
v29 = v28;
v30 = v6 + 16 * v29;
if ( (unsigned int *)v30 == v15 )
{
*(_OWORD *)v15 = *v55;
}
else
{
v54 = v26;
v49 = (_DWORD *)(v6 + 16 * v29);
v31 = *(_QWORD *)(v30 + 8);
v32 = (long long ( *)(long long, unsigned int *, _QWORD))*((_QWORD *)a1 + 6);
if ( v32 )
{
v33 = v32(v31, &v58, 0LL);
v34 = v58;
}
else
{
v34 = a1[1];
v58 = a1[1];
v33 = *a1 + v31;
}
v35 = (*((long long ( **)(long long, long long))a1 + 8))(v33, v34);
v36 = a1[2];
v37 = a1[3];
v38 = v35 & (v37 - 1);
v39 = v35 & ((v37 >> 1) - 1);
if ( v38 < v36 )
v39 = v38;
if ( (_DWORD)v29 == v39 )
{
v40 = v48 & v54;
if ( (v52 & v54) < v36 + 1 )
v40 = v52 & v54;
v41 = v35 & v52;
v42 = v48 & v35;
if ( v41 < v36 + 1 )
v42 = v41;
v43 = -1;
if ( v40 != v42 )
goto LABEL_40;
if ( v40 == v36 )
{
v43 = v29;
LABEL_40:
*(_OWORD *)v15 = *v55;
v44 = v14;
do
{
v45 = 16LL * v44;
v44 = *(_DWORD *)(v6 + v45);
}
while ( v44 != v43 );
*(_DWORD *)(v45 + v6) = *v49;
*v49 = v14;
goto LABEL_46;
}
*(_OWORD *)v15 = *v55;
do
{
v46 = 16LL * (unsigned int)v29;
LODWORD(v29) = *(_DWORD *)(v6 + v46);
}
while ( (_DWORD)v29 != v53 );
}
else
{
*(_OWORD *)v15 = *(_OWORD *)v49;
*(_OWORD *)v49 = *v55;
do
{
v46 = 16LL * v39;
v39 = *(_DWORD *)(v6 + v46);
}
while ( v39 != (_DWORD)v29 );
}
*(_DWORD *)(v46 + v6) = v14;
}
LABEL_46:
v3 = v56;
v21 = (long long)v57;
LABEL_47:
ma_pop_dynamic(v21);
v47 = (void ( *)(long long))*((_QWORD *)a1 + 7);
if ( v47 )
v47(v3);
return 0;
}
while ( 1 )
{
v14 = *v15;
if ( v14 == 0xFFFFFFFFLL )
return 1;
v16 = v15;
v15 = (unsigned int *)(16 * v14 + v6);
if ( *((_QWORD *)v15 + 1) == v3 )
goto LABEL_12;
}
}
| ma_hashtbl_delete:
MOV AL,0x1
CMP dword ptr [RDI + 0x8],0x0
JZ 0x00131814
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV RBX,RSI
MOV R14,RDI
MOV R12D,dword ptr [RDI + 0xc]
MOV R13,qword ptr [RDI + 0x18]
MOV RAX,qword ptr [RDI + 0x30]
TEST RAX,RAX
JZ 0x001315a8
LEA R15,[RBP + -0x58]
MOV RDI,RBX
MOV RSI,R15
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [R15]
JMP 0x001315b5
LAB_001315a8:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x58],ESI
MOV EDI,dword ptr [R14]
ADD RDI,RBX
LAB_001315b5:
CALL qword ptr [R14 + 0x40]
MOV R15D,EAX
MOV ESI,dword ptr [R14 + 0x8]
LEA R8D,[R12 + -0x1]
AND EAX,R8D
SHR R12D,0x1
DEC R12D
MOV qword ptr [RBP + -0x70],R12
AND R15D,R12D
CMP EAX,ESI
CMOVC R15D,EAX
MOV RAX,R15
SHL RAX,0x4
LEA R12,[RAX + R13*0x1]
CMP qword ptr [R13 + RAX*0x1 + 0x8],RBX
JZ 0x00131612
MOV ECX,0xffffffff
LAB_001315f2:
MOV R15D,dword ptr [R12]
CMP R15,RCX
JZ 0x00131647
MOV RAX,R12
MOV RDX,R15
SHL RDX,0x4
LEA R12,[RDX + R13*0x1]
CMP qword ptr [R13 + RDX*0x1 + 0x8],RBX
JNZ 0x001315f2
JMP 0x00131614
LAB_00131612:
XOR EAX,EAX
LAB_00131614:
DEC ESI
MOV dword ptr [R14 + 0x8],ESI
MOV ECX,dword ptr [R14 + 0xc]
SHR ECX,0x1
CMP ESI,ECX
JNC 0x00131628
MOV dword ptr [R14 + 0xc],ECX
LAB_00131628:
MOV dword ptr [R14 + 0x10],0xffffffff
MOV R9D,ESI
SHL R9,0x4
ADD R9,R13
MOV ECX,dword ptr [R12]
TEST RAX,RAX
JZ 0x0013164e
MOV dword ptr [RAX],ECX
JMP 0x00131674
LAB_00131647:
MOV AL,0x1
JMP 0x00131806
LAB_0013164e:
CMP ECX,-0x1
JZ 0x00131674
MOV RAX,RCX
SHL RAX,0x4
MOV RDX,qword ptr [R13 + RAX*0x1 + 0x8]
MOV qword ptr [R12 + 0x8],RDX
MOV EDX,dword ptr [R13 + RAX*0x1]
MOV dword ptr [R12],EDX
LEA R12,[RAX + R13*0x1]
MOV R15D,ECX
LAB_00131674:
LEA RDI,[R14 + 0x18]
CMP R12,R9
JZ 0x001317f1
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x54],R8D
MOV dword ptr [RBP + -0x50],ESI
MOV qword ptr [RBP + -0x48],R9
MOV RDI,qword ptr [R9 + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
MOV qword ptr [RBP + -0x40],RBX
JZ 0x001316b3
LEA RBX,[RBP + -0x5c]
MOV RSI,RBX
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
MOV ESI,dword ptr [RBX]
JMP 0x001316c0
LAB_001316b3:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x5c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_001316c0:
CALL qword ptr [R14 + 0x40]
MOV EBX,dword ptr [R14 + 0xc]
LEA ECX,[RBX + -0x1]
AND ECX,EAX
SHR EBX,0x1
DEC EBX
AND EBX,EAX
CMP ECX,dword ptr [R14 + 0x8]
CMOVC EBX,ECX
MOV RCX,RBX
SHL RCX,0x4
ADD RCX,R13
CMP RCX,R12
JZ 0x00131710
MOV dword ptr [RBP + -0x4c],EAX
MOV qword ptr [RBP + -0x68],RCX
MOV RDI,qword ptr [RCX + 0x8]
MOV RAX,qword ptr [R14 + 0x30]
TEST RAX,RAX
JZ 0x00131721
LEA RSI,[RBP + -0x2c]
XOR EDX,EDX
CALL RAX
MOV RDI,RAX
LEA RAX,[RBP + -0x2c]
MOV ESI,dword ptr [RAX]
JMP 0x0013172e
LAB_00131710:
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
JMP 0x001317e9
LAB_00131721:
MOV ESI,dword ptr [R14 + 0x4]
MOV dword ptr [RBP + -0x2c],ESI
MOV EAX,dword ptr [R14]
ADD RDI,RAX
LAB_0013172e:
CALL qword ptr [R14 + 0x40]
MOV ECX,dword ptr [R14 + 0x8]
MOV EDX,dword ptr [R14 + 0xc]
LEA ESI,[RDX + -0x1]
AND ESI,EAX
SHR EDX,0x1
DEC EDX
AND EDX,EAX
CMP ESI,ECX
CMOVC EDX,ESI
CMP EBX,EDX
JNZ 0x001317bd
LEA EDX,[RCX + 0x1]
MOV R9D,dword ptr [RBP + -0x4c]
MOV ESI,R9D
MOV R8D,dword ptr [RBP + -0x54]
AND ESI,R8D
MOV RDI,qword ptr [RBP + -0x70]
AND R9D,EDI
CMP ESI,EDX
CMOVC R9D,ESI
AND R8D,EAX
AND EAX,EDI
CMP R8D,EDX
CMOVC EAX,R8D
MOV EDX,0xffffffff
CMP R9D,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,qword ptr [RBP + -0x68]
JNZ 0x00131795
CMP R9D,ECX
JNZ 0x00131815
MOV EDX,EBX
LAB_00131795:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV EAX,dword ptr [RDI]
MOV ESI,R15D
LAB_001317a2:
MOV ECX,ESI
SHL RCX,0x4
MOV ESI,dword ptr [R13 + RCX*0x1]
CMP ESI,EDX
JNZ 0x001317a2
ADD R13,RCX
MOV dword ptr [R13],EAX
MOV dword ptr [RDI],R15D
JMP 0x001317e9
LAB_001317bd:
MOV RCX,qword ptr [RBP + -0x68]
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [R12],XMM0
MOV RAX,qword ptr [RBP + -0x48]
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [RCX],XMM0
LAB_001317d3:
MOV EAX,EDX
SHL RAX,0x4
MOV EDX,dword ptr [R13 + RAX*0x1]
CMP EDX,EBX
JNZ 0x001317d3
LAB_001317e2:
ADD R13,RAX
MOV dword ptr [R13],R15D
LAB_001317e9:
MOV RBX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RBP + -0x38]
LAB_001317f1:
CALL 0x00130311
MOV RAX,qword ptr [R14 + 0x38]
TEST RAX,RAX
JZ 0x00131804
MOV RDI,RBX
CALL RAX
LAB_00131804:
XOR EAX,EAX
LAB_00131806:
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
LAB_00131814:
RET
LAB_00131815:
MOVUPS XMM0,xmmword ptr [RAX]
MOVUPS xmmword ptr [R12],XMM0
MOV ECX,dword ptr [RBP + -0x50]
LAB_00131820:
MOV EAX,EBX
SHL RAX,0x4
MOV EBX,dword ptr [R13 + RAX*0x1]
CMP EBX,ECX
JNZ 0x00131820
JMP 0x001317e2
|
int8 ma_hashtbl_delete(uint *param_1,long param_2)
{
long lVar1;
int8 uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
long lVar6;
uint *puVar7;
ulong uVar8;
uint uVar9;
uint uVar10;
uint *puVar11;
uint uVar12;
uint *puVar13;
ulong uVar14;
uint local_64;
uint local_60;
uint local_5c;
uint local_58;
uint local_54;
uint *local_50;
long local_48;
uint *local_40;
uint local_34;
if (param_1[2] == 0) {
return 1;
}
uVar9 = param_1[3];
lVar1 = *(long *)(param_1 + 6);
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_60 = param_1[1];
lVar6 = (ulong)*param_1 + param_2;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(param_2,&local_60,0);
}
uVar3 = (**(code **)(param_1 + 0x10))(lVar6,local_60);
uVar4 = uVar9 - 1;
uVar12 = (uVar9 >> 1) - 1;
uVar9 = uVar3 & uVar12;
if ((uVar3 & uVar4) < param_1[2]) {
uVar9 = uVar3 & uVar4;
}
uVar14 = (ulong)uVar9;
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
if (*(long *)(lVar1 + 8 + uVar14 * 0x10) == param_2) {
puVar7 = (uint *)0x0;
}
else {
do {
puVar7 = puVar13;
uVar14 = (ulong)*puVar7;
if (uVar14 == 0xffffffff) {
return 1;
}
puVar13 = (uint *)(uVar14 * 0x10 + lVar1);
} while (*(long *)(lVar1 + 8 + uVar14 * 0x10) != param_2);
}
uVar9 = param_1[2] - 1;
param_1[2] = uVar9;
if (uVar9 < param_1[3] >> 1) {
param_1[3] = param_1[3] >> 1;
}
param_1[4] = 0xffffffff;
puVar11 = (uint *)((ulong)uVar9 * 0x10 + lVar1);
uVar3 = *puVar13;
if (puVar7 == (uint *)0x0) {
if (uVar3 != 0xffffffff) {
lVar6 = (ulong)uVar3 * 0x10;
*(int8 *)(puVar13 + 2) = *(int8 *)(lVar1 + 8 + lVar6);
*puVar13 = *(uint *)(lVar1 + lVar6);
puVar13 = (uint *)(lVar6 + lVar1);
uVar14 = (ulong)uVar3;
}
}
else {
*puVar7 = uVar3;
}
puVar7 = param_1 + 6;
if (puVar13 != puVar11) {
local_5c = uVar4;
local_58 = uVar9;
local_50 = puVar11;
local_48 = param_2;
local_40 = puVar7;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_64 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_64,0);
}
uVar4 = (**(code **)(param_1 + 0x10))(lVar6,local_64);
uVar3 = param_1[3] - 1 & uVar4;
uVar9 = (param_1[3] >> 1) - 1 & uVar4;
if (uVar3 < param_1[2]) {
uVar9 = uVar3;
}
uVar8 = (ulong)uVar9;
puVar11 = (uint *)(uVar8 * 0x10 + lVar1);
if (puVar11 == puVar13) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
param_2 = local_48;
puVar7 = local_40;
}
else {
local_54 = uVar4;
if (*(code **)(param_1 + 0xc) == (code *)0x0) {
local_34 = param_1[1];
lVar6 = *(long *)(puVar11 + 2) + (ulong)*param_1;
}
else {
lVar6 = (**(code **)(param_1 + 0xc))(*(long *)(puVar11 + 2),&local_34,0);
}
uVar5 = (**(code **)(param_1 + 0x10))(lVar6,local_34);
uVar4 = param_1[2];
uVar10 = param_1[3] - 1 & uVar5;
uVar3 = (param_1[3] >> 1) - 1 & uVar5;
if (uVar10 < uVar4) {
uVar3 = uVar10;
}
uVar10 = (uint)uVar14;
param_2 = local_48;
puVar7 = local_40;
if (uVar9 == uVar3) {
uVar3 = local_54 & uVar12;
if ((local_54 & local_5c) < uVar4 + 1) {
uVar3 = local_54 & local_5c;
}
uVar12 = uVar5 & uVar12;
if ((local_5c & uVar5) < uVar4 + 1) {
uVar12 = local_5c & uVar5;
}
uVar5 = 0xffffffff;
if ((uVar3 != uVar12) || (uVar5 = uVar9, uVar3 == uVar4)) {
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar14 * 0x10;
uVar9 = *(uint *)(lVar1 + lVar6);
uVar14 = (ulong)uVar9;
} while (uVar9 != uVar5);
*(uint *)(lVar1 + lVar6) = *puVar11;
*puVar11 = uVar10;
goto LAB_001317f1;
}
uVar9 = local_50[1];
uVar4 = local_50[2];
uVar3 = local_50[3];
*puVar13 = *local_50;
puVar13[1] = uVar9;
puVar13[2] = uVar4;
puVar13[3] = uVar3;
do {
lVar6 = uVar8 * 0x10;
uVar8 = (ulong)*(uint *)(lVar1 + lVar6);
} while (*(uint *)(lVar1 + lVar6) != local_58);
}
else {
uVar2 = *(int8 *)(puVar11 + 2);
*(int8 *)puVar13 = *(int8 *)puVar11;
*(int8 *)(puVar13 + 2) = uVar2;
uVar4 = local_50[1];
uVar12 = local_50[2];
uVar5 = local_50[3];
*puVar11 = *local_50;
puVar11[1] = uVar4;
puVar11[2] = uVar12;
puVar11[3] = uVar5;
do {
lVar6 = (ulong)uVar3 * 0x10;
uVar3 = *(uint *)(lVar1 + lVar6);
} while (uVar3 != uVar9);
}
*(uint *)(lVar1 + lVar6) = uVar10;
}
}
LAB_001317f1:
ma_pop_dynamic(puVar7);
if (*(code **)(param_1 + 0xe) != (code *)0x0) {
(**(code **)(param_1 + 0xe))(param_2);
}
return 0;
}
| |
24,962 | spdlog::details::mdc_formatter<spdlog::details::null_scoped_padder>::format_mdc(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/pattern_formatter-inl.h | void format_mdc(const mdc::mdc_map_t &mdc_map, memory_buf_t &dest) {
auto last_element = --mdc_map.end();
for (auto it = mdc_map.begin(); it != mdc_map.end(); ++it) {
auto &pair = *it;
const auto &key = pair.first;
const auto &value = pair.second;
size_t content_size = key.size() + value.size() + 1; // 1 for ':'
if (it != last_element) {
content_size++; // 1 for ' '
}
ScopedPadder p(content_size, padinfo_, dest);
fmt_helper::append_string_view(key, dest);
fmt_helper::append_string_view(":", dest);
fmt_helper::append_string_view(value, dest);
if (it != last_element) {
fmt_helper::append_string_view(" ", dest);
}
}
} | O3 | c | spdlog::details::mdc_formatter<spdlog::details::null_scoped_padder>::format_mdc(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&, fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rsi), %r15
movq %r15, %rdi
callq 0x11c90
movq 0x18(%r13), %r13
cmpq %r15, %r13
je 0x38064
movq %rax, %r12
addq $0x8, %r14
movq %rsp, %rbp
movq 0x28(%r13), %rax
movq 0x48(%r13), %rcx
xorl %edx, %edx
cmpq %r12, %r13
sete %dl
subq %rdx, %rax
leaq (%rcx,%rax), %rsi
addq $0x2, %rsi
movq %rbp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3535e
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2fac6
movq %rbx, %rdi
leaq 0x4fa13(%rip), %rsi # 0x87a21
leaq 0x4fa0d(%rip), %rdx # 0x87a22
callq 0x2fac6
movq 0x40(%r13), %rsi
movq 0x48(%r13), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2fac6
cmpq %r12, %r13
je 0x38048
movq %rbx, %rdi
leaq 0x4ed7b(%rip), %rsi # 0x86db7
leaq 0x4ed75(%rip), %rdx # 0x86db8
callq 0x2fac6
movq %rbp, %rdi
callq 0x353d2
movq %r13, %rdi
callq 0x11aa0
movq %rax, %r13
cmpq %r15, %rax
jne 0x37fc8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x353d2
movq %rbx, %rdi
callq 0x11760
| _ZN6spdlog7details13mdc_formatterINS0_13scoped_padderEE10format_mdcERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_St4lessISA_ESaISt4pairIKSA_SA_EEERN3fmt3v1019basic_memory_bufferIcLm250ES9_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov rbx, rdx
mov r13, rsi
mov r14, rdi
lea r15, [rsi+8]
mov rdi, r15
call __ZSt18_Rb_tree_decrementPKSt18_Rb_tree_node_base; std::_Rb_tree_decrement(std::_Rb_tree_node_base const*)
mov r13, [r13+18h]
cmp r13, r15
jz loc_38064
mov r12, rax
add r14, 8
mov rbp, rsp
loc_37FC8:
mov rax, [r13+28h]
mov rcx, [r13+48h]
xor edx, edx
cmp r13, r12
setz dl
sub rax, rdx
lea rsi, [rcx+rax]
add rsi, 2
mov rdi, rbp
mov rdx, r14
mov rcx, rbx
call _ZN6spdlog7details13scoped_padderC2EmRKNS0_12padding_infoERN3fmt3v1019basic_memory_bufferIcLm250ESaIcEEE; spdlog::details::scoped_padder::scoped_padder(ulong,spdlog::details::padding_info const&,fmt::v10::basic_memory_buffer<char,250ul,std::allocator<char>> &)
mov rsi, [r13+20h]
mov rdx, [r13+28h]
add rdx, rsi
mov rdi, rbx
call _ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v10::detail::buffer<char>::append<char>(char const*,char const*)
mov rdi, rbx
lea rsi, aTrace+6; ":"
lea rdx, aTrace+7; ""
call _ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v10::detail::buffer<char>::append<char>(char const*,char const*)
mov rsi, [r13+40h]
mov rdx, [r13+48h]
add rdx, rsi
mov rdi, rbx
call _ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v10::detail::buffer<char>::append<char>(char const*,char const*)
cmp r13, r12
jz short loc_38048
mov rdi, rbx
lea rsi, asc_86DB5+2; " "
lea rdx, asc_86DB5+3; ""
call _ZN3fmt3v106detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v10::detail::buffer<char>::append<char>(char const*,char const*)
loc_38048:
mov rdi, rbp; this
call _ZN6spdlog7details13scoped_padderD2Ev; spdlog::details::scoped_padder::~scoped_padder()
mov rdi, r13
call __ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base const*)
mov r13, rax
cmp rax, r15
jnz loc_37FC8
loc_38064:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, rsp; this
call _ZN6spdlog7details13scoped_padderD2Ev; spdlog::details::scoped_padder::~scoped_padder()
mov rdi, rbx
call __Unwind_Resume
| long long spdlog::details::mdc_formatter<spdlog::details::scoped_padder>::format_mdc(
long long a1,
long long a2,
long long a3)
{
long long result; // rax
long long *v5; // r13
long long *v6; // r12
_QWORD v7[11]; // [rsp+0h] [rbp-58h] BYREF
result = std::_Rb_tree_decrement(a2 + 8);
v5 = *(long long **)(a2 + 24);
if ( v5 != (long long *)(a2 + 8) )
{
v6 = (long long *)result;
do
{
spdlog::details::scoped_padder::scoped_padder(v7, v5[9] + v5[5] - (v5 == v6) + 2, a1 + 8, a3);
fmt::v10::detail::buffer<char>::append<char>(a3, v5[4], v5[4] + v5[5]);
fmt::v10::detail::buffer<char>::append<char>(a3, (long long)":", (long long)"");
fmt::v10::detail::buffer<char>::append<char>(a3, v5[8], v5[8] + v5[9]);
if ( v5 != v6 )
fmt::v10::detail::buffer<char>::append<char>(a3, (long long)" ", (long long)"");
spdlog::details::scoped_padder::~scoped_padder((spdlog::details::scoped_padder *)v7);
result = std::_Rb_tree_increment(v5);
v5 = (long long *)result;
}
while ( result != a2 + 8 );
}
return result;
}
| format_mdc:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV RBX,RDX
MOV R13,RSI
MOV R14,RDI
LEA R15,[RSI + 0x8]
MOV RDI,R15
CALL 0x00111c90
MOV R13,qword ptr [R13 + 0x18]
CMP R13,R15
JZ 0x00138064
MOV R12,RAX
ADD R14,0x8
MOV RBP,RSP
LAB_00137fc8:
MOV RAX,qword ptr [R13 + 0x28]
MOV RCX,qword ptr [R13 + 0x48]
XOR EDX,EDX
CMP R13,R12
SETZ DL
SUB RAX,RDX
LEA RSI,[RCX + RAX*0x1]
ADD RSI,0x2
MOV RDI,RBP
MOV RDX,R14
MOV RCX,RBX
CALL 0x0013535e
MOV RSI,qword ptr [R13 + 0x20]
MOV RDX,qword ptr [R13 + 0x28]
ADD RDX,RSI
LAB_00137ffc:
MOV RDI,RBX
CALL 0x0012fac6
MOV RDI,RBX
LEA RSI,[0x187a21]
LEA RDX,[0x187a22]
CALL 0x0012fac6
MOV RSI,qword ptr [R13 + 0x40]
MOV RDX,qword ptr [R13 + 0x48]
ADD RDX,RSI
MOV RDI,RBX
CALL 0x0012fac6
CMP R13,R12
JZ 0x00138048
MOV RDI,RBX
LEA RSI,[0x186db7]
LEA RDX,[0x186db8]
CALL 0x0012fac6
LAB_00138048:
MOV RDI,RBP
CALL 0x001353d2
MOV RDI,R13
CALL 0x00111aa0
MOV R13,RAX
CMP RAX,R15
JNZ 0x00137fc8
LAB_00138064:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* spdlog::details::mdc_formatter<spdlog::details::scoped_padder>::format_mdc(std::map<std::__cxx11::string,
std::__cxx11::string, std::less<std::__cxx11::string >,
std::allocator<std::pair<std::__cxx11::string const, std::__cxx11::string > > > const&,
fmt::v10::basic_memory_buffer<char, 250ul, std::allocator<char> >&) */
void __thiscall
spdlog::details::mdc_formatter<spdlog::details::scoped_padder>::format_mdc
(mdc_formatter<spdlog::details::scoped_padder> *this,map *param_1,
basic_memory_buffer *param_2)
{
_Rb_tree_node_base *p_Var1;
_Rb_tree_node_base *p_Var2;
_Rb_tree_node_base *p_Var3;
scoped_padder asStack_58 [40];
p_Var1 = (_Rb_tree_node_base *)(param_1 + 8);
p_Var2 = (_Rb_tree_node_base *)std::_Rb_tree_decrement(p_Var1);
p_Var3 = *(_Rb_tree_node_base **)(param_1 + 0x18);
if (p_Var3 != p_Var1) {
do {
scoped_padder::scoped_padder
(asStack_58,
*(long *)(p_Var3 + 0x48) + (*(long *)(p_Var3 + 0x28) - (ulong)(p_Var3 == p_Var2)) +
2,this + 8,param_2);
/* try { // try from 00137ffc to 00138047 has its CatchHandler @ 00138073 */
fmt::v10::detail::buffer<char>::append<char>
((buffer<char> *)param_2,*(char **)(p_Var3 + 0x20),
*(char **)(p_Var3 + 0x20) + *(long *)(p_Var3 + 0x28));
fmt::v10::detail::buffer<char>::append<char>((buffer<char> *)param_2,":","");
fmt::v10::detail::buffer<char>::append<char>
((buffer<char> *)param_2,*(char **)(p_Var3 + 0x40),
*(char **)(p_Var3 + 0x40) + *(long *)(p_Var3 + 0x48));
if (p_Var3 != p_Var2) {
fmt::v10::detail::buffer<char>::append<char>((buffer<char> *)param_2," ","");
}
scoped_padder::~scoped_padder(asStack_58);
p_Var3 = (_Rb_tree_node_base *)std::_Rb_tree_increment(p_Var3);
} while (p_Var3 != p_Var1);
}
return;
}
| |
24,963 | my_strxfrm_pad_desc_and_reverse_nopad | eloqsql/strings/ctype-simple.c | size_t
my_strxfrm_pad_desc_and_reverse_nopad(CHARSET_INFO *cs,
uchar *str, uchar *frmend, uchar *strend,
uint nweights, uint flags, uint level)
{
if (nweights && frmend < strend && (flags & MY_STRXFRM_PAD_WITH_SPACE))
{
uint fill_length= MY_MIN((uint) (strend - frmend), nweights * cs->mbminlen);
memset(frmend, 0x00, fill_length);
frmend+= fill_length;
}
my_strxfrm_desc_and_reverse(str, frmend, flags, level);
if ((flags & MY_STRXFRM_PAD_TO_MAXLEN) && frmend < strend)
{
size_t fill_length= strend - frmend;
memset(frmend, 0x00, fill_length);
frmend= strend;
}
return frmend - str;
} | O3 | c | my_strxfrm_pad_desc_and_reverse_nopad:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r12d
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movl 0x10(%rbp), %ecx
testl %r8d, %r8d
sete %al
cmpq %r15, %rdx
setae %sil
testb $0x40, %r12b
sete %dl
orb %al, %dl
orb %sil, %dl
jne 0x94551
movl %r8d, %r13d
movl %r15d, %eax
imull 0x98(%rdi), %r13d
subl %r14d, %eax
cmpl %eax, %r13d
cmovael %eax, %r13d
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x3a3a0
movl 0x10(%rbp), %ecx
addq %r13, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
callq 0x95d92
testb %r12b, %r12b
jns 0x9457c
cmpq %r15, %r14
jae 0x9457c
movq %r15, %rdx
subq %r14, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x3a3a0
movq %r15, %r14
subq %rbx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_strxfrm_pad_desc_and_reverse_nopad:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r12d, r9d
mov r15, rcx
mov r14, rdx
mov rbx, rsi
mov ecx, [rbp+arg_0]
test r8d, r8d
setz al
cmp rdx, r15
setnb sil
test r12b, 40h
setz dl
or dl, al
or dl, sil
jnz short loc_94551
mov r13d, r8d
mov eax, r15d
imul r13d, [rdi+98h]
sub eax, r14d
cmp r13d, eax
cmovnb r13d, eax
mov rdi, r14
xor esi, esi
mov rdx, r13
call _memset
mov ecx, [rbp+arg_0]
add r14, r13
loc_94551:
mov rdi, rbx
mov rsi, r14
mov edx, r12d
call my_strxfrm_desc_and_reverse
test r12b, r12b
jns short loc_9457C
cmp r14, r15
jnb short loc_9457C
mov rdx, r15
sub rdx, r14
mov rdi, r14
xor esi, esi
call _memset
mov r14, r15
loc_9457C:
sub r14, rbx
mov rax, r14
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_strxfrm_pad_desc_and_reverse_nopad(
long long a1,
long long a2,
unsigned long long a3,
unsigned long long a4,
int a5,
unsigned int a6,
unsigned int a7)
{
unsigned long long v9; // r14
long long v10; // rcx
long long v11; // r13
v9 = a3;
v10 = a7;
if ( a3 < a4 && a5 != 0 && (a6 & 0x40) != 0 )
{
v11 = (unsigned int)(*(_DWORD *)(a1 + 152) * a5);
if ( (unsigned int)v11 >= (int)a4 - (int)a3 )
v11 = (unsigned int)(a4 - a3);
memset(a3, 0LL, v11);
v10 = a7;
v9 += v11;
}
my_strxfrm_desc_and_reverse(a2, v9, a6, v10);
if ( (a6 & 0x80u) != 0 && v9 < a4 )
{
memset(v9, 0LL, a4 - v9);
v9 = a4;
}
return v9 - a2;
}
| my_strxfrm_pad_desc_and_reverse_nopad:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R12D,R9D
MOV R15,RCX
MOV R14,RDX
MOV RBX,RSI
MOV ECX,dword ptr [RBP + 0x10]
TEST R8D,R8D
SETZ AL
CMP RDX,R15
SETNC SIL
TEST R12B,0x40
SETZ DL
OR DL,AL
OR DL,SIL
JNZ 0x00194551
MOV R13D,R8D
MOV EAX,R15D
IMUL R13D,dword ptr [RDI + 0x98]
SUB EAX,R14D
CMP R13D,EAX
CMOVNC R13D,EAX
MOV RDI,R14
XOR ESI,ESI
MOV RDX,R13
CALL 0x0013a3a0
MOV ECX,dword ptr [RBP + 0x10]
ADD R14,R13
LAB_00194551:
MOV RDI,RBX
MOV RSI,R14
MOV EDX,R12D
CALL 0x00195d92
TEST R12B,R12B
JNS 0x0019457c
CMP R14,R15
JNC 0x0019457c
MOV RDX,R15
SUB RDX,R14
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013a3a0
MOV R14,R15
LAB_0019457c:
SUB R14,RBX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_strxfrm_pad_desc_and_reverse_nopad
(long param_1,long param_2,void *param_3,void *param_4,int param_5,uint param_6,
int4 param_7)
{
uint uVar1;
uint uVar2;
if (((param_6 & 0x40) != 0 && param_5 != 0) && param_3 < param_4) {
uVar2 = param_5 * *(int *)(param_1 + 0x98);
uVar1 = (int)param_4 - (int)param_3;
if (uVar1 <= uVar2) {
uVar2 = uVar1;
}
memset(param_3,0,(ulong)uVar2);
param_3 = (void *)((long)param_3 + (ulong)uVar2);
}
my_strxfrm_desc_and_reverse(param_2,param_3,param_6,param_7);
if (((char)param_6 < '\0') && (param_3 < param_4)) {
memset(param_3,0,(long)param_4 - (long)param_3);
param_3 = param_4;
}
return (long)param_3 - param_2;
}
| |
24,964 | js_parseFloat | bluesky950520[P]quickjs/quickjs.c | static JSValue js_parseFloat(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *str;
JSValue ret;
int flags;
size_t len;
str = JS_ToCStringLen(ctx, &len, argv[0]);
if (!str)
return JS_EXCEPTION;
flags = ATOD_TRIM_SPACES | ATOD_ACCEPT_FLOAT | ATOD_ACCEPT_INFINITY;
ret = js_atof(ctx, str, len, NULL, 10, flags);
JS_FreeCString(ctx, str);
return ret;
} | O2 | c | js_parseFloat:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
movq %rsp, %rsi
callq 0x36bee
testq %rax, %rax
je 0x65e22
movq %rax, %r14
movq (%rsp), %rdx
pushq $0xa
popq %r8
pushq $0xd
popq %r9
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x36bf6
movq %rax, %r12
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b057
jmp 0x65e29
pushq $0x6
popq %r15
xorl %r12d, %r12d
movq %r12, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_parseFloat:
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
mov rsi, rsp
call JS_ToCStringLen_0
test rax, rax
jz short loc_65E22
mov r14, rax
mov rdx, [rsp+28h+var_28]
push 0Ah
pop r8
push 0Dh
pop r9
mov rdi, rbx
mov rsi, rax
xor ecx, ecx
call js_atof
mov r12, rax
mov r15, rdx
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
jmp short loc_65E29
loc_65E22:
push 6
pop r15
xor r12d, r12d
loc_65E29:
mov rax, r12
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long js_parseFloat(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v5; // rax
unsigned __int8 *v6; // rax
long long v7; // r14
long long v8; // r12
long long v10[5]; // [rsp+0h] [rbp-28h] BYREF
v10[0] = v5;
v6 = (unsigned __int8 *)JS_ToCStringLen_0(a1, v10, *a5, a5[1]);
if ( !v6 )
return 0LL;
v7 = (long long)v6;
v8 = js_atof(a1, v6, v10[0], 0LL, 0xAu, 13);
JS_FreeCString(a1, v7);
return v8;
}
| js_parseFloat:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
MOV RSI,RSP
CALL 0x00136bee
TEST RAX,RAX
JZ 0x00165e22
MOV R14,RAX
MOV RDX,qword ptr [RSP]
PUSH 0xa
POP R8
PUSH 0xd
POP R9
MOV RDI,RBX
MOV RSI,RAX
XOR ECX,ECX
CALL 0x00136bf6
MOV R12,RAX
MOV R15,RDX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b057
JMP 0x00165e29
LAB_00165e22:
PUSH 0x6
POP R15
XOR R12D,R12D
LAB_00165e29:
MOV RAX,R12
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_parseFloat(int8 param_1)
{
int8 in_RAX;
long lVar1;
int8 *in_R8;
int1 auVar2 [16];
int8 local_28;
local_28 = in_RAX;
lVar1 = JS_ToCStringLen(param_1,&local_28,*in_R8,in_R8[1]);
if (lVar1 == 0) {
auVar2 = ZEXT816(6) << 0x40;
}
else {
auVar2 = js_atof(param_1,lVar1,local_28,0,10,0xd);
JS_FreeCString(param_1,lVar1);
}
return auVar2;
}
| |
24,965 | push_short_int | bluesky950520[P]quickjs/quickjs.c | static void push_short_int(DynBuf *bc_out, int val)
{
if (val >= -1 && val <= 7) {
dbuf_putc(bc_out, OP_push_0 + val);
return;
}
if (val == (int8_t)val) {
dbuf_putc(bc_out, OP_push_i8);
dbuf_putc(bc_out, val);
return;
}
if (val == (int16_t)val) {
dbuf_putc(bc_out, OP_push_i16);
dbuf_put_u16(bc_out, val);
return;
}
dbuf_putc(bc_out, OP_push_i32);
dbuf_put_u32(bc_out, val);
} | O0 | c | push_short_int:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
jl 0xc3143
cmpl $0x7, 0xc(%rsp)
jg 0xc3143
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0xb4, %eax
movzbl %al, %esi
callq 0x249c0
jmp 0xc31c2
movl 0xc(%rsp), %eax
movl 0xc(%rsp), %ecx
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0xc3174
movq 0x10(%rsp), %rdi
movl $0xbc, %esi
callq 0x249c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movzbl %al, %esi
callq 0x249c0
jmp 0xc31c2
movl 0xc(%rsp), %eax
movl 0xc(%rsp), %ecx
movswl %cx, %ecx
cmpl %ecx, %eax
jne 0xc31a5
movq 0x10(%rsp), %rdi
movl $0xbd, %esi
callq 0x249c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movzwl %ax, %esi
callq 0x7f860
jmp 0xc31c2
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x249c0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x80420
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| push_short_int:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_C], esi
cmp [rsp+18h+var_C], 0FFFFFFFFh
jl short loc_C3143
cmp [rsp+18h+var_C], 7
jg short loc_C3143
mov rdi, [rsp+18h+var_8]
mov eax, [rsp+18h+var_C]
add eax, 0B4h
movzx esi, al
call dbuf_putc
jmp short loc_C31C2
loc_C3143:
mov eax, [rsp+18h+var_C]
mov ecx, [rsp+18h+var_C]
movsx ecx, cl
cmp eax, ecx
jnz short loc_C3174
mov rdi, [rsp+18h+var_8]
mov esi, 0BCh
call dbuf_putc
mov rdi, [rsp+18h+var_8]
mov eax, [rsp+18h+var_C]
movzx esi, al
call dbuf_putc
jmp short loc_C31C2
loc_C3174:
mov eax, [rsp+18h+var_C]
mov ecx, [rsp+18h+var_C]
movsx ecx, cx
cmp eax, ecx
jnz short loc_C31A5
mov rdi, [rsp+18h+var_8]
mov esi, 0BDh
call dbuf_putc
mov rdi, [rsp+18h+var_8]
mov eax, [rsp+18h+var_C]
movzx esi, ax
call dbuf_put_u16
jmp short loc_C31C2
loc_C31A5:
mov rdi, [rsp+18h+var_8]
mov esi, 1
call dbuf_putc
mov rdi, [rsp+18h+var_8]
mov esi, [rsp+18h+var_C]
call dbuf_put_u32
loc_C31C2:
add rsp, 18h
retn
| long long push_short_int(_QWORD *a1, int a2)
{
if ( a2 >= -1 && a2 <= 7 )
return dbuf_putc(a1, (unsigned __int8)a2 - 76);
if ( a2 == (char)a2 )
{
dbuf_putc(a1, 188);
return dbuf_putc(a1, a2);
}
else
{
dbuf_putc(a1, 1);
return dbuf_put_u32(a1, a2);
}
}
| push_short_int:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV dword ptr [RSP + 0xc],ESI
CMP dword ptr [RSP + 0xc],-0x1
JL 0x001c3143
CMP dword ptr [RSP + 0xc],0x7
JG 0x001c3143
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0xc]
ADD EAX,0xb4
MOVZX ESI,AL
CALL 0x001249c0
JMP 0x001c31c2
LAB_001c3143:
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0xc]
MOVSX ECX,CL
CMP EAX,ECX
JNZ 0x001c3174
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0xbc
CALL 0x001249c0
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0xc]
MOVZX ESI,AL
CALL 0x001249c0
JMP 0x001c31c2
LAB_001c3174:
MOV EAX,dword ptr [RSP + 0xc]
MOV ECX,dword ptr [RSP + 0xc]
MOVSX ECX,CX
CMP EAX,ECX
JNZ 0x001c31a5
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0xbd
CALL 0x001249c0
MOV RDI,qword ptr [RSP + 0x10]
MOV EAX,dword ptr [RSP + 0xc]
MOVZX ESI,AX
CALL 0x0017f860
JMP 0x001c31c2
LAB_001c31a5:
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,0x1
CALL 0x001249c0
MOV RDI,qword ptr [RSP + 0x10]
MOV ESI,dword ptr [RSP + 0xc]
CALL 0x00180420
LAB_001c31c2:
ADD RSP,0x18
RET
|
void push_short_int(int8 param_1,uint param_2)
{
if (((int)param_2 < -1) || (7 < (int)param_2)) {
if (param_2 == (int)(char)param_2) {
dbuf_putc(param_1,0xbc);
dbuf_putc(param_1,param_2 & 0xff);
}
else if (param_2 == (int)(short)param_2) {
dbuf_putc(param_1,0xbd);
dbuf_put_u16(param_1,param_2 & 0xffff);
}
else {
dbuf_putc(param_1,1);
dbuf_put_u32(param_1,param_2);
}
}
else {
dbuf_putc(param_1,param_2 + 0xb4 & 0xff);
}
return;
}
| |
24,966 | js_map_iterator_mark | bluesky950520[P]quickjs/quickjs.c | static void js_map_iterator_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSMapIteratorData *it;
it = p->u.map_iterator_data;
if (it) {
/* the record is already marked by the object */
JS_MarkValue(rt, it->obj, mark_func);
}
} | O1 | c | js_map_iterator_mark:
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x3b21d
pushq %rax
movsd (%rax), %xmm0
movl 0x8(%rax), %eax
movsd %xmm0, (%rsp)
notl %eax
testl $0xfffffffe, %eax # imm = 0xFFFFFFFE
jne 0x3b219
movq (%rsp), %rsi
callq *%rcx
addq $0x8, %rsp
retq
| js_map_iterator_mark:
mov rax, [rsi+30h]
test rax, rax
jz short locret_3B21D
push rax
movsd xmm0, qword ptr [rax]
mov eax, [rax+8]
movsd [rsp+8+var_8], xmm0
not eax
test eax, 0FFFFFFFEh
jnz short loc_3B219
mov rsi, [rsp+8+var_8]
call rcx
loc_3B219:
add rsp, 8
locret_3B21D:
retn
| long long js_map_iterator_mark(long long a1, long long a2, long long a3, long long ( *a4)(long long, long long))
{
long long result; // rax
long long v5; // [rsp+0h] [rbp-8h]
result = *(_QWORD *)(a2 + 48);
if ( result )
{
v5 = *(_QWORD *)result;
result = (unsigned int)~*(_DWORD *)(result + 8);
if ( (result & 0xFFFFFFFE) == 0 )
return a4(a1, v5);
}
return result;
}
| js_map_iterator_mark:
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x0013b21d
PUSH RAX
MOVSD XMM0,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x8]
MOVSD qword ptr [RSP],XMM0
NOT EAX
TEST EAX,0xfffffffe
JNZ 0x0013b219
MOV RSI,qword ptr [RSP]
CALL RCX
LAB_0013b219:
ADD RSP,0x8
LAB_0013b21d:
RET
|
void js_map_iterator_mark(int8 param_1,long param_2,int8 param_3,code *param_4)
{
int8 *puVar1;
puVar1 = *(int8 **)(param_2 + 0x30);
if ((puVar1 != (int8 *)0x0) && ((~*(uint *)(puVar1 + 1) & 0xfffffffe) == 0)) {
(*param_4)(param_1,*puVar1);
}
return;
}
| |
24,967 | js_map_iterator_mark | bluesky950520[P]quickjs/quickjs.c | static void js_map_iterator_mark(JSRuntime *rt, JSValue val,
JS_MarkFunc *mark_func)
{
JSObject *p = JS_VALUE_GET_OBJ(val);
JSMapIteratorData *it;
it = p->u.map_iterator_data;
if (it) {
/* the record is already marked by the object */
JS_MarkValue(rt, it->obj, mark_func);
}
} | O2 | c | js_map_iterator_mark:
movq 0x30(%rsi), %rax
testq %rax, %rax
je 0x34083
movl 0x8(%rax), %edx
notl %edx
testl $0xfffffffe, %edx # imm = 0xFFFFFFFE
jne 0x34083
movq (%rax), %rsi
jmpq *%rcx
retq
| js_map_iterator_mark:
mov rax, [rsi+30h]
test rax, rax
jz short locret_34083
mov edx, [rax+8]
not edx
test edx, 0FFFFFFFEh
jnz short locret_34083
mov rsi, [rax]
jmp rcx
locret_34083:
retn
| long long js_map_iterator_mark(long long a1, long long a2, long long a3, long long ( *a4)(long long, _QWORD))
{
long long result; // rax
result = *(_QWORD *)(a2 + 48);
if ( result )
{
if ( (~*(_DWORD *)(result + 8) & 0xFFFFFFFE) == 0 )
return a4(a1, *(_QWORD *)result);
}
return result;
}
| js_map_iterator_mark:
MOV RAX,qword ptr [RSI + 0x30]
TEST RAX,RAX
JZ 0x00134083
MOV EDX,dword ptr [RAX + 0x8]
NOT EDX
TEST EDX,0xfffffffe
JNZ 0x00134083
MOV RSI,qword ptr [RAX]
JMP RCX
LAB_00134083:
RET
|
void js_map_iterator_mark
(int8 param_1,long param_2,int8 param_3,code *UNRECOVERED_JUMPTABLE)
{
int8 *puVar1;
puVar1 = *(int8 **)(param_2 + 0x30);
if ((puVar1 != (int8 *)0x0) && ((~*(uint *)(puVar1 + 1) & 0xfffffffe) == 0)) {
/* WARNING: Could not recover jumptable at 0x00134081. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(param_1,*puVar1);
return;
}
return;
}
| |
24,968 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long) | monkey531[P]llama/common/json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x45fb6(%rip), %rsi # 0xf4ed7
leaq 0x45fb0(%rip), %rdx # 0xf4ed8
callq 0x2337c
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x22a45
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
mov qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rax, [rbx+40h]
mov [rbx+30h], rax
lea rsi, aMinExp0+0Ah; "0"
lea rdx, aMinExp0+0Bh; ""
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 rax, [rbx+60h]
mov [rbx+50h], rax
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>((_QWORD *)(a1 + 48), "0", (long long)"");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
MOV qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
LAB_001aef1a:
LEA RSI,[0x1f4ed7]
LEA RDX,[0x1f4ed8]
CALL 0x0012337c
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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> >
>::iteration_proxy_value(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> >, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<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>>>
::iteration_proxy_value
(iteration_proxy_value<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>>>
*this,int4 *param_2,int8 param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[2];
uVar4 = param_2[3];
uVar5 = param_2[5];
uVar6 = param_2[6];
uVar7 = param_2[7];
*(int4 *)(this + 0x10) = param_2[4];
*(int4 *)(this + 0x14) = uVar5;
*(int4 *)(this + 0x18) = uVar6;
*(int4 *)(this + 0x1c) = uVar7;
*(int4 *)this = uVar1;
*(int4 *)(this + 4) = uVar2;
*(int4 *)(this + 8) = uVar3;
*(int4 *)(this + 0xc) = uVar4;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
*(iteration_proxy_value<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>>>
**)(this + 0x30) = this + 0x40;
/* try { // try from 001aef1a to 001aef2c has its CatchHandler @ 001aef43 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x30,"0","");
*(iteration_proxy_value<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>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<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>>>
)0x0;
return;
}
| |
24,969 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long) | monkey531[P]llama/common/json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x306ab(%rip), %rsi # 0xb5ef3
leaq 0xf(%rsp), %rdx
callq 0x26dae
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x2766f
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m:
push rbx
sub rsp, 10h
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
and qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rsi, aMinExp0+0Ah; "0"
lea rdx, [rsp+18h+var_9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+60h]
mov [rbx+50h], rax
and qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
add rsp, 10h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
std::string::basic_string<std::allocator<char>>((_QWORD *)(a1 + 48), "0");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
AND qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LAB_00185841:
LEA RSI,[0x1b5ef3]
LEA RDX,[RSP + 0xf]
CALL 0x00126dae
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
AND qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
ADD RSP,0x10
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>
>::iteration_proxy_value(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>, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<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>>
::iteration_proxy_value
(iteration_proxy_value<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>>
*this,int8 *param_2,int8 param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
allocator local_9;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[3];
*(int8 *)(this + 0x10) = param_2[2];
*(int8 *)(this + 0x18) = uVar3;
*(int8 *)this = uVar1;
*(int8 *)(this + 8) = uVar2;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
/* try { // try from 00185841 to 00185851 has its CatchHandler @ 00185869 */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x30),"0",&local_9);
*(iteration_proxy_value<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>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<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>>
)0x0;
return;
}
| |
24,970 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long) | monkey531[P]llama/common/json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>>::iteration_proxy_value(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>>, unsigned long):
pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
leaq 0x3c468(%rip), %rsi # 0xf1ec7
leaq 0x3c462(%rip), %rdx # 0xf1ec8
callq 0x22338
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x21a05
nop
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESI_m:
push rbx
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
mov qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rax, [rbx+40h]
mov [rbx+30h], rax
lea rsi, aMinExp0+0Ah; "0"
lea rdx, aMinExp0+0Bh; ""
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 rax, [rbx+60h]
mov [rbx+50h], rax
mov qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
*(_QWORD *)(a1 + 48) = a1 + 64;
std::string::_M_construct<char const*>(a1 + 48, "0", (long long)"");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
MOV qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LEA RAX,[RBX + 0x40]
MOV qword ptr [RBX + 0x30],RAX
LAB_001b5a58:
LEA RSI,[0x1f1ec7]
LEA RDX,[0x1f1ec8]
CALL 0x00122338
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
MOV qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<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>
>::iteration_proxy_value(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>, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<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>>
::iteration_proxy_value
(iteration_proxy_value<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>>
*this,int4 *param_2,int8 param_3)
{
int4 uVar1;
int4 uVar2;
int4 uVar3;
int4 uVar4;
int4 uVar5;
int4 uVar6;
int4 uVar7;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[2];
uVar4 = param_2[3];
uVar5 = param_2[5];
uVar6 = param_2[6];
uVar7 = param_2[7];
*(int4 *)(this + 0x10) = param_2[4];
*(int4 *)(this + 0x14) = uVar5;
*(int4 *)(this + 0x18) = uVar6;
*(int4 *)(this + 0x1c) = uVar7;
*(int4 *)this = uVar1;
*(int4 *)(this + 4) = uVar2;
*(int4 *)(this + 8) = uVar3;
*(int4 *)(this + 0xc) = uVar4;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
*(iteration_proxy_value<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>>
**)(this + 0x30) = this + 0x40;
/* try { // try from 001b5a58 to 001b5a6a has its CatchHandler @ 001b5a81 */
std::__cxx11::string::_M_construct<char_const*>(this + 0x30,"0","");
*(iteration_proxy_value<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>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<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>>
)0x0;
return;
}
| |
24,971 | maria_rtree_insert_level | eloqsql/storage/maria/ma_rt_index.c | int maria_rtree_insert_level(MARIA_HA *info, MARIA_KEY *key, int ins_level,
my_off_t *root)
{
my_off_t old_root;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
int res;
my_off_t new_page;
enum pagecache_page_lock write_lock;
DBUG_ENTER("maria_rtree_insert_level");
if ((old_root= share->state.key_root[keyinfo->key_nr]) == HA_OFFSET_ERROR)
{
MARIA_PINNED_PAGE tmp_page_link, *page_link;
MARIA_PAGE page;
page_link= &tmp_page_link;
if ((old_root= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==
HA_OFFSET_ERROR)
DBUG_RETURN(-1);
write_lock= page_link->write_lock;
info->keyread_buff_used= 1;
bzero(info->buff, share->block_size);
_ma_store_keynr(share, info->buff, keyinfo->key_nr);
_ma_store_page_used(share, info->buff, share->keypage_header);
_ma_page_setup(&page, info, keyinfo, old_root, info->buff);
if (share->now_transactional && _ma_log_new(&page, 1))
DBUG_RETURN(1);
res= maria_rtree_add_key(key, &page, NULL);
if (_ma_write_keypage(&page, write_lock, DFLT_INIT_HITS))
DBUG_RETURN(1);
*root= old_root;
DBUG_RETURN(res);
}
switch ((res= maria_rtree_insert_req(info, key, old_root, &new_page,
ins_level, 0)))
{
case 0: /* root was not split */
{
break;
}
case 1: /* root was split, grow a new root; very rare */
{
uchar *new_root_buf, *new_key_buff;
my_bool new_root_buf_alloced;
my_off_t new_root;
uint nod_flag= share->base.key_reflength;
MARIA_PINNED_PAGE tmp_page_link, *page_link;
MARIA_KEY new_key;
MARIA_PAGE page;
page_link= &tmp_page_link;
DBUG_PRINT("rtree", ("root was split, grow a new root"));
alloc_on_stack(*info->stack_end_ptr, new_root_buf, new_root_buf_alloced,
keyinfo->block_length + keyinfo->max_store_length);
if (!new_root_buf)
{
my_errno= HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1); /* purecov: inspected */
}
bzero(new_root_buf, keyinfo->block_length);
_ma_store_keypage_flag(share, new_root_buf, KEYPAGE_FLAG_ISNOD);
_ma_store_keynr(share, new_root_buf, keyinfo->key_nr);
_ma_store_page_used(share, new_root_buf, share->keypage_header);
if ((new_root= _ma_new(info, DFLT_INIT_HITS, &page_link)) ==
HA_OFFSET_ERROR)
goto err;
write_lock= page_link->write_lock;
_ma_page_setup(&page, info, keyinfo, new_root, new_root_buf);
if (share->now_transactional && _ma_log_new(&page, 1))
goto err;
/* Point to some free space */
new_key_buff= new_root_buf + keyinfo->block_length + nod_flag;
new_key.keyinfo= keyinfo;
new_key.data= new_key_buff;
new_key.data_length= key->data_length;
new_key.ref_length= key->ref_length;
new_key.flag= 0;
_ma_kpointer(info, new_key_buff - nod_flag, old_root);
if (maria_rtree_set_key_mbr(info, &new_key, old_root))
goto err;
if (maria_rtree_add_key(&new_key, &page, NULL) == -1)
goto err;
_ma_kpointer(info, new_key_buff - nod_flag, new_page);
if (maria_rtree_set_key_mbr(info, &new_key, new_page))
goto err;
if (maria_rtree_add_key(&new_key, &page, NULL) == -1)
goto err;
if (_ma_write_keypage(&page, write_lock, DFLT_INIT_HITS))
goto err;
*root= new_root;
DBUG_PRINT("rtree", ("new root page: %lu level: %d nod_flag: %u",
(ulong) new_root, 0, page.node));
stack_alloc_free(new_root_buf, new_root_buf_alloced);
break;
err:
stack_alloc_free(new_root_buf, new_root_buf_alloced);
DBUG_RETURN(-1); /* purecov: inspected */
}
default:
case -1: /* error */
{
DBUG_ASSERT(0);
break;
}
}
DBUG_RETURN(res);
} | O3 | c | maria_rtree_insert_level:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %r15
movq 0x8(%rsi), %r12
movq 0x118(%r15), %rax
movzbl 0xa5(%r12), %ecx
movq (%rax,%rcx,8), %r13
cmpq $-0x1, %r13
movq %rsi, -0x58(%rbp)
je 0x64c17
movl %edx, %r8d
movq %rbx, -0x40(%rbp)
leaq -0x68(%rbp), %rcx
movq %r14, %rdi
movq %r13, %rdx
xorl %r9d, %r9d
callq 0x64f45
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x64e7b
movl 0x3e4(%r15), %eax
movq %rax, -0x70(%rbp)
leaq -0xe8(%rbp), %rax
movq %rax, -0x60(%rbp)
movzwl 0xa6(%r12), %edx
movzwl 0xb0(%r12), %esi
addq %rdx, %rsi
leaq -0xd0(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%r14), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x64d38
cmpq $0x10000, %rax # imm = 0x10000
ja 0x64bfe
cmpl $0x1000, %esi # imm = 0x1000
jb 0x64d38
cmpq $0x8001, %rax # imm = 0x8001
jb 0x64d38
movq %rsp, %rbx
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %rbx
movq %rbx, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x64d60
leaq -0x90(%rbp), %rax
leaq -0xe8(%rbp), %rdx
movq %rax, (%rdx)
movq %r14, %rdi
movl $0x3, %esi
callq 0x724e7
cmpq $-0x1, %rax
je 0x64e76
movq %rax, %r13
movq %rbx, -0x40(%rbp)
movq -0xe8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movb $0x1, 0x685(%r14)
movq 0x378(%r14), %rdi
movl 0x7bc(%r15), %edx
xorl %esi, %esi
callq 0x2a2c0
movb 0xa5(%r12), %al
movq 0x378(%r14), %rcx
movl 0x744(%r15), %edx
addl $-0x4, %edx
movb %al, (%rcx,%rdx)
movl 0x744(%r15), %eax
movq 0x378(%r14), %rcx
movb %al, -0x1(%rcx,%rax)
movq 0x378(%r14), %rcx
movl 0x744(%r15), %edx
movb %ah, -0x2(%rcx,%rdx)
movq 0x378(%r14), %r8
leaq -0xc8(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x7206c
cmpb $0x0, 0x7e7(%r15)
je 0x64cf4
leaq -0xc8(%rbp), %rdi
movl $0x1, %ebx
movl $0x1, %esi
callq 0x594c4
testb %al, %al
jne 0x64e7b
leaq -0xc8(%rbp), %rbx
movq -0x58(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x661ac
movl %eax, %r14d
movq %rbx, %rdi
movl -0x34(%rbp), %esi
movl $0x3, %edx
callq 0x721fd
movl $0x1, %ebx
testb %al, %al
jne 0x64e7b
movq -0x40(%rbp), %rax
movq %r13, (%rax)
movl %r14d, %ebx
jmp 0x64e7b
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0xa63e5
testq %rax, %rax
je 0x64e6b
movq %rax, %rbx
movzwl 0xa6(%r12), %edx
movl $0x0, -0x34(%rbp)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2a2c0
movl 0x744(%r15), %eax
addl $-0x3, %eax
movb $0x1, (%rbx,%rax)
movb 0xa5(%r12), %al
movl 0x744(%r15), %ecx
addl $-0x4, %ecx
movb %al, (%rbx,%rcx)
movl 0x744(%r15), %eax
movb %al, -0x1(%rbx,%rax)
movl 0x744(%r15), %ecx
movb %ah, -0x2(%rbx,%rcx)
leaq -0x60(%rbp), %rdx
movq %r14, %rdi
movl $0x3, %esi
callq 0x724e7
movq %rax, -0x50(%rbp)
cmpq $-0x1, %rax
je 0x64e5b
movq -0x60(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
movq %r14, %rsi
movq %r12, %rdx
movq -0x50(%rbp), %rcx
movq %rbx, %r8
callq 0x7206c
cmpb $0x0, 0x7e7(%r15)
je 0x64e04
leaq -0xc8(%rbp), %rdi
movl $0x1, %esi
callq 0x594c4
testb %al, %al
jne 0x64e5b
movzwl 0xa6(%r12), %r15d
addq %rbx, %r15
movq -0x70(%rbp), %rax
addq %r15, %rax
leaq -0x90(%rbp), %rcx
movq %r12, 0x8(%rcx)
movq %rax, (%rcx)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rcx)
movl $0x0, 0x18(%rcx)
movq %rcx, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x7017d
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x6634b
testl %eax, %eax
je 0x64e9f
cmpb $0x0, -0x34(%rbp)
jne 0x64e76
movq %rbx, %rdi
callq 0xa6612
jmp 0x64e76
callq 0xa8156
movl $0x80, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x64f40
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x90(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
xorl %edx, %edx
callq 0x661ac
cmpl $-0x1, %eax
je 0x64e5b
movq -0x68(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7017d
movq -0x68(%rbp), %rdx
leaq -0x90(%rbp), %rsi
movq %r14, %rdi
callq 0x6634b
testl %eax, %eax
jne 0x64e5b
leaq -0x90(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
xorl %edx, %edx
callq 0x661ac
cmpl $-0x1, %eax
je 0x64e5b
leaq -0xc8(%rbp), %rdi
movl -0x44(%rbp), %esi
movl $0x3, %edx
callq 0x721fd
testb %al, %al
jne 0x64e5b
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
cmpb $0x0, -0x34(%rbp)
jne 0x64f36
movq %rbx, %rdi
callq 0xa6612
movl $0x1, %ebx
jmp 0x64e7b
callq 0x2a270
| maria_rtree_insert_level:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rbx, rcx
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r15, [rdi]
mov r12, [rsi+8]
mov rax, [r15+118h]
movzx ecx, byte ptr [r12+0A5h]
mov r13, [rax+rcx*8]
cmp r13, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rsi
jz loc_64C17
mov r8d, edx
mov [rbp+var_40], rbx
lea rcx, [rbp+var_68]
mov rdi, r14
mov rdx, r13
xor r9d, r9d
call maria_rtree_insert_req
mov ebx, eax
cmp eax, 1
jnz loc_64E7B
mov eax, [r15+3E4h]
mov [rbp+var_70], rax
lea rax, [rbp+var_E8]
mov [rbp+var_60], rax
movzx edx, word ptr [r12+0A6h]
movzx esi, word ptr [r12+0B0h]
add rsi, rdx
lea rcx, [rbp+var_D0]
mov [rcx], rsi
mov rax, [r14+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe loc_64D38
cmp rax, offset stru_10000
ja short loc_64BFE
cmp esi, 1000h
jb loc_64D38
cmp rax, 8001h
jb loc_64D38
loc_64BFE:
mov rbx, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub rbx, rsi
mov rsp, rbx
mov al, 1
mov [rbp+var_34], eax
jmp loc_64D60
loc_64C17:
lea rax, [rbp+var_90]
lea rdx, [rbp+var_E8]
mov [rdx], rax
mov rdi, r14
mov esi, 3
call _ma_new
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_64E76
mov r13, rax
mov [rbp+var_40], rbx
mov rax, [rbp+var_E8]
mov eax, [rax+0Ch]
mov [rbp+var_34], eax
mov byte ptr [r14+685h], 1
mov rdi, [r14+378h]
mov edx, [r15+7BCh]
xor esi, esi
call _memset
mov al, [r12+0A5h]
mov rcx, [r14+378h]
mov edx, [r15+744h]
add edx, 0FFFFFFFCh
mov [rcx+rdx], al
mov eax, [r15+744h]
mov rcx, [r14+378h]
mov [rcx+rax-1], al
mov rcx, [r14+378h]
mov edx, [r15+744h]
mov [rcx+rdx-2], ah
mov r8, [r14+378h]
lea rdi, [rbp+var_C8]
mov rsi, r14
mov rdx, r12
mov rcx, r13
call _ma_page_setup
cmp byte ptr [r15+7E7h], 0
jz short loc_64CF4
lea rdi, [rbp+var_C8]
mov ebx, 1
mov esi, 1
call _ma_log_new
test al, al
jnz loc_64E7B
loc_64CF4:
lea rbx, [rbp+var_C8]
mov rdi, [rbp+var_58]
mov rsi, rbx
xor edx, edx
call maria_rtree_add_key
mov r14d, eax
mov rdi, rbx
mov esi, [rbp+var_34]
mov edx, 3
call _ma_write_keypage
mov ebx, 1
test al, al
jnz loc_64E7B
mov rax, [rbp+var_40]
mov [rax], r13
mov ebx, r14d
jmp loc_64E7B
loc_64D38:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_64E6B
mov rbx, rax
movzx edx, word ptr [r12+0A6h]
mov [rbp+var_34], 0
loc_64D60:
mov rdi, rbx
xor esi, esi
call _memset
mov eax, [r15+744h]
add eax, 0FFFFFFFDh
mov byte ptr [rbx+rax], 1
mov al, [r12+0A5h]
mov ecx, [r15+744h]
add ecx, 0FFFFFFFCh
mov [rbx+rcx], al
mov eax, [r15+744h]
mov [rbx+rax-1], al
mov ecx, [r15+744h]
mov [rbx+rcx-2], ah
lea rdx, [rbp+var_60]
mov rdi, r14
mov esi, 3
call _ma_new
mov [rbp+var_50], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jz loc_64E5B
mov rax, [rbp+var_60]
mov eax, [rax+0Ch]
mov [rbp+var_44], eax
lea rdi, [rbp+var_C8]
mov rsi, r14
mov rdx, r12
mov rcx, [rbp+var_50]
mov r8, rbx
call _ma_page_setup
cmp byte ptr [r15+7E7h], 0
jz short loc_64E04
lea rdi, [rbp+var_C8]
mov esi, 1
call _ma_log_new
test al, al
jnz short loc_64E5B
loc_64E04:
movzx r15d, word ptr [r12+0A6h]
add r15, rbx
mov rax, [rbp+var_70]
add rax, r15
lea rcx, [rbp+var_90]
mov [rcx+8], r12
mov [rcx], rax
mov rax, [rbp+var_58]
mov rax, [rax+10h]
mov [rcx+10h], rax
mov dword ptr [rcx+18h], 0
mov r12, rcx
mov rdi, r14
mov rsi, r15
mov rdx, r13
call _ma_kpointer
mov rdi, r14
mov rsi, r12
mov rdx, r13
call maria_rtree_set_key_mbr
test eax, eax
jz short loc_64E9F
loc_64E5B:
cmp byte ptr [rbp+var_34], 0
jnz short loc_64E76
mov rdi, rbx
call my_free
jmp short loc_64E76
loc_64E6B:
call _my_thread_var
mov dword ptr [rax], 80h
loc_64E76:
mov ebx, 0FFFFFFFFh
loc_64E7B:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_64F40
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_64E9F:
lea rdi, [rbp+var_90]
lea rsi, [rbp+var_C8]
xor edx, edx
call maria_rtree_add_key
cmp eax, 0FFFFFFFFh
jz short loc_64E5B
mov rdx, [rbp+var_68]
mov rdi, r14
mov rsi, r15
call _ma_kpointer
mov rdx, [rbp+var_68]
lea rsi, [rbp+var_90]
mov rdi, r14
call maria_rtree_set_key_mbr
test eax, eax
jnz loc_64E5B
lea rdi, [rbp+var_90]
lea rsi, [rbp+var_C8]
xor edx, edx
call maria_rtree_add_key
cmp eax, 0FFFFFFFFh
jz loc_64E5B
lea rdi, [rbp+var_C8]
mov esi, [rbp+var_44]
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_64E5B
mov rax, [rbp+var_40]
mov rcx, [rbp+var_50]
mov [rax], rcx
cmp byte ptr [rbp+var_34], 0
jnz short loc_64F36
mov rdi, rbx
call my_free
loc_64F36:
mov ebx, 1
jmp loc_64E7B
loc_64F40:
call ___stack_chk_fail
| long long maria_rtree_insert_level(long long *a1, long long a2, unsigned int a3, long long *a4)
{
long long v5; // r15
long long v6; // r12
long long v7; // r13
unsigned int inserted; // ebx
long long v9; // rdx
unsigned long long v10; // rsi
unsigned long long v11; // rax
bool v12; // cc
unsigned long long v13; // rax
char *v14; // rbx
long long v15; // rax
long long v16; // r13
long long v17; // rax
unsigned int v18; // r14d
long long v19; // rax
long long v20; // rax
char *v21; // r15
_QWORD v24[3]; // [rsp+8h] [rbp-E8h] BYREF
unsigned long long v25; // [rsp+20h] [rbp-D0h] BYREF
long long *v26[7]; // [rsp+28h] [rbp-C8h] BYREF
_QWORD v27[3]; // [rsp+60h] [rbp-90h] BYREF
int v28; // [rsp+78h] [rbp-78h]
long long v29; // [rsp+80h] [rbp-70h]
long long v30; // [rsp+88h] [rbp-68h] BYREF
_QWORD *v31; // [rsp+90h] [rbp-60h] BYREF
long long v32; // [rsp+98h] [rbp-58h]
long long v33; // [rsp+A0h] [rbp-50h]
unsigned int v34; // [rsp+ACh] [rbp-44h]
long long *v35; // [rsp+B0h] [rbp-40h]
unsigned int v36; // [rsp+BCh] [rbp-34h]
unsigned long long v37; // [rsp+C0h] [rbp-30h]
v37 = __readfsqword(0x28u);
v5 = *a1;
v6 = *(_QWORD *)(a2 + 8);
v7 = *(_QWORD *)(*(_QWORD *)(*a1 + 280) + 8LL * *(unsigned __int8 *)(v6 + 165));
v32 = a2;
if ( v7 != -1 )
{
v35 = a4;
inserted = maria_rtree_insert_req(a1, a2, v7, &v30, a3, 0LL);
if ( inserted != 1 )
return inserted;
v29 = *(unsigned int *)(v5 + 996);
v31 = v24;
v9 = *(unsigned __int16 *)(v6 + 166);
v10 = v9 + *(unsigned __int16 *)(v6 + 176);
v25 = v10;
v11 = *(_QWORD *)a1[15] - (_QWORD)&v25;
v12 = v11 <= v10;
v13 = v11 - v10;
if ( v12 || v13 <= (unsigned long long)&stru_10000 && ((unsigned int)v10 < 0x1000 || v13 < 0x8001) )
{
v19 = my_malloc(0LL, v10, 65552LL);
if ( !v19 )
{
*(_DWORD *)my_thread_var(0LL) = 128;
return (unsigned int)-1;
}
v14 = (char *)v19;
v9 = *(unsigned __int16 *)(v6 + 166);
v36 = 0;
}
else
{
v14 = (char *)&v24[-1] - (((_DWORD)v10 + 15) & 0xFFFFFFF0);
LOBYTE(v13) = 1;
v36 = v13;
}
memset(v14, 0LL, v9);
v14[*(_DWORD *)(v5 + 1860) - 3] = 1;
v14[*(_DWORD *)(v5 + 1860) - 4] = *(_BYTE *)(v6 + 165);
v20 = *(unsigned int *)(v5 + 1860);
v14[v20 - 1] = v20;
v14[*(unsigned int *)(v5 + 1860) - 2] = BYTE1(v20);
v33 = ma_new(a1, 3LL, &v31);
if ( v33 != -1 )
{
v34 = *((_DWORD *)v31 + 3);
ma_page_setup(v26, a1, v6, v33, v14);
if ( !*(_BYTE *)(v5 + 2023) || !ma_log_new(v26, 1) )
{
v21 = &v14[*(unsigned __int16 *)(v6 + 166)];
v27[1] = v6;
v27[0] = &v21[v29];
v27[2] = *(_QWORD *)(v32 + 16);
v28 = 0;
ma_kpointer(a1, v21);
if ( !(unsigned int)maria_rtree_set_key_mbr(a1, v27, v7)
&& (unsigned int)maria_rtree_add_key(v27, v26, 0LL) != -1 )
{
ma_kpointer(a1, v21);
if ( !(unsigned int)maria_rtree_set_key_mbr(a1, v27, v30)
&& (unsigned int)maria_rtree_add_key(v27, v26, 0LL) != -1
&& !(unsigned __int8)ma_write_keypage(v26, v34, 3LL) )
{
*v35 = v33;
if ( !(_BYTE)v36 )
my_free(v14);
return 1;
}
}
}
}
if ( !(_BYTE)v36 )
my_free(v14);
return (unsigned int)-1;
}
v24[0] = v27;
v15 = ma_new(a1, 3LL, v24);
if ( v15 == -1 )
return (unsigned int)-1;
v16 = v15;
v35 = a4;
v36 = *(_DWORD *)(v24[0] + 12LL);
*((_BYTE *)a1 + 1669) = 1;
memset(a1[111], 0LL, *(unsigned int *)(v5 + 1980));
*(_BYTE *)(a1[111] + (unsigned int)(*(_DWORD *)(v5 + 1860) - 4)) = *(_BYTE *)(v6 + 165);
v17 = *(unsigned int *)(v5 + 1860);
*(_BYTE *)(a1[111] + v17 - 1) = v17;
*(_BYTE *)(a1[111] + *(unsigned int *)(v5 + 1860) - 2) = BYTE1(v17);
ma_page_setup(v26, a1, v6, v16, a1[111]);
if ( !*(_BYTE *)(v5 + 2023) || (inserted = 1, !ma_log_new(v26, 1)) )
{
v18 = maria_rtree_add_key(v32, v26, 0LL);
inserted = 1;
if ( !(unsigned __int8)ma_write_keypage(v26, v36, 3LL) )
{
*v35 = v16;
return v18;
}
}
return inserted;
}
| maria_rtree_insert_level:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RBX,RCX
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R15,qword ptr [RDI]
MOV R12,qword ptr [RSI + 0x8]
MOV RAX,qword ptr [R15 + 0x118]
MOVZX ECX,byte ptr [R12 + 0xa5]
MOV R13,qword ptr [RAX + RCX*0x8]
CMP R13,-0x1
MOV qword ptr [RBP + -0x58],RSI
JZ 0x00164c17
MOV R8D,EDX
MOV qword ptr [RBP + -0x40],RBX
LEA RCX,[RBP + -0x68]
MOV RDI,R14
MOV RDX,R13
XOR R9D,R9D
CALL 0x00164f45
MOV EBX,EAX
CMP EAX,0x1
JNZ 0x00164e7b
MOV EAX,dword ptr [R15 + 0x3e4]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[RBP + -0xe8]
MOV qword ptr [RBP + -0x60],RAX
MOVZX EDX,word ptr [R12 + 0xa6]
MOVZX ESI,word ptr [R12 + 0xb0]
ADD RSI,RDX
LEA RCX,[RBP + -0xd0]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [R14 + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x00164d38
CMP RAX,0x10000
JA 0x00164bfe
CMP ESI,0x1000
JC 0x00164d38
CMP RAX,0x8001
JC 0x00164d38
LAB_00164bfe:
MOV RBX,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB RBX,RSI
MOV RSP,RBX
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00164d60
LAB_00164c17:
LEA RAX,[RBP + -0x90]
LEA RDX,[RBP + -0xe8]
MOV qword ptr [RDX],RAX
MOV RDI,R14
MOV ESI,0x3
CALL 0x001724e7
CMP RAX,-0x1
JZ 0x00164e76
MOV R13,RAX
MOV qword ptr [RBP + -0x40],RBX
MOV RAX,qword ptr [RBP + -0xe8]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x34],EAX
MOV byte ptr [R14 + 0x685],0x1
MOV RDI,qword ptr [R14 + 0x378]
MOV EDX,dword ptr [R15 + 0x7bc]
XOR ESI,ESI
CALL 0x0012a2c0
MOV AL,byte ptr [R12 + 0xa5]
MOV RCX,qword ptr [R14 + 0x378]
MOV EDX,dword ptr [R15 + 0x744]
ADD EDX,-0x4
MOV byte ptr [RCX + RDX*0x1],AL
MOV EAX,dword ptr [R15 + 0x744]
MOV RCX,qword ptr [R14 + 0x378]
MOV byte ptr [RCX + RAX*0x1 + -0x1],AL
MOV RCX,qword ptr [R14 + 0x378]
MOV EDX,dword ptr [R15 + 0x744]
MOV byte ptr [RCX + RDX*0x1 + -0x2],AH
MOV R8,qword ptr [R14 + 0x378]
LEA RDI,[RBP + -0xc8]
MOV RSI,R14
MOV RDX,R12
MOV RCX,R13
CALL 0x0017206c
CMP byte ptr [R15 + 0x7e7],0x0
JZ 0x00164cf4
LEA RDI,[RBP + -0xc8]
MOV EBX,0x1
MOV ESI,0x1
CALL 0x001594c4
TEST AL,AL
JNZ 0x00164e7b
LAB_00164cf4:
LEA RBX,[RBP + -0xc8]
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,RBX
XOR EDX,EDX
CALL 0x001661ac
MOV R14D,EAX
MOV RDI,RBX
MOV ESI,dword ptr [RBP + -0x34]
MOV EDX,0x3
CALL 0x001721fd
MOV EBX,0x1
TEST AL,AL
JNZ 0x00164e7b
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],R13
MOV EBX,R14D
JMP 0x00164e7b
LAB_00164d38:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x001a63e5
TEST RAX,RAX
JZ 0x00164e6b
MOV RBX,RAX
MOVZX EDX,word ptr [R12 + 0xa6]
MOV dword ptr [RBP + -0x34],0x0
LAB_00164d60:
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0012a2c0
MOV EAX,dword ptr [R15 + 0x744]
ADD EAX,-0x3
MOV byte ptr [RBX + RAX*0x1],0x1
MOV AL,byte ptr [R12 + 0xa5]
MOV ECX,dword ptr [R15 + 0x744]
ADD ECX,-0x4
MOV byte ptr [RBX + RCX*0x1],AL
MOV EAX,dword ptr [R15 + 0x744]
MOV byte ptr [RBX + RAX*0x1 + -0x1],AL
MOV ECX,dword ptr [R15 + 0x744]
MOV byte ptr [RBX + RCX*0x1 + -0x2],AH
LEA RDX,[RBP + -0x60]
MOV RDI,R14
MOV ESI,0x3
CALL 0x001724e7
MOV qword ptr [RBP + -0x50],RAX
CMP RAX,-0x1
JZ 0x00164e5b
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x44],EAX
LEA RDI,[RBP + -0xc8]
MOV RSI,R14
MOV RDX,R12
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,RBX
CALL 0x0017206c
CMP byte ptr [R15 + 0x7e7],0x0
JZ 0x00164e04
LEA RDI,[RBP + -0xc8]
MOV ESI,0x1
CALL 0x001594c4
TEST AL,AL
JNZ 0x00164e5b
LAB_00164e04:
MOVZX R15D,word ptr [R12 + 0xa6]
ADD R15,RBX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,R15
LEA RCX,[RBP + -0x90]
MOV qword ptr [RCX + 0x8],R12
MOV qword ptr [RCX],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RCX + 0x10],RAX
MOV dword ptr [RCX + 0x18],0x0
MOV R12,RCX
MOV RDI,R14
MOV RSI,R15
MOV RDX,R13
CALL 0x0017017d
MOV RDI,R14
MOV RSI,R12
MOV RDX,R13
CALL 0x0016634b
TEST EAX,EAX
JZ 0x00164e9f
LAB_00164e5b:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x00164e76
MOV RDI,RBX
CALL 0x001a6612
JMP 0x00164e76
LAB_00164e6b:
CALL 0x001a8156
MOV dword ptr [RAX],0x80
LAB_00164e76:
MOV EBX,0xffffffff
LAB_00164e7b:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00164f40
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00164e9f:
LEA RDI,[RBP + -0x90]
LEA RSI,[RBP + -0xc8]
XOR EDX,EDX
CALL 0x001661ac
CMP EAX,-0x1
JZ 0x00164e5b
MOV RDX,qword ptr [RBP + -0x68]
MOV RDI,R14
MOV RSI,R15
CALL 0x0017017d
MOV RDX,qword ptr [RBP + -0x68]
LEA RSI,[RBP + -0x90]
MOV RDI,R14
CALL 0x0016634b
TEST EAX,EAX
JNZ 0x00164e5b
LEA RDI,[RBP + -0x90]
LEA RSI,[RBP + -0xc8]
XOR EDX,EDX
CALL 0x001661ac
CMP EAX,-0x1
JZ 0x00164e5b
LEA RDI,[RBP + -0xc8]
MOV ESI,dword ptr [RBP + -0x44]
MOV EDX,0x3
CALL 0x001721fd
TEST AL,AL
JNZ 0x00164e5b
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x50]
MOV qword ptr [RAX],RCX
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x00164f36
MOV RDI,RBX
CALL 0x001a6612
LAB_00164f36:
MOV EBX,0x1
JMP 0x00164e7b
LAB_00164f40:
CALL 0x0012a270
|
int maria_rtree_insert_level(long *param_1,long param_2,int4 param_3,long *param_4)
{
uint uVar1;
long lVar2;
int8 uVar3;
int4 uVar4;
char cVar5;
int iVar6;
int iVar7;
ulong uVar8;
long lVar9;
int1 *__s;
long lVar10;
int4 *puVar11;
size_t __n;
int1 *puVar12;
int1 *puVar13;
long lVar14;
long in_FS_OFFSET;
int1 auStack_f8 [8];
long *local_f0 [3];
ulong local_d8;
int1 local_d0 [56];
long local_98;
long local_90;
int8 local_88;
int4 local_80;
ulong local_78;
int8 local_70;
long **local_68;
long local_60;
long local_58;
int4 local_4c;
long *local_48;
int4 local_3c;
long local_38;
puVar12 = auStack_f8;
puVar13 = auStack_f8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar14 = *param_1;
lVar2 = *(long *)(param_2 + 8);
lVar9 = *(long *)(*(long *)(lVar14 + 0x118) + (ulong)*(byte *)(lVar2 + 0xa5) * 8);
local_60 = param_2;
if (lVar9 == -1) {
local_f0[0] = &local_98;
lVar9 = _ma_new(param_1);
if (lVar9 != -1) {
local_3c = *(int4 *)((long)local_f0[0] + 0xc);
*(int1 *)((long)param_1 + 0x685) = 1;
local_48 = param_4;
memset((void *)param_1[0x6f],0,(ulong)*(uint *)(lVar14 + 0x7bc));
*(int1 *)(param_1[0x6f] + (ulong)(*(int *)(lVar14 + 0x744) - 4)) =
*(int1 *)(lVar2 + 0xa5);
uVar1 = *(uint *)(lVar14 + 0x744);
*(char *)(param_1[0x6f] + -1 + (ulong)uVar1) = (char)uVar1;
*(char *)(param_1[0x6f] + -2 + (ulong)*(uint *)(lVar14 + 0x744)) = (char)(uVar1 >> 8);
_ma_page_setup(local_d0,param_1,lVar2,lVar9,param_1[0x6f]);
if (*(char *)(lVar14 + 0x7e7) != '\0') {
cVar5 = _ma_log_new(local_d0,1);
puVar13 = auStack_f8;
iVar6 = 1;
if (cVar5 != '\0') goto LAB_00164e7b;
}
iVar7 = maria_rtree_add_key(local_60,local_d0,0);
cVar5 = _ma_write_keypage(local_d0,local_3c,3);
puVar13 = auStack_f8;
iVar6 = 1;
if (cVar5 == '\0') {
*local_48 = lVar9;
puVar13 = auStack_f8;
iVar6 = iVar7;
}
goto LAB_00164e7b;
}
}
else {
local_48 = param_4;
iVar6 = maria_rtree_insert_req(param_1,param_2,lVar9,&local_70,param_3,0);
puVar13 = auStack_f8;
if (iVar6 != 1) goto LAB_00164e7b;
local_78 = (ulong)*(uint *)(lVar14 + 0x3e4);
local_68 = local_f0;
__n = (size_t)*(ushort *)(lVar2 + 0xa6);
local_d8 = *(ushort *)(lVar2 + 0xb0) + __n;
uVar8 = (*(long *)param_1[0xf] - (long)&local_d8) - local_d8;
if (((ulong)(*(long *)param_1[0xf] - (long)&local_d8) < local_d8 || uVar8 == 0) ||
((uVar8 < 0x10001 && (((uint)local_d8 < 0x1000 || (uVar8 < 0x8001)))))) {
__s = (int1 *)my_malloc(0,local_d8,0x10010);
if (__s == (int1 *)0x0) {
puVar11 = (int4 *)_my_thread_var();
*puVar11 = 0x80;
puVar13 = auStack_f8;
goto LAB_00164e76;
}
__n = (size_t)*(ushort *)(lVar2 + 0xa6);
local_3c = 0;
}
else {
__s = auStack_f8 + -(ulong)((uint)local_d8 + 0xf & 0xfffffff0);
local_3c = (int4)CONCAT71((int7)(uVar8 >> 8),1);
puVar12 = __s;
}
*(int8 *)(puVar12 + -8) = 0x164d6a;
memset(__s,0,__n);
*(int1 *)((long)__s + (ulong)(*(int *)(lVar14 + 0x744) - 3)) = 1;
*(int1 *)((long)__s + (ulong)(*(int *)(lVar14 + 0x744) - 4)) =
*(int1 *)(lVar2 + 0xa5);
uVar1 = *(uint *)(lVar14 + 0x744);
*(char *)((long)__s + ((ulong)uVar1 - 1)) = (char)uVar1;
*(char *)((long)__s + ((ulong)*(uint *)(lVar14 + 0x744) - 2)) = (char)(uVar1 >> 8);
*(int8 *)(puVar12 + -8) = 0x164db4;
lVar10 = _ma_new(param_1,3,&local_68);
local_58 = lVar10;
if (lVar10 != -1) {
local_4c = *(int4 *)((long)local_68 + 0xc);
*(int8 *)(puVar12 + -8) = 0x164de5;
_ma_page_setup(local_d0,param_1,lVar2,lVar10,__s);
if (*(char *)(lVar14 + 0x7e7) != '\0') {
*(int8 *)(puVar12 + -8) = 0x164e00;
cVar5 = _ma_log_new(local_d0,1);
if (cVar5 != '\0') goto LAB_00164e5b;
}
lVar14 = (ulong)*(ushort *)(lVar2 + 0xa6) + (long)__s;
local_98 = local_78 + lVar14;
local_88 = *(int8 *)(local_60 + 0x10);
local_80 = 0;
local_90 = lVar2;
*(int8 *)(puVar12 + -8) = 0x164e49;
_ma_kpointer(param_1,lVar14,lVar9);
*(int8 *)(puVar12 + -8) = 0x164e57;
iVar6 = maria_rtree_set_key_mbr(param_1,&local_98,lVar9);
if (iVar6 == 0) {
*(int8 *)(puVar12 + -8) = 0x164eb4;
iVar6 = maria_rtree_add_key(&local_98,local_d0,0);
uVar3 = local_70;
if (iVar6 != -1) {
*(int8 *)(puVar12 + -8) = 0x164ec8;
_ma_kpointer(param_1,lVar14,uVar3);
*(int8 *)(puVar12 + -8) = 0x164edb;
iVar6 = maria_rtree_set_key_mbr(param_1,&local_98,local_70);
if (iVar6 == 0) {
*(int8 *)(puVar12 + -8) = 0x164ef8;
iVar6 = maria_rtree_add_key(&local_98,local_d0,0);
uVar4 = local_4c;
if (iVar6 != -1) {
*(int8 *)(puVar12 + -8) = 0x164f15;
cVar5 = _ma_write_keypage(local_d0,uVar4,3);
if (cVar5 == '\0') {
*local_48 = local_58;
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x164f36;
my_free(__s);
}
puVar13 = puVar12;
iVar6 = 1;
goto LAB_00164e7b;
}
}
}
}
}
}
LAB_00164e5b:
puVar13 = puVar12;
if ((char)local_3c == '\0') {
*(int8 *)(puVar12 + -8) = 0x164e69;
my_free(__s);
}
}
LAB_00164e76:
iVar6 = -1;
LAB_00164e7b:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar6;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar13 + -8) = maria_rtree_insert_req;
__stack_chk_fail();
}
| |
24,972 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
this->memory[addr] = val;
return true;
} | O1 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x3ece
movq (%rdi), %rax
movl %ebx, %ecx
movb %dl, (%rax,%rcx)
cmpl $-0x1, %ebx
setne %al
popq %rbx
retq
leaq 0x22bc(%rip), %rdi # 0x6191
movl %ebx, %esi
xorl %eax, %eax
callq 0x32c0
jmp 0x3ec6
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov ebx, esi
cmp esi, 0FFFFFFFFh
jz short loc_3ECE
mov rax, [rdi]
mov ecx, ebx
mov [rax+rcx], dl
loc_3EC6:
cmp ebx, 0FFFFFFFFh
setnz al
pop rbx
retn
loc_3ECE:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov esi, ebx
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_3EC6
| bool MemoryManager::setByteNoCache(
MemoryManager *this,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-8h]
if ( a2 == -1 )
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
0xFFFFFFFFLL,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v15);
else
*(_BYTE *)(*(_QWORD *)this + a2) = a3;
return a2 != -1;
}
| setByteNoCache:
PUSH RBX
MOV EBX,ESI
CMP ESI,-0x1
JZ 0x00103ece
MOV RAX,qword ptr [RDI]
MOV ECX,EBX
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00103ec6:
CMP EBX,-0x1
SETNZ AL
POP RBX
RET
LAB_00103ece:
LEA RDI,[0x106191]
MOV ESI,EBX
XOR EAX,EAX
CALL 0x001032c0
JMP 0x00103ec6
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
if (param_1 == 0xffffffff) {
dbgprintf("Byte write to invalid addr 0x%x!\n",(ulong)param_1);
}
else {
*(uchar *)(*(long *)this + (ulong)param_1) = param_2;
}
return param_1 != 0xffffffff;
}
| |
24,973 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
this->memory[addr] = val;
return true;
} | O3 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x3ea2
movq (%rdi), %rax
movl %ebx, %ecx
movb %dl, (%rax,%rcx)
cmpl $-0x1, %ebx
setne %al
popq %rbx
retq
leaq 0x22e8(%rip), %rdi # 0x6191
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x32c0
jmp 0x3e9a
nop
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov ebx, esi
cmp esi, 0FFFFFFFFh
jz short loc_3EA2
mov rax, [rdi]
mov ecx, ebx
mov [rax+rcx], dl
loc_3E9A:
cmp ebx, 0FFFFFFFFh
setnz al
pop rbx
retn
loc_3EA2:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov esi, 0FFFFFFFFh
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_3E9A
| bool MemoryManager::setByteNoCache(
MemoryManager *this,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-8h]
if ( a2 == -1 )
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
0xFFFFFFFFLL,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v15);
else
*(_BYTE *)(*(_QWORD *)this + a2) = a3;
return a2 != -1;
}
| setByteNoCache:
PUSH RBX
MOV EBX,ESI
CMP ESI,-0x1
JZ 0x00103ea2
MOV RAX,qword ptr [RDI]
MOV ECX,EBX
MOV byte ptr [RAX + RCX*0x1],DL
LAB_00103e9a:
CMP EBX,-0x1
SETNZ AL
POP RBX
RET
LAB_00103ea2:
LEA RDI,[0x106191]
MOV ESI,0xffffffff
XOR EAX,EAX
CALL 0x001032c0
JMP 0x00103e9a
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
if (param_1 == 0xffffffff) {
dbgprintf("Byte write to invalid addr 0x%x!\n",0xffffffff);
}
else {
*(uchar *)(*(long *)this + (ulong)param_1) = param_2;
}
return param_1 != 0xffffffff;
}
| |
24,974 | fnv1a_hash | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | uint32_t fnv1a_hash(const void *data, size_t len) {
const uint8_t *bytes = (const uint8_t *) (data);
uint32_t hash = 2166136261u; // FNV offset basis
for (size_t i = 0; i < len; i++) {
hash ^= bytes[i];
hash *= 16777619; // FNV prime
}
return hash;
} | O0 | c | fnv1a_hash:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x811c9dc5, -0x1c(%rbp) # imm = 0x811C9DC5
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x3d37
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
xorl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
imull $0x1000193, -0x1c(%rbp), %eax # imm = 0x1000193
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3d03
movl -0x1c(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| fnv1a_hash:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_18], rax
mov [rbp+var_1C], 811C9DC5h
mov [rbp+var_28], 0
loc_3D03:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_10]
jnb short loc_3D37
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
movzx eax, byte ptr [rax+rcx]
xor eax, [rbp+var_1C]
mov [rbp+var_1C], eax
imul eax, [rbp+var_1C], 1000193h
mov [rbp+var_1C], eax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_3D03
loc_3D37:
mov eax, [rbp+var_1C]
pop rbp
retn
| long long fnv1a_hash(long long a1, unsigned long long a2)
{
unsigned long long i; // [rsp+0h] [rbp-28h]
unsigned int v4; // [rsp+Ch] [rbp-1Ch]
v4 = -2128831035;
for ( i = 0LL; i < a2; ++i )
v4 = 16777619 * (v4 ^ *(unsigned __int8 *)(a1 + i));
return v4;
}
| fnv1a_hash:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV dword ptr [RBP + -0x1c],0x811c9dc5
MOV qword ptr [RBP + -0x28],0x0
LAB_00103d03:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x00103d37
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
XOR EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
IMUL EAX,dword ptr [RBP + -0x1c],0x1000193
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00103d03
LAB_00103d37:
MOV EAX,dword ptr [RBP + -0x1c]
POP RBP
RET
|
uint fnv1a_hash(long param_1,ulong param_2)
{
int8 local_30;
int4 local_24;
local_24 = 0x811c9dc5;
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
local_24 = (*(byte *)(param_1 + local_30) ^ local_24) * 0x1000193;
}
return local_24;
}
| |
24,975 | fnv1a_hash | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | uint32_t fnv1a_hash(const void *data, size_t len) {
const uint8_t *bytes = (const uint8_t *) (data);
uint32_t hash = 2166136261u; // FNV offset basis
for (size_t i = 0; i < len; i++) {
hash ^= bytes[i];
hash *= 16777619; // FNV prime
}
return hash;
} | O1 | c | fnv1a_hash:
movl $0x811c9dc5, %eax # imm = 0x811C9DC5
testq %rsi, %rsi
je 0x2924
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
xorl %eax, %edx
imull $0x1000193, %edx, %eax # imm = 0x1000193
incq %rcx
cmpq %rcx, %rsi
jne 0x2910
retq
| fnv1a_hash:
mov eax, 811C9DC5h
test rsi, rsi
jz short locret_2924
xor ecx, ecx
loc_2910:
movzx edx, byte ptr [rdi+rcx]
xor edx, eax
imul eax, edx, 1000193h
inc rcx
cmp rsi, rcx
jnz short loc_2910
locret_2924:
retn
| long long fnv1a_hash(long long a1, long long a2)
{
long long result; // rax
long long i; // rcx
result = 2166136261LL;
if ( a2 )
{
for ( i = 0LL; i != a2; ++i )
result = 16777619 * ((unsigned int)result ^ *(unsigned __int8 *)(a1 + i));
}
return result;
}
| fnv1a_hash:
MOV EAX,0x811c9dc5
TEST RSI,RSI
JZ 0x00102924
XOR ECX,ECX
LAB_00102910:
MOVZX EDX,byte ptr [RDI + RCX*0x1]
XOR EDX,EAX
IMUL EAX,EDX,0x1000193
INC RCX
CMP RSI,RCX
JNZ 0x00102910
LAB_00102924:
RET
|
void fnv1a_hash(int8 param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
lVar1 = 0;
do {
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return;
}
| |
24,976 | fnv1a_hash | seiftnesse[P]memoryallocator/src/custom_alloc_util.c | uint32_t fnv1a_hash(const void *data, size_t len) {
const uint8_t *bytes = (const uint8_t *) (data);
uint32_t hash = 2166136261u; // FNV offset basis
for (size_t i = 0; i < len; i++) {
hash ^= bytes[i];
hash *= 16777619; // FNV prime
}
return hash;
} | O3 | c | fnv1a_hash:
movl $0x811c9dc5, %eax # imm = 0x811C9DC5
testq %rsi, %rsi
je 0x2884
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %edx
xorl %eax, %edx
imull $0x1000193, %edx, %eax # imm = 0x1000193
incq %rcx
cmpq %rcx, %rsi
jne 0x2870
retq
| fnv1a_hash:
mov eax, 811C9DC5h
test rsi, rsi
jz short locret_2884
xor ecx, ecx
loc_2870:
movzx edx, byte ptr [rdi+rcx]
xor edx, eax
imul eax, edx, 1000193h
inc rcx
cmp rsi, rcx
jnz short loc_2870
locret_2884:
retn
| long long fnv1a_hash(long long a1, long long a2)
{
long long result; // rax
long long i; // rcx
result = 2166136261LL;
if ( a2 )
{
for ( i = 0LL; i != a2; ++i )
result = 16777619 * ((unsigned int)result ^ *(unsigned __int8 *)(a1 + i));
}
return result;
}
| fnv1a_hash:
MOV EAX,0x811c9dc5
TEST RSI,RSI
JZ 0x00102884
XOR ECX,ECX
LAB_00102870:
MOVZX EDX,byte ptr [RDI + RCX*0x1]
XOR EDX,EAX
IMUL EAX,EDX,0x1000193
INC RCX
CMP RSI,RCX
JNZ 0x00102870
LAB_00102884:
RET
|
void fnv1a_hash(int8 param_1,long param_2)
{
long lVar1;
if (param_2 != 0) {
lVar1 = 0;
do {
lVar1 = lVar1 + 1;
} while (param_2 != lVar1);
}
return;
}
| |
24,977 | nglog::AddLogSink(nglog::LogSink*) | ng-log[P]ng-log/src/logging.cc | void AddLogSink(LogSink* destination) {
LogDestination::AddLogSink(destination);
} | O1 | cpp | nglog::AddLogSink(nglog::LogSink*):
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
leaq 0x255bf(%rip), %rdi # 0x31bd8
callq 0x7850
cmpl $0x23, %eax
je 0xc688
cmpq $0x0, 0x255a5(%rip) # 0x31bd0
jne 0xc64c
movl $0x18, %edi
callq 0x7530
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x25584(%rip) # 0x31bd0
movq 0x2557d(%rip), %rdi # 0x31bd0
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xc66c
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0xc676
leaq 0x8(%rsp), %rdx
callq 0x12bb2
leaq 0x2555b(%rip), %rdi # 0x31bd8
callq 0x7730
addq $0x10, %rsp
popq %rbx
retq
movl $0x23, %edi
callq 0x7350
jmp 0xc694
movq %rax, %rbx
leaq 0x2553a(%rip), %rdi # 0x31bd8
callq 0x7730
movq %rbx, %rdi
callq 0x7990
| _ZN5nglog10AddLogSinkEPNS_7LogSinkE:
push rbx
sub rsp, 10h
mov [rsp+18h+var_10], rdi
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_wrlock
cmp eax, 23h ; '#'
jz short loc_C688
cmp cs:_ZN5nglog14LogDestination6sinks_E, 0; nglog::LogDestination::sinks_
jnz short loc_C64C
mov edi, 18h; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov cs:_ZN5nglog14LogDestination6sinks_E, rax; nglog::LogDestination::sinks_
loc_C64C:
mov rdi, cs:_ZN5nglog14LogDestination6sinks_E; nglog::LogDestination::sinks_
mov rsi, [rdi+8]
cmp rsi, [rdi+10h]
jz short loc_C66C
mov rax, [rsp+18h+var_10]
mov [rsi], rax
add qword ptr [rdi+8], 8
jmp short loc_C676
loc_C66C:
lea rdx, [rsp+18h+var_10]
call _ZNSt6vectorIPN5nglog7LogSinkESaIS2_EE17_M_realloc_insertIJRKS2_EEEvN9__gnu_cxx17__normal_iteratorIPS2_S4_EEDpOT_; std::vector<nglog::LogSink *>::_M_realloc_insert<nglog::LogSink * const&>(__gnu_cxx::__normal_iterator<nglog::LogSink **,std::vector<nglog::LogSink *>>,nglog::LogSink * const&)
loc_C676:
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
add rsp, 10h
pop rbx
retn
loc_C688:
mov edi, 23h ; '#'; int
call __ZSt20__throw_system_errori; std::__throw_system_error(int)
jmp short $+2
loc_C694:
mov rbx, rax
lea rdi, _ZN5nglog14LogDestination11sink_mutex_E; nglog::LogDestination::sink_mutex_
call _pthread_rwlock_unlock
mov rdi, rbx
call __Unwind_Resume
| long long nglog::AddLogSink(nglog *this, nglog::LogSink *a2)
{
long long v2; // rax
long long v3; // rdi
nglog **v4; // rsi
nglog *v6; // [rsp+8h] [rbp-10h] BYREF
v6 = this;
if ( (unsigned int)pthread_rwlock_wrlock(&nglog::LogDestination::sink_mutex_) == 35 )
std::__throw_system_error(35);
if ( !nglog::LogDestination::sinks_ )
{
v2 = operator new(0x18uLL);
*(_OWORD *)v2 = 0LL;
*(_QWORD *)(v2 + 16) = 0LL;
nglog::LogDestination::sinks_ = v2;
}
v3 = nglog::LogDestination::sinks_;
v4 = *(nglog ***)(nglog::LogDestination::sinks_ + 8);
if ( v4 == *(nglog ***)(nglog::LogDestination::sinks_ + 16) )
{
std::vector<nglog::LogSink *>::_M_realloc_insert<nglog::LogSink * const&>(nglog::LogDestination::sinks_, v4, &v6);
}
else
{
*v4 = v6;
*(_QWORD *)(v3 + 8) += 8LL;
}
return pthread_rwlock_unlock(&nglog::LogDestination::sink_mutex_);
}
| AddLogSink:
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP + 0x8],RDI
LEA RDI,[0x131bd8]
CALL 0x00107850
CMP EAX,0x23
JZ 0x0010c688
CMP qword ptr [0x00131bd0],0x0
JNZ 0x0010c64c
LAB_0010c62d:
MOV EDI,0x18
CALL 0x00107530
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [0x00131bd0],RAX
LAB_0010c64c:
MOV RDI,qword ptr [0x00131bd0]
MOV RSI,qword ptr [RDI + 0x8]
CMP RSI,qword ptr [RDI + 0x10]
JZ 0x0010c66c
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSI],RAX
ADD qword ptr [RDI + 0x8],0x8
JMP 0x0010c676
LAB_0010c66c:
LEA RDX,[RSP + 0x8]
CALL 0x00112bb2
LAB_0010c676:
LEA RDI,[0x131bd8]
CALL 0x00107730
ADD RSP,0x10
POP RBX
RET
LAB_0010c688:
MOV EDI,0x23
CALL 0x00107350
|
/* nglog::AddLogSink(nglog::LogSink*) */
void nglog::AddLogSink(LogSink *param_1)
{
int8 *puVar1;
vector<nglog::LogSink*,std::allocator<nglog::LogSink*>> *pvVar2;
int iVar3;
LogSink *local_10;
local_10 = param_1;
iVar3 = pthread_rwlock_wrlock((pthread_rwlock_t *)LogDestination::sink_mutex_);
if (iVar3 != 0x23) {
if (LogDestination::sinks_ == (vector<nglog::LogSink*,std::allocator<nglog::LogSink*>> *)0x0) {
/* try { // try from 0010c62d to 0010c636 has its CatchHandler @ 0010c694 */
LogDestination::sinks_ =
(vector<nglog::LogSink*,std::allocator<nglog::LogSink*>> *)operator_new(0x18);
*(int8 *)LogDestination::sinks_ = 0;
*(int8 *)(LogDestination::sinks_ + 8) = 0;
*(int8 *)(LogDestination::sinks_ + 0x10) = 0;
}
pvVar2 = LogDestination::sinks_;
puVar1 = *(int8 **)(LogDestination::sinks_ + 8);
if (puVar1 == *(int8 **)(LogDestination::sinks_ + 0x10)) {
/* try { // try from 0010c66c to 0010c675 has its CatchHandler @ 0010c692 */
std::vector<nglog::LogSink*,std::allocator<nglog::LogSink*>>::
_M_realloc_insert<nglog::LogSink*const&>(LogDestination::sinks_,puVar1,&local_10);
}
else {
*puVar1 = local_10;
*(long *)(pvVar2 + 8) = *(long *)(pvVar2 + 8) + 8;
}
pthread_rwlock_unlock((pthread_rwlock_t *)LogDestination::sink_mutex_);
return;
}
/* WARNING: Subroutine does not return */
std::__throw_system_error(0x23);
}
| |
24,978 | 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;
} | O0 | c | ma_duplicate_resultset_metadata:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
shlq $0x7, %rsi
callq 0x47500
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x41b5a
movq $0x0, -0x8(%rbp)
jmp 0x41bba
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x41bb2
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
shlq $0x7, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x41bd0
cmpl $0x0, %eax
je 0x41ba2
movq $0x0, -0x8(%rbp)
jmp 0x41bba
jmp 0x41ba4
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x41b62
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_duplicate_resultset_metadata:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
shl rsi, 7
call ma_alloc_root
mov [rbp+var_30], rax
cmp [rbp+var_30], 0
jnz short loc_41B5A
mov [rbp+var_8], 0
jmp short loc_41BBA
loc_41B5A:
mov [rbp+var_28], 0
loc_41B62:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_18]
jnb short loc_41BB2
mov rdi, [rbp+var_10]
mov rax, [rbp+var_28]
shl rax, 7
add rdi, rax
mov rsi, [rbp+var_30]
mov rax, [rbp+var_28]
shl rax, 7
add rsi, rax
mov rdx, [rbp+var_20]
call ma_deep_copy_field
cmp eax, 0
jz short loc_41BA2
mov [rbp+var_8], 0
jmp short loc_41BBA
loc_41BA2:
jmp short $+2
loc_41BA4:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_41B62
loc_41BB2:
mov rax, [rbp+var_30]
mov [rbp+var_8], rax
loc_41BBA:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long ma_duplicate_resultset_metadata(long long a1, unsigned long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-30h]
unsigned long long i; // [rsp+8h] [rbp-28h]
v4 = ma_alloc_root(a3, a2 << 7);
if ( !v4 )
return 0LL;
for ( i = 0LL; i < a2; ++i )
{
if ( (unsigned int)ma_deep_copy_field((i << 7) + a1, (i << 7) + v4, a3) )
return 0LL;
}
return v4;
}
| ma_duplicate_resultset_metadata:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
SHL RSI,0x7
CALL 0x00147500
MOV qword ptr [RBP + -0x30],RAX
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x00141b5a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00141bba
LAB_00141b5a:
MOV qword ptr [RBP + -0x28],0x0
LAB_00141b62:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x18]
JNC 0x00141bb2
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x7
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x28]
SHL RAX,0x7
ADD RSI,RAX
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x00141bd0
CMP EAX,0x0
JZ 0x00141ba2
MOV qword ptr [RBP + -0x8],0x0
JMP 0x00141bba
LAB_00141ba2:
JMP 0x00141ba4
LAB_00141ba4:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00141b62
LAB_00141bb2:
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x8],RAX
LAB_00141bba:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long ma_duplicate_resultset_metadata(long param_1,ulong param_2,int8 param_3)
{
int iVar1;
ulong local_30;
long local_10;
local_10 = ma_alloc_root(param_3,param_2 << 7);
if (local_10 == 0) {
local_10 = 0;
}
else {
for (local_30 = 0; local_30 < param_2; local_30 = local_30 + 1) {
iVar1 = ma_deep_copy_field(param_1 + local_30 * 0x80,local_10 + local_30 * 0x80,param_3);
if (iVar1 != 0) {
return 0;
}
}
}
return local_10;
}
| |
24,979 | reinit_io_cache | eloqsql/mysys/mf_iocache.c | my_bool reinit_io_cache(IO_CACHE *info, enum cache_type type,
my_off_t seek_offset,
my_bool use_async_io __attribute__((unused)),
my_bool clear_cache)
{
DBUG_ENTER("reinit_io_cache");
DBUG_PRINT("enter",("cache:%p type: %d seek_offset: %llu clear_cache: %d",
info, type, (ulonglong) seek_offset,
(int) clear_cache));
DBUG_ASSERT(type == READ_CACHE || type == WRITE_CACHE);
DBUG_ASSERT(info->type == READ_CACHE || info->type == WRITE_CACHE);
/* If the whole file is in memory, avoid flushing to disk */
if (! clear_cache &&
seek_offset >= info->pos_in_file &&
seek_offset <= my_b_tell(info))
{
/* Reuse current buffer without flushing it to disk */
uchar *pos;
if (info->type == WRITE_CACHE && type == READ_CACHE)
{
info->read_end=info->write_pos;
info->end_of_file=my_b_tell(info);
/*
Trigger a new seek only if we have a valid
file handle.
*/
info->seek_not_done= (info->file != -1);
}
else if (type == WRITE_CACHE)
{
if (info->type == READ_CACHE)
{
info->write_end=info->write_buffer+info->buffer_length;
info->seek_not_done=1;
}
info->end_of_file = ~(my_off_t) 0;
}
pos=info->request_pos+(seek_offset-info->pos_in_file);
if (type == WRITE_CACHE)
info->write_pos=pos;
else
info->read_pos= pos;
}
else
{
/*
If we change from WRITE_CACHE to READ_CACHE, assume that everything
after the current positions should be ignored. In other cases we
update end_of_file as it may have changed since last init.
*/
if (type == READ_CACHE)
{
if (info->type == WRITE_CACHE)
info->end_of_file= my_b_tell(info);
else
{
if (!(info->myflags & MY_ENCRYPT))
info->end_of_file= mysql_file_seek(info->file, 0L,
MY_SEEK_END, MYF(0));
}
}
/* flush cache if we want to reuse it */
if (!clear_cache && my_b_flush_io_cache(info,1))
DBUG_RETURN(1);
info->pos_in_file=seek_offset;
/* Better to do always do a seek */
info->seek_not_done=1;
info->request_pos=info->read_pos=info->write_pos=info->buffer;
if (type == READ_CACHE)
{
info->read_end=info->buffer; /* Nothing in cache */
}
else
{
if (info->myflags & MY_ENCRYPT)
{
info->write_end = info->write_buffer + info->buffer_length;
if (seek_offset && info->file != -1)
{
info->read_end= info->buffer;
_my_b_encr_read(info, 0, 0); /* prefill the buffer */
info->write_pos= info->read_pos;
info->seek_not_done=1;
}
}
else
{
info->write_end=(info->buffer + info->buffer_length -
(seek_offset & (IO_SIZE-1)));
}
info->end_of_file= ~(my_off_t) 0;
}
}
info->type=type;
info->error=0;
init_functions(info);
DBUG_RETURN(0);
} | O0 | c | reinit_io_cache:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb %cl, -0x21(%rbp)
movb %al, -0x22(%rbp)
jmp 0xe083e
jmp 0xe0840
jmp 0xe0842
jmp 0xe0844
jmp 0xe0846
cmpb $0x0, -0x22(%rbp)
jne 0xe0961
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jb 0xe0961
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe0b50
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
ja 0xe0961
movq -0x10(%rbp), %rax
cmpl $0x2, 0xb0(%rax)
jne 0xe08d8
cmpl $0x1, -0x14(%rbp)
jne 0xe08d8
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0xe0b50
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xd4(%rax)
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xe0(%rax)
jmp 0xe0922
cmpl $0x2, -0x14(%rbp)
jne 0xe0920
movq -0x10(%rbp), %rax
cmpl $0x1, 0xb0(%rax)
jne 0xe0914
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xe8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x8(%rax)
jmp 0xe0922
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq (%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x14(%rbp)
jne 0xe0950
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xe095c
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xe0b16
cmpl $0x1, -0x14(%rbp)
jne 0xe09d7
movq -0x10(%rbp), %rax
cmpl $0x2, 0xb0(%rax)
jne 0xe098a
movq -0x10(%rbp), %rdi
callq 0xe0b50
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe09d5
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
jne 0xe09d3
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
leaq 0x737f5(%rip), %rdi # 0x1541a5
movl $0x1dd, %esi # imm = 0x1DD
xorl %eax, %eax
movl %eax, %r9d
movl $0x2, %r8d
movq %r9, %rcx
callq 0xe0230
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe09d5
jmp 0xe09d7
cmpb $0x0, -0x22(%rbp)
jne 0xe09fb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xe0bb0
cmpl $0x0, %eax
je 0xe09fb
jmp 0xe09f2
movb $0x1, -0x1(%rbp)
jmp 0xe0b3e
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpl $0x1, -0x14(%rbp)
jne 0xe0a4f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xe0b14
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0xe0ada
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xe8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xe0ad8
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xd4(%rax)
je 0xe0ad8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
leaq 0xba1c8e(%rip), %rax # 0xc82738
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
movq %rdx, %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0xe0(%rax)
jmp 0xe0b08
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0xe8(%rax), %rcx
movq -0x20(%rbp), %rdx
andq $0xfff, %rdx # imm = 0xFFF
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x8(%rax)
jmp 0xe0b16
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xb0(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xe4(%rax)
movq -0x10(%rbp), %rdi
callq 0xe0390
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| reinit_io_cache:
push rbp
mov rbp, rsp
sub rsp, 40h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_21], cl
mov [rbp+var_22], al
jmp short $+2
loc_E083E:
jmp short $+2
loc_E0840:
jmp short $+2
loc_E0842:
jmp short $+2
loc_E0844:
jmp short $+2
loc_E0846:
cmp [rbp+var_22], 0
jnz loc_E0961
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
cmp rax, [rcx]
jb loc_E0961
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
call my_b_tell_1
mov rcx, rax
mov rax, [rbp+var_38]
cmp rax, rcx
ja loc_E0961
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 2
jnz short loc_E08D8
cmp [rbp+var_14], 1
jnz short loc_E08D8
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
mov rdi, [rbp+var_10]
call my_b_tell_1
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+8], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+0D4h], 0FFFFFFFFh
setnz al
and al, 1
movzx ecx, al
mov rax, [rbp+var_10]
mov [rax+0E0h], ecx
jmp short loc_E0922
loc_E08D8:
cmp [rbp+var_14], 2
jnz short loc_E0920
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 1
jnz short loc_E0914
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
add rcx, [rax+0E8h]
mov rax, [rbp+var_10]
mov [rax+48h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
loc_E0914:
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0FFFFFFFFFFFFFFFFh
loc_E0920:
jmp short $+2
loc_E0922:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov rcx, [rbp+var_20]
mov rdx, [rbp+var_10]
sub rcx, [rdx]
add rax, rcx
mov [rbp+var_30], rax
cmp [rbp+var_14], 2
jnz short loc_E0950
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
jmp short loc_E095C
loc_E0950:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_10]
mov [rax+10h], rcx
loc_E095C:
jmp loc_E0B16
loc_E0961:
cmp [rbp+var_14], 1
jnz short loc_E09D7
mov rax, [rbp+var_10]
cmp dword ptr [rax+0B0h], 2
jnz short loc_E098A
mov rdi, [rbp+var_10]
call my_b_tell_1
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+8], rcx
jmp short loc_E09D5
loc_E098A:
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
and rax, 40h
cmp rax, 0
jnz short loc_E09D3
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 1DDh
xor eax, eax
mov r9d, eax
mov r8d, 2
mov rcx, r9
call inline_mysql_file_seek_6
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+8], rcx
loc_E09D3:
jmp short $+2
loc_E09D5:
jmp short $+2
loc_E09D7:
cmp [rbp+var_22], 0
jnz short loc_E09FB
mov rdi, [rbp+var_10]
mov esi, 1
call my_b_flush_io_cache
cmp eax, 0
jz short loc_E09FB
jmp short $+2
loc_E09F2:
mov [rbp+var_1], 1
jmp loc_E0B3E
loc_E09FB:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
mov [rax], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rax, [rbp+var_10]
mov [rax+10h], rcx
mov rax, [rbp+var_10]
mov [rax+28h], rcx
cmp [rbp+var_14], 1
jnz short loc_E0A4F
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
jmp loc_E0B14
loc_E0A4F:
mov rax, [rbp+var_10]
mov rax, [rax+0F8h]
and rax, 40h
cmp rax, 0
jz short loc_E0ADA
mov rax, [rbp+var_10]
mov rcx, [rax+30h]
mov rax, [rbp+var_10]
add rcx, [rax+0E8h]
mov rax, [rbp+var_10]
mov [rax+48h], rcx
cmp [rbp+var_20], 0
jz short loc_E0AD8
mov rax, [rbp+var_10]
cmp dword ptr [rax+0D4h], 0FFFFFFFFh
jz short loc_E0AD8
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
mov [rax+18h], rcx
lea rax, _my_b_encr_read
mov rax, [rax]
mov rdi, [rbp+var_10]
xor ecx, ecx
mov edx, ecx
mov rsi, rdx
call rax
mov rax, [rbp+var_10]
mov rcx, [rax+10h]
mov rax, [rbp+var_10]
mov [rax+40h], rcx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 1
loc_E0AD8:
jmp short loc_E0B08
loc_E0ADA:
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov rax, [rbp+var_10]
add rcx, [rax+0E8h]
mov rdx, [rbp+var_20]
and rdx, 0FFFh
xor eax, eax
sub rax, rdx
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+48h], rcx
loc_E0B08:
mov rax, [rbp+var_10]
mov qword ptr [rax+8], 0FFFFFFFFFFFFFFFFh
loc_E0B14:
jmp short $+2
loc_E0B16:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
mov [rax+0B0h], ecx
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0
mov rdi, [rbp+var_10]
call init_functions
mov [rbp+var_1], 0
loc_E0B3E:
mov al, [rbp+var_1]
add rsp, 40h
pop rbp
retn
| char reinit_io_cache(long long a1, int a2, unsigned long long a3, long long a4, char a5)
{
long long v5; // rcx
unsigned long long v7; // [rsp+10h] [rbp-30h]
if ( !a5 && a3 >= *(_QWORD *)a1 && a3 <= my_b_tell_1(a1) )
{
if ( *(_DWORD *)(a1 + 176) == 2 && a2 == 1 )
{
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 64);
*(_QWORD *)(a1 + 8) = my_b_tell_1(a1);
*(_DWORD *)(a1 + 224) = *(_DWORD *)(a1 + 212) != -1;
}
else if ( a2 == 2 )
{
if ( *(_DWORD *)(a1 + 176) == 1 )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + *(_QWORD *)(a1 + 48);
*(_DWORD *)(a1 + 224) = 1;
}
*(_QWORD *)(a1 + 8) = -1LL;
}
v7 = a3 - *(_QWORD *)a1 + *(_QWORD *)(a1 + 40);
if ( a2 == 2 )
*(_QWORD *)(a1 + 64) = v7;
else
*(_QWORD *)(a1 + 16) = v7;
LABEL_31:
*(_DWORD *)(a1 + 176) = a2;
*(_DWORD *)(a1 + 228) = 0;
init_functions(a1);
return 0;
}
if ( a2 == 1 )
{
if ( *(_DWORD *)(a1 + 176) == 2 )
{
*(_QWORD *)(a1 + 8) = my_b_tell_1(a1);
}
else if ( (*(_QWORD *)(a1 + 248) & 0x40LL) == 0 )
{
*(_QWORD *)(a1 + 8) = inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x1DDu,
*(_DWORD *)(a1 + 212),
0LL,
2u,
0LL);
}
}
if ( a5 || !(unsigned int)my_b_flush_io_cache(a1, 1LL) )
{
*(_QWORD *)a1 = a3;
*(_DWORD *)(a1 + 224) = 1;
v5 = *(_QWORD *)(a1 + 32);
*(_QWORD *)(a1 + 64) = v5;
*(_QWORD *)(a1 + 16) = v5;
*(_QWORD *)(a1 + 40) = v5;
if ( a2 == 1 )
{
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 32);
}
else
{
if ( (*(_QWORD *)(a1 + 248) & 0x40LL) != 0 )
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + *(_QWORD *)(a1 + 48);
if ( a3 && *(_DWORD *)(a1 + 212) != -1 )
{
*(_QWORD *)(a1 + 24) = *(_QWORD *)(a1 + 32);
my_b_encr_read(a1, 0LL);
*(_QWORD *)(a1 + 64) = *(_QWORD *)(a1 + 16);
*(_DWORD *)(a1 + 224) = 1;
}
}
else
{
*(_QWORD *)(a1 + 72) = *(_QWORD *)(a1 + 232) + *(_QWORD *)(a1 + 32) - (a3 & 0xFFF);
}
*(_QWORD *)(a1 + 8) = -1LL;
}
goto LABEL_31;
}
return 1;
}
| reinit_io_cache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RBP + -0x21],CL
MOV byte ptr [RBP + -0x22],AL
JMP 0x001e083e
LAB_001e083e:
JMP 0x001e0840
LAB_001e0840:
JMP 0x001e0842
LAB_001e0842:
JMP 0x001e0844
LAB_001e0844:
JMP 0x001e0846
LAB_001e0846:
CMP byte ptr [RBP + -0x22],0x0
JNZ 0x001e0961
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX]
JC 0x001e0961
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e0b50
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,RCX
JA 0x001e0961
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x2
JNZ 0x001e08d8
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x001e08d8
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x40]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e0b50
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xd4],-0x1
SETNZ AL
AND AL,0x1
MOVZX ECX,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],ECX
JMP 0x001e0922
LAB_001e08d8:
CMP dword ptr [RBP + -0x14],0x2
JNZ 0x001e0920
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x1
JNZ 0x001e0914
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
LAB_001e0914:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],-0x1
LAB_001e0920:
JMP 0x001e0922
LAB_001e0922:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x10]
SUB RCX,qword ptr [RDX]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x14],0x2
JNZ 0x001e0950
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
JMP 0x001e095c
LAB_001e0950:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
LAB_001e095c:
JMP 0x001e0b16
LAB_001e0961:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x001e09d7
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xb0],0x2
JNZ 0x001e098a
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e0b50
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
JMP 0x001e09d5
LAB_001e098a:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
AND RAX,0x40
CMP RAX,0x0
JNZ 0x001e09d3
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
LEA RDI,[0x2541a5]
MOV ESI,0x1dd
XOR EAX,EAX
MOV R9D,EAX
MOV R8D,0x2
MOV RCX,R9
CALL 0x001e0230
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],RCX
LAB_001e09d3:
JMP 0x001e09d5
LAB_001e09d5:
JMP 0x001e09d7
LAB_001e09d7:
CMP byte ptr [RBP + -0x22],0x0
JNZ 0x001e09fb
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x001e0bb0
CMP EAX,0x0
JZ 0x001e09fb
JMP 0x001e09f2
LAB_001e09f2:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001e0b3e
LAB_001e09fb:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x001e0a4f
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x001e0b14
LAB_001e0a4f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0xf8]
AND RAX,0x40
CMP RAX,0x0
JZ 0x001e0ada
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001e0ad8
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xd4],-0x1
JZ 0x001e0ad8
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x18],RCX
LEA RAX,[0xd82738]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x10]
XOR ECX,ECX
MOV EDX,ECX
MOV RSI,RDX
CALL RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x40],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x1
LAB_001e0ad8:
JMP 0x001e0b08
LAB_001e0ada:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0xe8]
MOV RDX,qword ptr [RBP + -0x20]
AND RDX,0xfff
XOR EAX,EAX
SUB RAX,RDX
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x48],RCX
LAB_001e0b08:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x8],-0x1
LAB_001e0b14:
JMP 0x001e0b16
LAB_001e0b16:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xb0],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0x0
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001e0390
MOV byte ptr [RBP + -0x1],0x0
LAB_001e0b3e:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x40
POP RBP
RET
|
int1 reinit_io_cache(ulong *param_1,int param_2,ulong param_3,int8 param_4,char param_5)
{
int iVar1;
ulong uVar2;
if (((param_5 == '\0') && (*param_1 <= param_3)) && (uVar2 = my_b_tell(param_1), param_3 <= uVar2)
) {
if (((int)param_1[0x16] == 2) && (param_2 == 1)) {
param_1[3] = param_1[8];
uVar2 = my_b_tell(param_1);
param_1[1] = uVar2;
*(uint *)(param_1 + 0x1c) = (uint)(*(int *)((long)param_1 + 0xd4) != -1);
}
else if (param_2 == 2) {
if ((int)param_1[0x16] == 1) {
param_1[9] = param_1[6] + param_1[0x1d];
*(int4 *)(param_1 + 0x1c) = 1;
}
param_1[1] = 0xffffffffffffffff;
}
uVar2 = param_1[5] + (param_3 - *param_1);
if (param_2 == 2) {
param_1[8] = uVar2;
}
else {
param_1[2] = uVar2;
}
}
else {
if (param_2 == 1) {
if ((int)param_1[0x16] == 2) {
uVar2 = my_b_tell(param_1);
param_1[1] = uVar2;
}
else if ((param_1[0x1f] & 0x40) == 0) {
uVar2 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x1dd,
*(int4 *)((long)param_1 + 0xd4),0,2);
param_1[1] = uVar2;
}
}
if ((param_5 == '\0') && (iVar1 = my_b_flush_io_cache(param_1,1), iVar1 != 0)) {
return 1;
}
*param_1 = param_3;
*(int4 *)(param_1 + 0x1c) = 1;
uVar2 = param_1[4];
param_1[8] = uVar2;
param_1[2] = uVar2;
param_1[5] = uVar2;
if (param_2 == 1) {
param_1[3] = param_1[4];
}
else {
if ((param_1[0x1f] & 0x40) == 0) {
param_1[9] = (param_1[4] + param_1[0x1d]) - (param_3 & 0xfff);
}
else {
param_1[9] = param_1[6] + param_1[0x1d];
if ((param_3 != 0) && (*(int *)((long)param_1 + 0xd4) != -1)) {
param_1[3] = param_1[4];
(*_my_b_encr_read)(param_1,0);
param_1[8] = param_1[2];
*(int4 *)(param_1 + 0x1c) = 1;
}
}
param_1[1] = 0xffffffffffffffff;
}
}
*(int *)(param_1 + 0x16) = param_2;
*(int4 *)((long)param_1 + 0xe4) = 0;
init_functions(param_1);
return 0;
}
| |
24,980 | nglog::LogMessage::RecordCrashReason(nglog::internal::CrashReason*) | ng-log[P]ng-log/src/logging.cc | void LogMessage::RecordCrashReason(internal::CrashReason* reason) {
reason->filename = fatal_msg_data_exclusive.fullname_;
reason->line_number = fatal_msg_data_exclusive.line_;
reason->message = fatal_msg_data_exclusive.message_text_ +
fatal_msg_data_exclusive.num_prefix_chars_;
#ifdef HAVE_STACKTRACE
// Retrieve the stack trace, omitting the logging frames that got us here.
reason->depth = GetStackTrace(reason->stack, ARRAYSIZE(reason->stack), 4);
#else
reason->depth = 0;
#endif
} | O2 | cpp | nglog::LogMessage::RecordCrashReason(nglog::internal::CrashReason*):
pushq %rbx
movq %rsi, %rbx
leaq 0x25a77(%rip), %rax # 0x31e60
movq 0x2d148(%rip), %rcx # 0x39538
movq %rcx, (%rsi)
movl 0x2d103(%rip), %ecx # 0x394fc
movl %ecx, 0x8(%rsi)
movq 0x2d115(%rip), %rcx # 0x39518
leaq 0x4(%rcx,%rax), %rax
movq %rax, 0x10(%rsi)
leaq 0x18(%rsi), %rdi
pushq $0x20
popq %rsi
pushq $0x4
popq %rdx
callq 0x1dbec
movl %eax, 0x118(%rbx)
popq %rbx
retq
nop
| _ZN5nglog10LogMessage17RecordCrashReasonEPNS_8internal11CrashReasonE:
push rbx
mov rbx, rsi
lea rax, _ZN5nglogL24fatal_msg_data_exclusiveE; nglog::fatal_msg_data_exclusive
mov rcx, cs:qword_39538
mov [rsi], rcx
mov ecx, cs:dword_394FC
mov [rsi+8], ecx
mov rcx, cs:qword_39518; int
lea rax, [rcx+rax+4]
mov [rsi+10h], rax
lea rdi, [rsi+18h]; this
push 20h ; ' '
pop rsi; void **
push 4
pop rdx; int
call _ZN5nglog5tools13GetStackTraceEPPvii; nglog::tools::GetStackTrace(void **,int,int)
mov [rbx+118h], eax
pop rbx
retn
| long long nglog::LogMessage::RecordCrashReason(long long a1, long long a2)
{
int v2; // ecx
long long result; // rax
*(_QWORD *)a2 = qword_39538;
*(_DWORD *)(a2 + 8) = dword_394FC;
v2 = qword_39518[0];
*(_QWORD *)(a2 + 16) = (char *)&nglog::fatal_msg_data_exclusive + *(_QWORD *)qword_39518 + 4;
result = nglog::tools::GetStackTrace((nglog::tools *)(a2 + 24), (void **)&qword_20, 4, v2);
*(_DWORD *)(a2 + 280) = result;
return result;
}
| RecordCrashReason:
PUSH RBX
MOV RBX,RSI
LEA RAX,[0x131e60]
MOV RCX,qword ptr [0x00139538]
MOV qword ptr [RSI],RCX
MOV ECX,dword ptr [0x001394fc]
MOV dword ptr [RSI + 0x8],ECX
MOV RCX,qword ptr [0x00139518]
LEA RAX,[RCX + RAX*0x1 + 0x4]
MOV qword ptr [RSI + 0x10],RAX
LEA RDI,[RSI + 0x18]
PUSH 0x20
POP RSI
PUSH 0x4
POP RDX
CALL 0x0011dbec
MOV dword ptr [RBX + 0x118],EAX
POP RBX
RET
|
/* nglog::LogMessage::RecordCrashReason(nglog::internal::CrashReason*) */
void __thiscall nglog::LogMessage::RecordCrashReason(LogMessage *this,CrashReason *param_1)
{
int4 uVar1;
*(int8 *)param_1 = fatal_msg_data_exclusive._30424_8_;
*(int4 *)(param_1 + 8) = fatal_msg_data_exclusive._30364_4_;
*(long *)(param_1 + 0x10) = fatal_msg_data_exclusive._30392_8_ + 0x131e64;
uVar1 = tools::GetStackTrace((void **)(param_1 + 0x18),0x20,4);
*(int4 *)(param_1 + 0x118) = uVar1;
return;
}
| |
24,981 | 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 0x76b33
movq 0x8(%r14), %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x18350
movq %rax, %rbx
movq %r14, %rdi
callq 0x3f3b0
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x364e3(%rip), %rsi # 0xad03a
leaq 0x10(%rsp), %rdi
callq 0x3f327
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x12e, %esi # imm = 0x12E
movq %r14, %rcx
callq 0x3f158
xorl %ebp, %ebp
leaq 0x65746(%rip), %rsi # 0xdc2c8
leaq -0x29513(%rip), %rdx # 0x4d676
movq %rbx, %rdi
callq 0x18b50
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x76baf
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x186a0
testb %bpl, %bpl
jne 0x76bb9
jmp 0x76bc1
movq %rax, %r14
movq %rbx, %rdi
callq 0x184f0
movq %r14, %rdi
callq 0x18bc0
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_76B33
mov rax, [r14+8]
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
loc_76B33:
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_76BAF
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_76BAF:
test bpl, bpl
jnz short loc_76BB9
jmp short loc_76BC1
mov r14, rax
loc_76BB9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_76BC1:
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 0x00176b33
MOV RAX,qword ptr [R14 + 0x8]
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
LAB_00176b33:
MOV EDI,0x20
CALL 0x00118350
MOV RBX,RAX
MOV RDI,R14
CALL 0x0013f3b0
LEA RDX,[RSP + 0x8]
MOV qword ptr [RDX],RAX
LAB_00176b50:
LEA RSI,[0x1ad03a]
LEA RDI,[RSP + 0x10]
CALL 0x0013f327
MOV BPL,0x1
LAB_00176b64:
LEA RDX,[RSP + 0x10]
MOV RDI,RBX
MOV ESI,0x12e
MOV RCX,R14
CALL 0x0013f158
XOR EBP,EBP
LEA RSI,[0x1dc2c8]
LEA RDX,[0x14d676]
MOV RDI,RBX
CALL 0x00118b50
|
/* 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 00176b50 to 00176b60 has its CatchHandler @ 00176bb6 */
detail::concat<std::__cxx11::string,char_const(&)[29],char_const*>
(local_38,"type must be binary, but is ",&local_40);
/* try { // try from 00176b64 to 00176b90 has its CatchHandler @ 00176b91 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar1,0x12e,local_38,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar1,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
24,982 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O2 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x6be24
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x6ce66
addq $0x40, %rbx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41bcc
movq %rax, %r14
leaq 0x18(%rbx), %rdi
callq 0x53f50
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x683d2
movq %r14, %rdi
callq 0x25020
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
add rdi, 20h ; ' '
xorps xmm0, xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx], xmm0
call _ZSt11make_sharedIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>()
lea rdi, [rbx+30h]
mov rsi, r14
call _ZNSt12__shared_ptrISt8functionIFN5minja5ValueERKSt10shared_ptrINS1_7ContextEERNS1_14ArgumentsValueEEELN9__gnu_cxx12_Lock_policyE2EEC2ERKSE_; std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2> const&)
add rbx, 40h ; '@'
mov rdi, rbx
xor esi, esi
add rsp, 8
pop rbx
pop r14
jmp _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
mov r14, rax
lea rdi, [rbx+18h]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
add rbx, 8
mov rdi, rbx
call _ZNSt12__weak_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__weak_count<(__gnu_cxx::_Lock_policy)2>::~__weak_count()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
std::make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>(a1 + 32);
std::__shared_ptr<std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>,(__gnu_cxx::_Lock_policy)2>::__shared_ptr(
(_QWORD *)(a1 + 48),
a2);
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>::basic_json(a1 + 64);
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
ADD RDI,0x20
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX],XMM0
LAB_00174350:
CALL 0x0016be24
LAB_00174355:
LEA RDI,[RBX + 0x30]
MOV RSI,R14
CALL 0x0016ce66
ADD RBX,0x40
MOV RDI,RBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP R14
JMP 0x00141bcc
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 00174350 to 00174354 has its CatchHandler @ 00174376 */
std::
make_shared<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>>
();
std::
__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
::__shared_ptr((__shared_ptr<std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>,(__gnu_cxx::_Lock_policy)2>
*)(this + 0x30),(__shared_ptr *)param_1);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)(this + 0x40));
return;
}
| |
24,983 | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&) | monkey531[P]llama/common/minja.hpp | Value(const std::shared_ptr<CallableType> & callable) : object_(std::make_shared<ObjectType>()), callable_(callable) {} | O3 | cpp | minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context> const&, minja::ArgumentsValue&)>> const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x30, %edi
callq 0x1b8f0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x942e5(%rip), %rcx # 0x12f438
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rax, %rcx
addq $0x10, %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
movq (%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x9b1a1
movq 0x95ded(%rip), %rcx # 0x130f80
cmpb $0x0, (%rcx)
je 0x9b19d
incl 0x8(%rax)
jmp 0x9b1a1
lock
incl 0x8(%rax)
leaq 0x40(%rbx), %r14
movb $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x5d774
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d774
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9b1e3
callq 0x725dc
movq %rbx, %rdi
callq 0x8c4ee
movq %r14, %rdi
callq 0x1c030
nop
| _ZN5minja5ValueC2ERKSt10shared_ptrISt8functionIFS0_RKS1_INS_7ContextEERNS_14ArgumentsValueEEEE:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, 100000001h
mov [rax+8], rcx
lea rcx, _ZTVSt23_Sp_counted_ptr_inplaceIN8nlohmann16json_abi_v3_11_311ordered_mapINS1_10basic_jsonIS2_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEEN5minja5ValueESt4lessISE_ESaISt4pairIKSE_SG_EEEESaISN_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
add rcx, 10h
mov [rax], rcx
mov rcx, rax
add rcx, 10h
xorps xmm0, xmm0
movups xmmword ptr [rax+10h], xmm0
mov qword ptr [rax+20h], 0
mov [rbx+28h], rax
mov [rbx+20h], rcx
mov rax, [r14]
mov [rbx+30h], rax
mov rax, [r14+8]
mov [rbx+38h], rax
test rax, rax
jz short loc_9B1A1
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_9B19D
inc dword ptr [rax+8]
jmp short loc_9B1A1
loc_9B19D:
lock inc dword ptr [rax+8]
loc_9B1A1:
lea r14, [rbx+40h]
mov byte ptr [rbx+40h], 0
mov qword ptr [rbx+48h], 0
mov rdi, r14
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, r14
mov esi, 1
add rsp, 8
pop rbx
pop r14
jmp _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov r14, rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9B1E3
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9B1E3:
mov rdi, rbx
call _ZNSt23enable_shared_from_thisIN5minja5ValueEED2Ev; std::enable_shared_from_this<minja::Value>::~enable_shared_from_this()
mov rdi, r14
call __Unwind_Resume
| long long minja::Value::Value(long long a1, _QWORD *a2)
{
long long v2; // rax
long long result; // rax
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = operator new(0x30uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = &`vtable for'std::_Sp_counted_ptr_inplace<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>,std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 32) = 0LL;
*(_QWORD *)(a1 + 40) = v2;
*(_QWORD *)(a1 + 32) = v2 + 16;
*(_QWORD *)(a1 + 48) = *a2;
result = a2[1];
*(_QWORD *)(a1 + 56) = result;
if ( result )
{
if ( _libc_single_threaded )
++*(_DWORD *)(result + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(result + 8));
}
*(_BYTE *)(a1 + 64) = 0;
*(_QWORD *)(a1 + 72) = 0LL;
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));
return result;
}
| Value:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_0019b134:
MOV EDI,0x30
CALL 0x0011b8f0
LAB_0019b13e:
MOV RCX,0x100000001
MOV qword ptr [RAX + 0x8],RCX
LEA RCX,[0x22f438]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
MOV RCX,RAX
ADD RCX,0x10
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX + 0x10],XMM0
MOV qword ptr [RAX + 0x20],0x0
MOV qword ptr [RBX + 0x28],RAX
MOV qword ptr [RBX + 0x20],RCX
MOV RAX,qword ptr [R14]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RBX + 0x38],RAX
TEST RAX,RAX
JZ 0x0019b1a1
MOV RCX,qword ptr [0x00230f80]
CMP byte ptr [RCX],0x0
JZ 0x0019b19d
INC dword ptr [RAX + 0x8]
JMP 0x0019b1a1
LAB_0019b19d:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019b1a1:
LEA R14,[RBX + 0x40]
MOV byte ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0015d774
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0015d774
|
/* minja::Value::Value(std::shared_ptr<std::function<minja::Value (std::shared_ptr<minja::Context>
const&, minja::ArgumentsValue&)> > const&) */
void __thiscall minja::Value::Value(Value *this,shared_ptr *param_1)
{
long lVar1;
int8 *puVar2;
bool bVar3;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
/* try { // try from 0019b134 to 0019b13d has its CatchHandler @ 0019b1d2 */
puVar2 = (int8 *)operator_new(0x30);
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_0022f448;
puVar2[2] = 0;
puVar2[3] = 0;
puVar2[4] = 0;
*(int8 **)(this + 0x28) = puVar2;
*(int8 **)(this + 0x20) = puVar2 + 2;
*(int8 *)(this + 0x30) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x38) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_00230f80 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
bVar3 = (bool)((char)this + '@');
this[0x40] = (Value)0x0;
*(int8 *)(this + 0x48) = 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>
::assert_invariant(bVar3);
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(bVar3);
return;
}
| |
24,984 | my_setwd | eloqsql/mysys/my_getwd.c | int my_setwd(const char *dir, myf MyFlags)
{
int res;
size_t length;
char *start, *pos;
DBUG_ENTER("my_setwd");
DBUG_PRINT("my",("dir: '%s' MyFlags %lu", dir, MyFlags));
start=(char *) dir;
if (! dir[0] || (dir[0] == FN_LIBCHAR && dir[1] == 0))
dir=FN_ROOTDIR;
if ((res=chdir((char*) dir)) != 0)
{
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_SETWD,MYF(ME_BELL),start,errno);
}
else
{
if (test_if_hard_path(start))
{ /* Hard pathname */
pos= strmake(&curr_dir[0],start,(size_t) FN_REFLEN-1);
if (pos[-1] != FN_LIBCHAR)
{
length=(uint) (pos-(char*) curr_dir);
curr_dir[length]=FN_LIBCHAR; /* must end with '/' */
curr_dir[length+1]='\0';
}
}
else
curr_dir[0]='\0'; /* Don't save name */
}
DBUG_RETURN(res);
} | O3 | c | my_setwd:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x2abef
movq %r14, %rdi
cmpl $0x2f, %eax
jne 0x2abf6
cmpb $0x0, 0x1(%r14)
movq %r14, %rdi
jne 0x2abf6
leaq 0x31668(%rip), %rdi # 0x5c25e
callq 0x24460
movl %eax, %ebx
testl %eax, %eax
je 0x2ac34
callq 0x24060
movq %rax, %r12
movl (%rax), %r13d
callq 0x2656a
movl %r13d, (%rax)
testb $0x10, %r15b
je 0x2ac91
movl (%r12), %ecx
movl $0x4, %esi
movl $0x11, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2a6c3
jmp 0x2ac91
leaq 0x33a0cd(%rip), %rax # 0x364d08
movq (%rax), %rax
movq %r14, %rcx
movzbl (%rcx), %edx
cmpl $0x7e, %edx
jne 0x2ac59
cmpb $0x2f, 0x1(%rcx)
jne 0x2ac87
movq %rax, %rcx
testq %rax, %rax
jne 0x2ac41
jmp 0x2ac87
cmpl $0x2f, %edx
jne 0x2ac87
leaq 0x33a0bb(%rip), %r15 # 0x364d20
movl $0x1ff, %edx # imm = 0x1FF
movq %r15, %rdi
movq %r14, %rsi
callq 0x5a124
cmpb $0x2f, -0x1(%rax)
je 0x2ac91
subl %r15d, %eax
movw $0x2f, (%r15,%rax)
jmp 0x2ac91
leaq 0x33a092(%rip), %rax # 0x364d20
movb $0x0, (%rax)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_setwd:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rsi
mov r14, rdi
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_2ABEF
mov rdi, r14
cmp eax, 2Fh ; '/'
jnz short loc_2ABF6
cmp byte ptr [r14+1], 0
mov rdi, r14
jnz short loc_2ABF6
loc_2ABEF:
lea rdi, unk_5C25E
loc_2ABF6:
call _chdir
mov ebx, eax
test eax, eax
jz short loc_2AC34
call ___errno_location
mov r12, rax
mov r13d, [rax]
call _my_thread_var
mov [rax], r13d
test r15b, 10h
jz short loc_2AC91
mov ecx, [r12]
mov esi, 4
mov edi, 11h
mov rdx, r14
xor eax, eax
call my_error
jmp short loc_2AC91
loc_2AC34:
lea rax, home_dir
mov rax, [rax]
mov rcx, r14
loc_2AC41:
movzx edx, byte ptr [rcx]
cmp edx, 7Eh ; '~'
jnz short loc_2AC59
cmp byte ptr [rcx+1], 2Fh ; '/'
jnz short loc_2AC87
mov rcx, rax
test rax, rax
jnz short loc_2AC41
jmp short loc_2AC87
loc_2AC59:
cmp edx, 2Fh ; '/'
jnz short loc_2AC87
lea r15, curr_dir
mov edx, 1FFh
mov rdi, r15
mov rsi, r14
call strmake
cmp byte ptr [rax-1], 2Fh ; '/'
jz short loc_2AC91
sub eax, r15d
mov word ptr [r15+rax], 2Fh ; '/'
jmp short loc_2AC91
loc_2AC87:
lea rax, curr_dir
mov byte ptr [rax], 0
loc_2AC91:
mov eax, ebx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_setwd(unsigned __int8 *a1, char a2)
{
unsigned __int8 *v2; // r14
unsigned int v3; // ebx
unsigned int *v4; // r12
unsigned int v5; // r13d
unsigned __int8 *v6; // rcx
int v7; // edx
long long v8; // rax
v2 = a1;
if ( !*a1 || *a1 == 47 && !a1[1] )
a1 = (unsigned __int8 *)&unk_5C25E;
v3 = chdir(a1);
if ( v3 )
{
v4 = (unsigned int *)__errno_location(a1);
v5 = *v4;
*(_DWORD *)my_thread_var() = v5;
if ( (a2 & 0x10) != 0 )
my_error(0x11u, 4, v2, *v4);
}
else
{
v6 = v2;
while ( 1 )
{
v7 = *v6;
if ( v7 != 126 )
break;
if ( v6[1] == 47 )
{
v6 = (unsigned __int8 *)home_dir;
if ( home_dir )
continue;
}
goto LABEL_16;
}
if ( v7 != 47 )
{
LABEL_16:
curr_dir[0] = 0;
return v3;
}
v8 = strmake(curr_dir, v2, 511LL);
if ( *(_BYTE *)(v8 - 1) != 47 )
*(_WORD *)&curr_dir[(unsigned int)v8 - (unsigned int)curr_dir] = 47;
}
return v3;
}
| my_setwd:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RSI
MOV R14,RDI
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x0012abef
MOV RDI,R14
CMP EAX,0x2f
JNZ 0x0012abf6
CMP byte ptr [R14 + 0x1],0x0
MOV RDI,R14
JNZ 0x0012abf6
LAB_0012abef:
LEA RDI,[0x15c25e]
LAB_0012abf6:
CALL 0x00124460
MOV EBX,EAX
TEST EAX,EAX
JZ 0x0012ac34
CALL 0x00124060
MOV R12,RAX
MOV R13D,dword ptr [RAX]
CALL 0x0012656a
MOV dword ptr [RAX],R13D
TEST R15B,0x10
JZ 0x0012ac91
MOV ECX,dword ptr [R12]
MOV ESI,0x4
MOV EDI,0x11
MOV RDX,R14
XOR EAX,EAX
CALL 0x0012a6c3
JMP 0x0012ac91
LAB_0012ac34:
LEA RAX,[0x464d08]
MOV RAX,qword ptr [RAX]
MOV RCX,R14
LAB_0012ac41:
MOVZX EDX,byte ptr [RCX]
CMP EDX,0x7e
JNZ 0x0012ac59
CMP byte ptr [RCX + 0x1],0x2f
JNZ 0x0012ac87
MOV RCX,RAX
TEST RAX,RAX
JNZ 0x0012ac41
JMP 0x0012ac87
LAB_0012ac59:
CMP EDX,0x2f
JNZ 0x0012ac87
LEA R15,[0x464d20]
MOV EDX,0x1ff
MOV RDI,R15
MOV RSI,R14
CALL 0x0015a124
CMP byte ptr [RAX + -0x1],0x2f
JZ 0x0012ac91
SUB EAX,R15D
MOV word ptr [R15 + RAX*0x1],0x2f
JMP 0x0012ac91
LAB_0012ac87:
LEA RAX,[0x464d20]
MOV byte ptr [RAX],0x0
LAB_0012ac91:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int my_setwd(char *param_1,ulong param_2)
{
int iVar1;
int iVar2;
int *piVar3;
int *piVar4;
long lVar5;
char *pcVar6;
if ((*param_1 == '\0') || ((pcVar6 = param_1, *param_1 == '/' && (param_1[1] == '\0')))) {
pcVar6 = "/";
}
iVar2 = chdir(pcVar6);
pcVar6 = param_1;
if (iVar2 == 0) {
while (*pcVar6 == '~') {
if ((pcVar6[1] != '/') || (pcVar6 = home_dir, home_dir == (char *)0x0)) goto LAB_0012ac87;
}
if (*pcVar6 == '/') {
lVar5 = strmake(&curr_dir,param_1,0x1ff);
if (*(char *)(lVar5 + -1) == '/') {
return 0;
}
*(int2 *)(&curr_dir + ((int)lVar5 - 0x464d20)) = 0x2f;
return 0;
}
LAB_0012ac87:
curr_dir = 0;
}
else {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar4 = (int *)_my_thread_var();
*piVar4 = iVar1;
if ((param_2 & 0x10) != 0) {
my_error(0x11,4,param_1,*piVar3);
}
}
return iVar2;
}
| |
24,985 | std::optional<std::vector<unsigned char, std::allocator<unsigned char>>> mjCAsset::GetVector<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | aimrt_mujoco_sim/_deps/mujoco-src/src/user/user_cache.cc | std::optional<std::vector<T>>
mjCAsset::GetVector(const std::string& name) const {
std::size_t n;
const T* ptr = Get<T>(name, &n);
if (ptr == nullptr) {
return std::nullopt;
}
return std::vector<T>(ptr, ptr + n);
} | O0 | cpp | std::optional<std::vector<unsigned char, std::allocator<unsigned char>>> mjCAsset::GetVector<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x314430
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x3148a3
movq 0x18(%rsp), %rdi
callq 0x314940
jmp 0x314921
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x68(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x314960
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x40(%rsp), %rdi
callq 0x314970
jmp 0x3148e2
movq 0x18(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x314a00
leaq 0x40(%rsp), %rdi
callq 0x314a30
leaq 0x3f(%rsp), %rdi
callq 0x314a90
jmp 0x314921
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x314a90
jmp 0x31492e
movq 0x20(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x4a070
nopl (%rax,%rax)
| _ZNK8mjCAsset9GetVectorIhEESt8optionalISt6vectorIT_SaIS3_EEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 88h
mov [rsp+88h+var_70], rdi
mov rax, rdi
mov [rsp+88h+var_68], rax
mov [rsp+88h+var_8], rdi
mov [rsp+88h+var_10], rsi
mov [rsp+88h+var_18], rdx
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_18]
lea rdx, [rsp+88h+var_20]
call _ZNK8mjCAsset3GetIhEEPKT_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPm; mjCAsset::Get<uchar>(std::string const&,ulong *)
mov [rsp+88h+var_28], rax
cmp [rsp+88h+var_28], 0
jnz short loc_3148A3
mov rdi, [rsp+88h+var_70]
call _ZNSt8optionalISt6vectorIhSaIhEEEC2ESt9nullopt_t; std::optional<std::vector<uchar>>::optional(std::nullopt_t)
jmp short loc_314921
loc_3148A3:
mov rax, [rsp+88h+var_28]
mov [rsp+88h+var_88], rax
mov rcx, [rsp+88h+var_20]
add rax, rcx
mov [rsp+88h+var_80], rax
lea rdi, [rsp+88h+var_49]
mov [rsp+88h+var_78], rdi
call _ZNSaIhEC2Ev; std::allocator<uchar>::allocator(void)
mov rsi, [rsp+88h+var_88]
mov rdx, [rsp+88h+var_80]
mov rcx, [rsp+88h+var_78]
lea rdi, [rsp+88h+var_48]
call _ZNSt6vectorIhSaIhEEC2IPKhvEET_S5_RKS0_; std::vector<uchar>::vector<uchar const*,void>(uchar const*,uchar const*,std::allocator<uchar> const&)
jmp short $+2
loc_3148E2:
mov rdi, [rsp+88h+var_70]
lea rsi, [rsp+88h+var_48]
call _ZNSt8optionalISt6vectorIhSaIhEEEC2IS2_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS3_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES6_IS7_ISt10in_place_tSE_EESt16is_constructibleIS2_JSA_EESt14is_convertibleISA_S2_EEEbE4typeELb1EEEOSA_
lea rdi, [rsp+88h+var_48]
call _ZNSt6vectorIhSaIhEED2Ev; std::vector<uchar>::~vector()
lea rdi, [rsp+88h+var_49]
call _ZNSaIhED2Ev; std::allocator<uchar>::~allocator()
jmp short loc_314921
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_37]
call _ZNSaIhED2Ev; std::allocator<uchar>::~allocator()
jmp short loc_31492E
loc_314921:
mov rax, [rsp+88h+var_68]
add rsp, 88h
retn
loc_31492E:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
| long long mjCAsset::GetVector<unsigned char>(long long a1, long long a2, long long a3)
{
int v3; // r8d
int v4; // r9d
long long v6; // [rsp+0h] [rbp-88h]
int v7; // [rsp+8h] [rbp-80h]
long long v8; // [rsp+18h] [rbp-70h]
long long v9; // [rsp+20h] [rbp-68h]
char v10; // [rsp+3Fh] [rbp-49h] BYREF
_BYTE v11[32]; // [rsp+40h] [rbp-48h] BYREF
long long v12; // [rsp+60h] [rbp-28h]
_QWORD v13[4]; // [rsp+68h] [rbp-20h] BYREF
v9 = a1;
v13[3] = a1;
v13[2] = a2;
v13[1] = a3;
v12 = mjCAsset::Get<unsigned char>(a2, a3, v13);
if ( v12 )
{
v6 = v12;
v7 = LODWORD(v13[0]) + v12;
std::allocator<unsigned char>::allocator();
std::vector<unsigned char>::vector<unsigned char const*,void>(
(unsigned int)v11,
v6,
v7,
(unsigned int)&v10,
v3,
v4,
v6,
v7,
(unsigned int)&v10,
a1,
a1);
ZNSt8optionalISt6vectorIhSaIhEEEC2IS2_TnNSt9enable_ifIX7__and_vISt6__not_ISt7is_sameIS3_NSt9remove_cvINSt16remove_referenceIT_E4typeEE4typeEEES6_IS7_ISt10in_place_tSE_EESt16is_constructibleIS2_JSA_EESt14is_convertibleISA_S2_EEEbE4typeELb1EEEOSA_(
v8,
v11);
std::vector<unsigned char>::~vector(v11);
std::allocator<unsigned char>::~allocator(&v10);
}
else
{
std::optional<std::vector<unsigned char>>::optional(a1);
}
return v9;
}
| |||
24,986 | std::optional<std::vector<unsigned char, std::allocator<unsigned char>>> mjCAsset::GetVector<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | aimrt_mujoco_sim/_deps/mujoco-src/src/user/user_cache.cc | std::optional<std::vector<T>>
mjCAsset::GetVector(const std::string& name) const {
std::size_t n;
const T* ptr = Get<T>(name, &n);
if (ptr == nullptr) {
return std::nullopt;
}
return std::vector<T>(ptr, ptr + n);
} | O3 | cpp | std::optional<std::vector<unsigned char, std::allocator<unsigned char>>> mjCAsset::GetVector<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x58(%rsi), %rdi
movq %rdx, %rsi
callq 0xbb1c2
testq %rax, %rax
je 0xb9d6e
movq 0x38(%rax), %rdx
testb $0x3, %dl
je 0xb9d7d
movb $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq 0x28(%rax), %rsi
testq %rsi, %rsi
je 0xb9d6e
addq %rsi, %rdx
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
callq 0xb7f92
vmovaps (%r14), %xmm0
vmovups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
jmp 0xb9d72
| _ZNK8mjCAsset9GetVectorIiEESt8optionalISt6vectorIT_SaIS3_EEERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push r14
push rbx
sub rsp, 28h
mov rbx, rdi
lea rdi, [rsi+58h]
mov rsi, rdx
call _ZNKSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_12mjCAssetDataESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,mjCAssetData>,std::allocator<std::pair<std::string const,mjCAssetData>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
test rax, rax
jz short loc_B9D6E
mov rdx, [rax+38h]
test dl, 3
jz short loc_B9D7D
loc_B9D6E:
mov byte ptr [rbx+18h], 0
loc_B9D72:
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
retn
loc_B9D7D:
mov rsi, [rax+28h]
test rsi, rsi
jz short loc_B9D6E
add rdx, rsi
lea r14, [rsp+38h+var_28]
lea rcx, [rsp+38h+var_29]
mov rdi, r14
call _ZNSt6vectorIiSaIiEEC2IPKivEET_S5_RKS0_; std::vector<int>::vector<int const*,void>(int const*,int const*,std::allocator<int> const&)
vmovaps xmm0, xmmword ptr [r14]
vmovups xmmword ptr [rbx], xmm0
mov rax, [r14+10h]
mov [rbx+10h], rax
mov byte ptr [rbx+18h], 1
jmp short loc_B9D72
| long long mjCAsset::GetVector<int>(long long a1, long long a2, long long a3, __m128 a4)
{
long long v5; // rax
_BYTE v9[16]; // [rsp+10h] [rbp-28h] BYREF
long long v10; // [rsp+20h] [rbp-18h]
_RBX = a1;
v5 = std::_Hashtable<std::string,std::pair<std::string const,mjCAssetData>,std::allocator<std::pair<std::string const,mjCAssetData>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
a2 + 88,
a3);
if ( v5 && (*(_QWORD *)(v5 + 56) & 3) == 0 && *(_QWORD *)(v5 + 40) )
{
_R14 = v9;
std::vector<int>::vector<int const*,void>((long long)v9, a4);
__asm
{
vmovaps xmm0, xmmword ptr [r14]
vmovups xmmword ptr [rbx], xmm0
}
*(_QWORD *)(a1 + 16) = v10;
*(_BYTE *)(a1 + 24) = 1;
}
else
{
*(_BYTE *)(a1 + 24) = 0;
}
return a1;
}
| GetVector<int>:
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RDI
LEA RDI,[RSI + 0x58]
MOV RSI,RDX
CALL 0x001bb1c2
TEST RAX,RAX
JZ 0x001b9d6e
MOV RDX,qword ptr [RAX + 0x38]
TEST DL,0x3
JZ 0x001b9d7d
LAB_001b9d6e:
MOV byte ptr [RBX + 0x18],0x0
LAB_001b9d72:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
RET
LAB_001b9d7d:
MOV RSI,qword ptr [RAX + 0x28]
TEST RSI,RSI
JZ 0x001b9d6e
ADD RDX,RSI
LEA R14,[RSP + 0x10]
LEA RCX,[RSP + 0xf]
MOV RDI,R14
CALL 0x001b7f92
VMOVAPS XMM0,xmmword ptr [R14]
VMOVUPS xmmword ptr [RBX],XMM0
MOV RAX,qword ptr [R14 + 0x10]
MOV qword ptr [RBX + 0x10],RAX
MOV byte ptr [RBX + 0x18],0x1
JMP 0x001b9d72
|
/* std::optional<std::vector<int, std::allocator<int> > >
mjCAsset::GetVector<int>(std::__cxx11::string const&) const */
string * mjCAsset::GetVector<int>(string *param_1)
{
int *piVar1;
long lVar2;
string *in_RDX;
long in_RSI;
int8 local_28;
int8 uStack_20;
int8 local_18;
lVar2 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,mjCAssetData>,std::allocator<std::pair<std::__cxx11::string_const,mjCAssetData>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,mjCAssetData>,std::allocator<std::pair<std::__cxx11::string_const,mjCAssetData>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
*)(in_RSI + 0x58),in_RDX);
if (((lVar2 == 0) || ((*(ulong *)(lVar2 + 0x38) & 3) != 0)) ||
(piVar1 = *(int **)(lVar2 + 0x28), piVar1 == (int *)0x0)) {
param_1[0x18] = (string)0x0;
}
else {
std::vector<int,std::allocator<int>>::vector<int_const*,void>
((int *)&local_28,piVar1,(allocator *)(*(ulong *)(lVar2 + 0x38) + (long)piVar1));
*(int8 *)param_1 = local_28;
*(int8 *)(param_1 + 8) = uStack_20;
*(int8 *)(param_1 + 0x10) = local_18;
param_1[0x18] = (string)0x1;
}
return param_1;
}
| |
24,987 | free_full_pages | eloqsql/storage/maria/ma_blockrec.c | static my_bool free_full_pages(MARIA_HA *info, MARIA_ROW *row)
{
uchar log_data[FILEID_STORE_SIZE + PAGERANGE_STORE_SIZE];
LEX_CUSTRING log_array[TRANSLOG_INTERNAL_PARTS + 2];
LSN lsn;
size_t extents_length;
uchar *extents= row->extents;
DBUG_ENTER("free_full_pages");
if (info->s->now_transactional)
{
/* Compact events by removing filler and tail events */
uchar *new_block= 0;
uchar *end, *to, *compact_extent_info;
my_bool res, buff_alloced;
uint extents_count;
alloc_on_stack(*info->stack_end_ptr, compact_extent_info, buff_alloced,
row->extents_count * ROW_EXTENT_SIZE);
if (!compact_extent_info)
DBUG_RETURN(1);
to= compact_extent_info;
for (end= extents + row->extents_count * ROW_EXTENT_SIZE ;
extents < end ;
extents+= ROW_EXTENT_SIZE)
{
uint page_count= uint2korr(extents + ROW_EXTENT_PAGE_SIZE);
page_count&= ~START_EXTENT_BIT;
if (! (page_count & TAIL_BIT) && page_count != 0)
{
/* Found correct extent */
if (!new_block)
new_block= extents; /* First extent in range */
continue;
}
/* Found extent to remove, copy everything found so far */
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
new_block= 0;
}
}
if (new_block)
{
size_t length= (size_t) (extents - new_block);
memcpy(to, new_block, length);
to+= length;
}
if (!unlikely(extents_length= (uint) (to - compact_extent_info)))
{
/*
No ranges. This happens in the rear case when we have a allocated
place for a blob on a tail page but it did fit into the main page.
*/
stack_alloc_free(compact_extent_info, buff_alloced);
DBUG_RETURN(0);
}
extents_count= (uint) (extents_length / ROW_EXTENT_SIZE);
pagerange_store(log_data + FILEID_STORE_SIZE, extents_count);
log_array[TRANSLOG_INTERNAL_PARTS + 0].str= log_data;
log_array[TRANSLOG_INTERNAL_PARTS + 0].length= sizeof(log_data);
log_array[TRANSLOG_INTERNAL_PARTS + 1].str= compact_extent_info;
log_array[TRANSLOG_INTERNAL_PARTS + 1].length= extents_length;
res= translog_write_record(&lsn, LOGREC_REDO_FREE_BLOCKS, info->trn,
info,
(translog_size_t) (sizeof(log_data) +
extents_length),
TRANSLOG_INTERNAL_PARTS + 2, log_array,
log_data, NULL);
stack_alloc_free(compact_extent_info, buff_alloced);
if (res)
DBUG_RETURN(1);
}
DBUG_RETURN(_ma_bitmap_free_full_pages(info, row->extents,
row->extents_count));
} | O3 | c | free_full_pages:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x10(%rsi), %r14
movq (%rdi), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x5e904
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
leaq -0xa0(%rbp), %r12
movq %r13, (%r12)
movq 0x78(%rbx), %rcx
movq (%rcx), %rcx
subq %r12, %rcx
subq %r13, %rcx
jbe 0x5e793
cmpq $0x10000, %rcx # imm = 0x10000
ja 0x5e776
cmpl $0x1000, %r13d # imm = 0x1000
jb 0x5e793
cmpq $0x8001, %rcx # imm = 0x8001
jb 0x5e793
movq %r15, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
movq %rsp, %rdi
leaq 0xf(%r13), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, %rsp
movb $0x1, %bl
jmp 0x5e7ca
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
movq %r13, %rsi
callq 0xa0cdd
testq %rax, %rax
je 0x5e86c
movq %rax, %rdi
movq %rbx, -0x40(%rbp)
movq %r15, -0x48(%rbp)
movl 0xac(%r15), %eax
leal (,%rax,8), %r13d
subl %eax, %r13d
xorl %ebx, %ebx
movq %rdi, %r15
testl %eax, %eax
je 0x5e84f
movl %ebx, -0x38(%rbp)
addq %r14, %r13
xorl %esi, %esi
movq %r14, %r12
movq %rdi, -0x50(%rbp)
movq %rdi, %r15
movzwl 0x5(%r14), %eax
testw %ax, %ax
sets %cl
testl $0xbfff, %eax # imm = 0xBFFF
sete %al
orb %cl, %al
jne 0x5e803
testq %rsi, %rsi
cmoveq %r14, %rsi
jmp 0x5e81e
testq %rsi, %rsi
je 0x5e81c
movq %r12, %rbx
subq %rsi, %rbx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x29080
addq %rbx, %r15
xorl %esi, %esi
addq $0x7, %r14
addq $0x7, %r12
cmpq %r13, %r14
jb 0x5e7e3
testq %rsi, %rsi
je 0x5e841
subq %rsi, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x29080
addq %r12, %r15
leaq -0xa0(%rbp), %r12
movq -0x50(%rbp), %rdi
movl -0x38(%rbp), %ebx
subq %rdi, %r15
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
andq %r15, %rax
jne 0x5e873
testb %bl, %bl
jne 0x5e865
callq 0xa0f0a
xorl %eax, %eax
jmp 0x5e916
movb $0x1, %al
jmp 0x5e916
movq %rdi, %r13
movl %r15d, %ecx
imulq $0x24924925, %rcx, %rcx # imm = 0x24924925
shrq $0x20, %rcx
movl %r15d, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x2, %edx
leaq -0x34(%rbp), %r10
movw %dx, 0x2(%r10)
movq %r10, -0x80(%rbp)
movq $0x4, -0x78(%rbp)
movq %rdi, -0x70(%rbp)
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rcx
movq 0x8(%rcx), %rdx
addl $0x4, %r15d
subq $0x8, %rsp
leaq -0x58(%rbp), %rdi
movl $0x8, %esi
movq %rcx, -0x40(%rbp)
movl %r15d, %r8d
movl $0x4, %r9d
pushq $0x0
pushq %r10
pushq %r12
callq 0x2a8ac
addq $0x20, %rsp
movl %eax, %r14d
testb %bl, %bl
jne 0x5e8f1
movq %r13, %rdi
callq 0xa0f0a
movb $0x1, %al
testb %r14b, %r14b
jne 0x5e916
movq -0x48(%rbp), %r15
movq 0x10(%r15), %r14
movq -0x40(%rbp), %rbx
movl 0xac(%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42a83
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x5e934
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| free_full_pages:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov r14, [rsi+10h]
mov rax, [rdi]
cmp byte ptr [rax+7E7h], 0
jz loc_5E904
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
lea r12, [rbp+var_A0]
mov [r12], r13
mov rcx, [rbx+78h]
mov rcx, [rcx]
sub rcx, r12
sub rcx, r13
jbe short loc_5E793
cmp rcx, offset stru_10000
ja short loc_5E776
cmp r13d, 1000h
jb short loc_5E793
cmp rcx, 8001h
jb short loc_5E793
loc_5E776:
mov [rbp+var_48], r15
mov [rbp+var_40], rbx
mov rdi, rsp
lea rcx, [r13+0Fh]
and rcx, 0FFFFFFFFFFFFFFF0h
sub rdi, rcx
mov rsp, rdi
mov bl, 1
jmp short loc_5E7CA
loc_5E793:
mov edx, 10010h
xor edi, edi
mov rsi, r13
call my_malloc
test rax, rax
jz loc_5E86C
mov rdi, rax
mov [rbp+var_40], rbx
mov [rbp+var_48], r15
mov eax, [r15+0ACh]
lea r13d, ds:0[rax*8]
sub r13d, eax
xor ebx, ebx
loc_5E7CA:
mov r15, rdi
test eax, eax
jz short loc_5E84F
mov [rbp+var_38], ebx
add r13, r14
xor esi, esi
mov r12, r14
mov [rbp+var_50], rdi
mov r15, rdi
loc_5E7E3:
movzx eax, word ptr [r14+5]
test ax, ax
sets cl
test eax, 0BFFFh
setz al
or al, cl
jnz short loc_5E803
test rsi, rsi
cmovz rsi, r14
jmp short loc_5E81E
loc_5E803:
test rsi, rsi
jz short loc_5E81C
mov rbx, r12
sub rbx, rsi
mov rdi, r15
mov rdx, rbx
call _memcpy
add r15, rbx
loc_5E81C:
xor esi, esi
loc_5E81E:
add r14, 7
add r12, 7
cmp r14, r13
jb short loc_5E7E3
test rsi, rsi
jz short loc_5E841
sub r12, rsi
mov rdi, r15
mov rdx, r12
call _memcpy
add r15, r12
loc_5E841:
lea r12, [rbp+var_A0]
mov rdi, [rbp+var_50]
mov ebx, [rbp+var_38]
loc_5E84F:
sub r15, rdi
mov eax, 0FFFFFFFFh
and rax, r15
jnz short loc_5E873
test bl, bl
jnz short loc_5E865
call my_free
loc_5E865:
xor eax, eax
jmp loc_5E916
loc_5E86C:
mov al, 1
jmp loc_5E916
loc_5E873:
mov r13, rdi
mov ecx, r15d
imul rcx, 24924925h
shr rcx, 20h
mov edx, r15d
sub edx, ecx
shr edx, 1
add edx, ecx
shr edx, 2
lea r10, [rbp+var_34]
mov [r10+2], dx
mov [rbp+var_80], r10
mov [rbp+var_78], 4
mov [rbp+var_70], rdi
mov [rbp+var_68], rax
mov rcx, [rbp+var_40]
mov rdx, [rcx+8]
add r15d, 4
sub rsp, 8
lea rdi, [rbp+var_58]
mov esi, 8
mov [rbp+var_40], rcx
mov r8d, r15d
mov r9d, 4
push 0
push r10
push r12
call translog_write_record
add rsp, 20h
mov r14d, eax
test bl, bl
jnz short loc_5E8F1
mov rdi, r13
call my_free
loc_5E8F1:
mov al, 1
test r14b, r14b
jnz short loc_5E916
mov r15, [rbp+var_48]
mov r14, [r15+10h]
mov rbx, [rbp+var_40]
loc_5E904:
mov edx, [r15+0ACh]
mov rdi, rbx
mov rsi, r14
call _ma_bitmap_free_full_pages
loc_5E916:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz short loc_5E934
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5E934:
call ___stack_chk_fail
| char free_full_pages(long long *a1, long long a2)
{
long long v2; // r15
long long *v3; // rbx
unsigned long long v4; // r14
int v5; // eax
unsigned long long v6; // r13
unsigned long long v7; // rcx
bool v8; // cc
unsigned long long v9; // rcx
char *v10; // rdi
long long v11; // rax
char *v12; // r15
unsigned long long v13; // r13
unsigned long long v14; // rsi
unsigned long long v15; // r12
unsigned long long v16; // r12
unsigned int v17; // r15d
char result; // al
char v19; // r14
_OWORD v20[2]; // [rsp+0h] [rbp-A0h] BYREF
_WORD *v21; // [rsp+20h] [rbp-80h]
long long v22; // [rsp+28h] [rbp-78h]
char *v23; // [rsp+30h] [rbp-70h]
long long v24; // [rsp+38h] [rbp-68h]
char v25[8]; // [rsp+48h] [rbp-58h] BYREF
char *v26; // [rsp+50h] [rbp-50h]
long long v27; // [rsp+58h] [rbp-48h]
long long *v28; // [rsp+60h] [rbp-40h]
int v29; // [rsp+68h] [rbp-38h]
_WORD v30[2]; // [rsp+6Ch] [rbp-34h] BYREF
unsigned long long v31; // [rsp+70h] [rbp-30h]
v2 = a2;
v3 = a1;
v31 = __readfsqword(0x28u);
v4 = *(_QWORD *)(a2 + 16);
if ( !*(_BYTE *)(*a1 + 2023) )
return ma_bitmap_free_full_pages(v3, (unsigned int *)v4, *(_DWORD *)(v2 + 172));
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
*(_QWORD *)&v20[0] = v6;
v7 = *(_QWORD *)a1[15] - (_QWORD)v20;
v8 = v7 <= v6;
v9 = v7 - v6;
if ( v8 || v9 <= (unsigned long long)&stru_10000 && ((unsigned int)v6 < 0x1000 || v9 < 0x8001) )
{
v11 = my_malloc(0LL, (unsigned int)(7 * v5), 65552LL);
if ( !v11 )
return 1;
v10 = (char *)v11;
v28 = v3;
v27 = a2;
v5 = *(_DWORD *)(a2 + 172);
v6 = (unsigned int)(7 * v5);
LODWORD(v3) = 0;
}
else
{
v27 = a2;
v28 = a1;
v10 = (char *)v20 - ((v6 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v3) = 1;
}
LODWORD(v12) = (_DWORD)v10;
if ( v5 )
{
v29 = (int)v3;
v13 = v4 + v6;
v14 = 0LL;
v15 = v4;
v26 = v10;
v12 = v10;
do
{
if ( *(__int16 *)(v4 + 5) < 0 || (*(_WORD *)(v4 + 5) & 0xBFFF) == 0 )
{
if ( v14 )
{
memcpy(v12, v14, v15 - v14);
v12 += v15 - v14;
}
v14 = 0LL;
}
else if ( !v14 )
{
v14 = v4;
}
v4 += 7LL;
v15 += 7LL;
}
while ( v4 < v13 );
if ( v14 )
{
v16 = v15 - v14;
memcpy(v12, v14, v16);
LODWORD(v12) = v16 + (_DWORD)v12;
}
v10 = v26;
LOBYTE(v3) = v29;
}
v17 = (_DWORD)v12 - (_DWORD)v10;
if ( !v17 )
{
if ( !(_BYTE)v3 )
my_free(v10);
return 0;
}
v30[1] = v17 / 7;
v21 = v30;
v22 = 4LL;
v23 = v10;
v24 = v17;
v19 = translog_write_record((unsigned long long)v25, &byte_8, v28[1], v28, v17 + 4, 4, v20, v30, 0LL);
if ( !(_BYTE)v3 )
my_free(v10);
result = 1;
if ( !v19 )
{
v2 = v27;
v4 = *(_QWORD *)(v27 + 16);
v3 = v28;
return ma_bitmap_free_full_pages(v3, (unsigned int *)v4, *(_DWORD *)(v2 + 172));
}
return result;
}
| free_full_pages:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R15,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV R14,qword ptr [RSI + 0x10]
MOV RAX,qword ptr [RDI]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0015e904
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
LEA R12,[RBP + -0xa0]
MOV qword ptr [R12],R13
MOV RCX,qword ptr [RBX + 0x78]
MOV RCX,qword ptr [RCX]
SUB RCX,R12
SUB RCX,R13
JBE 0x0015e793
CMP RCX,0x10000
JA 0x0015e776
CMP R13D,0x1000
JC 0x0015e793
CMP RCX,0x8001
JC 0x0015e793
LAB_0015e776:
MOV qword ptr [RBP + -0x48],R15
MOV qword ptr [RBP + -0x40],RBX
MOV RDI,RSP
LEA RCX,[R13 + 0xf]
AND RCX,-0x10
SUB RDI,RCX
MOV RSP,RDI
MOV BL,0x1
JMP 0x0015e7ca
LAB_0015e793:
MOV EDX,0x10010
XOR EDI,EDI
MOV RSI,R13
CALL 0x001a0cdd
TEST RAX,RAX
JZ 0x0015e86c
MOV RDI,RAX
MOV qword ptr [RBP + -0x40],RBX
MOV qword ptr [RBP + -0x48],R15
MOV EAX,dword ptr [R15 + 0xac]
LEA R13D,[RAX*0x8]
SUB R13D,EAX
XOR EBX,EBX
LAB_0015e7ca:
MOV R15,RDI
TEST EAX,EAX
JZ 0x0015e84f
MOV dword ptr [RBP + -0x38],EBX
ADD R13,R14
XOR ESI,ESI
MOV R12,R14
MOV qword ptr [RBP + -0x50],RDI
MOV R15,RDI
LAB_0015e7e3:
MOVZX EAX,word ptr [R14 + 0x5]
TEST AX,AX
SETS CL
TEST EAX,0xbfff
SETZ AL
OR AL,CL
JNZ 0x0015e803
TEST RSI,RSI
CMOVZ RSI,R14
JMP 0x0015e81e
LAB_0015e803:
TEST RSI,RSI
JZ 0x0015e81c
MOV RBX,R12
SUB RBX,RSI
MOV RDI,R15
MOV RDX,RBX
CALL 0x00129080
ADD R15,RBX
LAB_0015e81c:
XOR ESI,ESI
LAB_0015e81e:
ADD R14,0x7
ADD R12,0x7
CMP R14,R13
JC 0x0015e7e3
TEST RSI,RSI
JZ 0x0015e841
SUB R12,RSI
MOV RDI,R15
MOV RDX,R12
CALL 0x00129080
ADD R15,R12
LAB_0015e841:
LEA R12,[RBP + -0xa0]
MOV RDI,qword ptr [RBP + -0x50]
MOV EBX,dword ptr [RBP + -0x38]
LAB_0015e84f:
SUB R15,RDI
MOV EAX,0xffffffff
AND RAX,R15
JNZ 0x0015e873
TEST BL,BL
JNZ 0x0015e865
CALL 0x001a0f0a
LAB_0015e865:
XOR EAX,EAX
JMP 0x0015e916
LAB_0015e86c:
MOV AL,0x1
JMP 0x0015e916
LAB_0015e873:
MOV R13,RDI
MOV ECX,R15D
IMUL RCX,RCX,0x24924925
SHR RCX,0x20
MOV EDX,R15D
SUB EDX,ECX
SHR EDX,0x1
ADD EDX,ECX
SHR EDX,0x2
LEA R10,[RBP + -0x34]
MOV word ptr [R10 + 0x2],DX
MOV qword ptr [RBP + -0x80],R10
MOV qword ptr [RBP + -0x78],0x4
MOV qword ptr [RBP + -0x70],RDI
MOV qword ptr [RBP + -0x68],RAX
MOV RCX,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RCX + 0x8]
ADD R15D,0x4
SUB RSP,0x8
LEA RDI,[RBP + -0x58]
MOV ESI,0x8
MOV qword ptr [RBP + -0x40],RCX
MOV R8D,R15D
MOV R9D,0x4
PUSH 0x0
PUSH R10
PUSH R12
CALL 0x0012a8ac
ADD RSP,0x20
MOV R14D,EAX
TEST BL,BL
JNZ 0x0015e8f1
MOV RDI,R13
CALL 0x001a0f0a
LAB_0015e8f1:
MOV AL,0x1
TEST R14B,R14B
JNZ 0x0015e916
MOV R15,qword ptr [RBP + -0x48]
MOV R14,qword ptr [R15 + 0x10]
MOV RBX,qword ptr [RBP + -0x40]
LAB_0015e904:
MOV EDX,dword ptr [R15 + 0xac]
MOV RDI,RBX
MOV RSI,R14
CALL 0x00142a83
LAB_0015e916:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x0015e934
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015e934:
CALL 0x00129270
|
int8 free_full_pages(long *param_1,long param_2)
{
int4 uVar1;
long lVar2;
long *plVar3;
ulong *puVar4;
char cVar5;
int8 uVar6;
int iVar7;
ulong uVar8;
ulong *puVar9;
void *__src;
int1 *puVar10;
void *pvVar11;
void *pvVar12;
void *pvVar13;
int1 *__dest;
ulong uVar14;
long in_FS_OFFSET;
ulong local_a8 [4];
int1 *local_88;
int8 local_80;
int1 *local_78;
ulong local_70;
int1 local_60 [8];
int1 *local_58;
long local_50;
long *local_48;
uint local_40;
int1 local_3c [2];
int2 local_3a;
long local_38;
puVar9 = local_a8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pvVar11 = *(void **)(param_2 + 0x10);
puVar4 = local_a8;
if (*(char *)(*param_1 + 0x7e7) != '\0') {
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = (*(long *)param_1[0xf] - (long)local_a8) - uVar14;
local_a8[0] = uVar14;
if ((uVar14 < (ulong)(*(long *)param_1[0xf] - (long)local_a8)) &&
((0x10000 < uVar8 || ((0xfff < (uint)(iVar7 * 7) && (0x8000 < uVar8)))))) {
__dest = (int1 *)((long)local_a8 - (uVar14 + 0xf & 0xfffffffffffffff0));
uVar8 = CONCAT71((int7)((ulong)param_1 >> 8),1);
puVar9 = (ulong *)__dest;
}
else {
__dest = (int1 *)my_malloc(0,uVar14,0x10010);
if (__dest == (int1 *)0x0) {
uVar6 = 1;
goto LAB_0015e916;
}
iVar7 = *(int *)(param_2 + 0xac);
uVar14 = (ulong)(uint)(iVar7 * 7);
uVar8 = 0;
puVar9 = local_a8;
}
puVar10 = __dest;
local_50 = param_2;
local_48 = param_1;
if (iVar7 != 0) {
local_40 = (uint)uVar8;
pvVar12 = (void *)(uVar14 + (long)pvVar11);
__src = (void *)0x0;
pvVar13 = pvVar11;
local_58 = __dest;
do {
if ((*(ushort *)((long)pvVar13 + 5) & 0xbfff) == 0 ||
(short)*(ushort *)((long)pvVar13 + 5) < 0) {
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x15e819;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
__src = (void *)0x0;
}
else if (__src == (void *)0x0) {
__src = pvVar13;
}
pvVar13 = (void *)((long)pvVar13 + 7);
pvVar11 = (void *)((long)pvVar11 + 7);
} while (pvVar13 < pvVar12);
if (__src != (void *)0x0) {
*(int8 *)((long)puVar9 + -8) = 0x15e83e;
memcpy(__dest,__src,(long)pvVar11 - (long)__src);
__dest = __dest + ((long)pvVar11 - (long)__src);
}
uVar8 = (ulong)local_40;
puVar10 = local_58;
}
plVar3 = local_48;
uVar14 = (long)__dest - (long)puVar10;
if ((uVar14 & 0xffffffff) == 0) {
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x15e865;
my_free();
}
uVar6 = 0;
goto LAB_0015e916;
}
iVar7 = (int)((uVar14 & 0xffffffff) * 0x24924925 >> 0x20);
local_3a = (int2)(((uint)((int)uVar14 - iVar7) >> 1) + iVar7 >> 2);
local_80 = 4;
lVar2 = local_48[1];
local_88 = local_3c;
local_78 = puVar10;
local_70 = uVar14 & 0xffffffff;
*(int8 *)((long)puVar9 + -0x10) = 0;
*(int1 **)((long)puVar9 + -0x18) = local_3c;
*(ulong **)((long)puVar9 + -0x20) = local_a8;
*(int8 *)((long)puVar9 + -0x28) = 0x15e8de;
cVar5 = translog_write_record(local_60,8,lVar2,plVar3,(int)uVar14 + 4,4);
if ((char)uVar8 == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x15e8f1;
my_free(puVar10);
}
uVar6 = 1;
if (cVar5 != '\0') goto LAB_0015e916;
pvVar11 = *(void **)(local_50 + 0x10);
param_1 = local_48;
puVar4 = puVar9;
param_2 = local_50;
}
puVar9 = puVar4;
uVar1 = *(int4 *)(param_2 + 0xac);
*(int8 *)((long)puVar9 + -8) = 0x15e916;
uVar6 = _ma_bitmap_free_full_pages(param_1,pvVar11,uVar1);
LAB_0015e916:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_read_block_record2;
__stack_chk_fail();
}
return uVar6;
}
| |
24,988 | rtree_estimate | eloqsql/storage/myisam/rt_index.c | ha_rows rtree_estimate(MI_INFO *info, uint keynr, uchar *key,
uint key_length, uint flag)
{
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
my_off_t root;
uint i = 0;
uchar *k;
uchar *last;
uint nod_flag;
uchar *page_buf;
uint k_len;
double area = 0;
ha_rows res = 0;
if (flag & MBR_DISJOINT)
return HA_POS_ERROR;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
return HA_POS_ERROR;
if (!(page_buf = (uchar*)my_alloca((uint)keyinfo->block_length)))
return HA_POS_ERROR;
if (!_mi_fetch_keypage(info, keyinfo, root, DFLT_INIT_HITS, page_buf, 0))
goto err1;
nod_flag = mi_test_if_nod(page_buf);
k_len = keyinfo->keylength - info->s->base.rec_reflength;
k = rt_PAGE_FIRST_KEY(page_buf, nod_flag);
last = rt_PAGE_END(page_buf);
for (; k < last; k = rt_PAGE_NEXT_KEY(k, k_len, nod_flag), ++i)
{
if (nod_flag)
{
double k_area = rtree_rect_volume(keyinfo->seg, k, key_length);
/* The following should be safe, even if we compare doubles */
if (k_area == 0)
{
if (flag & (MBR_CONTAIN | MBR_INTERSECT))
{
area += 1;
}
else if (flag & (MBR_WITHIN | MBR_EQUAL))
{
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_WITHIN))
area += 1;
}
else
goto err1;
}
else
{
if (flag & (MBR_CONTAIN | MBR_INTERSECT))
{
area += rtree_overlapping_area(keyinfo->seg, key, k, key_length) /
k_area;
}
else if (flag & (MBR_WITHIN | MBR_EQUAL))
{
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, MBR_WITHIN))
area += rtree_rect_volume(keyinfo->seg, key, key_length) /
k_area;
}
else
goto err1;
}
}
else
{
if (!rtree_key_cmp(keyinfo->seg, key, k, key_length, flag))
++res;
}
}
if (nod_flag)
{
if (i)
res = (ha_rows) (area / i * info->state->records);
else
res = HA_POS_ERROR;
}
my_afree((uchar*)page_buf);
return res;
err1:
my_afree((uchar*)page_buf);
return HA_POS_ERROR;
} | O0 | c | rtree_estimate:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movl %r8d, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x218(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x44(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movl -0x30(%rbp), %eax
andl $0x1000, %eax # imm = 0x1000
cmpl $0x0, %eax
je 0x562f7
movq $-0x1, -0x10(%rbp)
jmp 0x56683
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x98(%rax), %rax
movl -0x1c(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
cmpq $-0x1, %rax
jne 0x56323
movq $-0x1, -0x10(%rbp)
jmp 0x56683
movq -0x38(%rbp), %rax
movzwl 0xe(%rax), %eax
addl $0xf, %eax
andl $-0x10, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x56353
movq $-0x1, -0x10(%rbp)
jmp 0x56683
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x68(%rbp), %r8
movl $0x3, %ecx
xorl %r9d, %r9d
callq 0x685f0
cmpq $0x0, %rax
jne 0x5637b
jmp 0x5667b
movq -0x68(%rbp), %rax
movzbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x563a1
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x17c(%rax), %eax
movl %eax, -0x8c(%rbp)
jmp 0x563ab
xorl %eax, %eax
movl %eax, -0x8c(%rbp)
jmp 0x563ab
movl -0x8c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x38(%rbp), %rax
movzwl 0x12(%rax), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
subl 0x178(%rcx), %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
addq $0x2, %rax
movl -0x5c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x68(%rbp), %rax
movq -0x68(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
movq -0x68(%rbp), %rdx
movzbl (%rdx), %edx
movzwl %dx, %edx
shll $0x8, %edx
orl %edx, %ecx
movzwl %cx, %ecx
andl $0x7fff, %ecx # imm = 0x7FFF
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x565ec
cmpl $0x0, -0x5c(%rbp)
je 0x56562
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x50(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x58a50
movsd %xmm0, -0x88(%rbp)
movsd -0x88(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x564c6
jp 0x564c6
movl -0x30(%rbp), %eax
andl $0x600, %eax # imm = 0x600
cmpl $0x0, %eax
je 0x56476
movsd 0x8cbbe(%rip), %xmm0 # 0xe3028
addsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x564c1
movl -0x30(%rbp), %eax
andl $0x2800, %eax # imm = 0x2800
cmpl $0x0, %eax
je 0x564ba
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl $0x800, %r8d # imm = 0x800
callq 0x57000
cmpl $0x0, %eax
jne 0x564b8
movsd 0x8cb7a(%rip), %xmm0 # 0xe3028
addsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x564bf
jmp 0x5667b
jmp 0x564c1
jmp 0x56560
movl -0x30(%rbp), %eax
andl $0x600, %eax # imm = 0x600
cmpl $0x0, %eax
je 0x564ff
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5b250
divsd -0x88(%rbp), %xmm0
addsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x5655e
movl -0x30(%rbp), %eax
andl $0x2800, %eax # imm = 0x2800
cmpl $0x0, %eax
je 0x56557
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl $0x800, %r8d # imm = 0x800
callq 0x57000
cmpl $0x0, %eax
jne 0x56555
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x58a50
divsd -0x88(%rbp), %xmm0
addsd -0x78(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
jmp 0x5655c
jmp 0x5667b
jmp 0x5655e
jmp 0x56560
jmp 0x56591
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x50(%rbp), %rdx
movl -0x2c(%rbp), %ecx
movl -0x30(%rbp), %r8d
callq 0x57000
cmpl $0x0, %eax
jne 0x5658f
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x56591
jmp 0x56593
movq -0x50(%rbp), %rax
movl -0x6c(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0x565b5
movl -0x5c(%rbp), %eax
movl %eax, -0x9c(%rbp)
jmp 0x565c8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x178(%rax), %eax
movl %eax, -0x9c(%rbp)
movq -0x98(%rbp), %rax
movl -0x9c(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x5640e
cmpl $0x0, -0x5c(%rbp)
je 0x56671
cmpl $0x0, -0x44(%rbp)
je 0x56667
movsd -0x78(%rbp), %xmm0
movl -0x44(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %xmm1
movaps 0x94604(%rip), %xmm2 # 0xeac20
punpckldq %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x94608(%rip), %xmm2 # 0xeac30
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1 # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x8c9ce(%rip), %xmm1 # 0xe3020
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x80(%rbp)
jmp 0x5666f
movq $-0x1, -0x80(%rbp)
jmp 0x56671
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x56683
movq $-0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x566ac
movq -0xa8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
callq 0x29420
nopw %cs:(%rax,%rax)
| rtree_estimate:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_1C], esi
mov [rbp+var_28], rdx
mov [rbp+var_2C], ecx
mov [rbp+var_30], r8d
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+218h]
mov ecx, [rbp+var_1C]
imul rcx, 70h ; 'p'
add rax, rcx
mov [rbp+var_38], rax
mov [rbp+var_44], 0
xorps xmm0, xmm0
movsd [rbp+var_78], xmm0
mov [rbp+var_80], 0
mov eax, [rbp+var_30]
and eax, 1000h
cmp eax, 0
jz short loc_562F7
mov [rbp+var_10], 0FFFFFFFFFFFFFFFFh
jmp loc_56683
loc_562F7:
mov rax, [rbp+var_18]
mov rax, [rax]
mov rax, [rax+98h]
mov ecx, [rbp+var_1C]
mov rax, [rax+rcx*8]
mov [rbp+var_40], rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_56323
mov [rbp+var_10], 0FFFFFFFFFFFFFFFFh
jmp loc_56683
loc_56323:
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+0Eh]
add eax, 0Fh
and eax, 0FFFFFFF0h
mov ecx, eax
mov rax, rsp
sub rax, rcx
mov rsp, rax
mov [rbp+var_68], rax
cmp rax, 0
jnz short loc_56353
mov [rbp+var_10], 0FFFFFFFFFFFFFFFFh
jmp loc_56683
loc_56353:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_40]
mov r8, [rbp+var_68]
mov ecx, 3
xor r9d, r9d
call _mi_fetch_keypage
cmp rax, 0
jnz short loc_5637B
jmp loc_5667B
loc_5637B:
mov rax, [rbp+var_68]
movzx eax, byte ptr [rax]
and eax, 80h
cmp eax, 0
jz short loc_563A1
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+17Ch]
mov [rbp+var_8C], eax
jmp short loc_563AB
loc_563A1:
xor eax, eax
mov [rbp+var_8C], eax
jmp short $+2
loc_563AB:
mov eax, [rbp+var_8C]
mov [rbp+var_5C], eax
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+12h]
mov rcx, [rbp+var_18]
mov rcx, [rcx]
sub eax, [rcx+178h]
mov [rbp+var_6C], eax
mov rax, [rbp+var_68]
add rax, 2
mov ecx, [rbp+var_5C]
add rax, rcx
mov [rbp+var_50], rax
mov rax, [rbp+var_68]
mov rcx, [rbp+var_68]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
mov rdx, [rbp+var_68]
movzx edx, byte ptr [rdx]
movzx edx, dx
shl edx, 8
or ecx, edx
movzx ecx, cx
and ecx, 7FFFh
mov ecx, ecx
add rax, rcx
mov [rbp+var_58], rax
loc_5640E:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_58]
jnb loc_565EC
cmp [rbp+var_5C], 0
jz loc_56562
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_50]
mov edx, [rbp+var_2C]
call rtree_rect_volume
movsd [rbp+var_88], xmm0
movsd xmm0, [rbp+var_88]
xorps xmm1, xmm1
ucomisd xmm0, xmm1
jnz short loc_564C6
jp short loc_564C6
mov eax, [rbp+var_30]
and eax, 600h
cmp eax, 0
jz short loc_56476
movsd xmm0, cs:qword_E3028
addsd xmm0, [rbp+var_78]
movsd [rbp+var_78], xmm0
jmp short loc_564C1
loc_56476:
mov eax, [rbp+var_30]
and eax, 2800h
cmp eax, 0
jz short loc_564BA
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_2C]
mov r8d, 800h
call rtree_key_cmp
cmp eax, 0
jnz short loc_564B8
movsd xmm0, cs:qword_E3028
addsd xmm0, [rbp+var_78]
movsd [rbp+var_78], xmm0
loc_564B8:
jmp short loc_564BF
loc_564BA:
jmp loc_5667B
loc_564BF:
jmp short $+2
loc_564C1:
jmp loc_56560
loc_564C6:
mov eax, [rbp+var_30]
and eax, 600h
cmp eax, 0
jz short loc_564FF
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_2C]
call rtree_overlapping_area
divsd xmm0, [rbp+var_88]
addsd xmm0, [rbp+var_78]
movsd [rbp+var_78], xmm0
jmp short loc_5655E
loc_564FF:
mov eax, [rbp+var_30]
and eax, 2800h
cmp eax, 0
jz short loc_56557
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_2C]
mov r8d, 800h
call rtree_key_cmp
cmp eax, 0
jnz short loc_56555
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_28]
mov edx, [rbp+var_2C]
call rtree_rect_volume
divsd xmm0, [rbp+var_88]
addsd xmm0, [rbp+var_78]
movsd [rbp+var_78], xmm0
loc_56555:
jmp short loc_5655C
loc_56557:
jmp loc_5667B
loc_5655C:
jmp short $+2
loc_5655E:
jmp short $+2
loc_56560:
jmp short loc_56591
loc_56562:
mov rax, [rbp+var_38]
mov rdi, [rax+28h]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_50]
mov ecx, [rbp+var_2C]
mov r8d, [rbp+var_30]
call rtree_key_cmp
cmp eax, 0
jnz short loc_5658F
mov rax, [rbp+var_80]
add rax, 1
mov [rbp+var_80], rax
loc_5658F:
jmp short $+2
loc_56591:
jmp short $+2
loc_56593:
mov rax, [rbp+var_50]
mov ecx, [rbp+var_6C]
add rax, rcx
mov [rbp+var_98], rax
cmp [rbp+var_5C], 0
jz short loc_565B5
mov eax, [rbp+var_5C]
mov [rbp+var_9C], eax
jmp short loc_565C8
loc_565B5:
mov rax, [rbp+var_18]
mov rax, [rax]
mov eax, [rax+178h]
mov [rbp+var_9C], eax
loc_565C8:
mov rax, [rbp+var_98]
mov ecx, [rbp+var_9C]
mov ecx, ecx
add rax, rcx
mov [rbp+var_50], rax
mov eax, [rbp+var_44]
add eax, 1
mov [rbp+var_44], eax
jmp loc_5640E
loc_565EC:
cmp [rbp+var_5C], 0
jz short loc_56671
cmp [rbp+var_44], 0
jz short loc_56667
movsd xmm0, [rbp+var_78]
mov eax, [rbp+var_44]
cvtsi2sd xmm1, rax
divsd xmm0, xmm1
mov rax, [rbp+var_18]
mov rax, [rax+8]
movq xmm1, qword ptr [rax]
movaps xmm2, cs:xmmword_EAC20
punpckldq xmm1, xmm2
movapd xmm2, cs:xmmword_EAC30
subpd xmm1, xmm2
movaps xmm2, xmm1
unpckhpd xmm1, xmm1
addsd xmm1, xmm2
mulsd xmm0, xmm1
movaps xmm1, xmm0
cvttsd2si rax, xmm1
mov rdx, rax
sar rdx, 3Fh
movsd xmm1, cs:qword_E3020
subsd xmm0, xmm1
cvttsd2si rcx, xmm0
and rcx, rdx
or rax, rcx
mov [rbp+var_80], rax
jmp short loc_5666F
loc_56667:
mov [rbp+var_80], 0FFFFFFFFFFFFFFFFh
loc_5666F:
jmp short $+2
loc_56671:
mov rax, [rbp+var_80]
mov [rbp+var_10], rax
jmp short loc_56683
loc_5667B:
mov [rbp+var_10], 0FFFFFFFFFFFFFFFFh
loc_56683:
mov rax, [rbp+var_10]
mov [rbp+var_A8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_566AC
mov rax, [rbp+var_A8]
mov rsp, rbp
pop rbp
retn
loc_566AC:
call ___stack_chk_fail
| long long rtree_estimate(_QWORD *a1, unsigned int a2, long long a3, unsigned int a4, unsigned int a5)
{
char *v5; // rcx
double v6; // xmm0_8
double v7; // xmm0_8
__m128d v8; // xmm2
long long v10; // [rsp+0h] [rbp-B0h] BYREF
unsigned int v11; // [rsp+14h] [rbp-9Ch]
unsigned long long v12; // [rsp+18h] [rbp-98h]
unsigned int v13; // [rsp+24h] [rbp-8Ch]
double v14; // [rsp+28h] [rbp-88h]
long long v15; // [rsp+30h] [rbp-80h]
double v16; // [rsp+38h] [rbp-78h]
unsigned int v17; // [rsp+44h] [rbp-6Ch]
unsigned __int16 *v18; // [rsp+48h] [rbp-68h]
unsigned int v19; // [rsp+54h] [rbp-5Ch]
char *v20; // [rsp+58h] [rbp-58h]
unsigned long long v21; // [rsp+60h] [rbp-50h]
int v22; // [rsp+6Ch] [rbp-44h]
long long v23; // [rsp+70h] [rbp-40h]
long long v24; // [rsp+78h] [rbp-38h]
unsigned int v25; // [rsp+80h] [rbp-30h]
unsigned int v26; // [rsp+84h] [rbp-2Ch]
long long v27; // [rsp+88h] [rbp-28h]
unsigned int v28; // [rsp+94h] [rbp-1Ch]
_QWORD *v29; // [rsp+98h] [rbp-18h]
unsigned long long v31; // [rsp+A8h] [rbp-8h]
v31 = __readfsqword(0x28u);
v29 = a1;
v28 = a2;
v27 = a3;
v26 = a4;
v25 = a5;
v24 = 112LL * a2 + *(_QWORD *)(*a1 + 536LL);
v22 = 0;
v16 = 0.0;
v15 = 0LL;
if ( (a5 & 0x1000) != 0 )
return -1LL;
v23 = *(_QWORD *)(*(_QWORD *)(*v29 + 152LL) + 8LL * v28);
if ( v23 == -1 )
return -1LL;
v5 = (char *)((*(unsigned __int16 *)(v24 + 14) + 15) & 0xFFFFFFF0);
v18 = (unsigned __int16 *)((char *)&v10 - v5);
if ( &v10 == (long long *)v5 )
return -1LL;
if ( !mi_fetch_keypage(v29, v24, v23, 3LL, v18, 0LL) )
return -1LL;
if ( (*(_BYTE *)v18 & 0x80) != 0 )
v13 = *(_DWORD *)(*v29 + 380LL);
else
v13 = 0;
v19 = v13;
v17 = *(unsigned __int16 *)(v24 + 18) - *(_DWORD *)(*v29 + 376LL);
v21 = (unsigned long long)v18 + v13 + 2;
v20 = (char *)v18 + (_byteswap_ushort(*v18) & 0x7FFF);
while ( v21 < (unsigned long long)v20 )
{
if ( v19 )
{
v14 = rtree_rect_volume(*(_QWORD *)(v24 + 40), v21, v26);
if ( v14 == 0.0 )
{
if ( (v25 & 0x600) != 0 )
{
v16 = v16 + 1.0;
}
else
{
if ( (v25 & 0x2800) == 0 )
return -1LL;
if ( !(unsigned int)rtree_key_cmp(*(_QWORD *)(v24 + 40), v27, v21, v26, 2048LL) )
v16 = v16 + 1.0;
}
}
else if ( (v25 & 0x600) != 0 )
{
v6 = rtree_overlapping_area(*(_QWORD *)(v24 + 40), v27, v21, v26);
v16 = v6 / v14 + v16;
}
else
{
if ( (v25 & 0x2800) == 0 )
return -1LL;
if ( !(unsigned int)rtree_key_cmp(*(_QWORD *)(v24 + 40), v27, v21, v26, 2048LL) )
{
v7 = rtree_rect_volume(*(_QWORD *)(v24 + 40), v27, v26);
v16 = v7 / v14 + v16;
}
}
}
else if ( !(unsigned int)rtree_key_cmp(*(_QWORD *)(v24 + 40), v27, v21, v26, v25) )
{
++v15;
}
v12 = v17 + v21;
if ( v19 )
v11 = v19;
else
v11 = *(_DWORD *)(*v29 + 376LL);
v21 = v11 + v12;
++v22;
}
if ( v19 )
{
if ( v22 )
{
v8 = _mm_sub_pd(
(__m128d)_mm_unpacklo_epi32(_mm_loadl_epi64((const __m128i *)v29[1]), (__m128i)xmmword_EAC20),
(__m128d)xmmword_EAC30);
return (unsigned int)(int)(v16 / (double)v22 * (_mm_unpackhi_pd(v8, v8).m128d_f64[0] + v8.m128d_f64[0]));
}
else
{
return -1LL;
}
}
return v15;
}
| rtree_estimate:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV dword ptr [RBP + -0x1c],ESI
MOV qword ptr [RBP + -0x28],RDX
MOV dword ptr [RBP + -0x2c],ECX
MOV dword ptr [RBP + -0x30],R8D
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
MOV ECX,dword ptr [RBP + -0x1c]
IMUL RCX,RCX,0x70
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x44],0x0
XORPS XMM0,XMM0
MOVSD qword ptr [RBP + -0x78],XMM0
MOV qword ptr [RBP + -0x80],0x0
MOV EAX,dword ptr [RBP + -0x30]
AND EAX,0x1000
CMP EAX,0x0
JZ 0x001562f7
MOV qword ptr [RBP + -0x10],-0x1
JMP 0x00156683
LAB_001562f7:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x98]
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,-0x1
JNZ 0x00156323
MOV qword ptr [RBP + -0x10],-0x1
JMP 0x00156683
LAB_00156323:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0xe]
ADD EAX,0xf
AND EAX,0xfffffff0
MOV ECX,EAX
MOV RAX,RSP
SUB RAX,RCX
MOV RSP,RAX
MOV qword ptr [RBP + -0x68],RAX
CMP RAX,0x0
JNZ 0x00156353
MOV qword ptr [RBP + -0x10],-0x1
JMP 0x00156683
LAB_00156353:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x40]
MOV R8,qword ptr [RBP + -0x68]
MOV ECX,0x3
XOR R9D,R9D
CALL 0x001685f0
CMP RAX,0x0
JNZ 0x0015637b
JMP 0x0015667b
LAB_0015637b:
MOV RAX,qword ptr [RBP + -0x68]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x80
CMP EAX,0x0
JZ 0x001563a1
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x17c]
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x001563ab
LAB_001563a1:
XOR EAX,EAX
MOV dword ptr [RBP + -0x8c],EAX
JMP 0x001563ab
LAB_001563ab:
MOV EAX,dword ptr [RBP + -0x8c]
MOV dword ptr [RBP + -0x5c],EAX
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x12]
MOV RCX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RCX]
SUB EAX,dword ptr [RCX + 0x178]
MOV dword ptr [RBP + -0x6c],EAX
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,0x2
MOV ECX,dword ptr [RBP + -0x5c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x68]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
MOV RDX,qword ptr [RBP + -0x68]
MOVZX EDX,byte ptr [RDX]
MOVZX EDX,DX
SHL EDX,0x8
OR ECX,EDX
MOVZX ECX,CX
AND ECX,0x7fff
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x58],RAX
LAB_0015640e:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x58]
JNC 0x001565ec
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00156562
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x00158a50
MOVSD qword ptr [RBP + -0x88],XMM0
MOVSD XMM0,qword ptr [RBP + -0x88]
XORPS XMM1,XMM1
UCOMISD XMM0,XMM1
JNZ 0x001564c6
JP 0x001564c6
MOV EAX,dword ptr [RBP + -0x30]
AND EAX,0x600
CMP EAX,0x0
JZ 0x00156476
MOVSD XMM0,qword ptr [0x001e3028]
ADDSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x78],XMM0
JMP 0x001564c1
LAB_00156476:
MOV EAX,dword ptr [RBP + -0x30]
AND EAX,0x2800
CMP EAX,0x0
JZ 0x001564ba
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x2c]
MOV R8D,0x800
CALL 0x00157000
CMP EAX,0x0
JNZ 0x001564b8
MOVSD XMM0,qword ptr [0x001e3028]
ADDSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x78],XMM0
LAB_001564b8:
JMP 0x001564bf
LAB_001564ba:
JMP 0x0015667b
LAB_001564bf:
JMP 0x001564c1
LAB_001564c1:
JMP 0x00156560
LAB_001564c6:
MOV EAX,dword ptr [RBP + -0x30]
AND EAX,0x600
CMP EAX,0x0
JZ 0x001564ff
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x2c]
CALL 0x0015b250
DIVSD XMM0,qword ptr [RBP + -0x88]
ADDSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x78],XMM0
JMP 0x0015655e
LAB_001564ff:
MOV EAX,dword ptr [RBP + -0x30]
AND EAX,0x2800
CMP EAX,0x0
JZ 0x00156557
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x2c]
MOV R8D,0x800
CALL 0x00157000
CMP EAX,0x0
JNZ 0x00156555
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x2c]
CALL 0x00158a50
DIVSD XMM0,qword ptr [RBP + -0x88]
ADDSD XMM0,qword ptr [RBP + -0x78]
MOVSD qword ptr [RBP + -0x78],XMM0
LAB_00156555:
JMP 0x0015655c
LAB_00156557:
JMP 0x0015667b
LAB_0015655c:
JMP 0x0015655e
LAB_0015655e:
JMP 0x00156560
LAB_00156560:
JMP 0x00156591
LAB_00156562:
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x28]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x2c]
MOV R8D,dword ptr [RBP + -0x30]
CALL 0x00157000
CMP EAX,0x0
JNZ 0x0015658f
MOV RAX,qword ptr [RBP + -0x80]
ADD RAX,0x1
MOV qword ptr [RBP + -0x80],RAX
LAB_0015658f:
JMP 0x00156591
LAB_00156591:
JMP 0x00156593
LAB_00156593:
MOV RAX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RBP + -0x6c]
ADD RAX,RCX
MOV qword ptr [RBP + -0x98],RAX
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x001565b5
MOV EAX,dword ptr [RBP + -0x5c]
MOV dword ptr [RBP + -0x9c],EAX
JMP 0x001565c8
LAB_001565b5:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x178]
MOV dword ptr [RBP + -0x9c],EAX
LAB_001565c8:
MOV RAX,qword ptr [RBP + -0x98]
MOV ECX,dword ptr [RBP + -0x9c]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
JMP 0x0015640e
LAB_001565ec:
CMP dword ptr [RBP + -0x5c],0x0
JZ 0x00156671
CMP dword ptr [RBP + -0x44],0x0
JZ 0x00156667
MOVSD XMM0,qword ptr [RBP + -0x78]
MOV EAX,dword ptr [RBP + -0x44]
CVTSI2SD XMM1,RAX
DIVSD XMM0,XMM1
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOVQ XMM1,qword ptr [RAX]
MOVAPS XMM2,xmmword ptr [0x001eac20]
PUNPCKLDQ XMM1,XMM2
MOVAPD XMM2,xmmword ptr [0x001eac30]
SUBPD XMM1,XMM2
MOVAPS XMM2,XMM1
UNPCKHPD XMM1,XMM1
ADDSD XMM1,XMM2
MULSD XMM0,XMM1
MOVAPS XMM1,XMM0
CVTTSD2SI RAX,XMM1
MOV RDX,RAX
SAR RDX,0x3f
MOVSD XMM1,qword ptr [0x001e3020]
SUBSD XMM0,XMM1
CVTTSD2SI RCX,XMM0
AND RCX,RDX
OR RAX,RCX
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0015666f
LAB_00156667:
MOV qword ptr [RBP + -0x80],-0x1
LAB_0015666f:
JMP 0x00156671
LAB_00156671:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00156683
LAB_0015667b:
MOV qword ptr [RBP + -0x10],-0x1
LAB_00156683:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001566ac
MOV RAX,qword ptr [RBP + -0xa8]
MOV RSP,RBP
POP RBP
RET
LAB_001566ac:
CALL 0x00129420
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong rtree_estimate(long *param_1,uint param_2,int8 param_3,int4 param_4,uint param_5)
{
long lVar1;
int8 uVar2;
int8 uVar3;
long lVar4;
byte *pbVar5;
uint uVar6;
int4 uVar7;
int iVar8;
long lVar9;
byte *pbVar10;
long in_FS_OFFSET;
double dVar11;
int1 auVar12 [16];
int8 uStack_c0;
byte abStack_b8 [8];
ulong local_b0;
uint local_a4;
byte *local_a0;
uint local_94;
double local_90;
ulong local_88;
double local_80;
uint local_74;
byte *local_70;
uint local_64;
byte *local_60;
byte *local_58;
uint local_4c;
long local_48;
long local_40;
uint local_38;
int4 local_34;
int8 local_30;
uint local_24;
long *local_20;
ulong local_18;
long local_10;
pbVar10 = abStack_b8;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
lVar9 = *(long *)(*param_1 + 0x218) + (ulong)param_2 * 0x70;
local_4c = 0;
local_80 = 0.0;
local_88 = 0;
local_40 = lVar9;
local_38 = param_5;
local_34 = param_4;
local_30 = param_3;
local_24 = param_2;
local_20 = param_1;
if ((param_5 & 0x1000) == 0) {
lVar1 = *(long *)(*(long *)(*param_1 + 0x98) + (ulong)param_2 * 8);
local_48 = lVar1;
if (lVar1 == -1) {
local_18 = 0xffffffffffffffff;
}
else {
lVar4 = -(ulong)(*(ushort *)(lVar9 + 0xe) + 0xf & 0xfffffff0);
pbVar10 = abStack_b8 + lVar4;
local_70 = pbVar10;
if (pbVar10 == (byte *)0x0) {
local_18 = 0xffffffffffffffff;
}
else {
*(int8 *)((long)&uStack_c0 + lVar4) = 0x156370;
lVar9 = _mi_fetch_keypage(param_1,lVar9,lVar1,3,pbVar10,0);
if (lVar9 == 0) {
LAB_0015667b:
local_18 = 0xffffffffffffffff;
}
else {
if ((*local_70 & 0x80) == 0) {
local_94 = 0;
}
else {
local_94 = *(uint *)(*local_20 + 0x17c);
}
local_64 = local_94;
local_74 = (uint)*(ushort *)(local_40 + 0x12) - *(int *)(*local_20 + 0x178);
local_60 = local_70 + ((uint)local_70[1] | (*local_70 & 0x7f) << 8);
local_58 = local_70 + (ulong)local_94 + 2;
while (uVar2 = local_30, uVar7 = local_34, uVar6 = local_38, pbVar5 = local_58,
local_58 < local_60) {
if (local_64 == 0) {
uVar3 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x15657e;
iVar8 = rtree_key_cmp(uVar3,uVar2,pbVar5,uVar7,uVar6);
if (iVar8 == 0) {
local_88 = local_88 + 1;
}
}
else {
uVar2 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x15643a;
local_90 = (double)rtree_rect_volume(uVar2,pbVar5,uVar7);
uVar2 = local_30;
uVar7 = local_34;
pbVar5 = local_58;
if ((local_90 != 0.0) || (NAN(local_90))) {
if ((local_38 & 0x600) == 0) {
if ((local_38 & 0x2800) == 0) goto LAB_0015667b;
uVar3 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x15652a;
iVar8 = rtree_key_cmp(uVar3,uVar2,pbVar5,uVar7,0x800);
uVar2 = local_30;
uVar7 = local_34;
if (iVar8 == 0) {
uVar3 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x156543;
dVar11 = (double)rtree_rect_volume(uVar3,uVar2,uVar7);
local_80 = dVar11 / local_90 + local_80;
}
}
else {
uVar3 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x1564eb;
dVar11 = (double)rtree_overlapping_area(uVar3,uVar2,pbVar5,uVar7);
local_80 = dVar11 / local_90 + local_80;
}
}
else if ((local_38 & 0x600) == 0) {
if ((local_38 & 0x2800) == 0) goto LAB_0015667b;
uVar3 = *(int8 *)(local_40 + 0x28);
*(int8 *)((long)&uStack_c0 + lVar4) = 0x1564a1;
iVar8 = rtree_key_cmp(uVar3,uVar2,pbVar5,uVar7,0x800);
if (iVar8 == 0) {
local_80 = DAT_001e3028 + local_80;
}
}
else {
local_80 = DAT_001e3028 + local_80;
}
}
local_a0 = local_58 + local_74;
if (local_64 == 0) {
local_a4 = *(uint *)(*local_20 + 0x178);
}
else {
local_a4 = local_64;
}
local_4c = local_4c + 1;
local_58 = local_a0 + local_a4;
}
if (local_64 != 0) {
if (local_4c == 0) {
local_88 = 0xffffffffffffffff;
}
else {
uVar2 = *(int8 *)local_20[1];
auVar12._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar12._0_8_ = uVar2;
auVar12._12_4_ = _UNK_001eac24;
dVar11 = (local_80 / (double)local_4c) *
((auVar12._8_8_ - _UNK_001eac38) +
((double)CONCAT44(_DAT_001eac20,(int)uVar2) - _DAT_001eac30));
local_88 = (ulong)dVar11;
local_88 = local_88 | (long)(dVar11 - DAT_001e3020) & (long)local_88 >> 0x3f;
}
}
local_18 = local_88;
}
}
}
}
else {
local_18 = 0xffffffffffffffff;
pbVar10 = abStack_b8;
}
local_b0 = local_18;
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
pbVar10[-8] = 0xb1;
pbVar10[-7] = 0x66;
pbVar10[-6] = 0x15;
pbVar10[-5] = 0;
pbVar10[-4] = 0;
pbVar10[-3] = 0;
pbVar10[-2] = 0;
pbVar10[-1] = 0;
__stack_chk_fail();
}
return local_18;
}
| |
24,989 | PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array, PFS_account_allocator>::apply(void (*)(PFS_account*)) | eloqsql/storage/perfschema/pfs_buffer_container.h | void apply(function_type fct)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
if (pfs->m_lock.is_populated())
{
fct(pfs);
}
pfs++;
}
}
}
} | O0 | c | PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array, PFS_account_allocator>::apply(void (*)(PFS_account*)):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x400, -0x14(%rbp) # imm = 0x400
jae 0x564e5
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movq 0xa8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x564d5
movq -0x20(%rbp), %rdi
callq 0x38e60
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x38e80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x564d3
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x38ea0
testb $0x1, %al
jne 0x564b9
jmp 0x564c3
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rdi
callq *%rax
movq -0x28(%rbp), %rax
addq $0x2440, %rax # imm = 0x2440
movq %rax, -0x28(%rbp)
jmp 0x5649c
jmp 0x564d5
jmp 0x564d7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5645f
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| _ZN29PFS_buffer_scalable_containerI9PFS_tableLi1024ELi1024E24PFS_buffer_default_arrayIS0_E28PFS_buffer_default_allocatorIS0_EE5applyEPFvPS0_E:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov [rbp+var_38], rax
mov [rbp+var_14], 0
loc_5645F:
cmp [rbp+var_14], 400h
jnb short loc_564E5
mov rax, [rbp+var_38]
mov ecx, [rbp+var_14]
mov rax, [rax+rcx*8+0A8h]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jz short loc_564D5
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI9PFS_tableE9get_firstEv; PFS_buffer_default_array<PFS_table>::get_first(void)
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call _ZN24PFS_buffer_default_arrayI9PFS_tableE8get_lastEv; PFS_buffer_default_array<PFS_table>::get_last(void)
mov [rbp+var_30], rax
loc_5649C:
mov rax, [rbp+var_28]
cmp rax, [rbp+var_30]
jnb short loc_564D3
mov rdi, [rbp+var_28]
add rdi, 8; this
call _ZN8pfs_lock12is_populatedEv; pfs_lock::is_populated(void)
test al, 1
jnz short loc_564B9
jmp short loc_564C3
loc_564B9:
mov rax, [rbp+var_10]
mov rdi, [rbp+var_28]
call rax
loc_564C3:
mov rax, [rbp+var_28]
add rax, 2440h
mov [rbp+var_28], rax
jmp short loc_5649C
loc_564D3:
jmp short $+2
loc_564D5:
jmp short $+2
loc_564D7:
mov eax, [rbp+var_14]
add eax, 1
mov [rbp+var_14], eax
jmp loc_5645F
loc_564E5:
add rsp, 40h
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>::apply(
long long a1,
unsigned int *a2)
{
long long result; // rax
unsigned long long last; // [rsp+10h] [rbp-30h]
unsigned long long first; // [rsp+18h] [rbp-28h]
long long v5; // [rsp+20h] [rbp-20h]
unsigned int i; // [rsp+2Ch] [rbp-14h]
result = a1;
for ( i = 0; i < 0x400; ++i )
{
v5 = *(_QWORD *)(a1 + 8LL * i + 168);
if ( v5 )
{
first = PFS_buffer_default_array<PFS_table>::get_first(v5);
last = PFS_buffer_default_array<PFS_table>::get_last(v5);
while ( first < last )
{
if ( pfs_lock::is_populated((pfs_lock *)(first + 8), a2) )
((void ( *)(unsigned long long))a2)(first);
first += 9280LL;
}
}
result = i + 1;
}
return result;
}
| apply:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x14],0x0
LAB_0015645f:
CMP dword ptr [RBP + -0x14],0x400
JNC 0x001564e5
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0xa8]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JZ 0x001564d5
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00138e60
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00138e80
MOV qword ptr [RBP + -0x30],RAX
LAB_0015649c:
MOV RAX,qword ptr [RBP + -0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x001564d3
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
CALL 0x00138ea0
TEST AL,0x1
JNZ 0x001564b9
JMP 0x001564c3
LAB_001564b9:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RBP + -0x28]
CALL RAX
LAB_001564c3:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x2440
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0015649c
LAB_001564d3:
JMP 0x001564d5
LAB_001564d5:
JMP 0x001564d7
LAB_001564d7:
MOV EAX,dword ptr [RBP + -0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x14],EAX
JMP 0x0015645f
LAB_001564e5:
ADD RSP,0x40
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_table, 1024, 1024, PFS_buffer_default_array<PFS_table>,
PFS_buffer_default_allocator<PFS_table> >::apply(void (*)(PFS_table*)) */
void __thiscall
PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
::apply(PFS_buffer_scalable_container<PFS_table,1024,1024,PFS_buffer_default_array<PFS_table>,PFS_buffer_default_allocator<PFS_table>>
*this,_func_void_PFS_table_ptr *param_1)
{
PFS_buffer_default_array<PFS_table> *this_00;
PFS_table *pPVar1;
ulong uVar2;
PFS_table *local_30;
uint local_1c;
for (local_1c = 0; local_1c < 0x400; local_1c = local_1c + 1) {
this_00 = *(PFS_buffer_default_array<PFS_table> **)(this + (ulong)local_1c * 8 + 0xa8);
if (this_00 != (PFS_buffer_default_array<PFS_table> *)0x0) {
local_30 = (PFS_table *)PFS_buffer_default_array<PFS_table>::get_first(this_00);
pPVar1 = (PFS_table *)PFS_buffer_default_array<PFS_table>::get_last(this_00);
for (; local_30 < pPVar1; local_30 = local_30 + 0x2440) {
uVar2 = pfs_lock::is_populated((pfs_lock *)(local_30 + 8));
if ((uVar2 & 1) != 0) {
(*param_1)(local_30);
}
}
}
}
return;
}
| |
24,990 | PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array, PFS_account_allocator>::apply(void (*)(PFS_account*)) | eloqsql/storage/perfschema/pfs_buffer_container.h | void apply(function_type fct)
{
uint i;
array_type *page;
value_type *pfs;
value_type *pfs_last;
for (i=0 ; i < PFS_PAGE_COUNT; i++)
{
page= m_pages[i];
if (page != NULL)
{
pfs= page->get_first();
pfs_last= page->get_last();
while (pfs < pfs_last)
{
if (pfs->m_lock.is_populated())
{
fct(pfs);
}
pfs++;
}
}
}
} | O3 | c | PFS_buffer_scalable_container<PFS_account, 128, 128, PFS_account_array, PFS_account_allocator>::apply(void (*)(PFS_account*)):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq 0xa8(%r14,%r12,8), %rax
testq %rax, %rax
je 0x4255b
movq 0x50(%rax), %rcx
testq %rcx, %rcx
jle 0x4255b
movq 0x48(%rax), %r15
imulq $0x1640, %rcx, %r13 # imm = 0x1640
addq %r15, %r13
movl 0x800(%r15), %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0x4254f
movq %r15, %rdi
callq *%rbx
addq $0x1640, %r15 # imm = 0x1640
cmpq %r13, %r15
jb 0x4253b
incq %r12
cmpq $0x100, %r12 # imm = 0x100
jne 0x42517
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN29PFS_buffer_scalable_containerI10PFS_threadLi256ELi256E16PFS_thread_array20PFS_thread_allocatorE5applyEPFvPS0_E:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
xor r12d, r12d
loc_42517:
mov rax, [r14+r12*8+0A8h]
test rax, rax
jz short loc_4255B
mov rcx, [rax+50h]
test rcx, rcx
jle short loc_4255B
mov r15, [rax+48h]
imul r13, rcx, 1640h
add r13, r15
loc_4253B:
mov eax, [r15+800h]
and eax, 3
cmp eax, 2
jnz short loc_4254F
mov rdi, r15
call rbx
loc_4254F:
add r15, 1640h
cmp r15, r13
jb short loc_4253B
loc_4255B:
inc r12
cmp r12, 100h
jnz short loc_42517
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long PFS_buffer_scalable_container<PFS_thread,256,256,PFS_thread_array,PFS_thread_allocator>::apply(
long long a1,
long long ( *a2)(unsigned long long))
{
long long i; // r12
long long result; // rax
long long v4; // rcx
unsigned long long v5; // r15
unsigned long long v6; // r13
for ( i = 0LL; i != 256; ++i )
{
result = *(_QWORD *)(a1 + 8 * i + 168);
if ( result )
{
v4 = *(_QWORD *)(result + 80);
if ( v4 > 0 )
{
v5 = *(_QWORD *)(result + 72);
v6 = v5 + 5696 * v4;
do
{
result = *(_DWORD *)(v5 + 2048) & 3;
if ( (_DWORD)result == 2 )
result = a2(v5);
v5 += 5696LL;
}
while ( v5 < v6 );
}
}
}
return result;
}
| apply:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
XOR R12D,R12D
LAB_00142517:
MOV RAX,qword ptr [R14 + R12*0x8 + 0xa8]
TEST RAX,RAX
JZ 0x0014255b
MOV RCX,qword ptr [RAX + 0x50]
TEST RCX,RCX
JLE 0x0014255b
MOV R15,qword ptr [RAX + 0x48]
IMUL R13,RCX,0x1640
ADD R13,R15
LAB_0014253b:
MOV EAX,dword ptr [R15 + 0x800]
AND EAX,0x3
CMP EAX,0x2
JNZ 0x0014254f
MOV RDI,R15
CALL RBX
LAB_0014254f:
ADD R15,0x1640
CMP R15,R13
JC 0x0014253b
LAB_0014255b:
INC R12
CMP R12,0x100
JNZ 0x00142517
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* PFS_buffer_scalable_container<PFS_thread, 256, 256, PFS_thread_array,
PFS_thread_allocator>::apply(void (*)(PFS_thread*)) */
void __thiscall
PFS_buffer_scalable_container<PFS_thread,256,256,PFS_thread_array,PFS_thread_allocator>::apply
(PFS_buffer_scalable_container<PFS_thread,256,256,PFS_thread_array,PFS_thread_allocator>
*this,_func_void_PFS_thread_ptr *param_1)
{
long lVar1;
long lVar2;
PFS_thread *pPVar3;
PFS_thread *pPVar4;
lVar2 = 0;
do {
lVar1 = *(long *)(this + lVar2 * 8 + 0xa8);
if ((lVar1 != 0) && (0 < *(long *)(lVar1 + 0x50))) {
pPVar4 = *(PFS_thread **)(lVar1 + 0x48);
pPVar3 = pPVar4 + *(long *)(lVar1 + 0x50) * 0x1640;
do {
if ((*(uint *)(pPVar4 + 0x800) & 3) == 2) {
(*param_1)(pPVar4);
}
pPVar4 = pPVar4 + 0x1640;
} while (pPVar4 < pPVar3);
}
lVar2 = lVar2 + 1;
} while (lVar2 != 0x100);
return;
}
| |
24,991 | evmone::VM::VM() | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/vm.cpp | VM::VM() noexcept
: evmc_vm{
EVMC_ABI_VERSION,
"evmone",
PROJECT_VERSION,
evmone::destroy,
evmone::baseline::execute,
evmone::get_capabilities,
evmone::set_option,
}
{
m_execution_states.reserve(1025);
} | O3 | cpp | evmone::VM::VM():
pushq %rax
movl $0xc, (%rdi)
leaq 0x5291a(%rip), %rax # 0x80c18
movq %rax, 0x8(%rdi)
leaq 0x52916(%rip), %rax # 0x80c1f
movq %rax, 0x10(%rdi)
leaq 0x51(%rip), %rax # 0x2e365
movq %rax, 0x18(%rdi)
leaq 0xf2c8(%rip), %rax # 0x3d5e7
movq %rax, 0x20(%rdi)
leaq 0x91(%rip), %rax # 0x2e3bb
movq %rax, 0x28(%rdi)
leaq 0x8c(%rip), %rax # 0x2e3c1
movq %rax, 0x30(%rdi)
movw $0x1, 0x38(%rdi)
leaq 0x40(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movl $0x401, %esi # imm = 0x401
movq %rax, %rdi
callq 0x2e5e6
popq %rax
retq
movq %rax, %rdi
callq 0x2e015
| _ZN6evmone2VMC2Ev:
push rax
mov dword ptr [rdi], 0Ch
lea rax, aEvmone; "evmone"
mov [rdi+8], rax
lea rax, a0141; "0.14.1"
mov [rdi+10h], rax
lea rax, _ZN6evmone12_GLOBAL__N_17destroyEP7evmc_vm; evmone::`anonymous namespace'::destroy(evmc_vm *)
mov [rdi+18h], rax
lea rax, _ZN6evmone8baseline7executeEP7evmc_vmPK19evmc_host_interfaceP17evmc_host_context13evmc_revisionPK12evmc_messagePKhm; evmone::baseline::execute(evmc_vm *,evmc_host_interface const*,evmc_host_context *,evmc_revision,evmc_message const*,uchar const*,ulong)
mov [rdi+20h], rax
lea rax, _ZN6evmone12_GLOBAL__N_116get_capabilitiesEP7evmc_vm; evmone::`anonymous namespace'::get_capabilities(evmc_vm *)
mov [rdi+28h], rax
lea rax, _ZN6evmone12_GLOBAL__N_110set_optionEP7evmc_vmPKcS4_; evmone::`anonymous namespace'::set_option(evmc_vm *,char const*,char const*)
mov [rdi+30h], rax
mov word ptr [rdi+38h], 1
lea rax, [rdi+40h]
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
mov esi, 401h
mov rdi, rax
call _ZNSt6vectorIN6evmone14ExecutionStateESaIS1_EE7reserveEm; std::vector<evmone::ExecutionState>::reserve(ulong)
pop rax
retn
mov rdi, rax
call __clang_call_terminate
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm0,xmm4,xmm5> evmone::VM::VM(evmone::VM *this)
{
*(_DWORD *)this = 12;
*((_QWORD *)this + 1) = "evmone";
*((_QWORD *)this + 2) = "0.14.1";
*((_QWORD *)this + 3) = evmone::`anonymous namespace'::destroy;
*((_QWORD *)this + 4) = evmone::baseline::execute;
*((_QWORD *)this + 5) = evmone::`anonymous namespace'::get_capabilities;
*((_QWORD *)this + 6) = evmone::`anonymous namespace'::set_option;
*((_WORD *)this + 28) = 1;
*((_OWORD *)this + 4) = 0LL;
*((_OWORD *)this + 5) = 0LL;
std::vector<evmone::ExecutionState>::reserve((char *)this + 64, 1025LL);
}
| VM:
PUSH RAX
MOV dword ptr [RDI],0xc
LEA RAX,[0x180c18]
MOV qword ptr [RDI + 0x8],RAX
LEA RAX,[0x180c1f]
MOV qword ptr [RDI + 0x10],RAX
LEA RAX,[0x12e365]
MOV qword ptr [RDI + 0x18],RAX
LEA RAX,[0x13d5e7]
MOV qword ptr [RDI + 0x20],RAX
LEA RAX,[0x12e3bb]
MOV qword ptr [RDI + 0x28],RAX
LEA RAX,[0x12e3c1]
MOV qword ptr [RDI + 0x30],RAX
MOV word ptr [RDI + 0x38],0x1
LEA RAX,[RDI + 0x40]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
LAB_0012e34e:
MOV ESI,0x401
MOV RDI,RAX
CALL 0x0012e5e6
POP RAX
RET
|
/* evmone::VM::VM() */
int8 __thiscall evmone::VM::VM(VM *this)
{
int8 in_RAX;
*(int4 *)this = 0xc;
*(char **)(this + 8) = "evmone";
*(char **)(this + 0x10) = "0.14.1";
*(code **)(this + 0x18) = (anonymous_namespace)::destroy;
*(code **)(this + 0x20) = baseline::execute;
*(code **)(this + 0x28) = (anonymous_namespace)::get_capabilities;
*(code **)(this + 0x30) = (anonymous_namespace)::set_option;
*(int2 *)(this + 0x38) = 1;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 0012e34e to 0012e35a has its CatchHandler @ 0012e35d */
std::vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>>::reserve
((vector<evmone::ExecutionState,std::allocator<evmone::ExecutionState>> *)(this + 0x40),
0x401);
return in_RAX;
}
| |
24,992 | fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender, char>(fmt::v10::appender, char const*, int, int, char) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h | FMT_CONSTEXPR auto write_significand(OutputIt out, const char* significand,
int significand_size, int integral_size,
Char decimal_point) -> OutputIt {
out = detail::copy_str_noinline<Char>(significand,
significand + integral_size, out);
if (!decimal_point) return out;
*out++ = decimal_point;
return detail::copy_str_noinline<Char>(significand + integral_size,
significand + significand_size, out);
} | O3 | c | fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender, char>(fmt::v10::appender, char const*, int, int, char):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rdx
movslq %ecx, %r15
addq %rsi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x48a93
movq %rax, %r12
testb %bpl, %bpl
je 0x48a87
movq 0x10(%r12), %rax
leaq 0x1(%rax), %rsi
cmpq %rsi, 0x18(%r12)
jae 0x48a5d
movq (%r12), %rax
movq %r12, %rdi
callq *(%rax)
movq 0x10(%r12), %rax
leaq 0x1(%rax), %rsi
movq 0x8(%r12), %rcx
movq %rsi, 0x10(%r12)
movb %bpl, (%rcx,%rax)
movslq %r14d, %rax
addq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x48a93
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| _ZN3fmt3v106detail17write_significandINS0_8appenderEcEET_S4_PKciiT0_:
push rbp
push r15
push r14
push r12
push rbx
mov ebp, r8d
mov r14d, edx
mov rbx, rsi
mov rdx, rdi
movsxd r15, ecx
add r15, rsi
mov rdi, rsi
mov rsi, r15
call _ZN3fmt3v106detail17copy_str_noinlineIcPKcNS0_8appenderEEET1_T0_S7_S6_; fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(char const*,char const*,fmt::v10::appender)
mov r12, rax
test bpl, bpl
jz short loc_48A87
mov rax, [r12+10h]
lea rsi, [rax+1]
cmp [r12+18h], rsi
jnb short loc_48A5D
mov rax, [r12]
mov rdi, r12
call qword ptr [rax]
mov rax, [r12+10h]
lea rsi, [rax+1]
loc_48A5D:
mov rcx, [r12+8]
mov [r12+10h], rsi
mov [rcx+rax], bpl
movsxd rax, r14d
add rbx, rax
mov rdi, r15
mov rsi, rbx
mov rdx, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp _ZN3fmt3v106detail17copy_str_noinlineIcPKcNS0_8appenderEEET1_T0_S7_S6_; fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(char const*,char const*,fmt::v10::appender)
loc_48A87:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long fmt::v10::detail::write_significand<fmt::v10::appender,char>(
long long a1,
long long a2,
int a3,
int a4,
char a5)
{
long long v8; // r15
long long result; // rax
long long v10; // r12
long long v11; // rax
long long v12; // rsi
long long v13; // rcx
v8 = a2 + a4;
result = fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(a2, v8, a1);
v10 = result;
if ( a5 )
{
v11 = *(_QWORD *)(result + 16);
v12 = v11 + 1;
if ( *(_QWORD *)(v10 + 24) < (unsigned long long)(v11 + 1) )
{
(**(void ( ***)(long long))v10)(v10);
v11 = *(_QWORD *)(v10 + 16);
v12 = v11 + 1;
}
v13 = *(_QWORD *)(v10 + 8);
*(_QWORD *)(v10 + 16) = v12;
*(_BYTE *)(v13 + v11) = a5;
return fmt::v10::detail::copy_str_noinline<char,char const*,fmt::v10::appender>(v8, a3 + a2, v10);
}
return result;
}
| write_significand<fmt::v10::appender,char>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV EBP,R8D
MOV R14D,EDX
MOV RBX,RSI
MOV RDX,RDI
MOVSXD R15,ECX
ADD R15,RSI
MOV RDI,RSI
MOV RSI,R15
CALL 0x00148a93
MOV R12,RAX
TEST BPL,BPL
JZ 0x00148a87
MOV RAX,qword ptr [R12 + 0x10]
LEA RSI,[RAX + 0x1]
CMP qword ptr [R12 + 0x18],RSI
JNC 0x00148a5d
MOV RAX,qword ptr [R12]
MOV RDI,R12
CALL qword ptr [RAX]
MOV RAX,qword ptr [R12 + 0x10]
LEA RSI,[RAX + 0x1]
LAB_00148a5d:
MOV RCX,qword ptr [R12 + 0x8]
MOV qword ptr [R12 + 0x10],RSI
MOV byte ptr [RCX + RAX*0x1],BPL
MOVSXD RAX,R14D
ADD RBX,RAX
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x00148a93
LAB_00148a87:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* fmt::v10::appender fmt::v10::detail::write_significand<fmt::v10::appender,
char>(fmt::v10::appender, char const*, int, int, char) */
int8 *
fmt::v10::detail::write_significand<fmt::v10::appender,char>
(int8 param_1,long param_2,int param_3,int param_4,char param_5)
{
int8 *puVar1;
long lVar2;
ulong uVar3;
puVar1 = (int8 *)
copy_str_noinline<char,char_const*,fmt::v10::appender>(param_2,param_4 + param_2,param_1)
;
if (param_5 != '\0') {
lVar2 = puVar1[2];
uVar3 = lVar2 + 1;
if ((ulong)puVar1[3] < uVar3) {
(**(code **)*puVar1)(puVar1);
lVar2 = puVar1[2];
uVar3 = lVar2 + 1;
}
puVar1[2] = uVar3;
*(char *)(puVar1[1] + lVar2) = param_5;
puVar1 = (int8 *)
copy_str_noinline<char,char_const*,fmt::v10::appender>
(param_4 + param_2,param_2 + param_3,puVar1);
return puVar1;
}
return puVar1;
}
| |
24,993 | gguf_write_to_file | llama.cpp/ggml/src/gguf.cpp | bool gguf_write_to_file(const struct gguf_context * ctx, const char * fname, bool only_meta) {
FILE * file = ggml_fopen(fname, "wb");
if (!file) {
fprintf(stderr, "%s: failed to open file '%s' for writing GGUF data\n", __func__, fname);
return false;
}
std::vector<int8_t> buf;
gguf_write_to_buf(ctx, buf, only_meta);
const bool ok = fwrite(buf.data(), 1, buf.size(), file) == buf.size();
fclose(file);
return ok;
} | O3 | cpp | gguf_write_to_file:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1b2aa(%rip), %rsi # 0x5a37c
movq %r14, %rdi
callq 0x17240
testq %rax, %rax
je 0x3f153
movq %rax, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movzbl %bpl, %edx
movq %r15, %rdi
callq 0x16d80
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
subq %rdi, %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x18180
movq 0x8(%rsp), %rcx
subq (%rsp), %rcx
cmpq %rcx, %rax
sete %bpl
movq %rbx, %rdi
callq 0x17010
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3f146
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x17080
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ae6e(%rip), %rax # 0x69fc8
movq (%rax), %rdi
leaq 0x1b21b(%rip), %rsi # 0x5a37f
leaq 0x1b248(%rip), %rdx # 0x5a3b3
xorl %ebp, %ebp
movq %r14, %rcx
xorl %eax, %eax
callq 0x17840
jmp 0x3f146
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3f192
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x17080
movq %rbx, %rdi
callq 0x17e50
| gguf_write_to_file:
push rbp
push r15
push r14
push rbx
sub rsp, 18h
mov ebp, edx
mov r14, rsi
mov r15, rdi
lea rsi, aWb; "wb"
mov rdi, r14
call _ggml_fopen
test rax, rax
jz short loc_3F153
mov rbx, rax
xorps xmm0, xmm0
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov qword ptr [rsi+10h], 0
movzx edx, bpl
mov rdi, r15
call __Z17gguf_write_to_bufPK12gguf_contextRSt6vectorIaSaIaEEb; gguf_write_to_buf(gguf_context const*,std::vector<signed char> &,bool)
mov rdi, [rsp+38h+var_38]
mov rdx, [rsp+38h+var_30]
sub rdx, rdi
mov esi, 1
mov rcx, rbx
call _fwrite
mov rcx, [rsp+38h+var_30]
sub rcx, [rsp+38h+var_38]
cmp rax, rcx
setz bpl
mov rdi, rbx
call _fclose
mov rdi, [rsp+38h+var_38]; void *
test rdi, rdi
jz short loc_3F146
mov rsi, [rsp+38h+var_28]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3F146:
mov eax, ebp
add rsp, 18h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_3F153:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aSFailedToOpenF; "%s: failed to open file '%s' for writin"...
lea rdx, aGgufWriteToFil_0; "gguf_write_to_file"
xor ebp, ebp
mov rcx, r14
xor eax, eax
call _fprintf
jmp short loc_3F146
mov rbx, rax
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_3F192
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_3F192:
mov rdi, rbx
call __Unwind_Resume
| long long gguf_write_to_file(_QWORD *a1, const char *a2, unsigned int a3)
{
long long v4; // rax
long long v5; // rbx
long long v6; // rax
__int128 v8; // [rsp+0h] [rbp-38h] BYREF
long long v9; // [rsp+10h] [rbp-28h]
v4 = ggml_fopen(a2, "wb");
if ( v4 )
{
v5 = v4;
v8 = 0LL;
v9 = 0LL;
gguf_write_to_buf(a1, (long long)&v8, a3);
v6 = fwrite(v8, 1LL, *((_QWORD *)&v8 + 1) - v8, v5);
LOBYTE(a3) = v6 == *((_QWORD *)&v8 + 1) - (_QWORD)v8;
fclose(v5);
if ( (_QWORD)v8 )
operator delete((void *)v8, v9 - v8);
}
else
{
a3 = 0;
fprintf(stderr, "%s: failed to open file '%s' for writing GGUF data\n", "gguf_write_to_file", a2);
}
return a3;
}
| gguf_write_to_file:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV EBP,EDX
MOV R14,RSI
MOV R15,RDI
LEA RSI,[0x15a37c]
MOV RDI,R14
CALL 0x00117240
TEST RAX,RAX
JZ 0x0013f153
MOV RBX,RAX
XORPS XMM0,XMM0
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV qword ptr [RSI + 0x10],0x0
LAB_0013f0f3:
MOVZX EDX,BPL
MOV RDI,R15
CALL 0x00116d80
LAB_0013f0ff:
MOV RDI,qword ptr [RSP]
MOV RDX,qword ptr [RSP + 0x8]
SUB RDX,RDI
MOV ESI,0x1
MOV RCX,RBX
CALL 0x00118180
MOV RCX,qword ptr [RSP + 0x8]
SUB RCX,qword ptr [RSP]
CMP RAX,RCX
SETZ BPL
MOV RDI,RBX
CALL 0x00117010
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0013f146
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00117080
LAB_0013f146:
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0013f153:
MOV RAX,qword ptr [0x00169fc8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x15a37f]
LEA RDX,[0x15a3b3]
XOR EBP,EBP
MOV RCX,R14
XOR EAX,EAX
CALL 0x00117840
JMP 0x0013f146
|
bool gguf_write_to_file(gguf_context *param_1,char *param_2,bool param_3)
{
FILE *__s;
size_t sVar1;
bool bVar2;
void *local_38;
long lStack_30;
long local_28;
__s = ggml_fopen(param_2,"wb");
if (__s == (FILE *)0x0) {
bVar2 = false;
fprintf(*(FILE **)PTR_stderr_00169fc8,"%s: failed to open file \'%s\' for writing GGUF data\n",
"gguf_write_to_file",param_2);
}
else {
local_38 = (void *)0x0;
lStack_30 = 0;
local_28 = 0;
/* try { // try from 0013f0f3 to 0013f0fe has its CatchHandler @ 0013f179 */
gguf_write_to_buf(param_1,(vector *)&local_38,param_3);
sVar1 = fwrite(local_38,1,lStack_30 - (long)local_38,__s);
bVar2 = sVar1 == lStack_30 - (long)local_38;
fclose(__s);
if (local_38 != (void *)0x0) {
operator_delete(local_38,local_28 - (long)local_38);
}
}
return bVar2;
}
| |
24,994 | my_caseup_utf8mb3 | eloqsql/strings/ctype-utf8.c | static size_t my_caseup_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O3 | c | my_caseup_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rcx, -0x30(%rbp)
testq %rdx, %rdx
jle 0xd6a43
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
addq %rsi, %r15
movq -0x30(%rbp), %r13
addq %r13, %r14
movq 0x78(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xd6683
testl %eax, %eax
jle 0xd6a43
movl %eax, %ebx
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x38(%rbp), %rax
movzbl %ah, %edx
movq (%rcx,%rdx,8), %rcx
testq %rcx, %rcx
je 0xd6a22
movzbl %al, %eax
leaq (%rax,%rax,2), %rax
movl (%rcx,%rax,4), %eax
movq %rax, -0x38(%rbp)
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0xd6748
testl %eax, %eax
jle 0xd6a43
movl %ebx, %ecx
addq %rcx, %r12
movl %eax, %eax
addq %rax, %r13
cmpq %r15, %r12
jb 0xd69e7
subq -0x30(%rbp), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_caseup_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov [rbp+var_30], rcx
test rdx, rdx
jle short loc_D6A43
mov r14, r8
mov r15, rdx
mov r12, rsi
add r15, rsi
mov r13, [rbp+var_30]
add r14, r13
mov rax, [rdi+78h]
mov [rbp+var_40], rax
loc_D69E7:
lea rsi, [rbp+var_38]
mov rdx, r12
mov rcx, r15
call my_utf8mb3_uni
test eax, eax
jle short loc_D6A43
mov ebx, eax
mov rax, [rbp+var_40]
mov rcx, [rax+8]
mov rax, [rbp+var_38]
movzx edx, ah
mov rcx, [rcx+rdx*8]
test rcx, rcx
jz short loc_D6A22
movzx eax, al
lea rax, [rax+rax*2]
mov eax, [rcx+rax*4]
mov [rbp+var_38], rax
loc_D6A22:
mov rsi, rax
mov rdx, r13
mov rcx, r14
call my_uni_utf8mb3
test eax, eax
jle short loc_D6A43
mov ecx, ebx
add r12, rcx
mov eax, eax
add r13, rax
cmp r12, r15
jb short loc_D69E7
loc_D6A43:
sub r13, [rbp+var_30]
mov rax, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| _BYTE * my_caseup_utf8mb3(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4, long long a5)
{
_BYTE *v5; // r13
unsigned __int8 *v6; // r12
unsigned long long v7; // r15
unsigned long long v8; // r14
int v9; // eax
unsigned int v10; // ebx
unsigned long long v11; // rax
long long v12; // rcx
int v13; // eax
long long v15; // [rsp+0h] [rbp-40h]
unsigned long long v16; // [rsp+8h] [rbp-38h] BYREF
_BYTE *v17; // [rsp+10h] [rbp-30h]
v5 = a4;
v17 = a4;
if ( a3 > 0 )
{
v6 = a2;
v7 = (unsigned long long)&a2[a3];
v5 = v17;
v8 = (unsigned long long)&v17[a5];
v15 = *(_QWORD *)(a1 + 120);
do
{
v9 = my_utf8mb3_uni(a1, &v16, v6, v7);
if ( v9 <= 0 )
break;
v10 = v9;
v11 = v16;
v12 = *(_QWORD *)(*(_QWORD *)(v15 + 8) + 8LL * BYTE1(v16));
if ( v12 )
{
v11 = *(unsigned int *)(v12 + 12LL * (unsigned __int8)v16);
v16 = v11;
}
v13 = my_uni_utf8mb3(a1, v11, v5, v8);
if ( v13 <= 0 )
break;
v6 += v10;
v5 += (unsigned int)v13;
}
while ( (unsigned long long)v6 < v7 );
}
return (_BYTE *)(v5 - v17);
}
| my_caseup_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV qword ptr [RBP + -0x30],RCX
TEST RDX,RDX
JLE 0x001d6a43
MOV R14,R8
MOV R15,RDX
MOV R12,RSI
ADD R15,RSI
MOV R13,qword ptr [RBP + -0x30]
ADD R14,R13
MOV RAX,qword ptr [RDI + 0x78]
MOV qword ptr [RBP + -0x40],RAX
LAB_001d69e7:
LEA RSI,[RBP + -0x38]
MOV RDX,R12
MOV RCX,R15
CALL 0x001d6683
TEST EAX,EAX
JLE 0x001d6a43
MOV EBX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EDX,AH
MOV RCX,qword ptr [RCX + RDX*0x8]
TEST RCX,RCX
JZ 0x001d6a22
MOVZX EAX,AL
LEA RAX,[RAX + RAX*0x2]
MOV EAX,dword ptr [RCX + RAX*0x4]
MOV qword ptr [RBP + -0x38],RAX
LAB_001d6a22:
MOV RSI,RAX
MOV RDX,R13
MOV RCX,R14
CALL 0x001d6748
TEST EAX,EAX
JLE 0x001d6a43
MOV ECX,EBX
ADD R12,RCX
MOV EAX,EAX
ADD R13,RAX
CMP R12,R15
JC 0x001d69e7
LAB_001d6a43:
SUB R13,qword ptr [RBP + -0x30]
MOV RAX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
long my_caseup_utf8mb3(long param_1,ulong param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
uint uVar3;
uint uVar4;
long lVar5;
ulong uVar6;
int8 local_40;
lVar5 = param_4;
if (0 < param_3) {
uVar6 = param_3 + param_2;
lVar1 = *(long *)(param_1 + 0x78);
do {
uVar3 = my_utf8mb3_uni();
if ((int)uVar3 < 1) break;
lVar2 = *(long *)(*(long *)(lVar1 + 8) + (local_40 >> 8 & 0xff) * 8);
if (lVar2 != 0) {
local_40 = (ulong)*(uint *)(lVar2 + (local_40 & 0xff) * 0xc);
}
uVar4 = my_uni_utf8mb3();
if ((int)uVar4 < 1) break;
param_2 = param_2 + uVar3;
lVar5 = lVar5 + (ulong)uVar4;
} while (param_2 < uVar6);
}
return lVar5 - param_4;
}
| |
24,995 | mi_calc_total_blob_length | eloqsql/storage/myisam/mi_dynrec.c | ulong _mi_calc_total_blob_length(MI_INFO *info, const uchar *record)
{
ulong length;
MI_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length=_mi_calc_blob_length(blob->pack_length,record + blob->offset);
length+=blob->length;
}
return length;
} | O3 | c | mi_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl 0x188(%rax), %eax
testq %rax, %rax
je 0x3196b
movq 0x48(%rdi), %rcx
shlq $0x3, %rax
leaq (%rax,%rax,2), %rdx
xorl %edi, %edi
leaq 0x6a8e5(%rip), %r8 # 0x9c1f4
xorl %eax, %eax
movl 0x8(%rcx,%rdi), %r10d
decl %r10d
cmpl $0x3, %r10d
ja 0x31955
movq (%rcx,%rdi), %r9
movslq (%r8,%r10,4), %r10
addq %r8, %r10
jmpq *%r10
movzbl (%rsi,%r9), %r9d
jmp 0x31958
movzwl (%rsi,%r9), %r10d
movzbl 0x2(%rsi,%r9), %r9d
shll $0x10, %r9d
orq %r10, %r9
jmp 0x31958
movl (%rsi,%r9), %r9d
jmp 0x31958
movzwl (%rsi,%r9), %r9d
jmp 0x31958
xorl %r9d, %r9d
movq %r9, 0x10(%rcx,%rdi)
addq %r9, %rax
addq $0x18, %rdi
cmpq %rdi, %rdx
jne 0x31911
jmp 0x3196d
xorl %eax, %eax
popq %rbp
retq
| _mi_calc_total_blob_length:
push rbp
mov rbp, rsp
mov rax, [rdi]
mov eax, [rax+188h]
test rax, rax
jz short loc_3196B
mov rcx, [rdi+48h]
shl rax, 3
lea rdx, [rax+rax*2]
xor edi, edi
lea r8, jpt_3192A
xor eax, eax
loc_31911:
mov r10d, [rcx+rdi+8]
dec r10d; switch 4 cases
cmp r10d, 3
ja short def_3192A; jumptable 000000000003192A default case
mov r9, [rcx+rdi]
movsxd r10, ds:(jpt_3192A - 9C1F4h)[r8+r10*4]
add r10, r8
jmp r10; switch jump
loc_3192D:
movzx r9d, byte ptr [rsi+r9]; jumptable 000000000003192A case 1
jmp short loc_31958
loc_31934:
movzx r10d, word ptr [rsi+r9]; jumptable 000000000003192A case 3
movzx r9d, byte ptr [rsi+r9+2]
shl r9d, 10h
or r9, r10
jmp short loc_31958
loc_31948:
mov r9d, [rsi+r9]; jumptable 000000000003192A case 4
jmp short loc_31958
loc_3194E:
movzx r9d, word ptr [rsi+r9]; jumptable 000000000003192A case 2
jmp short loc_31958
def_3192A:
xor r9d, r9d; jumptable 000000000003192A default case
loc_31958:
mov [rcx+rdi+10h], r9
add rax, r9
add rdi, 18h
cmp rdx, rdi
jnz short loc_31911
jmp short loc_3196D
loc_3196B:
xor eax, eax
loc_3196D:
pop rbp
retn
| long long mi_calc_total_blob_length(_QWORD *a1, long long a2)
{
long long v2; // rcx
long long v3; // rdx
long long v4; // rdi
long long result; // rax
long long v6; // r9
unsigned long long v7; // r9
if ( !*(_DWORD *)(*a1 + 392LL) )
return 0LL;
v2 = a1[9];
v3 = 24LL * *(unsigned int *)(*a1 + 392LL);
v4 = 0LL;
result = 0LL;
do
{
v6 = *(_QWORD *)(v2 + v4);
switch ( *(_DWORD *)(v2 + v4 + 8) )
{
case 1:
v7 = *(unsigned __int8 *)(a2 + v6);
break;
case 2:
v7 = *(unsigned __int16 *)(a2 + v6);
break;
case 3:
v7 = *(unsigned __int16 *)(a2 + v6) | (unsigned long long)(*(unsigned __int8 *)(a2 + v6 + 2) << 16);
break;
case 4:
v7 = *(unsigned int *)(a2 + v6);
break;
default:
v7 = 0LL;
break;
}
*(_QWORD *)(v2 + v4 + 16) = v7;
result += v7;
v4 += 24LL;
}
while ( v3 != v4 );
return result;
}
| _mi_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
MOV EAX,dword ptr [RAX + 0x188]
TEST RAX,RAX
JZ 0x0013196b
MOV RCX,qword ptr [RDI + 0x48]
SHL RAX,0x3
LEA RDX,[RAX + RAX*0x2]
XOR EDI,EDI
LEA R8,[0x19c1f4]
XOR EAX,EAX
LAB_00131911:
MOV R10D,dword ptr [RCX + RDI*0x1 + 0x8]
DEC R10D
CMP R10D,0x3
JA 0x00131955
MOV R9,qword ptr [RCX + RDI*0x1]
MOVSXD R10,dword ptr [R8 + R10*0x4]
ADD R10,R8
switchD:
JMP R10
caseD_1:
MOVZX R9D,byte ptr [RSI + R9*0x1]
JMP 0x00131958
caseD_3:
MOVZX R10D,word ptr [RSI + R9*0x1]
MOVZX R9D,byte ptr [RSI + R9*0x1 + 0x2]
SHL R9D,0x10
OR R9,R10
JMP 0x00131958
caseD_4:
MOV R9D,dword ptr [RSI + R9*0x1]
JMP 0x00131958
caseD_2:
MOVZX R9D,word ptr [RSI + R9*0x1]
JMP 0x00131958
LAB_00131955:
XOR R9D,R9D
LAB_00131958:
MOV qword ptr [RCX + RDI*0x1 + 0x10],R9
ADD RAX,R9
ADD RDI,0x18
CMP RDX,RDI
JNZ 0x00131911
JMP 0x0013196d
LAB_0013196b:
XOR EAX,EAX
LAB_0013196d:
POP RBP
RET
|
long _mi_calc_total_blob_length(long *param_1,long param_2)
{
uint uVar1;
int iVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
ulong uVar7;
uVar1 = *(uint *)(*param_1 + 0x188);
if ((ulong)uVar1 == 0) {
lVar5 = 0;
}
else {
lVar3 = param_1[9];
lVar6 = 0;
lVar5 = 0;
do {
iVar2 = *(int *)(lVar3 + 8 + lVar6);
if (iVar2 - 1U < 4) {
lVar4 = *(long *)(lVar3 + lVar6);
switch(iVar2) {
case 1:
uVar7 = (ulong)*(byte *)(param_2 + lVar4);
break;
case 2:
uVar7 = (ulong)*(ushort *)(param_2 + lVar4);
break;
case 3:
uVar7 = (ulong)CONCAT12(*(int1 *)(param_2 + 2 + lVar4),
*(int2 *)(param_2 + lVar4));
break;
case 4:
uVar7 = (ulong)*(uint *)(param_2 + lVar4);
}
}
else {
uVar7 = 0;
}
*(ulong *)(lVar3 + 0x10 + lVar6) = uVar7;
lVar5 = lVar5 + uVar7;
lVar6 = lVar6 + 0x18;
} while ((ulong)uVar1 * 0x18 != lVar6);
}
return lVar5;
}
| |
24,996 | common_arg::common_arg(std::initializer_list<char const*> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&)) | monkey531[P]llama/common/arg.h | common_arg(
const std::initializer_list<const char *> & args,
const std::string & help,
void (*handler)(common_params & params)
) : args(args), help(help), handler_void(handler) {} | O2 | c | common_arg::common_arg(std::initializer_list<char const*> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void (*)(common_params&)):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
pushq $0x1
popq %rdx
leaq 0xb(%rsp), %rcx
leaq 0xa(%rsp), %r8
callq 0x3feda
leaq 0x38(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
andq $0x0, 0x40(%rbx)
movq %rax, 0x48(%rbx)
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
leaq 0x60(%rbx), %r12
movq (%r13), %rsi
movq 0x8(%r13), %rdx
leaq 0x9(%rsp), %rcx
movq %r12, %rdi
callq 0x3ff20
leaq 0x90(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rbx)
andq $0x0, 0x88(%rbx)
movq %r15, %rsi
callq 0x23cd0
movb $0x0, 0xb0(%rbx)
movq %r14, 0xb8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
andq $0x0, 0xd0(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x4025c
jmp 0x3c97f
movq %rax, %r14
leaq 0x30(%rbx), %rdi
callq 0x3ffa4
movq %rbx, %rdi
callq 0x3ffa4
movq %r14, %rdi
callq 0x240e0
| _ZN10common_argC2ERKSt16initializer_listIPKcERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPFvR13common_paramsE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rcx
mov r15, rdx
mov r13, rsi
mov rbx, rdi
lea rsi, [rsp+38h+var_2C]
and dword ptr [rsi], 0
push 1
pop rdx
lea rcx, [rsp+38h+var_2D]
lea r8, [rsp+38h+var_2E]
call _ZNSt3setI13llama_exampleSt4lessIS0_ESaIS0_EEC2ESt16initializer_listIS0_ERKS2_RKS3_; std::set<llama_example>::set(std::initializer_list<llama_example>,std::less<llama_example> const&,std::allocator<llama_example> const&)
lea rax, [rbx+38h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+30h], xmm0
and qword ptr [rbx+40h], 0
mov [rbx+48h], rax
mov [rbx+50h], rax
and qword ptr [rbx+58h], 0
lea r12, [rbx+60h]
mov rsi, [r13+0]
mov rdx, [r13+8]
lea rcx, [rsp+38h+var_2F]
mov rdi, r12
call _ZNSt6vectorIPKcSaIS1_EEC2ESt16initializer_listIS1_ERKS2_; std::vector<char const*>::vector(std::initializer_list<char const*>,std::allocator<char const*> const&)
lea rdi, [rbx+90h]
xorps xmm0, xmm0
movups xmmword ptr [rbx+78h], xmm0
and qword ptr [rbx+88h], 0
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2ERKS4_; std::string::basic_string(std::string const&)
mov byte ptr [rbx+0B0h], 0
mov [rbx+0B8h], r14
xorps xmm0, xmm0
movups xmmword ptr [rbx+0C0h], xmm0
and qword ptr [rbx+0D0h], 0
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov r14, rax
mov rdi, r12
call _ZNSt12_Vector_baseIPKcSaIS1_EED2Ev; std::_Vector_base<char const*>::~_Vector_base()
jmp short loc_3C97F
mov r14, rax
loc_3C97F:
lea rdi, [rbx+30h]
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, rbx
call _ZNSt8_Rb_treeI13llama_exampleS0_St9_IdentityIS0_ESt4lessIS0_ESaIS0_EED2Ev; std::_Rb_tree<llama_example,llama_example,std::_Identity<llama_example>,std::less<llama_example>,std::allocator<llama_example>>::~_Rb_tree()
mov rdi, r14
call __Unwind_Resume
| long long common_arg::common_arg(long long a1, _QWORD *a2, long long a3, long long a4)
{
long long result; // rax
char v7; // [rsp+9h] [rbp-2Fh] BYREF
char v8; // [rsp+Ah] [rbp-2Eh] BYREF
char v9; // [rsp+Bh] [rbp-2Dh] BYREF
_DWORD v10[11]; // [rsp+Ch] [rbp-2Ch] BYREF
v10[0] = 0;
std::set<llama_example>::set(a1, v10, 1LL, &v9, &v8);
*(_OWORD *)(a1 + 48) = 0LL;
*(_QWORD *)(a1 + 64) = 0LL;
*(_QWORD *)(a1 + 72) = a1 + 56;
*(_QWORD *)(a1 + 80) = a1 + 56;
*(_QWORD *)(a1 + 88) = 0LL;
std::vector<char const*>::vector(a1 + 96, *a2, a2[1], &v7);
*(_OWORD *)(a1 + 120) = 0LL;
*(_QWORD *)(a1 + 136) = 0LL;
result = std::string::basic_string(a1 + 144, a3);
*(_BYTE *)(a1 + 176) = 0;
*(_QWORD *)(a1 + 184) = a4;
*(_OWORD *)(a1 + 192) = 0LL;
*(_QWORD *)(a1 + 208) = 0LL;
return result;
}
| common_arg:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RCX
MOV R15,RDX
MOV R13,RSI
MOV RBX,RDI
LEA RSI,[RSP + 0xc]
AND dword ptr [RSI],0x0
PUSH 0x1
POP RDX
LEA RCX,[RSP + 0xb]
LEA R8,[RSP + 0xa]
CALL 0x0013feda
LEA RAX,[RBX + 0x38]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
AND qword ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],RAX
MOV qword ptr [RBX + 0x50],RAX
AND qword ptr [RBX + 0x58],0x0
LEA R12,[RBX + 0x60]
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
LAB_0013c916:
LEA RCX,[RSP + 0x9]
MOV RDI,R12
CALL 0x0013ff20
LEA RDI,[RBX + 0x90]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0x78],XMM0
AND qword ptr [RBX + 0x88],0x0
LAB_0013c939:
MOV RSI,R15
CALL 0x00123cd0
LAB_0013c941:
MOV byte ptr [RBX + 0xb0],0x0
MOV qword ptr [RBX + 0xb8],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
AND qword ptr [RBX + 0xd0],0x0
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* common_arg::common_arg(std::initializer_list<char const*> const&, std::__cxx11::string const&,
void (*)(common_params&)) */
void __thiscall
common_arg::common_arg
(common_arg *this,initializer_list *param_1,string *param_2,
_func_void_common_params_ptr *param_3)
{
int1 local_2f;
int1 local_2e;
int1 local_2d;
int4 local_2c;
local_2c = 0;
std::set<llama_example,std::less<llama_example>,std::allocator<llama_example>>::set
(this,&local_2c,1,&local_2d,&local_2e);
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(common_arg **)(this + 0x48) = this + 0x38;
*(common_arg **)(this + 0x50) = this + 0x38;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 0013c916 to 0013c922 has its CatchHandler @ 0013c97c */
std::vector<char_const*,std::allocator<char_const*>>::vector
((vector<char_const*,std::allocator<char_const*>> *)(this + 0x60),*(int8 *)param_1
,*(int8 *)(param_1 + 8),&local_2f);
*(int8 *)(this + 0x78) = 0;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
/* try { // try from 0013c939 to 0013c940 has its CatchHandler @ 0013c96f */
std::__cxx11::string::string((string *)(this + 0x90),param_2);
this[0xb0] = (common_arg)0x0;
*(_func_void_common_params_ptr **)(this + 0xb8) = param_3;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = 0;
return;
}
| |
24,997 | JS_IsEqual | bluesky950520[P]quickjs/quickjs.c | int JS_IsEqual(JSContext *ctx, JSValue op1, JSValue op2)
{
JSValue sp[2] = { js_dup(op1), js_dup(op2) };
if (js_eq_slow(ctx, endof(sp), 0))
return -1;
return JS_VALUE_GET_BOOL(sp[0]);
} | O1 | c | JS_IsEqual:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x10(%rsp)
cmpl $-0x9, %edx
jb 0x38fde
movq 0x10(%rsp), %rax
incl (%rax)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
cmpl $-0x9, %r8d
jb 0x38ffa
movq 0x8(%rsp), %rax
incl (%rax)
leaq 0x30(%rsp), %rbx
movq %rcx, -0x10(%rbx)
movq %r8, -0x8(%rbx)
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %edx, %edx
callq 0x39023
negl %eax
sbbl %ebp, %ebp
orl -0x20(%rbx), %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
| JS_IsEqual:
push rbp
push rbx
sub rsp, 38h
mov [rsp+48h+var_38], rsi
cmp edx, 0FFFFFFF7h
jb short loc_38FDE
mov rax, [rsp+48h+var_38]
inc dword ptr [rax]
loc_38FDE:
mov [rsp+48h+var_38], rsi
mov [rsp+48h+var_30], rdx
mov [rsp+48h+var_40], rcx
cmp r8d, 0FFFFFFF7h
jb short loc_38FFA
mov rax, [rsp+48h+var_40]
inc dword ptr [rax]
loc_38FFA:
lea rbx, [rsp+48h+var_18]
mov [rbx-10h], rcx
mov [rbx-8], r8
xor ebp, ebp
mov rsi, rbx
xor edx, edx
call js_eq_slow
neg eax
sbb ebp, ebp
or ebp, [rbx-20h]
mov eax, ebp
add rsp, 38h
pop rbx
pop rbp
retn
| long long JS_IsEqual(long long a1, _DWORD *a2, unsigned int a3, _DWORD *a4, unsigned int a5)
{
_BYTE v6[24]; // [rsp+30h] [rbp-18h] BYREF
if ( a3 >= 0xFFFFFFF7 )
++*a2;
if ( a5 >= 0xFFFFFFF7 )
++*a4;
return (unsigned int)js_eq_slow(a1, v6, 0LL) != 0 ? -1 : (unsigned int)a2;
}
| JS_IsEqual:
PUSH RBP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RSP + 0x10],RSI
CMP EDX,-0x9
JC 0x00138fde
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
LAB_00138fde:
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x18],RDX
MOV qword ptr [RSP + 0x8],RCX
CMP R8D,-0x9
JC 0x00138ffa
MOV RAX,qword ptr [RSP + 0x8]
INC dword ptr [RAX]
LAB_00138ffa:
LEA RBX,[RSP + 0x30]
MOV qword ptr [RBX + -0x10],RCX
MOV qword ptr [RBX + -0x8],R8
XOR EBP,EBP
MOV RSI,RBX
XOR EDX,EDX
CALL 0x00139023
NEG EAX
SBB EBP,EBP
OR EBP,dword ptr [RBX + -0x20]
MOV EAX,EBP
ADD RSP,0x38
POP RBX
POP RBP
RET
|
uint JS_IsEqual(int8 param_1,int *param_2,uint param_3,int *param_4,uint param_5)
{
int iVar1;
uint local_38;
int1 local_18 [8];
if (0xfffffff6 < param_3) {
*param_2 = *param_2 + 1;
}
if (0xfffffff6 < param_5) {
*param_4 = *param_4 + 1;
}
iVar1 = js_eq_slow(param_1,local_18,0);
local_38 = (uint)param_2;
return -(uint)(iVar1 != 0) | local_38;
}
| |
24,998 | my_thread_init | eloqsql/mysys/my_thr_init.c | my_bool my_thread_init(void)
{
struct st_my_thread_var *tmp;
my_bool error=0;
if (!my_thread_global_init_done)
return 1; /* cannot proceed with uninitialized library */
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init(): pthread_self: %p\n", pthread_self());
#endif
if (my_thread_var)
{
#ifdef EXTRA_DEBUG_THREADS
fprintf(stderr,"my_thread_init() called more than once in thread 0x%lx\n",
(long) pthread_self());
#endif
goto end;
}
#ifdef _MSC_VER
install_sigabrt_handler();
#endif
if (!(tmp= (struct st_my_thread_var *) calloc(1, sizeof(*tmp))))
{
error= 1;
goto end;
}
set_mysys_var(tmp);
tmp->pthread_self= pthread_self();
my_thread_init_thr_mutex(tmp);
tmp->stack_ends_here= (char*)&tmp +
STACK_DIRECTION * (long)my_thread_stack_size;
mysql_mutex_lock(&THR_LOCK_threads);
tmp->id= tmp->dbug_id= ++thread_id;
++THR_thread_count;
mysql_mutex_unlock(&THR_LOCK_threads);
tmp->init= 1;
#ifndef DBUG_OFF
/* Generate unique name for thread */
(void) my_thread_name();
#endif
end:
return error;
} | O0 | c | my_thread_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, -0x11(%rbp)
cmpb $0x0, 0x36881d(%rip) # 0x3a1870
jne 0x3905e
movb $0x1, -0x1(%rbp)
jmp 0x39147
callq 0x38f00
cmpq $0x0, %rax
je 0x3906e
jmp 0x39141
movl $0x1, %edi
movl $0xf0, %esi
callq 0x25220
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x39090
movb $0x1, -0x11(%rbp)
jmp 0x39141
movq -0x10(%rbp), %rdi
callq 0x393b0
callq 0x252a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc8(%rax)
movq -0x10(%rbp), %rdi
callq 0x38f50
leaq 0x1a82a4(%rip), %rax # 0x1e1360
movq (%rax), %rax
shlq $0x0, %rax
leaq -0x10(%rbp), %rcx
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb8(%rax)
leaq 0x3686cc(%rip), %rdi # 0x3a17a8
leaq 0x51052(%rip), %rsi # 0x8a135
movl $0x12e, %edx # imm = 0x12E
callq 0x39260
movq 0x368784(%rip), %rcx # 0x3a1878
addq $0x1, %rcx
movq %rcx, 0x368779(%rip) # 0x3a1878
movq -0x10(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0xd0(%rax)
leaq 0x36848c(%rip), %rax # 0x3a15a8
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x368480(%rip), %rax # 0x3a15a8
movl %ecx, (%rax)
leaq 0x368677(%rip), %rdi # 0x3a17a8
callq 0x39350
movq -0x10(%rbp), %rax
movb $0x1, 0xe8(%rax)
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
| my_thread_init:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_11], 0
cmp cs:my_thread_global_init_done, 0
jnz short loc_3905E
mov [rbp+var_1], 1
jmp loc_39147
loc_3905E:
call _my_thread_var
cmp rax, 0
jz short loc_3906E
jmp loc_39141
loc_3906E:
mov edi, 1
mov esi, 0F0h
call _calloc
mov [rbp+var_10], rax
cmp rax, 0
jnz short loc_39090
mov [rbp+var_11], 1
jmp loc_39141
loc_39090:
mov rdi, [rbp+var_10]
call set_mysys_var
call _pthread_self
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+0C8h], rcx
mov rdi, [rbp+var_10]
call my_thread_init_thr_mutex
lea rax, my_thread_stack_size
mov rax, [rax]
shl rax, 0
lea rcx, [rbp+var_10]
add rcx, rax
mov rax, [rbp+var_10]
mov [rax+0B8h], rcx
lea rdi, THR_LOCK_threads
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 12Eh
call inline_mysql_mutex_lock_1
mov rcx, cs:thread_id
add rcx, 1
mov cs:thread_id, rcx
mov rax, [rbp+var_10]
mov [rax+0D8h], rcx
mov rax, [rbp+var_10]
mov [rax+0D0h], rcx
lea rax, THR_thread_count
mov ecx, [rax]
add ecx, 1
lea rax, THR_thread_count
mov [rax], ecx
lea rdi, THR_LOCK_threads
call inline_mysql_mutex_unlock_1
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 1
loc_39141:
mov al, [rbp+var_11]
mov [rbp+var_1], al
loc_39147:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_thread_init()
{
long long v0; // rcx
char v2; // [rsp+Fh] [rbp-11h]
long long v3; // [rsp+10h] [rbp-10h] BYREF
v2 = 0;
if ( !my_thread_global_init_done )
return 1;
if ( !my_thread_var() )
{
v3 = calloc(1LL, 240LL);
if ( v3 )
{
set_mysys_var(v3);
*(_QWORD *)(v3 + 200) = pthread_self();
my_thread_init_thr_mutex(v3);
*(_QWORD *)(v3 + 184) = (char *)&v3 + (_QWORD)my_thread_stack_size;
inline_mysql_mutex_lock_1(
&THR_LOCK_threads,
"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
302LL);
v0 = thread_id + 1;
thread_id = v0;
*(_QWORD *)(v3 + 216) = v0;
*(_QWORD *)(v3 + 208) = v0;
++THR_thread_count;
inline_mysql_mutex_unlock_1(&THR_LOCK_threads);
*(_BYTE *)(v3 + 232) = 1;
}
else
{
return 1;
}
}
return v2;
}
| my_thread_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV byte ptr [RBP + -0x11],0x0
CMP byte ptr [0x004a1870],0x0
JNZ 0x0013905e
MOV byte ptr [RBP + -0x1],0x1
JMP 0x00139147
LAB_0013905e:
CALL 0x00138f00
CMP RAX,0x0
JZ 0x0013906e
JMP 0x00139141
LAB_0013906e:
MOV EDI,0x1
MOV ESI,0xf0
CALL 0x00125220
MOV qword ptr [RBP + -0x10],RAX
CMP RAX,0x0
JNZ 0x00139090
MOV byte ptr [RBP + -0x11],0x1
JMP 0x00139141
LAB_00139090:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001393b0
CALL 0x001252a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc8],RCX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00138f50
LEA RAX,[0x2e1360]
MOV RAX,qword ptr [RAX]
SHL RAX,0x0
LEA RCX,[RBP + -0x10]
ADD RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xb8],RCX
LEA RDI,[0x4a17a8]
LEA RSI,[0x18a135]
MOV EDX,0x12e
CALL 0x00139260
MOV RCX,qword ptr [0x004a1878]
ADD RCX,0x1
MOV qword ptr [0x004a1878],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xd0],RCX
LEA RAX,[0x4a15a8]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x4a15a8]
MOV dword ptr [RAX],ECX
LEA RDI,[0x4a17a8]
CALL 0x00139350
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x1
LAB_00139141:
MOV AL,byte ptr [RBP + -0x11]
MOV byte ptr [RBP + -0x1],AL
LAB_00139147:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
int1 my_thread_init(void)
{
long lVar1;
pthread_t pVar2;
int1 local_19;
void *local_18;
int1 local_9;
local_19 = 0;
if (my_thread_global_init_done == '\0') {
local_9 = 1;
}
else {
lVar1 = _my_thread_var();
if (lVar1 == 0) {
local_18 = calloc(1,0xf0);
if (local_18 == (void *)0x0) {
local_19 = 1;
}
else {
set_mysys_var(local_18);
pVar2 = pthread_self();
*(pthread_t *)((long)local_18 + 200) = pVar2;
my_thread_init_thr_mutex(local_18);
*(long *)((long)local_18 + 0xb8) = (long)&local_18 + my_thread_stack_size;
inline_mysql_mutex_lock
(THR_LOCK_threads,"/workspace/llm4binary/github2025/eloqsql/mysys/my_thr_init.c",
0x12e);
lVar1 = thread_id + 1;
thread_id = lVar1;
*(long *)((long)local_18 + 0xd8) = lVar1;
*(long *)((long)local_18 + 0xd0) = lVar1;
THR_thread_count = THR_thread_count + 1;
inline_mysql_mutex_unlock(THR_LOCK_threads);
*(int1 *)((long)local_18 + 0xe8) = 1;
}
}
local_9 = local_19;
}
return local_9;
}
| |
24,999 | MyCTX_nopad::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int) | eloqsql/mysys_ssl/my_crypt.cc | int init(const EVP_CIPHER *cipher, int encrypt, const uchar *key, uint klen,
const uchar *iv, uint ivlen)
{
compile_time_assert(MY_AES_CTX_SIZE >= sizeof(MyCTX_nopad));
this->key= key;
this->klen= klen;
this->source_tail_len= 0;
if (ivlen)
memcpy(oiv, iv, ivlen);
DBUG_ASSERT(ivlen == 0 || ivlen == sizeof(oiv));
int res= MyCTX::init(cipher, encrypt, key, klen, iv, ivlen);
EVP_CIPHER_CTX_set_padding(ctx, 0);
return res;
} | O0 | cpp | MyCTX_nopad::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xb9c9dc
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xd8(%rax)
movl $0x0, 0xdc(%rax)
cmpl $0x0, 0x10(%rbp)
je 0xb9ca1d
movq -0x40(%rbp), %rdi
addq $0xe0, %rdi
movq -0x30(%rbp), %rsi
movl 0x10(%rbp), %eax
movl %eax, %edx
callq 0x4331a0
jmp 0xb9ca1f
jmp 0xb9ca21
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0xb9c810
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x34(%rbp)
movq 0xc8(%rax), %rdi
xorl %esi, %esi
callq 0x433a60
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN11MyCTX_nopad4initEPK13evp_cipher_stiPKhjS4_j:
push rbp
mov rbp, rsp
sub rsp, 50h
mov eax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
mov rax, [rbp+var_8]
mov [rbp+var_40], rax
jmp short $+2
loc_B9C9DC:
mov rax, [rbp+var_40]
mov rcx, [rbp+var_20]
mov [rax+0D0h], rcx
mov ecx, [rbp+var_24]
mov [rax+0D8h], ecx
mov dword ptr [rax+0DCh], 0
cmp [rbp+arg_0], 0
jz short loc_B9CA1D
mov rdi, [rbp+var_40]
add rdi, 0E0h
mov rsi, [rbp+var_30]
mov eax, [rbp+arg_0]
mov edx, eax
call _memcpy
loc_B9CA1D:
jmp short $+2
loc_B9CA1F:
jmp short $+2
loc_B9CA21:
mov rdi, [rbp+var_40]
mov rsi, [rbp+var_10]
mov edx, [rbp+var_14]
mov rcx, [rbp+var_20]
mov r8d, [rbp+var_24]
mov r9, [rbp+var_30]
mov eax, [rbp+arg_0]
mov [rsp+50h+var_50], eax
call _ZN5MyCTX4initEPK13evp_cipher_stiPKhjS4_j; MyCTX::init(evp_cipher_st const*,int,uchar const*,uint,uchar const*,uint)
mov ecx, eax
mov rax, [rbp+var_40]
mov [rbp+var_34], ecx
mov rdi, [rax+0C8h]
xor esi, esi
call _EVP_CIPHER_CTX_set_padding
mov eax, [rbp+var_34]
add rsp, 50h
pop rbp
retn
| long long MyCTX_nopad::init(
_QWORD *a1,
long long a2,
unsigned int a3,
long long a4,
unsigned int a5,
long long a6,
unsigned int a7)
{
unsigned int v8; // [rsp+1Ch] [rbp-34h]
a1[26] = a4;
a1[27] = a5;
if ( a7 )
memcpy(a1 + 28, a6, a7);
v8 = MyCTX::init((long long)a1, a2, a3, a4, a5, a6);
EVP_CIPHER_CTX_set_padding(a1[25], 0LL);
return v8;
}
| create_func_number:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RSI,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RSI
MOV EDI,0xa8
CALL 0x005b54b0
MOV RCX,RAX
MOV qword ptr [RBP + -0x38],RCX
MOV byte ptr [RBP + -0x15],0x0
XOR EAX,EAX
CMP RCX,0x0
MOV qword ptr [RBP + -0x30],RAX
JZ 0x00b9ca1a
MOV RDI,qword ptr [RBP + -0x38]
MOV byte ptr [RBP + -0x15],0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX]
LAB_00b9ca09:
CALL 0x00ba2b70
LAB_00b9ca0e:
JMP 0x00b9ca10
LAB_00b9ca10:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00b9ca1a
LAB_00b9ca1a:
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x40
POP RBP
RET
|
/* create_func_number(my_xpath_st*, Item**, unsigned int) */
Item_xpath_cast_number * create_func_number(my_xpath_st *param_1,Item **param_2,uint param_3)
{
Item_xpath_cast_number *this;
int8 local_38;
this = (Item_xpath_cast_number *)
Item::operator_new(0xa8,*(st_mem_root **)(*(long *)param_1 + 0x28));
local_38 = (Item_xpath_cast_number *)0x0;
if (this != (Item_xpath_cast_number *)0x0) {
/* try { // try from 00b9ca09 to 00b9ca0d has its CatchHandler @ 00b9ca24 */
Item_xpath_cast_number::Item_xpath_cast_number(this,*(THD **)param_1,*param_2);
local_38 = this;
}
return local_38;
}
|
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.