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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
22,900 | nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l, 1l>> const&) | ng-log[P]ng-log/src/logging.cc | string PrettyDuration(const std::chrono::duration<int>& secs) {
std::stringstream result;
int mins = secs.count() / 60;
int hours = mins / 60;
mins = mins % 60;
int s = secs.count() % 60;
result.fill('0');
result << hours << ':' << setw(2) << mins << ':' << setw(2) << s;
return result.str();
} | O0 | cpp | nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l, 1l>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa5b0
movq -0x10(%rbp), %rdi
callq 0x3bc30
movl %eax, -0x1c0(%rbp)
jmp 0x37db1
movl -0x1c0(%rbp), %ecx
movslq %ecx, %rax
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
movl %eax, -0x19c(%rbp)
movslq -0x19c(%rbp), %rax
movl %eax, %ecx
imulq $-0x77777777, %rax, %rax # imm = 0x88888889
shrq $0x20, %rax
addl %ecx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
sarl $0x5, %eax
addl %ecx, %eax
movl %eax, -0x1b0(%rbp)
movslq -0x19c(%rbp), %rcx
movl %ecx, %eax
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, -0x19c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3bc30
movl %eax, -0x1d4(%rbp)
jmp 0x37e39
movl -0x1d4(%rbp), %eax
movslq %eax, %rcx
imulq $-0x77777777, %rcx, %rcx # imm = 0x88888889
shrq $0x20, %rcx
addl %eax, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x5, %ecx
addl %edx, %ecx
imull $0x3c, %ecx, %ecx
subl %ecx, %eax
movl %eax, -0x1b4(%rbp)
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
movl $0x30, %esi
callq 0xa8f0
jmp 0x37e83
leaq -0x188(%rbp), %rdi
movl -0x1b0(%rbp), %esi
callq 0xaf20
movq %rax, -0x1e0(%rbp)
jmp 0x37e9e
movq -0x1e0(%rbp), %rdi
movl $0x3a, %esi
callq 0xa9c0
movq %rax, -0x1e8(%rbp)
jmp 0x37eb8
movl $0x2, %edi
callq 0x27de0
movl %eax, -0x1ec(%rbp)
jmp 0x37eca
movq -0x1e8(%rbp), %rdi
movl -0x1ec(%rbp), %eax
movl %eax, -0x1b8(%rbp)
movl -0x1b8(%rbp), %esi
callq 0xa990
movq %rax, -0x1f8(%rbp)
jmp 0x37ef1
movq -0x1f8(%rbp), %rdi
movl -0x19c(%rbp), %esi
callq 0xaf20
movq %rax, -0x200(%rbp)
jmp 0x37f0c
movq -0x200(%rbp), %rdi
movl $0x3a, %esi
callq 0xa9c0
movq %rax, -0x208(%rbp)
jmp 0x37f26
movl $0x2, %edi
callq 0x27de0
movl %eax, -0x20c(%rbp)
jmp 0x37f38
movq -0x208(%rbp), %rdi
movl -0x20c(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %esi
callq 0xa990
movq %rax, -0x218(%rbp)
jmp 0x37f5f
movq -0x218(%rbp), %rdi
movl -0x1b4(%rbp), %esi
callq 0xaf20
jmp 0x37f73
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0xa7c0
jmp 0x37f88
leaq -0x198(%rbp), %rdi
callq 0xa610
movq -0x1c8(%rbp), %rax
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0xa610
movq -0x1a8(%rbp), %rdi
callq 0xaf50
nop
| _ZN5nglog12_GLOBAL__N_114PrettyDurationB5cxx11ERKNSt6chrono8durationIiSt5ratioILl1ELl1EEEE:
push rbp
mov rbp, rsp
sub rsp, 220h
mov [rbp+var_1D0], rdi
mov rax, rdi
mov [rbp+var_1C8], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(void)
mov rdi, [rbp+var_10]
call _ZNKSt6chrono8durationIiSt5ratioILl1ELl1EEE5countEv; std::chrono::duration<int,std::ratio<1l,1l>>::count(void)
mov [rbp+var_1C0], eax
jmp short $+2
loc_37DB1:
mov ecx, [rbp+var_1C0]
movsxd rax, ecx
imul rax, 0FFFFFFFF88888889h
shr rax, 20h
add eax, ecx
mov ecx, eax
shr ecx, 1Fh
sar eax, 5
add eax, ecx
mov [rbp+var_19C], eax
movsxd rax, [rbp+var_19C]
mov ecx, eax
imul rax, 0FFFFFFFF88888889h
shr rax, 20h
add eax, ecx
mov ecx, eax
shr ecx, 1Fh
sar eax, 5
add eax, ecx
mov [rbp+var_1B0], eax
movsxd rcx, [rbp+var_19C]
mov eax, ecx
imul rcx, 0FFFFFFFF88888889h
shr rcx, 20h
add ecx, eax
mov edx, ecx
shr edx, 1Fh
sar ecx, 5
add ecx, edx
imul ecx, 3Ch ; '<'
sub eax, ecx
mov [rbp+var_19C], eax
mov rdi, [rbp+var_10]
call _ZNKSt6chrono8durationIiSt5ratioILl1ELl1EEE5countEv; std::chrono::duration<int,std::ratio<1l,1l>>::count(void)
mov [rbp+var_1D4], eax
jmp short $+2
loc_37E39:
mov eax, [rbp+var_1D4]
movsxd rcx, eax
imul rcx, 0FFFFFFFF88888889h
shr rcx, 20h
add ecx, eax
mov edx, ecx
shr edx, 1Fh
sar ecx, 5
add ecx, edx
imul ecx, 3Ch ; '<'
sub eax, ecx
mov [rbp+var_1B4], eax
mov rax, [rbp+var_198]
mov rax, [rax-18h]
lea rdi, [rbp+rax+var_198]
mov esi, 30h ; '0'
call __ZNSt9basic_iosIcSt11char_traitsIcEE4fillEc; std::ios::fill(char)
jmp short $+2
loc_37E83:
lea rdi, [rbp+var_188]
mov esi, [rbp+var_1B0]
call __ZNSolsEi; std::ostream::operator<<(int)
mov [rbp+var_1E0], rax
jmp short $+2
loc_37E9E:
mov rdi, [rbp+var_1E0]
mov esi, 3Ah ; ':'
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov [rbp+var_1E8], rax
jmp short $+2
loc_37EB8:
mov edi, 2; int
call _ZSt4setwi; std::setw(int)
mov [rbp+var_1EC], eax
jmp short $+2
loc_37ECA:
mov rdi, [rbp+var_1E8]
mov eax, [rbp+var_1EC]
mov [rbp+var_1B8], eax
mov esi, [rbp+var_1B8]
call __ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Setw)
mov [rbp+var_1F8], rax
jmp short $+2
loc_37EF1:
mov rdi, [rbp+var_1F8]
mov esi, [rbp+var_19C]
call __ZNSolsEi; std::ostream::operator<<(int)
mov [rbp+var_200], rax
jmp short $+2
loc_37F0C:
mov rdi, [rbp+var_200]
mov esi, 3Ah ; ':'
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_c; std::operator<<<std::char_traits<char>>(std::ostream &,char)
mov [rbp+var_208], rax
jmp short $+2
loc_37F26:
mov edi, 2; int
call _ZSt4setwi; std::setw(int)
mov [rbp+var_20C], eax
jmp short $+2
loc_37F38:
mov rdi, [rbp+var_208]
mov eax, [rbp+var_20C]
mov [rbp+var_1BC], eax
mov esi, [rbp+var_1BC]
call __ZStlsIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_St5_Setw; std::operator<<<char,std::char_traits<char>>(std::ostream &,std::_Setw)
mov [rbp+var_218], rax
jmp short $+2
loc_37F5F:
mov rdi, [rbp+var_218]
mov esi, [rbp+var_1B4]
call __ZNSolsEi; std::ostream::operator<<(int)
jmp short $+2
loc_37F73:
mov rdi, [rbp+var_1D0]
lea rsi, [rbp+var_198]
call __ZNKSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEE3strEv; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(void)
jmp short $+2
loc_37F88:
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rax, [rbp+var_1C8]
add rsp, 220h
pop rbp
retn
mov rcx, rax
mov eax, edx
mov [rbp+var_1A8], rcx
mov [rbp+var_1AC], eax
lea rdi, [rbp+var_198]
call __ZNSt7__cxx1118basic_stringstreamIcSt11char_traitsIcESaIcEED1Ev; std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream()
mov rdi, [rbp+var_1A8]
call __Unwind_Resume
| long long nglog::`anonymous namespace'::PrettyDuration[abi:cxx11](long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-218h]
long long v4; // [rsp+18h] [rbp-208h]
long long v5; // [rsp+20h] [rbp-200h]
long long v6; // [rsp+28h] [rbp-1F8h]
long long v7; // [rsp+38h] [rbp-1E8h]
long long v8; // [rsp+40h] [rbp-1E0h]
int v9; // [rsp+60h] [rbp-1C0h]
unsigned int v10; // [rsp+64h] [rbp-1BCh]
unsigned int v11; // [rsp+68h] [rbp-1B8h]
unsigned int v12; // [rsp+6Ch] [rbp-1B4h]
_QWORD v13[2]; // [rsp+88h] [rbp-198h] BYREF
_BYTE v14[376]; // [rsp+98h] [rbp-188h] BYREF
long long v15; // [rsp+210h] [rbp-10h]
long long v16; // [rsp+218h] [rbp-8h]
v16 = a1;
v15 = a2;
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::basic_stringstream(v13);
v9 = std::chrono::duration<int,std::ratio<1l,1l>>::count(v15);
v12 = (int)std::chrono::duration<int,std::ratio<1l,1l>>::count(v15) % 60;
std::ios::fill((char *)v13 + *(_QWORD *)(v13[0] - 24LL), 48LL);
v8 = std::ostream::operator<<(v14, (unsigned int)(v9 / 60 / 60));
v7 = std::operator<<<std::char_traits<char>>(v8, 58LL);
v11 = std::setw(2u);
v6 = std::operator<<<char,std::char_traits<char>>(v7, v11);
v5 = std::ostream::operator<<(v6, (unsigned int)(v9 / 60 % 60));
v4 = std::operator<<<std::char_traits<char>>(v5, 58LL);
v10 = std::setw(2u);
v3 = std::operator<<<char,std::char_traits<char>>(v4, v10);
std::ostream::operator<<(v3, v12);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::str(a1, v13);
std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>>::~basic_stringstream(v13);
return a1;
}
| PrettyDuration[abi:cxx11]:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x220
MOV qword ptr [RBP + -0x1d0],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x1c8],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
LEA RDI,[RBP + -0x198]
CALL 0x0010a5b0
MOV RDI,qword ptr [RBP + -0x10]
LAB_00137da4:
CALL 0x0013bc30
MOV dword ptr [RBP + -0x1c0],EAX
JMP 0x00137db1
LAB_00137db1:
MOV ECX,dword ptr [RBP + -0x1c0]
MOVSXD RAX,ECX
IMUL RAX,RAX,-0x77777777
SHR RAX,0x20
ADD EAX,ECX
MOV ECX,EAX
SHR ECX,0x1f
SAR EAX,0x5
ADD EAX,ECX
MOV dword ptr [RBP + -0x19c],EAX
MOVSXD RAX,dword ptr [RBP + -0x19c]
MOV ECX,EAX
IMUL RAX,RAX,-0x77777777
SHR RAX,0x20
ADD EAX,ECX
MOV ECX,EAX
SHR ECX,0x1f
SAR EAX,0x5
ADD EAX,ECX
MOV dword ptr [RBP + -0x1b0],EAX
MOVSXD RCX,dword ptr [RBP + -0x19c]
MOV EAX,ECX
IMUL RCX,RCX,-0x77777777
SHR RCX,0x20
ADD ECX,EAX
MOV EDX,ECX
SHR EDX,0x1f
SAR ECX,0x5
ADD ECX,EDX
IMUL ECX,ECX,0x3c
SUB EAX,ECX
MOV dword ptr [RBP + -0x19c],EAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x0013bc30
MOV dword ptr [RBP + -0x1d4],EAX
JMP 0x00137e39
LAB_00137e39:
MOV EAX,dword ptr [RBP + -0x1d4]
MOVSXD RCX,EAX
IMUL RCX,RCX,-0x77777777
SHR RCX,0x20
ADD ECX,EAX
MOV EDX,ECX
SHR EDX,0x1f
SAR ECX,0x5
ADD ECX,EDX
IMUL ECX,ECX,0x3c
SUB EAX,ECX
MOV dword ptr [RBP + -0x1b4],EAX
MOV RAX,qword ptr [RBP + -0x198]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RBP + RAX*0x1 + -0x198]
MOV ESI,0x30
CALL 0x0010a8f0
JMP 0x00137e83
LAB_00137e83:
LEA RDI,[RBP + -0x188]
MOV ESI,dword ptr [RBP + -0x1b0]
CALL 0x0010af20
MOV qword ptr [RBP + -0x1e0],RAX
JMP 0x00137e9e
LAB_00137e9e:
MOV RDI,qword ptr [RBP + -0x1e0]
MOV ESI,0x3a
CALL 0x0010a9c0
MOV qword ptr [RBP + -0x1e8],RAX
JMP 0x00137eb8
LAB_00137eb8:
MOV EDI,0x2
CALL 0x00127de0
MOV dword ptr [RBP + -0x1ec],EAX
JMP 0x00137eca
LAB_00137eca:
MOV RDI,qword ptr [RBP + -0x1e8]
MOV EAX,dword ptr [RBP + -0x1ec]
MOV dword ptr [RBP + -0x1b8],EAX
MOV ESI,dword ptr [RBP + -0x1b8]
CALL 0x0010a990
MOV qword ptr [RBP + -0x1f8],RAX
JMP 0x00137ef1
LAB_00137ef1:
MOV RDI,qword ptr [RBP + -0x1f8]
MOV ESI,dword ptr [RBP + -0x19c]
CALL 0x0010af20
MOV qword ptr [RBP + -0x200],RAX
JMP 0x00137f0c
LAB_00137f0c:
MOV RDI,qword ptr [RBP + -0x200]
MOV ESI,0x3a
CALL 0x0010a9c0
MOV qword ptr [RBP + -0x208],RAX
JMP 0x00137f26
LAB_00137f26:
MOV EDI,0x2
CALL 0x00127de0
MOV dword ptr [RBP + -0x20c],EAX
JMP 0x00137f38
LAB_00137f38:
MOV RDI,qword ptr [RBP + -0x208]
MOV EAX,dword ptr [RBP + -0x20c]
MOV dword ptr [RBP + -0x1bc],EAX
MOV ESI,dword ptr [RBP + -0x1bc]
CALL 0x0010a990
MOV qword ptr [RBP + -0x218],RAX
JMP 0x00137f5f
LAB_00137f5f:
MOV RDI,qword ptr [RBP + -0x218]
MOV ESI,dword ptr [RBP + -0x1b4]
CALL 0x0010af20
JMP 0x00137f73
LAB_00137f73:
MOV RDI,qword ptr [RBP + -0x1d0]
LEA RSI,[RBP + -0x198]
CALL 0x0010a7c0
LAB_00137f86:
JMP 0x00137f88
LAB_00137f88:
LEA RDI,[RBP + -0x198]
CALL 0x0010a610
MOV RAX,qword ptr [RBP + -0x1c8]
ADD RSP,0x220
POP RBP
RET
|
/* nglog::(anonymous namespace)::PrettyDuration[abi:cxx11](std::chrono::duration<int, std::ratio<1l,
1l> > const&) */
_anonymous_namespace_ * __thiscall
nglog::(anonymous_namespace)::PrettyDuration_abi_cxx11_
(_anonymous_namespace_ *this,duration *param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
ostream *poVar4;
long local_1a0 [2];
ostream local_190 [376];
duration<int,std::ratio<1l,1l>> *local_18;
_anonymous_namespace_ *local_10;
local_18 = (duration<int,std::ratio<1l,1l>> *)param_1;
local_10 = this;
std::__cxx11::stringstream::stringstream((stringstream *)local_1a0);
/* try { // try from 00137da4 to 00137f85 has its CatchHandler @ 00137fa4 */
iVar1 = std::chrono::duration<int,std::ratio<1l,1l>>::count(local_18);
iVar2 = std::chrono::duration<int,std::ratio<1l,1l>>::count(local_18);
std::ios::fill((char)local_1a0 + (char)*(int8 *)(local_1a0[0] + -0x18));
poVar4 = (ostream *)std::ostream::operator<<(local_190,(iVar1 / 0x3c) / 0x3c);
poVar4 = std::operator<<(poVar4,':');
uVar3 = std::setw(2);
poVar4 = std::operator<<(poVar4,uVar3);
poVar4 = (ostream *)std::ostream::operator<<(poVar4,(iVar1 / 0x3c) % 0x3c);
poVar4 = std::operator<<(poVar4,':');
uVar3 = std::setw(2);
poVar4 = std::operator<<(poVar4,uVar3);
std::ostream::operator<<(poVar4,iVar2 % 0x3c);
std::__cxx11::stringstream::str();
std::__cxx11::stringstream::~stringstream((stringstream *)local_1a0);
return this;
}
| |
22,901 | SET_scan_module | xtate/src/xconf.c | static ConfRes SET_scan_module(void *conf, const char *name,
const char *value) {
XConf *xconf = (XConf *)conf;
if (xconf->echo) {
if (xconf->scanner) {
fprintf(xconf->echo, "scan-module = %s\n", xconf->scanner->name);
}
return 0;
}
xconf->scanner = get_scan_module_by_name(value);
if (!xconf->scanner) {
LOG(LEVEL_ERROR, "fail %s: no such scan module named %s\n", name,
value);
return Conf_ERR;
}
if (xconf->op == Op_Default)
xconf->op = Op_Scan;
return Conf_OK;
} | O3 | c | SET_scan_module:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x2a8(%rdi), %rdi
testq %rdi, %rdi
je 0x597d7
movq 0x4f0(%r15), %rax
testq %rax, %rax
je 0x5980a
movq (%rax), %rdx
leaq 0x2552c(%rip), %rsi # 0x7ecf8
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x15220
jmp 0x5982c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdx, %rdi
callq 0x392e4
movq %rax, 0x4f0(%r15)
testq %rax, %rax
je 0x5980e
xorl %ebx, %ebx
cmpl $0x0, 0x6b0(%r15)
jne 0x5982c
movl $0x1, 0x6b0(%r15)
jmp 0x5982c
xorl %ebx, %ebx
jmp 0x5982c
leaq 0x254f5(%rip), %rsi # 0x7ed0a
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x536da
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
| SET_scan_module:
push r15
push r14
push rbx
mov r15, rdi
mov rdi, [rdi+2A8h]
test rdi, rdi
jz short loc_597D7
mov rax, [r15+4F0h]
test rax, rax
jz short loc_5980A
mov rdx, [rax]
lea rsi, aScanModuleS; "scan-module = %s\n"
xor ebx, ebx
xor eax, eax
call _fprintf
jmp short loc_5982C
loc_597D7:
mov rbx, rdx
mov r14, rsi
mov rdi, rdx
call get_scan_module_by_name
mov [r15+4F0h], rax
test rax, rax
jz short loc_5980E
xor ebx, ebx
cmp dword ptr [r15+6B0h], 0
jnz short loc_5982C
mov dword ptr [r15+6B0h], 1
jmp short loc_5982C
loc_5980A:
xor ebx, ebx
jmp short loc_5982C
loc_5980E:
lea rsi, aFailSNoSuchSca; "fail %s: no such scan module named %s\n"
mov edi, 0FFFFFFFFh
mov rdx, r14
mov rcx, rbx
xor eax, eax
call LOG
mov ebx, 1
loc_5982C:
mov eax, ebx
pop rbx
pop r14
pop r15
retn
| long long SET_scan_module(
long long a1,
long long a2,
long long a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
long long v12; // rdi
const char **v13; // rax
unsigned int v14; // ebx
_UNKNOWN **scan_module_by_name; // rax
long long v17; // r8
long long v18; // r9
__m128 v19; // xmm4
__m128 v20; // xmm5
char v22; // [rsp+0h] [rbp-18h]
v12 = *(_QWORD *)(a1 + 680);
if ( v12 )
{
v13 = *(const char ***)(a1 + 1264);
v14 = 0;
if ( v13 )
fprintf(v12, "scan-module = %s\n", *v13);
}
else
{
scan_module_by_name = get_scan_module_by_name(a3);
*(_QWORD *)(a1 + 1264) = scan_module_by_name;
if ( scan_module_by_name )
{
v14 = 0;
if ( !*(_DWORD *)(a1 + 1712) )
*(_DWORD *)(a1 + 1712) = 1;
}
else
{
LOG(
-1,
(long long)"fail %s: no such scan module named %s\n",
a2,
a3,
v17,
v18,
a4,
a5,
a6,
a7,
v19,
v20,
a10,
a11,
v22);
return 1;
}
}
return v14;
}
| SET_scan_module:
PUSH R15
PUSH R14
PUSH RBX
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x2a8]
TEST RDI,RDI
JZ 0x001597d7
MOV RAX,qword ptr [R15 + 0x4f0]
TEST RAX,RAX
JZ 0x0015980a
MOV RDX,qword ptr [RAX]
LEA RSI,[0x17ecf8]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00115220
JMP 0x0015982c
LAB_001597d7:
MOV RBX,RDX
MOV R14,RSI
MOV RDI,RDX
CALL 0x001392e4
MOV qword ptr [R15 + 0x4f0],RAX
TEST RAX,RAX
JZ 0x0015980e
XOR EBX,EBX
CMP dword ptr [R15 + 0x6b0],0x0
JNZ 0x0015982c
MOV dword ptr [R15 + 0x6b0],0x1
JMP 0x0015982c
LAB_0015980a:
XOR EBX,EBX
JMP 0x0015982c
LAB_0015980e:
LEA RSI,[0x17ed0a]
MOV EDI,0xffffffff
MOV RDX,R14
MOV RCX,RBX
XOR EAX,EAX
CALL 0x001536da
MOV EBX,0x1
LAB_0015982c:
MOV EAX,EBX
POP RBX
POP R14
POP R15
RET
|
int8 SET_scan_module(long param_1,int8 param_2,int8 param_3)
{
long lVar1;
int8 uVar2;
if (*(FILE **)(param_1 + 0x2a8) == (FILE *)0x0) {
lVar1 = get_scan_module_by_name(param_3);
*(long *)(param_1 + 0x4f0) = lVar1;
if (lVar1 == 0) {
LOG(0xffffffff,"fail %s: no such scan module named %s\n",param_2,param_3);
uVar2 = 1;
}
else {
uVar2 = 0;
if (*(int *)(param_1 + 0x6b0) == 0) {
*(int4 *)(param_1 + 0x6b0) = 1;
uVar2 = 0;
}
}
}
else if (*(int8 **)(param_1 + 0x4f0) == (int8 *)0x0) {
uVar2 = 0;
}
else {
fprintf(*(FILE **)(param_1 + 0x2a8),"scan-module = %s\n",**(int8 **)(param_1 + 0x4f0));
uVar2 = 0;
}
return uVar2;
}
| |
22,902 | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) | monkey531[P]llama/common/minja.hpp | static std::string typeToString(Type t) {
switch (t) {
case Type::Text: return "text";
case Type::Expression: return "expression";
case Type::If: return "if";
case Type::Else: return "else";
case Type::Elif: return "elif";
case Type::EndIf: return "endif";
case Type::For: return "for";
case Type::EndFor: return "endfor";
case Type::Set: return "set";
case Type::EndSet: return "endset";
case Type::Comment: return "comment";
case Type::Macro: return "macro";
case Type::EndMacro: return "endmacro";
case Type::Filter: return "filter";
case Type::EndFilter: return "endfilter";
case Type::Generation: return "generation";
case Type::EndGeneration: return "endgeneration";
case Type::Break: return "break";
case Type::Continue: return "continue";
}
return "Unknown";
} | O2 | cpp | minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x12, %esi
ja 0x8eda5
movl %esi, %eax
leaq 0x411c6(%rip), %rcx # 0xcfea8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3670d(%rip), %rsi # 0xc53ff
jmp 0x8edac
leaq 0x4228d(%rip), %rsi # 0xd0f8b
jmp 0x8edac
leaq 0x42254(%rip), %rsi # 0xd0f5e
jmp 0x8edac
leaq 0x4221e(%rip), %rsi # 0xd0f34
jmp 0x8edac
leaq 0x4211c(%rip), %rsi # 0xd0e3e
jmp 0x8edac
leaq 0x4328d(%rip), %rsi # 0xd1fbb
jmp 0x8edac
leaq 0x42192(%rip), %rsi # 0xd0ec9
jmp 0x8edac
leaq 0x3b03c(%rip), %rsi # 0xc9d7c
jmp 0x8edac
leaq 0x3878f(%rip), %rsi # 0xc74d8
jmp 0x8edac
leaq 0x42112(%rip), %rsi # 0xd0e64
jmp 0x8edac
leaq 0x42167(%rip), %rsi # 0xd0ec2
jmp 0x8edac
leaq 0x422d1(%rip), %rsi # 0xd1035
jmp 0x8edac
leaq 0x42228(%rip), %rsi # 0xd0f95
jmp 0x8edac
leaq 0x420f3(%rip), %rsi # 0xd0e69
jmp 0x8edac
leaq 0x421e2(%rip), %rsi # 0xd0f61
jmp 0x8edac
leaq 0x4213d(%rip), %rsi # 0xd0ec5
jmp 0x8edac
leaq 0x4220a(%rip), %rsi # 0xd0f9b
jmp 0x8edac
leaq 0x472bf(%rip), %rsi # 0xd6059
jmp 0x8edac
leaq 0x42129(%rip), %rsi # 0xd0ecc
jmp 0x8edac
leaq 0x43217(%rip), %rsi # 0xd1fc3
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ac52
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5minja13TemplateToken12typeToStringB5cxx11ENS0_4TypeE:
push rbx
sub rsp, 10h
mov rbx, rdi
cmp esi, 12h; switch 19 cases
ja def_8ECE9; jumptable 000000000008ECE9 default case
mov eax, esi
lea rcx, jpt_8ECE9
movsxd rax, ds:(jpt_8ECE9 - 0CFEA8h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_8ECEB:
lea rsi, aLlavaInitConte+0Eh; jumptable 000000000008ECE9 case 0
jmp loc_8EDAC
loc_8ECF7:
lea rsi, aEndfilter; jumptable 000000000008ECE9 case 16
jmp loc_8EDAC
loc_8ED03:
lea rsi, aEndmacro; jumptable 000000000008ECE9 case 14
jmp loc_8EDAC
loc_8ED0F:
lea rsi, aEndset; jumptable 000000000008ECE9 case 11
jmp loc_8EDAC
loc_8ED1B:
lea rsi, aElif; jumptable 000000000008ECE9 case 4
jmp loc_8EDAC
loc_8ED27:
lea rsi, aComment; jumptable 000000000008ECE9 case 12
jmp short loc_8EDAC
loc_8ED30:
lea rsi, aEndgeneration; jumptable 000000000008ECE9 case 9
jmp short loc_8EDAC
loc_8ED39:
lea rsi, aIf+1; jumptable 000000000008ECE9 case 2
jmp short loc_8EDAC
loc_8ED42:
lea rsi, aInvalidFilter+8; jumptable 000000000008ECE9 case 15
jmp short loc_8EDAC
loc_8ED4B:
lea rsi, aElse; jumptable 000000000008ECE9 case 3
jmp short loc_8EDAC
loc_8ED54:
lea rsi, aEndfor; jumptable 000000000008ECE9 case 7
jmp short loc_8EDAC
loc_8ED5D:
lea rsi, aExpectedLeftSi_0+24h; jumptable 000000000008ECE9 case 1
jmp short loc_8EDAC
loc_8ED66:
lea rsi, aBreak; jumptable 000000000008ECE9 case 17
jmp short loc_8EDAC
loc_8ED6F:
lea rsi, aEndif; jumptable 000000000008ECE9 case 5
jmp short loc_8EDAC
loc_8ED78:
lea rsi, aEndmacro+3; jumptable 000000000008ECE9 case 13
jmp short loc_8EDAC
loc_8ED81:
lea rsi, aEndfor+3; jumptable 000000000008ECE9 case 6
jmp short loc_8EDAC
loc_8ED8A:
lea rsi, aContinue; jumptable 000000000008ECE9 case 18
jmp short loc_8EDAC
loc_8ED93:
lea rsi, aAtLeastOneOfMi+2Fh; jumptable 000000000008ECE9 case 10
jmp short loc_8EDAC
loc_8ED9C:
lea rsi, aEndgeneration+3; jumptable 000000000008ECE9 case 8
jmp short loc_8EDAC
def_8ECE9:
lea rsi, aUnknown; jumptable 000000000008ECE9 default case
loc_8EDAC:
lea rdx, [rsp+18h+var_9]
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _QWORD * minja::TemplateToken::typeToString[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
switch ( a2 )
{
case 0:
v2 = "text";
break;
case 1:
v2 = (char *)"expression";
break;
case 2:
v2 = "if";
break;
case 3:
v2 = "else";
break;
case 4:
v2 = "elif";
break;
case 5:
v2 = "endif";
break;
case 6:
v2 = "for";
break;
case 7:
v2 = "endfor";
break;
case 8:
v2 = "generation";
break;
case 9:
v2 = "endgeneration";
break;
case 10:
v2 = (char *)"set";
break;
case 11:
v2 = "endset";
break;
case 12:
v2 = "comment";
break;
case 13:
v2 = "macro";
break;
case 14:
v2 = "endmacro";
break;
case 15:
v2 = "filter";
break;
case 16:
v2 = "endfilter";
break;
case 17:
v2 = "break";
break;
case 18:
v2 = "continue";
break;
default:
v2 = "Unknown";
break;
}
std::string::basic_string<std::allocator<char>>(a1, (long long)v2);
return a1;
}
| typeToString[abi:cxx11]:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
CMP ESI,0x12
JA 0x0018eda5
MOV EAX,ESI
LEA RCX,[0x1cfea8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_0:
LEA RSI,[0x1c53ff]
JMP 0x0018edac
caseD_10:
LEA RSI,[0x1d0f8b]
JMP 0x0018edac
caseD_e:
LEA RSI,[0x1d0f5e]
JMP 0x0018edac
caseD_b:
LEA RSI,[0x1d0f34]
JMP 0x0018edac
caseD_4:
LEA RSI,[0x1d0e3e]
JMP 0x0018edac
caseD_c:
LEA RSI,[0x1d1fbb]
JMP 0x0018edac
caseD_9:
LEA RSI,[0x1d0ec9]
JMP 0x0018edac
caseD_2:
LEA RSI,[0x1c9d7c]
JMP 0x0018edac
caseD_f:
LEA RSI,[0x1c74d8]
JMP 0x0018edac
caseD_3:
LEA RSI,[0x1d0e64]
JMP 0x0018edac
caseD_7:
LEA RSI,[0x1d0ec2]
JMP 0x0018edac
caseD_1:
LEA RSI,[0x1d1035]
JMP 0x0018edac
caseD_11:
LEA RSI,[0x1d0f95]
JMP 0x0018edac
caseD_5:
LEA RSI,[0x1d0e69]
JMP 0x0018edac
caseD_d:
LEA RSI,[0x1d0f61]
JMP 0x0018edac
caseD_6:
LEA RSI,[0x1d0ec5]
JMP 0x0018edac
caseD_12:
LEA RSI,[0x1d0f9b]
JMP 0x0018edac
caseD_a:
LEA RSI,[0x1d6059]
JMP 0x0018edac
caseD_8:
LEA RSI,[0x1d0ecc]
JMP 0x0018edac
default:
LEA RSI,[0x1d1fc3]
LAB_0018edac:
LEA RDX,[RSP + 0xf]
MOV RDI,RBX
CALL 0x0012ac52
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* minja::TemplateToken::typeToString[abi:cxx11](minja::TemplateToken::Type) */
TemplateToken * __thiscall
minja::TemplateToken::typeToString_abi_cxx11_(TemplateToken *this,int4 param_2)
{
char *pcVar1;
allocator local_9;
switch(param_2) {
case 0:
pcVar1 = "text";
break;
case 1:
pcVar1 = "expression";
break;
case 2:
pcVar1 = "if";
break;
case 3:
pcVar1 = "else";
break;
case 4:
pcVar1 = "elif";
break;
case 5:
pcVar1 = "endif";
break;
case 6:
pcVar1 = "for";
break;
case 7:
pcVar1 = "endfor";
break;
case 8:
pcVar1 = "generation";
break;
case 9:
pcVar1 = "endgeneration";
break;
case 10:
pcVar1 = "set";
break;
case 0xb:
pcVar1 = "endset";
break;
case 0xc:
pcVar1 = "comment";
break;
case 0xd:
pcVar1 = "macro";
break;
case 0xe:
pcVar1 = "endmacro";
break;
case 0xf:
pcVar1 = "filter";
break;
case 0x10:
pcVar1 = "endfilter";
break;
case 0x11:
pcVar1 = "break";
break;
case 0x12:
pcVar1 = "continue";
break;
default:
pcVar1 = "Unknown";
}
std::__cxx11::string::string<std::allocator<char>>((string *)this,pcVar1,&local_9);
return this;
}
| |
22,903 | plutovg_skip_ws | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-utils.h | static inline bool plutovg_skip_ws(const char** begin, const char* end)
{
const char* it = *begin;
while(it < end && PLUTOVG_IS_WS(*it))
++it;
*begin = it;
return it < end;
} | O0 | c | plutovg_skip_ws:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x19(%rbp)
jae 0x5ea4f
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x1a(%rbp)
je 0x5ea49
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x9, %ecx
movb %al, -0x1a(%rbp)
je 0x5ea49
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1a(%rbp)
je 0x5ea49
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x5ea58
jmp 0x5ea66
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5e9f7
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
setb %al
andb $0x1, %al
popq %rbp
retq
| plutovg_skip_ws_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
loc_5E9F7:
mov rcx, [rbp+var_18]
xor eax, eax
cmp rcx, [rbp+var_10]
mov [rbp+var_19], al
jnb short loc_5EA4F
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 20h ; ' '
mov [rbp+var_1A], al
jz short loc_5EA49
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 9
mov [rbp+var_1A], al
jz short loc_5EA49
mov rax, [rbp+var_18]
movsx ecx, byte ptr [rax]
mov al, 1
cmp ecx, 0Ah
mov [rbp+var_1A], al
jz short loc_5EA49
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0Dh
setz al
mov [rbp+var_1A], al
loc_5EA49:
mov al, [rbp+var_1A]
mov [rbp+var_19], al
loc_5EA4F:
mov al, [rbp+var_19]
test al, 1
jnz short loc_5EA58
jmp short loc_5EA66
loc_5EA58:
mov rax, [rbp+var_18]
add rax, 1
mov [rbp+var_18], rax
jmp short loc_5E9F7
loc_5EA66:
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax], rcx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_10]
setb al
and al, 1
pop rbp
retn
| bool plutovg_skip_ws_0(_BYTE **a1, unsigned long long a2)
{
bool v3; // [rsp+0h] [rbp-1Ah]
bool v4; // [rsp+1h] [rbp-19h]
_BYTE *i; // [rsp+2h] [rbp-18h]
for ( i = *a1; ; ++i )
{
v4 = 0;
if ( (unsigned long long)i < a2 )
{
v3 = 1;
if ( *i != 32 )
{
v3 = 1;
if ( *i != 9 )
{
v3 = 1;
if ( *i != 10 )
v3 = *i == 13;
}
}
v4 = v3;
}
if ( !v4 )
break;
}
*a1 = i;
return (unsigned long long)i < a2;
}
| plutovg_skip_ws:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_0015e9f7:
MOV RCX,qword ptr [RBP + -0x18]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x10]
MOV byte ptr [RBP + -0x19],AL
JNC 0x0015ea4f
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0x20
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0015ea49
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0x9
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0015ea49
MOV RAX,qword ptr [RBP + -0x18]
MOVSX ECX,byte ptr [RAX]
MOV AL,0x1
CMP ECX,0xa
MOV byte ptr [RBP + -0x1a],AL
JZ 0x0015ea49
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0xd
SETZ AL
MOV byte ptr [RBP + -0x1a],AL
LAB_0015ea49:
MOV AL,byte ptr [RBP + -0x1a]
MOV byte ptr [RBP + -0x19],AL
LAB_0015ea4f:
MOV AL,byte ptr [RBP + -0x19]
TEST AL,0x1
JNZ 0x0015ea58
JMP 0x0015ea66
LAB_0015ea58:
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x1
MOV qword ptr [RBP + -0x18],RAX
JMP 0x0015e9f7
LAB_0015ea66:
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x10]
SETC AL
AND AL,0x1
POP RBP
RET
|
int8 plutovg_skip_ws(int8 *param_1,char *param_2)
{
bool bVar1;
char *local_20;
local_20 = (char *)*param_1;
while( true ) {
bVar1 = false;
if ((((local_20 < param_2) && (bVar1 = true, *local_20 != ' ')) &&
(bVar1 = true, *local_20 != '\t')) && (bVar1 = true, *local_20 != '\n')) {
bVar1 = *local_20 == '\r';
}
if (!bVar1) break;
local_20 = local_20 + 1;
}
*param_1 = local_20;
return CONCAT71((int7)((ulong)local_20 >> 8),local_20 < param_2);
}
| |
22,904 | lunasvg::SVGLinearGradientAttributes::setDefaultValues(lunasvg::SVGLinearGradientElement const*) | dmazzella[P]pylunasvg/lunasvg/source/svgpaintelement.h | void setDefaultValues(const SVGLinearGradientElement* element) {
SVGGradientAttributes::setDefaultValues(element);
if(!m_x1) { m_x1 = element; }
if(!m_y1) { m_y1 = element; }
if(!m_x2) { m_x2 = element; }
if(!m_y2) { m_y2 = element; }
} | O0 | c | lunasvg::SVGLinearGradientAttributes::setDefaultValues(lunasvg::SVGLinearGradientElement const*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x386b0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x37908
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x3791f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x37936
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x3794d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN7lunasvg27SVGLinearGradientAttributes16setDefaultValuesEPKNS_24SVGLinearGradientElementE:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; this
mov [rbp+var_18], rdi
mov rsi, [rbp+var_10]; lunasvg::SVGGradientElement *
call _ZN7lunasvg21SVGGradientAttributes16setDefaultValuesEPKNS_18SVGGradientElementE; lunasvg::SVGGradientAttributes::setDefaultValues(lunasvg::SVGGradientElement const*)
mov rax, [rbp+var_18]
cmp qword ptr [rax+20h], 0
jnz short loc_37908
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov [rax+20h], rcx
loc_37908:
mov rax, [rbp+var_18]
cmp qword ptr [rax+28h], 0
jnz short loc_3791F
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov [rax+28h], rcx
loc_3791F:
mov rax, [rbp+var_18]
cmp qword ptr [rax+30h], 0
jnz short loc_37936
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov [rax+30h], rcx
loc_37936:
mov rax, [rbp+var_18]
cmp qword ptr [rax+38h], 0
jnz short loc_3794D
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
mov [rax+38h], rcx
loc_3794D:
add rsp, 20h
pop rbp
retn
| lunasvg::SVGLinearGradientAttributes * lunasvg::SVGLinearGradientAttributes::setDefaultValues(
lunasvg::SVGLinearGradientAttributes *this,
const lunasvg::SVGLinearGradientElement *a2)
{
lunasvg::SVGLinearGradientAttributes *result; // rax
lunasvg::SVGGradientAttributes::setDefaultValues(this, a2);
if ( !*((_QWORD *)this + 4) )
*((_QWORD *)this + 4) = a2;
if ( !*((_QWORD *)this + 5) )
*((_QWORD *)this + 5) = a2;
if ( !*((_QWORD *)this + 6) )
*((_QWORD *)this + 6) = a2;
result = this;
if ( !*((_QWORD *)this + 7) )
{
result = this;
*((_QWORD *)this + 7) = a2;
}
return result;
}
| setDefaultValues:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x18],RDI
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x001386b0
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x00137908
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x20],RCX
LAB_00137908:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x28],0x0
JNZ 0x0013791f
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x28],RCX
LAB_0013791f:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x30],0x0
JNZ 0x00137936
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
LAB_00137936:
MOV RAX,qword ptr [RBP + -0x18]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x0013794d
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x38],RCX
LAB_0013794d:
ADD RSP,0x20
POP RBP
RET
|
/* lunasvg::SVGLinearGradientAttributes::setDefaultValues(lunasvg::SVGLinearGradientElement const*)
*/
void __thiscall
lunasvg::SVGLinearGradientAttributes::setDefaultValues
(SVGLinearGradientAttributes *this,SVGLinearGradientElement *param_1)
{
SVGGradientAttributes::setDefaultValues
((SVGGradientAttributes *)this,(SVGGradientElement *)param_1);
if (*(long *)(this + 0x20) == 0) {
*(SVGLinearGradientElement **)(this + 0x20) = param_1;
}
if (*(long *)(this + 0x28) == 0) {
*(SVGLinearGradientElement **)(this + 0x28) = param_1;
}
if (*(long *)(this + 0x30) == 0) {
*(SVGLinearGradientElement **)(this + 0x30) = param_1;
}
if (*(long *)(this + 0x38) == 0) {
*(SVGLinearGradientElement **)(this + 0x38) = param_1;
}
return;
}
| |
22,905 | func_gb2312_uni_onechar | eloqsql/strings/ctype-gb2312.c | static int func_gb2312_uni_onechar(int code){
if ((code>=0x2121)&&(code<=0x2658))
return(tab_gb2312_uni0[code-0x2121]);
if ((code>=0x2721)&&(code<=0x296F))
return(tab_gb2312_uni1[code-0x2721]);
if ((code>=0x3021)&&(code<=0x777E))
return(tab_gb2312_uni2[code-0x3021]);
return(0);
} | O0 | c | func_gb2312_uni_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x2121, -0x8(%rbp) # imm = 0x2121
jl 0x512d4
cmpl $0x2658, -0x8(%rbp) # imm = 0x2658
jg 0x512d4
movl -0x8(%rbp), %eax
subl $0x2121, %eax # imm = 0x2121
movslq %eax, %rcx
leaq 0xc9515(%rip), %rax # 0x11a7e0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x51335
cmpl $0x2721, -0x8(%rbp) # imm = 0x2721
jl 0x51301
cmpl $0x296f, -0x8(%rbp) # imm = 0x296F
jg 0x51301
movl -0x8(%rbp), %eax
subl $0x2721, %eax # imm = 0x2721
movslq %eax, %rcx
leaq 0xc9f58(%rip), %rax # 0x11b250
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x51335
cmpl $0x3021, -0x8(%rbp) # imm = 0x3021
jl 0x5132e
cmpl $0x777e, -0x8(%rbp) # imm = 0x777E
jg 0x5132e
movl -0x8(%rbp), %eax
subl $0x3021, %eax # imm = 0x3021
movslq %eax, %rcx
leaq 0xca3cb(%rip), %rax # 0x11b6f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x51335
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_gb2312_uni_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 2121h
jl short loc_512D4
cmp [rbp+var_8], 2658h
jg short loc_512D4
mov eax, [rbp+var_8]
sub eax, 2121h
movsxd rcx, eax
lea rax, tab_gb2312_uni0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_51335
loc_512D4:
cmp [rbp+var_8], 2721h
jl short loc_51301
cmp [rbp+var_8], 296Fh
jg short loc_51301
mov eax, [rbp+var_8]
sub eax, 2721h
movsxd rcx, eax
lea rax, tab_gb2312_uni1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_51335
loc_51301:
cmp [rbp+var_8], 3021h
jl short loc_5132E
cmp [rbp+var_8], 777Eh
jg short loc_5132E
mov eax, [rbp+var_8]
sub eax, 3021h
movsxd rcx, eax
lea rax, tab_gb2312_uni2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_51335
loc_5132E:
mov [rbp+var_4], 0
loc_51335:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_gb2312_uni_onechar(int a1)
{
if ( a1 < 8481 || a1 > 9816 )
{
if ( a1 < 10017 || a1 > 10607 )
{
if ( a1 < 12321 || a1 > 30590 )
return 0;
else
return tab_gb2312_uni2[a1 - 12321];
}
else
{
return tab_gb2312_uni1[a1 - 10017];
}
}
else
{
return tab_gb2312_uni0[a1 - 8481];
}
}
| func_gb2312_uni_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0x2121
JL 0x001512d4
CMP dword ptr [RBP + -0x8],0x2658
JG 0x001512d4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2121
MOVSXD RCX,EAX
LEA RAX,[0x21a7e0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00151335
LAB_001512d4:
CMP dword ptr [RBP + -0x8],0x2721
JL 0x00151301
CMP dword ptr [RBP + -0x8],0x296f
JG 0x00151301
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2721
MOVSXD RCX,EAX
LEA RAX,[0x21b250]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00151335
LAB_00151301:
CMP dword ptr [RBP + -0x8],0x3021
JL 0x0015132e
CMP dword ptr [RBP + -0x8],0x777e
JG 0x0015132e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3021
MOVSXD RCX,EAX
LEA RAX,[0x21b6f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00151335
LAB_0015132e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00151335:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_gb2312_uni_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0x2121) || (0x2658 < param_1)) {
if ((param_1 < 0x2721) || (0x296f < param_1)) {
if ((param_1 < 0x3021) || (0x777e < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni2 + (long)(param_1 + -0x3021) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni1 + (long)(param_1 + -0x2721) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_gb2312_uni0 + (long)(param_1 + -0x2121) * 2);
}
return uVar1;
}
| |
22,906 | dedup_selftest | xtate/src/dedup/dedup.c | int dedup_selftest() {
DedupTable *dedup;
unsigned seed = 0;
size_t i;
unsigned found_match = 0;
unsigned line = 0;
dedup = dedup_create(1000000);
/* Deterministic test.
*
* The first time we check on a socket combo, there should
* be no duplicate. The second time we check, however, there should
* be a duplicate.
*/
{
ipaddress ip_me;
ipaddress ip_them;
unsigned port_me;
unsigned port_them;
unsigned type;
ip_me.version = 4;
ip_them.version = 4;
ip_me.ipv4 = 0x12345678;
ip_them.ipv4 = 0xabcdef0;
port_me = 0x1234;
port_them = 0xfedc;
type = 0x8967;
if (dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
line = __LINE__;
goto fail;
}
if (!dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
line = __LINE__;
goto fail;
}
ip_me.version = 6;
ip_them.version = 6;
ip_me.ipv6.hi = 0x12345678;
ip_me.ipv6.lo = 0x12345678;
ip_them.ipv6.hi = 0xabcdef0;
ip_them.ipv6.lo = 0xabcdef0;
type = 0x7654;
if (dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
line = __LINE__;
goto fail;
}
if (!dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
ipaddress_formatted_t fmt1 = ipaddress_fmt(ip_them);
ipaddress_formatted_t fmt2 = ipaddress_fmt(ip_me);
LOG(LEVEL_ERROR, "(%s):%u -> (%s):%u\n", fmt1.string, port_them,
fmt2.string, port_me);
line = __LINE__;
goto fail;
}
}
/* Test IPv4 addresses */
for (i = 0; i < 100000; i++) {
ipaddress ip_them;
unsigned port_them;
ipaddress ip_me;
unsigned port_me;
unsigned type;
ip_them.version = 4;
ip_me.version = 4;
/* Instead of completely random numbers over the entire
* range, each port/IP is restricted to just 512
* random combinations. This should statistically
* give us around 10 matches*/
ip_them.ipv4 = _rand(&seed) & 0x1FF;
port_them = _rand(&seed) & 0x1FF;
ip_me.ipv4 = _rand(&seed) & 0xFF800000;
port_me = _rand(&seed) & 0xFF80;
type = _rand(&seed) & 0B111;
if (dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
found_match++;
}
}
if (found_match == 0 || found_match > 200) {
line = __LINE__;
goto fail;
}
/* Now do IPv6 */
found_match = 0;
seed = 0;
/* Test IPv4 addresses */
for (i = 0; i < 100000; i++) {
ipaddress ip_them;
unsigned port_them;
ipaddress ip_me;
unsigned port_me;
unsigned type;
ip_them.version = 6;
ip_me.version = 6;
/* Instead of completely random numbers over the entire
* range, each port/IP is restricted to just 512
* random combinations. This should statistically
* give us around 10 matches*/
ip_me.ipv6.hi = _rand(&seed) & 0xFF800000;
ip_them.ipv6.lo = _rand(&seed) & 0x1FF;
port_me = _rand(&seed) & 0xFF80;
port_them = _rand(&seed) & 0x1FF;
type = _rand(&seed) & 0B111;
if (dedup_is_dup(dedup, ip_them, port_them, ip_me, port_me, type)) {
found_match++;
}
}
/* The result should be same as for IPv4, around 30 matches found. */
if (found_match == 0 || found_match > 200) {
line = __LINE__;
goto fail;
}
dedup_destroy(dedup);
/* All tests have passed */
return 0; /* success :) */
fail:
LOG(LEVEL_ERROR, "(%s) selftest failed, file=%s, line=%u\n", __func__,
__FILE__, line);
return 1;
} | O3 | c | dedup_selftest:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl $0x1, %edi
movl $0x4800008, %esi # imm = 0x4800008
callq 0x5080b
movq %rax, %rbx
movl $0x3ffff, (%rax) # imm = 0x3FFFF
movb $0x4, %al
movb %al, 0x60(%rsp)
movb %al, 0x48(%rsp)
movl $0x12345678, 0x50(%rsp) # imm = 0x12345678
movl $0xabcdef0, 0x38(%rsp) # imm = 0xABCDEF0
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xfedc, %esi # imm = 0xFEDC
movl $0x1234, %edx # imm = 0x1234
movl $0x8967, %ecx # imm = 0x8967
callq 0x1ea55
movl $0x1b1, %r8d # imm = 0x1B1
testl %eax, %eax
je 0x1ee76
leaq 0x419d7(%rip), %rsi # 0x6081c
leaq 0x419f8(%rip), %rdx # 0x60844
leaq 0x41a00(%rip), %rcx # 0x60853
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0x536da
movl $0x1, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xfedc, %esi # imm = 0xFEDC
movl $0x1234, %edx # imm = 0x1234
movl $0x8967, %ecx # imm = 0x8967
callq 0x1ea55
testl %eax, %eax
je 0x1f143
movb $0x6, %al
movb %al, 0x60(%rsp)
movb %al, 0x48(%rsp)
movl $0x12345678, %eax # imm = 0x12345678
movq %rax, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movl $0xabcdef0, %eax # imm = 0xABCDEF0
movq %rax, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xfedc, %esi # imm = 0xFEDC
movl $0x1234, %edx # imm = 0x1234
movl $0x7654, %ecx # imm = 0x7654
callq 0x1ea55
movl $0x1c2, %r8d # imm = 0x1C2
testl %eax, %eax
jne 0x1ee3e
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xfedc, %esi # imm = 0xFEDC
movl $0x1234, %edx # imm = 0x1234
movl $0x7654, %ecx # imm = 0x7654
callq 0x1ea55
testl %eax, %eax
je 0x1f14e
xorl %ebp, %ebp
movl $0x186a0, %r14d # imm = 0x186A0
movb $0x4, %r15b
movl $0x1ff, %r12d # imm = 0x1FF
xorl %r13d, %r13d
movb %r15b, 0xa8(%rsp)
movb %r15b, 0x78(%rsp)
imull $0x343fd, %r13d, %eax # imm = 0x343FD
addl $0x269ec3, %eax # imm = 0x269EC3
shrl $0x10, %eax
andl %r12d, %eax
movl %eax, 0x98(%rsp)
imull $0xa9fc6809, %r13d, %esi # imm = 0xA9FC6809
addl $0x1e278e7a, %esi # imm = 0x1E278E7A
shrl $0x10, %esi
andl %r12d, %esi
movl $0x0, 0x68(%rsp)
imull $0xddff5051, %r13d, %edx # imm = 0xDDFF5051
addl $0x98520c4, %edx # imm = 0x98520C4
shrl $0x10, %edx
andl $0x7f80, %edx # imm = 0x7F80
imull $0x284a930d, %r13d, %r13d # imm = 0x284A930D
addl $0xa2974c77, %r13d # imm = 0xA2974C77
movl %r13d, %ecx
shrl $0x10, %ecx
andl $0x7, %ecx
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x98(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1ea55
cmpl $0x1, %eax
sbbl $-0x1, %ebp
decq %r14
jne 0x1ef8a
addl $0xffffff37, %ebp # imm = 0xFFFFFF37
movl $0x1ea, %r8d # imm = 0x1EA
cmpl $0xffffff38, %ebp # imm = 0xFFFFFF38
jb 0x1ee3e
xorl %ebp, %ebp
movl $0x186a0, %r14d # imm = 0x186A0
movb $0x6, %r15b
movl $0x1ff, %r12d # imm = 0x1FF
xorl %r13d, %r13d
movb %r15b, 0xa8(%rsp)
movb %r15b, 0x78(%rsp)
movq $0x0, 0x68(%rsp)
imull $0xa9fc6809, %r13d, %eax # imm = 0xA9FC6809
addl $0x1e278e7a, %eax # imm = 0x1E278E7A
shrl $0x10, %eax
andl %r12d, %eax
movq %rax, 0xa0(%rsp)
imull $0x45c82be5, %r13d, %edx # imm = 0x45C82BE5
addl $0xd2f65b55, %edx # imm = 0xD2F65B55
shrl $0x10, %edx
andl $0x7f80, %edx # imm = 0x7F80
imull $0xddff5051, %r13d, %esi # imm = 0xDDFF5051
addl $0x98520c4, %esi # imm = 0x98520C4
shrl $0x10, %esi
andl %r12d, %esi
imull $0x284a930d, %r13d, %r13d # imm = 0x284A930D
addl $0xa2974c77, %r13d # imm = 0xA2974C77
movl %r13d, %ecx
shrl $0x10, %ecx
andl $0x7, %ecx
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x98(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1ea55
cmpl $0x1, %eax
sbbl $-0x1, %ebp
decq %r14
jne 0x1f068
addl $0xffffff37, %ebp # imm = 0xFFFFFF37
movl $0x20e, %r8d # imm = 0x20E
cmpl $0xffffff38, %ebp # imm = 0xFFFFFF38
jb 0x1ee3e
movq %rbx, %rdi
callq 0x151e0
xorl %eax, %eax
jmp 0x1ee64
movl $0x1b5, %r8d # imm = 0x1B5
jmp 0x1ee3e
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x44638
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x44638
leaq 0x41670(%rip), %rsi # 0x60808
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movq %rbx, %rdx
movl $0xfedc, %ecx # imm = 0xFEDC
movq %r14, %r8
movl $0x1234, %r9d # imm = 0x1234
xorl %eax, %eax
callq 0x536da
movl $0x1ca, %r8d # imm = 0x1CA
jmp 0x1ee3e
| dedup_selftest:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov edi, 1
mov esi, 4800008h
call CALLOC
mov rbx, rax
mov dword ptr [rax], 3FFFFh
mov al, 4
mov byte ptr [rsp+0F8h+var_98], al
mov byte ptr [rsp+0F8h+var_B0], al
mov dword ptr [rsp+0F8h+var_A8], 12345678h
mov dword ptr [rsp+0F8h+var_C0], 0ABCDEF0h
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_A8]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_C0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
mov esi, 0FEDCh
mov edx, 1234h
mov ecx, 8967h
call dedup_is_dup
mov r8d, 1B1h
test eax, eax
jz short loc_1EE76
loc_1EE3E:
lea rsi, aSSelftestFaile; "(%s) selftest failed, file=%s, line=%u"...
lea rdx, aDedupSelftest; "dedup_selftest"
lea rcx, aWorkspaceLlm4b; "/workspace/llm4binary/github2025/xtate/"...
mov edi, 0FFFFFFFFh
xor eax, eax
call LOG
mov eax, 1
loc_1EE64:
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_1EE76:
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_A8]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_C0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
mov esi, 0FEDCh
mov edx, 1234h
mov ecx, 8967h
call dedup_is_dup
test eax, eax
jz loc_1F143
mov al, 6
mov byte ptr [rsp+0F8h+var_98], al
mov byte ptr [rsp+0F8h+var_B0], al
mov eax, 12345678h
mov qword ptr [rsp+0F8h+var_A8], rax
mov qword ptr [rsp+0F8h+var_A8+8], rax
mov eax, 0ABCDEF0h
mov qword ptr [rsp+0F8h+var_C0], rax
mov qword ptr [rsp+0F8h+var_C0+8], rax
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_A8]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_C0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
mov esi, 0FEDCh
mov edx, 1234h
mov ecx, 7654h
call dedup_is_dup
mov r8d, 1C2h
test eax, eax
jnz loc_1EE3E
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_A8]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_C0]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
mov esi, 0FEDCh
mov edx, 1234h
mov ecx, 7654h
call dedup_is_dup
test eax, eax
jz loc_1F14E
xor ebp, ebp
mov r14d, 186A0h
mov r15b, 4
mov r12d, 1FFh
xor r13d, r13d
loc_1EF8A:
mov byte ptr [rsp+0F8h+var_50], r15b
mov byte ptr [rsp+0F8h+var_80], r15b
imul eax, r13d, 343FDh
add eax, 269EC3h
shr eax, 10h
and eax, r12d
mov dword ptr [rsp+0F8h+var_60], eax
imul esi, r13d, 0A9FC6809h
add esi, 1E278E7Ah
shr esi, 10h
and esi, r12d
mov dword ptr [rsp+0F8h+var_90], 0
imul edx, r13d, 0DDFF5051h
add edx, 98520C4h
shr edx, 10h
and edx, 7F80h
imul r13d, 284A930Dh
add r13d, 0A2974C77h
mov ecx, r13d
shr ecx, 10h
and ecx, 7
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_90]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_60]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
call dedup_is_dup
cmp eax, 1
sbb ebp, 0FFFFFFFFh
dec r14
jnz loc_1EF8A
add ebp, 0FFFFFF37h
mov r8d, 1EAh
cmp ebp, 0FFFFFF38h
jb loc_1EE3E
xor ebp, ebp
mov r14d, 186A0h
mov r15b, 6
mov r12d, 1FFh
xor r13d, r13d
loc_1F068:
mov byte ptr [rsp+0F8h+var_50], r15b
mov byte ptr [rsp+0F8h+var_80], r15b
mov qword ptr [rsp+0F8h+var_90], 0
imul eax, r13d, 0A9FC6809h
add eax, 1E278E7Ah
shr eax, 10h
and eax, r12d
mov qword ptr [rsp+0F8h+var_60+8], rax
imul edx, r13d, 45C82BE5h
add edx, 0D2F65B55h
shr edx, 10h
and edx, 7F80h
imul esi, r13d, 0DDFF5051h
add esi, 98520C4h
shr esi, 10h
and esi, r12d
imul r13d, 284A930Dh
add r13d, 0A2974C77h
mov ecx, r13d
shr ecx, 10h
and ecx, 7
mov rax, [rsp+0F8h+var_80]
mov [rsp+0F8h+var_D0], rax
movups xmm0, [rsp+0F8h+var_90]
movups [rsp+0F8h+var_E0], xmm0
mov rax, [rsp+0F8h+var_50]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_60]
movups [rsp+0F8h+var_F8], xmm0
mov rdi, rbx
call dedup_is_dup
cmp eax, 1
sbb ebp, 0FFFFFFFFh
dec r14
jnz loc_1F068
add ebp, 0FFFFFF37h
mov r8d, 20Eh
cmp ebp, 0FFFFFF38h
jb loc_1EE3E
mov rdi, rbx
call _free
xor eax, eax
jmp loc_1EE64
loc_1F143:
mov r8d, 1B5h
jmp loc_1EE3E
loc_1F14E:
mov rax, [rsp+0F8h+var_B0]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_C0]
movups [rsp+0F8h+var_F8], xmm0
lea rbx, [rsp+0F8h+var_60]
mov rdi, rbx
call ipaddress_fmt
mov rax, [rsp+0F8h+var_98]
mov [rsp+0F8h+var_E8], rax
movups xmm0, [rsp+0F8h+var_A8]
movups [rsp+0F8h+var_F8], xmm0
lea r14, [rsp+0F8h+var_90]
mov rdi, r14
call ipaddress_fmt
lea rsi, aSUSU; "(%s):%u -> (%s):%u\n"
mov edi, 0FFFFFFFFh
mov rdx, rbx
mov ecx, 0FEDCh
mov r8, r14
mov r9d, 1234h
xor eax, eax
call LOG
mov r8d, 1CAh
jmp loc_1EE3E
| long long dedup_selftest(double a1, __m128i a2)
{
_DWORD *v2; // rbx
long long v3; // r8
long long v4; // r9
int is_dup; // eax
long long v6; // r9
long long v7; // r8
long long v9; // r8
int v10; // eax
int v11; // edx
int v12; // ecx
long long v13; // r8
int v14; // ebp
long long v15; // r14
unsigned int v16; // r13d
unsigned int v17; // esi
unsigned int v18; // edx
int v19; // ebp
long long v20; // r14
unsigned int v21; // r13d
unsigned int v22; // edx
unsigned int v23; // esi
int v24; // edx
int v25; // ecx
int v26; // r8d
int v27; // r9d
__m128i v28; // [rsp+38h] [rbp-C0h]
__m128i v29; // [rsp+38h] [rbp-C0h]
__int128 v30; // [rsp+68h] [rbp-90h] BYREF
long long v31; // [rsp+78h] [rbp-80h]
__m128i v32; // [rsp+98h] [rbp-60h] BYREF
long long v33; // [rsp+A8h] [rbp-50h]
v2 = (_DWORD *)CALLOC(1LL, 75497480LL);
*v2 = 0x3FFFF;
v28.m128i_i32[0] = 180150000;
is_dup = dedup_is_dup(v2, 65244, 4660, 35175, v3, v4, v28, v28.m128i_i8[0], a2);
LODWORD(v7) = 433;
if ( is_dup )
goto LABEL_2;
if ( !(unsigned int)dedup_is_dup(v2, 65244, 4660, 35175, 433LL, v6, v28, v28.m128i_i8[0], a2) )
{
LODWORD(v7) = 437;
goto LABEL_2;
}
v29.m128i_i64[0] = 180150000LL;
v29.m128i_i64[1] = 180150000LL;
v10 = dedup_is_dup(v2, 65244, 4660, 30292, v9, v6, v29, 240, a2);
LODWORD(v7) = 450;
if ( v10 )
{
LABEL_2:
LOG(
-1,
(unsigned int)"(%s) selftest failed, file=%s, line=%u\n",
(unsigned int)"dedup_selftest",
(unsigned int)"/workspace/llm4binary/github2025/xtate/src/dedup/dedup.c",
v7,
v6);
return 1LL;
}
if ( !(unsigned int)dedup_is_dup(v2, 65244, 4660, 30292, 450LL, v6, v29, v29.m128i_i8[0], a2) )
{
ipaddress_fmt((unsigned int)&v32, 65244, v11, v12, v13, v6, 180150000, 180150000, 6);
ipaddress_fmt((unsigned int)&v30, 65244, v24, v25, v26, v27, 305419896, 305419896, 6);
LOG(-1, (unsigned int)"(%s):%u -> (%s):%u\n", (unsigned int)&v32, 65244, (unsigned int)&v30, 4660);
LODWORD(v7) = 458;
goto LABEL_2;
}
v14 = 0;
v15 = 100000LL;
v16 = 0;
do
{
LOBYTE(v33) = 4;
LOBYTE(v31) = 4;
v32.m128i_i32[0] = ((214013 * v16 + 2531011) >> 16) & 0x1FF;
v17 = ((-1443076087 * v16 + 505908858) >> 16) & 0x1FF;
LODWORD(v30) = 0;
v18 = ((-570470319 * v16 + 159719620) >> 16) & 0x7F80;
v16 = 675975949 * v16 - 1567142793;
v14 -= ((unsigned int)dedup_is_dup(v2, v17, v18, HIWORD(v16) & 7, v13, v6, v32, v32.m128i_i8[0], a2) == 0) - 1;
--v15;
}
while ( v15 );
v7 = 490LL;
if ( (unsigned int)(v14 - 201) < 0xFFFFFF38 )
goto LABEL_2;
v19 = 0;
v20 = 100000LL;
v21 = 0;
do
{
LOBYTE(v33) = 6;
LOBYTE(v31) = 6;
*(_QWORD *)&v30 = 0LL;
v32.m128i_i64[1] = ((-1443076087 * v21 + 505908858) >> 16) & 0x1FF;
v22 = ((1170746341 * v21 - 755606699) >> 16) & 0x7F80;
v23 = ((-570470319 * v21 + 159719620) >> 16) & 0x1FF;
v21 = 675975949 * v21 - 1567142793;
v19 -= ((unsigned int)dedup_is_dup(v2, v23, v22, HIWORD(v21) & 7, v7, v6, v32, v32.m128i_i8[0], a2) == 0) - 1;
--v20;
}
while ( v20 );
LODWORD(v7) = 526;
if ( (unsigned int)(v19 - 201) < 0xFFFFFF38 )
goto LABEL_2;
free(v2);
return 0LL;
}
| dedup_selftest:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV EDI,0x1
MOV ESI,0x4800008
CALL 0x0015080b
MOV RBX,RAX
MOV dword ptr [RAX],0x3ffff
MOV AL,0x4
MOV byte ptr [RSP + 0x60],AL
MOV byte ptr [RSP + 0x48],AL
MOV dword ptr [RSP + 0x50],0x12345678
MOV dword ptr [RSP + 0x38],0xabcdef0
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV ESI,0xfedc
MOV EDX,0x1234
MOV ECX,0x8967
CALL 0x0011ea55
MOV R8D,0x1b1
TEST EAX,EAX
JZ 0x0011ee76
LAB_0011ee3e:
LEA RSI,[0x16081c]
LEA RDX,[0x160844]
LEA RCX,[0x160853]
MOV EDI,0xffffffff
XOR EAX,EAX
CALL 0x001536da
MOV EAX,0x1
LAB_0011ee64:
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0011ee76:
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV ESI,0xfedc
MOV EDX,0x1234
MOV ECX,0x8967
CALL 0x0011ea55
TEST EAX,EAX
JZ 0x0011f143
MOV AL,0x6
MOV byte ptr [RSP + 0x60],AL
MOV byte ptr [RSP + 0x48],AL
MOV EAX,0x12345678
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RAX
MOV EAX,0xabcdef0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV ESI,0xfedc
MOV EDX,0x1234
MOV ECX,0x7654
CALL 0x0011ea55
MOV R8D,0x1c2
TEST EAX,EAX
JNZ 0x0011ee3e
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
MOV ESI,0xfedc
MOV EDX,0x1234
MOV ECX,0x7654
CALL 0x0011ea55
TEST EAX,EAX
JZ 0x0011f14e
XOR EBP,EBP
MOV R14D,0x186a0
MOV R15B,0x4
MOV R12D,0x1ff
XOR R13D,R13D
LAB_0011ef8a:
MOV byte ptr [RSP + 0xa8],R15B
MOV byte ptr [RSP + 0x78],R15B
IMUL EAX,R13D,0x343fd
ADD EAX,0x269ec3
SHR EAX,0x10
AND EAX,R12D
MOV dword ptr [RSP + 0x98],EAX
IMUL ESI,R13D,-0x560397f7
ADD ESI,0x1e278e7a
SHR ESI,0x10
AND ESI,R12D
MOV dword ptr [RSP + 0x68],0x0
IMUL EDX,R13D,-0x2200afaf
ADD EDX,0x98520c4
SHR EDX,0x10
AND EDX,0x7f80
IMUL R13D,R13D,0x284a930d
ADD R13D,0xa2974c77
MOV ECX,R13D
SHR ECX,0x10
AND ECX,0x7
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x68]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x98]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
CALL 0x0011ea55
CMP EAX,0x1
SBB EBP,-0x1
DEC R14
JNZ 0x0011ef8a
ADD EBP,0xffffff37
MOV R8D,0x1ea
CMP EBP,0xffffff38
JC 0x0011ee3e
XOR EBP,EBP
MOV R14D,0x186a0
MOV R15B,0x6
MOV R12D,0x1ff
XOR R13D,R13D
LAB_0011f068:
MOV byte ptr [RSP + 0xa8],R15B
MOV byte ptr [RSP + 0x78],R15B
MOV qword ptr [RSP + 0x68],0x0
IMUL EAX,R13D,-0x560397f7
ADD EAX,0x1e278e7a
SHR EAX,0x10
AND EAX,R12D
MOV qword ptr [RSP + 0xa0],RAX
IMUL EDX,R13D,0x45c82be5
ADD EDX,0xd2f65b55
SHR EDX,0x10
AND EDX,0x7f80
IMUL ESI,R13D,-0x2200afaf
ADD ESI,0x98520c4
SHR ESI,0x10
AND ESI,R12D
IMUL R13D,R13D,0x284a930d
ADD R13D,0xa2974c77
MOV ECX,R13D
SHR ECX,0x10
AND ECX,0x7
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x68]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x98]
MOVUPS xmmword ptr [RSP],XMM0
MOV RDI,RBX
CALL 0x0011ea55
CMP EAX,0x1
SBB EBP,-0x1
DEC R14
JNZ 0x0011f068
ADD EBP,0xffffff37
MOV R8D,0x20e
CMP EBP,0xffffff38
JC 0x0011ee3e
MOV RDI,RBX
CALL 0x001151e0
XOR EAX,EAX
JMP 0x0011ee64
LAB_0011f143:
MOV R8D,0x1b5
JMP 0x0011ee3e
LAB_0011f14e:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x38]
MOVUPS xmmword ptr [RSP],XMM0
LEA RBX,[RSP + 0x98]
MOV RDI,RBX
CALL 0x00144638
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x10],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x50]
MOVUPS xmmword ptr [RSP],XMM0
LEA R14,[RSP + 0x68]
MOV RDI,R14
CALL 0x00144638
LEA RSI,[0x160808]
MOV EDI,0xffffffff
MOV RDX,RBX
MOV ECX,0xfedc
MOV R8,R14
MOV R9D,0x1234
XOR EAX,EAX
CALL 0x001536da
MOV R8D,0x1ca
JMP 0x0011ee3e
|
int8 dedup_selftest(void)
{
int iVar1;
int4 *__ptr;
int iVar2;
int iVar3;
int8 uVar4;
uint uVar5;
long lVar6;
int8 uVar7;
int8 uVar8;
int8 uVar9;
int4 local_a8;
int4 uStack_a0;
int7 uStack_97;
ulong local_90 [2];
int1 local_80;
uint local_60 [2];
ulong uStack_58;
int1 local_50;
__ptr = (int4 *)CALLOC(1,0x4800008);
*__ptr = 0x3ffff;
iVar1 = dedup_is_dup(__ptr,0xfedc,0x1234,0x8967);
uVar4 = 0x1b1;
if (iVar1 == 0) {
iVar1 = dedup_is_dup(__ptr,0xfedc,0x1234,0x8967,0x1b1);
if (iVar1 == 0) {
uVar4 = 0x1b5;
}
else {
iVar1 = dedup_is_dup(__ptr,0xfedc,0x1234,0x7654);
uVar4 = 0x1c2;
if (iVar1 == 0) {
uVar4 = CONCAT71(uStack_97,6);
uVar8 = 0x12345678;
uVar9 = 0x12345678;
iVar1 = dedup_is_dup(__ptr,0xfedc,0x1234,0x7654,0x1c2);
if (iVar1 == 0) {
ipaddress_fmt(local_60);
uVar7 = CONCAT71(uStack_97,6);
local_a8 = 0x12345678;
uStack_a0 = 0x12345678;
ipaddress_fmt(local_90);
LOG(0xffffffff,"(%s):%u -> (%s):%u\n",local_60,0xfedc,local_90,0x1234,local_a8,uStack_a0,
uVar7,uVar8,uVar9,uVar4);
uVar4 = 0x1ca;
}
else {
iVar1 = 0;
lVar6 = 100000;
uVar5 = 0;
do {
local_50 = 4;
local_80 = 4;
local_60[0] = uVar5 * 0x343fd + 0x269ec3 >> 0x10 & 0x1ff;
iVar3 = uVar5 * -0x560397f7;
local_90[0] = local_90[0] & 0xffffffff00000000;
iVar2 = uVar5 * -0x2200afaf;
uVar5 = uVar5 * 0x284a930d + 0xa2974c77;
iVar2 = dedup_is_dup(__ptr,iVar3 + 0x1e278e7aU >> 0x10 & 0x1ff,
iVar2 + 0x98520c4U >> 0x10 & 0x7f80,uVar5 >> 0x10 & 7);
iVar1 = (iVar1 + 1) - (uint)(iVar2 == 0);
lVar6 = lVar6 + -1;
} while (lVar6 != 0);
uVar4 = 0x1ea;
if (0xffffff37 < iVar1 - 0xc9U) {
iVar1 = 0;
lVar6 = 100000;
uVar5 = 0;
do {
local_50 = 6;
local_80 = 6;
local_90[0] = 0;
uStack_58 = (ulong)(uVar5 * -0x560397f7 + 0x1e278e7a >> 0x10 & 0x1ff);
iVar2 = uVar5 * 0x45c82be5;
iVar3 = uVar5 * -0x2200afaf;
uVar5 = uVar5 * 0x284a930d + 0xa2974c77;
iVar2 = dedup_is_dup(__ptr,iVar3 + 0x98520c4U >> 0x10 & 0x1ff,
iVar2 + 0xd2f65b55U >> 0x10 & 0x7f80,uVar5 >> 0x10 & 7);
iVar1 = (iVar1 + 1) - (uint)(iVar2 == 0);
lVar6 = lVar6 + -1;
} while (lVar6 != 0);
uVar4 = 0x20e;
if (0xffffff37 < iVar1 - 0xc9U) {
free(__ptr);
return 0;
}
}
}
}
}
}
LOG(0xffffffff,"(%s) selftest failed, file=%s, line=%u\n","dedup_selftest",
"/workspace/llm4binary/github2025/xtate/src/dedup/dedup.c",uVar4);
return 1;
}
| |
22,907 | copy_uca_collation | eloqsql/mysys/charset.c | static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
} | O0 | c | copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xb8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq -0x10(%rbp), %rax
movq 0xc0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc0(%rax)
movq -0x18(%rbp), %rax
movzbl 0xb2(%rax), %eax
cmpl $0x1, %eax
jle 0xd4c16
movl $0x4, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd4c23
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x10(%rbp), %rax
movl 0x98(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl 0x9c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x9c(%rax)
movq -0x10(%rbp), %rax
movb 0x94(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x94(%rax)
movq -0x10(%rbp), %rax
movb 0x95(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x95(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2c8, %ecx # imm = 0x2C8
movl %ecx, 0xc(%rax)
popq %rbp
retq
nop
| copy_uca_collation:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_10]
mov rcx, [rax+0B8h]
mov rax, [rbp+var_8]
mov [rax+0B8h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0C0h]
mov rax, [rbp+var_8]
mov [rax+0C0h], rcx
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+0B2h]
cmp eax, 1
jle short loc_D4C16
mov eax, 4
mov [rbp+var_1C], eax
jmp short loc_D4C23
loc_D4C16:
mov rax, [rbp+var_10]
mov eax, [rax+90h]
mov [rbp+var_1C], eax
loc_D4C23:
mov ecx, [rbp+var_1C]
mov rax, [rbp+var_8]
mov [rax+90h], ecx
mov rax, [rbp+var_10]
mov rcx, [rax+0A0h]
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
mov rax, [rbp+var_10]
mov rcx, [rax+0A8h]
mov rax, [rbp+var_8]
mov [rax+0A8h], rcx
mov rax, [rbp+var_10]
mov ecx, [rax+98h]
mov rax, [rbp+var_8]
mov [rax+98h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+9Ch]
mov rax, [rbp+var_8]
mov [rax+9Ch], ecx
mov rax, [rbp+var_10]
mov cl, [rax+94h]
mov rax, [rbp+var_8]
mov [rax+94h], cl
mov rax, [rbp+var_10]
mov cl, [rax+95h]
mov rax, [rbp+var_8]
mov [rax+95h], cl
mov rax, [rbp+var_8]
mov ecx, [rax+0Ch]
or ecx, 2C8h
mov [rax+0Ch], ecx
pop rbp
retn
| long long copy_uca_collation(long long a1, long long a2, long long a3)
{
long long result; // rax
int v4; // [rsp+0h] [rbp-1Ch]
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
if ( *(unsigned __int8 *)(a3 + 178) <= 1u )
v4 = *(_DWORD *)(a2 + 144);
else
v4 = 4;
*(_DWORD *)(a1 + 144) = v4;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
*(_BYTE *)(a1 + 149) = *(_BYTE *)(a2 + 149);
result = a1;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
| copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xb8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xc0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xc0],RCX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0xb2]
CMP EAX,0x1
JLE 0x001d4c16
MOV EAX,0x4
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001d4c23
LAB_001d4c16:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x90]
MOV dword ptr [RBP + -0x1c],EAX
LAB_001d4c23:
MOV ECX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x90],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xa8]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x98],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x9c]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x9c],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x94]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x94],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x95]
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x95],CL
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0xc]
OR ECX,0x2c8
MOV dword ptr [RAX + 0xc],ECX
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 local_24;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
if (*(byte *)(param_3 + 0xb2) < 2) {
local_24 = *(int4 *)(param_2 + 0x90);
}
else {
local_24 = 4;
}
*(int4 *)(param_1 + 0x90) = local_24;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
| |
22,908 | copy_uca_collation | eloqsql/mysys/charset.c | static void
copy_uca_collation(struct charset_info_st *to, CHARSET_INFO *from,
CHARSET_INFO *loaded)
{
to->cset= from->cset;
to->coll= from->coll;
/*
Single-level UCA collation have strnxfrm_multiple=8.
In case of a multi-level UCA collation we use strnxfrm_multiply=4.
That means MY_COLLATION_HANDLER::strnfrmlen() will request the caller
to allocate a buffer smaller size for each level, for performance purpose,
and to fit longer VARCHARs to @@max_sort_length.
This makes filesort produce non-precise order for some rare Unicode
characters that produce more than 4 weights (long expansions).
UCA requires 2 bytes per weight multiplied by the number of levels.
In case of a 2-level collation, each character requires 4*2=8 bytes.
Therefore, the longest VARCHAR that fits into the default @@max_sort_length
is 1024/8=VARCHAR(128). With strnxfrm_multiply==8, only VARCHAR(64)
would fit.
Note, the built-in collation utf8_thai_520_w2 also uses strnxfrm_multiply=4,
for the same purpose.
TODO: we could add a new LDML syntax to choose strxfrm_multiply value.
*/
to->strxfrm_multiply= loaded->levels_for_order > 1 ?
4 : from->strxfrm_multiply;
to->min_sort_char= from->min_sort_char;
to->max_sort_char= from->max_sort_char;
to->mbminlen= from->mbminlen;
to->mbmaxlen= from->mbmaxlen;
to->caseup_multiply= from->caseup_multiply;
to->casedn_multiply= from->casedn_multiply;
to->state|= MY_CS_AVAILABLE | MY_CS_LOADED |
MY_CS_STRNXFRM | MY_CS_UNICODE;
} | O3 | c | copy_uca_collation:
pushq %rbp
movq %rsp, %rbp
movq 0xb8(%rsi), %rax
movq %rax, 0xb8(%rdi)
movq 0xc0(%rsi), %rax
movq %rax, 0xc0(%rdi)
movl $0x4, %eax
cmpb $0x1, 0xb2(%rdx)
ja 0xa61b3
movl 0x90(%rsi), %eax
movl %eax, 0x90(%rdi)
movq 0xa0(%rsi), %rax
movq %rax, 0xa0(%rdi)
movq 0xa8(%rsi), %rax
movq %rax, 0xa8(%rdi)
movl 0x98(%rsi), %eax
movl %eax, 0x98(%rdi)
movl 0x9c(%rsi), %eax
movl %eax, 0x9c(%rdi)
movb 0x94(%rsi), %al
movb %al, 0x94(%rdi)
movb 0x95(%rsi), %al
movb %al, 0x95(%rdi)
orl $0x2c8, 0xc(%rdi) # imm = 0x2C8
popq %rbp
retq
| copy_uca_collation:
push rbp
mov rbp, rsp
mov rax, [rsi+0B8h]
mov [rdi+0B8h], rax
mov rax, [rsi+0C0h]
mov [rdi+0C0h], rax
mov eax, 4
cmp byte ptr [rdx+0B2h], 1
ja short loc_A61B3
mov eax, [rsi+90h]
loc_A61B3:
mov [rdi+90h], eax
mov rax, [rsi+0A0h]
mov [rdi+0A0h], rax
mov rax, [rsi+0A8h]
mov [rdi+0A8h], rax
mov eax, [rsi+98h]
mov [rdi+98h], eax
mov eax, [rsi+9Ch]
mov [rdi+9Ch], eax
mov al, [rsi+94h]
mov [rdi+94h], al
mov al, [rsi+95h]
mov [rdi+95h], al
or dword ptr [rdi+0Ch], 2C8h
pop rbp
retn
| char copy_uca_collation(long long a1, long long a2, long long a3)
{
int v3; // eax
char result; // al
*(_QWORD *)(a1 + 184) = *(_QWORD *)(a2 + 184);
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a2 + 192);
v3 = 4;
if ( *(_BYTE *)(a3 + 178) <= 1u )
v3 = *(_DWORD *)(a2 + 144);
*(_DWORD *)(a1 + 144) = v3;
*(_QWORD *)(a1 + 160) = *(_QWORD *)(a2 + 160);
*(_QWORD *)(a1 + 168) = *(_QWORD *)(a2 + 168);
*(_DWORD *)(a1 + 152) = *(_DWORD *)(a2 + 152);
*(_DWORD *)(a1 + 156) = *(_DWORD *)(a2 + 156);
*(_BYTE *)(a1 + 148) = *(_BYTE *)(a2 + 148);
result = *(_BYTE *)(a2 + 149);
*(_BYTE *)(a1 + 149) = result;
*(_DWORD *)(a1 + 12) |= 0x2C8u;
return result;
}
| copy_uca_collation:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RSI + 0xb8]
MOV qword ptr [RDI + 0xb8],RAX
MOV RAX,qword ptr [RSI + 0xc0]
MOV qword ptr [RDI + 0xc0],RAX
MOV EAX,0x4
CMP byte ptr [RDX + 0xb2],0x1
JA 0x001a61b3
MOV EAX,dword ptr [RSI + 0x90]
LAB_001a61b3:
MOV dword ptr [RDI + 0x90],EAX
MOV RAX,qword ptr [RSI + 0xa0]
MOV qword ptr [RDI + 0xa0],RAX
MOV RAX,qword ptr [RSI + 0xa8]
MOV qword ptr [RDI + 0xa8],RAX
MOV EAX,dword ptr [RSI + 0x98]
MOV dword ptr [RDI + 0x98],EAX
MOV EAX,dword ptr [RSI + 0x9c]
MOV dword ptr [RDI + 0x9c],EAX
MOV AL,byte ptr [RSI + 0x94]
MOV byte ptr [RDI + 0x94],AL
MOV AL,byte ptr [RSI + 0x95]
MOV byte ptr [RDI + 0x95],AL
OR dword ptr [RDI + 0xc],0x2c8
POP RBP
RET
|
void copy_uca_collation(long param_1,long param_2,long param_3)
{
int4 uVar1;
*(int8 *)(param_1 + 0xb8) = *(int8 *)(param_2 + 0xb8);
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_2 + 0xc0);
uVar1 = 4;
if (*(byte *)(param_3 + 0xb2) < 2) {
uVar1 = *(int4 *)(param_2 + 0x90);
}
*(int4 *)(param_1 + 0x90) = uVar1;
*(int8 *)(param_1 + 0xa0) = *(int8 *)(param_2 + 0xa0);
*(int8 *)(param_1 + 0xa8) = *(int8 *)(param_2 + 0xa8);
*(int4 *)(param_1 + 0x98) = *(int4 *)(param_2 + 0x98);
*(int4 *)(param_1 + 0x9c) = *(int4 *)(param_2 + 0x9c);
*(int1 *)(param_1 + 0x94) = *(int1 *)(param_2 + 0x94);
*(int1 *)(param_1 + 0x95) = *(int1 *)(param_2 + 0x95);
*(uint *)(param_1 + 0xc) = *(uint *)(param_1 + 0xc) | 0x2c8;
return;
}
| |
22,909 | lunasvg::parseUrl[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | dmazzella[P]pylunasvg/lunasvg/source/svglayoutstate.cpp | static std::string parseUrl(std::string_view input)
{
std::string value;
if(!parseUrlValue(input, value) || !input.empty())
value.clear();
return value;
} | O1 | cpp | lunasvg::parseUrl[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rsi
callq 0x16e40
cmpq $0x0, (%rsp)
sete %cl
testb %cl, %al
jne 0x16c11
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x16c34
movq (%r15), %rsi
incq %rsi
callq 0xa320
movq %r14, %rdi
callq 0xa5c0
| _ZN7lunasvgL8parseUrlB5cxx11ESt17basic_string_viewIcSt11char_traitsIcEE:
push r15
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov rdi, rsp
mov [rdi], rsi
mov [rdi+8], rdx
lea r15, [rbx+10h]
mov [rbx], r15
mov qword ptr [rbx+8], 0
mov byte ptr [rbx+10h], 0
mov rsi, rbx
call _ZN7lunasvgL13parseUrlValueERSt17basic_string_viewIcSt11char_traitsIcEERNSt7__cxx1112basic_stringIcS2_SaIcEEE; lunasvg::parseUrlValue(std::string_view &,std::string &)
cmp [rsp+28h+var_28], 0
setz cl
test al, cl
jnz short loc_16C11
mov qword ptr [rbx+8], 0
mov rax, [rbx]
mov byte ptr [rax], 0
loc_16C11:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r15
jz short loc_16C34
mov rsi, [r15]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_16C34:
mov rdi, r14
call __Unwind_Resume
| long long lunasvg::parseUrl[abi:cxx11](long long a1, long long a2, long long a3)
{
unsigned __int8 v3; // al
_QWORD v5[5]; // [rsp+0h] [rbp-28h] BYREF
v5[0] = a2;
v5[1] = a3;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = lunasvg::parseUrlValue(v5, a1);
if ( ((v5[0] == 0LL) & v3) == 0 )
{
*(_QWORD *)(a1 + 8) = 0LL;
**(_BYTE **)a1 = 0;
}
return a1;
}
| parseUrl[abi:cxx11]:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RDI,RSP
MOV qword ptr [RDI],RSI
MOV qword ptr [RDI + 0x8],RDX
LEA R15,[RBX + 0x10]
MOV qword ptr [RBX],R15
MOV qword ptr [RBX + 0x8],0x0
MOV byte ptr [RBX + 0x10],0x0
LAB_00116bef:
MOV RSI,RBX
CALL 0x00116e40
LAB_00116bf7:
CMP qword ptr [RSP],0x0
SETZ CL
TEST AL,CL
JNZ 0x00116c11
MOV qword ptr [RBX + 0x8],0x0
MOV RAX,qword ptr [RBX]
MOV byte ptr [RAX],0x0
LAB_00116c11:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* lunasvg::parseUrl[abi:cxx11](std::basic_string_view<char, std::char_traits<char> >) */
string * lunasvg::parseUrl_abi_cxx11_(string *param_1,long param_2,int8 param_3)
{
byte bVar1;
long local_28;
int8 local_20;
*(string **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (string)0x0;
local_28 = param_2;
local_20 = param_3;
/* try { // try from 00116bef to 00116bf6 has its CatchHandler @ 00116c1e */
bVar1 = parseUrlValue((basic_string_view *)&local_28,param_1);
if ((bVar1 & local_28 == 0) == 0) {
*(int8 *)(param_1 + 8) = 0;
**(int1 **)param_1 = 0;
}
return param_1;
}
| |
22,910 | mi_status | eloqsql/storage/myisam/mi_info.c | int mi_status(MI_INFO *info, register MI_ISAMINFO *x, uint flag)
{
MY_STAT state;
MYISAM_SHARE *share=info->s;
DBUG_ENTER("mi_status");
x->recpos = info->lastpos;
if (flag == HA_STATUS_POS)
DBUG_RETURN(0); /* Compatible with ISAM */
if (!(flag & HA_STATUS_NO_LOCK))
{
mysql_mutex_lock(&share->intern_lock);
(void) _mi_readinfo(info,F_RDLCK,0);
fast_mi_writeinfo(info);
mysql_mutex_unlock(&share->intern_lock);
}
if (flag & HA_STATUS_VARIABLE)
{
x->records = info->state->records;
x->deleted = info->state->del;
x->delete_length = info->state->empty;
x->data_file_length =info->state->data_file_length;
x->index_file_length=info->state->key_file_length;
x->keys = share->state.header.keys;
x->check_time = share->state.check_time;
x->mean_reclength= x->records ?
(ulong) ((x->data_file_length - x->delete_length) / x->records) :
(ulong) share->min_pack_length;
}
if (flag & HA_STATUS_ERRKEY)
{
x->errkey = info->errkey;
x->dupp_key_pos= info->dupp_key_pos;
}
if (flag & HA_STATUS_CONST)
{
x->reclength = share->base.reclength;
x->max_data_file_length=share->base.max_data_file_length;
x->max_index_file_length=info->s->base.max_key_file_length;
x->filenr = info->dfile;
x->options = share->options;
x->create_time=share->state.create_time;
x->reflength= mi_get_pointer_length(share->base.max_data_file_length,
myisam_data_pointer_size);
x->record_offset= ((share->options &
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
0L : share->base.pack_reclength);
x->sortkey= -1; /* No clustering */
x->rec_per_key = share->state.rec_per_key_part;
x->key_map = share->state.key_map;
x->data_file_name = share->data_file_name;
x->index_file_name = share->index_file_name;
}
if ((flag & HA_STATUS_TIME) && !mysql_file_fstat(info->dfile, &state, MYF(0)))
{
MSAN_STAT_WORKAROUND(&state);
x->update_time=state.st_mtime;
}
else
x->update_time=0;
if (flag & HA_STATUS_AUTO)
{
x->auto_increment= share->state.auto_increment+1;
if (!x->auto_increment) /* This shouldn't happen */
x->auto_increment= ~(ulonglong) 0;
}
DBUG_RETURN(0);
} | O3 | c | mi_status:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq (%rdi), %r13
movq 0x170(%rdi), %rax
movq %rax, 0x10(%rsi)
cmpl $0x1, %edx
je 0x7dc40
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
testb $0x2, %r14b
jne 0x7da7a
leaq 0x480(%r13), %r12
cmpq $0x0, 0x4c0(%r13)
jne 0x7dc5a
movq %r12, %rdi
callq 0x2a220
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7f57f
movq (%r15), %rax
cmpl $0x0, 0x368(%rax)
jne 0x7da62
movq %r15, %rdi
xorl %esi, %esi
callq 0x7f672
movq 0x4c0(%r13), %rdi
testq %rdi, %rdi
jne 0x7dc73
movq %r12, %rdi
callq 0x2a1e0
testb $0x10, %r14b
je 0x7daed
movq 0x8(%r15), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rax
movq 0x10(%rax), %rdx
movq %rdx, 0x48(%rbx)
movq 0x8(%r15), %rax
movq 0x28(%rax), %rax
movq %rax, 0x28(%rbx)
movq 0x8(%r15), %rsi
movq 0x20(%rsi), %rsi
movq %rsi, 0x38(%rbx)
movzbl 0x12(%r13), %esi
movl %esi, 0x80(%rbx)
movq 0xe0(%r13), %rsi
movq %rsi, 0xa0(%rbx)
testq %rcx, %rcx
je 0x7dae2
subq %rdx, %rax
xorl %edx, %edx
divq %rcx
jmp 0x7dae9
movq 0x320(%r13), %rax
movq %rax, 0x58(%rbx)
testb $0x20, %r14b
je 0x7db0b
movl 0x1f0(%r15), %eax
movl %eax, 0x88(%rbx)
movq 0x1a0(%r15), %rax
movq %rax, 0x20(%rbx)
testb $0x8, %r14b
je 0x7dbd1
movq 0x140(%r13), %rax
movq %rax, 0x50(%rbx)
movq 0x110(%r13), %rax
movq %rax, 0x30(%rbx)
movq (%r15), %rax
movq 0x118(%rax), %rax
movq %rax, 0x40(%rbx)
movl 0x1c0(%r15), %eax
movl %eax, 0x90(%rbx)
movl 0x318(%r13), %eax
movl %eax, 0x84(%rbx)
movq 0xd0(%r13), %rax
movq %rax, 0x98(%rbx)
movq 0x110(%r13), %rdi
leaq 0x3109b1(%rip), %rax # 0x38e520
movl (%rax), %esi
callq 0x93b7b
movl %eax, 0xb0(%rbx)
testb $0x5, 0x318(%r13)
je 0x7db8a
xorl %eax, %eax
jmp 0x7db91
movq 0x148(%r13), %rax
movq %rax, 0xb8(%rbx)
movl $0xffffffff, 0x8c(%rbx) # imm = 0xFFFFFFFF
movq 0x88(%r13), %rax
movq %rax, 0xc0(%rbx)
movq 0xc0(%r13), %rax
movq %rax, 0x68(%rbx)
movq 0x260(%r13), %rax
movq %rax, 0x70(%rbx)
movq 0x268(%r13), %rax
movq %rax, 0x78(%rbx)
testb $0x4, %r14b
je 0x7dc1b
movl 0x1c0(%r15), %r15d
leaq 0x311673(%rip), %rax # 0x38f258
movq (%rax), %rax
leaq -0x108(%rbp), %rdi
movl %r15d, %esi
movl $0xc, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x7dc88
leaq -0xc0(%rbp), %rsi
movl %r15d, %edi
xorl %edx, %edx
callq 0xa617b
testl %eax, %eax
je 0x7dc54
xorl %eax, %eax
movq %rax, 0xa8(%rbx)
testb $0x40, %r14b
je 0x7dc40
movq 0x60(%r13), %rax
incq %rax
movq $-0x1, %rcx
cmovneq %rax, %rcx
movq %rcx, 0x60(%rbx)
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x68(%rbp), %rax
jmp 0x7dc1d
leaq 0x65611(%rip), %rsi # 0xe3272
movq %r12, %rdi
movl $0x2e, %edx
callq 0x30603
jmp 0x7da40
leaq 0x3115de(%rip), %rax # 0x38f258
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x7da72
leaq -0xc0(%rbp), %rdx
leaq -0x2c(%rbp), %r12
movq %rax, %rdi
movl %r15d, %esi
movq %r12, %rcx
callq 0x2ea5f
movl (%r12), %eax
jmp 0x7dc17
| mi_status:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0E8h
mov r13, [rdi]
mov rax, [rdi+170h]
mov [rsi+10h], rax
cmp edx, 1
jz loc_7DC40
mov r14d, edx
mov rbx, rsi
mov r15, rdi
test r14b, 2
jnz short loc_7DA7A
lea r12, [r13+480h]
cmp qword ptr [r13+4C0h], 0
jnz loc_7DC5A
mov rdi, r12
call _pthread_mutex_lock
loc_7DA40:
mov rdi, r15
xor esi, esi
xor edx, edx
call _mi_readinfo
mov rax, [r15]
cmp dword ptr [rax+368h], 0
jnz short loc_7DA62
mov rdi, r15
xor esi, esi
call _mi_writeinfo
loc_7DA62:
mov rdi, [r13+4C0h]
test rdi, rdi
jnz loc_7DC73
loc_7DA72:
mov rdi, r12
call _pthread_mutex_unlock
loc_7DA7A:
test r14b, 10h
jz short loc_7DAED
mov rax, [r15+8]
mov rcx, [rax]
mov [rbx], rcx
mov rax, [r15+8]
mov rax, [rax+8]
mov [rbx+8], rax
mov rax, [r15+8]
mov rdx, [rax+10h]
mov [rbx+48h], rdx
mov rax, [r15+8]
mov rax, [rax+28h]
mov [rbx+28h], rax
mov rsi, [r15+8]
mov rsi, [rsi+20h]
mov [rbx+38h], rsi
movzx esi, byte ptr [r13+12h]
mov [rbx+80h], esi
mov rsi, [r13+0E0h]
mov [rbx+0A0h], rsi
test rcx, rcx
jz short loc_7DAE2
sub rax, rdx
xor edx, edx
div rcx
jmp short loc_7DAE9
loc_7DAE2:
mov rax, [r13+320h]
loc_7DAE9:
mov [rbx+58h], rax
loc_7DAED:
test r14b, 20h
jz short loc_7DB0B
mov eax, [r15+1F0h]
mov [rbx+88h], eax
mov rax, [r15+1A0h]
mov [rbx+20h], rax
loc_7DB0B:
test r14b, 8
jz loc_7DBD1
mov rax, [r13+140h]
mov [rbx+50h], rax
mov rax, [r13+110h]
mov [rbx+30h], rax
mov rax, [r15]
mov rax, [rax+118h]
mov [rbx+40h], rax
mov eax, [r15+1C0h]
mov [rbx+90h], eax
mov eax, [r13+318h]
mov [rbx+84h], eax
mov rax, [r13+0D0h]
mov [rbx+98h], rax
mov rdi, [r13+110h]
lea rax, myisam_data_pointer_size
mov esi, [rax]
call mi_get_pointer_length
mov [rbx+0B0h], eax
test byte ptr [r13+318h], 5
jz short loc_7DB8A
xor eax, eax
jmp short loc_7DB91
loc_7DB8A:
mov rax, [r13+148h]
loc_7DB91:
mov [rbx+0B8h], rax
mov dword ptr [rbx+8Ch], 0FFFFFFFFh
mov rax, [r13+88h]
mov [rbx+0C0h], rax
mov rax, [r13+0C0h]
mov [rbx+68h], rax
mov rax, [r13+260h]
mov [rbx+70h], rax
mov rax, [r13+268h]
mov [rbx+78h], rax
loc_7DBD1:
test r14b, 4
jz short loc_7DC1B
mov r15d, [r15+1C0h]
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_108]
mov esi, r15d
mov edx, 0Ch
call qword ptr [rax+158h]
test rax, rax
jnz loc_7DC88
lea rsi, [rbp+var_C0]
mov edi, r15d
xor edx, edx
call my_fstat
loc_7DC17:
test eax, eax
jz short loc_7DC54
loc_7DC1B:
xor eax, eax
loc_7DC1D:
mov [rbx+0A8h], rax
test r14b, 40h
jz short loc_7DC40
mov rax, [r13+60h]
inc rax
mov rcx, 0FFFFFFFFFFFFFFFFh
cmovnz rcx, rax
mov [rbx+60h], rcx
loc_7DC40:
xor eax, eax
add rsp, 0E8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7DC54:
mov rax, [rbp+var_68]
jmp short loc_7DC1D
loc_7DC5A:
lea rsi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r12
mov edx, 2Eh ; '.'
call psi_mutex_lock
jmp loc_7DA40
loc_7DC73:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_7DA72
loc_7DC88:
lea rdx, [rbp+var_C0]
lea r12, [rbp+var_2C]
mov rdi, rax
mov esi, r15d
mov rcx, r12
call mi_status_cold_1
mov eax, [r12]
jmp loc_7DC17
| long long mi_status(_DWORD *a1, long long a2, int a3)
{
long long v3; // r13
char v4; // r14
unsigned long long v5; // rcx
long long v6; // rdx
long long v7; // rax
unsigned long long v8; // rax
long long v9; // rax
unsigned int v10; // r15d
long long v11; // rax
int v12; // eax
long long v13; // rax
long long v14; // rcx
_BYTE v16[72]; // [rsp+8h] [rbp-108h] BYREF
_BYTE v17[88]; // [rsp+50h] [rbp-C0h] BYREF
long long v18; // [rsp+A8h] [rbp-68h]
_DWORD v19[11]; // [rsp+E4h] [rbp-2Ch] BYREF
v3 = *(_QWORD *)a1;
*(_QWORD *)(a2 + 16) = *((_QWORD *)a1 + 46);
if ( a3 != 1 )
{
v4 = a3;
if ( (a3 & 2) == 0 )
{
if ( *(_QWORD *)(v3 + 1216) )
psi_mutex_lock(v3 + 1152, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_info.c", 0x2Eu);
else
pthread_mutex_lock(v3 + 1152);
mi_readinfo(a1, 0LL, 0LL);
if ( !*(_DWORD *)(*(_QWORD *)a1 + 872LL) )
mi_writeinfo(a1, 0LL);
if ( *(_QWORD *)(v3 + 1216) )
PSI_server[44]();
pthread_mutex_unlock(v3 + 1152);
}
if ( (v4 & 0x10) != 0 )
{
v5 = **((_QWORD **)a1 + 1);
*(_QWORD *)a2 = v5;
*(_QWORD *)(a2 + 8) = *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
v6 = *(_QWORD *)(*((_QWORD *)a1 + 1) + 16LL);
*(_QWORD *)(a2 + 72) = v6;
v7 = *(_QWORD *)(*((_QWORD *)a1 + 1) + 40LL);
*(_QWORD *)(a2 + 40) = v7;
*(_QWORD *)(a2 + 56) = *(_QWORD *)(*((_QWORD *)a1 + 1) + 32LL);
*(_DWORD *)(a2 + 128) = *(unsigned __int8 *)(v3 + 18);
*(_QWORD *)(a2 + 160) = *(_QWORD *)(v3 + 224);
if ( v5 )
v8 = (v7 - v6) / v5;
else
v8 = *(_QWORD *)(v3 + 800);
*(_QWORD *)(a2 + 88) = v8;
}
if ( (v4 & 0x20) != 0 )
{
*(_DWORD *)(a2 + 136) = a1[124];
*(_QWORD *)(a2 + 32) = *((_QWORD *)a1 + 52);
}
if ( (v4 & 8) != 0 )
{
*(_QWORD *)(a2 + 80) = *(_QWORD *)(v3 + 320);
*(_QWORD *)(a2 + 48) = *(_QWORD *)(v3 + 272);
*(_QWORD *)(a2 + 64) = *(_QWORD *)(*(_QWORD *)a1 + 280LL);
*(_DWORD *)(a2 + 144) = a1[112];
*(_DWORD *)(a2 + 132) = *(_DWORD *)(v3 + 792);
*(_QWORD *)(a2 + 152) = *(_QWORD *)(v3 + 208);
*(_DWORD *)(a2 + 176) = mi_get_pointer_length(*(_QWORD *)(v3 + 272), myisam_data_pointer_size);
if ( (*(_BYTE *)(v3 + 792) & 5) != 0 )
v9 = 0LL;
else
v9 = *(_QWORD *)(v3 + 328);
*(_QWORD *)(a2 + 184) = v9;
*(_DWORD *)(a2 + 140) = -1;
*(_QWORD *)(a2 + 192) = *(_QWORD *)(v3 + 136);
*(_QWORD *)(a2 + 104) = *(_QWORD *)(v3 + 192);
*(_QWORD *)(a2 + 112) = *(_QWORD *)(v3 + 608);
*(_QWORD *)(a2 + 120) = *(_QWORD *)(v3 + 616);
}
if ( (v4 & 4) != 0
&& ((v10 = a1[112], (v11 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v16, v10, 12LL)) != 0)
? (mi_status_cold_1(v11, v10, (long long)v17, v19), v12 = v19[0])
: (v12 = my_fstat(v10, v17, 0LL)),
!v12) )
{
v13 = v18;
}
else
{
v13 = 0LL;
}
*(_QWORD *)(a2 + 168) = v13;
if ( (v4 & 0x40) != 0 )
{
v14 = -1LL;
if ( *(_QWORD *)(v3 + 96) != -1LL )
v14 = *(_QWORD *)(v3 + 96) + 1LL;
*(_QWORD *)(a2 + 96) = v14;
}
}
return 0LL;
}
| mi_status:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xe8
MOV R13,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x170]
MOV qword ptr [RSI + 0x10],RAX
CMP EDX,0x1
JZ 0x0017dc40
MOV R14D,EDX
MOV RBX,RSI
MOV R15,RDI
TEST R14B,0x2
JNZ 0x0017da7a
LEA R12,[R13 + 0x480]
CMP qword ptr [R13 + 0x4c0],0x0
JNZ 0x0017dc5a
MOV RDI,R12
CALL 0x0012a220
LAB_0017da40:
MOV RDI,R15
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0017f57f
MOV RAX,qword ptr [R15]
CMP dword ptr [RAX + 0x368],0x0
JNZ 0x0017da62
MOV RDI,R15
XOR ESI,ESI
CALL 0x0017f672
LAB_0017da62:
MOV RDI,qword ptr [R13 + 0x4c0]
TEST RDI,RDI
JNZ 0x0017dc73
LAB_0017da72:
MOV RDI,R12
CALL 0x0012a1e0
LAB_0017da7a:
TEST R14B,0x10
JZ 0x0017daed
MOV RAX,qword ptr [R15 + 0x8]
MOV RCX,qword ptr [RAX]
MOV qword ptr [RBX],RCX
MOV RAX,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBX + 0x8],RAX
MOV RAX,qword ptr [R15 + 0x8]
MOV RDX,qword ptr [RAX + 0x10]
MOV qword ptr [RBX + 0x48],RDX
MOV RAX,qword ptr [R15 + 0x8]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBX + 0x28],RAX
MOV RSI,qword ptr [R15 + 0x8]
MOV RSI,qword ptr [RSI + 0x20]
MOV qword ptr [RBX + 0x38],RSI
MOVZX ESI,byte ptr [R13 + 0x12]
MOV dword ptr [RBX + 0x80],ESI
MOV RSI,qword ptr [R13 + 0xe0]
MOV qword ptr [RBX + 0xa0],RSI
TEST RCX,RCX
JZ 0x0017dae2
SUB RAX,RDX
XOR EDX,EDX
DIV RCX
JMP 0x0017dae9
LAB_0017dae2:
MOV RAX,qword ptr [R13 + 0x320]
LAB_0017dae9:
MOV qword ptr [RBX + 0x58],RAX
LAB_0017daed:
TEST R14B,0x20
JZ 0x0017db0b
MOV EAX,dword ptr [R15 + 0x1f0]
MOV dword ptr [RBX + 0x88],EAX
MOV RAX,qword ptr [R15 + 0x1a0]
MOV qword ptr [RBX + 0x20],RAX
LAB_0017db0b:
TEST R14B,0x8
JZ 0x0017dbd1
MOV RAX,qword ptr [R13 + 0x140]
MOV qword ptr [RBX + 0x50],RAX
MOV RAX,qword ptr [R13 + 0x110]
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,qword ptr [R15]
MOV RAX,qword ptr [RAX + 0x118]
MOV qword ptr [RBX + 0x40],RAX
MOV EAX,dword ptr [R15 + 0x1c0]
MOV dword ptr [RBX + 0x90],EAX
MOV EAX,dword ptr [R13 + 0x318]
MOV dword ptr [RBX + 0x84],EAX
MOV RAX,qword ptr [R13 + 0xd0]
MOV qword ptr [RBX + 0x98],RAX
MOV RDI,qword ptr [R13 + 0x110]
LEA RAX,[0x48e520]
MOV ESI,dword ptr [RAX]
CALL 0x00193b7b
MOV dword ptr [RBX + 0xb0],EAX
TEST byte ptr [R13 + 0x318],0x5
JZ 0x0017db8a
XOR EAX,EAX
JMP 0x0017db91
LAB_0017db8a:
MOV RAX,qword ptr [R13 + 0x148]
LAB_0017db91:
MOV qword ptr [RBX + 0xb8],RAX
MOV dword ptr [RBX + 0x8c],0xffffffff
MOV RAX,qword ptr [R13 + 0x88]
MOV qword ptr [RBX + 0xc0],RAX
MOV RAX,qword ptr [R13 + 0xc0]
MOV qword ptr [RBX + 0x68],RAX
MOV RAX,qword ptr [R13 + 0x260]
MOV qword ptr [RBX + 0x70],RAX
MOV RAX,qword ptr [R13 + 0x268]
MOV qword ptr [RBX + 0x78],RAX
LAB_0017dbd1:
TEST R14B,0x4
JZ 0x0017dc1b
MOV R15D,dword ptr [R15 + 0x1c0]
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x108]
MOV ESI,R15D
MOV EDX,0xc
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0017dc88
LEA RSI,[RBP + -0xc0]
MOV EDI,R15D
XOR EDX,EDX
CALL 0x001a617b
LAB_0017dc17:
TEST EAX,EAX
JZ 0x0017dc54
LAB_0017dc1b:
XOR EAX,EAX
LAB_0017dc1d:
MOV qword ptr [RBX + 0xa8],RAX
TEST R14B,0x40
JZ 0x0017dc40
MOV RAX,qword ptr [R13 + 0x60]
INC RAX
MOV RCX,-0x1
CMOVNZ RCX,RAX
MOV qword ptr [RBX + 0x60],RCX
LAB_0017dc40:
XOR EAX,EAX
ADD RSP,0xe8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017dc54:
MOV RAX,qword ptr [RBP + -0x68]
JMP 0x0017dc1d
LAB_0017dc5a:
LEA RSI,[0x1e3272]
MOV RDI,R12
MOV EDX,0x2e
CALL 0x00130603
JMP 0x0017da40
LAB_0017dc73:
LEA RAX,[0x48f258]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x0017da72
LAB_0017dc88:
LEA RDX,[RBP + -0xc0]
LEA R12,[RBP + -0x2c]
MOV RDI,RAX
MOV ESI,R15D
MOV RCX,R12
CALL 0x0012ea5f
MOV EAX,dword ptr [R12]
JMP 0x0017dc17
|
int8 mi_status(long *param_1,ulong *param_2,uint param_3)
{
pthread_mutex_t *__mutex;
long lVar1;
int4 uVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
ulong uVar6;
int1 local_110 [72];
int1 local_c8 [88];
ulong local_70;
int local_34;
lVar1 = *param_1;
param_2[2] = param_1[0x2e];
if (param_3 == 1) {
return 0;
}
if ((param_3 & 2) == 0) {
__mutex = (pthread_mutex_t *)(lVar1 + 0x480);
if (*(long *)(lVar1 + 0x4c0) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_info.c",
0x2e);
}
_mi_readinfo(param_1,0,0);
if (*(int *)(*param_1 + 0x368) == 0) {
_mi_writeinfo(param_1,0);
}
if (*(long *)(lVar1 + 0x4c0) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
}
if ((param_3 & 0x10) != 0) {
uVar3 = *(ulong *)param_1[1];
*param_2 = uVar3;
param_2[1] = *(ulong *)(param_1[1] + 8);
uVar4 = *(ulong *)(param_1[1] + 0x10);
param_2[9] = uVar4;
uVar6 = *(ulong *)(param_1[1] + 0x28);
param_2[5] = uVar6;
param_2[7] = *(ulong *)(param_1[1] + 0x20);
*(uint *)(param_2 + 0x10) = (uint)*(byte *)(lVar1 + 0x12);
param_2[0x14] = *(ulong *)(lVar1 + 0xe0);
if (uVar3 == 0) {
uVar3 = *(ulong *)(lVar1 + 800);
}
else {
uVar3 = (uVar6 - uVar4) / uVar3;
}
param_2[0xb] = uVar3;
}
if ((param_3 & 0x20) != 0) {
*(int *)(param_2 + 0x11) = (int)param_1[0x3e];
param_2[4] = param_1[0x34];
}
if ((param_3 & 8) != 0) {
param_2[10] = *(ulong *)(lVar1 + 0x140);
param_2[6] = *(ulong *)(lVar1 + 0x110);
param_2[8] = *(ulong *)(*param_1 + 0x118);
*(int *)(param_2 + 0x12) = (int)param_1[0x38];
*(int4 *)((long)param_2 + 0x84) = *(int4 *)(lVar1 + 0x318);
param_2[0x13] = *(ulong *)(lVar1 + 0xd0);
uVar2 = mi_get_pointer_length
(*(int8 *)(lVar1 + 0x110),(int4)myisam_data_pointer_size);
*(int4 *)(param_2 + 0x16) = uVar2;
if ((*(byte *)(lVar1 + 0x318) & 5) == 0) {
uVar4 = *(ulong *)(lVar1 + 0x148);
}
else {
uVar4 = 0;
}
param_2[0x17] = uVar4;
*(int4 *)((long)param_2 + 0x8c) = 0xffffffff;
param_2[0x18] = *(ulong *)(lVar1 + 0x88);
param_2[0xd] = *(ulong *)(lVar1 + 0xc0);
param_2[0xe] = *(ulong *)(lVar1 + 0x260);
param_2[0xf] = *(ulong *)(lVar1 + 0x268);
}
if ((param_3 & 4) != 0) {
uVar2 = (int4)param_1[0x38];
lVar5 = (**(code **)(PSI_server + 0x158))(local_110,uVar2,0xc);
if (lVar5 == 0) {
local_34 = my_fstat(uVar2,local_c8,0);
}
else {
mi_status_cold_1(lVar5,uVar2,local_c8,&local_34);
}
if (local_34 == 0) goto LAB_0017dc1d;
}
local_70 = 0;
LAB_0017dc1d:
param_2[0x15] = local_70;
if ((param_3 & 0x40) != 0) {
uVar6 = *(long *)(lVar1 + 0x60) + 1;
uVar4 = 0xffffffffffffffff;
if (uVar6 != 0) {
uVar4 = uVar6;
}
param_2[0xc] = uVar4;
}
return 0;
}
| |
22,911 | my_wc_mb_bin | eloqsql/strings/ctype-bin.c | int my_wc_mb_bin(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
if (s >= e)
return MY_CS_TOOSMALL;
if (wc < 256)
{
s[0]= (char) wc;
return 1;
}
return MY_CS_ILUNI;
} | O0 | c | my_wc_mb_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3cd67
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3cd8d
cmpq $0x100, -0x18(%rbp) # imm = 0x100
jae 0x3cd86
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3cd8d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_wc_mb_bin:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3CD67
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_3CD8D
loc_3CD67:
cmp [rbp+var_18], 100h
jnb short loc_3CD86
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_3CD8D
loc_3CD86:
mov [rbp+var_4], 0
loc_3CD8D:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_wc_mb_bin(long long a1, unsigned long long a2, _BYTE *a3, unsigned long long a4)
{
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x100 )
{
return 0;
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013cd67
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013cd8d
LAB_0013cd67:
CMP qword ptr [RBP + -0x18],0x100
JNC 0x0013cd86
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013cd8d
LAB_0013cd86:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013cd8d:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_wc_mb_bin(int8 param_1,ulong param_2,int1 *param_3,int1 *param_4)
{
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x100) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
22,912 | nglog::tools::GetHex(char const*, char const*, unsigned long*) | ng-log[P]ng-log/src/symbolize.cc | static char* GetHex(const char* start, const char* end, uint64_t* hex) {
*hex = 0;
const char* p;
for (p = start; p < end; ++p) {
int ch = *p;
if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
(ch >= 'a' && ch <= 'f')) {
*hex = (*hex << 4U) |
(ch < 'A' ? static_cast<uint64_t>(ch - '0') : (ch & 0xF) + 9U);
} else { // Encountered the first non-hex character.
break;
}
}
NGLOG_SAFE_ASSERT(p <= end);
return const_cast<char*>(p);
} | O0 | cpp | nglog::tools::GetHex(char const*, char const*, unsigned long*):
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4a9ce
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x30, -0x24(%rbp)
jl 0x4a95b
cmpl $0x39, -0x24(%rbp)
jle 0x4a973
cmpl $0x41, -0x24(%rbp)
jl 0x4a967
cmpl $0x46, -0x24(%rbp)
jle 0x4a973
cmpl $0x61, -0x24(%rbp)
jl 0x4a9b9
cmpl $0x66, -0x24(%rbp)
jg 0x4a9b9
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq $0x4, %rax
movq %rax, -0x30(%rbp)
cmpl $0x41, -0x24(%rbp)
jge 0x4a996
movl -0x24(%rbp), %eax
subl $0x30, %eax
cltq
movq %rax, -0x38(%rbp)
jmp 0x4a9a5
movl -0x24(%rbp), %eax
andl $0xf, %eax
addl $0x9, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
orq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4a9bb
jmp 0x4a9ce
jmp 0x4a9bd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4a937
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x4a9da
jmp 0x4a9df
callq 0x93b0
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN5nglog5toolsL6GetHexEPKcS2_Pm:
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_18]
mov qword ptr [rax], 0
mov rax, [rbp+var_8]
mov [rbp+var_20], rax
loc_4A937:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_10]
jnb loc_4A9CE
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
mov [rbp+var_24], eax
cmp [rbp+var_24], 30h ; '0'
jl short loc_4A95B
cmp [rbp+var_24], 39h ; '9'
jle short loc_4A973
loc_4A95B:
cmp [rbp+var_24], 41h ; 'A'
jl short loc_4A967
cmp [rbp+var_24], 46h ; 'F'
jle short loc_4A973
loc_4A967:
cmp [rbp+var_24], 61h ; 'a'
jl short loc_4A9B9
cmp [rbp+var_24], 66h ; 'f'
jg short loc_4A9B9
loc_4A973:
mov rax, [rbp+var_18]
mov rax, [rax]
shl rax, 4
mov [rbp+var_30], rax
cmp [rbp+var_24], 41h ; 'A'
jge short loc_4A996
mov eax, [rbp+var_24]
sub eax, 30h ; '0'
cdqe
mov [rbp+var_38], rax
jmp short loc_4A9A5
loc_4A996:
mov eax, [rbp+var_24]
and eax, 0Fh
add eax, 9
mov eax, eax
mov [rbp+var_38], rax
loc_4A9A5:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_38]
or rcx, rax
mov rax, [rbp+var_18]
mov [rax], rcx
jmp short loc_4A9BB
loc_4A9B9:
jmp short loc_4A9CE
loc_4A9BB:
jmp short $+2
loc_4A9BD:
mov rax, [rbp+var_20]
add rax, 1
mov [rbp+var_20], rax
jmp loc_4A937
loc_4A9CE:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_10]
ja short loc_4A9DA
jmp short loc_4A9DF
loc_4A9DA:
call _abort
loc_4A9DF:
mov rax, [rbp+var_20]
add rsp, 40h
pop rbp
retn
| nglog::tools * nglog::tools::GetHex(nglog::tools *this, nglog::tools *a2, char *a3, unsigned long long *a4)
{
long long v5; // [rsp+8h] [rbp-38h]
int v6; // [rsp+1Ch] [rbp-24h]
nglog::tools *i; // [rsp+20h] [rbp-20h]
*(_QWORD *)a3 = 0LL;
for ( i = this; i < a2; i = (nglog::tools *)((char *)i + 1) )
{
v6 = *(char *)i;
if ( (v6 < 48 || v6 > 57) && (v6 < 65 || v6 > 70) && (v6 < 97 || v6 > 102) )
break;
if ( v6 >= 65 )
v5 = (v6 & 0xFu) + 9;
else
v5 = v6 - 48;
*(_QWORD *)a3 = v5 | (16LL * *(_QWORD *)a3);
}
if ( i > a2 )
abort(this, a2);
return i;
}
| GetHex:
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 + -0x18]
MOV qword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_0014a937:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x10]
JNC 0x0014a9ce
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x24],EAX
CMP dword ptr [RBP + -0x24],0x30
JL 0x0014a95b
CMP dword ptr [RBP + -0x24],0x39
JLE 0x0014a973
LAB_0014a95b:
CMP dword ptr [RBP + -0x24],0x41
JL 0x0014a967
CMP dword ptr [RBP + -0x24],0x46
JLE 0x0014a973
LAB_0014a967:
CMP dword ptr [RBP + -0x24],0x61
JL 0x0014a9b9
CMP dword ptr [RBP + -0x24],0x66
JG 0x0014a9b9
LAB_0014a973:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
SHL RAX,0x4
MOV qword ptr [RBP + -0x30],RAX
CMP dword ptr [RBP + -0x24],0x41
JGE 0x0014a996
MOV EAX,dword ptr [RBP + -0x24]
SUB EAX,0x30
CDQE
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0014a9a5
LAB_0014a996:
MOV EAX,dword ptr [RBP + -0x24]
AND EAX,0xf
ADD EAX,0x9
MOV EAX,EAX
MOV qword ptr [RBP + -0x38],RAX
LAB_0014a9a5:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x38]
OR RCX,RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
JMP 0x0014a9bb
LAB_0014a9b9:
JMP 0x0014a9ce
LAB_0014a9bb:
JMP 0x0014a9bd
LAB_0014a9bd:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x1
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0014a937
LAB_0014a9ce:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x10]
JA 0x0014a9da
JMP 0x0014a9df
LAB_0014a9da:
CALL 0x001093b0
LAB_0014a9df:
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x40
POP RBP
RET
|
/* nglog::tools::GetHex(char const*, char const*, unsigned long*) */
char * nglog::tools::GetHex(char *param_1,char *param_2,ulong *param_3)
{
uint uVar1;
ulong local_40;
char *local_28;
*param_3 = 0;
for (local_28 = param_1;
(local_28 < param_2 &&
((((uVar1 = (uint)*local_28, 0x2f < (int)uVar1 && ((int)uVar1 < 0x3a)) ||
((0x40 < (int)uVar1 && ((int)uVar1 < 0x47)))) ||
((0x60 < (int)uVar1 && ((int)uVar1 < 0x67)))))); local_28 = local_28 + 1) {
if ((int)uVar1 < 0x41) {
local_40 = (ulong)(int)(uVar1 - 0x30);
}
else {
local_40 = (ulong)((uVar1 & 0xf) + 9);
}
*param_3 = *param_3 << 4 | local_40;
}
if (param_2 < local_28) {
/* WARNING: Subroutine does not return */
abort();
}
return local_28;
}
| |
22,913 | nglog::tools::GetHex(char const*, char const*, unsigned long*) | ng-log[P]ng-log/src/symbolize.cc | static char* GetHex(const char* start, const char* end, uint64_t* hex) {
*hex = 0;
const char* p;
for (p = start; p < end; ++p) {
int ch = *p;
if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
(ch >= 'a' && ch <= 'f')) {
*hex = (*hex << 4U) |
(ch < 'A' ? static_cast<uint64_t>(ch - '0') : (ch & 0xF) + 9U);
} else { // Encountered the first non-hex character.
break;
}
}
NGLOG_SAFE_ASSERT(p <= end);
return const_cast<char*>(p);
} | O2 | cpp | nglog::tools::GetHex(char const*, char const*, unsigned long*):
pushq %rax
andq $0x0, (%rdx)
xorl %eax, %eax
movabsq $0x3f0000003f, %rcx # imm = 0x3F0000003F
cmpq %rsi, %rdi
jae 0x1c68a
movb (%rdi), %r8b
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jb 0x1c660
movzbl %r8b, %r9d
addl $-0x41, %r9d
cmpl $0x25, %r9d
ja 0x1c68a
btq %r9, %rcx
jae 0x1c68a
movsbl %r8b, %r9d
shlq $0x4, %rax
leal -0x30(%r9), %r10d
andl $0xf, %r9d
addl $0x9, %r9d
cmpb $0x41, %r8b
movslq %r10d, %r8
cmovbq %r8, %r9
orq %r9, %rax
movq %rax, (%rdx)
incq %rdi
jmp 0x1c63a
cmpq %rsi, %rdi
ja 0x1c694
movq %rdi, %rax
popq %rcx
retq
callq 0x7320
nop
| _ZN5nglog5toolsL6GetHexEPKcS2_Pm:
push rax
and qword ptr [rdx], 0
xor eax, eax
mov rcx, 3F0000003Fh
loc_1C63A:
cmp rdi, rsi
jnb short loc_1C68A
mov r8b, [rdi]
lea r9d, [r8-30h]
cmp r9b, 0Ah
jb short loc_1C660
movzx r9d, r8b
add r9d, 0FFFFFFBFh
cmp r9d, 25h ; '%'
ja short loc_1C68A
bt rcx, r9
jnb short loc_1C68A
loc_1C660:
movsx r9d, r8b
shl rax, 4
lea r10d, [r9-30h]
and r9d, 0Fh
add r9d, 9
cmp r8b, 41h ; 'A'
movsxd r8, r10d
cmovb r9, r8
or rax, r9
mov [rdx], rax
inc rdi
jmp short loc_1C63A
loc_1C68A:
cmp rdi, rsi
ja short loc_1C694
mov rax, rdi
pop rcx
retn
loc_1C694:
call _abort
| nglog::tools * nglog::tools::GetHex(nglog::tools *this, nglog::tools *a2, char *a3, unsigned long long *a4)
{
long long v4; // rax
long long v5; // rcx
unsigned __int8 v6; // r8
unsigned long long v7; // r9
long long v8; // rax
long long v9; // r9
*(_QWORD *)a3 = 0LL;
v4 = 0LL;
v5 = 0x3F0000003FLL;
while ( this < a2 )
{
v6 = *(_BYTE *)this;
if ( (unsigned __int8)(*(_BYTE *)this - 48) >= 0xAu )
{
v7 = (unsigned int)v6 - 65;
if ( (unsigned int)v7 > 0x25 || !_bittest64(&v5, v7) )
break;
}
v8 = 16 * v4;
v9 = ((char)v6 & 0xFu) + 9;
if ( v6 < 0x41u )
v9 = (char)v6 - 48;
v4 = v9 | v8;
*(_QWORD *)a3 = v4;
this = (nglog::tools *)((char *)this + 1);
}
if ( this > a2 )
abort(this);
return this;
}
| GetHex:
PUSH RAX
AND qword ptr [RDX],0x0
XOR EAX,EAX
MOV RCX,0x3f0000003f
LAB_0011c63a:
CMP RDI,RSI
JNC 0x0011c68a
MOV R8B,byte ptr [RDI]
LEA R9D,[R8 + -0x30]
CMP R9B,0xa
JC 0x0011c660
MOVZX R9D,R8B
ADD R9D,-0x41
CMP R9D,0x25
JA 0x0011c68a
BT RCX,R9
JNC 0x0011c68a
LAB_0011c660:
MOVSX R9D,R8B
SHL RAX,0x4
LEA R10D,[R9 + -0x30]
AND R9D,0xf
ADD R9D,0x9
CMP R8B,0x41
MOVSXD R8,R10D
CMOVC R9,R8
OR RAX,R9
MOV qword ptr [RDX],RAX
INC RDI
JMP 0x0011c63a
LAB_0011c68a:
CMP RDI,RSI
JA 0x0011c694
MOV RAX,RDI
POP RCX
RET
LAB_0011c694:
CALL 0x00107320
|
/* nglog::tools::GetHex(char const*, char const*, unsigned long*) */
byte * nglog::tools::GetHex(char *param_1,char *param_2,ulong *param_3)
{
byte bVar1;
ulong uVar2;
ulong uVar3;
*param_3 = 0;
uVar2 = 0;
while ((param_1 < param_2 &&
((bVar1 = *param_1, (byte)(bVar1 - 0x30) < 10 ||
((bVar1 - 0x41 < 0x26 && ((0x3f0000003fU >> ((ulong)(bVar1 - 0x41) & 0x3f) & 1) != 0))))))
) {
uVar3 = (ulong)(((int)(char)bVar1 & 0xfU) + 9);
if (bVar1 < 0x41) {
uVar3 = (long)(int)((int)(char)bVar1 - 0x30);
}
uVar2 = uVar2 << 4 | uVar3;
*param_3 = uVar2;
param_1 = (char *)((byte *)param_1 + 1);
}
if (param_1 <= param_2) {
return (byte *)param_1;
}
/* WARNING: Subroutine does not return */
abort();
}
| |
22,914 | LefDefParser::lefrSettings::lefrSettings() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefrSettings.cpp | lefrSettings::lefrSettings()
: DisPropStrProcess(0),
CaseSensitive(FALSE),
CaseSensitiveSet(FALSE),
CommentChar('#'),
DeltaNumberLines(10000),
AntennaInoutWarnings(999),
AntennaInputWarnings(999),
AntennaOutputWarnings(999),
ArrayWarnings(999),
CaseSensitiveWarnings(999),
CorrectionTableWarnings(999),
DielectricWarnings(999),
EdgeRateScaleFactorWarnings(999),
EdgeRateThreshold1Warnings(999),
EdgeRateThreshold2Warnings(999),
ErrorLogFunction(0),
FreeFunction(0),
IRDropWarnings(999),
InoutAntennaWarnings(999),
InputAntennaWarnings(999),
LayerWarnings(999),
LineNumberFunction(0),
MacroWarnings(999),
MallocFunction(0),
MaxStackViaWarnings(999),
MinFeatureWarnings(999),
NoWireExtensionWarnings(999),
NoiseMarginWarnings(999),
NoiseTableWarnings(999),
NonDefaultWarnings(999),
OutputAntennaWarnings(999),
PinWarnings(999),
ReadFunction(0),
ReadEncrypted(0),
ReallocFunction(0),
RegisterUnused(0),
RelaxMode(FALSE),
ShiftCase(0),
SiteWarnings(999),
SpacingWarnings(999),
TimingWarnings(999),
UnitsWarnings(999),
UseMinSpacingWarnings(999),
UserData(NULL),
VersionNum(0.0),
ViaRuleWarnings(999),
ViaWarnings(999),
LogFileAppend(0),
SetLogFunction(0),
TotalMsgLimit(0),
WarningLogFunction(0),
dAllMsgs(0)
{
memset(MsgLimit, 0, MAX_LEF_MSGS * sizeof(int));
init_symbol_table();
} | O3 | cpp | LefDefParser::lefrSettings::lefrSettings():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb $0x23, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movl %eax, 0x48(%rdi)
movaps 0x1db2e(%rip), %xmm1 # 0x4b050
movups %xmm1, 0x4c(%rdi)
movaps 0x1db33(%rip), %xmm1 # 0x4b060
movups %xmm1, 0x5c(%rdi)
movups %xmm1, 0x6c(%rdi)
movabsq $0x3e7000003e7, %rcx # imm = 0x3E7000003E7
movq %rcx, 0x7c(%rdi)
movq %rax, 0x88(%rdi)
movups %xmm1, 0x90(%rdi)
movups %xmm1, 0xa0(%rdi)
movq %rcx, 0xb0(%rdi)
movups %xmm0, 0xb8(%rdi)
movq %rax, 0xc8(%rdi)
movups %xmm1, 0xd0(%rdi)
movaps 0x1daf5(%rip), %xmm1 # 0x4b070
movups %xmm1, 0xe0(%rdi)
movl %eax, 0xf0(%rdi)
leaq 0x4ab0(%rdi), %rcx
movl %eax, 0x4ab0(%rdi)
movq %rax, 0x4ab8(%rdi)
movups %xmm0, 0xf8(%rdi)
movups %xmm0, 0x108(%rdi)
movups %xmm0, 0x118(%rdi)
movq %rax, 0x128(%rdi)
movq %rcx, 0x4ac0(%rdi)
movq %rcx, 0x4ac8(%rdi)
movq %rax, 0x4ad0(%rdi)
movl %eax, 0x4ad8(%rdi)
leaq 0x4ae0(%rdi), %r14
movq %r14, %rdi
callq 0x30b2e
leaq 0x130(%rbx), %rdi
movl $0x4974, %edx # imm = 0x4974
xorl %esi, %esi
callq 0x2110
movq %rbx, %rdi
callq 0x2d630
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x30c22
jmp 0x2d613
movq %rax, %r15
leaq 0x4aa8(%rbx), %rdi
callq 0x24274
movq %rbx, %rdi
callq 0x242c4
movq %r15, %rdi
callq 0x2350
nop
| _ZN12LefDefParser12lefrSettingsC2Ev:
push r15; Alternative name is 'LefDefParser::lefrSettings::lefrSettings(void)'
push r14
push rbx
mov rbx, rdi
lea rcx, [rdi+8]
xor eax, eax
mov [rdi+8], eax
mov [rdi+10h], rax
mov [rdi+18h], rcx
mov [rdi+20h], rcx
mov [rdi+28h], rax
mov byte ptr [rdi+30h], 23h ; '#'
xorps xmm0, xmm0
movups xmmword ptr [rdi+38h], xmm0
mov [rdi+48h], eax
movaps xmm1, cs:xmmword_4B050
movups xmmword ptr [rdi+4Ch], xmm1
movaps xmm1, cs:xmmword_4B060
movups xmmword ptr [rdi+5Ch], xmm1
movups xmmword ptr [rdi+6Ch], xmm1
mov rcx, 3E7000003E7h
mov [rdi+7Ch], rcx
mov [rdi+88h], rax
movups xmmword ptr [rdi+90h], xmm1
movups xmmword ptr [rdi+0A0h], xmm1
mov [rdi+0B0h], rcx
movups xmmword ptr [rdi+0B8h], xmm0
mov [rdi+0C8h], rax
movups xmmword ptr [rdi+0D0h], xmm1
movaps xmm1, cs:xmmword_4B070
movups xmmword ptr [rdi+0E0h], xmm1
mov [rdi+0F0h], eax
lea rcx, [rdi+4AB0h]
mov [rdi+4AB0h], eax
mov [rdi+4AB8h], rax
movups xmmword ptr [rdi+0F8h], xmm0
movups xmmword ptr [rdi+108h], xmm0
movups xmmword ptr [rdi+118h], xmm0
mov [rdi+128h], rax
mov [rdi+4AC0h], rcx
mov [rdi+4AC8h], rcx
mov [rdi+4AD0h], rax
mov [rdi+4AD8h], eax
lea r14, [rdi+4AE0h]
mov rdi, r14; this
call _ZN12LefDefParser9lefrPropsC2Ev; LefDefParser::lefrProps::lefrProps(void)
lea rdi, [rbx+130h]
mov edx, 4974h
xor esi, esi
call _memset
mov rdi, rbx; this
call _ZN12LefDefParser12lefrSettings17init_symbol_tableEv; LefDefParser::lefrSettings::init_symbol_table(void)
pop rbx
pop r14
pop r15
retn
mov r15, rax
mov rdi, r14; this
call _ZN12LefDefParser9lefrPropsD2Ev; LefDefParser::lefrProps::~lefrProps()
jmp short loc_2D613
mov r15, rax
loc_2D613:
lea rdi, [rbx+4AA8h]
call _ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EED2Ev; std::_Rb_tree<int,std::pair<int const,int>,std::_Select1st<std::pair<int const,int>>,std::less<int>,std::allocator<std::pair<int const,int>>>::~_Rb_tree()
mov rdi, rbx
call _ZNSt8_Rb_treeIPKcSt4pairIKS1_iESt10_Select1stIS4_EN12LefDefParser18lefCompareCStringsESaIS4_EED2Ev; std::_Rb_tree<char const*,std::pair<char const* const,int>,std::_Select1st<std::pair<char const* const,int>>,LefDefParser::lefCompareCStrings,std::allocator<std::pair<char const* const,int>>>::~_Rb_tree()
mov rdi, r15
call __Unwind_Resume
| long long LefDefParser::lefrSettings::lefrSettings(LefDefParser::lefrSettings *this)
{
*((_DWORD *)this + 2) = 0;
*((_QWORD *)this + 2) = 0LL;
*((_QWORD *)this + 3) = (char *)this + 8;
*((_QWORD *)this + 4) = (char *)this + 8;
*((_QWORD *)this + 5) = 0LL;
*((_BYTE *)this + 48) = 35;
*(_OWORD *)((char *)this + 56) = 0LL;
*((_DWORD *)this + 18) = 0;
*(_OWORD *)((char *)this + 76) = xmmword_4B050;
*(_OWORD *)((char *)this + 92) = xmmword_4B060;
*(_OWORD *)((char *)this + 108) = xmmword_4B060;
*(_QWORD *)((char *)this + 124) = 0x3E7000003E7LL;
*((_QWORD *)this + 17) = 0LL;
*((_OWORD *)this + 9) = xmmword_4B060;
*((_OWORD *)this + 10) = xmmword_4B060;
*((_QWORD *)this + 22) = 0x3E7000003E7LL;
*(_OWORD *)((char *)this + 184) = 0LL;
*((_QWORD *)this + 25) = 0LL;
*((_OWORD *)this + 13) = xmmword_4B060;
*((_OWORD *)this + 14) = xmmword_4B070;
*((_DWORD *)this + 60) = 0;
*((_DWORD *)this + 4780) = 0;
*((_QWORD *)this + 2391) = 0LL;
*(_OWORD *)((char *)this + 248) = 0LL;
*(_OWORD *)((char *)this + 264) = 0LL;
*(_OWORD *)((char *)this + 280) = 0LL;
*((_QWORD *)this + 37) = 0LL;
*((_QWORD *)this + 2392) = (char *)this + 19120;
*((_QWORD *)this + 2393) = (char *)this + 19120;
*((_QWORD *)this + 2394) = 0LL;
*((_DWORD *)this + 4790) = 0;
LefDefParser::lefrProps::lefrProps((LefDefParser::lefrSettings *)((char *)this + 19168));
memset((char *)this + 304, 0LL, 18804LL);
return LefDefParser::lefrSettings::init_symbol_table(this);
}
| lefrSettings:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA RCX,[RDI + 0x8]
XOR EAX,EAX
MOV dword ptr [RDI + 0x8],EAX
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RCX
MOV qword ptr [RDI + 0x28],RAX
MOV byte ptr [RDI + 0x30],0x23
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOV dword ptr [RDI + 0x48],EAX
MOVAPS XMM1,xmmword ptr [0x0014b050]
MOVUPS xmmword ptr [RDI + 0x4c],XMM1
MOVAPS XMM1,xmmword ptr [0x0014b060]
MOVUPS xmmword ptr [RDI + 0x5c],XMM1
MOVUPS xmmword ptr [RDI + 0x6c],XMM1
MOV RCX,0x3e7000003e7
MOV qword ptr [RDI + 0x7c],RCX
MOV qword ptr [RDI + 0x88],RAX
MOVUPS xmmword ptr [RDI + 0x90],XMM1
MOVUPS xmmword ptr [RDI + 0xa0],XMM1
MOV qword ptr [RDI + 0xb0],RCX
MOVUPS xmmword ptr [RDI + 0xb8],XMM0
MOV qword ptr [RDI + 0xc8],RAX
MOVUPS xmmword ptr [RDI + 0xd0],XMM1
MOVAPS XMM1,xmmword ptr [0x0014b070]
MOVUPS xmmword ptr [RDI + 0xe0],XMM1
MOV dword ptr [RDI + 0xf0],EAX
LEA RCX,[RDI + 0x4ab0]
MOV dword ptr [RDI + 0x4ab0],EAX
MOV qword ptr [RDI + 0x4ab8],RAX
MOVUPS xmmword ptr [RDI + 0xf8],XMM0
MOVUPS xmmword ptr [RDI + 0x108],XMM0
MOVUPS xmmword ptr [RDI + 0x118],XMM0
MOV qword ptr [RDI + 0x128],RAX
MOV qword ptr [RDI + 0x4ac0],RCX
MOV qword ptr [RDI + 0x4ac8],RCX
MOV qword ptr [RDI + 0x4ad0],RAX
MOV dword ptr [RDI + 0x4ad8],EAX
LEA R14,[RDI + 0x4ae0]
LAB_0012d5da:
MOV RDI,R14
CALL 0x00130b2e
LAB_0012d5e2:
LEA RDI,[RBX + 0x130]
MOV EDX,0x4974
XOR ESI,ESI
CALL 0x00102110
LAB_0012d5f5:
MOV RDI,RBX
CALL 0x0012d630
LAB_0012d5fd:
POP RBX
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* LefDefParser::lefrSettings::lefrSettings() */
void __thiscall LefDefParser::lefrSettings::lefrSettings(lefrSettings *this)
{
int8 uVar1;
int8 uVar2;
*(int4 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(lefrSettings **)(this + 0x18) = this + 8;
*(lefrSettings **)(this + 0x20) = this + 8;
*(int8 *)(this + 0x28) = 0;
this[0x30] = (lefrSettings)0x23;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int4 *)(this + 0x48) = 0;
uVar1 = _UNK_0014b058;
*(int8 *)(this + 0x4c) = _DAT_0014b050;
*(int8 *)(this + 0x54) = uVar1;
uVar2 = _UNK_0014b068;
uVar1 = _DAT_0014b060;
*(int8 *)(this + 0x5c) = _DAT_0014b060;
*(int8 *)(this + 100) = uVar2;
*(int8 *)(this + 0x6c) = uVar1;
*(int8 *)(this + 0x74) = uVar2;
*(int8 *)(this + 0x7c) = 0x3e7000003e7;
*(int8 *)(this + 0x88) = 0;
*(int8 *)(this + 0x90) = uVar1;
*(int8 *)(this + 0x98) = uVar2;
*(int8 *)(this + 0xa0) = uVar1;
*(int8 *)(this + 0xa8) = uVar2;
*(int8 *)(this + 0xb0) = 0x3e7000003e7;
*(int8 *)(this + 0xb8) = 0;
*(int8 *)(this + 0xc0) = 0;
*(int8 *)(this + 200) = 0;
*(int8 *)(this + 0xd0) = uVar1;
*(int8 *)(this + 0xd8) = uVar2;
uVar1 = _UNK_0014b078;
*(int8 *)(this + 0xe0) = _DAT_0014b070;
*(int8 *)(this + 0xe8) = uVar1;
*(int4 *)(this + 0xf0) = 0;
*(int4 *)(this + 0x4ab0) = 0;
*(int8 *)(this + 0x4ab8) = 0;
*(int8 *)(this + 0xf8) = 0;
*(int8 *)(this + 0x100) = 0;
*(int8 *)(this + 0x108) = 0;
*(int8 *)(this + 0x110) = 0;
*(int8 *)(this + 0x118) = 0;
*(int8 *)(this + 0x120) = 0;
*(int8 *)(this + 0x128) = 0;
*(lefrSettings **)(this + 0x4ac0) = this + 0x4ab0;
*(lefrSettings **)(this + 0x4ac8) = this + 0x4ab0;
*(int8 *)(this + 0x4ad0) = 0;
*(int4 *)(this + 0x4ad8) = 0;
/* try { // try from 0012d5da to 0012d5e1 has its CatchHandler @ 0012d610 */
lefrProps::lefrProps((lefrProps *)(this + 0x4ae0));
memset(this + 0x130,0,0x4974);
/* try { // try from 0012d5f5 to 0012d5fc has its CatchHandler @ 0012d603 */
init_symbol_table(this);
return;
}
| |
22,915 | evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&) | corpus-core[P]colibri-stateless/build_O3/_deps/evmone_external-src/lib/evmone/advanced_instructions.cpp | const Instruction* op_sstore(const Instruction* instr, AdvancedExecutionState& state) noexcept
{
const auto gas_left_correction = state.current_block_cost - instr->arg.number;
state.gas_left += gas_left_correction;
const auto status = instr::impl<OP_SSTORE>(state);
if (status != EVMC_SUCCESS)
return state.exit(status);
if ((state.gas_left -= gas_left_correction) < 0)
return state.exit(EVMC_OUT_OF_GAS);
return ++instr;
} | O3 | cpp | evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*, evmone::advanced::AdvancedExecutionState&):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x230(%rsi), %r15d
subq 0x8(%rdi), %r15
movq 0x220(%rsi), %rsi
addq %r15, %rsi
movq %rsi, 0x220(%r14)
movq 0x228(%r14), %rdi
movq %r14, %rdx
callq 0x4b6f9
movq %rdx, 0x220(%r14)
addq $-0x40, 0x228(%r14)
testl %eax, %eax
je 0x4f386
movl %eax, 0x78(%r14)
xorl %ebx, %ebx
jmp 0x4f396
subq %r15, %rdx
movq %rdx, 0x220(%r14)
js 0x4f39f
addq $0x10, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, 0x78(%r14)
jmp 0x4f382
| _ZN6evmone8advanced12_GLOBAL__N_19op_sstoreEPKNS0_11InstructionERNS0_22AdvancedExecutionStateE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov r15d, [rsi+230h]
sub r15, [rdi+8]
mov rsi, [rsi+220h]
add rsi, r15
mov [r14+220h], rsi
mov rdi, [r14+228h]
mov rdx, r14
call _ZN6evmone5instr4core6sstoreENS_8StackTopElRNS_14ExecutionStateE; evmone::instr::core::sstore(evmone::StackTop,long,evmone::ExecutionState &)
mov [r14+220h], rdx
add qword ptr [r14+228h], 0FFFFFFFFFFFFFFC0h
test eax, eax
jz short loc_4F386
mov [r14+78h], eax
loc_4F382:
xor ebx, ebx
jmp short loc_4F396
loc_4F386:
sub rdx, r15
mov [r14+220h], rdx
js short loc_4F39F
add rbx, 10h
loc_4F396:
mov rax, rbx
pop rbx
pop r14
pop r15
retn
loc_4F39F:
mov dword ptr [r14+78h], 3
jmp short loc_4F382
| long long evmone::advanced::`anonymous namespace'::op_sstore(long long a1, long long a2)
{
long long v3; // r15
long long v4; // rsi
int v5; // eax
long long v6; // rdx
long long v8; // rdx
v3 = *(unsigned int *)(a2 + 560) - *(_QWORD *)(a1 + 8);
v4 = v3 + *(_QWORD *)(a2 + 544);
*(_QWORD *)(a2 + 544) = v4;
v5 = evmone::instr::core::sstore(*(const __m128i **)(a2 + 552), v4, a2);
*(_QWORD *)(a2 + 544) = v6;
*(_QWORD *)(a2 + 552) -= 64LL;
if ( v5 )
{
*(_DWORD *)(a2 + 120) = v5;
}
else
{
v8 = v6 - v3;
*(_QWORD *)(a2 + 544) = v8;
if ( v8 >= 0 )
return a1 + 16;
*(_DWORD *)(a2 + 120) = 3;
}
return 0LL;
}
| op_sstore:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV R15D,dword ptr [RSI + 0x230]
SUB R15,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI + 0x220]
ADD RSI,R15
MOV qword ptr [R14 + 0x220],RSI
MOV RDI,qword ptr [R14 + 0x228]
MOV RDX,R14
CALL 0x0014b6f9
MOV qword ptr [R14 + 0x220],RDX
ADD qword ptr [R14 + 0x228],-0x40
TEST EAX,EAX
JZ 0x0014f386
MOV dword ptr [R14 + 0x78],EAX
LAB_0014f382:
XOR EBX,EBX
JMP 0x0014f396
LAB_0014f386:
SUB RDX,R15
MOV qword ptr [R14 + 0x220],RDX
JS 0x0014f39f
ADD RBX,0x10
LAB_0014f396:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
LAB_0014f39f:
MOV dword ptr [R14 + 0x78],0x3
JMP 0x0014f382
|
/* evmone::advanced::(anonymous namespace)::op_sstore(evmone::advanced::Instruction const*,
evmone::advanced::AdvancedExecutionState&) */
Instruction *
evmone::advanced::(anonymous_namespace)::op_sstore
(Instruction *param_1,AdvancedExecutionState *param_2)
{
uint uVar1;
int iVar2;
long extraout_RDX;
long lVar3;
long lVar4;
uVar1 = *(uint *)(param_2 + 0x230);
lVar3 = *(long *)(param_1 + 8);
lVar4 = *(long *)(param_2 + 0x220) + ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar4;
iVar2 = instr::core::sstore(*(int8 *)(param_2 + 0x228),lVar4,param_2);
*(long *)(param_2 + 0x220) = extraout_RDX;
*(long *)(param_2 + 0x228) = *(long *)(param_2 + 0x228) + -0x40;
if (iVar2 == 0) {
lVar3 = extraout_RDX - ((ulong)uVar1 - lVar3);
*(long *)(param_2 + 0x220) = lVar3;
if (-1 < lVar3) {
return param_1 + 0x10;
}
*(int4 *)(param_2 + 0x78) = 3;
}
else {
*(int *)(param_2 + 0x78) = iVar2;
}
return (Instruction *)0x0;
}
| |
22,916 | my_get_err_msg | eloqsql/mysys/my_error.c | const char *my_get_err_msg(uint nr)
{
const char *format;
struct my_err_head *meh_p;
/* Search for the range this error is in. */
for (meh_p= my_errmsgs_list; meh_p; meh_p= meh_p->meh_next)
if (nr <= meh_p->meh_last)
break;
/*
If we found the range this error number is in, get the format string.
If the string is empty, or a NULL pointer, or if we're out of return,
we return NULL.
*/
if (!(format= (meh_p && (nr >= meh_p->meh_first)) ?
meh_p->get_errmsgs(nr)[nr - meh_p->meh_first] : NULL) ||
!*format)
return NULL;
return format;
} | O3 | c | my_get_err_msg:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x2f3408(%rip), %r14 # 0x3ae148
xorl %eax, %eax
movq (%r14), %r14
testq %r14, %r14
je 0xbad76
cmpl %ebx, 0x14(%r14)
jb 0xbad42
cmpl %ebx, 0x10(%r14)
ja 0xbad74
movl %ebx, %edi
callq *0x8(%r14)
subl 0x10(%r14), %ebx
movq (%rax,%rbx,8), %rcx
testq %rcx, %rcx
je 0xbad74
xorl %eax, %eax
cmpb $0x0, (%rcx)
cmovneq %rcx, %rax
jmp 0xbad76
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
| my_get_err_msg:
push rbp
mov rbp, rsp
push r14
push rbx
mov ebx, edi
lea r14, my_errmsgs_list
xor eax, eax
loc_BAD42:
mov r14, [r14]
test r14, r14
jz short loc_BAD76
cmp [r14+14h], ebx
jb short loc_BAD42
cmp [r14+10h], ebx
ja short loc_BAD74
mov edi, ebx
call qword ptr [r14+8]
sub ebx, [r14+10h]
mov rcx, [rax+rbx*8]
test rcx, rcx
jz short loc_BAD74
xor eax, eax
cmp byte ptr [rcx], 0
cmovnz rax, rcx
jmp short loc_BAD76
loc_BAD74:
xor eax, eax
loc_BAD76:
pop rbx
pop r14
pop rbp
retn
| _BYTE * my_get_err_msg(unsigned int a1)
{
long long **v1; // r14
_BYTE *result; // rax
_BYTE *v3; // rcx
v1 = &my_errmsgs_list;
result = 0LL;
while ( 1 )
{
v1 = (long long **)*v1;
if ( !v1 )
break;
if ( *((_DWORD *)v1 + 5) >= a1 )
{
if ( *((_DWORD *)v1 + 4) > a1 )
return 0LL;
v3 = *(_BYTE **)(((long long ( *)(_QWORD))v1[1])(a1) + 8LL * (a1 - *((_DWORD *)v1 + 4)));
if ( !v3 )
return 0LL;
result = 0LL;
if ( *v3 )
return v3;
return result;
}
}
return result;
}
| my_get_err_msg:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV EBX,EDI
LEA R14,[0x4ae148]
XOR EAX,EAX
LAB_001bad42:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x001bad76
CMP dword ptr [R14 + 0x14],EBX
JC 0x001bad42
CMP dword ptr [R14 + 0x10],EBX
JA 0x001bad74
MOV EDI,EBX
CALL qword ptr [R14 + 0x8]
SUB EBX,dword ptr [R14 + 0x10]
MOV RCX,qword ptr [RAX + RBX*0x8]
TEST RCX,RCX
JZ 0x001bad74
XOR EAX,EAX
CMP byte ptr [RCX],0x0
CMOVNZ RAX,RCX
JMP 0x001bad76
LAB_001bad74:
XOR EAX,EAX
LAB_001bad76:
POP RBX
POP R14
POP RBP
RET
|
char * my_get_err_msg(uint param_1)
{
char *pcVar1;
long lVar2;
int **ppuVar3;
ppuVar3 = &my_errmsgs_list;
do {
ppuVar3 = (int **)*ppuVar3;
if (ppuVar3 == (int **)0x0) {
return (char *)0x0;
}
} while (*(uint *)((long)ppuVar3 + 0x14) < param_1);
if (*(uint *)(ppuVar3 + 2) <= param_1) {
lVar2 = (*(code *)ppuVar3[1])(param_1);
pcVar1 = *(char **)(lVar2 + (ulong)(param_1 - *(int *)(ppuVar3 + 2)) * 8);
if (pcVar1 != (char *)0x0) {
if (*pcVar1 == '\0') {
return (char *)0x0;
}
return pcVar1;
}
}
return (char *)0x0;
}
| |
22,917 | stbiw__jpg_writeBits | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-image-write.h | static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) {
int bitBuf = *bitBufP, bitCnt = *bitCntP;
bitCnt += bs[1];
bitBuf |= bs[0] << (24 - bitCnt);
while(bitCnt >= 8) {
unsigned char c = (bitBuf >> 16) & 255;
stbiw__putc(s, c);
if(c == 255) {
stbiw__putc(s, 0);
}
bitBuf <<= 8;
bitCnt -= 8;
}
*bitBufP = bitBuf;
*bitCntP = bitCnt;
} | O1 | c | stbiw__jpg_writeBits:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzwl 0x2(%rcx), %ebx
movq %rdx, 0x10(%rsp)
addl (%rdx), %ebx
movq %rsi, %r14
movzwl (%rcx), %ebp
movb $0x18, %cl
subb %bl, %cl
shll %cl, %ebp
orl (%rsi), %ebp
cmpl $0x8, %ebx
jl 0x1b3c1
movq %rdi, %r15
leaq 0xe(%rsp), %r12
leaq 0xf(%rsp), %r13
movl %ebp, %eax
shrl $0x10, %eax
movb %al, 0xe(%rsp)
movq 0x8(%r15), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq *(%r15)
movl %ebp, %eax
notl %eax
testl $0xff0000, %eax # imm = 0xFF0000
jne 0x1b3b2
movb $0x0, 0xf(%rsp)
movq 0x8(%r15), %rdi
movq %r13, %rsi
movl $0x1, %edx
callq *(%r15)
shll $0x8, %ebp
leal -0x8(%rbx), %eax
cmpl $0xf, %ebx
movl %eax, %ebx
jg 0x1b37b
jmp 0x1b3c3
movl %ebx, %eax
movl %ebp, (%r14)
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| stbiw__jpg_writeBits:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
movzx ebx, word ptr [rcx+2]
mov [rsp+48h+var_38], rdx
add ebx, [rdx]
mov r14, rsi
movzx ebp, word ptr [rcx]
mov cl, 18h
sub cl, bl
shl ebp, cl
or ebp, [rsi]
cmp ebx, 8
jl short loc_1B3C1
mov r15, rdi
lea r12, [rsp+48h+var_3A]
lea r13, [rsp+48h+var_39]
loc_1B37B:
mov eax, ebp
shr eax, 10h
mov [rsp+48h+var_3A], al
mov rdi, [r15+8]
mov rsi, r12
mov edx, 1
call qword ptr [r15]
mov eax, ebp
not eax
test eax, 0FF0000h
jnz short loc_1B3B2
mov [rsp+48h+var_39], 0
mov rdi, [r15+8]
mov rsi, r13
mov edx, 1
call qword ptr [r15]
loc_1B3B2:
shl ebp, 8
lea eax, [rbx-8]
cmp ebx, 0Fh
mov ebx, eax
jg short loc_1B37B
jmp short loc_1B3C3
loc_1B3C1:
mov eax, ebx
loc_1B3C3:
mov [r14], ebp
mov rcx, [rsp+48h+var_38]
mov [rcx], eax
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long stbiw__jpg_writeBits(long long a1, int *a2, _DWORD *a3, unsigned __int16 *a4)
{
int v4; // ebx
int v5; // ebx
int v6; // ebp
long long result; // rax
bool v8; // cc
char v9; // [rsp+Eh] [rbp-3Ah] BYREF
char v10; // [rsp+Fh] [rbp-39h] BYREF
_DWORD *v11; // [rsp+10h] [rbp-38h]
v4 = a4[1];
v11 = a3;
v5 = *a3 + v4;
v6 = *a2 | (*a4 << (24 - v5));
if ( v5 < 8 )
{
result = (unsigned int)v5;
}
else
{
do
{
v9 = BYTE2(v6);
(*(void ( **)(_QWORD, char *, long long))a1)(*(_QWORD *)(a1 + 8), &v9, 1LL);
if ( (~v6 & 0xFF0000) == 0 )
{
v10 = 0;
(*(void ( **)(_QWORD, char *, long long))a1)(*(_QWORD *)(a1 + 8), &v10, 1LL);
}
v6 <<= 8;
result = (unsigned int)(v5 - 8);
v8 = v5 <= 15;
v5 -= 8;
}
while ( !v8 );
}
*a2 = v6;
*v11 = result;
return result;
}
| stbiw__jpg_writeBits:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOVZX EBX,word ptr [RCX + 0x2]
MOV qword ptr [RSP + 0x10],RDX
ADD EBX,dword ptr [RDX]
MOV R14,RSI
MOVZX EBP,word ptr [RCX]
MOV CL,0x18
SUB CL,BL
SHL EBP,CL
OR EBP,dword ptr [RSI]
CMP EBX,0x8
JL 0x0011b3c1
MOV R15,RDI
LEA R12,[RSP + 0xe]
LEA R13,[RSP + 0xf]
LAB_0011b37b:
MOV EAX,EBP
SHR EAX,0x10
MOV byte ptr [RSP + 0xe],AL
MOV RDI,qword ptr [R15 + 0x8]
MOV RSI,R12
MOV EDX,0x1
CALL qword ptr [R15]
MOV EAX,EBP
NOT EAX
TEST EAX,0xff0000
JNZ 0x0011b3b2
MOV byte ptr [RSP + 0xf],0x0
MOV RDI,qword ptr [R15 + 0x8]
MOV RSI,R13
MOV EDX,0x1
CALL qword ptr [R15]
LAB_0011b3b2:
SHL EBP,0x8
LEA EAX,[RBX + -0x8]
CMP EBX,0xf
MOV EBX,EAX
JG 0x0011b37b
JMP 0x0011b3c3
LAB_0011b3c1:
MOV EAX,EBX
LAB_0011b3c3:
MOV dword ptr [R14],EBP
MOV RCX,qword ptr [RSP + 0x10]
MOV dword ptr [RCX],EAX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
void stbiw__jpg_writeBits(int8 *param_1,uint *param_2,int *param_3,ushort *param_4)
{
bool bVar1;
int iVar2;
int iVar3;
uint uVar4;
int1 local_3a;
int1 local_39;
int *local_38;
iVar2 = (uint)param_4[1] + *param_3;
uVar4 = (uint)*param_4 << (0x18U - (char)iVar2 & 0x1f) | *param_2;
local_38 = param_3;
if (7 < iVar2) {
iVar3 = iVar2;
do {
local_3a = (int1)(uVar4 >> 0x10);
(*(code *)*param_1)(param_1[1],&local_3a,1);
if ((~uVar4 & 0xff0000) == 0) {
local_39 = 0;
(*(code *)*param_1)(param_1[1],&local_39,1);
}
uVar4 = uVar4 << 8;
iVar2 = iVar3 + -8;
bVar1 = 0xf < iVar3;
iVar3 = iVar2;
} while (bVar1);
}
*param_2 = uVar4;
*local_38 = iVar2;
return;
}
| |
22,918 | vemit_tap | eloqsql/unittest/mytap/tap.c | static void
vemit_tap(int pass, char const *fmt, va_list ap)
{
fprintf(tapout, "%sok %d%s",
pass ? "" : "not ",
++g_test.last,
(fmt && *fmt) ? " - " : "");
if (fmt && *fmt)
vfprintf(tapout, fmt, ap);
fflush(tapout);
} | O0 | c | vemit_tap:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq 0xe666(%rip), %rax # 0xffd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %edx
leaq 0xb82c(%rip), %rax # 0xd1a7
leaq 0xb7a9(%rip), %rcx # 0xd12b
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x28(%rbp)
movl 0x16309(%rip), %eax # 0x17c9c
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl %eax, 0x162fd(%rip) # 0x17c9c
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x19bb
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rdi
movb -0x19(%rbp), %sil
leaq 0xb75a(%rip), %r8 # 0xd12b
leaq 0xb7d4(%rip), %rax # 0xd1ac
testb $0x1, %sil
cmovneq %rax, %r8
leaq 0xb7b6(%rip), %rsi # 0xd19d
movb $0x0, %al
callq 0x1130
cmpq $0x0, -0x10(%rbp)
je 0x1a18
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1a18
movq 0xe5c8(%rip), %rax # 0xffd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1100
movq 0xe5b1(%rip), %rax # 0xffd0
movq (%rax), %rdi
callq 0x10b0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| vemit_tap:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, cs:stdout_ptr
mov rax, [rax]
mov [rbp+var_30], rax
mov edx, [rbp+var_4]
lea rax, aNot; "not "
lea rcx, a1D+6; ""
cmp edx, 0
cmovnz rax, rcx
mov [rbp+var_28], rax
mov eax, cs:dword_17C9C
add eax, 1
mov [rbp+var_20], eax
mov cs:dword_17C9C, eax
xor eax, eax
cmp [rbp+var_10], 0
mov [rbp+var_19], al
jz short loc_19BB
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
setnz al
mov [rbp+var_19], al
loc_19BB:
mov ecx, [rbp+var_20]
mov rdx, [rbp+var_28]
mov rdi, [rbp+var_30]
mov sil, [rbp+var_19]
lea r8, a1D+6; ""
lea rax, asc_D1AC; " - "
test sil, 1
cmovnz r8, rax
lea rsi, aSokDS; "%sok %d%s"
mov al, 0
call _fprintf
cmp [rbp+var_10], 0
jz short loc_1A18
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_1A18
mov rax, cs:stdout_ptr
mov rdi, [rax]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _vfprintf
loc_1A18:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
add rsp, 30h
pop rbp
retn
| long long vemit_tap(int a1, _BYTE *a2, long long a3)
{
const char *v3; // rax
const char *v4; // r8
int v6; // [rsp+10h] [rbp-20h]
bool v7; // [rsp+17h] [rbp-19h]
v3 = "not ";
if ( a1 )
v3 = "";
v6 = ++dword_17C9C;
v7 = 0;
if ( a2 )
v7 = *a2 != 0;
v4 = "";
if ( v7 )
v4 = " - ";
fprintf(stdout, "%sok %d%s", v3, v6, v4);
if ( a2 && *a2 )
vfprintf(stdout, a2, a3);
return fflush(stdout);
}
| vemit_tap:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [0x0010ffd0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV EDX,dword ptr [RBP + -0x4]
LEA RAX,[0x10d1a7]
LEA RCX,[0x10d12b]
CMP EDX,0x0
CMOVNZ RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOV EAX,dword ptr [0x00117c9c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [0x00117c9c],EAX
XOR EAX,EAX
CMP qword ptr [RBP + -0x10],0x0
MOV byte ptr [RBP + -0x19],AL
JZ 0x001019bb
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x19],AL
LAB_001019bb:
MOV ECX,dword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RBP + -0x30]
MOV SIL,byte ptr [RBP + -0x19]
LEA R8,[0x10d12b]
LEA RAX,[0x10d1ac]
TEST SIL,0x1
CMOVNZ R8,RAX
LEA RSI,[0x10d19d]
MOV AL,0x0
CALL 0x00101130
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00101a18
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x00101a18
MOV RAX,qword ptr [0x0010ffd0]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00101100
LAB_00101a18:
MOV RAX,qword ptr [0x0010ffd0]
MOV RDI,qword ptr [RAX]
CALL 0x001010b0
ADD RSP,0x30
POP RBP
RET
|
void vemit_tap(int param_1,char *param_2,__gnuc_va_list param_3)
{
int *puVar1;
int *puVar2;
bool bVar3;
puVar1 = &DAT_0010d1a7;
if (param_1 != 0) {
puVar1 = &DAT_0010d12b;
}
DAT_00117c9c = DAT_00117c9c + 1;
bVar3 = false;
if (param_2 != (char *)0x0) {
bVar3 = *param_2 != '\0';
}
puVar2 = &DAT_0010d12b;
if (bVar3) {
puVar2 = &DAT_0010d1ac;
}
fprintf(*(FILE **)PTR_stdout_0010ffd0,"%sok %d%s",puVar1,(ulong)DAT_00117c9c,puVar2);
if ((param_2 != (char *)0x0) && (*param_2 != '\0')) {
vfprintf(*(FILE **)PTR_stdout_0010ffd0,param_2,param_3);
}
fflush(*(FILE **)PTR_stdout_0010ffd0);
return;
}
| |
22,919 | my_large_free | eloqsql/mysys/my_largepage.c | void my_large_free(void *ptr, size_t size)
{
DBUG_ENTER("my_large_free");
/*
The following implementations can only fail if ptr was not allocated with
my_large_malloc(), i.e. my_malloc_lock() was used so we should free it
with my_free_lock()
For ASAN, we need to explicitly unpoison this memory region because the OS
may reuse that memory for some TLS or stack variable. It will remain
poisoned if it was explicitly poisioned before release. If this happens,
we'll have hard to debug false positives like in MDEV-21239.
For valgrind, we mark it as UNDEFINED rather than NOACCESS because of the
implict reuse possiblility.
*/
#if defined(HAVE_MMAP) && !defined(_WIN32)
if (munmap(ptr, size))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size, errno);
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#elif defined(_WIN32)
/*
When RELEASE memory, the size parameter must be 0.
Do not use MEM_RELEASE with MEM_DECOMMIT.
*/
if (ptr && !VirtualFree(ptr, 0, MEM_RELEASE))
{
my_error(EE_BADMEMORYRELEASE, MYF(ME_ERROR_LOG_ONLY), ptr, size,
GetLastError());
}
# if !__has_feature(memory_sanitizer)
else
{
MEM_MAKE_ADDRESSABLE(ptr, size);
}
# endif
#else
my_free_lock(ptr);
#endif
DBUG_VOID_RETURN;
} | O3 | c | my_large_free:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29220
testl %eax, %eax
je 0x76fbc
callq 0x29050
movl (%rax), %r8d
movl $0x80, %esi
movl $0x24, %edi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x6bbb7
popq %rbx
popq %r14
popq %rbp
retq
| my_large_free:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rsi
mov r14, rdi
call _munmap
test eax, eax
jz short loc_76FBC
call ___errno_location
mov r8d, [rax]
mov esi, 80h
mov edi, 24h ; '$'
mov rdx, r14
mov rcx, rbx
xor eax, eax
pop rbx
pop r14
pop rbp
jmp my_error
loc_76FBC:
pop rbx
pop r14
pop rbp
retn
| unsigned long long my_large_free(long long a1, long long a2)
{
unsigned long long result; // rax
unsigned int *v3; // rax
result = munmap(a1, a2);
if ( (_DWORD)result )
{
v3 = (unsigned int *)__errno_location(a1);
return my_error(0x24u, 128LL, a1, a2, *v3);
}
return result;
}
| my_large_free:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
CALL 0x00129220
TEST EAX,EAX
JZ 0x00176fbc
CALL 0x00129050
MOV R8D,dword ptr [RAX]
MOV ESI,0x80
MOV EDI,0x24
MOV RDX,R14
MOV RCX,RBX
XOR EAX,EAX
POP RBX
POP R14
POP RBP
JMP 0x0016bbb7
LAB_00176fbc:
POP RBX
POP R14
POP RBP
RET
|
void my_large_free(void *param_1,size_t param_2)
{
int iVar1;
int *piVar2;
iVar1 = munmap(param_1,param_2);
if (iVar1 != 0) {
piVar2 = __errno_location();
my_error(0x24,0x80,param_1,param_2,*piVar2);
return;
}
return;
}
| |
22,920 | 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>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | llama.cpp/common/json.hpp | reference operator[](typename object_t::key_type key)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
// operator[] only works for objects
if (JSON_HEDLEY_LIKELY(is_object()))
{
auto result = m_data.m_value.object->emplace(std::move(key), nullptr);
return set_parent(result.first->second);
}
JSON_THROW(type_error::create(305, detail::concat("cannot use operator[] with a string argument with ", type_name()), this));
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0xc8974
movb $0x1, (%r14)
movl $0x20, %edi
callq 0x21200
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x84776
movb (%r14), %al
cmpb $0x1, %al
jne 0xc89dd
movq 0x8(%r14), %r14
movq %rsp, %r15
movb $0x0, (%r15)
movq $0x0, 0x8(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x84776
movq %r15, %rdi
movl $0x1, %esi
callq 0x84776
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x8a488
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x84776
movq %r14, %rdi
callq 0x88e90
addq $0x20, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x21630
movq %rax, %rbx
movq %r14, %rdi
callq 0x89e28
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x58b33(%rip), %rsi # 0x121534
movq %rsp, %rdi
callq 0xbba28
movb $0x1, %bpl
movq %rsp, %rdx
movq %rbx, %rdi
movl $0x131, %esi # imm = 0x131
movq %r14, %rcx
callq 0x89c50
xorl %ebp, %ebp
leaq 0x9a608(%rip), %rsi # 0x163030
leaq -0x52d37(%rip), %rdx # 0x75cf8
movq %rbx, %rdi
callq 0x21a50
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x84776
movq %rbx, %rdi
callq 0x88e90
jmp 0xc8a81
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc8a6f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21170
testb %bpl, %bpl
jne 0xc8a79
jmp 0xc8a81
movq %rax, %r14
movq %rbx, %rdi
callq 0x21ef0
movq %r14, %rdi
callq 0x21af0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixES9_:
push rbp; void *
push r15; int
push r14; __int64
push rbx; int
sub rsp, 28h
mov rbx, rsi
mov r14, rdi
mov al, [rdi]
test al, al
jnz short loc_C8974
mov byte ptr [r14], 1
mov edi, 20h ; ' '; unsigned __int64
call __Znwm; operator new(ulong)
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
mov qword ptr [rax+10h], 0
mov [r14+8], rax
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 al, [r14]
loc_C8974:
cmp al, 1
jnz short loc_C89DD
mov r14, [r14+8]
mov r15, rsp
mov byte ptr [r15], 0
mov qword ptr [r15+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, 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, r14
mov rsi, rbx
mov rdx, r15
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE7emplaceERSH_OSD_; nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::emplace(std::string const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
mov rbx, rax
mov r14, rsp
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()
add rbx, 20h ; ' '
mov rax, rbx
add rsp, 28h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_C89DD:
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_28]
mov [rdx], rax
lea rsi, aCannotUseOpera_0; "cannot use operator[] with a string arg"...
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA51_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[51],char const*>(char const(&)[51],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, rbx; this
mov esi, 131h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rbx, rsp
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_C8A81
mov r14, rax
lea rax, [rsp+48h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_C8A6F
mov rsi, [rsp+48h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_C8A6F:
test bpl, bpl
jnz short loc_C8A79
jmp short loc_C8A81
mov r14, rax
loc_C8A79:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_C8A81:
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>::operator[](
long long a1,
long long *a2)
{
char v2; // al
long long v3; // rax
_QWORD *v4; // r14
long long v5; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
_QWORD v8[2]; // [rsp+0h] [rbp-48h] BYREF
const char *v9; // [rsp+20h] [rbp-28h] BYREF
v2 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
v3 = operator new(0x20uLL);
*(_OWORD *)v3 = 0LL;
*(_QWORD *)(v3 + 16) = 0LL;
*(_QWORD *)(a1 + 8) = 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>::assert_invariant((char *)a1);
v2 = *(_BYTE *)a1;
}
if ( v2 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9 = 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(&)[51],char const*>(
(long long)v8,
(long long)"cannot use operator[] with a string argument with ",
&v9);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
305,
v8);
__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);
}
v4 = *(_QWORD **)(a1 + 8);
LOBYTE(v8[0]) = 0;
v8[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 *)v8);
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 *)v8);
v5 = nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::emplace(
v4,
a2,
(long long)v8);
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 *)v8);
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(v8);
return v5 + 32;
}
| operator[]:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x28
MOV RBX,RSI
MOV R14,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x001c8974
MOV byte ptr [R14],0x1
MOV EDI,0x20
CALL 0x00121200
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],0x0
MOV qword ptr [R14 + 0x8],RAX
MOV RDI,R14
MOV ESI,0x1
CALL 0x00184776
MOV AL,byte ptr [R14]
LAB_001c8974:
CMP AL,0x1
JNZ 0x001c89dd
MOV R14,qword ptr [R14 + 0x8]
MOV R15,RSP
MOV byte ptr [R15],0x0
MOV qword ptr [R15 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x00184776
MOV RDI,R15
MOV ESI,0x1
CALL 0x00184776
LAB_001c89a5:
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R15
CALL 0x0018a488
LAB_001c89b3:
MOV RBX,RAX
MOV R14,RSP
MOV RDI,R14
XOR ESI,ESI
CALL 0x00184776
MOV RDI,R14
CALL 0x00188e90
ADD RBX,0x20
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001c89dd:
MOV EDI,0x20
CALL 0x00121630
MOV RBX,RAX
MOV RDI,R14
CALL 0x00189e28
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_001c89fa:
LEA RSI,[0x221534]
MOV RDI,RSP
CALL 0x001bba28
MOV BPL,0x1
LAB_001c8a0c:
MOV RDX,RSP
MOV RDI,RBX
MOV ESI,0x131
MOV RCX,R14
CALL 0x00189c50
XOR EBP,EBP
LEA RSI,[0x263030]
LEA RDX,[0x175cf8]
MOV RDI,RBX
CALL 0x00121a50
|
/* 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[](std::__cxx11::string) */
long __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>
::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,string *param_2)
{
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_00;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
int8 *puVar2;
long lVar3;
int8 uVar4;
bool bVar5;
basic_json local_48 [8];
int8 local_40;
char *local_28;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
puVar2 = (int8 *)operator_new(0x20);
*puVar2 = 0;
puVar2[1] = 0;
puVar2[2] = 0;
*(int8 **)(this + 8) = puVar2;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
this_00 = *(ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
local_48[0] = (basic_json)0x0;
local_40 = 0;
bVar5 = SUB81(local_48,0);
assert_invariant(bVar5);
assert_invariant(bVar5);
/* try { // try from 001c89a5 to 001c89b2 has its CatchHandler @ 001c8a37 */
lVar3 = ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::emplace(this_00,param_2,local_48);
assert_invariant(bVar5);
data::~data((data *)local_48);
return lVar3 + 0x20;
}
uVar4 = __cxa_allocate_exception(0x20);
local_28 = (char *)type_name(this);
/* try { // try from 001c89fa to 001c8a08 has its CatchHandler @ 001c8a76 */
detail::concat<std::__cxx11::string,char_const(&)[51],char_const*>
((detail *)local_48,"cannot use operator[] with a string argument with ",&local_28);
/* try { // try from 001c8a0c to 001c8a36 has its CatchHandler @ 001c8a51 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x131,local_48,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&detail::type_error::typeinfo,detail::exception::~exception);
}
| |
22,921 | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(unsigned char) | monkey531[P]llama/common/json.hpp | static std::string hex_bytes(std::uint8_t byte)
{
std::string result = "FF";
constexpr const char* nibble_to_hex = "0123456789ABCDEF";
result[0] = nibble_to_hex[byte / 16];
result[1] = nibble_to_hex[byte % 16];
return result;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(unsigned char):
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28a20(%rip), %rsi # 0xb174a
leaq 0x7(%rsp), %rdx
callq 0x28b3c
movl %ebx, %eax
shrl $0x4, %eax
leaq 0x2dcb9(%rip), %rcx # 0xb69f9
movb (%rax,%rcx), %al
movq (%r14), %rdx
movb %al, (%rdx)
andl $0xf, %ebx
movb (%rbx,%rcx), %al
movq (%r14), %rcx
movb %al, 0x1(%rcx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE9hex_bytesEh:
push r14
push rbx
push rax
mov ebx, esi
mov r14, rdi
lea rsi, aInvalidStringS_0+41h; "FF"
lea rdx, [rsp+18h+var_11]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov eax, ebx
shr eax, 4
lea rcx, a0123456789abcd; "0123456789ABCDEF"
mov al, [rax+rcx]
mov rdx, [r14]
mov [rdx], al
and ebx, 0Fh
mov al, [rbx+rcx]
mov rcx, [r14]
mov [rcx+1], al
mov rax, r14
add rsp, 8
pop rbx
pop r14
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::serializer<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>>::hex_bytes(
_QWORD *a1,
unsigned int a2)
{
std::string::basic_string<std::allocator<char>>(a1, (long long)"FF");
*(_BYTE *)*a1 = a0123456789abcd[a2 >> 4];
*(_BYTE *)(*a1 + 1LL) = a0123456789abcd[a2 & 0xF];
return a1;
}
| hex_bytes:
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ESI
MOV R14,RDI
LEA RSI,[0x1b174a]
LEA RDX,[RSP + 0x7]
CALL 0x00128b3c
MOV EAX,EBX
SHR EAX,0x4
LEA RCX,[0x1b69f9]
MOV AL,byte ptr [RAX + RCX*0x1]
MOV RDX,qword ptr [R14]
MOV byte ptr [RDX],AL
AND EBX,0xf
MOV AL,byte ptr [RBX + RCX*0x1]
MOV RCX,qword ptr [R14]
MOV byte ptr [RCX + 0x1],AL
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<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> >::hex_bytes(unsigned char) */
serializer<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>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<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>>
::hex_bytes(serializer<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,uchar param_1)
{
int7 in_register_00000031;
allocator local_11;
std::__cxx11::string::string<std::allocator<char>>((string *)this,"FF",&local_11);
**(char **)this = "0123456789ABCDEF"[(CONCAT71(in_register_00000031,param_1) & 0xffffffff) >> 4];
*(char *)(*(long *)this + 1) =
"0123456789ABCDEF"[(uint)CONCAT71(in_register_00000031,param_1) & 0xf];
return this;
}
| |
22,922 | minja::Parser::parseDictionary() | monkey531[P]llama/common/minja.hpp | std::shared_ptr<Expression> parseDictionary() {
if (consumeToken("{").empty()) return nullptr;
std::vector<std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>>> elements;
if (!consumeToken("}").empty()) {
return std::make_shared<DictExpr>(get_location(), std::move(elements));
}
auto parseKeyValuePair = [&]() {
auto key = parseExpression();
if (!key) throw std::runtime_error("Expected key in dictionary");
if (consumeToken(":").empty()) throw std::runtime_error("Expected colon betweek key & value in dictionary");
auto value = parseExpression();
if (!value) throw std::runtime_error("Expected value in dictionary");
elements.emplace_back(std::pair(std::move(key), std::move(value)));
};
parseKeyValuePair();
while (it != end) {
if (!consumeToken(",").empty()) {
parseKeyValuePair();
} else if (!consumeToken("}").empty()) {
return std::make_shared<DictExpr>(get_location(), std::move(elements));
} else {
throw std::runtime_error("Expected comma or closing brace in dictionary");
}
}
throw std::runtime_error("Expected closing brace");
} | O3 | cpp | minja::Parser::parseDictionary():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x64613(%rip), %rsi # 0xeea9d
leaq 0x6460d(%rip), %rdx # 0xeea9e
movq %rsp, %rdi
callq 0x21540
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x83112
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %rbx
cmpq %rax, %rdi
je 0x8a4cd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a4e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x8a5a2
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %rsp, %rdi
leaq 0x10(%rsp), %rax
movq %rax, (%rdi)
leaq 0x68d6b(%rip), %rsi # 0xf327f
leaq 0x68d65(%rip), %rdx # 0xf3280
callq 0x21540
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x83112
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rbx
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8a556
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a571
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
testq %rbx, %rbx
je 0x8a5ac
movq %r12, %r13
movq (%r14), %r12
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x8a700
movq 0x9f9f0(%rip), %rax # 0x129f80
cmpb $0x0, (%rax)
je 0x8a6fb
incl 0x8(%r15)
jmp 0x8a700
movups %xmm0, (%r12)
jmp 0x8a81e
movq %r12, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rdi)
callq 0x8d7cc
leaq 0x649c9(%rip), %r12 # 0xeef97
movq %rsp, %r13
leaq 0x20(%rsp), %rbp
leaq 0x68(%rsp), %rbx
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x8a830
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
leaq 0x6499a(%rip), %rsi # 0xeef96
movq %r12, %rdx
callq 0x21540
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
movl $0x1, %ecx
callq 0x83112
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %r15
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8a638
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a653
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
testq %r15, %r15
je 0x8a665
movq %rbx, %rdi
callq 0x8d7cc
jmp 0x8a5db
movq %rsp, %rdi
leaq 0x10(%rsp), %rax
movq %rax, (%rdi)
leaq 0x68c08(%rip), %rsi # 0xf327f
leaq 0x68c02(%rip), %rdx # 0xf3280
callq 0x21540
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
movl $0x1, %ecx
callq 0x83112
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rbx
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8a6b9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a890
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a6d4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
testq %rbx, %rbx
je 0x8a862
movq (%r14), %r12
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x8a75b
movq 0x9f890(%rip), %rax # 0x129f80
cmpb $0x0, (%rax)
je 0x8a756
incl 0x8(%r15)
jmp 0x8a75b
lock
incl 0x8(%r15)
movq 0x20(%r14), %rbx
subq 0x10(%r14), %rbx
movl $0x48, %edi
callq 0x1a870
leaq 0x9dedf(%rip), %rdx # 0x1285f8
addq $0x10, %rdx
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x9dc7d(%rip), %rsi # 0x1283a8
addq $0x10, %rsi
movabsq $0x100000001, %rdi # imm = 0x100000001
movq %rdi, 0x8(%rax)
movq %rdx, (%rax)
movq %rsi, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
testq %r15, %r15
movq %r13, %r12
jne 0x8a7b1
jmp 0x8a7c8
lock
incl 0x8(%r15)
movq 0x20(%r14), %rbx
subq 0x10(%r14), %rbx
movl $0x48, %edi
callq 0x1a870
leaq 0x9de84(%rip), %rdx # 0x1285f8
addq $0x10, %rdx
movq %rax, %rcx
addq $0x10, %rcx
leaq 0x9dc22(%rip), %rsi # 0x1283a8
addq $0x10, %rsi
movabsq $0x100000001, %rdi # imm = 0x100000001
movq %rdi, 0x8(%rax)
movq %rdx, (%rax)
movq %rsi, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
testq %r15, %r15
movq 0x60(%rsp), %r12
je 0x8a7c8
movq 0x9f7c8(%rip), %rdx # 0x129f80
cmpb $0x0, (%rdx)
je 0x8a7c3
incl 0x8(%r15)
jmp 0x8a7c8
lock
incl 0x8(%r15)
leaq 0x9de79(%rip), %rdx # 0x128648
addq $0x10, %rdx
movq %rbx, 0x28(%rax)
movq %rdx, 0x10(%rax)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x30(%rax)
movq 0x50(%rsp), %rdx
movq %rdx, 0x40(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq %rcx, (%r12)
movq %rax, 0x8(%r12)
testq %r15, %r15
je 0x8a814
movq %r15, %rdi
callq 0x6c8e8
leaq 0x40(%rsp), %rdi
callq 0x8da04
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x1a430
movq %rax, %r14
leaq 0x64886(%rip), %rsi # 0xef0ca
movq %rax, %rdi
callq 0x1a310
movq 0x9f795(%rip), %rsi # 0x129fe8
movq 0x9f6fe(%rip), %rdx # 0x129f58
movq %r14, %rdi
callq 0x1aea0
movl $0x10, %edi
callq 0x1a430
movq %rax, %r14
leaq 0x64826(%rip), %rsi # 0xef09c
movq %rax, %rdi
callq 0x1a310
jmp 0x8a84c
jmp 0x8a8c3
jmp 0x8a888
jmp 0x8a8e9
jmp 0x8a8d4
movq %rax, %rbx
testq %r15, %r15
je 0x8a8d7
movq %r15, %rdi
callq 0x6c8e8
jmp 0x8a8d7
jmp 0x8a8e9
jmp 0x8a8d4
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a8e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0x8a8e1
movq %rax, %rbx
jmp 0x8a8e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x1a640
jmp 0x8a8d7
jmp 0x8a8d4
jmp 0x8a8d4
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x8da04
movq %rbx, %rdi
callq 0x1af20
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8a8d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a890
jmp 0x8a8d7
nop
| _ZN5minja6Parser15parseDictionaryEv:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r14, rsi
mov r12, rdi
lea rax, [rsp+0A8h+var_98]
mov [rax-10h], rax
lea rsi, asc_EEA9D; "{"
lea rdx, asc_EEA9D+1; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0A8h+var_88]
mov rdx, rsp
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
lea rax, [rsp+0A8h+var_78]
mov rdi, [rax-10h]; void *
mov rbx, [rax-8]
cmp rdi, rax
jz short loc_8A4CD
mov rsi, [rsp+0A8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A4CD:
mov rdi, [rsp+0A8h+var_A8]; void *
lea rax, [rsp+0A8h+var_98]
cmp rdi, rax
jz short loc_8A4E8
mov rsi, [rsp+0A8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A4E8:
xorps xmm0, xmm0
test rbx, rbx
jz loc_8A5A2
movaps [rsp+0A8h+var_68], xmm0
mov [rsp+0A8h+var_58], 0
mov rdi, rsp
lea rax, [rsp+0A8h+var_98]
mov [rdi], rax
lea rsi, aT020+7; "}"
lea rdx, aT020+8; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0A8h+var_88]
mov rdx, rsp
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov rdi, [rsp+0A8h+var_88]; void *
mov rbx, [rsp+0A8h+var_80]
lea rax, [rsp+0A8h+var_78]
cmp rdi, rax
jz short loc_8A556
mov rsi, [rsp+0A8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A556:
mov rdi, [rsp+0A8h+var_A8]; void *
lea rax, [rsp+0A8h+var_98]
cmp rdi, rax
jz short loc_8A571
mov rsi, [rsp+0A8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A571:
test rbx, rbx
jz short loc_8A5AC
mov r13, r12
mov r12, [r14]
mov r15, [r14+8]
test r15, r15
jz loc_8A700
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz loc_8A6FB
inc dword ptr [r15+8]
jmp loc_8A700
loc_8A5A2:
movups xmmword ptr [r12], xmm0
jmp loc_8A81E
loc_8A5AC:
mov [rsp+0A8h+var_48], r12
lea rdi, [rsp+0A8h+var_40]
mov [rdi], r14
lea rax, [rsp+0A8h+var_68]
mov [rdi+8], rax
call _ZZN5minja6Parser15parseDictionaryEvENKUlvE_clEv; minja::Parser::parseDictionary(void)::{lambda(void)#1}::operator()(void)
lea r12, asc_EEF96+1; ""
mov r13, rsp
lea rbp, [rsp+0A8h+var_88]
lea rbx, [rsp+0A8h+var_40]
loc_8A5DB:
mov rax, [r14+20h]
cmp rax, [r14+18h]
jz loc_8A830
lea rax, [rsp+0A8h+var_98]
mov [rsp+0A8h+var_A8], rax
mov rdi, r13
lea rsi, asc_EEF96; ","
mov rdx, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rbp
mov rsi, r14
mov rdx, r13
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov rdi, [rsp+0A8h+var_88]; void *
mov r15, [rsp+0A8h+var_80]
lea rax, [rsp+0A8h+var_78]
cmp rdi, rax
jz short loc_8A638
mov rsi, [rsp+0A8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A638:
mov rdi, [rsp+0A8h+var_A8]; void *
lea rax, [rsp+0A8h+var_98]
cmp rdi, rax
jz short loc_8A653
mov rsi, [rsp+0A8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A653:
test r15, r15
jz short loc_8A665
mov rdi, rbx
call _ZZN5minja6Parser15parseDictionaryEvENKUlvE_clEv; minja::Parser::parseDictionary(void)::{lambda(void)#1}::operator()(void)
jmp loc_8A5DB
loc_8A665:
mov rdi, rsp
lea rax, [rsp+0A8h+var_98]
mov [rdi], rax
lea rsi, aT020+7; "}"
lea rdx, aT020+8; ""
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rdi, [rsp+0A8h+var_88]
mov rdx, rsp
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::string const&,minja::SpaceHandling)
mov rdi, [rsp+0A8h+var_88]; void *
mov rbx, [rsp+0A8h+var_80]
lea rax, [rsp+0A8h+var_78]
cmp rdi, rax
jz short loc_8A6B9
mov rsi, [rsp+0A8h+var_78]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A6B9:
mov rdi, [rsp+0A8h+var_A8]; void *
lea rax, [rsp+0A8h+var_98]
cmp rdi, rax
jz short loc_8A6D4
mov rsi, [rsp+0A8h+var_98]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_8A6D4:
test rbx, rbx
jz loc_8A862
mov r12, [r14]
mov r15, [r14+8]
test r15, r15
jz short loc_8A75B
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_8A756
inc dword ptr [r15+8]
jmp short loc_8A75B
loc_8A6FB:
lock inc dword ptr [r15+8]
loc_8A700:
mov rbx, [r14+20h]
sub rbx, [r14+10h]
mov edi, 48h ; 'H'; unsigned __int64
call __Znwm; operator new(ulong)
lea rdx, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja8DictExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::DictExpr,std::allocator<minja::DictExpr>,(__gnu_cxx::_Lock_policy)2>
add rdx, 10h
mov rcx, rax
add rcx, 10h
lea rsi, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rsi, 10h
mov rdi, 100000001h
mov [rax+8], rdi
mov [rax], rdx
mov [rax+10h], rsi
mov [rax+18h], r12
mov [rax+20h], r15
test r15, r15
mov r12, r13
jnz short loc_8A7B1
jmp short loc_8A7C8
loc_8A756:
lock inc dword ptr [r15+8]
loc_8A75B:
mov rbx, [r14+20h]
sub rbx, [r14+10h]
mov edi, 48h ; 'H'; unsigned __int64
call __Znwm; operator new(ulong)
lea rdx, _ZTVSt23_Sp_counted_ptr_inplaceIN5minja8DictExprESaIS1_ELN9__gnu_cxx12_Lock_policyE2EE; `vtable for'std::_Sp_counted_ptr_inplace<minja::DictExpr,std::allocator<minja::DictExpr>,(__gnu_cxx::_Lock_policy)2>
add rdx, 10h
mov rcx, rax
add rcx, 10h
lea rsi, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rsi, 10h
mov rdi, 100000001h
mov [rax+8], rdi
mov [rax], rdx
mov [rax+10h], rsi
mov [rax+18h], r12
mov [rax+20h], r15
test r15, r15
mov r12, [rsp+0A8h+var_48]
jz short loc_8A7C8
loc_8A7B1:
mov rdx, cs:__libc_single_threaded_ptr
cmp byte ptr [rdx], 0
jz short loc_8A7C3
inc dword ptr [r15+8]
jmp short loc_8A7C8
loc_8A7C3:
lock inc dword ptr [r15+8]
loc_8A7C8:
lea rdx, _ZTVN5minja8DictExprE; `vtable for'minja::DictExpr
add rdx, 10h
mov [rax+28h], rbx
mov [rax+10h], rdx
movaps xmm0, [rsp+0A8h+var_68]
movups xmmword ptr [rax+30h], xmm0
mov rdx, [rsp+0A8h+var_58]
mov [rax+40h], rdx
xorps xmm0, xmm0
movaps [rsp+0A8h+var_68], xmm0
mov [rsp+0A8h+var_58], 0
mov [r12], rcx
mov [r12+8], rax
test r15, r15
jz short loc_8A814
mov rdi, r15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_8A814:
lea rdi, [rsp+0A8h+var_68]
call _ZNSt6vectorISt4pairISt10shared_ptrIN5minja10ExpressionEES4_ESaIS5_EED2Ev; std::vector<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>>::~vector()
loc_8A81E:
mov rax, r12
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_8A830:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedClosin_5; "Expected closing brace"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_8A84C:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_8A862:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCommaO_0; "Expected comma or closing brace in dict"...
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_8A84C
jmp short loc_8A8C3
jmp short loc_8A888
jmp short loc_8A8E9
jmp short loc_8A8D4
loc_8A888:
mov rbx, rax
test r15, r15
jz short loc_8A8D7
mov rdi, r15
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_8A8D7
jmp short loc_8A8E9
jmp short loc_8A8D4
mov rbx, rax
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_8A8E1
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8A8E1
mov rbx, rax
jmp short loc_8A8E1
loc_8A8C3:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_8A8D7
jmp short loc_8A8D4
jmp short $+2
loc_8A8D4:
mov rbx, rax
loc_8A8D7:
lea rdi, [rsp+arg_38]
call _ZNSt6vectorISt4pairISt10shared_ptrIN5minja10ExpressionEES4_ESaIS5_EED2Ev; std::vector<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>>::~vector()
loc_8A8E1:
mov rdi, rbx
call __Unwind_Resume
loc_8A8E9:
mov rbx, rax
mov rdi, [rsp+0]; void *
lea rax, [rsp+arg_8]
cmp rdi, rax
jz short loc_8A8D7
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_8A8D7
| minja::Parser * minja::Parser::parseDictionary(minja::Parser *this, _QWORD *a2)
{
minja::Parser *v2; // r12
long long v3; // rbx
long long v4; // rbx
long long v5; // r12
volatile signed __int32 *v6; // r15
long long v7; // r15
long long v8; // rbx
long long v9; // r12
long long v10; // rbx
long long v11; // rax
long long v12; // rcx
std::runtime_error *exception; // r14
void *v15[2]; // [rsp+0h] [rbp-A8h] BYREF
_QWORD v16[2]; // [rsp+10h] [rbp-98h] BYREF
void *v17; // [rsp+20h] [rbp-88h] BYREF
long long v18; // [rsp+28h] [rbp-80h]
_QWORD v19[2]; // [rsp+30h] [rbp-78h] BYREF
__int128 v20; // [rsp+40h] [rbp-68h] BYREF
long long v21; // [rsp+50h] [rbp-58h]
minja::Parser *v22; // [rsp+60h] [rbp-48h]
_QWORD *v23; // [rsp+68h] [rbp-40h]
__int128 *v24; // [rsp+70h] [rbp-38h]
v2 = this;
v15[0] = v16;
std::string::_M_construct<char const*>((long long)v15, "{", (long long)"");
minja::Parser::consumeToken(&v17, (long long)a2, (_BYTE **)v15, 1u);
v3 = v18;
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( !v3 )
{
*(_OWORD *)this = 0LL;
return v2;
}
v20 = 0LL;
v21 = 0LL;
v15[0] = v16;
std::string::_M_construct<char const*>((long long)v15, "}", (long long)"");
minja::Parser::consumeToken(&v17, (long long)a2, (_BYTE **)v15, 1u);
v4 = v18;
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( v4 )
{
v5 = *a2;
v6 = (volatile signed __int32 *)a2[1];
if ( v6 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v6 + 2);
else
_InterlockedIncrement(v6 + 2);
}
v10 = a2[4] - a2[2];
v11 = operator new(0x48uLL);
v12 = v11 + 16;
*(_QWORD *)(v11 + 8) = 0x100000001LL;
*(_QWORD *)v11 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::DictExpr,std::allocator<minja::DictExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_QWORD *)(v11 + 16) = &`vtable for'minja::Expression + 2;
*(_QWORD *)(v11 + 24) = v5;
*(_QWORD *)(v11 + 32) = v6;
v2 = this;
if ( v6 )
goto LABEL_36;
goto LABEL_39;
}
v22 = this;
v23 = a2;
v24 = &v20;
minja::Parser::parseDictionary(void)::{lambda(void)#1}::operator()(0.0);
while ( 1 )
{
if ( a2[4] == a2[3] )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected closing brace");
goto LABEL_44;
}
v15[0] = v16;
std::string::_M_construct<char const*>((long long)v15, ",", (long long)"");
minja::Parser::consumeToken(&v17, (long long)a2, (_BYTE **)v15, 1u);
v7 = v18;
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( !v7 )
break;
minja::Parser::parseDictionary(void)::{lambda(void)#1}::operator()(0.0);
}
v15[0] = v16;
std::string::_M_construct<char const*>((long long)v15, "}", (long long)"");
minja::Parser::consumeToken(&v17, (long long)a2, (_BYTE **)v15, 1u);
v8 = v18;
if ( v17 != v19 )
operator delete(v17, v19[0] + 1LL);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( !v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected comma or closing brace in dictionary");
LABEL_44:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v9 = *a2;
v6 = (volatile signed __int32 *)a2[1];
if ( v6 )
{
if ( _libc_single_threaded )
++*((_DWORD *)v6 + 2);
else
_InterlockedIncrement(v6 + 2);
}
v10 = a2[4] - a2[2];
v11 = operator new(0x48uLL);
v12 = v11 + 16;
*(_QWORD *)(v11 + 8) = 0x100000001LL;
*(_QWORD *)v11 = &`vtable for'std::_Sp_counted_ptr_inplace<minja::DictExpr,std::allocator<minja::DictExpr>,(__gnu_cxx::_Lock_policy)2>
+ 2;
*(_QWORD *)(v11 + 16) = &`vtable for'minja::Expression + 2;
*(_QWORD *)(v11 + 24) = v9;
*(_QWORD *)(v11 + 32) = v6;
v2 = v22;
if ( v6 )
{
LABEL_36:
if ( _libc_single_threaded )
++*((_DWORD *)v6 + 2);
else
_InterlockedIncrement(v6 + 2);
}
LABEL_39:
*(_QWORD *)(v11 + 40) = v10;
*(_QWORD *)(v11 + 16) = &`vtable for'minja::DictExpr + 2;
*(_OWORD *)(v11 + 48) = v20;
*(_QWORD *)(v11 + 64) = v21;
v20 = 0LL;
v21 = 0LL;
*(_QWORD *)v2 = v12;
*((_QWORD *)v2 + 1) = v11;
if ( v6 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v6);
std::vector<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>>::~vector(&v20);
return v2;
}
| parseDictionary:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RSI
MOV R12,RDI
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + -0x10],RAX
LAB_0018a483:
LEA RSI,[0x1eea9d]
LEA RDX,[0x1eea9e]
MOV RDI,RSP
CALL 0x00121540
LAB_0018a499:
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
MOV RSI,R14
MOV ECX,0x1
CALL 0x00183112
LEA RAX,[RSP + 0x30]
MOV RDI,qword ptr [RAX + -0x10]
MOV RBX,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x0018a4cd
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a890
LAB_0018a4cd:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0018a4e8
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a890
LAB_0018a4e8:
XORPS XMM0,XMM0
TEST RBX,RBX
JZ 0x0018a5a2
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RDI],RAX
LAB_0018a50d:
LEA RSI,[0x1f327f]
LEA RDX,[0x1f3280]
CALL 0x00121540
LAB_0018a520:
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
MOV RSI,R14
MOV ECX,0x1
CALL 0x00183112
MOV RDI,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0018a556
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a890
LAB_0018a556:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0018a571
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a890
LAB_0018a571:
TEST RBX,RBX
JZ 0x0018a5ac
MOV R13,R12
MOV R12,qword ptr [R14]
MOV R15,qword ptr [R14 + 0x8]
TEST R15,R15
JZ 0x0018a700
MOV RAX,qword ptr [0x00229f80]
CMP byte ptr [RAX],0x0
JZ 0x0018a6fb
INC dword ptr [R15 + 0x8]
JMP 0x0018a700
LAB_0018a5a2:
MOVUPS xmmword ptr [R12],XMM0
JMP 0x0018a81e
LAB_0018a5ac:
MOV qword ptr [RSP + 0x60],R12
LEA RDI,[RSP + 0x68]
MOV qword ptr [RDI],R14
LEA RAX,[RSP + 0x40]
MOV qword ptr [RDI + 0x8],RAX
LAB_0018a5c2:
CALL 0x0018d7cc
LEA R12,[0x1eef97]
MOV R13,RSP
LEA RBP,[RSP + 0x20]
LEA RBX,[RSP + 0x68]
LAB_0018a5db:
MOV RAX,qword ptr [R14 + 0x20]
CMP RAX,qword ptr [R14 + 0x18]
JZ 0x0018a830
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LAB_0018a5f2:
MOV RDI,R13
LEA RSI,[0x1eef96]
MOV RDX,R12
CALL 0x00121540
LAB_0018a604:
MOV RDI,RBP
MOV RSI,R14
MOV RDX,R13
MOV ECX,0x1
CALL 0x00183112
MOV RDI,qword ptr [RSP + 0x20]
MOV R15,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0018a638
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a890
LAB_0018a638:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0018a653
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a890
LAB_0018a653:
TEST R15,R15
JZ 0x0018a665
LAB_0018a658:
MOV RDI,RBX
CALL 0x0018d7cc
JMP 0x0018a5db
LAB_0018a665:
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RDI],RAX
LAB_0018a670:
LEA RSI,[0x1f327f]
LEA RDX,[0x1f3280]
CALL 0x00121540
LAB_0018a683:
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
MOV RSI,R14
MOV ECX,0x1
CALL 0x00183112
MOV RDI,qword ptr [RSP + 0x20]
MOV RBX,qword ptr [RSP + 0x28]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0018a6b9
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x0011a890
LAB_0018a6b9:
MOV RDI,qword ptr [RSP]
LEA RAX,[RSP + 0x10]
CMP RDI,RAX
JZ 0x0018a6d4
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x0011a890
LAB_0018a6d4:
TEST RBX,RBX
JZ 0x0018a862
MOV R12,qword ptr [R14]
MOV R15,qword ptr [R14 + 0x8]
TEST R15,R15
JZ 0x0018a75b
MOV RAX,qword ptr [0x00229f80]
CMP byte ptr [RAX],0x0
JZ 0x0018a756
INC dword ptr [R15 + 0x8]
JMP 0x0018a75b
LAB_0018a6fb:
INC.LOCK dword ptr [R15 + 0x8]
LAB_0018a700:
MOV RBX,qword ptr [R14 + 0x20]
SUB RBX,qword ptr [R14 + 0x10]
LAB_0018a708:
MOV EDI,0x48
CALL 0x0011a870
LEA RDX,[0x2285f8]
ADD RDX,0x10
MOV RCX,RAX
ADD RCX,0x10
LEA RSI,[0x2283a8]
ADD RSI,0x10
MOV RDI,0x100000001
MOV qword ptr [RAX + 0x8],RDI
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],R12
MOV qword ptr [RAX + 0x20],R15
TEST R15,R15
MOV R12,R13
JNZ 0x0018a7b1
JMP 0x0018a7c8
LAB_0018a756:
INC.LOCK dword ptr [R15 + 0x8]
LAB_0018a75b:
MOV RBX,qword ptr [R14 + 0x20]
SUB RBX,qword ptr [R14 + 0x10]
LAB_0018a763:
MOV EDI,0x48
CALL 0x0011a870
LAB_0018a76d:
LEA RDX,[0x2285f8]
ADD RDX,0x10
MOV RCX,RAX
ADD RCX,0x10
LEA RSI,[0x2283a8]
ADD RSI,0x10
MOV RDI,0x100000001
MOV qword ptr [RAX + 0x8],RDI
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x10],RSI
MOV qword ptr [RAX + 0x18],R12
MOV qword ptr [RAX + 0x20],R15
TEST R15,R15
MOV R12,qword ptr [RSP + 0x60]
JZ 0x0018a7c8
LAB_0018a7b1:
MOV RDX,qword ptr [0x00229f80]
CMP byte ptr [RDX],0x0
JZ 0x0018a7c3
INC dword ptr [R15 + 0x8]
JMP 0x0018a7c8
LAB_0018a7c3:
INC.LOCK dword ptr [R15 + 0x8]
LAB_0018a7c8:
LEA RDX,[0x228648]
ADD RDX,0x10
MOV qword ptr [RAX + 0x28],RBX
MOV qword ptr [RAX + 0x10],RDX
MOVAPS XMM0,xmmword ptr [RSP + 0x40]
MOVUPS xmmword ptr [RAX + 0x30],XMM0
MOV RDX,qword ptr [RSP + 0x50]
MOV qword ptr [RAX + 0x40],RDX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x40],XMM0
MOV qword ptr [RSP + 0x50],0x0
MOV qword ptr [R12],RCX
MOV qword ptr [R12 + 0x8],RAX
TEST R15,R15
JZ 0x0018a814
MOV RDI,R15
CALL 0x0016c8e8
LAB_0018a814:
LEA RDI,[RSP + 0x40]
CALL 0x0018da04
LAB_0018a81e:
MOV RAX,R12
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0018a830:
MOV EDI,0x10
CALL 0x0011a430
MOV R14,RAX
LAB_0018a83d:
LEA RSI,[0x1ef0ca]
MOV RDI,RAX
CALL 0x0011a310
LAB_0018a84c:
MOV RSI,qword ptr [0x00229fe8]
MOV RDX,qword ptr [0x00229f58]
MOV RDI,R14
CALL 0x0011aea0
LAB_0018a862:
MOV EDI,0x10
CALL 0x0011a430
MOV R14,RAX
LAB_0018a86f:
LEA RSI,[0x1ef09c]
MOV RDI,RAX
CALL 0x0011a310
LAB_0018a87e:
JMP 0x0018a84c
|
/* minja::Parser::parseDictionary() */
int8 * minja::Parser::parseDictionary(void)
{
int8 uVar1;
int8 *puVar2;
runtime_error *this;
int8 *puVar3;
long lVar4;
int8 *in_RSI;
int8 *in_RDI;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
long *local_a8 [2];
long local_98 [2];
long *local_88;
long local_80;
long local_78 [2];
int8 local_68;
int8 uStack_60;
int8 local_58;
int8 *local_48;
_lambda___1_ local_40 [8];
int8 *local_38;
local_a8[0] = local_98;
/* try { // try from 0018a483 to 0018a498 has its CatchHandler @ 0018a8be */
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001eea9d,&DAT_001eea9e);
/* try { // try from 0018a499 to 0018a4ad has its CatchHandler @ 0018a89e */
consumeToken(&local_88);
lVar4 = local_80;
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (lVar4 == 0) {
*in_RDI = 0;
in_RDI[1] = 0;
}
else {
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
local_a8[0] = local_98;
/* try { // try from 0018a50d to 0018a51f has its CatchHandler @ 0018a89c */
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001f327f,&DAT_001f3280);
/* try { // try from 0018a520 to 0018a534 has its CatchHandler @ 0018a89a */
consumeToken(&local_88);
lVar4 = local_80;
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (lVar4 == 0) {
local_38 = &local_68;
local_48 = in_RDI;
/* try { // try from 0018a5c2 to 0018a5c6 has its CatchHandler @ 0018a8d0 */
parseDictionary()::{lambda()#1}::operator()(local_40);
do {
if (in_RSI[4] == in_RSI[3]) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018a83d to 0018a84b has its CatchHandler @ 0018a8c3 */
std::runtime_error::runtime_error(this,"Expected closing brace");
LAB_0018a84c:
/* try { // try from 0018a84c to 0018a861 has its CatchHandler @ 0018a8d0 */
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_00229fe8,PTR__runtime_error_00229f58);
}
local_a8[0] = local_98;
/* try { // try from 0018a5f2 to 0018a603 has its CatchHandler @ 0018a8d4 */
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001eef96,&DAT_001eef97);
/* try { // try from 0018a604 to 0018a616 has its CatchHandler @ 0018a8e9 */
consumeToken(&local_88);
lVar4 = local_80;
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (lVar4 == 0) {
local_a8[0] = local_98;
/* try { // try from 0018a670 to 0018a682 has its CatchHandler @ 0018a886 */
std::__cxx11::string::_M_construct<char_const*>(local_a8,&DAT_001f327f,&DAT_001f3280);
/* try { // try from 0018a683 to 0018a697 has its CatchHandler @ 0018a884 */
consumeToken(&local_88);
if (local_88 != local_78) {
operator_delete(local_88,local_78[0] + 1);
}
if (local_a8[0] != local_98) {
operator_delete(local_a8[0],local_98[0] + 1);
}
if (local_80 == 0) {
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0018a86f to 0018a87d has its CatchHandler @ 0018a880 */
std::runtime_error::runtime_error(this,"Expected comma or closing brace in dictionary");
goto LAB_0018a84c;
}
uVar1 = *in_RSI;
this_00 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
UNLOCK();
}
else {
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
}
}
lVar4 = in_RSI[4] - in_RSI[2];
/* try { // try from 0018a763 to 0018a76c has its CatchHandler @ 0018a882 */
puVar2 = (int8 *)operator_new(0x48);
puVar3 = puVar2 + 2;
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_00228608;
puVar2[2] = &PTR___cxa_pure_virtual_002283b8;
puVar2[3] = uVar1;
puVar2[4] = this_00;
in_RDI = local_48;
if (this_00 == (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) goto LAB_0018a7c8;
goto LAB_0018a7b1;
}
/* try { // try from 0018a658 to 0018a65f has its CatchHandler @ 0018a8d2 */
parseDictionary()::{lambda()#1}::operator()(local_40);
} while( true );
}
uVar1 = *in_RSI;
this_00 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)in_RSI[1];
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
UNLOCK();
}
else {
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
}
}
lVar4 = in_RSI[4] - in_RSI[2];
/* try { // try from 0018a708 to 0018a711 has its CatchHandler @ 0018a888 */
puVar2 = (int8 *)operator_new(0x48);
puVar3 = puVar2 + 2;
puVar2[1] = 0x100000001;
*puVar2 = &PTR___Sp_counted_ptr_inplace_00228608;
puVar2[2] = &PTR___cxa_pure_virtual_002283b8;
puVar2[3] = uVar1;
puVar2[4] = this_00;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
LAB_0018a7b1:
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
UNLOCK();
}
else {
*(int *)(this_00 + 8) = *(int *)(this_00 + 8) + 1;
}
}
LAB_0018a7c8:
puVar2[5] = lVar4;
puVar2[2] = &PTR_do_evaluate_00228658;
puVar2[6] = local_68;
puVar2[7] = uStack_60;
puVar2[8] = local_58;
local_68 = 0;
uStack_60 = 0;
local_58 = 0;
*in_RDI = puVar3;
in_RDI[1] = puVar2;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
std::
vector<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>>>
::~vector((vector<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>,std::allocator<std::pair<std::shared_ptr<minja::Expression>,std::shared_ptr<minja::Expression>>>>
*)&local_68);
}
return in_RDI;
}
| |
22,923 | my_xml_enter | eloqsql/strings/xml.c | static int my_xml_enter(MY_XML_PARSER *st, const char *str, size_t len)
{
if (my_xml_attr_ensure_space(st, len + 1 /* the separator char */))
return MY_XML_ERROR;
if (st->attr.end > st->attr.start)
{
st->attr.end[0]= '/';
st->attr.end++;
}
memcpy(st->attr.end, str, len);
st->attr.end+= len;
st->attr.end[0]= '\0';
if (st->flags & MY_XML_FLAG_RELATIVE_NAMES)
return st->enter ? st->enter(st, str, len) : MY_XML_OK;
else
return st->enter ?
st->enter(st, st->attr.start, st->attr.end - st->attr.start) : MY_XML_OK;
} | O3 | c | my_xml_enter:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x120(%rdi), %rdi
movq 0x110(%rbx), %rcx
movq 0x118(%rbx), %rax
movq %rdi, %r12
subq %rax, %r12
addq %r12, %rdx
addq $0x2, %rdx
cmpq %rcx, %rdx
jbe 0xd7d51
leaq 0x2(%r14), %rax
movq $-0x3, %rdx
subq %r14, %rdx
shrq %rdx
cmpq %rcx, %rdx
leaq (%rax,%rcx,2), %rax
movq $-0x1, %rdx
cmovaq %rax, %rdx
movq %rdx, 0x110(%rbx)
movq 0x108(%rbx), %rsi
xorl %edi, %edi
testq %rsi, %rsi
je 0xd7cff
xorl %ecx, %ecx
callq 0x9feac
movq %rax, 0x108(%rbx)
jmp 0xd7d34
movq %rdx, %rsi
xorl %edx, %edx
callq 0x9fd89
movq %rax, 0x108(%rbx)
testq %rax, %rax
je 0xd7dcf
leaq 0x88(%rbx), %rsi
leaq 0x1(%r12), %rdx
movq %rax, %rdi
callq 0x29080
movq 0x108(%rbx), %rax
movq %rax, 0x118(%rbx)
addq %rax, %r12
movq %r12, 0x120(%rbx)
movq %r12, %rdi
testq %rax, %rax
je 0xd7de1
cmpq %rax, %rdi
jbe 0xd7d6a
movb $0x2f, (%rdi)
movq 0x120(%rbx), %rdi
incq %rdi
movq %rdi, 0x120(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x29080
movq 0x120(%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, 0x120(%rbx)
movb $0x0, (%rax,%r14)
testb $0x1, (%rbx)
movq 0x148(%rbx), %rax
jne 0xd7db3
testq %rax, %rax
je 0xd7dcb
movq 0x118(%rbx), %rsi
movq 0x120(%rbx), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
jmp 0xd7dc1
testq %rax, %rax
je 0xd7dcb
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
xorl %eax, %eax
jmp 0xd7de6
movq $0x0, 0x118(%rbx)
movq %r12, 0x120(%rbx)
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_xml_enter:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov rdi, [rdi+120h]
mov rcx, [rbx+110h]
mov rax, [rbx+118h]
mov r12, rdi
sub r12, rax
add rdx, r12
add rdx, 2
cmp rdx, rcx
jbe loc_D7D51
lea rax, [r14+2]
mov rdx, 0FFFFFFFFFFFFFFFDh
sub rdx, r14
shr rdx, 1
cmp rdx, rcx
lea rax, [rax+rcx*2]
mov rdx, 0FFFFFFFFFFFFFFFFh
cmova rdx, rax
mov [rbx+110h], rdx
mov rsi, [rbx+108h]
xor edi, edi
test rsi, rsi
jz short loc_D7CFF
xor ecx, ecx
call my_realloc
mov [rbx+108h], rax
jmp short loc_D7D34
loc_D7CFF:
mov rsi, rdx
xor edx, edx
call my_malloc
mov [rbx+108h], rax
test rax, rax
jz loc_D7DCF
lea rsi, [rbx+88h]
lea rdx, [r12+1]
mov rdi, rax
call _memcpy
mov rax, [rbx+108h]
loc_D7D34:
mov [rbx+118h], rax
add r12, rax
mov [rbx+120h], r12
mov rdi, r12
test rax, rax
jz loc_D7DE1
loc_D7D51:
cmp rdi, rax
jbe short loc_D7D6A
mov byte ptr [rdi], 2Fh ; '/'
mov rdi, [rbx+120h]
inc rdi
mov [rbx+120h], rdi
loc_D7D6A:
mov rsi, r15
mov rdx, r14
call _memcpy
mov rax, [rbx+120h]
lea rcx, [rax+r14]
mov [rbx+120h], rcx
mov byte ptr [rax+r14], 0
test byte ptr [rbx], 1
mov rax, [rbx+148h]
jnz short loc_D7DB3
test rax, rax
jz short loc_D7DCB
mov rsi, [rbx+118h]
mov rdx, [rbx+120h]
sub rdx, rsi
mov rdi, rbx
jmp short loc_D7DC1
loc_D7DB3:
test rax, rax
jz short loc_D7DCB
mov rdi, rbx
mov rsi, r15
mov rdx, r14
loc_D7DC1:
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp rax
loc_D7DCB:
xor eax, eax
jmp short loc_D7DE6
loc_D7DCF:
mov qword ptr [rbx+118h], 0
mov [rbx+120h], r12
loc_D7DE1:
mov eax, 1
loc_D7DE6:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_xml_enter(long long a1, long long a2, long long a3)
{
_BYTE *v6; // rdi
unsigned long long v7; // rcx
unsigned long long v8; // rax
_BYTE *v9; // r12
bool v10; // cc
long long v11; // rdx
long long v12; // rsi
long long v13; // rax
_BYTE *v14; // r12
_BYTE *v15; // rcx
long long ( *v16)(long long, long long, long long); // rax
long long v17; // rsi
long long v18; // rdx
long long v19; // rdi
v6 = *(_BYTE **)(a1 + 288);
v7 = *(_QWORD *)(a1 + 272);
v8 = *(_QWORD *)(a1 + 280);
v9 = &v6[-v8];
if ( (unsigned long long)&v6[a3 - v8 + 2] > v7 )
{
v10 = (unsigned long long)(-3 - a3) >> 1 <= v7;
v11 = -1LL;
if ( !v10 )
v11 = a3 + 2 + 2 * v7;
*(_QWORD *)(a1 + 272) = v11;
v12 = *(_QWORD *)(a1 + 264);
if ( v12 )
{
v8 = my_realloc(0, v12, (const char *)v11, 0);
*(_QWORD *)(a1 + 264) = v8;
}
else
{
v13 = my_malloc(0, (const char *)v11, 0);
*(_QWORD *)(a1 + 264) = v13;
if ( !v13 )
{
*(_QWORD *)(a1 + 280) = 0LL;
*(_QWORD *)(a1 + 288) = v9;
return 1LL;
}
memcpy(v13, a1 + 136, v9 + 1);
v8 = *(_QWORD *)(a1 + 264);
}
*(_QWORD *)(a1 + 280) = v8;
v14 = &v9[v8];
*(_QWORD *)(a1 + 288) = v14;
v6 = v14;
if ( v8 )
goto LABEL_9;
return 1LL;
}
LABEL_9:
if ( (unsigned long long)v6 > v8 )
{
*v6 = 47;
v6 = (_BYTE *)(*(_QWORD *)(a1 + 288) + 1LL);
*(_QWORD *)(a1 + 288) = v6;
}
memcpy(v6, a2, a3);
v15 = (_BYTE *)(*(_QWORD *)(a1 + 288) + a3);
*(_QWORD *)(a1 + 288) = v15;
*v15 = 0;
v16 = *(long long ( **)(long long, long long, long long))(a1 + 328);
if ( (*(_BYTE *)a1 & 1) != 0 )
{
if ( v16 )
{
v19 = a1;
v17 = a2;
v18 = a3;
return v16(v19, v17, v18);
}
}
else if ( v16 )
{
v17 = *(_QWORD *)(a1 + 280);
v18 = *(_QWORD *)(a1 + 288) - v17;
v19 = a1;
return v16(v19, v17, v18);
}
return 0LL;
}
| my_xml_enter:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x120]
MOV RCX,qword ptr [RBX + 0x110]
MOV RAX,qword ptr [RBX + 0x118]
MOV R12,RDI
SUB R12,RAX
ADD RDX,R12
ADD RDX,0x2
CMP RDX,RCX
JBE 0x001d7d51
LEA RAX,[R14 + 0x2]
MOV RDX,-0x3
SUB RDX,R14
SHR RDX,0x1
CMP RDX,RCX
LEA RAX,[RAX + RCX*0x2]
MOV RDX,-0x1
CMOVA RDX,RAX
MOV qword ptr [RBX + 0x110],RDX
MOV RSI,qword ptr [RBX + 0x108]
XOR EDI,EDI
TEST RSI,RSI
JZ 0x001d7cff
XOR ECX,ECX
CALL 0x0019feac
MOV qword ptr [RBX + 0x108],RAX
JMP 0x001d7d34
LAB_001d7cff:
MOV RSI,RDX
XOR EDX,EDX
CALL 0x0019fd89
MOV qword ptr [RBX + 0x108],RAX
TEST RAX,RAX
JZ 0x001d7dcf
LEA RSI,[RBX + 0x88]
LEA RDX,[R12 + 0x1]
MOV RDI,RAX
CALL 0x00129080
MOV RAX,qword ptr [RBX + 0x108]
LAB_001d7d34:
MOV qword ptr [RBX + 0x118],RAX
ADD R12,RAX
MOV qword ptr [RBX + 0x120],R12
MOV RDI,R12
TEST RAX,RAX
JZ 0x001d7de1
LAB_001d7d51:
CMP RDI,RAX
JBE 0x001d7d6a
MOV byte ptr [RDI],0x2f
MOV RDI,qword ptr [RBX + 0x120]
INC RDI
MOV qword ptr [RBX + 0x120],RDI
LAB_001d7d6a:
MOV RSI,R15
MOV RDX,R14
CALL 0x00129080
MOV RAX,qword ptr [RBX + 0x120]
LEA RCX,[RAX + R14*0x1]
MOV qword ptr [RBX + 0x120],RCX
MOV byte ptr [RAX + R14*0x1],0x0
TEST byte ptr [RBX],0x1
MOV RAX,qword ptr [RBX + 0x148]
JNZ 0x001d7db3
TEST RAX,RAX
JZ 0x001d7dcb
MOV RSI,qword ptr [RBX + 0x118]
MOV RDX,qword ptr [RBX + 0x120]
SUB RDX,RSI
MOV RDI,RBX
JMP 0x001d7dc1
LAB_001d7db3:
TEST RAX,RAX
JZ 0x001d7dcb
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
LAB_001d7dc1:
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP RAX
LAB_001d7dcb:
XOR EAX,EAX
JMP 0x001d7de6
LAB_001d7dcf:
MOV qword ptr [RBX + 0x118],0x0
MOV qword ptr [RBX + 0x120],R12
LAB_001d7de1:
MOV EAX,0x1
LAB_001d7de6:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int8 my_xml_enter(byte *param_1,void *param_2,size_t param_3)
{
ulong uVar1;
code *UNRECOVERED_JUMPTABLE;
int1 *puVar2;
void *__dest;
int8 uVar3;
long lVar4;
long lVar5;
int1 *__dest_00;
__dest_00 = *(int1 **)(param_1 + 0x120);
uVar1 = *(ulong *)(param_1 + 0x110);
puVar2 = *(int1 **)(param_1 + 0x118);
lVar5 = (long)__dest_00 - (long)puVar2;
if (uVar1 < param_3 + lVar5 + 2) {
lVar4 = -1;
if (uVar1 < -param_3 - 3 >> 1) {
lVar4 = param_3 + 2 + uVar1 * 2;
}
*(long *)(param_1 + 0x110) = lVar4;
if (*(long *)(param_1 + 0x108) == 0) {
__dest = (void *)my_malloc(0,lVar4,0);
*(void **)(param_1 + 0x108) = __dest;
if (__dest != (void *)0x0) {
memcpy(__dest,param_1 + 0x88,lVar5 + 1);
puVar2 = *(int1 **)(param_1 + 0x108);
goto LAB_001d7d34;
}
param_1[0x118] = 0;
param_1[0x119] = 0;
param_1[0x11a] = 0;
param_1[0x11b] = 0;
param_1[0x11c] = 0;
param_1[0x11d] = 0;
param_1[0x11e] = 0;
param_1[0x11f] = 0;
*(long *)(param_1 + 0x120) = lVar5;
}
else {
puVar2 = (int1 *)my_realloc();
*(int1 **)(param_1 + 0x108) = puVar2;
LAB_001d7d34:
*(int1 **)(param_1 + 0x118) = puVar2;
__dest_00 = puVar2 + lVar5;
*(int1 **)(param_1 + 0x120) = __dest_00;
if (puVar2 != (int1 *)0x0) goto LAB_001d7d51;
}
uVar3 = 1;
}
else {
LAB_001d7d51:
if (puVar2 < __dest_00) {
*__dest_00 = 0x2f;
__dest_00 = (int1 *)(*(long *)(param_1 + 0x120) + 1);
*(int1 **)(param_1 + 0x120) = __dest_00;
}
memcpy(__dest_00,param_2,param_3);
lVar5 = *(long *)(param_1 + 0x120);
*(size_t *)(param_1 + 0x120) = lVar5 + param_3;
*(int1 *)(lVar5 + param_3) = 0;
UNRECOVERED_JUMPTABLE = *(code **)(param_1 + 0x148);
if ((*param_1 & 1) == 0) {
if (UNRECOVERED_JUMPTABLE != (code *)0x0) {
param_2 = *(void **)(param_1 + 0x118);
param_3 = *(long *)(param_1 + 0x120) - (long)param_2;
LAB_001d7dc1:
/* WARNING: Could not recover jumptable at 0x001d7dc9. Too many branches */
/* WARNING: Treating indirect jump as call */
uVar3 = (*UNRECOVERED_JUMPTABLE)(param_1,param_2,param_3);
return uVar3;
}
}
else if (UNRECOVERED_JUMPTABLE != (code *)0x0) goto LAB_001d7dc1;
uVar3 = 0;
}
return uVar3;
}
| |
22,924 | lshift | eloqsql/strings/dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O0 | c | lshift:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %eax
sarl $0x5, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x7278b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
jmp 0x72770
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x72000
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x727d5
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl $0x0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x727ad
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x72874
movl $0x20, %eax
subl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl -0xc(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
orl -0x4c(%rbp), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %eax
movl -0x20(%rbp), %ecx
shrl %cl, %eax
movl %eax, -0x4c(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x72817
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
cmpl $0x0, %eax
je 0x72872
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x728a4
jmp 0x72876
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x38(%rbp)
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x40(%rbp)
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
cmpq -0x48(%rbp), %rax
jb 0x72876
jmp 0x728a4
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x726b0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| lshift:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov eax, [rbp+var_C]
sar eax, 5
mov [rbp+var_24], eax
mov rax, [rbp+var_8]
mov eax, [rax+8]
mov [rbp+var_20], eax
mov eax, [rbp+var_24]
mov rcx, [rbp+var_8]
add eax, [rcx+14h]
add eax, 1
mov [rbp+var_28], eax
mov rax, [rbp+var_8]
mov eax, [rax+0Ch]
mov [rbp+var_1C], eax
loc_72770:
mov eax, [rbp+var_28]
cmp eax, [rbp+var_1C]
jle short loc_7278B
mov eax, [rbp+var_20]
add eax, 1
mov [rbp+var_20], eax
mov eax, [rbp+var_1C]
shl eax, 1
mov [rbp+var_1C], eax
jmp short loc_72770
loc_7278B:
mov edi, [rbp+var_20]
mov rsi, [rbp+var_18]
call Balloc
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov rax, [rax]
mov [rbp+var_40], rax
mov [rbp+var_1C], 0
loc_727AD:
mov eax, [rbp+var_1C]
cmp eax, [rbp+var_24]
jge short loc_727D5
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 4
mov [rbp+var_40], rcx
mov dword ptr [rax], 0
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_727AD
loc_727D5:
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov rcx, [rbp+var_8]
movsxd rcx, dword ptr [rcx+14h]
shl rcx, 2
add rax, rcx
mov [rbp+var_48], rax
mov eax, [rbp+var_C]
and eax, 1Fh
mov [rbp+var_C], eax
cmp eax, 0
jz short loc_72874
mov eax, 20h ; ' '
sub eax, [rbp+var_C]
mov [rbp+var_20], eax
mov [rbp+var_4C], 0
loc_72817:
mov rax, [rbp+var_38]
mov eax, [rax]
mov ecx, [rbp+var_C]
shl eax, cl
mov ecx, eax
or ecx, [rbp+var_4C]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov eax, [rax]
mov ecx, [rbp+var_20]
shr eax, cl
mov [rbp+var_4C], eax
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_72817
mov eax, [rbp+var_4C]
mov rcx, [rbp+var_40]
mov [rcx], eax
cmp eax, 0
jz short loc_72872
mov eax, [rbp+var_28]
add eax, 1
mov [rbp+var_28], eax
loc_72872:
jmp short loc_728A4
loc_72874:
jmp short $+2
loc_72876:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 4
mov [rbp+var_38], rcx
mov ecx, [rax]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 4
mov [rbp+var_40], rdx
mov [rax], ecx
mov rax, [rbp+var_38]
cmp rax, [rbp+var_48]
jb short loc_72876
jmp short $+2
loc_728A4:
mov ecx, [rbp+var_28]
sub ecx, 1
mov rax, [rbp+var_30]
mov [rax+14h], ecx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_18]
call Bfree
mov rax, [rbp+var_30]
add rsp, 50h
pop rbp
retn
| long long lshift(unsigned long long a1, int a2, unsigned long long *a3)
{
int *v3; // rax
int *v4; // rax
int *v5; // rax
int *v6; // rax
int v7; // ecx
int *v8; // rax
int v10; // [rsp+4h] [rbp-4Ch]
unsigned long long v11; // [rsp+8h] [rbp-48h]
int *v12; // [rsp+10h] [rbp-40h]
int *v13; // [rsp+18h] [rbp-38h]
long long v14; // [rsp+20h] [rbp-30h]
int v15; // [rsp+28h] [rbp-28h]
int v16; // [rsp+30h] [rbp-20h]
int i; // [rsp+34h] [rbp-1Ch]
int j; // [rsp+34h] [rbp-1Ch]
char v20; // [rsp+44h] [rbp-Ch]
v16 = *(_DWORD *)(a1 + 8);
v15 = *(_DWORD *)(a1 + 20) + (a2 >> 5) + 1;
for ( i = *(_DWORD *)(a1 + 12); v15 > i; i *= 2 )
++v16;
v14 = Balloc(v16, (long long)a3);
v12 = *(int **)v14;
for ( j = 0; j < a2 >> 5; ++j )
{
v3 = v12++;
*v3 = 0;
}
v13 = *(int **)a1;
v11 = 4LL * *(int *)(a1 + 20) + *(_QWORD *)a1;
v20 = a2 & 0x1F;
if ( (a2 & 0x1F) != 0 )
{
v10 = 0;
do
{
v4 = v12++;
*v4 = v10 | (*v13 << v20);
v5 = v13++;
v10 = (unsigned int)*v5 >> (32 - v20);
}
while ( (unsigned long long)v13 < v11 );
*v12 = v10;
if ( v10 )
++v15;
}
else
{
do
{
v6 = v13++;
v7 = *v6;
v8 = v12++;
*v8 = v7;
}
while ( (unsigned long long)v13 < v11 );
}
*(_DWORD *)(v14 + 20) = v15 - 1;
Bfree(a1, a3);
return v14;
}
| lshift:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV EAX,dword ptr [RBP + -0xc]
SAR EAX,0x5
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x8]
ADD EAX,dword ptr [RCX + 0x14]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00172770:
MOV EAX,dword ptr [RBP + -0x28]
CMP EAX,dword ptr [RBP + -0x1c]
JLE 0x0017278b
MOV EAX,dword ptr [RBP + -0x20]
ADD EAX,0x1
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x1c]
SHL EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x00172770
LAB_0017278b:
MOV EDI,dword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x00172000
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x1c],0x0
LAB_001727ad:
MOV EAX,dword ptr [RBP + -0x1c]
CMP EAX,dword ptr [RBP + -0x24]
JGE 0x001727d5
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x40],RCX
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x001727ad
LAB_001727d5:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x8]
MOVSXD RCX,dword ptr [RCX + 0x14]
SHL RCX,0x2
ADD RAX,RCX
MOV qword ptr [RBP + -0x48],RAX
MOV EAX,dword ptr [RBP + -0xc]
AND EAX,0x1f
MOV dword ptr [RBP + -0xc],EAX
CMP EAX,0x0
JZ 0x00172874
MOV EAX,0x20
SUB EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x20],EAX
MOV dword ptr [RBP + -0x4c],0x0
LAB_00172817:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0xc]
SHL EAX,CL
MOV ECX,EAX
OR ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV EAX,dword ptr [RAX]
MOV ECX,dword ptr [RBP + -0x20]
SHR EAX,CL
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00172817
MOV EAX,dword ptr [RBP + -0x4c]
MOV RCX,qword ptr [RBP + -0x40]
MOV dword ptr [RCX],EAX
CMP EAX,0x0
JZ 0x00172872
MOV EAX,dword ptr [RBP + -0x28]
ADD EAX,0x1
MOV dword ptr [RBP + -0x28],EAX
LAB_00172872:
JMP 0x001728a4
LAB_00172874:
JMP 0x00172876
LAB_00172876:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x38],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x40],RDX
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x48]
JC 0x00172876
JMP 0x001728a4
LAB_001728a4:
MOV ECX,dword ptr [RBP + -0x28]
SUB ECX,0x1
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX + 0x14],ECX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x001726b0
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x50
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
sbyte sVar1;
int iVar2;
int8 *puVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint local_54;
uint *local_48;
uint *local_40;
int local_30;
int local_28;
int local_24;
local_28 = *(int *)(param_1 + 1);
iVar2 = ((int)param_2 >> 5) + *(int *)((long)param_1 + 0x14);
local_30 = iVar2 + 1;
for (local_24 = *(int *)((long)param_1 + 0xc); local_24 < local_30; local_24 = local_24 << 1) {
local_28 = local_28 + 1;
}
puVar3 = (int8 *)Balloc(local_28,param_3);
local_48 = (uint *)*puVar3;
for (local_24 = 0; local_24 < (int)param_2 >> 5; local_24 = local_24 + 1) {
*local_48 = 0;
local_48 = local_48 + 1;
}
local_40 = (uint *)*param_1;
puVar4 = local_40 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
puVar5 = local_40 + 1;
*local_48 = *local_40;
local_48 = local_48 + 1;
local_40 = puVar5;
} while (puVar5 < puVar4);
}
else {
sVar1 = (sbyte)(param_2 & 0x1f);
local_54 = 0;
do {
puVar6 = local_48 + 1;
*local_48 = *local_40 << sVar1 | local_54;
puVar5 = local_40 + 1;
local_54 = *local_40 >> (0x20U - sVar1 & 0x1f);
local_48 = puVar6;
local_40 = puVar5;
} while (puVar5 < puVar4);
*puVar6 = local_54;
if (local_54 != 0) {
local_30 = iVar2 + 2;
}
}
*(int *)((long)puVar3 + 0x14) = local_30 + -1;
Bfree(param_1,param_3);
return puVar3;
}
| |
22,925 | lshift | eloqsql/strings/dtoa.c | static Bigint *lshift(Bigint *b, int k, Stack_alloc *alloc)
{
int i, k1, n, n1;
Bigint *b1;
ULong *x, *x1, *xe, z;
n= k >> 5;
k1= b->k;
n1= n + b->wds + 1;
for (i= b->maxwds; n1 > i; i<<= 1)
k1++;
b1= Balloc(k1, alloc);
x1= b1->p.x;
for (i= 0; i < n; i++)
*x1++= 0;
x= b->p.x;
xe= x + b->wds;
if (k&= 0x1f)
{
k1= 32 - k;
z= 0;
do
{
*x1++= *x << k | z;
z= *x++ >> k1;
}
while (x < xe);
if ((*x1= z))
++n1;
}
else
do
*x1++= *x++;
while (x < xe);
b1->wds= n1 - 1;
Bfree(b, alloc);
return b1;
} | O3 | c | lshift:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %r14
movl %esi, %r12d
shrl $0x5, %r12d
movl 0x8(%rdi), %edi
movl 0xc(%r14), %eax
movl 0x14(%r14), %ebx
addl %r12d, %ebx
cmpl %eax, %ebx
jl 0x5826d
incl %edi
addl %eax, %eax
jmp 0x58263
movq %rdx, -0x38(%rbp)
movq %rdx, %rsi
callq 0x57e10
movq (%rax), %r13
cmpl $0x20, %r15d
jb 0x582a4
decl %r12d
leaq 0x4(,%r12,4), %rdx
movq %r13, %rdi
xorl %esi, %esi
movq %rax, -0x30(%rbp)
callq 0x24190
movq -0x30(%rbp), %rax
leaq 0x4(%r13,%r12,4), %r13
movq (%r14), %rdx
movslq 0x14(%r14), %rcx
leaq (%rdx,%rcx,4), %rsi
andl $0x1f, %r15d
je 0x582f0
movl $0x20, %r9d
subl %r15d, %r9d
xorl %edi, %edi
movl (%rdx), %r8d
movl %r15d, %ecx
shll %cl, %r8d
orl %edi, %r8d
movl %r8d, (%r13)
addq $0x4, %r13
movl (%rdx), %edi
addq $0x4, %rdx
movl %r9d, %ecx
shrl %cl, %edi
cmpq %rsi, %rdx
jb 0x582c0
movl %edi, (%r13)
cmpl $0x1, %edi
sbbl $-0x1, %ebx
jmp 0x58303
movl (%rdx), %ecx
addq $0x4, %rdx
movl %ecx, (%r13)
addq $0x4, %r13
cmpq %rsi, %rdx
jb 0x582f0
movl %ebx, 0x14(%rax)
movq %r14, %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rbx
callq 0x58209
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| lshift:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, esi
mov r14, rdi
mov r12d, esi
shr r12d, 5
mov edi, [rdi+8]
mov eax, [r14+0Ch]
mov ebx, [r14+14h]
add ebx, r12d
loc_58263:
cmp ebx, eax
jl short loc_5826D
inc edi
add eax, eax
jmp short loc_58263
loc_5826D:
mov [rbp+var_38], rdx
mov rsi, rdx
call Balloc
mov r13, [rax]
cmp r15d, 20h ; ' '
jb short loc_582A4
dec r12d
lea rdx, ds:4[r12*4]
mov rdi, r13
xor esi, esi
mov [rbp+var_30], rax
call _memset
mov rax, [rbp+var_30]
lea r13, [r13+r12*4+4]
loc_582A4:
mov rdx, [r14]
movsxd rcx, dword ptr [r14+14h]
lea rsi, [rdx+rcx*4]
and r15d, 1Fh
jz short loc_582F0
mov r9d, 20h ; ' '
sub r9d, r15d
xor edi, edi
loc_582C0:
mov r8d, [rdx]
mov ecx, r15d
shl r8d, cl
or r8d, edi
mov [r13+0], r8d
add r13, 4
mov edi, [rdx]
add rdx, 4
mov ecx, r9d
shr edi, cl
cmp rdx, rsi
jb short loc_582C0
mov [r13+0], edi
cmp edi, 1
sbb ebx, 0FFFFFFFFh
jmp short loc_58303
loc_582F0:
mov ecx, [rdx]
add rdx, 4
mov [r13+0], ecx
add r13, 4
cmp rdx, rsi
jb short loc_582F0
loc_58303:
mov [rax+14h], ebx
mov rdi, r14
mov rsi, [rbp+var_38]
mov rbx, rax
call Bfree
mov rax, rbx
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long lshift(unsigned long long a1, unsigned int a2, unsigned long long *a3)
{
char v3; // r15
int v5; // edi
int v6; // eax
int v7; // ebx
long long v8; // rax
int *v9; // r13
long long v10; // r12
int *v11; // rdx
unsigned long long v12; // rsi
int v13; // r15d
int v14; // edi
unsigned int v15; // edi
int v16; // ecx
long long v17; // rbx
long long v20; // [rsp+10h] [rbp-30h]
v3 = a2;
v5 = *(_DWORD *)(a1 + 8);
v6 = *(_DWORD *)(a1 + 12);
v7 = (a2 >> 5) + *(_DWORD *)(a1 + 20);
while ( v7 >= v6 )
{
++v5;
v6 *= 2;
}
v8 = Balloc(v5, (long long)a3);
v9 = *(int **)v8;
if ( a2 >= 0x20 )
{
v10 = (a2 >> 5) - 1;
v20 = v8;
memset(*(_QWORD *)v8, 0LL, 4 * v10 + 4);
v8 = v20;
v9 += v10 + 1;
}
v11 = *(int **)a1;
v12 = *(_QWORD *)a1 + 4LL * *(int *)(a1 + 20);
v13 = v3 & 0x1F;
if ( v13 )
{
v14 = 0;
do
{
*v9++ = v14 | (*v11 << v13);
v15 = *v11++;
v14 = v15 >> (32 - v13);
}
while ( (unsigned long long)v11 < v12 );
*v9 = v14;
v7 -= (v14 == 0) - 1;
}
else
{
do
{
v16 = *v11++;
*v9++ = v16;
}
while ( (unsigned long long)v11 < v12 );
}
*(_DWORD *)(v8 + 20) = v7;
v17 = v8;
Bfree(a1, a3);
return v17;
}
| lshift:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,ESI
MOV R14,RDI
MOV R12D,ESI
SHR R12D,0x5
MOV EDI,dword ptr [RDI + 0x8]
MOV EAX,dword ptr [R14 + 0xc]
MOV EBX,dword ptr [R14 + 0x14]
ADD EBX,R12D
LAB_00158263:
CMP EBX,EAX
JL 0x0015826d
INC EDI
ADD EAX,EAX
JMP 0x00158263
LAB_0015826d:
MOV qword ptr [RBP + -0x38],RDX
MOV RSI,RDX
CALL 0x00157e10
MOV R13,qword ptr [RAX]
CMP R15D,0x20
JC 0x001582a4
DEC R12D
LEA RDX,[0x4 + R12*0x4]
MOV RDI,R13
XOR ESI,ESI
MOV qword ptr [RBP + -0x30],RAX
CALL 0x00124190
MOV RAX,qword ptr [RBP + -0x30]
LEA R13,[R13 + R12*0x4 + 0x4]
LAB_001582a4:
MOV RDX,qword ptr [R14]
MOVSXD RCX,dword ptr [R14 + 0x14]
LEA RSI,[RDX + RCX*0x4]
AND R15D,0x1f
JZ 0x001582f0
MOV R9D,0x20
SUB R9D,R15D
XOR EDI,EDI
LAB_001582c0:
MOV R8D,dword ptr [RDX]
MOV ECX,R15D
SHL R8D,CL
OR R8D,EDI
MOV dword ptr [R13],R8D
ADD R13,0x4
MOV EDI,dword ptr [RDX]
ADD RDX,0x4
MOV ECX,R9D
SHR EDI,CL
CMP RDX,RSI
JC 0x001582c0
MOV dword ptr [R13],EDI
CMP EDI,0x1
SBB EBX,-0x1
JMP 0x00158303
LAB_001582f0:
MOV ECX,dword ptr [RDX]
ADD RDX,0x4
MOV dword ptr [R13],ECX
ADD R13,0x4
CMP RDX,RSI
JC 0x001582f0
LAB_00158303:
MOV dword ptr [RAX + 0x14],EBX
MOV RDI,R14
MOV RSI,qword ptr [RBP + -0x38]
MOV RBX,RAX
CALL 0x00158209
MOV RAX,RBX
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 * lshift(int8 *param_1,uint param_2,int8 param_3)
{
uint *puVar1;
sbyte sVar2;
int iVar3;
int8 *puVar4;
uint *puVar5;
int iVar6;
uint uVar7;
ulong uVar8;
uint *__s;
iVar6 = *(int *)((long)param_1 + 0x14) + (param_2 >> 5);
for (iVar3 = *(int *)((long)param_1 + 0xc); iVar3 <= iVar6; iVar3 = iVar3 * 2) {
}
puVar4 = (int8 *)Balloc();
__s = (uint *)*puVar4;
if (0x1f < param_2) {
uVar8 = (ulong)((param_2 >> 5) - 1);
memset(__s,0,uVar8 * 4 + 4);
__s = __s + uVar8 + 1;
}
puVar5 = (uint *)*param_1;
puVar1 = puVar5 + *(int *)((long)param_1 + 0x14);
if ((param_2 & 0x1f) == 0) {
do {
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
*__s = uVar7;
__s = __s + 1;
} while (puVar5 < puVar1);
}
else {
sVar2 = (sbyte)(param_2 & 0x1f);
uVar7 = 0;
do {
*__s = *puVar5 << sVar2 | uVar7;
__s = __s + 1;
uVar7 = *puVar5;
puVar5 = puVar5 + 1;
uVar7 = uVar7 >> (0x20U - sVar2 & 0x1f);
} while (puVar5 < puVar1);
*__s = uVar7;
iVar6 = (iVar6 + 1) - (uint)(uVar7 == 0);
}
*(int *)((long)puVar4 + 0x14) = iVar6;
Bfree(param_1,param_3);
return puVar4;
}
| |
22,926 | mcp::tool_builder::with_string_param(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&, bool) | hkr04[P]cpp-mcp/src/mcp_tool.cpp | tool_builder& tool_builder::with_string_param(const std::string& name,
const std::string& description,
bool required) {
return add_param(name, description, "string", required);
} | O3 | cpp | mcp::tool_builder::with_string_param(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&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a53(%rip), %rsi # 0x56312
leaq 0x1a52(%rip), %rdx # 0x56318
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf902
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rcx
movl %ebp, %r8d
callq 0x54590
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x548fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa630
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5492a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xa630
movq %rbx, %rdi
callq 0xaa50
| _ZN3mcp12tool_builder17with_string_paramERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_b:
push rbp; int
push r15; int
push r14; int
push r13; char
push r12; int
push rbx; __int64
sub rsp, 28h
mov ebp, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r13, [rsp+58h+var_40]
mov [r13-10h], r13
lea rsi, aString; "string"
lea rdx, aString+6; ""
lea r12, [rsp+58h+var_50]
mov rdi, r12
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rdi, rbx; int
mov rsi, r15; int
mov rdx, r14; int
mov rcx, r12; int
mov r8d, ebp; int
call _ZN3mcp12tool_builder9add_paramERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES8_S8_b; mcp::tool_builder::add_param(std::string const&,std::string const&,std::string const&,bool)
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r13
jz short loc_548FE
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_548FE:
mov rax, rbx
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_0]; void *
cmp rdi, r13
jz short loc_5492A
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5492A:
mov rdi, rbx
call __Unwind_Resume
| long long mcp::tool_builder::with_string_param(long long a1, long long a2, long long a3, char a4)
{
void *v7[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v8[8]; // [rsp+18h] [rbp-40h] BYREF
v7[0] = v8;
std::string::_M_construct<char const*>((long long)v7, "string", (long long)"");
mcp::tool_builder::add_param(a1, a2, a3, (long long)v7, a4);
if ( v7[0] != v8 )
operator delete(v7[0], v8[0] + 1LL);
return a1;
}
| with_string_param:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R13,[RSP + 0x18]
MOV qword ptr [R13 + -0x10],R13
LEA RSI,[0x156312]
LEA RDX,[0x156318]
LEA R12,[RSP + 0x8]
MOV RDI,R12
CALL 0x0010f902
LAB_001548d3:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
MOV RCX,R12
MOV R8D,EBP
CALL 0x00154590
LAB_001548e7:
MOV RDI,qword ptr [RSP + 0x8]
CMP RDI,R13
JZ 0x001548fe
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0010a630
LAB_001548fe:
MOV RAX,RBX
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* mcp::tool_builder::with_string_param(std::__cxx11::string const&, std::__cxx11::string const&,
bool) */
tool_builder * __thiscall
mcp::tool_builder::with_string_param
(tool_builder *this,string *param_1,string *param_2,bool param_3)
{
long *local_50 [2];
long local_40 [2];
local_50[0] = local_40;
std::__cxx11::string::_M_construct<char_const*>((string *)local_50,"string","");
/* try { // try from 001548d3 to 001548e6 has its CatchHandler @ 00154910 */
add_param(this,param_1,param_2,(string *)local_50,param_3);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
| |
22,927 | my_interval_timer | eloqsql/mysys/my_getsystime.c | ulonglong my_interval_timer()
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec tp;
clock_gettime(CLOCK_MONOTONIC, &tp);
return tp.tv_sec*1000000000ULL+tp.tv_nsec;
#elif defined(HAVE_GETHRTIME)
return gethrtime();
#elif defined(_WIN32)
DBUG_ASSERT(query_performance_frequency);
LARGE_INTEGER t_cnt;
QueryPerformanceCounter(&t_cnt);
return (t_cnt.QuadPart / query_performance_frequency * 1000000000ULL) +
((t_cnt.QuadPart % query_performance_frequency) * 1000000000ULL /
query_performance_frequency);
#else
/* TODO: check for other possibilities for hi-res timestamping */
struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_sec*1000000000ULL+tv.tv_usec*1000ULL;
#endif
} | O0 | c | my_interval_timer:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
leaq -0x10(%rbp), %rsi
callq 0x252c0
imulq $0x3b9aca00, -0x10(%rbp), %rax # imm = 0x3B9ACA00
addq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_interval_timer:
push rbp
mov rbp, rsp
sub rsp, 10h
mov edi, 1
lea rsi, [rbp+var_10]
call _clock_gettime
imul rax, [rbp+var_10], 3B9ACA00h
add rax, [rbp+var_8]
add rsp, 10h
pop rbp
retn
| long long my_interval_timer()
{
_QWORD v1[2]; // [rsp+0h] [rbp-10h] BYREF
clock_gettime(1LL, v1);
return v1[1] + 1000000000LL * v1[0];
}
| my_interval_timer:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV EDI,0x1
LEA RSI,[RBP + -0x10]
CALL 0x001252c0
IMUL RAX,qword ptr [RBP + -0x10],0x3b9aca00
ADD RAX,qword ptr [RBP + -0x8]
ADD RSP,0x10
POP RBP
RET
|
long my_interval_timer(void)
{
timespec local_18;
clock_gettime(1,&local_18);
return local_18.tv_sec * 1000000000 + local_18.tv_nsec;
}
| |
22,928 | LefDefParser::lefwLayerRoutingMaxwidth(double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefwWriter.cpp | int
lefwLayerRoutingMaxwidth(double width)
{
if (!lefwFile)
return LEFW_UNINITIALIZED;
if (lefwState != LEFW_LAYERROUTING_START &&
lefwState != LEFW_LAYERROUTING)
return LEFW_BAD_ORDER;
if (!lefwIsRouting)
return LEFW_BAD_DATA; // only routing calls this func
if (prtSemiColon) {
// the previous statement hasn't written the ; yet
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) ";\n");
else
fprintf(lefwFile, ";\n");
prtSemiColon = 0;
}
if (lefwWriteEncrypt)
encPrint(lefwFile, (char*) " MAXWIDTH %.11g ;\n", width);
else
fprintf(lefwFile, " MAXWIDTH %.11g ;\n", width);
lefwLines++;
return LEFW_OK;
} | O0 | cpp | LefDefParser::lefwLayerRoutingMaxwidth(double):
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
leaq 0x20a4f(%rip), %rax # 0x32e00
cmpq $0x0, (%rax)
jne 0x123c4
movl $0x1, 0x14(%rsp)
jmp 0x124b4
leaq 0x20c85(%rip), %rax # 0x33050
cmpl $0x7, (%rax)
je 0x123e9
leaq 0x20c79(%rip), %rax # 0x33050
cmpl $0x1f, (%rax)
je 0x123e9
movl $0x2, 0x14(%rsp)
jmp 0x124b4
leaq 0x20cd4(%rip), %rax # 0x330c4
cmpl $0x0, (%rax)
jne 0x12402
movl $0x3, 0x14(%rsp)
jmp 0x124b4
cmpl $0x0, 0x20ceb(%rip) # 0x330f4
je 0x12450
cmpl $0x0, 0x20cda(%rip) # 0x330ec
je 0x1242e
leaq 0x209e5(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x17b2f(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x289b0
jmp 0x12446
leaq 0x209cb(%rip), %rax # 0x32e00
movq (%rax), %rdi
leaq 0x17b15(%rip), %rsi # 0x29f54
movb $0x0, %al
callq 0x1100
movl $0x0, 0x20ca4(%rip) # 0x330f4
cmpl $0x0, 0x20c95(%rip) # 0x330ec
je 0x12479
leaq 0x209a0(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x183ed(%rip), %rsi # 0x2a85d
movb $0x1, %al
callq 0x289b0
jmp 0x12497
leaq 0x20980(%rip), %rax # 0x32e00
movq (%rax), %rdi
movsd 0x8(%rsp), %xmm0
leaq 0x183cd(%rip), %rsi # 0x2a85d
movb $0x1, %al
callq 0x1100
leaq 0x20bae(%rip), %rax # 0x3304c
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x20ba2(%rip), %rax # 0x3304c
movl %ecx, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser24lefwLayerRoutingMaxwidthEd:
sub rsp, 18h
movsd [rsp+18h+var_10], xmm0
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
cmp qword ptr [rax], 0
jnz short loc_123C4
mov [rsp+18h+var_4], 1
jmp loc_124B4
loc_123C4:
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 7
jz short loc_123E9
lea rax, _ZN12LefDefParser9lefwStateE; LefDefParser::lefwState
cmp dword ptr [rax], 1Fh
jz short loc_123E9
mov [rsp+18h+var_4], 2
jmp loc_124B4
loc_123E9:
lea rax, _ZN12LefDefParser13lefwIsRoutingE; LefDefParser::lefwIsRouting
cmp dword ptr [rax], 0
jnz short loc_12402
mov [rsp+18h+var_4], 3
jmp loc_124B4
loc_12402:
cmp cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
jz short loc_12450
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_1242E
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_12446
loc_1242E:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
lea rsi, aDividercharS+11h; ";\n"
mov al, 0
call _fprintf
loc_12446:
mov cs:_ZN12LefDefParserL12prtSemiColonE, 0; LefDefParser::prtSemiColon
loc_12450:
cmp cs:_ZN12LefDefParserL16lefwWriteEncryptE, 0; LefDefParser::lefwWriteEncrypt
jz short loc_12479
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aMaxwidth11g; " MAXWIDTH %.11g ;\n"
mov al, 1
call _ZN12LefDefParser8encPrintEP8_IO_FILEPcz; LefDefParser::encPrint(_IO_FILE *,char *,...)
jmp short loc_12497
loc_12479:
lea rax, _ZN12LefDefParser8lefwFileE; LefDefParser::lefwFile
mov rdi, [rax]
movsd xmm0, [rsp+18h+var_10]
lea rsi, aMaxwidth11g; " MAXWIDTH %.11g ;\n"
mov al, 1
call _fprintf
loc_12497:
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov ecx, [rax]
add ecx, 1
lea rax, _ZN12LefDefParser9lefwLinesE; LefDefParser::lefwLines
mov [rax], ecx
mov [rsp+18h+var_4], 0
loc_124B4:
mov eax, [rsp+18h+var_4]
add rsp, 18h
retn
| long long LefDefParser::lefwLayerRoutingMaxwidth(
LefDefParser *this,
double a2,
long long a3,
int a4,
int a5,
int a6,
int a7)
{
if ( *(_QWORD *)&LefDefParser::lefwFile )
{
if ( LefDefParser::lefwState == 7 || LefDefParser::lefwState == 31 )
{
if ( LefDefParser::lefwIsRouting )
{
if ( LefDefParser::prtSemiColon )
{
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)";\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, ";\n");
LefDefParser::prtSemiColon = 0;
}
if ( LefDefParser::lefwWriteEncrypt )
LefDefParser::encPrint(LefDefParser::lefwFile, (unsigned int)" MAXWIDTH %.11g ;\n", a4, a5, a6, a7);
else
fprintf(*(_QWORD *)&LefDefParser::lefwFile, " MAXWIDTH %.11g ;\n", a2);
++LefDefParser::lefwLines;
return 0;
}
else
{
return 3;
}
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| lefwLayerRoutingMaxwidth:
SUB RSP,0x18
MOVSD qword ptr [RSP + 0x8],XMM0
LEA RAX,[0x132e00]
CMP qword ptr [RAX],0x0
JNZ 0x001123c4
MOV dword ptr [RSP + 0x14],0x1
JMP 0x001124b4
LAB_001123c4:
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x7
JZ 0x001123e9
LEA RAX,[0x133050]
CMP dword ptr [RAX],0x1f
JZ 0x001123e9
MOV dword ptr [RSP + 0x14],0x2
JMP 0x001124b4
LAB_001123e9:
LEA RAX,[0x1330c4]
CMP dword ptr [RAX],0x0
JNZ 0x00112402
MOV dword ptr [RSP + 0x14],0x3
JMP 0x001124b4
LAB_00112402:
CMP dword ptr [0x001330f4],0x0
JZ 0x00112450
CMP dword ptr [0x001330ec],0x0
JZ 0x0011242e
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x001289b0
JMP 0x00112446
LAB_0011242e:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x129f54]
MOV AL,0x0
CALL 0x00101100
LAB_00112446:
MOV dword ptr [0x001330f4],0x0
LAB_00112450:
CMP dword ptr [0x001330ec],0x0
JZ 0x00112479
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a85d]
MOV AL,0x1
CALL 0x001289b0
JMP 0x00112497
LAB_00112479:
LEA RAX,[0x132e00]
MOV RDI,qword ptr [RAX]
MOVSD XMM0,qword ptr [RSP + 0x8]
LEA RSI,[0x12a85d]
MOV AL,0x1
CALL 0x00101100
LAB_00112497:
LEA RAX,[0x13304c]
MOV ECX,dword ptr [RAX]
ADD ECX,0x1
LEA RAX,[0x13304c]
MOV dword ptr [RAX],ECX
MOV dword ptr [RSP + 0x14],0x0
LAB_001124b4:
MOV EAX,dword ptr [RSP + 0x14]
ADD RSP,0x18
RET
|
/* LefDefParser::lefwLayerRoutingMaxwidth(double) */
int4 LefDefParser::lefwLayerRoutingMaxwidth(double param_1)
{
int4 local_4;
if (lefwFile == (_IO_FILE *)0x0) {
local_4 = 1;
}
else if ((lefwState == 7) || (lefwState == 0x1f)) {
if (lefwIsRouting == 0) {
local_4 = 3;
}
else {
if (prtSemiColon != 0) {
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile,";\n");
}
else {
encPrint(lefwFile,";\n");
}
prtSemiColon = 0;
}
if (lefwWriteEncrypt == 0) {
fprintf(lefwFile," MAXWIDTH %.11g ;\n",param_1);
}
else {
encPrint(lefwFile," MAXWIDTH %.11g ;\n",param_1);
}
lefwLines = lefwLines + 1;
local_4 = 0;
}
}
else {
local_4 = 2;
}
return local_4;
}
| |
22,929 | pvio_socket_set_timeout | eloqsql/libmariadb/plugins/pvio/pvio_socket.c | my_bool pvio_socket_set_timeout(MARIADB_PVIO *pvio, enum enum_pvio_timeout type, int timeout)
{
struct st_pvio_socket *csock= NULL;
if (!pvio)
return 1;
csock= (struct st_pvio_socket *)pvio->data;
pvio->timeout[type]= (timeout > 0) ? timeout * 1000 : -1;
if (csock)
return pvio_socket_change_timeout(pvio, type, timeout * 1000);
return 0;
} | O3 | c | pvio_socket_set_timeout:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x31449
movl %edx, %eax
imull $0x3e8, %edx, %edx # imm = 0x3E8
testl %eax, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovgl %edx, %eax
movl %esi, %ecx
cmpq $0x0, (%rdi)
movl %eax, 0x24(%rdi,%rcx,4)
je 0x3144d
popq %rbp
jmp 0x320a0
movb $0x1, %al
jmp 0x3144f
xorl %eax, %eax
popq %rbp
retq
| pvio_socket_set_timeout:
push rbp
mov rbp, rsp
test rdi, rdi
jz short loc_31449
mov eax, edx
imul edx, 3E8h
test eax, eax
mov eax, 0FFFFFFFFh
cmovg eax, edx
mov ecx, esi
cmp qword ptr [rdi], 0
mov [rdi+rcx*4+24h], eax
jz short loc_3144D
pop rbp
jmp pvio_socket_change_timeout
loc_31449:
mov al, 1
jmp short loc_3144F
loc_3144D:
xor eax, eax
loc_3144F:
pop rbp
retn
| char pvio_socket_set_timeout(_QWORD *a1, unsigned int a2, int a3)
{
int v4; // edx
bool v5; // cc
int v6; // eax
bool v7; // zf
if ( !a1 )
return 1;
v4 = 1000 * a3;
v5 = a3 <= 0;
v6 = -1;
if ( !v5 )
v6 = v4;
v7 = *a1 == 0LL;
*((_DWORD *)a1 + a2 + 9) = v6;
if ( v7 )
return 0;
else
return pvio_socket_change_timeout();
}
| pvio_socket_set_timeout:
PUSH RBP
MOV RBP,RSP
TEST RDI,RDI
JZ 0x00131449
MOV EAX,EDX
IMUL EDX,EDX,0x3e8
TEST EAX,EAX
MOV EAX,0xffffffff
CMOVG EAX,EDX
MOV ECX,ESI
CMP qword ptr [RDI],0x0
MOV dword ptr [RDI + RCX*0x4 + 0x24],EAX
JZ 0x0013144d
POP RBP
JMP 0x001320a0
LAB_00131449:
MOV AL,0x1
JMP 0x0013144f
LAB_0013144d:
XOR EAX,EAX
LAB_0013144f:
POP RBP
RET
|
int8 pvio_socket_set_timeout(long *param_1,uint param_2,int param_3)
{
long lVar1;
int iVar2;
int8 uVar3;
if (param_1 == (long *)0x0) {
uVar3 = 1;
}
else {
iVar2 = -1;
if (0 < param_3) {
iVar2 = param_3 * 1000;
}
lVar1 = *param_1;
*(int *)((long)param_1 + (ulong)param_2 * 4 + 0x24) = iVar2;
if (lVar1 != 0) {
uVar3 = pvio_socket_change_timeout();
return uVar3;
}
uVar3 = 0;
}
return uVar3;
}
| |
22,930 | my_coll_parser_scan_shift | eloqsql/strings/ctype-uca.c | static int
my_coll_parser_scan_shift(MY_COLL_RULE_PARSER *p)
{
if (my_coll_parser_curr(p)->term == MY_COLL_LEXEM_SHIFT)
{
my_coll_rule_shift_at_level(&p->rule, my_coll_parser_curr(p)->diff);
return my_coll_parser_scan(p);
}
return 0;
} | O3 | c | my_coll_parser_scan_shift:
xorl %eax, %eax
cmpl $0x1, (%rdi)
jne 0x3f976
movl 0x20(%rdi), %eax
decl %eax
cmpl $0x3, %eax
ja 0x3f949
leaq 0x1a4418(%rip), %rcx # 0x1e3d10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
incl 0xd0(%rdi)
movl $0x0, 0xdc(%rdi)
movq $0x0, 0xd4(%rdi)
jmp 0x3f949
incl 0xd8(%rdi)
movl $0x0, 0xdc(%rdi)
jmp 0x3f949
incl 0xdc(%rdi)
jmp 0x3f949
incl 0xd4(%rdi)
movq $0x0, 0xd8(%rdi)
pushq %rbp
movq %rsp, %rbp
leaq 0x28(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movups 0x28(%rdi), %xmm0
movups 0x38(%rdi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rax, %rdi
callq 0x3f643
movl $0x1, %eax
popq %rbp
retq
| my_coll_parser_scan_shift:
xor eax, eax
cmp dword ptr [rdi], 1
jnz locret_3F976
mov eax, [rdi+20h]
dec eax; switch 4 cases
cmp eax, 3
ja short def_3F8FF; jumptable 000000000003F8FF default case
lea rcx, jpt_3F8FF
movsxd rax, ds:(jpt_3F8FF - 1E3D10h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_3F901:
inc dword ptr [rdi+0D0h]; jumptable 000000000003F8FF case 1
mov dword ptr [rdi+0DCh], 0
mov qword ptr [rdi+0D4h], 0
jmp short def_3F8FF; jumptable 000000000003F8FF default case
loc_3F91E:
inc dword ptr [rdi+0D8h]; jumptable 000000000003F8FF case 3
mov dword ptr [rdi+0DCh], 0
jmp short def_3F8FF; jumptable 000000000003F8FF default case
loc_3F930:
inc dword ptr [rdi+0DCh]; jumptable 000000000003F8FF case 4
jmp short def_3F8FF; jumptable 000000000003F8FF default case
loc_3F938:
inc dword ptr [rdi+0D4h]; jumptable 000000000003F8FF case 2
mov qword ptr [rdi+0D8h], 0
def_3F8FF:
push rbp; jumptable 000000000003F8FF default case
mov rbp, rsp
lea rax, [rdi+28h]
mov rcx, [rdi+48h]
mov [rdi+20h], rcx
movups xmm0, xmmword ptr [rdi+28h]
movups xmm1, xmmword ptr [rdi+38h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov rdi, rax
call my_coll_lexem_next
mov eax, 1
pop rbp
locret_3F976:
retn
| long long my_coll_parser_scan_shift(long long a1)
{
long long result; // rax
__int128 v2; // xmm0
result = 0LL;
if ( *(_DWORD *)a1 == 1 )
{
switch ( *(_DWORD *)(a1 + 32) )
{
case 1:
++*(_DWORD *)(a1 + 208);
*(_DWORD *)(a1 + 220) = 0;
*(_QWORD *)(a1 + 212) = 0LL;
break;
case 2:
++*(_DWORD *)(a1 + 212);
*(_QWORD *)(a1 + 216) = 0LL;
break;
case 3:
++*(_DWORD *)(a1 + 216);
*(_DWORD *)(a1 + 220) = 0;
break;
case 4:
++*(_DWORD *)(a1 + 220);
break;
default:
break;
}
*(_QWORD *)(a1 + 32) = *(_QWORD *)(a1 + 72);
v2 = *(_OWORD *)(a1 + 40);
*(_OWORD *)(a1 + 16) = *(_OWORD *)(a1 + 56);
*(_OWORD *)a1 = v2;
my_coll_lexem_next(a1 + 40);
return 1LL;
}
return result;
}
| my_coll_parser_scan_shift:
XOR EAX,EAX
CMP dword ptr [RDI],0x1
JNZ 0x0013f976
MOV EAX,dword ptr [RDI + 0x20]
DEC EAX
CMP EAX,0x3
JA 0x0013f949
LEA RCX,[0x2e3d10]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
INC dword ptr [RDI + 0xd0]
MOV dword ptr [RDI + 0xdc],0x0
MOV qword ptr [RDI + 0xd4],0x0
JMP 0x0013f949
caseD_3:
INC dword ptr [RDI + 0xd8]
MOV dword ptr [RDI + 0xdc],0x0
JMP 0x0013f949
caseD_4:
INC dword ptr [RDI + 0xdc]
JMP 0x0013f949
caseD_2:
INC dword ptr [RDI + 0xd4]
MOV qword ptr [RDI + 0xd8],0x0
default:
PUSH RBP
MOV RBP,RSP
LEA RAX,[RDI + 0x28]
MOV RCX,qword ptr [RDI + 0x48]
MOV qword ptr [RDI + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RDI + 0x28]
MOVUPS XMM1,xmmword ptr [RDI + 0x38]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RAX
CALL 0x0013f643
MOV EAX,0x1
POP RBP
LAB_0013f976:
RET
|
int8 my_coll_parser_scan_shift(int *param_1)
{
int8 uVar1;
uVar1 = 0;
if (*param_1 == 1) {
switch(param_1[8]) {
case 1:
param_1[0x34] = param_1[0x34] + 1;
param_1[0x37] = 0;
param_1[0x35] = 0;
param_1[0x36] = 0;
break;
case 2:
param_1[0x35] = param_1[0x35] + 1;
param_1[0x36] = 0;
param_1[0x37] = 0;
break;
case 3:
param_1[0x36] = param_1[0x36] + 1;
param_1[0x37] = 0;
break;
case 4:
param_1[0x37] = param_1[0x37] + 1;
}
*(int8 *)(param_1 + 8) = *(int8 *)(param_1 + 0x12);
param_1[4] = param_1[0xe];
param_1[5] = param_1[0xf];
param_1[6] = param_1[0x10];
param_1[7] = param_1[0x11];
*param_1 = param_1[10];
param_1[1] = param_1[0xb];
param_1[2] = param_1[0xc];
param_1[3] = param_1[0xd];
my_coll_lexem_next(param_1 + 10);
uVar1 = 1;
}
return uVar1;
}
| |
22,931 | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op) | monkey531[P]llama/common/minja.hpp | UnaryOpExpr(const Location & location, std::shared_ptr<Expression> && e, Op o)
: Expression(location), expr(std::move(e)), op(o) {} | O2 | cpp | minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&, minja::UnaryOpExpr::Op):
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
callq 0x5f8a0
leaq 0x7ac71(%rip), %rax # 0xda4e8
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x28(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x20(%r15)
andq $0x0, (%r14)
movl %ebx, 0x30(%r15)
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN5minja11UnaryOpExprC2ERKNS_8LocationEOSt10shared_ptrINS_10ExpressionEENS0_2OpE:
push r15
push r14
push rbx
mov ebx, ecx
mov r14, rdx
mov r15, rdi
call _ZN5minja10ExpressionC2ERKNS_8LocationE; minja::Expression::Expression(minja::Location const&)
lea rax, _ZTVN5minja11UnaryOpExprE; `vtable for'minja::UnaryOpExpr
add rax, 10h
mov [r15], rax
and qword ptr [r15+28h], 0
movups xmm0, xmmword ptr [r14]
and qword ptr [r14+8], 0
movups xmmword ptr [r15+20h], xmm0
and qword ptr [r14], 0
mov [r15+30h], ebx
pop rbx
pop r14
pop r15
retn
| long long * minja::UnaryOpExpr::UnaryOpExpr(long long a1, long long a2, __int128 *a3, int a4)
{
long long *result; // rax
__int128 v7; // xmm0
minja::Expression::Expression();
result = &`vtable for'minja::UnaryOpExpr + 2;
*(_QWORD *)a1 = &`vtable for'minja::UnaryOpExpr + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v7;
*(_QWORD *)a3 = 0LL;
*(_DWORD *)(a1 + 48) = a4;
return result;
}
| UnaryOpExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,ECX
MOV R14,RDX
MOV R15,RDI
CALL 0x0015f8a0
LEA RAX,[0x1da4e8]
ADD RAX,0x10
MOV qword ptr [R15],RAX
AND qword ptr [R15 + 0x28],0x0
MOVUPS XMM0,xmmword ptr [R14]
AND qword ptr [R14 + 0x8],0x0
MOVUPS xmmword ptr [R15 + 0x20],XMM0
AND qword ptr [R14],0x0
MOV dword ptr [R15 + 0x30],EBX
POP RBX
POP R14
POP R15
RET
|
/* minja::UnaryOpExpr::UnaryOpExpr(minja::Location const&, std::shared_ptr<minja::Expression>&&,
minja::UnaryOpExpr::Op) */
void __thiscall
minja::UnaryOpExpr::UnaryOpExpr
(UnaryOpExpr *this,Location *param_1,int8 *param_2,int4 param_4)
{
int8 uVar1;
Expression::Expression((Expression *)this,param_1);
*(int ***)this = &PTR_do_evaluate_001da4f8;
*(int8 *)(this + 0x28) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)(this + 0x20) = *param_2;
*(int8 *)(this + 0x28) = uVar1;
*param_2 = 0;
*(int4 *)(this + 0x30) = param_4;
return;
}
| |
22,932 | ma_update_blob_record | eloqsql/storage/maria/ma_dynrec.c | my_bool _ma_update_blob_record(MARIA_HA *info, MARIA_RECORD_POS pos,
const uchar *oldrec __attribute__ ((unused)),
const uchar *record)
{
uchar *rec_buff;
int error;
ulong reclength,reclength2,extra;
my_bool buff_alloced;
extra= (ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER)+MARIA_SPLIT_LENGTH+
MARIA_DYN_DELETE_BLOCK_HEADER);
reclength= (info->s->base.pack_reclength+
_ma_calc_total_blob_length(info,record)+ extra);
#ifdef NOT_USED /* We now support big rows */
if (reclength > MARIA_DYN_MAX_ROW_LENGTH)
{
my_errno=HA_ERR_TO_BIG_ROW;
return 1;
}
#endif
alloc_on_stack(*info->stack_end_ptr, rec_buff, buff_alloced, reclength);
if (!rec_buff)
{
my_errno= HA_ERR_OUT_OF_MEM; /* purecov: inspected */
return(1);
}
reclength2= _ma_rec_pack(info, rec_buff+
ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
record);
if (!reclength2)
{
error= 1;
goto err;
}
DBUG_ASSERT(reclength2 <= reclength);
error=update_dynamic_record(info,pos,
rec_buff+ALIGN_SIZE(MARIA_MAX_DYN_BLOCK_HEADER),
reclength2);
err:
stack_alloc_free(rec_buff, buff_alloced);
return(error != 0);
} | O3 | c | ma_update_blob_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq 0x3a0(%rax), %r12
movq %rcx, %rsi
callq 0x478fa
leaq (%r12,%rax), %rsi
addq $0x5c, %rsi
leaq -0x40(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%r14), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x47a0c
cmpq $0x10000, %rax # imm = 0x10000
ja 0x479f4
cmpq $0x1000, %rsi # imm = 0x1000
jb 0x47a0c
cmpq $0x8001, %rax # imm = 0x8001
jb 0x47a0c
movq %rsp, %r12
addq $0xf, %rsi
andq $-0x10, %rsi
subq %rsi, %r12
movq %r12, %rsp
movb $0x1, %al
movl %eax, -0x34(%rbp)
jmp 0x47a27
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fd51
testq %rax, %rax
je 0x47a67
movq %rax, %r12
movl $0x0, -0x34(%rbp)
leaq 0x18(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x46f6d
testl %eax, %eax
je 0x47a55
movl %eax, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x47402
testb %al, %al
setne %bl
jmp 0x47a57
movb $0x1, %bl
cmpb $0x0, -0x34(%rbp)
jne 0x47a74
movq %r12, %rdi
callq 0x9ff7e
jmp 0x47a74
callq 0xa1ac2
movl $0x80, (%rax)
movb $0x1, %bl
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x47a94
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| _ma_update_blob_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rcx
mov rbx, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov r12, [rax+3A0h]
mov rsi, rcx
call _ma_calc_total_blob_length
lea rsi, [r12+rax]
add rsi, 5Ch ; '\'
lea rcx, [rbp+var_40]
mov [rcx], rsi
mov rax, [r14+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_47A0C
cmp rax, offset stru_10000
ja short loc_479F4
cmp rsi, 1000h
jb short loc_47A0C
cmp rax, 8001h
jb short loc_47A0C
loc_479F4:
mov r12, rsp
add rsi, 0Fh
and rsi, 0FFFFFFFFFFFFFFF0h
sub r12, rsi
mov rsp, r12
mov al, 1
mov [rbp+var_34], eax
jmp short loc_47A27
loc_47A0C:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz short loc_47A67
mov r12, rax
mov [rbp+var_34], 0
loc_47A27:
lea r13, [r12+18h]
mov rdi, r14
mov rsi, r13
mov rdx, r15
call _ma_rec_pack
test eax, eax
jz short loc_47A55
mov ecx, eax
mov rdi, r14
mov rsi, rbx
mov rdx, r13
call update_dynamic_record
test al, al
setnz bl
jmp short loc_47A57
loc_47A55:
mov bl, 1
loc_47A57:
cmp byte ptr [rbp+var_34], 0
jnz short loc_47A74
mov rdi, r12
call my_free
jmp short loc_47A74
loc_47A67:
call _my_thread_var
mov dword ptr [rax], 80h
mov bl, 1
loc_47A74:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_47A94
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_47A94:
call ___stack_chk_fail
| long long ma_update_blob_record(long long a1, long long a2, long long a3, unsigned __int8 *a4)
{
long long v6; // r12
unsigned long long v7; // rsi
unsigned long long v8; // rax
bool v9; // cc
unsigned long long v10; // rax
char *v11; // r12
long long v12; // rax
unsigned int v13; // eax
unsigned long long v15; // [rsp+0h] [rbp-40h] BYREF
int v16; // [rsp+Ch] [rbp-34h]
unsigned long long v17; // [rsp+10h] [rbp-30h]
v17 = __readfsqword(0x28u);
v6 = *(_QWORD *)(*(_QWORD *)a1 + 928LL);
v7 = v6 + ma_calc_total_blob_length((_QWORD *)a1, (long long)a4) + 92;
v15 = v7;
v8 = **(_QWORD **)(a1 + 120) - (_QWORD)&v15;
v9 = v8 <= v7;
v10 = v8 - v7;
if ( v9 || v10 <= (unsigned long long)&stru_10000 && (v7 < 0x1000 || v10 < 0x8001) )
{
v12 = my_malloc(0LL, v7, 65552LL);
if ( !v12 )
{
*(_DWORD *)my_thread_var(0LL) = 128;
LOBYTE(a2) = 1;
return (unsigned int)a2;
}
v11 = (char *)v12;
v16 = 0;
}
else
{
v11 = (char *)&v15 - ((v7 + 15) & 0xFFFFFFFFFFFFFFF0LL);
LOBYTE(v10) = 1;
v16 = v10;
}
v13 = ma_rec_pack((unsigned __int8 *)a1, v11 + 24, a4);
if ( v13 )
LOBYTE(a2) = update_dynamic_record((_QWORD *)a1, a2, (long long)(v11 + 24), v13);
else
LOBYTE(a2) = 1;
if ( !(_BYTE)v16 )
my_free(v11);
return (unsigned int)a2;
}
| _ma_update_blob_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RCX
MOV RBX,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV R12,qword ptr [RAX + 0x3a0]
MOV RSI,RCX
CALL 0x001478fa
LEA RSI,[R12 + RAX*0x1]
ADD RSI,0x5c
LEA RCX,[RBP + -0x40]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [R14 + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x00147a0c
CMP RAX,0x10000
JA 0x001479f4
CMP RSI,0x1000
JC 0x00147a0c
CMP RAX,0x8001
JC 0x00147a0c
LAB_001479f4:
MOV R12,RSP
ADD RSI,0xf
AND RSI,-0x10
SUB R12,RSI
MOV RSP,R12
MOV AL,0x1
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00147a27
LAB_00147a0c:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fd51
TEST RAX,RAX
JZ 0x00147a67
MOV R12,RAX
MOV dword ptr [RBP + -0x34],0x0
LAB_00147a27:
LEA R13,[R12 + 0x18]
MOV RDI,R14
MOV RSI,R13
MOV RDX,R15
CALL 0x00146f6d
TEST EAX,EAX
JZ 0x00147a55
MOV ECX,EAX
MOV RDI,R14
MOV RSI,RBX
MOV RDX,R13
CALL 0x00147402
TEST AL,AL
SETNZ BL
JMP 0x00147a57
LAB_00147a55:
MOV BL,0x1
LAB_00147a57:
CMP byte ptr [RBP + -0x34],0x0
JNZ 0x00147a74
MOV RDI,R12
CALL 0x0019ff7e
JMP 0x00147a74
LAB_00147a67:
CALL 0x001a1ac2
MOV dword ptr [RAX],0x80
MOV BL,0x1
LAB_00147a74:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00147a94
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00147a94:
CALL 0x00129250
|
ulong _ma_update_blob_record(long *param_1,int8 param_2,int8 param_3,int8 param_4)
{
long lVar1;
char cVar2;
int iVar3;
long lVar4;
ulong uVar5;
int1 *puVar6;
int4 *puVar7;
int7 uVar8;
ulong *puVar9;
long in_FS_OFFSET;
ulong local_48;
int4 local_3c;
long local_38;
puVar9 = &local_48;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
lVar1 = *(long *)(*param_1 + 0x3a0);
lVar4 = _ma_calc_total_blob_length(param_1,param_4);
lVar1 = lVar1 + lVar4;
local_48 = lVar1 + 0x5c;
uVar5 = (*(long *)param_1[0xf] - (long)&local_48) - local_48;
uVar8 = (int7)((ulong)param_2 >> 8);
if (((ulong)(*(long *)param_1[0xf] - (long)&local_48) < local_48 || uVar5 == 0) ||
((uVar5 < 0x10001 && ((local_48 < 0x1000 || (uVar5 < 0x8001)))))) {
puVar6 = (int1 *)my_malloc(0,local_48,0x10010);
if (puVar6 == (int1 *)0x0) {
puVar7 = (int4 *)_my_thread_var();
*puVar7 = 0x80;
uVar5 = CONCAT71(uVar8,1);
goto LAB_00147a74;
}
local_3c = 0;
puVar9 = &local_48;
}
else {
puVar6 = (int1 *)((long)&local_48 - (lVar1 + 0x6bU & 0xfffffffffffffff0));
local_3c = (int4)CONCAT71((int7)(uVar5 >> 8),1);
puVar9 = (ulong *)puVar6;
}
*(int8 *)((long)puVar9 + -8) = 0x147a3a;
iVar3 = _ma_rec_pack(param_1,puVar6 + 0x18,param_4);
if (iVar3 == 0) {
uVar5 = CONCAT71(uVar8,1);
}
else {
*(int8 *)((long)puVar9 + -8) = 0x147a4e;
cVar2 = update_dynamic_record(param_1,param_2,puVar6 + 0x18,iVar3);
uVar5 = CONCAT71(uVar8,cVar2 != '\0');
}
if ((char)local_3c == '\0') {
*(int8 *)((long)puVar9 + -8) = 0x147a65;
my_free(puVar6);
}
LAB_00147a74:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5 & 0xffffffff;
}
/* WARNING: Subroutine does not return */
*(code **)((long)puVar9 + -8) = _ma_delete_dynamic_record;
__stack_chk_fail();
}
| |
22,933 | CLI::App::_process_help_flags(bool, bool) const | MikePodsytnik[P]TCRtrie/build_O0/_deps/cli11-src/include/CLI/impl/App_inl.hpp | CLI11_INLINE void App::_process_help_flags(bool trigger_help, bool trigger_all_help) const {
const Option *help_ptr = get_help_ptr();
const Option *help_all_ptr = get_help_all_ptr();
if(help_ptr != nullptr && help_ptr->count() > 0)
trigger_help = true;
if(help_all_ptr != nullptr && help_all_ptr->count() > 0)
trigger_all_help = true;
// If there were parsed subcommands, call those. First subcommand wins if there are multiple ones.
if(!parsed_subcommands_.empty()) {
for(const App *sub : parsed_subcommands_)
sub->_process_help_flags(trigger_help, trigger_all_help);
// Only the final subcommand should call for help. All help wins over help.
} else if(trigger_all_help) {
throw CallForAllHelp();
} else if(trigger_help) {
throw CallForHelp();
}
} | O0 | cpp | CLI::App::_process_help_flags(bool, bool) const:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x270a0
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x270c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ab84
movq -0x18(%rbp), %rdi
callq 0x38fb0
cmpq $0x0, %rax
jbe 0x3ab84
movb $0x1, -0x9(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3ab9e
movq -0x20(%rbp), %rdi
callq 0x38fb0
cmpq $0x0, %rax
jbe 0x3ab9e
movb $0x1, -0xa(%rbp)
movq -0x58(%rbp), %rdi
addq $0x1a8, %rdi # imm = 0x1A8
callq 0x3dca0
testb $0x1, %al
jne 0x3ac27
movq -0x58(%rbp), %rax
addq $0x1a8, %rax # imm = 0x1A8
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3c970
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3c9a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3c9d0
testb $0x1, %al
jne 0x3abed
jmp 0x3ac22
leaq -0x30(%rbp), %rdi
callq 0x3ca10
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movb -0x9(%rbp), %cl
movb -0xa(%rbp), %al
andb $0x1, %cl
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0x3ab30
leaq -0x30(%rbp), %rdi
callq 0x3cb30
jmp 0x3abda
jmp 0x3acc9
testb $0x1, -0xa(%rbp)
je 0x3ac76
movl $0x38, %edi
callq 0x92d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x3dce0
jmp 0x3ac48
movq -0x60(%rbp), %rdi
leaq 0x669ed(%rip), %rsi # 0xa1640
leaq 0x3126(%rip), %rdx # 0x3dd80
callq 0x9a30
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x9470
jmp 0x3accf
testb $0x1, -0x9(%rbp)
je 0x3acc5
movl $0x38, %edi
callq 0x92d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x3dda0
jmp 0x3ac97
movq -0x68(%rbp), %rdi
leaq 0x669b6(%rip), %rsi # 0xa1658
leaq 0x3197(%rip), %rdx # 0x3de40
callq 0x9a30
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x9470
jmp 0x3accf
jmp 0x3acc7
jmp 0x3acc9
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x9a70
nopl (%rax,%rax)
| _ZNK3CLI3App19_process_help_flagsEbb:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, dl
mov cl, sil
mov [rbp+var_8], rdi
and cl, 1
mov [rbp+var_9], cl
and al, 1
mov [rbp+var_A], al
mov rdi, [rbp+var_8]; this
mov [rbp+var_58], rdi
call _ZNK3CLI3App12get_help_ptrEv; CLI::App::get_help_ptr(void)
mov rdi, [rbp+var_58]; this
mov [rbp+var_18], rax
call _ZNK3CLI3App16get_help_all_ptrEv; CLI::App::get_help_all_ptr(void)
mov [rbp+var_20], rax
cmp [rbp+var_18], 0
jz short loc_3AB84
mov rdi, [rbp+var_18]; this
call _ZNK3CLI6Option5countEv; CLI::Option::count(void)
cmp rax, 0
jbe short loc_3AB84
mov [rbp+var_9], 1
loc_3AB84:
cmp [rbp+var_20], 0
jz short loc_3AB9E
mov rdi, [rbp+var_20]; this
call _ZNK3CLI6Option5countEv; CLI::Option::count(void)
cmp rax, 0
jbe short loc_3AB9E
mov [rbp+var_A], 1
loc_3AB9E:
mov rdi, [rbp+var_58]
add rdi, 1A8h
call _ZNKSt6vectorIPN3CLI3AppESaIS2_EE5emptyEv; std::vector<CLI::App *>::empty(void)
test al, 1
jnz short loc_3AC27
mov rax, [rbp+var_58]
add rax, 1A8h
mov [rbp+var_28], rax
mov rdi, [rbp+var_28]
call _ZNKSt6vectorIPN3CLI3AppESaIS2_EE5beginEv; std::vector<CLI::App *>::begin(void)
mov [rbp+var_30], rax
mov rdi, [rbp+var_28]
call _ZNKSt6vectorIPN3CLI3AppESaIS2_EE3endEv; std::vector<CLI::App *>::end(void)
mov [rbp+var_38], rax
loc_3ABDA:
lea rdi, [rbp+var_30]
lea rsi, [rbp+var_38]
call _ZN9__gnu_cxxneIPKPN3CLI3AppESt6vectorIS3_SaIS3_EEEEbRKNS_17__normal_iteratorIT_T0_EESE_; __gnu_cxx::operator!=<CLI::App * const*,std::vector<CLI::App *>>(__gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>> const&,__gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>> const&)
test al, 1
jnz short loc_3ABED
jmp short loc_3AC22
loc_3ABED:
lea rdi, [rbp+var_30]
call _ZNK9__gnu_cxx17__normal_iteratorIPKPN3CLI3AppESt6vectorIS3_SaIS3_EEEdeEv; __gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>>::operator*(void)
mov rax, [rax]
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]; this
mov cl, [rbp+var_9]
mov al, [rbp+var_A]
and cl, 1
and al, 1
movzx esi, cl; bool
movzx edx, al; bool
call _ZNK3CLI3App19_process_help_flagsEbb; CLI::App::_process_help_flags(bool,bool)
lea rdi, [rbp+var_30]
call _ZN9__gnu_cxx17__normal_iteratorIPKPN3CLI3AppESt6vectorIS3_SaIS3_EEEppEv; __gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>>::operator++(void)
jmp short loc_3ABDA
loc_3AC22:
jmp loc_3ACC9
loc_3AC27:
test [rbp+var_A], 1
jz short loc_3AC76
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rbp+var_60], rax
call _ZN3CLI14CallForAllHelpC2Ev; CLI::CallForAllHelp::CallForAllHelp(void)
jmp short $+2
loc_3AC48:
mov rdi, [rbp+var_60]; void *
lea rsi, _ZTIN3CLI14CallForAllHelpE; lptinfo
lea rdx, _ZN3CLI14CallForAllHelpD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rbp+var_60]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
call ___cxa_free_exception
jmp short loc_3ACCF
loc_3AC76:
test [rbp+var_9], 1
jz short loc_3ACC5
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rbp+var_68], rax
call _ZN3CLI11CallForHelpC2Ev; CLI::CallForHelp::CallForHelp(void)
jmp short $+2
loc_3AC97:
mov rdi, [rbp+var_68]; void *
lea rsi, _ZTIN3CLI11CallForHelpE; lptinfo
lea rdx, _ZN3CLI11CallForHelpD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rbp+var_68]; void *
mov rcx, rax
mov eax, edx
mov [rbp+var_48], rcx
mov [rbp+var_4C], eax
call ___cxa_free_exception
jmp short loc_3ACCF
loc_3ACC5:
jmp short $+2
loc_3ACC7:
jmp short $+2
loc_3ACC9:
add rsp, 70h
pop rbp
retn
loc_3ACCF:
mov rdi, [rbp+var_48]
call __Unwind_Resume
| long long CLI::App::_process_help_flags(CLI::App *this, char a2, char a3)
{
long long result; // rax
CLI::App **v4; // rax
CLI::CallForHelp *v5; // [rsp+8h] [rbp-68h]
CLI::CallForAllHelp *exception; // [rsp+10h] [rbp-60h]
long long v7; // [rsp+38h] [rbp-38h] BYREF
_QWORD v8[2]; // [rsp+40h] [rbp-30h] BYREF
CLI::Option *help_all_ptr; // [rsp+50h] [rbp-20h]
CLI::Option *help_ptr; // [rsp+58h] [rbp-18h]
char v11; // [rsp+66h] [rbp-Ah]
char v12; // [rsp+67h] [rbp-9h]
CLI::App *v13; // [rsp+68h] [rbp-8h]
v13 = this;
v12 = a2 & 1;
v11 = a3 & 1;
help_ptr = (CLI::Option *)CLI::App::get_help_ptr(this);
help_all_ptr = (CLI::Option *)CLI::App::get_help_all_ptr(this);
if ( help_ptr && CLI::Option::count(help_ptr) )
v12 = 1;
if ( help_all_ptr && CLI::Option::count(help_all_ptr) )
v11 = 1;
result = std::vector<CLI::App *>::empty((char *)this + 424);
if ( (result & 1) != 0 )
{
if ( (v11 & 1) != 0 )
{
exception = (CLI::CallForAllHelp *)__cxa_allocate_exception(0x38uLL);
CLI::CallForAllHelp::CallForAllHelp(exception);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'CLI::CallForAllHelp,
CLI::CallForAllHelp::~CallForAllHelp);
}
if ( (v12 & 1) != 0 )
{
v5 = (CLI::CallForHelp *)__cxa_allocate_exception(0x38uLL);
CLI::CallForHelp::CallForHelp(v5);
__cxa_throw(v5, (struct type_info *)&`typeinfo for'CLI::CallForHelp, CLI::CallForHelp::~CallForHelp);
}
}
else
{
v8[1] = (char *)this + 424;
v8[0] = std::vector<CLI::App *>::begin((char *)this + 424);
v7 = std::vector<CLI::App *>::end((char *)this + 424);
while ( 1 )
{
result = __gnu_cxx::operator!=<CLI::App * const*,std::vector<CLI::App *>>(v8, &v7);
if ( (result & 1) == 0 )
break;
v4 = (CLI::App **)__gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>>::operator*(v8);
CLI::App::_process_help_flags(*v4, v12 & 1, v11 & 1);
__gnu_cxx::__normal_iterator<CLI::App * const*,std::vector<CLI::App *>>::operator++(v8);
}
}
return result;
}
| _process_help_flags:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,DL
MOV CL,SIL
MOV qword ptr [RBP + -0x8],RDI
AND CL,0x1
MOV byte ptr [RBP + -0x9],CL
AND AL,0x1
MOV byte ptr [RBP + -0xa],AL
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x58],RDI
CALL 0x001270a0
MOV RDI,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x18],RAX
CALL 0x001270c0
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x0013ab84
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00138fb0
CMP RAX,0x0
JBE 0x0013ab84
MOV byte ptr [RBP + -0x9],0x1
LAB_0013ab84:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x0013ab9e
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00138fb0
CMP RAX,0x0
JBE 0x0013ab9e
MOV byte ptr [RBP + -0xa],0x1
LAB_0013ab9e:
MOV RDI,qword ptr [RBP + -0x58]
ADD RDI,0x1a8
CALL 0x0013dca0
TEST AL,0x1
JNZ 0x0013ac27
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x1a8
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013c970
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0013c9a0
MOV qword ptr [RBP + -0x38],RAX
LAB_0013abda:
LEA RDI,[RBP + -0x30]
LEA RSI,[RBP + -0x38]
CALL 0x0013c9d0
TEST AL,0x1
JNZ 0x0013abed
JMP 0x0013ac22
LAB_0013abed:
LEA RDI,[RBP + -0x30]
CALL 0x0013ca10
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV CL,byte ptr [RBP + -0x9]
MOV AL,byte ptr [RBP + -0xa]
AND CL,0x1
AND AL,0x1
MOVZX ESI,CL
MOVZX EDX,AL
CALL 0x0013ab30
LEA RDI,[RBP + -0x30]
CALL 0x0013cb30
JMP 0x0013abda
LAB_0013ac22:
JMP 0x0013acc9
LAB_0013ac27:
TEST byte ptr [RBP + -0xa],0x1
JZ 0x0013ac76
MOV EDI,0x38
CALL 0x001092d0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RBP + -0x60],RAX
LAB_0013ac41:
CALL 0x0013dce0
LAB_0013ac46:
JMP 0x0013ac48
LAB_0013ac48:
MOV RDI,qword ptr [RBP + -0x60]
LEA RSI,[0x1a1640]
LEA RDX,[0x13dd80]
CALL 0x00109a30
LAB_0013ac76:
TEST byte ptr [RBP + -0x9],0x1
JZ 0x0013acc5
MOV EDI,0x38
CALL 0x001092d0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RBP + -0x68],RAX
LAB_0013ac90:
CALL 0x0013dda0
LAB_0013ac95:
JMP 0x0013ac97
LAB_0013ac97:
MOV RDI,qword ptr [RBP + -0x68]
LEA RSI,[0x1a1658]
LEA RDX,[0x13de40]
CALL 0x00109a30
LAB_0013acc5:
JMP 0x0013acc7
LAB_0013acc7:
JMP 0x0013acc9
LAB_0013acc9:
ADD RSP,0x70
POP RBP
RET
|
/* CLI::App::_process_help_flags(bool, bool) const */
void __thiscall CLI::App::_process_help_flags(App *this,bool param_1,bool param_2)
{
bool bVar1;
long lVar2;
ulong uVar3;
int8 *puVar4;
CallForAllHelp *this_00;
CallForHelp *this_01;
int8 local_40;
int8 local_38;
vector<CLI::App*,std::allocator<CLI::App*>> *local_30;
Option *local_28;
Option *local_20;
byte local_12;
byte local_11;
App *local_10;
local_12 = param_2;
local_11 = param_1;
local_10 = this;
local_20 = (Option *)get_help_ptr(this);
local_28 = (Option *)get_help_all_ptr(this);
if ((local_20 != (Option *)0x0) && (lVar2 = Option::count(local_20), lVar2 != 0)) {
local_11 = 1;
}
if ((local_28 != (Option *)0x0) && (lVar2 = Option::count(local_28), lVar2 != 0)) {
local_12 = 1;
}
uVar3 = std::vector<CLI::App*,std::allocator<CLI::App*>>::empty
((vector<CLI::App*,std::allocator<CLI::App*>> *)(this + 0x1a8));
if ((uVar3 & 1) == 0) {
local_30 = (vector<CLI::App*,std::allocator<CLI::App*>> *)(this + 0x1a8);
local_38 = std::vector<CLI::App*,std::allocator<CLI::App*>>::begin(local_30);
local_40 = std::vector<CLI::App*,std::allocator<CLI::App*>>::end(local_30);
while (bVar1 = __gnu_cxx::operator!=
((__normal_iterator *)&local_38,(__normal_iterator *)&local_40), bVar1)
{
puVar4 = (int8 *)
__gnu_cxx::
__normal_iterator<CLI::App*const*,std::vector<CLI::App*,std::allocator<CLI::App*>>>::
operator*((__normal_iterator<CLI::App*const*,std::vector<CLI::App*,std::allocator<CLI::App*>>>
*)&local_38);
_process_help_flags((App *)*puVar4,(bool)(local_11 & 1),(bool)(local_12 & 1));
__gnu_cxx::__normal_iterator<CLI::App*const*,std::vector<CLI::App*,std::allocator<CLI::App*>>>
::operator++((__normal_iterator<CLI::App*const*,std::vector<CLI::App*,std::allocator<CLI::App*>>>
*)&local_38);
}
}
else {
if ((local_12 & 1) != 0) {
this_00 = (CallForAllHelp *)__cxa_allocate_exception(0x38);
/* try { // try from 0013ac41 to 0013ac45 has its CatchHandler @ 0013ac5f */
CallForAllHelp::CallForAllHelp(this_00);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&CallForAllHelp::typeinfo,CallForAllHelp::~CallForAllHelp);
}
if ((local_11 & 1) != 0) {
this_01 = (CallForHelp *)__cxa_allocate_exception(0x38);
/* try { // try from 0013ac90 to 0013ac94 has its CatchHandler @ 0013acae */
CallForHelp::CallForHelp(this_01);
/* WARNING: Subroutine does not return */
__cxa_throw(this_01,&CallForHelp::typeinfo,CallForHelp::~CallForHelp);
}
}
return;
}
| |
22,934 | mysql_fetch_row_start | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_fetch_row_start(MYSQL_ROW *ret, MYSQL_RES *result)
{
MK_ASYNC_START_BODY(
mysql_fetch_row,
result->handle,
{
WIN_SET_NONBLOCKING(result->handle)
parms.result= result;
},
NULL,
r_ptr,
/*
If we already fetched all rows from server (eg. mysql_store_result()),
then result->handle will be NULL and we cannot suspend. But that is fine,
since in this case mysql_fetch_row cannot block anyway. Just return
directly.
*/
if (!result->handle)
{
*ret= mysql_fetch_row(result);
return 0;
})
} | O3 | c | mysql_fetch_row_start:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rsi), %rax
testq %rax, %rax
je 0x2c99a
movq 0x480(%rax), %rax
movq 0x28(%rax), %r15
leaq -0x20(%rbp), %rdx
movq %r14, (%rdx)
movb $0x1, 0x14(%r15)
leaq 0x38(%r15), %rdi
leaq 0xa1(%rip), %rsi # 0x2ca21
callq 0x31240
movw $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2c9a7
movb $0x1, 0x15(%r15)
movl (%r15), %eax
jmp 0x2ca16
movq %r14, %rdi
callq 0x1efdc
movq %rax, (%rbx)
jmp 0x2ca14
js 0x2c9af
movq 0x8(%r15), %r15
jmp 0x2ca11
movq 0x78(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x78(%r14), %rdi
leaq 0x223c3(%rip), %rax # 0x4ed90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x78(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x78(%r14), %rdi
leaq 0x223a8(%rip), %rax # 0x4eda0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x78(%r14), %rax
movb %r15b, 0x296(%rax)
movq %r15, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_fetch_row_start:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+78h]
test rax, rax
jz short loc_2C99A
mov rax, [rax+480h]
mov r15, [rax+28h]
lea rdx, [rbp+var_20]
mov [rdx], r14
mov byte ptr [r15+14h], 1
lea rdi, [r15+38h]
lea rsi, mysql_fetch_row_start_internal
call my_context_spawn
mov word ptr [r15+14h], 0
test eax, eax
jle short loc_2C9A7
mov byte ptr [r15+15h], 1
mov eax, [r15]
jmp short loc_2CA16
loc_2C99A:
mov rdi, r14
call mysql_fetch_row
mov [rbx], rax
jmp short loc_2CA14
loc_2C9A7:
js short loc_2C9AF
mov r15, [r15+8]
jmp short loc_2CA11
loc_2C9AF:
mov rax, [r14+78h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+78h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+78h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+78h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+78h]
mov [rax+296h], r15b
loc_2CA11:
mov [rbx], r15
loc_2CA14:
xor eax, eax
loc_2CA16:
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_fetch_row_start(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
long long v7; // r15
long long v8[4]; // [rsp+0h] [rbp-20h] BYREF
v8[0] = v2;
v3 = *(_QWORD *)(a2 + 120);
if ( v3 )
{
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
v8[0] = a2;
*((_BYTE *)v4 + 20) = 1;
v5 = my_context_spawn(v4 + 14, mysql_fetch_row_start_internal, v8);
*((_WORD *)v4 + 10) = 0;
if ( v5 > 0 )
{
*((_BYTE *)v4 + 21) = 1;
return *v4;
}
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 120) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 120) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v7 = 0LL;
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 120) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 120) + 662LL) = 0;
}
else
{
v7 = *((_QWORD *)v4 + 1);
}
*a1 = v7;
}
else
{
*a1 = mysql_fetch_row(a2);
}
return 0LL;
}
| mysql_fetch_row_start:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x78]
TEST RAX,RAX
JZ 0x0012c99a
MOV RAX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RAX + 0x28]
LEA RDX,[RBP + -0x20]
MOV qword ptr [RDX],R14
MOV byte ptr [R15 + 0x14],0x1
LEA RDI,[R15 + 0x38]
LEA RSI,[0x12ca21]
CALL 0x00131240
MOV word ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012c9a7
MOV byte ptr [R15 + 0x15],0x1
MOV EAX,dword ptr [R15]
JMP 0x0012ca16
LAB_0012c99a:
MOV RDI,R14
CALL 0x0011efdc
MOV qword ptr [RBX],RAX
JMP 0x0012ca14
LAB_0012c9a7:
JS 0x0012c9af
MOV R15,qword ptr [R15 + 0x8]
JMP 0x0012ca11
LAB_0012c9af:
MOV RAX,qword ptr [R14 + 0x78]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14ed90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x78]
LEA RAX,[0x14eda0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x78]
MOV byte ptr [RAX + 0x296],R15B
LAB_0012ca11:
MOV qword ptr [RBX],R15
LAB_0012ca14:
XOR EAX,EAX
LAB_0012ca16:
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_fetch_row_start(int8 *param_1,long param_2)
{
int4 *puVar1;
int iVar2;
int8 uVar3;
if (*(long *)(param_2 + 0x78) == 0) {
uVar3 = mysql_fetch_row(param_2);
*param_1 = uVar3;
}
else {
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x78) + 0x480) + 0x28);
*(int1 *)(puVar1 + 5) = 1;
iVar2 = my_context_spawn(puVar1 + 0xe,mysql_fetch_row_start_internal);
*(int2 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
*(int1 *)((long)puVar1 + 0x15) = 1;
return *puVar1;
}
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x78) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x297),SQLSTATE_UNKNOWN,5);
uVar3 = 0;
*(int1 *)(*(long *)(param_2 + 0x78) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x78) + 0x97),PTR_s_Client_run_out_of_memory_0014ede0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x78) + 0x296) = 0;
}
else {
uVar3 = *(int8 *)(puVar1 + 2);
}
*param_1 = uVar3;
}
return 0;
}
| |
22,935 | inline_mysql_cond_signal | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_signal(
mysql_cond_t *that)
{
int result;
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_COND_CALL(signal_cond)(that->m_psi);
#endif
result= pthread_cond_signal(&that->m_cond);
return result;
} | O0 | c | inline_mysql_cond_signal:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe75bb
leaq 0x1dfff9(%rip), %rax # 0x2c75a0
movq (%rax), %rax
movq 0x170(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x2a570
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
| inline_mysql_cond_signal_2:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 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 short loc_E75BB
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+170h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
loc_E75BB:
mov rdi, [rbp+var_8]
call _pthread_cond_signal
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long inline_mysql_cond_signal_2(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
((void ( *)(_QWORD))PSI_server[46])(*(_QWORD *)(a1 + 48));
return (unsigned int)pthread_cond_signal(a1);
}
| inline_mysql_cond_signal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],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 0x001e75bb
LEA RAX,[0x3c75a0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x170]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
LAB_001e75bb:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a570
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int inline_mysql_cond_signal(pthread_cond_t *param_1)
{
int iVar1;
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x170))(param_1[1].__align);
}
iVar1 = pthread_cond_signal(param_1);
return iVar1;
}
| |
22,936 | THD::restore_sub_statement_state(Sub_statement_state*) | eloqsql/sql/sql_class.cc | void THD::restore_sub_statement_state(Sub_statement_state *backup)
{
DBUG_ENTER("THD::restore_sub_statement_state");
#ifndef EMBEDDED_LIBRARY
/* BUG#33029, if we are replicating from a buggy master, restore
auto_inc_intervals_forced so that the top statement can use the
INSERT_ID value set before this statement.
*/
if (rpl_master_erroneous_autoinc(this))
{
backup->auto_inc_intervals_forced.swap(&auto_inc_intervals_forced);
DBUG_ASSERT(backup->auto_inc_intervals_forced.nb_elements() == 0);
}
#endif
/*
To save resources we want to release savepoints which were created
during execution of function or trigger before leaving their savepoint
level. It is enough to release first savepoint set on this level since
all later savepoints will be released automatically.
*/
if (transaction->savepoints)
{
SAVEPOINT *sv;
for (sv= transaction->savepoints; sv->prev; sv= sv->prev)
{}
/* ha_release_savepoint() never returns error. */
(void)ha_release_savepoint(this, sv);
}
count_cuted_fields= backup->count_cuted_fields;
transaction->savepoints= backup->savepoints;
variables.option_bits= backup->option_bits;
in_sub_stmt= backup->in_sub_stmt;
enable_slow_log= backup->enable_slow_log;
first_successful_insert_id_in_prev_stmt=
backup->first_successful_insert_id_in_prev_stmt;
first_successful_insert_id_in_cur_stmt=
backup->first_successful_insert_id_in_cur_stmt;
limit_found_rows= backup->limit_found_rows;
set_sent_row_count(backup->sent_row_count);
client_capabilities= backup->client_capabilities;
/* Restore statistic needed for slow log */
add_slow_query_state(backup);
/*
If we've left sub-statement mode, reset the fatal error flag.
Otherwise keep the current value, to propagate it up the sub-statement
stack.
NOTE: is_fatal_sub_stmt_error can be set only if we've been in the
sub-statement mode.
*/
if (!in_sub_stmt)
is_fatal_sub_stmt_error= false;
if ((variables.option_bits & OPTION_BIN_LOG) && is_update_query(lex->sql_command) &&
!is_current_stmt_binlog_format_row())
mysql_bin_log.stop_union_events(this);
/*
The following is added to the old values as we are interested in the
total complexity of the query
*/
inc_examined_row_count(backup->examined_row_count);
cuted_fields+= backup->cuted_fields;
DBUG_VOID_RETURN;
} | O0 | cpp | THD::restore_sub_statement_state(Sub_statement_state*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4cf740
testb $0x1, %al
jne 0x54bb43
jmp 0x54bb5f
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
addq $0x3aa0, %rsi # imm = 0x3AA0
callq 0x553270
jmp 0x54bb5d
jmp 0x54bb5f
movq -0x20(%rbp), %rax
movq 0x3998(%rax), %rax
cmpq $0x0, (%rax)
je 0x54bba8
movq -0x20(%rbp), %rax
movq 0x3998(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x54bb9b
jmp 0x54bb8e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x54bb82
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8de6a0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xd0(%rax), %eax
movl %eax, 0x3e80(%rdi)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq 0x3998(%rdi), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8a8(%rdi)
movq -0x10(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, 0x27b0(%rdi)
movq -0x10(%rbp), %rax
movb 0xcc(%rax), %al
andb $0x1, %al
movb %al, 0x3fc4(%rdi)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x3a60(%rdi)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x3a70(%rdi)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x3ac0(%rdi)
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rsi
callq 0x545ce0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x25a8(%rdi)
movq -0x10(%rbp), %rsi
callq 0x54bd00
movq -0x20(%rbp), %rax
cmpl $0x0, 0x27b0(%rax)
jne 0x54bc70
movq -0x20(%rbp), %rax
movb $0x0, 0x3fb7(%rax)
movq -0x20(%rbp), %rax
movq 0x8a8(%rax), %rax
andq $0x40000, %rax # imm = 0x40000
cmpq $0x0, %rax
je 0x54bcbb
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movl 0x8(%rax), %edi
callq 0x5b1200
testb $0x1, %al
jne 0x54bc9d
jmp 0x54bcbb
movq -0x20(%rbp), %rdi
callq 0x4e3b60
cmpl $0x0, %eax
jne 0x54bcbb
movq -0x20(%rbp), %rsi
leaq 0x10a89d2(%rip), %rdi # 0x15f4688
callq 0x9f6030
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x54bdf0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x80(%rcx), %rcx
addq 0x3ad0(%rax), %rcx
movq %rcx, 0x3ad0(%rax)
jmp 0x54bcee
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN3THD27restore_sub_statement_stateEP19Sub_statement_state:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rdi, [rbp+var_8]; THD *
mov [rbp+var_20], rdi
call _Z28rpl_master_erroneous_autoincP3THD; rpl_master_erroneous_autoinc(THD *)
test al, 1
jnz short loc_54BB43
jmp short loc_54BB5F
loc_54BB43:
mov rsi, [rbp+var_20]
mov rdi, [rbp+var_10]
add rdi, 20h ; ' '; this
add rsi, 3AA0h; Discrete_intervals_list *
call _ZN23Discrete_intervals_list4swapEPS_; Discrete_intervals_list::swap(Discrete_intervals_list*)
jmp short $+2
loc_54BB5D:
jmp short $+2
loc_54BB5F:
mov rax, [rbp+var_20]
mov rax, [rax+3998h]
cmp qword ptr [rax], 0
jz short loc_54BBA8
mov rax, [rbp+var_20]
mov rax, [rax+3998h]
mov rax, [rax]
mov [rbp+var_18], rax
loc_54BB82:
mov rax, [rbp+var_18]
cmp qword ptr [rax], 0
jz short loc_54BB9B
jmp short $+2
loc_54BB8E:
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_18], rax
jmp short loc_54BB82
loc_54BB9B:
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_18]
call _Z20ha_release_savepointP3THDP12st_savepoint; ha_release_savepoint(THD *,st_savepoint *)
loc_54BBA8:
mov rdi, [rbp+var_20]; this
mov rax, [rbp+var_10]
mov eax, [rax+0D0h]
mov [rdi+3E80h], eax
mov rax, [rbp+var_10]
mov rcx, [rax+40h]
mov rax, [rdi+3998h]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rax, [rax+48h]
mov [rdi+8A8h], rax
mov rax, [rbp+var_10]
mov eax, [rax+0C8h]
mov [rdi+27B0h], eax
mov rax, [rbp+var_10]
mov al, [rax+0CCh]
and al, 1
mov [rdi+3FC4h], al
mov rax, [rbp+var_10]
mov rax, [rax+50h]
mov [rdi+3A60h], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rdi+3A70h], rax
mov rax, [rbp+var_10]
mov rax, [rax+68h]
mov [rdi+3AC0h], rax
mov rax, [rbp+var_10]
mov rsi, [rax+88h]; unsigned __int64
call _ZN3THD18set_sent_row_countEy; THD::set_sent_row_count(ulong long)
mov rdi, [rbp+var_20]
mov rax, [rbp+var_10]
mov rax, [rax+78h]
mov [rdi+25A8h], rax
mov rsi, [rbp+var_10]
call _ZN3THD20add_slow_query_stateEP19Sub_statement_state; THD::add_slow_query_state(Sub_statement_state *)
mov rax, [rbp+var_20]
cmp dword ptr [rax+27B0h], 0
jnz short loc_54BC70
mov rax, [rbp+var_20]
mov byte ptr [rax+3FB7h], 0
loc_54BC70:
mov rax, [rbp+var_20]
mov rax, [rax+8A8h]
and rax, 40000h
cmp rax, 0
jz short loc_54BCBB
mov rax, [rbp+var_20]
mov rax, [rax+58h]
mov edi, [rax+8]
call _Z15is_update_query16enum_sql_command; is_update_query(enum_sql_command)
test al, 1
jnz short loc_54BC9D
jmp short loc_54BCBB
loc_54BC9D:
mov rdi, [rbp+var_20]; this
call _ZNK3THD33is_current_stmt_binlog_format_rowEv; THD::is_current_stmt_binlog_format_row(void)
cmp eax, 0
jnz short loc_54BCBB
mov rsi, [rbp+var_20]; THD *
lea rdi, mysql_bin_log; this
call _ZN13MYSQL_BIN_LOG17stop_union_eventsEP3THD; MYSQL_BIN_LOG::stop_union_events(THD *)
loc_54BCBB:
mov rdi, [rbp+var_20]; this
mov rax, [rbp+var_10]
mov rsi, [rax+90h]; unsigned __int64
call _ZN3THD22inc_examined_row_countEy; THD::inc_examined_row_count(ulong long)
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov rcx, [rcx+80h]
add rcx, [rax+3AD0h]
mov [rax+3AD0h], rcx
jmp short $+2
loc_54BCEE:
add rsp, 20h
pop rbp
retn
| THD * THD::restore_sub_statement_state(THD *this, Sub_statement_state *a2)
{
THD *result; // rax
_QWORD *i; // [rsp+8h] [rbp-18h]
if ( (rpl_master_erroneous_autoinc(this) & 1) != 0 )
Discrete_intervals_list::swap((Sub_statement_state *)((char *)a2 + 32), (THD *)((char *)this + 15008));
if ( **((_QWORD **)this + 1843) )
{
for ( i = (_QWORD *)**((_QWORD **)this + 1843); *i; i = (_QWORD *)*i )
;
ha_release_savepoint(this, i);
}
*((_DWORD *)this + 4000) = *((_DWORD *)a2 + 52);
**((_QWORD **)this + 1843) = *((_QWORD *)a2 + 8);
*((_QWORD *)this + 277) = *((_QWORD *)a2 + 9);
*((_DWORD *)this + 2540) = *((_DWORD *)a2 + 50);
*((_BYTE *)this + 16324) = *((_BYTE *)a2 + 204) & 1;
*((_QWORD *)this + 1868) = *((_QWORD *)a2 + 10);
*((_QWORD *)this + 1870) = *((_QWORD *)a2 + 11);
*((_QWORD *)this + 1880) = *((_QWORD *)a2 + 13);
THD::set_sent_row_count(this, *((_QWORD *)a2 + 17));
*((_QWORD *)this + 1205) = *((_QWORD *)a2 + 15);
THD::add_slow_query_state(this, a2);
if ( !*((_DWORD *)this + 2540) )
*((_BYTE *)this + 16311) = 0;
if ( (*((_QWORD *)this + 277) & 0x40000LL) != 0
&& (is_update_query(*(unsigned int *)(*((_QWORD *)this + 11) + 8LL)) & 1) != 0
&& !THD::is_current_stmt_binlog_format_row(this) )
{
MYSQL_BIN_LOG::stop_union_events((MYSQL_BIN_LOG *)&mysql_bin_log, this);
}
THD::inc_examined_row_count(this, *((_QWORD *)a2 + 18));
result = this;
*((_QWORD *)this + 1882) += *((_QWORD *)a2 + 16);
return result;
}
| __cxx_global_var_init.7:
PUSH RBP
MOV RBP,RSP
LEA RDI,[0x16d0404]
MOV ESI,0x2000000
CALL 0x0058cc10
POP RBP
RET
|
void __cxx_global_var_init_7(void)
{
date_conv_mode_t::date_conv_mode_t((date_conv_mode_t *)&TIME_INVALID_DATES,0x2000000);
return;
}
| |
22,937 | my_rw_init | eloqsql/mysys/thr_rwlock.c | int my_rw_init(my_rw_lock_t *rwp)
{
pthread_condattr_t cond_attr;
pthread_mutex_init( &rwp->lock, MY_MUTEX_INIT_FAST);
pthread_condattr_init( &cond_attr );
pthread_cond_init( &rwp->readers, &cond_attr );
pthread_cond_init( &rwp->writers, &cond_attr );
pthread_condattr_destroy(&cond_attr);
rwp->state = 0;
rwp->waiters = 0;
#ifdef SAFE_MUTEX
rwp->write_thread = 0;
#endif
return(0);
} | O0 | c | my_rw_init:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3b54d9(%rip), %rsi # 0x410620
callq 0x264f0
leaq -0xc(%rbp), %rdi
callq 0x260a0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
leaq -0xc(%rbp), %rsi
callq 0x263e0
movq -0x8(%rbp), %rdi
addq $0x58, %rdi
leaq -0xc(%rbp), %rsi
callq 0x263e0
leaq -0xc(%rbp), %rdi
callq 0x261b0
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8c(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_rw_init:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
lea rsi, my_fast_mutexattr
call _pthread_mutex_init
lea rdi, [rbp+var_C]
call _pthread_condattr_init
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
lea rsi, [rbp+var_C]
call _pthread_cond_init
mov rdi, [rbp+var_8]
add rdi, 58h ; 'X'
lea rsi, [rbp+var_C]
call _pthread_cond_init
lea rdi, [rbp+var_C]
call _pthread_condattr_destroy
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+8Ch], 0
xor eax, eax
add rsp, 10h
pop rbp
retn
| long long my_rw_init(long long a1)
{
_BYTE v2[4]; // [rsp+4h] [rbp-Ch] BYREF
long long v3; // [rsp+8h] [rbp-8h]
v3 = a1;
pthread_mutex_init(a1, &my_fast_mutexattr);
pthread_condattr_init(v2);
pthread_cond_init(v3 + 40, v2);
pthread_cond_init(v3 + 88, v2);
pthread_condattr_destroy(v2);
*(_DWORD *)(v3 + 136) = 0;
*(_DWORD *)(v3 + 140) = 0;
return 0LL;
}
| my_rw_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
LEA RSI,[0x510620]
CALL 0x001264f0
LEA RDI,[RBP + -0xc]
CALL 0x001260a0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
LEA RSI,[RBP + -0xc]
CALL 0x001263e0
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x58
LEA RSI,[RBP + -0xc]
CALL 0x001263e0
LEA RDI,[RBP + -0xc]
CALL 0x001261b0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x8c],0x0
XOR EAX,EAX
ADD RSP,0x10
POP RBP
RET
|
int8 my_rw_init(pthread_mutex_t *param_1)
{
pthread_condattr_t local_14;
pthread_mutex_t *local_10;
local_10 = param_1;
pthread_mutex_init(param_1,(pthread_mutexattr_t *)&my_fast_mutexattr);
pthread_condattr_init(&local_14);
pthread_cond_init((pthread_cond_t *)(local_10 + 1),&local_14);
pthread_cond_init((pthread_cond_t *)((long)local_10 + 0x58),&local_14);
pthread_condattr_destroy(&local_14);
*(int4 *)((long)local_10 + 0x88) = 0;
*(int4 *)((long)local_10 + 0x8c) = 0;
return 0;
}
| |
22,938 | test_if_reopen | eloqsql/storage/myisam/mi_open.c | MI_INFO *test_if_reopen(char *filename)
{
LIST *pos;
for (pos=myisam_open_list ; pos ; pos=pos->next)
{
MI_INFO *info=(MI_INFO*) pos->data;
MYISAM_SHARE *share=info->s;
DBUG_ASSERT(strcmp(share->unique_file_name,filename) ||
share->last_version);
if (!strcmp(share->unique_file_name,filename) && share->last_version)
return info;
}
return 0;
} | O0 | c | test_if_reopen:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xbc80cd(%rip), %rax # 0xc7a550
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb24eb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb24aa
movq -0x28(%rbp), %rax
movq 0x258(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a660
cmpl $0x0, %eax
jne 0xb24db
movq -0x28(%rbp), %rax
cmpq $0x0, 0x310(%rax)
je 0xb24db
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb24f3
jmp 0xb24dd
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb248a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| test_if_reopen:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
lea rax, myisam_open_list
mov rax, [rax]
mov [rbp+var_18], rax
loc_B248A:
cmp [rbp+var_18], 0
jz short loc_B24EB
mov rax, [rbp+var_18]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_28], rax
jmp short $+2
loc_B24AA:
mov rax, [rbp+var_28]
mov rdi, [rax+258h]
mov rsi, [rbp+var_10]
call _strcmp
cmp eax, 0
jnz short loc_B24DB
mov rax, [rbp+var_28]
cmp qword ptr [rax+310h], 0
jz short loc_B24DB
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_B24F3
loc_B24DB:
jmp short $+2
loc_B24DD:
mov rax, [rbp+var_18]
mov rax, [rax+8]
mov [rbp+var_18], rax
jmp short loc_B248A
loc_B24EB:
mov [rbp+var_8], 0
loc_B24F3:
mov rax, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| long long * test_if_reopen(long long a1)
{
long long v2; // [rsp+8h] [rbp-28h]
long long *v3; // [rsp+10h] [rbp-20h]
long long i; // [rsp+18h] [rbp-18h]
for ( i = myisam_open_list; i; i = *(_QWORD *)(i + 8) )
{
v3 = *(long long **)(i + 16);
v2 = *v3;
if ( !(unsigned int)strcmp(*(_QWORD *)(*v3 + 600), a1) && *(_QWORD *)(v2 + 784) )
return v3;
}
return 0LL;
}
| test_if_reopen:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
LEA RAX,[0xd7a550]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
LAB_001b248a:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001b24eb
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x28],RAX
JMP 0x001b24aa
LAB_001b24aa:
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x258]
MOV RSI,qword ptr [RBP + -0x10]
CALL 0x0012a660
CMP EAX,0x0
JNZ 0x001b24db
MOV RAX,qword ptr [RBP + -0x28]
CMP qword ptr [RAX + 0x310],0x0
JZ 0x001b24db
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001b24f3
LAB_001b24db:
JMP 0x001b24dd
LAB_001b24dd:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001b248a
LAB_001b24eb:
MOV qword ptr [RBP + -0x8],0x0
LAB_001b24f3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
long * test_if_reopen(char *param_1)
{
long *plVar1;
long lVar2;
int iVar3;
long local_20;
local_20 = myisam_open_list;
while( true ) {
if (local_20 == 0) {
return (long *)0x0;
}
plVar1 = *(long **)(local_20 + 0x10);
lVar2 = *plVar1;
iVar3 = strcmp(*(char **)(lVar2 + 600),param_1);
if ((iVar3 == 0) && (*(long *)(lVar2 + 0x310) != 0)) break;
local_20 = *(long *)(local_20 + 8);
}
return plVar1;
}
| |
22,939 | ma_bitmap_unpin_all | eloqsql/storage/maria/ma_bitmap.c | static void _ma_bitmap_unpin_all(MARIA_SHARE *share)
{
MARIA_FILE_BITMAP *bitmap= &share->bitmap;
MARIA_PINNED_PAGE *page_link= ((MARIA_PINNED_PAGE*)
dynamic_array_ptr(&bitmap->pinned_pages, 0));
MARIA_PINNED_PAGE *pinned_page= page_link + bitmap->pinned_pages.elements;
DBUG_ENTER("_ma_bitmap_unpin_all");
DBUG_PRINT("info", ("pinned: %u", bitmap->pinned_pages.elements));
while (pinned_page-- != page_link)
pagecache_unlock_by_link(share->pagecache, pinned_page->link,
pinned_page->unlock, PAGECACHE_UNPIN,
LSN_IMPOSSIBLE, LSN_IMPOSSIBLE, FALSE, TRUE);
bitmap->pinned_pages.elements= 0;
DBUG_VOID_RETURN;
} | O3 | c | ma_bitmap_unpin_all:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xb58(%rdi), %eax
testq %rax, %rax
je 0x3fd67
movq 0xb50(%rbx), %r14
shlq $0x3, %rax
leaq (%rax,%rax,2), %r15
movq 0x600(%rbx), %rdi
movq -0x18(%r14,%r15), %rsi
movl -0x10(%r14,%r15), %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x1
pushq $0x0
callq 0x31ea5
addq $0x10, %rsp
addq $-0x18, %r15
jne 0x3fd38
movl $0x0, 0xb58(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _ma_bitmap_unpin_all:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov eax, [rdi+0B58h]
test rax, rax
jz short loc_3FD67
mov r14, [rbx+0B50h]
shl rax, 3
lea r15, [rax+rax*2]
loc_3FD38:
mov rdi, [rbx+600h]
mov rsi, [r14+r15-18h]
mov edx, [r14+r15-10h]
mov ecx, 3
xor r8d, r8d
xor r9d, r9d
push 1
push 0
call pagecache_unlock_by_link
add rsp, 10h
add r15, 0FFFFFFFFFFFFFFE8h
jnz short loc_3FD38
loc_3FD67:
mov dword ptr [rbx+0B58h], 0
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long ma_bitmap_unpin_all(long long a1)
{
long long result; // rax
long long v2; // r14
long long v3; // r15
result = *(unsigned int *)(a1 + 2904);
if ( *(_DWORD *)(a1 + 2904) )
{
v2 = *(_QWORD *)(a1 + 2896);
v3 = 24 * result;
do
{
result = pagecache_unlock_by_link(
*(_QWORD *)(a1 + 1536),
*(_QWORD *)(v2 + v3 - 24),
*(_DWORD *)(v2 + v3 - 16),
3,
0LL,
0LL,
0);
v3 -= 24LL;
}
while ( v3 );
}
*(_DWORD *)(a1 + 2904) = 0;
return result;
}
| _ma_bitmap_unpin_all:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0xb58]
TEST RAX,RAX
JZ 0x0013fd67
MOV R14,qword ptr [RBX + 0xb50]
SHL RAX,0x3
LEA R15,[RAX + RAX*0x2]
LAB_0013fd38:
MOV RDI,qword ptr [RBX + 0x600]
MOV RSI,qword ptr [R14 + R15*0x1 + -0x18]
MOV EDX,dword ptr [R14 + R15*0x1 + -0x10]
MOV ECX,0x3
XOR R8D,R8D
XOR R9D,R9D
PUSH 0x1
PUSH 0x0
CALL 0x00131ea5
ADD RSP,0x10
ADD R15,-0x18
JNZ 0x0013fd38
LAB_0013fd67:
MOV dword ptr [RBX + 0xb58],0x0
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
void _ma_bitmap_unpin_all(long param_1)
{
long lVar1;
long lVar2;
if ((ulong)*(uint *)(param_1 + 0xb58) != 0) {
lVar1 = *(long *)(param_1 + 0xb50);
lVar2 = (ulong)*(uint *)(param_1 + 0xb58) * 0x18;
do {
pagecache_unlock_by_link
(*(int8 *)(param_1 + 0x600),*(int8 *)(lVar1 + -0x18 + lVar2),
*(int4 *)(lVar1 + -0x10 + lVar2),3,0,0,0,1);
lVar2 = lVar2 + -0x18;
} while (lVar2 != 0);
}
*(int4 *)(param_1 + 0xb58) = 0;
return;
}
| |
22,940 | test_if_hard_path | eloqsql/mysys/my_getwd.c | int test_if_hard_path(register const char *dir_name)
{
if (dir_name[0] == FN_HOMELIB && dir_name[1] == FN_LIBCHAR)
return (home_dir != NullS && test_if_hard_path(home_dir));
if (dir_name[0] == FN_LIBCHAR)
return (TRUE);
#ifdef FN_DEVCHAR
return (strchr(dir_name,FN_DEVCHAR) != 0);
#else
return FALSE;
#endif
} | O3 | c | test_if_hard_path:
pushq %rbp
movq %rsp, %rbp
leaq 0xb6d837(%rip), %rax # 0xc12028
movq (%rax), %rax
movb (%rdi), %cl
cmpb $0x7e, %cl
jne 0xa480d
cmpb $0x2f, 0x1(%rdi)
jne 0xa480d
movq %rax, %rdi
testq %rax, %rax
jne 0xa47f4
xorl %eax, %eax
jmp 0xa4815
xorl %eax, %eax
cmpb $0x2f, %cl
sete %al
popq %rbp
retq
| test_if_hard_path:
push rbp
mov rbp, rsp
lea rax, home_dir
mov rax, [rax]
loc_A47F4:
mov cl, [rdi]
cmp cl, 7Eh ; '~'
jnz short loc_A480D
cmp byte ptr [rdi+1], 2Fh ; '/'
jnz short loc_A480D
mov rdi, rax
test rax, rax
jnz short loc_A47F4
xor eax, eax
jmp short loc_A4815
loc_A480D:
xor eax, eax
cmp cl, 2Fh ; '/'
setz al
loc_A4815:
pop rbp
retn
| _BOOL8 test_if_hard_path(_BYTE *a1)
{
while ( *a1 == 126 && a1[1] == 47 )
{
a1 = (_BYTE *)home_dir;
if ( !home_dir )
return 0LL;
}
return *a1 == 47;
}
| test_if_hard_path:
PUSH RBP
MOV RBP,RSP
LEA RAX,[0xd12028]
MOV RAX,qword ptr [RAX]
LAB_001a47f4:
MOV CL,byte ptr [RDI]
CMP CL,0x7e
JNZ 0x001a480d
CMP byte ptr [RDI + 0x1],0x2f
JNZ 0x001a480d
MOV RDI,RAX
TEST RAX,RAX
JNZ 0x001a47f4
XOR EAX,EAX
JMP 0x001a4815
LAB_001a480d:
XOR EAX,EAX
CMP CL,0x2f
SETZ AL
LAB_001a4815:
POP RBP
RET
|
bool test_if_hard_path(char *param_1)
{
while ((*param_1 == '~' && (param_1[1] == '/'))) {
param_1 = home_dir;
if (home_dir == (char *)0x0) {
return false;
}
}
return *param_1 == '/';
}
| |
22,941 | my_init_mysys_psi_keys | eloqsql/mysys/my_init.c | void my_init_mysys_psi_keys()
{
const char* category= "mysys";
int count;
count= sizeof(all_mysys_mutexes)/sizeof(all_mysys_mutexes[0]);
mysql_mutex_register(category, all_mysys_mutexes, count);
count= sizeof(all_mysys_conds)/sizeof(all_mysys_conds[0]);
mysql_cond_register(category, all_mysys_conds, count);
count= sizeof(all_mysys_rwlocks)/sizeof(all_mysys_rwlocks[0]);
mysql_rwlock_register(category, all_mysys_rwlocks, count);
count= sizeof(all_mysys_threads)/sizeof(all_mysys_threads[0]);
mysql_thread_register(category, all_mysys_threads, count);
count= sizeof(all_mysys_files)/sizeof(all_mysys_files[0]);
mysql_file_register(category, all_mysys_files, count);
count= array_elements(all_mysys_stages);
mysql_stage_register(category, all_mysys_stages, count);
} | O3 | c | my_init_mysys_psi_keys:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x2efd9f(%rip), %r14 # 0x3aea18
movq (%r14), %rax
leaq 0x4192b(%rip), %rbx # 0x1005ae
leaq 0x2ef536(%rip), %rsi # 0x3ae1c0
movq %rbx, %rdi
movl $0x13, %edx
callq *(%rax)
movq (%r14), %rax
leaq 0x2ef6f2(%rip), %rsi # 0x3ae390
movq %rbx, %rdi
movl $0x7, %edx
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x2ef78d(%rip), %rsi # 0x3ae440
movq %rbx, %rdi
movl $0x1, %edx
callq *0x8(%rax)
movq (%r14), %rax
leaq 0x2ef798(%rip), %rsi # 0x3ae460
movq %rbx, %rdi
movl $0x1, %edx
callq *0x18(%rax)
movq (%r14), %rax
leaq 0x2ef7a3(%rip), %rsi # 0x3ae480
movq %rbx, %rdi
movl $0x2, %edx
callq *0x20(%rax)
movq (%r14), %rax
movq 0x28(%rax), %rax
leaq 0x2ef4ba(%rip), %rsi # 0x3ae1b0
movq %rbx, %rdi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
| my_init_mysys_psi_keys:
push rbp
mov rbp, rsp
push r14
push rbx
lea r14, PSI_server
mov rax, [r14]
lea rbx, aMysys; "mysys"
lea rsi, all_mysys_mutexes
mov rdi, rbx
mov edx, 13h
call qword ptr [rax]
mov rax, [r14]
lea rsi, all_mysys_conds
mov rdi, rbx
mov edx, 7
call qword ptr [rax+10h]
mov rax, [r14]
lea rsi, all_mysys_rwlocks
mov rdi, rbx
mov edx, 1
call qword ptr [rax+8]
mov rax, [r14]
lea rsi, all_mysys_threads
mov rdi, rbx
mov edx, 1
call qword ptr [rax+18h]
mov rax, [r14]
lea rsi, all_mysys_files
mov rdi, rbx
mov edx, 2
call qword ptr [rax+20h]
mov rax, [r14]
mov rax, [rax+28h]
lea rsi, all_mysys_stages
mov rdi, rbx
mov edx, 1
pop rbx
pop r14
pop rbp
jmp rax
| long long my_init_mysys_psi_keys()
{
((void ( *)(const char *, _UNKNOWN **, long long))*PSI_server)("mysys", &all_mysys_mutexes, 19LL);
((void ( *)(const char *, _UNKNOWN **, long long))PSI_server[2])("mysys", &all_mysys_conds, 7LL);
((void ( *)(const char *, _UNKNOWN **, long long))PSI_server[1])("mysys", &all_mysys_rwlocks, 1LL);
((void ( *)(const char *, _UNKNOWN **, long long))PSI_server[3])("mysys", &all_mysys_threads, 1LL);
((void ( *)(const char *, _UNKNOWN **, long long))PSI_server[4])("mysys", &all_mysys_files, 2LL);
return ((long long ( *)(const char *, _UNKNOWN **, long long))PSI_server[5])("mysys", &all_mysys_stages, 1LL);
}
| my_init_mysys_psi_keys:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
LEA R14,[0x4aea18]
MOV RAX,qword ptr [R14]
LEA RBX,[0x2005ae]
LEA RSI,[0x4ae1c0]
MOV RDI,RBX
MOV EDX,0x13
CALL qword ptr [RAX]
MOV RAX,qword ptr [R14]
LEA RSI,[0x4ae390]
MOV RDI,RBX
MOV EDX,0x7
CALL qword ptr [RAX + 0x10]
MOV RAX,qword ptr [R14]
LEA RSI,[0x4ae440]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x8]
MOV RAX,qword ptr [R14]
LEA RSI,[0x4ae460]
MOV RDI,RBX
MOV EDX,0x1
CALL qword ptr [RAX + 0x18]
MOV RAX,qword ptr [R14]
LEA RSI,[0x4ae480]
MOV RDI,RBX
MOV EDX,0x2
CALL qword ptr [RAX + 0x20]
MOV RAX,qword ptr [R14]
MOV RAX,qword ptr [RAX + 0x28]
LEA RSI,[0x4ae1b0]
MOV RDI,RBX
MOV EDX,0x1
POP RBX
POP R14
POP RBP
JMP RAX
|
void my_init_mysys_psi_keys(void)
{
(**(code **)PSI_server)("mysys",all_mysys_mutexes,0x13);
(**(code **)(PSI_server + 0x10))("mysys",all_mysys_conds,7);
(**(code **)(PSI_server + 8))("mysys",all_mysys_rwlocks,1);
(**(code **)(PSI_server + 0x18))("mysys",all_mysys_threads,1);
(**(code **)(PSI_server + 0x20))("mysys",all_mysys_files,2);
/* WARNING: Could not recover jumptable at 0x001bed02. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(PSI_server + 0x28))("mysys",&all_mysys_stages,1);
return;
}
| |
22,942 | bitmap_union | eloqsql/mysys/my_bitmap.c | void bitmap_union(MY_BITMAP *map, const MY_BITMAP *map2)
{
my_bitmap_map *to= map->bitmap, *from= map2->bitmap, *end;
DBUG_ASSERT(map->bitmap);
DBUG_ASSERT(map2->bitmap);
DBUG_ASSERT(map->n_bits == map2->n_bits);
end= map->last_word_ptr;
while (to <= end)
*to++ |= *from++;
} | O0 | c | bitmap_union:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xeee14
jmp 0xeee16
jmp 0xeee18
jmp 0xeee1a
jmp 0xeee1c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0xeee58
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x20(%rbp)
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x18(%rbp)
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0xeee28
popq %rbp
retq
nopw (%rax,%rax)
| bitmap_union:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short $+2
loc_EEE14:
jmp short $+2
loc_EEE16:
jmp short $+2
loc_EEE18:
jmp short $+2
loc_EEE1A:
jmp short $+2
loc_EEE1C:
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_28], rax
loc_EEE28:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_28]
ja short loc_EEE58
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 4
mov [rbp+var_20], rcx
mov ecx, [rax]
mov rax, [rbp+var_18]
mov rdx, rax
add rdx, 4
mov [rbp+var_18], rdx
or ecx, [rax]
mov [rax], ecx
jmp short loc_EEE28
loc_EEE58:
pop rbp
retn
| _DWORD * bitmap_union(_QWORD *a1, int **a2)
{
_DWORD *result; // rax
int *v3; // rax
int v4; // ecx
_DWORD *v5; // rax
unsigned long long v6; // [rsp+0h] [rbp-28h]
int *v7; // [rsp+8h] [rbp-20h]
_DWORD *v8; // [rsp+10h] [rbp-18h]
v8 = (_DWORD *)*a1;
v7 = *a2;
v6 = a1[1];
while ( 1 )
{
result = v8;
if ( (unsigned long long)v8 > v6 )
break;
v3 = v7++;
v4 = *v3;
v5 = v8++;
*v5 |= v4;
}
return result;
}
| bitmap_union:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001eee14
LAB_001eee14:
JMP 0x001eee16
LAB_001eee16:
JMP 0x001eee18
LAB_001eee18:
JMP 0x001eee1a
LAB_001eee1a:
JMP 0x001eee1c
LAB_001eee1c:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_001eee28:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x28]
JA 0x001eee58
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x4
MOV qword ptr [RBP + -0x20],RCX
MOV ECX,dword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RDX,RAX
ADD RDX,0x4
MOV qword ptr [RBP + -0x18],RDX
OR ECX,dword ptr [RAX]
MOV dword ptr [RAX],ECX
JMP 0x001eee28
LAB_001eee58:
POP RBP
RET
|
void bitmap_union(int8 *param_1,int8 *param_2)
{
uint *puVar1;
uint *local_28;
uint *local_20;
puVar1 = (uint *)param_1[1];
local_28 = (uint *)*param_2;
local_20 = (uint *)*param_1;
while (local_20 <= puVar1) {
*local_20 = *local_28 | *local_20;
local_28 = local_28 + 1;
local_20 = local_20 + 1;
}
return;
}
| |
22,943 | common_context_params_to_llama(common_params const&) | monkey531[P]llama/common/common.cpp | struct llama_context_params common_context_params_to_llama(const common_params & params) {
auto cparams = llama_context_default_params();
cparams.n_ctx = params.n_ctx;
cparams.n_seq_max = params.n_parallel;
cparams.n_batch = params.n_batch;
cparams.n_ubatch = params.n_ubatch;
cparams.n_threads = params.cpuparams.n_threads;
cparams.n_threads_batch = params.cpuparams_batch.n_threads == -1 ?
params.cpuparams.n_threads : params.cpuparams_batch.n_threads;
cparams.logits_all = params.logits_all;
cparams.embeddings = params.embedding;
cparams.rope_scaling_type = params.rope_scaling_type;
cparams.rope_freq_base = params.rope_freq_base;
cparams.rope_freq_scale = params.rope_freq_scale;
cparams.yarn_ext_factor = params.yarn_ext_factor;
cparams.yarn_attn_factor = params.yarn_attn_factor;
cparams.yarn_beta_fast = params.yarn_beta_fast;
cparams.yarn_beta_slow = params.yarn_beta_slow;
cparams.yarn_orig_ctx = params.yarn_orig_ctx;
cparams.pooling_type = params.pooling_type;
cparams.attention_type = params.attention_type;
cparams.defrag_thold = params.defrag_thold;
cparams.cb_eval = params.cb_eval;
cparams.cb_eval_user_data = params.cb_eval_user_data;
cparams.offload_kqv = !params.no_kv_offload;
cparams.flash_attn = params.flash_attn;
cparams.no_perf = params.no_perf;
if (params.reranking) {
cparams.embeddings = true;
cparams.pooling_type = LLAMA_POOLING_TYPE_RANK;
}
cparams.type_k = params.cache_type_k;
cparams.type_v = params.cache_type_v;
return cparams;
} | O2 | cpp | common_context_params_to_llama(common_params const&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x260c0
movl 0x18(%r14), %eax
movl %eax, 0xc(%rbx)
movq 0x4(%r14), %rax
movq %rax, (%rbx)
movl 0xc(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0x274(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x488(%r14), %ecx
cmpl $-0x1, %ecx
cmovel %eax, %ecx
movl %ecx, 0x14(%rbx)
movb 0xfe8(%r14), %al
movb %al, 0x60(%rbx)
movb 0x1038(%r14), %al
movb %al, 0x61(%rbx)
movups 0x2c(%r14), %xmm0
movups %xmm0, 0x24(%rbx)
movsd 0x3c(%r14), %xmm0
movsd %xmm0, 0x34(%rbx)
movl 0x44(%r14), %eax
movl %eax, 0x3c(%rbx)
movq 0x6b4(%r14), %rax
movq %rax, 0x18(%rbx)
movl 0x6bc(%r14), %eax
movl %eax, 0x20(%rbx)
movss 0x48(%r14), %xmm0
movss %xmm0, 0x40(%rbx)
movups 0x6a0(%r14), %xmm0
movups %xmm0, 0x48(%rbx)
movb 0xfee(%r14), %al
xorb $0x1, %al
movb %al, 0x62(%rbx)
movb 0xfe4(%r14), %al
movb %al, 0x63(%rbx)
movb 0xfe5(%r14), %al
movb %al, 0x64(%rbx)
cmpb $0x1, 0x1080(%r14)
jne 0x71b36
movb $0x1, 0x61(%rbx)
movl $0x4, 0x1c(%rbx)
movq 0xff4(%r14), %rax
movq %rax, 0x58(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z30common_context_params_to_llamaRK13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_context_default_params
mov eax, [r14+18h]
mov [rbx+0Ch], eax
mov rax, [r14+4]
mov [rbx], rax
mov eax, [r14+0Ch]
mov [rbx+8], eax
mov eax, [r14+274h]
mov [rbx+10h], eax
mov ecx, [r14+488h]
cmp ecx, 0FFFFFFFFh
cmovz ecx, eax
mov [rbx+14h], ecx
mov al, [r14+0FE8h]
mov [rbx+60h], al
mov al, [r14+1038h]
mov [rbx+61h], al
movups xmm0, xmmword ptr [r14+2Ch]
movups xmmword ptr [rbx+24h], xmm0
movsd xmm0, qword ptr [r14+3Ch]
movsd qword ptr [rbx+34h], xmm0
mov eax, [r14+44h]
mov [rbx+3Ch], eax
mov rax, [r14+6B4h]
mov [rbx+18h], rax
mov eax, [r14+6BCh]
mov [rbx+20h], eax
movss xmm0, dword ptr [r14+48h]
movss dword ptr [rbx+40h], xmm0
movups xmm0, xmmword ptr [r14+6A0h]
movups xmmword ptr [rbx+48h], xmm0
mov al, [r14+0FEEh]
xor al, 1
mov [rbx+62h], al
mov al, [r14+0FE4h]
mov [rbx+63h], al
mov al, [r14+0FE5h]
mov [rbx+64h], al
cmp byte ptr [r14+1080h], 1
jnz short loc_71B36
mov byte ptr [rbx+61h], 1
mov dword ptr [rbx+1Ch], 4
loc_71B36:
mov rax, [r14+0FF4h]
mov [rbx+58h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| const common_params * common_context_params_to_llama(const common_params *a1, long long a2)
{
int v2; // eax
int v3; // ecx
llama_context_default_params(a1);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 24);
*(_QWORD *)a1 = *(_QWORD *)(a2 + 4);
*((_DWORD *)a1 + 2) = *(_DWORD *)(a2 + 12);
v2 = *(_DWORD *)(a2 + 628);
*((_DWORD *)a1 + 4) = v2;
v3 = *(_DWORD *)(a2 + 1160);
if ( v3 == -1 )
v3 = v2;
*((_DWORD *)a1 + 5) = v3;
*((_BYTE *)a1 + 96) = *(_BYTE *)(a2 + 4072);
*((_BYTE *)a1 + 97) = *(_BYTE *)(a2 + 4152);
*(_OWORD *)((char *)a1 + 36) = *(_OWORD *)(a2 + 44);
*(_QWORD *)((char *)a1 + 52) = *(_QWORD *)(a2 + 60);
*((_DWORD *)a1 + 15) = *(_DWORD *)(a2 + 68);
*((_QWORD *)a1 + 3) = *(_QWORD *)(a2 + 1716);
*((_DWORD *)a1 + 8) = *(_DWORD *)(a2 + 1724);
*((_DWORD *)a1 + 16) = *(_DWORD *)(a2 + 72);
*(_OWORD *)((char *)a1 + 72) = *(_OWORD *)(a2 + 1696);
*((_BYTE *)a1 + 98) = *(_BYTE *)(a2 + 4078) ^ 1;
*((_BYTE *)a1 + 99) = *(_BYTE *)(a2 + 4068);
*((_BYTE *)a1 + 100) = *(_BYTE *)(a2 + 4069);
if ( *(_BYTE *)(a2 + 4224) == 1 )
{
*((_BYTE *)a1 + 97) = 1;
*((_DWORD *)a1 + 7) = 4;
}
*((_QWORD *)a1 + 11) = *(_QWORD *)(a2 + 4084);
return a1;
}
| common_context_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x001260c0
MOV EAX,dword ptr [R14 + 0x18]
MOV dword ptr [RBX + 0xc],EAX
MOV RAX,qword ptr [R14 + 0x4]
MOV qword ptr [RBX],RAX
MOV EAX,dword ptr [R14 + 0xc]
MOV dword ptr [RBX + 0x8],EAX
MOV EAX,dword ptr [R14 + 0x274]
MOV dword ptr [RBX + 0x10],EAX
MOV ECX,dword ptr [R14 + 0x488]
CMP ECX,-0x1
CMOVZ ECX,EAX
MOV dword ptr [RBX + 0x14],ECX
MOV AL,byte ptr [R14 + 0xfe8]
MOV byte ptr [RBX + 0x60],AL
MOV AL,byte ptr [R14 + 0x1038]
MOV byte ptr [RBX + 0x61],AL
MOVUPS XMM0,xmmword ptr [R14 + 0x2c]
MOVUPS xmmword ptr [RBX + 0x24],XMM0
MOVSD XMM0,qword ptr [R14 + 0x3c]
MOVSD qword ptr [RBX + 0x34],XMM0
MOV EAX,dword ptr [R14 + 0x44]
MOV dword ptr [RBX + 0x3c],EAX
MOV RAX,qword ptr [R14 + 0x6b4]
MOV qword ptr [RBX + 0x18],RAX
MOV EAX,dword ptr [R14 + 0x6bc]
MOV dword ptr [RBX + 0x20],EAX
MOVSS XMM0,dword ptr [R14 + 0x48]
MOVSS dword ptr [RBX + 0x40],XMM0
MOVUPS XMM0,xmmword ptr [R14 + 0x6a0]
MOVUPS xmmword ptr [RBX + 0x48],XMM0
MOV AL,byte ptr [R14 + 0xfee]
XOR AL,0x1
MOV byte ptr [RBX + 0x62],AL
MOV AL,byte ptr [R14 + 0xfe4]
MOV byte ptr [RBX + 0x63],AL
MOV AL,byte ptr [R14 + 0xfe5]
MOV byte ptr [RBX + 0x64],AL
CMP byte ptr [R14 + 0x1080],0x1
JNZ 0x00171b36
MOV byte ptr [RBX + 0x61],0x1
MOV dword ptr [RBX + 0x1c],0x4
LAB_00171b36:
MOV RAX,qword ptr [R14 + 0xff4]
MOV qword ptr [RBX + 0x58],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_context_params_to_llama(common_params const&) */
common_params * common_context_params_to_llama(common_params *param_1)
{
int iVar1;
int8 uVar2;
int iVar3;
long in_RSI;
llama_context_default_params();
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x18);
*(int8 *)param_1 = *(int8 *)(in_RSI + 4);
*(int4 *)(param_1 + 8) = *(int4 *)(in_RSI + 0xc);
iVar1 = *(int *)(in_RSI + 0x274);
*(int *)(param_1 + 0x10) = iVar1;
iVar3 = *(int *)(in_RSI + 0x488);
if (*(int *)(in_RSI + 0x488) == -1) {
iVar3 = iVar1;
}
*(int *)(param_1 + 0x14) = iVar3;
param_1[0x60] = *(common_params *)(in_RSI + 0xfe8);
param_1[0x61] = *(common_params *)(in_RSI + 0x1038);
uVar2 = *(int8 *)(in_RSI + 0x34);
*(int8 *)(param_1 + 0x24) = *(int8 *)(in_RSI + 0x2c);
*(int8 *)(param_1 + 0x2c) = uVar2;
*(int8 *)(param_1 + 0x34) = *(int8 *)(in_RSI + 0x3c);
*(int4 *)(param_1 + 0x3c) = *(int4 *)(in_RSI + 0x44);
*(int8 *)(param_1 + 0x18) = *(int8 *)(in_RSI + 0x6b4);
*(int4 *)(param_1 + 0x20) = *(int4 *)(in_RSI + 0x6bc);
*(int4 *)(param_1 + 0x40) = *(int4 *)(in_RSI + 0x48);
uVar2 = *(int8 *)(in_RSI + 0x6a8);
*(int8 *)(param_1 + 0x48) = *(int8 *)(in_RSI + 0x6a0);
*(int8 *)(param_1 + 0x50) = uVar2;
param_1[0x62] = (common_params)(*(byte *)(in_RSI + 0xfee) ^ 1);
param_1[99] = *(common_params *)(in_RSI + 0xfe4);
param_1[100] = *(common_params *)(in_RSI + 0xfe5);
if (*(char *)(in_RSI + 0x1080) == '\x01') {
param_1[0x61] = (common_params)0x1;
*(int4 *)(param_1 + 0x1c) = 4;
}
*(int8 *)(param_1 + 0x58) = *(int8 *)(in_RSI + 0xff4);
return param_1;
}
| |
22,944 | ma_read_rnd_pack_record | eloqsql/storage/maria/ma_packrec.c | int _ma_read_rnd_pack_record(MARIA_HA *info,
uchar *buf,
register MARIA_RECORD_POS filepos,
my_bool skip_deleted_blocks)
{
File file;
MARIA_BLOCK_INFO block_info;
MARIA_SHARE *share= info->s;
DBUG_ENTER("_ma_read_rnd_pack_record");
if (filepos >= info->state->data_file_length)
{
my_errno= HA_ERR_END_OF_FILE;
goto err;
}
file= info->dfile.file;
if (info->opt_flag & READ_CACHE_USED)
{
if (_ma_read_cache(info, &info->rec_cache, block_info.header,
filepos, share->pack.ref_length,
skip_deleted_blocks ? READING_NEXT : 0))
goto err;
file= -1;
}
if (_ma_pack_get_block_info(info, &info->bit_buff, &block_info,
&info->rec_buff, &info->rec_buff_size,
file, filepos))
goto err; /* Error code is already set */
#ifndef DBUG_OFF
if (block_info.rec_len > share->max_pack_length)
{
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
#endif
if (info->opt_flag & READ_CACHE_USED)
{
if (_ma_read_cache(info, &info->rec_cache, info->rec_buff,
block_info.filepos, block_info.rec_len,
skip_deleted_blocks ? READING_NEXT : 0))
goto err;
}
else
{
if (mysql_file_read(info->dfile.file, info->rec_buff + block_info.offset,
block_info.rec_len-block_info.offset,
MYF(MY_NABP)))
goto err;
}
info->packed_length= block_info.rec_len;
info->cur_row.lastpos= filepos;
info->cur_row.nextpos= block_info.filepos+block_info.rec_len;
info->update|= HA_STATE_AKTIV | HA_STATE_KEY_CHANGED;
info->rec_buff[block_info.rec_len]= 0; /* Keep valgrind happy */
DBUG_RETURN(_ma_pack_rec_unpack(info, &info->bit_buff, buf,
info->rec_buff, block_info.rec_len));
err:
DBUG_RETURN(my_errno);
} | O3 | c | ma_read_rnd_pack_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0x20(%rdi), %rax
cmpq %rdx, 0x28(%rax)
jbe 0x65148
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testb $0x2, 0x61c(%rdi)
jne 0x65155
movl 0x480(%r14), %r9d
jmp 0x6518c
callq 0xc14ee
movl $0x89, (%rax)
jmp 0x651bb
movq (%r14), %rax
leaq 0x4b8(%r14), %rsi
movl 0x598(%rax), %r8d
xorl %r9d, %r9d
testb %r13b, %r13b
setne %r9b
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
movq %r15, %rcx
callq 0x8ba3c
testb %al, %al
jne 0x651bb
movl $0xffffffff, %r9d # imm = 0xFFFFFFFF
leaq 0x290(%r14), %r12
leaq 0x3a0(%r14), %rcx
leaq 0x460(%r14), %r8
movq %r15, (%rsp)
leaq -0x88(%rbp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x64d49
testl %eax, %eax
je 0x651e7
callq 0xc14ee
movl (%rax), %eax
movq %fs:0x28, %rcx
cmpq -0x30(%rbp), %rcx
jne 0x65356
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x2, 0x61c(%r14)
movq 0x3a0(%r14), %rdx
jne 0x65263
movl 0x480(%r14), %esi
movl -0x34(%rbp), %eax
addq %rax, %rdx
movq %rdx, -0x98(%rbp)
movq -0x70(%rbp), %r13
subq %rax, %r13
leaq 0x3497fe(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0xe8(%rbp), %rdi
movl %esi, -0x8c(%rbp)
movl $0x6, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x652dd
movl $0x4, %ecx
movl -0x8c(%rbp), %edi
movq -0x98(%rbp), %rsi
movq %r13, %rdx
callq 0xbff8c
testq %rax, %rax
jne 0x651bb
jmp 0x6528c
leaq 0x4b8(%r14), %rsi
movq -0x70(%rbp), %r8
movq -0x50(%rbp), %rcx
xorl %r9d, %r9d
testb %r13b, %r13b
setne %r9b
movq %r14, %rdi
callq 0x8ba3c
testb %al, %al
jne 0x651bb
movq -0x70(%rbp), %rax
movq %rax, 0x450(%r14)
movq %r15, 0x98(%r14)
movq -0x50(%rbp), %rcx
addq %rax, %rcx
movq %rcx, 0xa0(%r14)
orb $-0x7e, 0x624(%r14)
movq 0x3a0(%r14), %rcx
movb $0x0, (%rcx,%rax)
movq 0x3a0(%r14), %rcx
movq -0x70(%rbp), %r8
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x65009
jmp 0x651c2
movq %rax, %rcx
leaq 0x349731(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq 0x96732(%rip), %rdx # 0xfba23
movq %rcx, -0xa0(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
movl $0x572, %ecx # imm = 0x572
callq *0x210(%rax)
movl $0x4, %ecx
movl -0x8c(%rbp), %edi
movq -0x98(%rbp), %rsi
movq %r13, %rdx
callq 0xbff8c
movq %rax, -0x98(%rbp)
xorl %esi, %esi
testq %rax, %rax
cmoveq %r13, %rsi
leaq 0x3496de(%rip), %rax # 0x3aea18
movq (%rax), %rax
movq -0xa0(%rbp), %rdi
callq *0x218(%rax)
movq -0x98(%rbp), %rax
jmp 0x65258
callq 0x2a280
| _ma_read_rnd_pack_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi+20h]
cmp [rax+28h], rdx
jbe short loc_65148
mov r13d, ecx
mov r15, rdx
mov rbx, rsi
mov r14, rdi
test byte ptr [rdi+61Ch], 2
jnz short loc_65155
mov r9d, [r14+480h]
jmp short loc_6518C
loc_65148:
call _my_thread_var
mov dword ptr [rax], 89h
jmp short loc_651BB
loc_65155:
mov rax, [r14]
lea rsi, [r14+4B8h]
mov r8d, [rax+598h]
xor r9d, r9d
test r13b, r13b
setnz r9b
lea rdx, [rbp+var_88]
mov rdi, r14
mov rcx, r15
call _ma_read_cache
test al, al
jnz short loc_651BB
mov r9d, 0FFFFFFFFh
loc_6518C:
lea r12, [r14+290h]
lea rcx, [r14+3A0h]
lea r8, [r14+460h]
mov [rsp+0F0h+var_F0], r15
lea rdx, [rbp+var_88]
mov rdi, r14
mov rsi, r12
call _ma_pack_get_block_info
test eax, eax
jz short loc_651E7
loc_651BB:
call _my_thread_var
mov eax, [rax]
loc_651C2:
mov rcx, fs:28h
cmp rcx, [rbp+var_30]
jnz loc_65356
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_651E7:
test byte ptr [r14+61Ch], 2
mov rdx, [r14+3A0h]
jnz short loc_65263
mov esi, [r14+480h]
mov eax, [rbp+var_34]
add rdx, rax
mov [rbp+var_98], rdx
mov r13, [rbp+var_70]
sub r13, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_E8]
mov [rbp+var_8C], esi
mov edx, 6
call qword ptr [rax+158h]
test rax, rax
jnz loc_652DD
mov ecx, 4
mov edi, [rbp+var_8C]
mov rsi, [rbp+var_98]
mov rdx, r13
call my_read
loc_65258:
test rax, rax
jnz loc_651BB
jmp short loc_6528C
loc_65263:
lea rsi, [r14+4B8h]
mov r8, [rbp+var_70]
mov rcx, [rbp+var_50]
xor r9d, r9d
test r13b, r13b
setnz r9b
mov rdi, r14
call _ma_read_cache
test al, al
jnz loc_651BB
loc_6528C:
mov rax, [rbp+var_70]
mov [r14+450h], rax
mov [r14+98h], r15
mov rcx, [rbp+var_50]
add rcx, rax
mov [r14+0A0h], rcx
or byte ptr [r14+624h], 82h
mov rcx, [r14+3A0h]
mov byte ptr [rcx+rax], 0
mov rcx, [r14+3A0h]
mov r8, [rbp+var_70]
mov rdi, r14
mov rsi, r12
mov rdx, rbx
call _ma_pack_rec_unpack
jmp loc_651C2
loc_652DD:
mov rcx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdx, aWorkspaceLlm4b_11; "/workspace/llm4binary/github2025/eloqsq"...
mov [rbp+var_A0], rcx
mov rdi, rcx
mov rsi, r13
mov ecx, 572h
call qword ptr [rax+210h]
mov ecx, 4
mov edi, [rbp+var_8C]
mov rsi, [rbp+var_98]
mov rdx, r13
call my_read
mov [rbp+var_98], rax
xor esi, esi
test rax, rax
cmovz rsi, r13
lea rax, PSI_server
mov rax, [rax]
mov rdi, [rbp+var_A0]
call qword ptr [rax+218h]
mov rax, [rbp+var_98]
jmp loc_65258
loc_65356:
call ___stack_chk_fail
| long long ma_read_rnd_pack_record(long long a1, long long a2, unsigned long long a3, char a4)
{
long long v7; // r14
unsigned int v8; // r9d
long long v10; // rdx
long long v11; // rsi
long long v12; // r13
long long v13; // rax
long long v14; // rax
int v15; // r9d
long long v16; // rax
long long v17; // rsi
char v18[72]; // [rsp+8h] [rbp-E8h] BYREF
long long v19; // [rsp+50h] [rbp-A0h]
long long v20; // [rsp+58h] [rbp-98h]
unsigned int v21; // [rsp+64h] [rbp-8Ch]
unsigned __int8 v22[24]; // [rsp+68h] [rbp-88h] BYREF
long long v23; // [rsp+80h] [rbp-70h]
long long v24; // [rsp+A0h] [rbp-50h]
unsigned int v25; // [rsp+BCh] [rbp-34h]
unsigned long long v26; // [rsp+C0h] [rbp-30h]
v26 = __readfsqword(0x28u);
if ( *(_QWORD *)(*(_QWORD *)(a1 + 32) + 40LL) <= a3 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return *(unsigned int *)my_thread_var(a1);
}
v7 = a1;
if ( (*(_BYTE *)(a1 + 1564) & 2) == 0 )
{
v8 = *(_DWORD *)(a1 + 1152);
goto LABEL_7;
}
if ( (unsigned __int8)ma_read_cache(a1, a1 + 1208, v22, a3, *(unsigned int *)(*(_QWORD *)a1 + 1432LL), a4 != 0) )
return *(unsigned int *)my_thread_var(a1);
v8 = -1;
LABEL_7:
if ( (unsigned int)ma_pack_get_block_info(
(long long *)a1,
a1 + 656,
v22,
(long long *)(a1 + 928),
(unsigned long long *)(a1 + 1120),
v8,
a3) )
return *(unsigned int *)my_thread_var(a1);
v10 = *(_QWORD *)(a1 + 928);
if ( (*(_BYTE *)(a1 + 1564) & 2) != 0 )
{
if ( (unsigned __int8)ma_read_cache(a1, a1 + 1208, v10, v24, v23, a4 != 0) )
return *(unsigned int *)my_thread_var(a1);
}
else
{
v11 = *(unsigned int *)(a1 + 1152);
v20 = v25 + v10;
v12 = v23 - v25;
v21 = v11;
v13 = ((long long ( *)(char *, long long, long long))PSI_server[43])(v18, v11, 6LL);
if ( v13 )
{
v19 = v13;
((void ( *)(long long, long long, const char *, long long))PSI_server[66])(
v13,
v12,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_packrec.c",
1394LL);
v20 = my_read(v21, v20, v12, 4LL);
v17 = 0LL;
if ( !v20 )
v17 = v12;
a1 = v19;
((void ( *)(long long, long long))PSI_server[67])(v19, v17);
v14 = v20;
}
else
{
a1 = v21;
v14 = my_read(v21, v20, v12, 4LL);
}
if ( v14 )
return *(unsigned int *)my_thread_var(a1);
}
v16 = v23;
*(_QWORD *)(v7 + 1104) = v23;
*(_QWORD *)(v7 + 152) = a3;
*(_QWORD *)(v7 + 160) = v16 + v24;
*(_BYTE *)(v7 + 1572) |= 0x82u;
*(_BYTE *)(*(_QWORD *)(v7 + 928) + v16) = 0;
return ma_pack_rec_unpack((_BYTE *)v7, v7 + 656, a2, *(_QWORD *)(v7 + 928), v23, v15);
}
| _ma_read_rnd_pack_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0x20]
CMP qword ptr [RAX + 0x28],RDX
JBE 0x00165148
MOV R13D,ECX
MOV R15,RDX
MOV RBX,RSI
MOV R14,RDI
TEST byte ptr [RDI + 0x61c],0x2
JNZ 0x00165155
MOV R9D,dword ptr [R14 + 0x480]
JMP 0x0016518c
LAB_00165148:
CALL 0x001c14ee
MOV dword ptr [RAX],0x89
JMP 0x001651bb
LAB_00165155:
MOV RAX,qword ptr [R14]
LEA RSI,[R14 + 0x4b8]
MOV R8D,dword ptr [RAX + 0x598]
XOR R9D,R9D
TEST R13B,R13B
SETNZ R9B
LEA RDX,[RBP + -0x88]
MOV RDI,R14
MOV RCX,R15
CALL 0x0018ba3c
TEST AL,AL
JNZ 0x001651bb
MOV R9D,0xffffffff
LAB_0016518c:
LEA R12,[R14 + 0x290]
LEA RCX,[R14 + 0x3a0]
LEA R8,[R14 + 0x460]
MOV qword ptr [RSP],R15
LEA RDX,[RBP + -0x88]
MOV RDI,R14
MOV RSI,R12
CALL 0x00164d49
TEST EAX,EAX
JZ 0x001651e7
LAB_001651bb:
CALL 0x001c14ee
MOV EAX,dword ptr [RAX]
LAB_001651c2:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x30]
JNZ 0x00165356
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001651e7:
TEST byte ptr [R14 + 0x61c],0x2
MOV RDX,qword ptr [R14 + 0x3a0]
JNZ 0x00165263
MOV ESI,dword ptr [R14 + 0x480]
MOV EAX,dword ptr [RBP + -0x34]
ADD RDX,RAX
MOV qword ptr [RBP + -0x98],RDX
MOV R13,qword ptr [RBP + -0x70]
SUB R13,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0xe8]
MOV dword ptr [RBP + -0x8c],ESI
MOV EDX,0x6
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x001652dd
MOV ECX,0x4
MOV EDI,dword ptr [RBP + -0x8c]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDX,R13
CALL 0x001bff8c
LAB_00165258:
TEST RAX,RAX
JNZ 0x001651bb
JMP 0x0016528c
LAB_00165263:
LEA RSI,[R14 + 0x4b8]
MOV R8,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x50]
XOR R9D,R9D
TEST R13B,R13B
SETNZ R9B
MOV RDI,R14
CALL 0x0018ba3c
TEST AL,AL
JNZ 0x001651bb
LAB_0016528c:
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [R14 + 0x450],RAX
MOV qword ptr [R14 + 0x98],R15
MOV RCX,qword ptr [RBP + -0x50]
ADD RCX,RAX
MOV qword ptr [R14 + 0xa0],RCX
OR byte ptr [R14 + 0x624],0x82
MOV RCX,qword ptr [R14 + 0x3a0]
MOV byte ptr [RCX + RAX*0x1],0x0
MOV RCX,qword ptr [R14 + 0x3a0]
MOV R8,qword ptr [RBP + -0x70]
MOV RDI,R14
MOV RSI,R12
MOV RDX,RBX
CALL 0x00165009
JMP 0x001651c2
LAB_001652dd:
MOV RCX,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDX,[0x1fba23]
MOV qword ptr [RBP + -0xa0],RCX
MOV RDI,RCX
MOV RSI,R13
MOV ECX,0x572
CALL qword ptr [RAX + 0x210]
MOV ECX,0x4
MOV EDI,dword ptr [RBP + -0x8c]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDX,R13
CALL 0x001bff8c
MOV qword ptr [RBP + -0x98],RAX
XOR ESI,ESI
TEST RAX,RAX
CMOVZ RSI,R13
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0xa0]
CALL qword ptr [RAX + 0x218]
MOV RAX,qword ptr [RBP + -0x98]
JMP 0x00165258
LAB_00165356:
CALL 0x0012a280
|
ulong _ma_read_rnd_pack_record(long *param_1,int8 param_2,ulong param_3,char param_4)
{
char cVar1;
int iVar2;
int4 *puVar3;
uint *puVar4;
long lVar5;
ulong uVar6;
int4 uVar7;
long lVar8;
long in_FS_OFFSET;
int1 local_f0 [72];
long local_a8;
long local_a0;
int4 local_94;
int1 local_90 [24];
long local_78;
long local_58;
uint local_3c;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (param_3 < *(ulong *)(param_1[4] + 0x28)) {
if ((*(byte *)((long)param_1 + 0x61c) & 2) == 0) {
uVar7 = (int4)param_1[0x90];
}
else {
cVar1 = _ma_read_cache(param_1,param_1 + 0x97,local_90,param_3,
*(int4 *)(*param_1 + 0x598),param_4 != '\0');
if (cVar1 != '\0') goto LAB_001651bb;
uVar7 = 0xffffffff;
}
iVar2 = _ma_pack_get_block_info
(param_1,param_1 + 0x52,local_90,param_1 + 0x74,param_1 + 0x8c,uVar7,param_3);
if (iVar2 == 0) {
if ((*(byte *)((long)param_1 + 0x61c) & 2) == 0) {
local_94 = (int4)param_1[0x90];
local_a0 = param_1[0x74] + (ulong)local_3c;
lVar8 = local_78 - (ulong)local_3c;
lVar5 = (**(code **)(PSI_server + 0x158))(local_f0,local_94,6);
if (lVar5 == 0) {
lVar5 = my_read(local_94,local_a0,lVar8,4);
}
else {
local_a8 = lVar5;
(**(code **)(PSI_server + 0x210))
(lVar5,lVar8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_packrec.c",0x572);
local_a0 = my_read(local_94,local_a0,lVar8,4);
lVar5 = 0;
if (local_a0 == 0) {
lVar5 = lVar8;
}
(**(code **)(PSI_server + 0x218))(local_a8,lVar5);
lVar5 = local_a0;
}
if (lVar5 == 0) {
LAB_0016528c:
param_1[0x8a] = local_78;
param_1[0x13] = param_3;
param_1[0x14] = local_58 + local_78;
*(byte *)((long)param_1 + 0x624) = *(byte *)((long)param_1 + 0x624) | 0x82;
*(int1 *)(param_1[0x74] + local_78) = 0;
uVar6 = _ma_pack_rec_unpack(param_1,param_1 + 0x52,param_2,param_1[0x74],local_78);
goto LAB_001651c2;
}
}
else {
cVar1 = _ma_read_cache(param_1,param_1 + 0x97,param_1[0x74],local_58,local_78,
param_4 != '\0');
if (cVar1 == '\0') goto LAB_0016528c;
}
}
}
else {
puVar3 = (int4 *)_my_thread_var();
*puVar3 = 0x89;
}
LAB_001651bb:
puVar4 = (uint *)_my_thread_var();
uVar6 = (ulong)*puVar4;
LAB_001651c2:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar6;
}
| |
22,945 | translog_sync_files | eloqsql/storage/maria/ma_loghandler.c | static my_bool translog_sync_files(uint32 min, uint32 max,
my_bool sync_dir)
{
uint fn;
my_bool rc= 0;
ulonglong flush_interval;
DBUG_ENTER("translog_sync_files");
DBUG_PRINT("info", ("min: %lu max: %lu sync dir: %d",
(ulong) min, (ulong) max, (int) sync_dir));
DBUG_ASSERT(min <= max);
flush_interval= group_commit_wait;
if (flush_interval)
flush_start= microsecond_interval_timer();
for (fn= min; fn <= max; fn++)
{
TRANSLOG_FILE *file= get_logfile_by_number(fn);
DBUG_ASSERT(file != NULL);
if (!file->is_sync)
{
if (mysql_file_sync(file->handler.file, MYF(MY_WME)))
{
rc= 1;
translog_stop_writing();
DBUG_RETURN(rc);
}
translog_syncs++;
file->is_sync= 1;
}
}
if (sync_dir)
{
if (!(rc= sync_dir(log_descriptor.directory_fd,
MYF(MY_WME | MY_IGNORE_BADFD))))
translog_syncs++;
}
DBUG_RETURN(rc);
} | O3 | c | translog_sync_files:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, -0x30(%rbp)
movl %esi, %r14d
movl %edi, %r15d
cmpl $0x0, 0xbb33e9(%rip) # 0xc01994
je 0x4e5ce
callq 0x9f488
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
shrq $0x4, %rdx
movq %rdx, 0xbb33b2(%rip) # 0xc01980
cmpl %r14d, %r15d
jbe 0x4e625
cmpb $0x0, -0x30(%rbp)
je 0x4e61e
movl 0x3b2781(%rip), %ebx # 0x400d60
leaq 0x339ada(%rip), %rax # 0x3880c0
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
movl %ebx, %esi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4e6ce
movl $0x30, %esi
movl %ebx, %edi
callq 0xa23d0
testb %al, %al
jne 0x4e6bf
incq 0x3b124a(%rip) # 0x3ff868
xorl %eax, %eax
jmp 0x4e6bf
leaq -0x78(%rbp), %r12
movl %r15d, %edi
callq 0x4fce2
cmpb $0x0, 0x51(%rax)
jne 0x4e678
movq %rax, %r13
movl 0x18(%rax), %ebx
leaq 0x339a7c(%rip), %rax # 0x3880c0
movq (%rax), %rax
movq %r12, %rdi
movl %ebx, %esi
movl $0x10, %edx
callq *0x158(%rax)
testq %rax, %rax
jne 0x4e685
movl $0x10, %esi
movl %ebx, %edi
callq 0xa23d0
testl %eax, %eax
jne 0x4e698
incq 0x3b11f5(%rip) # 0x3ff868
movb $0x1, 0x51(%r13)
incl %r15d
cmpl %r14d, %r15d
jbe 0x4e629
jmp 0x4e5d3
movq %rax, %rdi
movl %ebx, %esi
leaq -0x2c(%rbp), %rdx
callq 0x2cb15
movl -0x2c(%rbp), %eax
jmp 0x4e668
xorl %eax, %eax
cmpl $0x3, 0x3b11bf(%rip) # 0x3ff860
setne %al
addl %eax, %eax
movl %eax, 0x3b11b4(%rip) # 0x3ff860
movb $0x1, 0xbb328d(%rip) # 0xc01940
movl $0x0, 0x3b23bf(%rip) # 0x400a7c
movb $0x1, %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2c(%rbp), %r14
movq %rax, %rdi
movl %ebx, %esi
movq %r14, %rdx
callq 0x2cb6e
movl (%r14), %eax
jmp 0x4e60f
| translog_sync_files:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov [rbp+var_30], edx
mov r14d, esi
mov r15d, edi
cmp cs:group_commit_wait, 0
jz short loc_4E5CE
call my_interval_timer
shr rax, 3
mov rcx, 20C49BA5E353F7CFh
mul rcx
shr rdx, 4
mov cs:flush_start, rdx
loc_4E5CE:
cmp r15d, r14d
jbe short loc_4E625
loc_4E5D3:
cmp byte ptr [rbp+var_30], 0
jz short loc_4E61E
mov ebx, cs:dword_400D60
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_78]
mov esi, ebx
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz loc_4E6CE
mov esi, 30h ; '0'
mov edi, ebx
call my_sync
loc_4E60F:
test al, al
jnz loc_4E6BF
inc cs:translog_syncs
loc_4E61E:
xor eax, eax
jmp loc_4E6BF
loc_4E625:
lea r12, [rbp+var_78]
loc_4E629:
mov edi, r15d
call get_logfile_by_number
cmp byte ptr [rax+51h], 0
jnz short loc_4E678
mov r13, rax
mov ebx, [rax+18h]
lea rax, PSI_server
mov rax, [rax]
mov rdi, r12
mov esi, ebx
mov edx, 10h
call qword ptr [rax+158h]
test rax, rax
jnz short loc_4E685
mov esi, 10h
mov edi, ebx
call my_sync
loc_4E668:
test eax, eax
jnz short loc_4E698
inc cs:translog_syncs
mov byte ptr [r13+51h], 1
loc_4E678:
inc r15d
cmp r15d, r14d
jbe short loc_4E629
jmp loc_4E5D3
loc_4E685:
mov rdi, rax
mov esi, ebx
lea rdx, [rbp+var_2C]
call translog_sync_files_cold_1
mov eax, [rbp+var_2C]
jmp short loc_4E668
loc_4E698:
xor eax, eax
cmp cs:translog_status, 3
setnz al
add eax, eax
mov cs:translog_status, eax
mov byte ptr cs:word_C01940, 1
mov cs:dword_400A7C, 0
mov al, 1
loc_4E6BF:
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4E6CE:
lea r14, [rbp+var_2C]
mov rdi, rax
mov esi, ebx
mov rdx, r14
call translog_sync_files_cold_2
mov eax, [r14]
jmp loc_4E60F
| char translog_sync_files(unsigned int a1, unsigned int a2, int a3)
{
unsigned int v3; // r15d
unsigned int v4; // ebx
long long v5; // rax
char result; // al
long long logfile_by_number; // rax
long long v8; // r13
unsigned int v9; // ebx
long long v10; // rax
int v11; // eax
_BYTE v12[72]; // [rsp+8h] [rbp-78h] BYREF
int v13; // [rsp+50h] [rbp-30h]
_DWORD v14[11]; // [rsp+54h] [rbp-2Ch] BYREF
v13 = a3;
v3 = a1;
if ( group_commit_wait )
flush_start = my_interval_timer() / 0x3E8uLL;
if ( a1 <= a2 )
{
do
{
logfile_by_number = get_logfile_by_number(v3);
if ( !*(_BYTE *)(logfile_by_number + 81) )
{
v8 = logfile_by_number;
v9 = *(_DWORD *)(logfile_by_number + 24);
v10 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v12, v9, 16LL);
if ( v10 )
{
translog_sync_files_cold_1(v10, v9, v14);
v11 = v14[0];
}
else
{
v11 = my_sync(v9, 16LL);
}
if ( v11 )
{
translog_status = 2 * (translog_status != 3);
LOBYTE(word_C01940) = 1;
dword_400A7C = 0;
return 1;
}
++translog_syncs;
*(_BYTE *)(v8 + 81) = 1;
}
++v3;
}
while ( v3 <= a2 );
}
if ( !(_BYTE)v13 )
return 0;
v4 = dword_400D60;
v5 = ((long long ( *)(_BYTE *, _QWORD, long long))PSI_server[43])(v12, (unsigned int)dword_400D60, 16LL);
if ( v5 )
{
translog_sync_files_cold_2(v5, v4, v14);
result = v14[0];
}
else
{
result = my_sync(v4, 48LL);
}
if ( !result )
{
++translog_syncs;
return 0;
}
return result;
}
| translog_sync_files:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x30],EDX
MOV R14D,ESI
MOV R15D,EDI
CMP dword ptr [0x00d01994],0x0
JZ 0x0014e5ce
CALL 0x0019f488
SHR RAX,0x3
MOV RCX,0x20c49ba5e353f7cf
MUL RCX
SHR RDX,0x4
MOV qword ptr [0x00d01980],RDX
LAB_0014e5ce:
CMP R15D,R14D
JBE 0x0014e625
LAB_0014e5d3:
CMP byte ptr [RBP + -0x30],0x0
JZ 0x0014e61e
MOV EBX,dword ptr [0x00500d60]
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x78]
MOV ESI,EBX
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014e6ce
MOV ESI,0x30
MOV EDI,EBX
CALL 0x001a23d0
LAB_0014e60f:
TEST AL,AL
JNZ 0x0014e6bf
INC qword ptr [0x004ff868]
LAB_0014e61e:
XOR EAX,EAX
JMP 0x0014e6bf
LAB_0014e625:
LEA R12,[RBP + -0x78]
LAB_0014e629:
MOV EDI,R15D
CALL 0x0014fce2
CMP byte ptr [RAX + 0x51],0x0
JNZ 0x0014e678
MOV R13,RAX
MOV EBX,dword ptr [RAX + 0x18]
LEA RAX,[0x4880c0]
MOV RAX,qword ptr [RAX]
MOV RDI,R12
MOV ESI,EBX
MOV EDX,0x10
CALL qword ptr [RAX + 0x158]
TEST RAX,RAX
JNZ 0x0014e685
MOV ESI,0x10
MOV EDI,EBX
CALL 0x001a23d0
LAB_0014e668:
TEST EAX,EAX
JNZ 0x0014e698
INC qword ptr [0x004ff868]
MOV byte ptr [R13 + 0x51],0x1
LAB_0014e678:
INC R15D
CMP R15D,R14D
JBE 0x0014e629
JMP 0x0014e5d3
LAB_0014e685:
MOV RDI,RAX
MOV ESI,EBX
LEA RDX,[RBP + -0x2c]
CALL 0x0012cb15
MOV EAX,dword ptr [RBP + -0x2c]
JMP 0x0014e668
LAB_0014e698:
XOR EAX,EAX
CMP dword ptr [0x004ff860],0x3
SETNZ AL
ADD EAX,EAX
MOV dword ptr [0x004ff860],EAX
MOV byte ptr [0x00d01940],0x1
MOV dword ptr [0x00500a7c],0x0
MOV AL,0x1
LAB_0014e6bf:
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014e6ce:
LEA R14,[RBP + -0x2c]
MOV RDI,RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x0012cb6e
MOV EAX,dword ptr [R14]
JMP 0x0014e60f
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
ulong translog_sync_files(uint param_1,uint param_2,int4 param_3)
{
int4 uVar1;
uint uVar2;
ulong uVar3;
long lVar4;
long lVar5;
int1 local_80 [72];
int4 local_38;
uint local_34;
local_38 = param_3;
if (group_commit_wait != 0) {
uVar3 = my_interval_timer();
flush_start = uVar3 / 1000;
}
if (param_1 <= param_2) {
do {
lVar4 = get_logfile_by_number(param_1);
if (*(char *)(lVar4 + 0x51) == '\0') {
uVar1 = *(int4 *)(lVar4 + 0x18);
lVar5 = (**(code **)(PSI_server + 0x158))(local_80,uVar1,0x10);
if (lVar5 == 0) {
uVar2 = my_sync(uVar1,0x10);
}
else {
translog_sync_files_cold_1(lVar5,uVar1,&local_34);
uVar2 = local_34;
}
if (uVar2 != 0) {
translog_status = (uint)(translog_status != 3) * 2;
_DAT_00500a7c = 0;
DAT_00d01940 = 1;
return 1;
}
translog_syncs = translog_syncs + 1;
*(int1 *)(lVar4 + 0x51) = 1;
}
param_1 = param_1 + 1;
} while (param_1 <= param_2);
}
uVar1 = DAT_00500d60;
if ((char)local_38 != '\0') {
lVar4 = (**(code **)(PSI_server + 0x158))(local_80,DAT_00500d60,0x10);
if (lVar4 == 0) {
uVar3 = my_sync(uVar1,0x30);
}
else {
translog_sync_files_cold_2(lVar4,uVar1,&local_34);
uVar3 = (ulong)local_34;
}
if ((char)uVar3 != '\0') {
return uVar3;
}
translog_syncs = translog_syncs + 1;
}
return 0;
}
| |
22,946 | my_casedn_8bit | eloqsql/strings/ctype-simple.c | size_t my_casedn_8bit(CHARSET_INFO * cs, const char *src, size_t srclen,
char *dst, size_t dstlen __attribute__((unused)))
{
const char *end= src + srclen;
register const uchar *map=cs->to_lower;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O0 | c | my_casedn_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x49ad2
jmp 0x49ad4
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x49b0b
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x49ad4
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_casedn_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax+48h]
mov [rbp+var_38], rax
jmp short $+2
loc_49AD2:
jmp short $+2
loc_49AD4:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jz short loc_49B0B
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov cl, [rax+rcx]
mov rax, [rbp+var_20]
mov rdx, rax
add rdx, 1
mov [rbp+var_20], rdx
mov [rax], cl
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_49AD4
loc_49B0B:
mov rax, [rbp+var_18]
pop rbp
retn
| long long my_casedn_8bit(long long a1, unsigned __int8 *a2, long long a3, _BYTE *a4)
{
_BYTE *v4; // rax
long long v6; // [rsp+0h] [rbp-38h]
unsigned __int8 *v8; // [rsp+28h] [rbp-10h]
v8 = a2;
v6 = *(_QWORD *)(a1 + 72);
while ( v8 != &a2[a3] )
{
v4 = a4++;
*v4 = *(_BYTE *)(v6 + *v8++);
}
return a3;
}
| my_casedn_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00149ad2
LAB_00149ad2:
JMP 0x00149ad4
LAB_00149ad4:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JZ 0x00149b0b
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x20]
MOV RDX,RAX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOV byte ptr [RAX],CL
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00149ad4
LAB_00149b0b:
MOV RAX,qword ptr [RBP + -0x18]
POP RBP
RET
|
long my_casedn_8bit(long param_1,byte *param_2,long param_3,int1 *param_4)
{
long lVar1;
int1 *local_28;
byte *local_18;
lVar1 = *(long *)(param_1 + 0x48);
local_28 = param_4;
for (local_18 = param_2; local_18 != param_2 + param_3; local_18 = local_18 + 1) {
*local_28 = *(int1 *)(lVar1 + (ulong)*local_18);
local_28 = local_28 + 1;
}
return param_3;
}
| |
22,947 | my_strndup | eloqsql/mysys/my_malloc.c | char *my_strndup(PSI_memory_key key, const char *from, size_t length, myf my_flags)
{
char *ptr;
DBUG_ENTER("my_strndup");
if ((ptr= (char*) my_malloc(key, length+1, my_flags)))
{
memcpy(ptr, from, length);
ptr[length]= 0;
}
DBUG_RETURN(ptr);
} | O0 | c | my_strndup:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
callq 0x5b620
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5bb62
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24220
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x5bb64
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_strndup:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov edi, [rbp+var_4]
mov rsi, [rbp+var_18]
add rsi, 1
mov rdx, [rbp+var_20]
call my_malloc
mov [rbp+var_28], rax
cmp rax, 0
jz short loc_5BB62
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
call _memcpy
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
mov byte ptr [rax+rcx], 0
loc_5BB62:
jmp short $+2
loc_5BB64:
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
add rsp, 30h
pop rbp
retn
| long long my_strndup(unsigned int a1, long long a2, long long a3, int a4)
{
long long v5; // [rsp+8h] [rbp-28h]
v5 = my_malloc(a1, a3 + 1, a4);
if ( v5 )
{
memcpy(v5, a2, a3);
*(_BYTE *)(v5 + a3) = 0;
}
return v5;
}
| my_strndup:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x18]
ADD RSI,0x1
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0015b620
MOV qword ptr [RBP + -0x28],RAX
CMP RAX,0x0
JZ 0x0015bb62
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00124220
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + RCX*0x1],0x0
LAB_0015bb62:
JMP 0x0015bb64
LAB_0015bb64:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RSP,0x30
POP RBP
RET
|
void * my_strndup(int4 param_1,void *param_2,size_t param_3,int8 param_4)
{
void *__dest;
__dest = (void *)my_malloc(param_1,param_3 + 1,param_4);
if (__dest != (void *)0x0) {
memcpy(__dest,param_2,param_3);
*(int1 *)((long)__dest + param_3) = 0;
}
return __dest;
}
| |
22,948 | mbr_join_square | eloqsql/storage/myisam/rt_split.c | static double mbr_join_square(const double *a, const double *b, int n_dim)
{
const double *end = a + n_dim * 2;
double square = 1.0;
do
{
square *=
((a[1] < b[1]) ? b[1] : a[1]) - ((a[0] > b[0]) ? b[0] : a[0]);
a += 2;
b += 2;
}while (a != end);
/* Check if not finite (i.e. infinity or NaN) */
if (!isfinite(square))
square = DBL_MAX;
return square;
} | O0 | c | mbr_join_square:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movsd 0x82d1a(%rip), %xmm0 # 0x158c58
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xd5f6b
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xd5f79
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0xd5fa4
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0xd5fb1
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
subsd %xmm1, %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0xd5f43
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0xd6027
movsd 0x82c4e(%rip), %xmm0 # 0x158c70
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
popq %rbp
retq
nop
| mbr_join_square_0:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov rax, [rbp+var_8]
mov ecx, [rbp+var_14]
shl ecx, 1
movsxd rcx, ecx
shl rcx, 3
add rax, rcx
mov [rbp+var_20], rax
movsd xmm0, cs:qword_158C58
movsd [rbp+var_28], xmm0
loc_D5F43:
mov rax, [rbp+var_8]
movsd xmm1, qword ptr [rax+8]
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
ucomisd xmm0, xmm1
jbe short loc_D5F6B
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
jmp short loc_D5F79
loc_D5F6B:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax+8]
movsd [rbp+var_30], xmm0
loc_D5F79:
movsd xmm0, [rbp+var_30]
movsd [rbp+var_38], xmm0
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_D5FA4
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
jmp short loc_D5FB1
loc_D5FA4:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
movsd [rbp+var_40], xmm0
loc_D5FB1:
movsd xmm0, [rbp+var_38]
movsd xmm1, [rbp+var_40]
subsd xmm0, xmm1
mulsd xmm0, [rbp+var_28]
movsd [rbp+var_28], xmm0
mov rax, [rbp+var_8]
add rax, 10h
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
add rax, 10h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
cmp rax, [rbp+var_20]
jnz loc_D5F43
movsd xmm0, [rbp+var_28]
movq rax, xmm0
mov rcx, 7FFFFFFFFFFFFFFFh
and rax, rcx
mov rcx, 7FF0000000000000h
sub rax, rcx
setl al
test al, 1
jnz short loc_D6027
movsd xmm0, cs:qword_158C70
movsd [rbp+var_28], xmm0
loc_D6027:
movsd xmm0, [rbp+var_28]
pop rbp
retn
| double mbr_join_square_0(double *a1, double *a2, int a3)
{
double v4; // [rsp+0h] [rbp-40h]
double v5; // [rsp+10h] [rbp-30h]
double v6; // [rsp+18h] [rbp-28h]
double *v8; // [rsp+38h] [rbp-8h]
v8 = a1;
v6 = 1.0;
do
{
if ( a2[1] <= v8[1] )
v5 = v8[1];
else
v5 = a2[1];
if ( *v8 <= *a2 )
v4 = *v8;
else
v4 = *a2;
v6 = (v5 - v4) * v6;
v8 += 2;
a2 += 2;
}
while ( v8 != &a1[2 * a3] );
if ( (*(_QWORD *)&v6 & 0x7FFFFFFFFFFFFFFFuLL) >= 0x7FF0000000000000LL )
return 1.797693134862316e308;
return v6;
}
| mbr_join_square:
PUSH RBP
MOV RBP,RSP
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 ECX,dword ptr [RBP + -0x14]
SHL ECX,0x1
MOVSXD RCX,ECX
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOVSD XMM0,qword ptr [0x00258c58]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001d5f43:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM1,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
UCOMISD XMM0,XMM1
JBE 0x001d5f6b
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
JMP 0x001d5f79
LAB_001d5f6b:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOVSD qword ptr [RBP + -0x30],XMM0
LAB_001d5f79:
MOVSD XMM0,qword ptr [RBP + -0x30]
MOVSD qword ptr [RBP + -0x38],XMM0
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x001d5fa4
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
JMP 0x001d5fb1
LAB_001d5fa4:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOVSD qword ptr [RBP + -0x40],XMM0
LAB_001d5fb1:
MOVSD XMM0,qword ptr [RBP + -0x38]
MOVSD XMM1,qword ptr [RBP + -0x40]
SUBSD XMM0,XMM1
MULSD XMM0,qword ptr [RBP + -0x28]
MOVSD qword ptr [RBP + -0x28],XMM0
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x10
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x10
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x001d5f43
MOVSD XMM0,qword ptr [RBP + -0x28]
MOVQ RAX,XMM0
MOV RCX,0x7fffffffffffffff
AND RAX,RCX
MOV RCX,0x7ff0000000000000
SUB RAX,RCX
SETL AL
TEST AL,0x1
JNZ 0x001d6027
MOVSD XMM0,qword ptr [0x00258c70]
MOVSD qword ptr [RBP + -0x28],XMM0
LAB_001d6027:
MOVSD XMM0,qword ptr [RBP + -0x28]
POP RBP
RET
|
double mbr_join_square(double *param_1,double *param_2,int param_3)
{
double local_48;
double local_38;
double local_30;
double *local_18;
double *local_10;
local_30 = DAT_00258c58;
local_18 = param_2;
local_10 = param_1;
do {
if (local_18[1] <= local_10[1]) {
local_38 = local_10[1];
}
else {
local_38 = local_18[1];
}
if (*local_10 < *local_18 || *local_10 == *local_18) {
local_48 = *local_10;
}
else {
local_48 = *local_18;
}
local_30 = (local_38 - local_48) * local_30;
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
if (0x7fefffffffffffff < (ulong)ABS(local_30)) {
local_30 = DAT_00258c70;
}
return local_30;
}
| |
22,949 | 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>>::start_array(unsigned long) | monkey531[P]llama/common/json.hpp | bool start_array(std::size_t len)
{
const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
keep_stack.push_back(keep);
auto val = handle_value(BasicJsonType::value_t::array, true);
ref_stack.push_back(val.second);
// check array limit
if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
}
return true;
} | O0 | cpp | 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>>::start_array(unsigned long):
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
addq $0x80, %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rdi
callq 0xc5b50
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movl %eax, %esi
addq $0xa8, %rcx
movl $0x2, %edx
callq 0xc5af0
movq 0x20(%rsp), %rdi
andb $0x1, %al
movb %al, 0x97(%rsp)
addq $0x20, %rdi
movb 0x97(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xc2910
movq 0x20(%rsp), %rdi
movb $0x2, 0x7f(%rsp)
leaq 0x7f(%rsp), %rsi
movl $0x1, %edx
callq 0xc5b70
movq 0x20(%rsp), %rdi
movb %al, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
addq $0x8, %rdi
leaq 0x80(%rsp), %rsi
addq $0x8, %rsi
callq 0xc60d0
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0xc6140
cmpq $0x0, (%rax)
je 0xc5315
xorl %eax, %eax
cmpq $-0x1, 0x98(%rsp)
movb %al, 0x17(%rsp)
je 0xc522b
movq 0x20(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xc6140
movq (%rax), %rdi
callq 0xc6180
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
seta %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc523c
jmp 0xc5315
movb $0x1, 0x2b(%rsp)
movl $0x20, %edi
callq 0x52570
movq %rax, (%rsp)
movq 0x98(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0xc6460
jmp 0xc5263
leaq 0x10035a(%rip), %rsi # 0x1c55c4
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0xcab30
jmp 0xc527b
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
callq 0xc6140
movq (%rsp), %rdi
movq (%rax), %rcx
movl $0x198, %esi # imm = 0x198
leaq 0x58(%rsp), %rdx
callq 0xc6200
jmp 0xc52a1
movq (%rsp), %rdi
movb $0x0, 0x2b(%rsp)
leaq 0x17cf4f(%rip), %rsi # 0x242200
leaq 0x558(%rip), %rdx # 0xc5810
callq 0x52960
jmp 0xc532b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xc5301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0xc52f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x53180
leaq 0x38(%rsp), %rdi
callq 0x53180
testb $0x1, 0x2b(%rsp)
jne 0xc530a
jmp 0xc5313
movq (%rsp), %rdi
callq 0x52cb0
jmp 0xc5321
movb $0x1, %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x529b0
nopl (%rax,%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11start_arrayEm:
sub rsp, 0A8h
mov qword ptr [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov rdi, qword ptr [rsp+0A8h+var_8]
mov qword ptr [rsp+0A8h+var_88], rdi; int
mov rax, rdi
add rax, 80h
mov qword ptr [rsp+0A8h+var_90], rax; char
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, qword ptr [rsp+0A8h+var_90]
mov rcx, qword ptr [rsp+0A8h+var_88]
mov esi, eax
add rcx, 0A8h
mov edx, 2
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 rdi, qword ptr [rsp+0A8h+var_88]
and al, 1
mov [rsp+0A8h+var_11], al
add rdi, 20h ; ' '
mov al, [rsp+0A8h+var_11]
and al, 1
movzx esi, al
call _ZNSt6vectorIbSaIbEE9push_backEb; std::vector<bool>::push_back(bool)
mov rdi, qword ptr [rsp+0A8h+var_88]
mov [rsp+0A8h+var_29], 2
lea rsi, [rsp+0A8h+var_29]
mov edx, 1
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueINS1_7value_tEEESt4pairIbPSF_EOT_b; 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,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(nlohmann::json_abi_v3_11_3::detail::value_t &&,bool)
mov rdi, qword ptr [rsp+0A8h+var_88]
mov byte ptr [rsp+0A8h+var_28], al; int
mov qword ptr [rsp+0A8h+var_20], rdx; int
add rdi, 8
lea rsi, [rsp+0A8h+var_28]
add rsi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE9push_backERKSE_; 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> *>>::push_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> * const&)
mov rdi, qword ptr [rsp+0A8h+var_88]
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
jz loc_C5315
xor eax, eax
cmp [rsp+0A8h+var_10], 0FFFFFFFFFFFFFFFFh
mov [rsp+0A8h+var_91], al
jz short loc_C522B
mov rdi, qword ptr [rsp+0A8h+var_88]
mov rax, [rsp+0A8h+var_10]
mov qword ptr [rsp+0A8h+var_A0], rax; int
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_IhSaIhEEvE8max_sizeEv; 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>::max_size(void)
mov rcx, rax
mov rax, qword ptr [rsp+0A8h+var_A0]
cmp rax, rcx
setnbe al
mov [rsp+0A8h+var_91], al
loc_C522B:
mov al, [rsp+0A8h+var_91]
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_C523C
jmp loc_C5315
loc_C523C:
mov [rsp+0A8h+var_7D], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0A8h+var_A8], rax; int
mov rsi, [rsp+0A8h+var_10]; unsigned __int64
lea rdi, [rsp+0A8h+var_70]; this
call _ZNSt7__cxx119to_stringEm; std::to_string(ulong)
jmp short $+2
loc_C5263:
lea rsi, aExcessiveArray; "excessive array size: "
lea rdi, [rsp+0A8h+var_50]
lea rdx, [rsp+0A8h+var_70]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA23_KcS8_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[23],std::string>(char const(&)[23],std::string &&)
jmp short $+2
loc_C527B:
mov rdi, qword ptr [rsp+0A8h+var_88]
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, [rsp+0A8h+var_A8]; int
mov rcx, [rax]
mov esi, 198h
lea rdx, [rsp+0A8h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_C52A1:
mov rdi, [rsp+0A8h+var_A8]; void *
mov [rsp+0A8h+var_7D], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail12out_of_rangeD2Ev; void (*)(void *)
call ___cxa_throw
jmp short loc_C532B
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_C5301
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
jmp short loc_C52F7
mov rcx, rax
mov eax, edx
mov [rsp+arg_28], rcx
mov [rsp+arg_24], eax
lea rdi, [rsp+arg_50]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C52F7:
lea rdi, [rsp+arg_30]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_C5301:
test [rsp+arg_23], 1
jnz short loc_C530A
jmp short loc_C5313
loc_C530A:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_C5313:
jmp short loc_C5321
loc_C5315:
mov al, 1
and al, 1
add rsp, 0A8h
retn
loc_C5321:
mov rdi, [rsp+arg_28]
call __Unwind_Resume
loc_C532B:
nop dword ptr [rax+rax+00h]
| start_array:
SUB RSP,0xa8
MOV qword ptr [RSP + 0xa0],RDI
MOV qword ptr [RSP + 0x98],RSI
MOV RDI,qword ptr [RSP + 0xa0]
MOV qword ptr [RSP + 0x20],RDI
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP + 0x18],RAX
ADD RDI,0x8
CALL 0x001c5b50
MOV RDI,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x20]
MOV ESI,EAX
ADD RCX,0xa8
MOV EDX,0x2
CALL 0x001c5af0
MOV RDI,qword ptr [RSP + 0x20]
AND AL,0x1
MOV byte ptr [RSP + 0x97],AL
ADD RDI,0x20
MOV AL,byte ptr [RSP + 0x97]
AND AL,0x1
MOVZX ESI,AL
CALL 0x001c2910
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x7f],0x2
LEA RSI,[RSP + 0x7f]
MOV EDX,0x1
CALL 0x001c5b70
MOV RDI,qword ptr [RSP + 0x20]
MOV byte ptr [RSP + 0x80],AL
MOV qword ptr [RSP + 0x88],RDX
ADD RDI,0x8
LEA RSI,[RSP + 0x80]
ADD RSI,0x8
CALL 0x001c60d0
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x8
CALL 0x001c6140
CMP qword ptr [RAX],0x0
JZ 0x001c5315
XOR EAX,EAX
CMP qword ptr [RSP + 0x98],-0x1
MOV byte ptr [RSP + 0x17],AL
JZ 0x001c522b
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x98]
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x8
CALL 0x001c6140
MOV RDI,qword ptr [RAX]
CALL 0x001c6180
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
SETA AL
MOV byte ptr [RSP + 0x17],AL
LAB_001c522b:
MOV AL,byte ptr [RSP + 0x17]
XOR AL,0xff
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c523c
JMP 0x001c5315
LAB_001c523c:
MOV byte ptr [RSP + 0x2b],0x1
MOV EDI,0x20
CALL 0x00152570
MOV qword ptr [RSP],RAX
MOV RSI,qword ptr [RSP + 0x98]
LAB_001c5257:
LEA RDI,[RSP + 0x38]
CALL 0x001c6460
JMP 0x001c5263
LAB_001c5263:
LEA RSI,[0x2c55c4]
LEA RDI,[RSP + 0x58]
LEA RDX,[RSP + 0x38]
CALL 0x001cab30
JMP 0x001c527b
LAB_001c527b:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x8
CALL 0x001c6140
MOV RDI,qword ptr [RSP]
MOV RCX,qword ptr [RAX]
LAB_001c5290:
MOV ESI,0x198
LEA RDX,[RSP + 0x58]
CALL 0x001c6200
JMP 0x001c52a1
LAB_001c52a1:
MOV RDI,qword ptr [RSP]
MOV byte ptr [RSP + 0x2b],0x0
LEA RSI,[0x342200]
LEA RDX,[0x1c5810]
CALL 0x00152960
LAB_001c5315:
MOV AL,0x1
AND AL,0x1
ADD RSP,0xa8
RET
|
/* 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> >::start_array(unsigned long) */
int8 __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>>
::start_array(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 bVar1;
ulong uVar2;
byte bVar3;
int4 uVar4;
long *plVar5;
int8 *puVar6;
ulong uVar7;
int8 uVar8;
basic_json *extraout_RDX;
__cxx11 local_70 [32];
detail local_50 [39];
value_t local_29;
int1 local_28;
basic_json *local_20;
int1 local_11;
ulong local_10;
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_8;
local_10 = param_1;
local_8 = this;
uVar4 = 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));
bVar3 = 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),uVar4,2,this + 0xa8);
local_11 = bVar3 & 1;
std::vector<bool,std::allocator<bool>>::push_back
((vector<bool,std::allocator<bool>> *)(this + 0x20),(bool)local_11);
local_29 = 2;
local_28 = handle_value<nlohmann::json_abi_v3_11_3::detail::value_t>(this,&local_29,true);
local_20 = extraout_RDX;
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>*>>
::push_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_20);
plVar5 = (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));
uVar2 = local_10;
if (*plVar5 != 0) {
bVar1 = false;
if (local_10 != 0xffffffffffffffff) {
puVar6 = (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));
uVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::max_size((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar6);
bVar1 = uVar7 < uVar2;
}
if (bVar1) {
uVar8 = __cxa_allocate_exception(0x20);
/* try { // try from 001c5257 to 001c5260 has its CatchHandler @ 001c52bf */
std::__cxx11::to_string(local_70,local_10);
/* try { // try from 001c5263 to 001c5278 has its CatchHandler @ 001c52cf */
concat<std::__cxx11::string,char_const(&)[23],std::__cxx11::string>
(local_50,"excessive array size: ",(string *)local_70);
puVar6 = (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));
/* try { // try from 001c5290 to 001c52bc has its CatchHandler @ 001c52df */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar8,0x198,local_50,*puVar6);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar8,&out_of_range::typeinfo,out_of_range::~out_of_range);
}
}
return 1;
}
| ||
22,950 | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, 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> const&) const | monkey531[P]llama/common/chat-template.hpp | std::string try_raw_render(
const nlohmann::ordered_json & messages,
const nlohmann::ordered_json & tools,
bool add_generation_prompt,
const nlohmann::ordered_json & extra_context = nlohmann::ordered_json()) const
{
try {
auto prompt = apply(messages, tools, add_generation_prompt, extra_context, /* adjust_inputs= */ false);
// fprintf(stderr, "try_raw_render: %s\n", prompt.c_str());
return prompt;
} catch (const std::exception & e) {
// fprintf(stderr, "try_raw_render error: %s\n", e.what());
return "";
}
} | O3 | cpp | minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, 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> const&) const:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, (%rsp)
callq 0xa1ebc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7f664
movq %r14, %rdi
callq 0x1a390
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x66d83(%rip), %rdx # 0xe63cd
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x22402
callq 0x1ae50
jmp 0x7f621
movq %rax, %r14
callq 0x1ae50
movq %r14, %rdi
callq 0x1af90
movq %rax, %rdi
callq 0x22203
| _ZNK5minja13chat_template14try_raw_renderERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_:
push r14
push rbx
push rax
mov rbx, rdi
mov [rsp+18h+var_18], 0
call _ZNK5minja13chat_template5applyERKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES5_IhSaIhEEvEESH_bSH_b; minja::chat_template::apply(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool,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&,bool)
loc_7F621:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
cmp edx, 1
jnz short loc_7F664
mov rdi, r14; void *
call ___cxa_begin_catch
lea rax, [rbx+10h]
mov [rbx], rax
lea rdx, aCosineSimilari+1Bh; ""
mov rdi, rbx
mov rsi, rdx
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)
call ___cxa_end_catch
jmp short loc_7F621
mov r14, rax
call ___cxa_end_catch
loc_7F664:
mov rdi, r14
call __Unwind_Resume
mov rdi, rax
call __clang_call_terminate
| long long minja::chat_template::try_raw_render(long long a1)
{
minja::chat_template::apply(a1);
return a1;
}
| try_raw_render:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LAB_0017f615:
MOV dword ptr [RSP],0x0
CALL 0x001a1ebc
LAB_0017f621:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* minja::chat_template::try_raw_render(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, 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> const&) const */
chat_template * __thiscall
minja::chat_template::try_raw_render
(chat_template *this,basic_json *param_1,basic_json *param_2,bool param_3,
basic_json *param_4)
{
int7 in_register_00000009;
/* try { // try from 0017f615 to 0017f620 has its CatchHandler @ 0017f62c */
apply((basic_json *)this,param_1,SUB81(param_2,0),
(basic_json *)CONCAT71(in_register_00000009,param_3),SUB81(param_4,0));
return this;
}
| |
22,951 | ma_calc_length_for_store_length | eloqsql/storage/maria/ma_blockrec.c | uint ma_calc_length_for_store_length(ulong nr)
{
if (nr < 251)
return 1;
if (nr < 65536)
{
if (nr <= 255)
return 2;
return 3;
}
if (nr < 16777216)
return 4;
return 5;
} | O0 | c | ma_calc_length_for_store_length:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0xfb, -0x10(%rbp)
jae 0x5600b
movl $0x1, -0x4(%rbp)
jmp 0x5604b
cmpq $0x10000, -0x10(%rbp) # imm = 0x10000
jae 0x56031
cmpq $0xff, -0x10(%rbp)
ja 0x56028
movl $0x2, -0x4(%rbp)
jmp 0x5604b
movl $0x3, -0x4(%rbp)
jmp 0x5604b
cmpq $0x1000000, -0x10(%rbp) # imm = 0x1000000
jae 0x56044
movl $0x4, -0x4(%rbp)
jmp 0x5604b
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
| ma_calc_length_for_store_length:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
cmp [rbp+var_10], 0FBh
jnb short loc_5600B
mov [rbp+var_4], 1
jmp short loc_5604B
loc_5600B:
cmp [rbp+var_10], 10000h
jnb short loc_56031
cmp [rbp+var_10], 0FFh
ja short loc_56028
mov [rbp+var_4], 2
jmp short loc_5604B
loc_56028:
mov [rbp+var_4], 3
jmp short loc_5604B
loc_56031:
cmp [rbp+var_10], 1000000h
jnb short loc_56044
mov [rbp+var_4], 4
jmp short loc_5604B
loc_56044:
mov [rbp+var_4], 5
loc_5604B:
mov eax, [rbp+var_4]
pop rbp
retn
| long long ma_calc_length_for_store_length(unsigned long long a1)
{
if ( a1 >= 0xFB )
{
if ( a1 >= 0x10000 )
{
if ( a1 >= 0x1000000 )
return 5;
else
return 4;
}
else if ( a1 > 0xFF )
{
return 3;
}
else
{
return 2;
}
}
else
{
return 1;
}
}
| ma_calc_length_for_store_length:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
CMP qword ptr [RBP + -0x10],0xfb
JNC 0x0015600b
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0015604b
LAB_0015600b:
CMP qword ptr [RBP + -0x10],0x10000
JNC 0x00156031
CMP qword ptr [RBP + -0x10],0xff
JA 0x00156028
MOV dword ptr [RBP + -0x4],0x2
JMP 0x0015604b
LAB_00156028:
MOV dword ptr [RBP + -0x4],0x3
JMP 0x0015604b
LAB_00156031:
CMP qword ptr [RBP + -0x10],0x1000000
JNC 0x00156044
MOV dword ptr [RBP + -0x4],0x4
JMP 0x0015604b
LAB_00156044:
MOV dword ptr [RBP + -0x4],0x5
LAB_0015604b:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 ma_calc_length_for_store_length(ulong param_1)
{
int4 local_c;
if (param_1 < 0xfb) {
local_c = 1;
}
else if (param_1 < 0x10000) {
if (param_1 < 0x100) {
local_c = 2;
}
else {
local_c = 3;
}
}
else if (param_1 < 0x1000000) {
local_c = 4;
}
else {
local_c = 5;
}
return local_c;
}
| |
22,952 | std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node>>> ftxui::unpack<std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>) | Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/include/ftxui/dom/take_any_args.hpp | Elements unpack(Args... args) {
std::vector<Element> vec;
(Merge(vec, std::move(args)), ...);
return vec;
} | O1 | cpp | std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node>>> ftxui::unpack<std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rsi), %rdx
leaq 0x20(%rsp), %rax
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq 0x8(%rsi), %rdx
movq %rcx, 0x8(%rsi)
movq %rdx, 0x8(%rax)
movq %rcx, (%rsi)
movq %rax, %rsi
callq 0x1535e
movq (%r15), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r15), %rcx
movq %rax, 0x8(%r15)
movq %rcx, 0x8(%rsi)
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x1535e
movq (%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x8(%r14), %rcx
movq %rax, 0x8(%r14)
movq %rcx, 0x8(%rsi)
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1535e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23737
callq 0x14c7c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x23746
callq 0x14c7c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x23755
callq 0x14c7c
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x23779
callq 0x14c7c
jmp 0x23779
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2378d
callq 0x14c7c
jmp 0x2378d
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x2379c
callq 0x14c7c
movq %rbx, %rdi
callq 0x151c0
movq %r14, %rdi
callq 0xb780
| _ZN5ftxui6unpackIJSt10shared_ptrINS_4NodeEES3_S3_EEESt6vectorIS3_SaIS3_EEDpT_:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rcx
mov r15, rdx
mov rbx, rdi
xor ecx, ecx
mov [rdi+10h], rcx
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
lea rax, [rsp+48h+var_28]
mov [rax], rdx
mov [rax+8], rcx
mov rdx, [rsi+8]
mov [rsi+8], rcx
mov [rax+8], rdx
mov [rsi], rcx
mov rsi, rax
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node> &&)
mov rax, [r15]
lea rsi, [rsp+48h+var_38]
mov [rsi], rax
xor eax, eax
mov [rsi+8], rax
mov rcx, [r15+8]
mov [r15+8], rax
mov [rsi+8], rcx
mov [r15], rax
mov rdi, rbx
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node> &&)
mov rax, [r14]
mov rsi, rsp
mov [rsi], rax
xor eax, eax
mov [rsi+8], rax
mov rcx, [r14+8]
mov [r14+8], rax
mov [rsi+8], rcx
mov [r14], rax
mov rdi, rbx
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node> &&)
mov rdi, [rsp+48h+var_40]
test rdi, rdi
jz short loc_23737
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_23737:
mov rdi, [rsp+48h+var_30]
test rdi, rdi
jz short loc_23746
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_23746:
mov rdi, [rsp+48h+var_20]
test rdi, rdi
jz short loc_23755
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_23755:
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_23779
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_23779
mov r14, rax
loc_23779:
mov rdi, [rsp+arg_10]
test rdi, rdi
jz short loc_2378D
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_2378D
mov r14, rax
loc_2378D:
mov rdi, [rsp+arg_20]
test rdi, rdi
jz short loc_2379C
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_2379C:
mov rdi, rbx
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, r14
call __Unwind_Resume
| long long ftxui::unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>(
long long a1,
long long *a2,
long long *a3,
long long *a4)
{
volatile signed __int32 *v6; // rdx
volatile signed __int32 *v7; // rcx
volatile signed __int32 *v8; // rcx
long long v10; // [rsp+0h] [rbp-48h] BYREF
volatile signed __int32 *v11; // [rsp+8h] [rbp-40h]
long long v12; // [rsp+10h] [rbp-38h] BYREF
volatile signed __int32 *v13; // [rsp+18h] [rbp-30h]
long long v14; // [rsp+20h] [rbp-28h] BYREF
volatile signed __int32 *v15; // [rsp+28h] [rbp-20h]
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v14 = *a2;
v15 = 0LL;
v6 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v15 = v6;
*a2 = 0LL;
std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(a1, &v14);
v12 = *a3;
v13 = 0LL;
v7 = (volatile signed __int32 *)a3[1];
a3[1] = 0LL;
v13 = v7;
*a3 = 0LL;
std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(a1, &v12);
v10 = *a4;
v11 = 0LL;
v8 = (volatile signed __int32 *)a4[1];
a4[1] = 0LL;
v11 = v8;
*a4 = 0LL;
std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(a1, &v10);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v13 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v13);
if ( v15 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v15);
return a1;
}
| unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RCX
MOV R15,RDX
MOV RBX,RDI
XOR ECX,ECX
MOV qword ptr [RDI + 0x10],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
LEA RAX,[RSP + 0x20]
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RAX + 0x8],RDX
MOV qword ptr [RSI],RCX
LAB_001236d2:
MOV RSI,RAX
CALL 0x0011535e
MOV RAX,qword ptr [R15]
LEA RSI,[RSP + 0x10]
MOV qword ptr [RSI],RAX
XOR EAX,EAX
MOV qword ptr [RSI + 0x8],RAX
MOV RCX,qword ptr [R15 + 0x8]
MOV qword ptr [R15 + 0x8],RAX
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [R15],RAX
LAB_001236fa:
MOV RDI,RBX
CALL 0x0011535e
MOV RAX,qword ptr [R14]
MOV RSI,RSP
MOV qword ptr [RSI],RAX
XOR EAX,EAX
MOV qword ptr [RSI + 0x8],RAX
MOV RCX,qword ptr [R14 + 0x8]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [R14],RAX
LAB_00123720:
MOV RDI,RBX
CALL 0x0011535e
LAB_00123728:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00123737
CALL 0x00114c7c
LAB_00123737:
MOV RDI,qword ptr [RSP + 0x18]
TEST RDI,RDI
JZ 0x00123746
CALL 0x00114c7c
LAB_00123746:
MOV RDI,qword ptr [RSP + 0x28]
TEST RDI,RDI
JZ 0x00123755
CALL 0x00114c7c
LAB_00123755:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node> > >
ftxui::unpack<std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>,
std::shared_ptr<ftxui::Node> >(std::shared_ptr<ftxui::Node>, std::shared_ptr<ftxui::Node>,
std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall
ftxui::
unpack<std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>,std::shared_ptr<ftxui::Node>>
(ftxui *this,int8 *param_2,int8 *param_3,int8 *param_4)
{
int8 local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_40;
int8 local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
int8 local_28;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_20;
*(int8 *)(this + 0x10) = 0;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
local_28 = *param_2;
local_20 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 001236d2 to 001236d9 has its CatchHandler @ 0012378a */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::
emplace_back<std::shared_ptr<ftxui::Node>>
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
this,(shared_ptr *)&local_28);
local_38 = *param_3;
local_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_3[1];
param_3[1] = 0;
*param_3 = 0;
/* try { // try from 001236fa to 00123701 has its CatchHandler @ 00123776 */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::
emplace_back<std::shared_ptr<ftxui::Node>>
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
this,(shared_ptr *)&local_38);
local_48 = *param_4;
local_40 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_4[1];
param_4[1] = 0;
*param_4 = 0;
/* try { // try from 00123720 to 00123727 has its CatchHandler @ 00123762 */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::
emplace_back<std::shared_ptr<ftxui::Node>>
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
this,(shared_ptr *)&local_48);
if (local_40 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_40);
}
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
if (local_20 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_20);
}
return this;
}
| |
22,953 | nglog::VADoRawLog(char**, unsigned long*, char const*, __va_list_tag*) | ng-log[P]ng-log/src/raw_logging.cc | inline static bool VADoRawLog(char** buf, size_t* size, const char* format,
va_list ap) {
#if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif
int n = std::vsnprintf(*buf, *size, format, ap);
#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif
if (n < 0 || static_cast<size_t>(n) > *size) return false;
*size -= static_cast<size_t>(n);
*buf += n;
return true;
} | O0 | cpp | nglog::VADoRawLog(char**, unsigned long*, char const*, __va_list_tag*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x9460
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x49409
movslq -0x2c(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x4940f
movb $0x0, -0x1(%rbp)
jmp 0x49437
movslq -0x2c(%rbp), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movl -0x2c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ZN5nglogL10VADoRawLogEPPcPmPKcP13__va_list_tag:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_18]
mov rsi, [rax]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call _vsnprintf
mov [rbp+var_2C], eax
cmp [rbp+var_2C], 0
jl short loc_49409
movsxd rax, [rbp+var_2C]
mov rcx, [rbp+var_18]
cmp rax, [rcx]
jbe short loc_4940F
loc_49409:
mov [rbp+var_1], 0
jmp short loc_49437
loc_4940F:
movsxd rdx, [rbp+var_2C]
mov rax, [rbp+var_18]
mov rcx, [rax]
sub rcx, rdx
mov [rax], rcx
mov edx, [rbp+var_2C]
mov rax, [rbp+var_10]
mov rcx, [rax]
movsxd rdx, edx
add rcx, rdx
mov [rax], rcx
mov [rbp+var_1], 1
loc_49437:
mov al, [rbp+var_1]
and al, 1
add rsp, 30h
pop rbp
retn
| char nglog::VADoRawLog(nglog *this, char **a2, unsigned long long *a3, const char *a4, __va_list_tag *a5)
{
int v6; // [rsp+4h] [rbp-2Ch]
v6 = vsnprintf(*(_QWORD *)this, *a2, a3, a4);
if ( v6 < 0 || v6 > (unsigned long long)*a2 )
return 0;
*a2 -= v6;
*(_QWORD *)this += v6;
return 1;
}
| VADoRawLog:
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 qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x00109460
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x2c],0x0
JL 0x00149409
MOVSXD RAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX]
JBE 0x0014940f
LAB_00149409:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x00149437
LAB_0014940f:
MOVSXD RDX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
SUB RCX,RDX
MOV qword ptr [RAX],RCX
MOV EDX,dword ptr [RBP + -0x2c]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOVSXD RDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX],RCX
MOV byte ptr [RBP + -0x1],0x1
LAB_00149437:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x30
POP RBP
RET
|
/* nglog::VADoRawLog(char**, unsigned long*, char const*, __va_list_tag*) */
int1 nglog::VADoRawLog(char **param_1,ulong *param_2,char *param_3,__va_list_tag *param_4)
{
int iVar1;
int1 local_9;
iVar1 = vsnprintf(*param_1,*param_2,param_3,param_4);
if ((iVar1 < 0) || (*param_2 < (ulong)(long)iVar1)) {
local_9 = 0;
}
else {
*param_2 = *param_2 - (long)iVar1;
*param_1 = *param_1 + iVar1;
local_9 = 1;
}
return local_9;
}
| |
22,954 | lefSpacing(LefDefParser::lefiSpacing*, char*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lefdiff/diffLefRW.cpp | void lefSpacing(lefiSpacing* spacing, char *inName) {
fprintf(fout, "%s SAMENET %s %s %g ", inName, spacing->name1(),
spacing->name2(), chkNum(spacing->distance()));
if (spacing->hasStack())
fprintf(fout, " STACK");
fprintf(fout,"\n");
return;
} | O3 | cpp | lefSpacing(LefDefParser::lefiSpacing*, char*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x742bb(%rip), %r15 # 0x773f0
callq 0x12326
movq %rax, %r12
movq %rbx, %rdi
callq 0x1232c
movq %rax, %r13
movq %rbx, %rdi
callq 0x12332
movapd 0x47eb8(%rip), %xmm1 # 0x4b010
andpd %xmm0, %xmm1
ucomisd 0x47f2c(%rip), %xmm1 # 0x4b090
jbe 0x319d
cvttsd2si %xmm0, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
movabsq $0x1999999999999999, %rax # imm = 0x1999999999999999
addq %rcx, %rax
movabsq $0x3333333333333332, %rcx # imm = 0x3333333333333332
cmpq %rcx, %rax
ja 0x319d
addsd 0x47efb(%rip), %xmm0 # 0x4b098
leaq 0x4816a(%rip), %rsi # 0x4b30e
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %r13, %r8
movb $0x1, %al
callq 0x22c0
movq %rbx, %rdi
callq 0x12338
testl %eax, %eax
je 0x31e0
movq 0x74226(%rip), %rcx # 0x773f0
leaq 0x4a7cd(%rip), %rdi # 0x4d99e
movl $0x6, %esi
movl $0x1, %edx
callq 0x23b0
movq 0x74209(%rip), %rsi # 0x773f0
movl $0xa, %edi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2270
| _Z10lefSpacingPN12LefDefParser11lefiSpacingEPc:
push r15
push r14
push r13
push r12
push rbx
mov r14, rsi
mov rbx, rdi
mov r15, cs:fout
call _ZNK12LefDefParser11lefiSpacing5name1Ev; LefDefParser::lefiSpacing::name1(void)
mov r12, rax
mov rdi, rbx; this
call _ZNK12LefDefParser11lefiSpacing5name2Ev; LefDefParser::lefiSpacing::name2(void)
mov r13, rax
mov rdi, rbx; this
call _ZNK12LefDefParser11lefiSpacing8distanceEv; LefDefParser::lefiSpacing::distance(void)
movapd xmm1, cs:xmmword_4B010
andpd xmm1, xmm0
ucomisd xmm1, cs:qword_4B090
jbe short loc_319D
cvttsd2si rax, xmm0
mov rcx, 0CCCCCCCCCCCCCCCDh
imul rcx, rax
mov rax, 1999999999999999h
add rax, rcx
mov rcx, 3333333333333332h
cmp rax, rcx
ja short loc_319D
addsd xmm0, cs:qword_4B098
loc_319D:
lea rsi, aSSamenetSSG; "%s SAMENET %s %s %g "
mov rdi, r15
mov rdx, r14
mov rcx, r12
mov r8, r13
mov al, 1
call _fprintf
mov rdi, rbx; this
call _ZNK12LefDefParser11lefiSpacing8hasStackEv; LefDefParser::lefiSpacing::hasStack(void)
test eax, eax
jz short loc_31E0
mov rcx, cs:fout
lea rdi, aStack+1; " STACK"
mov esi, 6
mov edx, 1
call _fwrite
loc_31E0:
mov rsi, cs:fout
mov edi, 0Ah
pop rbx
pop r12
pop r13
pop r14
pop r15
jmp _fputc
| long long lefSpacing(LefDefParser::lefiSpacing *this, char *a2, double a3)
{
long long v3; // r15
const char *v4; // r12
const char *v5; // r13
v3 = fout;
v4 = (const char *)LefDefParser::lefiSpacing::name1(this);
v5 = (const char *)LefDefParser::lefiSpacing::name2(this);
LefDefParser::lefiSpacing::distance(this);
if ( fabs(a3) > 1000004.0
&& 0xCCCCCCCCCCCCCCCDLL * (unsigned int)(int)a3 + 0x1999999999999999LL <= 0x3333333333333332LL )
{
a3 = a3 + 3.0;
}
fprintf(v3, "%s SAMENET %s %s %g ", a2, v4, v5, a3);
if ( (unsigned int)LefDefParser::lefiSpacing::hasStack(this) )
fwrite(" STACK", 6LL, 1LL, fout);
return fputc(10LL, fout);
}
| lefSpacing:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV R15,qword ptr [0x001773f0]
CALL 0x00112326
MOV R12,RAX
MOV RDI,RBX
CALL 0x0011232c
MOV R13,RAX
MOV RDI,RBX
CALL 0x00112332
MOVAPD XMM1,xmmword ptr [0x0014b010]
ANDPD XMM1,XMM0
UCOMISD XMM1,qword ptr [0x0014b090]
JBE 0x0010319d
CVTTSD2SI RAX,XMM0
MOV RCX,-0x3333333333333333
IMUL RCX,RAX
MOV RAX,0x1999999999999999
ADD RAX,RCX
MOV RCX,0x3333333333333332
CMP RAX,RCX
JA 0x0010319d
ADDSD XMM0,qword ptr [0x0014b098]
LAB_0010319d:
LEA RSI,[0x14b30e]
MOV RDI,R15
MOV RDX,R14
MOV RCX,R12
MOV R8,R13
MOV AL,0x1
CALL 0x001022c0
MOV RDI,RBX
CALL 0x00112338
TEST EAX,EAX
JZ 0x001031e0
MOV RCX,qword ptr [0x001773f0]
LEA RDI,[0x14d99e]
MOV ESI,0x6
MOV EDX,0x1
CALL 0x001023b0
LAB_001031e0:
MOV RSI,qword ptr [0x001773f0]
MOV EDI,0xa
POP RBX
POP R12
POP R13
POP R14
POP R15
JMP 0x00102270
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* lefSpacing(LefDefParser::lefiSpacing*, char*) */
void lefSpacing(lefiSpacing *param_1,char *param_2)
{
FILE *__stream;
int iVar1;
int8 uVar2;
int8 uVar3;
double dVar4;
__stream = fout;
uVar2 = LefDefParser::lefiSpacing::name1(param_1);
uVar3 = LefDefParser::lefiSpacing::name2(param_1);
dVar4 = (double)LefDefParser::lefiSpacing::distance(param_1);
if ((DAT_0014b090 < (double)(_DAT_0014b010 & (ulong)dVar4)) &&
((long)dVar4 * -0x3333333333333333 + 0x1999999999999999U < 0x3333333333333333)) {
dVar4 = dVar4 + _DAT_0014b098;
}
fprintf(__stream,"%s SAMENET %s %s %g ",dVar4,param_2,uVar2,uVar3);
iVar1 = LefDefParser::lefiSpacing::hasStack(param_1);
if (iVar1 != 0) {
fwrite(" STACK",6,1,fout);
}
fputc(10,fout);
return;
}
| |
22,955 | js_std_dump_error1 | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_dump_error1(JSContext *ctx, JSValue exception_val)
{
JSValue val;
BOOL is_error;
is_error = JS_IsError(ctx, exception_val);
js_dump_obj(ctx, stderr, exception_val);
if (is_error) {
val = JS_GetPropertyStr(ctx, exception_val, "stack");
if (!JS_IsUndefined(val)) {
js_dump_obj(ctx, stderr, val);
}
JS_FreeValue(ctx, val);
}
} | O0 | c | js_std_dump_error1:
subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x3e490
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x125501(%rip), %rax # 0x13cff8
movq (%rax), %rsi
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x17ba0
cmpl $0x0, 0x1c(%rsp)
je 0x17b8f
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0xf7ec7(%rip), %rcx # 0x10f9ed
callq 0x38170
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x17c20
cmpl $0x0, %eax
jne 0x17b7b
movq 0x30(%rsp), %rdi
movq 0x12548f(%rip), %rax # 0x13cff8
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x17ba0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x29f80
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
| js_std_dump_error1:
sub rsp, 48h
mov [rsp+48h+var_10], rsi
mov [rsp+48h+var_8], rdx
mov [rsp+48h+var_18], rdi
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
call JS_IsError
mov [rsp+48h+var_2C], eax
mov rdi, [rsp+48h+var_18]
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov rdx, [rsp+48h+var_10]
mov rcx, [rsp+48h+var_8]
call js_dump_obj
cmp [rsp+48h+var_2C], 0
jz short loc_17B8F
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
lea rcx, aStack; "stack"
call JS_GetPropertyStr
mov [rsp+48h+var_40], rax
mov [rsp+48h+var_38], rdx
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_28], rax
mov rax, [rsp+48h+var_38]
mov [rsp+48h+var_20], rax
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_20]
call JS_IsUndefined_0
cmp eax, 0
jnz short loc_17B7B
mov rdi, [rsp+48h+var_18]
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov rdx, [rsp+48h+var_28]
mov rcx, [rsp+48h+var_20]
call js_dump_obj
loc_17B7B:
mov rdi, [rsp+48h+var_18]
mov rsi, [rsp+48h+var_28]
mov rdx, [rsp+48h+var_20]
call JS_FreeValue
loc_17B8F:
add rsp, 48h
retn
| long long js_std_dump_error1(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rdx
long long PropertyStr; // [rsp+8h] [rbp-40h]
int IsError; // [rsp+1Ch] [rbp-2Ch]
long long v7; // [rsp+28h] [rbp-20h]
IsError = JS_IsError(a1, a2, a3);
result = js_dump_obj(a1, stderr, a2, a3);
if ( IsError )
{
PropertyStr = JS_GetPropertyStr(a1, a2, a3, "stack");
v7 = v4;
if ( !(unsigned int)JS_IsUndefined_0(PropertyStr, v4) )
js_dump_obj(a1, stderr, PropertyStr, v7);
return JS_FreeValue(a1, PropertyStr, v7);
}
return result;
}
| js_std_dump_error1:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RSI
MOV qword ptr [RSP + 0x40],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
CALL 0x0013e490
MOV dword ptr [RSP + 0x1c],EAX
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [0x0023cff8]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x38]
MOV RCX,qword ptr [RSP + 0x40]
CALL 0x00117ba0
CMP dword ptr [RSP + 0x1c],0x0
JZ 0x00117b8f
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
LEA RCX,[0x20f9ed]
CALL 0x00138170
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RDX
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP + 0x28],RAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
CALL 0x00117c20
CMP EAX,0x0
JNZ 0x00117b7b
MOV RDI,qword ptr [RSP + 0x30]
MOV RAX,qword ptr [0x0023cff8]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x00117ba0
LAB_00117b7b:
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
CALL 0x00129f80
LAB_00117b8f:
ADD RSP,0x48
RET
|
void js_std_dump_error1(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
int8 uVar3;
int1 auVar4 [16];
iVar1 = JS_IsError(param_1,param_2,param_3);
js_dump_obj(param_1,*(int8 *)PTR_stderr_0023cff8,param_2,param_3);
if (iVar1 != 0) {
auVar4 = JS_GetPropertyStr(param_1,param_2,param_3,"stack");
uVar3 = auVar4._8_8_;
uVar2 = auVar4._0_8_;
iVar1 = JS_IsUndefined(uVar2,uVar3);
if (iVar1 == 0) {
js_dump_obj(param_1,*(int8 *)PTR_stderr_0023cff8,uVar2,uVar3);
}
JS_FreeValue(param_1,uVar2,uVar3);
}
return;
}
| |
22,956 | js_std_dump_error1 | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_dump_error1(JSContext *ctx, JSValue exception_val)
{
JSValue val;
BOOL is_error;
is_error = JS_IsError(ctx, exception_val);
js_dump_obj(ctx, stderr, exception_val);
if (is_error) {
val = JS_GetPropertyStr(ctx, exception_val, "stack");
if (!JS_IsUndefined(val)) {
js_dump_obj(ctx, stderr, val);
}
JS_FreeValue(ctx, val);
}
} | O1 | c | js_std_dump_error1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2b53b
movl %eax, %ebp
movq 0xb8b4a(%rip), %r12 # 0xd1ff8
movq (%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x19516
testl %ebp, %ebp
je 0x1950d
leaq 0x8652f(%rip), %rcx # 0x9f9fa
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x28346
movq %rax, %r14
movq %rdx, %r15
cmpl $0x3, %r15d
je 0x194f7
movq (%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x19516
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2190f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| js_std_dump_error1:
push rbp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
call JS_IsError
mov ebp, eax
mov r12, cs:stderr_ptr
mov rsi, [r12]
mov rdi, rbx
mov rdx, r15
mov rcx, r14
call js_dump_obj
test ebp, ebp
jz short loc_1950D
lea rcx, aStack; "stack"
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetPropertyStr
mov r14, rax
mov r15, rdx
cmp r15d, 3
jz short loc_194F7
mov rsi, [r12]
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call js_dump_obj
loc_194F7:
mov rdi, rbx
mov rsi, r14
mov rdx, r15
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp JS_FreeValue
loc_1950D:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long js_std_dump_error1(long long a1, long long a2, long long a3)
{
int IsError; // ebp
long long result; // rax
long long PropertyStr; // rax
long long v7; // rdx
long long v8; // r14
IsError = JS_IsError(a1, a2);
result = js_dump_obj(a1, stderr, a2, a3);
if ( IsError )
{
PropertyStr = JS_GetPropertyStr(a1, a2, a3, "stack");
v8 = PropertyStr;
if ( (_DWORD)v7 != 3 )
js_dump_obj(a1, stderr, PropertyStr, v7);
return JS_FreeValue(a1, v8);
}
return result;
}
| js_std_dump_error1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x0012b53b
MOV EBP,EAX
MOV R12,qword ptr [0x001d1ff8]
MOV RSI,qword ptr [R12]
MOV RDI,RBX
MOV RDX,R15
MOV RCX,R14
CALL 0x00119516
TEST EBP,EBP
JZ 0x0011950d
LEA RCX,[0x19f9fa]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00128346
MOV R14,RAX
MOV R15,RDX
CMP R15D,0x3
JZ 0x001194f7
MOV RSI,qword ptr [R12]
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x00119516
LAB_001194f7:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0012190f
LAB_0011950d:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void js_std_dump_error1(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
int *puVar2;
int iVar3;
int8 extraout_RDX;
iVar3 = JS_IsError();
puVar2 = PTR_stderr_001d1ff8;
js_dump_obj(param_1,*(int8 *)PTR_stderr_001d1ff8,param_2,param_3);
if (iVar3 != 0) {
uVar1 = JS_GetPropertyStr(param_1,param_2,param_3,"stack");
if ((int)extraout_RDX != 3) {
js_dump_obj(param_1,*(int8 *)puVar2,uVar1,extraout_RDX);
}
JS_FreeValue(param_1,uVar1,extraout_RDX);
return;
}
return;
}
| |
22,957 | js_std_dump_error1 | bluesky950520[P]quickjs/quickjs-libc.c | void js_std_dump_error1(JSContext *ctx, JSValue exception_val)
{
JSValue val;
BOOL is_error;
is_error = JS_IsError(ctx, exception_val);
js_dump_obj(ctx, stderr, exception_val);
if (is_error) {
val = JS_GetPropertyStr(ctx, exception_val, "stack");
if (!JS_IsUndefined(val)) {
js_dump_obj(ctx, stderr, val);
}
JS_FreeValue(ctx, val);
}
} | O2 | c | js_std_dump_error1:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x24d24
movl %eax, %ebp
movq 0xab070(%rip), %r12 # 0xbeff8
movq (%r12), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x13ff0
testl %ebp, %ebp
je 0x13fe7
leaq 0x71a3e(%rip), %rcx # 0x859e3
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21fab
movq %rax, %r14
movq %rdx, %r15
cmpl $0x3, %r15d
je 0x13fd1
movq (%r12), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x13ff0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1bbce
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| js_std_dump_error1:
push rbp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
call JS_IsError
mov ebp, eax
mov r12, cs:stderr_ptr
mov rsi, [r12]
mov rdi, rbx
mov rdx, r15
mov rcx, r14
call js_dump_obj
test ebp, ebp
jz short loc_13FE7
lea rcx, aStack; "stack"
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_GetPropertyStr
mov r14, rax
mov r15, rdx
cmp r15d, 3
jz short loc_13FD1
mov rsi, [r12]
mov rdi, rbx
mov rdx, r14
mov rcx, r15
call js_dump_obj
loc_13FD1:
mov rdi, rbx
mov rsi, r14
mov rdx, r15
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp JS_FreeValue
loc_13FE7:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long js_std_dump_error1(long long a1, long long a2, long long a3)
{
int IsError; // ebp
long long result; // rax
long long PropertyStr; // rax
long long v7; // rdx
long long v8; // r14
IsError = JS_IsError(a1, a2);
result = js_dump_obj(a1, stderr, a2, a3);
if ( IsError )
{
PropertyStr = JS_GetPropertyStr(a1, a2, a3, "stack");
v8 = PropertyStr;
if ( (_DWORD)v7 != 3 )
js_dump_obj(a1, stderr, PropertyStr, v7);
return JS_FreeValue(a1, v8);
}
return result;
}
| js_std_dump_error1:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
CALL 0x00124d24
MOV EBP,EAX
MOV R12,qword ptr [0x001beff8]
MOV RSI,qword ptr [R12]
MOV RDI,RBX
MOV RDX,R15
MOV RCX,R14
CALL 0x00113ff0
TEST EBP,EBP
JZ 0x00113fe7
LEA RCX,[0x1859e3]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x00121fab
MOV R14,RAX
MOV R15,RDX
CMP R15D,0x3
JZ 0x00113fd1
MOV RSI,qword ptr [R12]
MOV RDI,RBX
MOV RDX,R14
MOV RCX,R15
CALL 0x00113ff0
LAB_00113fd1:
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x0011bbce
LAB_00113fe7:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void js_std_dump_error1(int8 param_1,int8 param_2,int8 param_3)
{
int8 uVar1;
int *puVar2;
int iVar3;
int8 extraout_RDX;
iVar3 = JS_IsError();
puVar2 = PTR_stderr_001beff8;
js_dump_obj(param_1,*(int8 *)PTR_stderr_001beff8,param_2,param_3);
if (iVar3 != 0) {
uVar1 = JS_GetPropertyStr(param_1,param_2,param_3,"stack");
if ((int)extraout_RDX != 3) {
js_dump_obj(param_1,*(int8 *)puVar2,uVar1,extraout_RDX);
}
JS_FreeValue(param_1,uVar1,extraout_RDX);
return;
}
return;
}
| |
22,958 | init_events_statements_history_long(unsigned long) | eloqsql/storage/perfschema/pfs_events_statements.cc | int init_events_statements_history_long(size_t events_statements_history_long_sizing)
{
events_statements_history_long_size= events_statements_history_long_sizing;
events_statements_history_long_full= false;
PFS_atomic::store_u32(&events_statements_history_long_index.m_u32, 0);
if (events_statements_history_long_size == 0)
return 0;
events_statements_history_long_array=
PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long,
events_statements_history_long_size, sizeof(PFS_events_statements),
PFS_events_statements, MYF(MY_ZEROFILL));
if (events_statements_history_long_array == NULL)
{
cleanup_events_statements_history_long();
return 1;
}
if (pfs_max_digest_length > 0)
{
/* Size of each digest text array. */
size_t digest_text_size= pfs_max_digest_length * sizeof(unsigned char);
h_long_stmts_digest_token_array=
PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long_tokens,
events_statements_history_long_size, digest_text_size,
unsigned char, MYF(MY_ZEROFILL));
if (h_long_stmts_digest_token_array == NULL)
{
cleanup_events_statements_history_long();
return 1;
}
}
if (pfs_max_sqltext > 0)
{
/* Size of each sql text array. */
size_t sqltext_size= pfs_max_sqltext * sizeof(char);
h_long_stmts_text_array=
PFS_MALLOC_ARRAY(& builtin_memory_statements_history_long_sqltext,
events_statements_history_long_size, sqltext_size,
char, MYF(MY_ZEROFILL));
if (h_long_stmts_text_array == NULL)
{
cleanup_events_statements_history_long();
return 1;
}
}
for (size_t index= 0; index < events_statements_history_long_size; index++)
{
events_statements_history_long_array[index].m_digest_storage.reset(h_long_stmts_digest_token_array
+ index * pfs_max_digest_length, pfs_max_digest_length);
events_statements_history_long_array[index].m_sqltext= h_long_stmts_text_array + index * pfs_max_sqltext;
}
return 0;
} | O3 | cpp | init_events_statements_history_long(unsigned long):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, 0x38de1f(%rip) # 0x3d2c00
movb $0x0, 0x38df18(%rip) # 0x3d2d00
xorl %ebx, %ebx
xorl %eax, %eax
xchgl %eax, 0x38df4e(%rip) # 0x3d2d40
testq %rdi, %rdi
je 0x44f31
movq %rdi, %rsi
leaq 0x3892bb(%rip), %rdi # 0x3ce0c0
movl $0x590, %edx # imm = 0x590
movl $0x20, %ecx
callq 0x30f01
movq %rax, 0x38df65(%rip) # 0x3d2d80
testq %rax, %rax
je 0x44f27
leaq 0x38a4d5(%rip), %r14 # 0x3cf300
movq (%r14), %rdx
testq %rdx, %rdx
je 0x44e5b
movq 0x38ddc6(%rip), %rsi # 0x3d2c00
leaq 0x3893bf(%rip), %rdi # 0x3ce200
movl $0x20, %ecx
callq 0x30f01
movq %rax, 0x38df36(%rip) # 0x3d2d88
testq %rax, %rax
je 0x44f27
leaq 0x38a4a6(%rip), %r15 # 0x3cf308
movq (%r15), %rdx
testq %rdx, %rdx
je 0x44e92
movq 0x38dd8f(%rip), %rsi # 0x3d2c00
leaq 0x3894c8(%rip), %rdi # 0x3ce340
movl $0x20, %ecx
callq 0x30f01
movq %rax, 0x38df07(%rip) # 0x3d2d90
testq %rax, %rax
je 0x44f27
cmpq $0x0, 0x38dd66(%rip) # 0x3d2c00
je 0x44f31
movq 0x38dee1(%rip), %rax # 0x3d2d88
movq 0x38dee2(%rip), %rcx # 0x3d2d90
xorl %ebx, %ebx
xorps %xmm0, %xmm0
xorl %edx, %edx
xorl %esi, %esi
movq 0x38dec2(%rip), %rdi # 0x3d2d80
movq (%r14), %r8
movq %r8, %r9
imulq %rsi, %r9
addq %rax, %r9
movq %r9, 0x580(%rdi,%rdx)
movl %r8d, 0x588(%rdi,%rdx)
movb $0x0, 0x560(%rdi,%rdx)
movl %ebx, 0x564(%rdi,%rdx)
movl %ebx, 0x578(%rdi,%rdx)
movups %xmm0, 0x568(%rdi,%rdx)
movq (%r15), %rdi
imulq %rsi, %rdi
addq %rcx, %rdi
movq 0x38de76(%rip), %r8 # 0x3d2d80
movq %rdi, 0x550(%r8,%rdx)
incq %rsi
addq $0x590, %rdx # imm = 0x590
cmpq 0x38dcdd(%rip), %rsi # 0x3d2c00
jb 0x44eb7
jmp 0x44f31
callq 0x44f3e
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| _Z35init_events_statements_history_longm:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov cs:events_statements_history_long_size, rdi
mov cs:events_statements_history_long_full, 0
xor ebx, ebx
xor eax, eax
xchg eax, cs:events_statements_history_long_index
test rdi, rdi
jz loc_44F31
mov rsi, rdi
lea rdi, builtin_memory_statements_history_long
mov edx, 590h
mov ecx, 20h ; ' '
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:events_statements_history_long_array, rax
test rax, rax
jz loc_44F27
lea r14, pfs_max_digest_length
mov rdx, [r14]
test rdx, rdx
jz short loc_44E5B
mov rsi, cs:events_statements_history_long_size
lea rdi, builtin_memory_statements_history_long_tokens
mov ecx, 20h ; ' '
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:_ZL31h_long_stmts_digest_token_array, rax; h_long_stmts_digest_token_array
test rax, rax
jz loc_44F27
loc_44E5B:
lea r15, pfs_max_sqltext
mov rdx, [r15]
test rdx, rdx
jz short loc_44E92
mov rsi, cs:events_statements_history_long_size
lea rdi, builtin_memory_statements_history_long_sqltext
mov ecx, 20h ; ' '
call _Z16pfs_malloc_arrayP24PFS_builtin_memory_classmmm; pfs_malloc_array(PFS_builtin_memory_class *,ulong,ulong,ulong)
mov cs:_ZL23h_long_stmts_text_array, rax; h_long_stmts_text_array
test rax, rax
jz loc_44F27
loc_44E92:
cmp cs:events_statements_history_long_size, 0
jz loc_44F31
mov rax, cs:_ZL31h_long_stmts_digest_token_array; h_long_stmts_digest_token_array
mov rcx, cs:_ZL23h_long_stmts_text_array; h_long_stmts_text_array
xor ebx, ebx
xorps xmm0, xmm0
xor edx, edx
xor esi, esi
loc_44EB7:
mov rdi, cs:events_statements_history_long_array
mov r8, [r14]
mov r9, r8
imul r9, rsi
add r9, rax
mov [rdi+rdx+580h], r9
mov [rdi+rdx+588h], r8d
mov byte ptr [rdi+rdx+560h], 0
mov [rdi+rdx+564h], ebx
mov [rdi+rdx+578h], ebx
movups xmmword ptr [rdi+rdx+568h], xmm0
mov rdi, [r15]
imul rdi, rsi
add rdi, rcx
mov r8, cs:events_statements_history_long_array
mov [r8+rdx+550h], rdi
inc rsi
add rdx, 590h
cmp rsi, cs:events_statements_history_long_size
jb short loc_44EB7
jmp short loc_44F31
loc_44F27:
call _Z38cleanup_events_statements_history_longv; cleanup_events_statements_history_long(void)
mov ebx, 1
loc_44F31:
mov eax, ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long init_events_statements_history_long(unsigned long long a1)
{
unsigned int v1; // ebx
long long v2; // rax
long long v3; // rcx
long long v4; // rdx
unsigned long long v5; // rsi
long long v6; // rdi
int v7; // r8d
events_statements_history_long_size = a1;
events_statements_history_long_full = 0;
v1 = 0;
_InterlockedExchange(&events_statements_history_long_index, 0);
if ( a1 )
{
events_statements_history_long_array = pfs_malloc_array(
(long long)&builtin_memory_statements_history_long,
a1,
0x590uLL,
32);
if ( events_statements_history_long_array
&& (!pfs_max_digest_length
|| (h_long_stmts_digest_token_array = pfs_malloc_array(
(long long)&builtin_memory_statements_history_long_tokens,
events_statements_history_long_size,
pfs_max_digest_length,
32)) != 0)
&& (!pfs_max_sqltext
|| (h_long_stmts_text_array = pfs_malloc_array(
(long long)&builtin_memory_statements_history_long_sqltext,
events_statements_history_long_size,
pfs_max_sqltext,
32)) != 0) )
{
if ( events_statements_history_long_size )
{
v2 = h_long_stmts_digest_token_array;
v3 = h_long_stmts_text_array;
v1 = 0;
v4 = 0LL;
v5 = 0LL;
do
{
v6 = events_statements_history_long_array;
v7 = pfs_max_digest_length;
*(_QWORD *)(events_statements_history_long_array + v4 + 1408) = v2 + v5 * pfs_max_digest_length;
*(_DWORD *)(v6 + v4 + 1416) = v7;
*(_BYTE *)(v6 + v4 + 1376) = 0;
*(_DWORD *)(v6 + v4 + 1380) = 0;
*(_DWORD *)(v6 + v4 + 1400) = 0;
*(_OWORD *)(v6 + v4 + 1384) = 0LL;
*(_QWORD *)(events_statements_history_long_array + v4 + 1360) = v3 + v5 * pfs_max_sqltext;
++v5;
v4 += 1424LL;
}
while ( v5 < events_statements_history_long_size );
}
}
else
{
cleanup_events_statements_history_long();
return 1;
}
}
return v1;
}
| init_events_statements_history_long:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV qword ptr [0x004d2c00],RDI
MOV byte ptr [0x004d2d00],0x0
XOR EBX,EBX
XOR EAX,EAX
XCHG dword ptr [0x004d2d40],EAX
TEST RDI,RDI
JZ 0x00144f31
MOV RSI,RDI
LEA RDI,[0x4ce0c0]
MOV EDX,0x590
MOV ECX,0x20
CALL 0x00130f01
MOV qword ptr [0x004d2d80],RAX
TEST RAX,RAX
JZ 0x00144f27
LEA R14,[0x4cf300]
MOV RDX,qword ptr [R14]
TEST RDX,RDX
JZ 0x00144e5b
MOV RSI,qword ptr [0x004d2c00]
LEA RDI,[0x4ce200]
MOV ECX,0x20
CALL 0x00130f01
MOV qword ptr [0x004d2d88],RAX
TEST RAX,RAX
JZ 0x00144f27
LAB_00144e5b:
LEA R15,[0x4cf308]
MOV RDX,qword ptr [R15]
TEST RDX,RDX
JZ 0x00144e92
MOV RSI,qword ptr [0x004d2c00]
LEA RDI,[0x4ce340]
MOV ECX,0x20
CALL 0x00130f01
MOV qword ptr [0x004d2d90],RAX
TEST RAX,RAX
JZ 0x00144f27
LAB_00144e92:
CMP qword ptr [0x004d2c00],0x0
JZ 0x00144f31
MOV RAX,qword ptr [0x004d2d88]
MOV RCX,qword ptr [0x004d2d90]
XOR EBX,EBX
XORPS XMM0,XMM0
XOR EDX,EDX
XOR ESI,ESI
LAB_00144eb7:
MOV RDI,qword ptr [0x004d2d80]
MOV R8,qword ptr [R14]
MOV R9,R8
IMUL R9,RSI
ADD R9,RAX
MOV qword ptr [RDI + RDX*0x1 + 0x580],R9
MOV dword ptr [RDI + RDX*0x1 + 0x588],R8D
MOV byte ptr [RDI + RDX*0x1 + 0x560],0x0
MOV dword ptr [RDI + RDX*0x1 + 0x564],EBX
MOV dword ptr [RDI + RDX*0x1 + 0x578],EBX
MOVUPS xmmword ptr [RDI + RDX*0x1 + 0x568],XMM0
MOV RDI,qword ptr [R15]
IMUL RDI,RSI
ADD RDI,RCX
MOV R8,qword ptr [0x004d2d80]
MOV qword ptr [R8 + RDX*0x1 + 0x550],RDI
INC RSI
ADD RDX,0x590
CMP RSI,qword ptr [0x004d2c00]
JC 0x00144eb7
JMP 0x00144f31
LAB_00144f27:
CALL 0x00144f3e
MOV EBX,0x1
LAB_00144f31:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* init_events_statements_history_long(unsigned long) */
int4 init_events_statements_history_long(ulong param_1)
{
int8 *puVar1;
ulong uVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
int4 uVar7;
ulong uVar8;
events_statements_history_long_full = 0;
LOCK();
events_statements_history_long_index = 0;
UNLOCK();
uVar7 = 0;
events_statements_history_long_size = param_1;
if (param_1 != 0) {
events_statements_history_long_array =
pfs_malloc_array((PFS_builtin_memory_class *)builtin_memory_statements_history_long,param_1
,0x590,0x20);
if (((events_statements_history_long_array == 0) ||
((pfs_max_digest_length != 0 &&
(h_long_stmts_digest_token_array =
pfs_malloc_array((PFS_builtin_memory_class *)
builtin_memory_statements_history_long_tokens,
events_statements_history_long_size,pfs_max_digest_length,0x20),
h_long_stmts_digest_token_array == 0)))) ||
((pfs_max_sqltext != 0 &&
(h_long_stmts_text_array =
pfs_malloc_array((PFS_builtin_memory_class *)
builtin_memory_statements_history_long_sqltext,
events_statements_history_long_size,pfs_max_sqltext,0x20),
h_long_stmts_text_array == 0)))) {
cleanup_events_statements_history_long();
uVar7 = 1;
}
else {
lVar5 = h_long_stmts_text_array;
lVar4 = h_long_stmts_digest_token_array;
uVar7 = 0;
if (events_statements_history_long_size != 0) {
uVar7 = 0;
lVar6 = 0;
uVar8 = 0;
do {
lVar3 = events_statements_history_long_array;
uVar2 = pfs_max_digest_length;
*(ulong *)(events_statements_history_long_array + 0x580 + lVar6) =
pfs_max_digest_length * uVar8 + lVar4;
*(int *)(lVar3 + 0x588 + lVar6) = (int)uVar2;
*(int1 *)(lVar3 + 0x560 + lVar6) = 0;
*(int4 *)(lVar3 + 0x564 + lVar6) = 0;
*(int4 *)(lVar3 + 0x578 + lVar6) = 0;
puVar1 = (int8 *)(lVar3 + 0x568 + lVar6);
*puVar1 = 0;
puVar1[1] = 0;
*(ulong *)(events_statements_history_long_array + 0x550 + lVar6) =
pfs_max_sqltext * uVar8 + lVar5;
uVar8 = uVar8 + 1;
lVar6 = lVar6 + 0x590;
} while (uVar8 < events_statements_history_long_size);
}
}
}
return uVar7;
}
| |
22,959 | my_strnncollsp_tis620 | eloqsql/strings/ctype-tis620.c | static
int my_strnncollsp_tis620(CHARSET_INFO * cs __attribute__((unused)),
const uchar *a0, size_t a_length,
const uchar *b0, size_t b_length)
{
uchar buf[80], *end, *a, *b, *alloced= NULL;
size_t length;
int res= 0;
a= buf;
if ((a_length + b_length +2) > (int) sizeof(buf))
alloced= a= (uchar*) my_malloc(PSI_INSTRUMENT_ME, a_length+b_length+2, MYF(MY_FAE));
b= a + a_length+1;
if (a_length)
memcpy((char*) a, (char*) a0, a_length);
a[a_length]= 0; /* if length(a0)> len1, need to put 'end of string' */
if (b_length)
memcpy((char *)b, (char *)b0, b_length);
b[b_length]= 0; /* put end of string */
a_length= thai2sortable(a, a_length);
b_length= thai2sortable(b, b_length);
end= a + (length= MY_MIN(a_length, b_length));
while (a < end)
{
if (*a++ != *b++)
{
res= ((int) a[-1] - (int) b[-1]);
goto ret;
}
}
res= a_length == b_length ? 0 :
a_length < b_length ?
-my_strnncollsp_padspace_bin(b, b_length - length) :
my_strnncollsp_padspace_bin(a, a_length - length);
ret:
if (alloced)
my_free(alloced);
return res;
} | O3 | c | my_strnncollsp_tis620:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, -0x90(%rbp)
movq %rdx, %r15
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq (%rdx,%r8), %rsi
addq $0x2, %rsi
cmpq $0x51, %rsi
jb 0x7020c
movl $0x8, %edx
xorl %edi, %edi
callq 0x5a1cd
movq %rax, %r12
movq %rax, -0x88(%rbp)
jmp 0x7021b
movq $0x0, -0x88(%rbp)
leaq -0x80(%rbp), %r12
leaq (%r12,%r15), %r13
testq %r15, %r15
je 0x70232
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x282c0
leaq (%r12,%r15), %rbx
incq %rbx
movb $0x0, (%r13)
testq %r14, %r14
je 0x70255
movq %rbx, %rdi
movq -0x90(%rbp), %rsi
movq %r14, %rdx
callq 0x282c0
movb $0x0, (%rbx,%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x703b3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x703b3
cmpq %r14, %r15
movq %r14, %rax
cmovbq %r15, %rax
leaq (%r12,%rax), %rcx
cmpq %rcx, %r12
jae 0x7029b
movzbl (%r12), %r13d
movzbl 0x1(%r12,%r15), %edx
incq %r12
cmpb %dl, %r13b
je 0x7027e
subl %edx, %r13d
jmp 0x702d0
xorl %r13d, %r13d
cmpq %r14, %r15
je 0x702d0
jae 0x702bf
leaq (%r15,%r12), %rdi
incq %rdi
subq %rax, %r14
movq %r14, %rsi
callq 0x648c9
movl %eax, %r13d
negl %r13d
jmp 0x702d0
subq %rax, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x648c9
movl %eax, %r13d
movq -0x88(%rbp), %rdi
testq %rdi, %rdi
je 0x702e1
callq 0x5a3fa
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x70302
movl %r13d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x283f0
| my_strnncollsp_tis620:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, r8
mov [rbp+var_90], rcx
mov r15, rdx
mov rbx, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rsi, [rdx+r8]
add rsi, 2
cmp rsi, 51h ; 'Q'
jb short loc_7020C
mov edx, 8
xor edi, edi
call my_malloc
mov r12, rax
mov [rbp+var_88], rax
jmp short loc_7021B
loc_7020C:
mov [rbp+var_88], 0
lea r12, [rbp+var_80]
loc_7021B:
lea r13, [r12+r15]
test r15, r15
jz short loc_70232
mov rdi, r12
mov rsi, rbx
mov rdx, r15
call _memcpy
loc_70232:
lea rbx, [r12+r15]
inc rbx
mov byte ptr [r13+0], 0
test r14, r14
jz short loc_70255
mov rdi, rbx
mov rsi, [rbp+var_90]
mov rdx, r14
call _memcpy
loc_70255:
mov byte ptr [rbx+r14], 0
mov rdi, r12
mov rsi, r15
call thai2sortable
mov rdi, rbx
mov rsi, r14
call thai2sortable
cmp r15, r14
mov rax, r14
cmovb rax, r15
lea rcx, [r12+rax]
loc_7027E:
cmp r12, rcx
jnb short loc_7029B
movzx r13d, byte ptr [r12]
movzx edx, byte ptr [r12+r15+1]
inc r12
cmp r13b, dl
jz short loc_7027E
sub r13d, edx
jmp short loc_702D0
loc_7029B:
xor r13d, r13d
cmp r15, r14
jz short loc_702D0
jnb short loc_702BF
lea rdi, [r15+r12]
inc rdi
sub r14, rax
mov rsi, r14
call my_strnncollsp_padspace_bin
mov r13d, eax
neg r13d
jmp short loc_702D0
loc_702BF:
sub r15, rax
mov rdi, r12
mov rsi, r15
call my_strnncollsp_padspace_bin
mov r13d, eax
loc_702D0:
mov rdi, [rbp+var_88]
test rdi, rdi
jz short loc_702E1
call my_free
loc_702E1:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_70302
mov eax, r13d
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_70302:
call ___stack_chk_fail
| long long my_strnncollsp_tis620(long long a1, long long a2, unsigned long long a3, long long a4, unsigned long long a5)
{
unsigned long long v8; // rsi
unsigned __int8 *v9; // r12
unsigned long long v10; // rax
unsigned __int8 *v11; // rcx
int v12; // r13d
int v13; // edx
unsigned int v14; // r13d
long long v17; // [rsp+8h] [rbp-88h]
char v18; // [rsp+10h] [rbp-80h] BYREF
unsigned long long v19; // [rsp+60h] [rbp-30h]
v19 = __readfsqword(0x28u);
v8 = a3 + a5 + 2;
if ( v8 < 0x51 )
{
v17 = 0LL;
v9 = (unsigned __int8 *)&v18;
}
else
{
v9 = (unsigned __int8 *)my_malloc(0, v8, 8);
v17 = (long long)v9;
}
if ( a3 )
memcpy(v9, a2, a3);
v9[a3] = 0;
if ( a5 )
memcpy(&v9[a3 + 1], a4, a5);
v9[a3 + 1 + a5] = 0;
thai2sortable(v9, a3);
thai2sortable(&v9[a3 + 1], a5);
v10 = a5;
if ( a3 < a5 )
v10 = a3;
v11 = &v9[v10];
while ( v9 < v11 )
{
v12 = *v9;
v13 = v9[a3 + 1];
++v9;
if ( (_BYTE)v12 != (_BYTE)v13 )
{
v14 = v12 - v13;
goto LABEL_18;
}
}
v14 = 0;
if ( a3 != a5 )
{
if ( a3 >= a5 )
v14 = my_strnncollsp_padspace_bin((long long)v9, a3 - v10);
else
v14 = -(int)my_strnncollsp_padspace_bin((long long)&v9[a3 + 1], a5 - v10);
}
LABEL_18:
if ( v17 )
my_free(v17);
return v14;
}
| my_strnncollsp_tis620:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,R8
MOV qword ptr [RBP + -0x90],RCX
MOV R15,RDX
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RSI,[RDX + R8*0x1]
ADD RSI,0x2
CMP RSI,0x51
JC 0x0017020c
MOV EDX,0x8
XOR EDI,EDI
CALL 0x0015a1cd
MOV R12,RAX
MOV qword ptr [RBP + -0x88],RAX
JMP 0x0017021b
LAB_0017020c:
MOV qword ptr [RBP + -0x88],0x0
LEA R12,[RBP + -0x80]
LAB_0017021b:
LEA R13,[R12 + R15*0x1]
TEST R15,R15
JZ 0x00170232
MOV RDI,R12
MOV RSI,RBX
MOV RDX,R15
CALL 0x001282c0
LAB_00170232:
LEA RBX,[R12 + R15*0x1]
INC RBX
MOV byte ptr [R13],0x0
TEST R14,R14
JZ 0x00170255
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,R14
CALL 0x001282c0
LAB_00170255:
MOV byte ptr [RBX + R14*0x1],0x0
MOV RDI,R12
MOV RSI,R15
CALL 0x001703b3
MOV RDI,RBX
MOV RSI,R14
CALL 0x001703b3
CMP R15,R14
MOV RAX,R14
CMOVC RAX,R15
LEA RCX,[R12 + RAX*0x1]
LAB_0017027e:
CMP R12,RCX
JNC 0x0017029b
MOVZX R13D,byte ptr [R12]
MOVZX EDX,byte ptr [R12 + R15*0x1 + 0x1]
INC R12
CMP R13B,DL
JZ 0x0017027e
SUB R13D,EDX
JMP 0x001702d0
LAB_0017029b:
XOR R13D,R13D
CMP R15,R14
JZ 0x001702d0
JNC 0x001702bf
LEA RDI,[R15 + R12*0x1]
INC RDI
SUB R14,RAX
MOV RSI,R14
CALL 0x001648c9
MOV R13D,EAX
NEG R13D
JMP 0x001702d0
LAB_001702bf:
SUB R15,RAX
MOV RDI,R12
MOV RSI,R15
CALL 0x001648c9
MOV R13D,EAX
LAB_001702d0:
MOV RDI,qword ptr [RBP + -0x88]
TEST RDI,RDI
JZ 0x001702e1
CALL 0x0015a3fa
LAB_001702e1:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00170302
MOV EAX,R13D
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00170302:
CALL 0x001283f0
|
int my_strnncollsp_tis620
(int8 param_1,void *param_2,ulong param_3,void *param_4,ulong param_5)
{
byte *pbVar1;
byte bVar2;
byte *__dest;
byte *pbVar3;
ulong uVar4;
int iVar5;
long in_FS_OFFSET;
byte *local_90;
byte local_88 [80];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
uVar4 = param_3 + param_5 + 2;
if (uVar4 < 0x51) {
local_90 = (byte *)0x0;
__dest = local_88;
}
else {
__dest = (byte *)my_malloc(0,uVar4,8);
local_90 = __dest;
}
if (param_3 != 0) {
memcpy(__dest,param_2,param_3);
}
pbVar3 = __dest + param_3 + 1;
__dest[param_3] = 0;
if (param_5 != 0) {
memcpy(pbVar3,param_4,param_5);
}
pbVar3[param_5] = 0;
thai2sortable(__dest,param_3);
thai2sortable(pbVar3,param_5);
uVar4 = param_5;
if (param_3 < param_5) {
uVar4 = param_3;
}
pbVar3 = __dest + uVar4;
do {
if (pbVar3 <= __dest) {
iVar5 = 0;
if (param_3 != param_5) {
if (param_3 < param_5) {
iVar5 = my_strnncollsp_padspace_bin(__dest + param_3 + 1,param_5 - uVar4);
iVar5 = -iVar5;
}
else {
iVar5 = my_strnncollsp_padspace_bin(__dest,param_3 - uVar4);
}
}
goto LAB_001702d0;
}
bVar2 = *__dest;
pbVar1 = __dest + param_3 + 1;
__dest = __dest + 1;
} while (bVar2 == *pbVar1);
iVar5 = (uint)bVar2 - (uint)*pbVar1;
LAB_001702d0:
if (local_90 != (byte *)0x0) {
my_free();
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return iVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,960 | host_selfdestruct | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_selfdestruct(void* context, const evmc_address* addr, const evmc_address* beneficiary) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("selfdestruct account", addr);
debug_print_address("selfdestruct beneficiary", beneficiary);
bool created;
changed_account_t* acc = create_changed_account(ctx, addr->bytes, &created);
while (acc->storage) {
changed_storage_t* storage = acc->storage;
acc->storage = storage->next;
safe_free(storage);
}
acc->deleted = true;
EVM_LOG("selfdestruct: account marked as deleted");
} | O2 | c | host_selfdestruct:
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rdx
callq 0x27e33
movq %rax, %rbx
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x27b19
movq 0x40(%rdi), %rax
movq %rax, 0x50(%rbx)
callq 0x4a0e0
jmp 0x27b01
movb $0x1, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| host_selfdestruct:
push rbx
sub rsp, 10h
lea rdx, [rsp+18h+var_9]
call create_changed_account
mov rbx, rax
loc_27B01:
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_27B19
mov rax, [rdi+40h]
mov [rbx+50h], rax
call safe_free
jmp short loc_27B01
loc_27B19:
mov byte ptr [rbx+58h], 1
add rsp, 10h
pop rbx
retn
| long long host_selfdestruct(long long a1, long long a2)
{
long long result; // rax
long long v3; // rbx
long long v4; // rdi
_BYTE v5[9]; // [rsp+Fh] [rbp-9h] BYREF
result = create_changed_account(a1, a2, v5);
v3 = result;
while ( 1 )
{
v4 = *(_QWORD *)(v3 + 80);
if ( !v4 )
break;
*(_QWORD *)(v3 + 80) = *(_QWORD *)(v4 + 64);
result = safe_free(v4);
}
*(_BYTE *)(v3 + 88) = 1;
return result;
}
| host_selfdestruct:
PUSH RBX
SUB RSP,0x10
LEA RDX,[RSP + 0xf]
CALL 0x00127e33
MOV RBX,RAX
LAB_00127b01:
MOV RDI,qword ptr [RBX + 0x50]
TEST RDI,RDI
JZ 0x00127b19
MOV RAX,qword ptr [RDI + 0x40]
MOV qword ptr [RBX + 0x50],RAX
CALL 0x0014a0e0
JMP 0x00127b01
LAB_00127b19:
MOV byte ptr [RBX + 0x58],0x1
ADD RSP,0x10
POP RBX
RET
|
void host_selfdestruct(int8 param_1,int8 param_2)
{
long lVar1;
int1 local_9;
lVar1 = create_changed_account(param_1,param_2,&local_9);
while (*(long *)(lVar1 + 0x50) != 0) {
*(int8 *)(lVar1 + 0x50) = *(int8 *)(*(long *)(lVar1 + 0x50) + 0x40);
safe_free();
}
*(int1 *)(lVar1 + 0x58) = 1;
return;
}
| |
22,961 | host_selfdestruct | corpus-core[P]colibri-stateless/src/chains/eth/verifier/call_evmone.c | static void host_selfdestruct(void* context, const evmc_address* addr, const evmc_address* beneficiary) {
evmone_context_t* ctx = (evmone_context_t*) context;
debug_print_address("selfdestruct account", addr);
debug_print_address("selfdestruct beneficiary", beneficiary);
bool created;
changed_account_t* acc = create_changed_account(ctx, addr->bytes, &created);
while (acc->storage) {
changed_storage_t* storage = acc->storage;
acc->storage = storage->next;
safe_free(storage);
}
acc->deleted = true;
EVM_LOG("selfdestruct: account marked as deleted");
} | O3 | c | host_selfdestruct:
pushq %rbx
subq $0x10, %rsp
leaq 0xf(%rsp), %rdx
callq 0x27f55
movq %rax, %rbx
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x27bbf
movq 0x40(%rdi), %rax
movq %rax, 0x50(%rbx)
callq 0x50f4c
movq 0x50(%rbx), %rdi
jmp 0x27ba7
movb $0x1, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
retq
| host_selfdestruct:
push rbx
sub rsp, 10h
lea rdx, [rsp+18h+var_9]
call create_changed_account
mov rbx, rax
mov rdi, [rax+50h]
loc_27BA7:
test rdi, rdi
jz short loc_27BBF
mov rax, [rdi+40h]
mov [rbx+50h], rax
call safe_free
mov rdi, [rbx+50h]
jmp short loc_27BA7
loc_27BBF:
mov byte ptr [rbx+58h], 1
add rsp, 10h
pop rbx
retn
| long long host_selfdestruct(long long a1, long long a2)
{
long long result; // rax
long long v3; // rbx
long long i; // rdi
_BYTE v5[9]; // [rsp+Fh] [rbp-9h] BYREF
result = create_changed_account(a1, a2, v5);
v3 = result;
for ( i = *(_QWORD *)(result + 80); i; i = *(_QWORD *)(v3 + 80) )
{
*(_QWORD *)(v3 + 80) = *(_QWORD *)(i + 64);
result = safe_free(i);
}
*(_BYTE *)(v3 + 88) = 1;
return result;
}
| host_selfdestruct:
PUSH RBX
SUB RSP,0x10
LEA RDX,[RSP + 0xf]
CALL 0x00127f55
MOV RBX,RAX
MOV RDI,qword ptr [RAX + 0x50]
LAB_00127ba7:
TEST RDI,RDI
JZ 0x00127bbf
MOV RAX,qword ptr [RDI + 0x40]
MOV qword ptr [RBX + 0x50],RAX
CALL 0x00150f4c
MOV RDI,qword ptr [RBX + 0x50]
JMP 0x00127ba7
LAB_00127bbf:
MOV byte ptr [RBX + 0x58],0x1
ADD RSP,0x10
POP RBX
RET
|
void host_selfdestruct(int8 param_1,int8 param_2)
{
long lVar1;
long lVar2;
int1 local_9;
lVar1 = create_changed_account(param_1,param_2,&local_9);
lVar2 = *(long *)(lVar1 + 0x50);
while (lVar2 != 0) {
*(int8 *)(lVar1 + 0x50) = *(int8 *)(lVar2 + 0x40);
safe_free();
lVar2 = *(long *)(lVar1 + 0x50);
}
*(int1 *)(lVar1 + 0x58) = 1;
return;
}
| |
22,962 | ma_checkpoint_init | eloqsql/storage/maria/ma_checkpoint.c | int ma_checkpoint_init(ulong interval)
{
int res= 0;
DBUG_ENTER("ma_checkpoint_init");
if (ma_service_thread_control_init(&checkpoint_control))
res= 1;
else if (interval > 0)
{
size_t intv= interval;
compile_time_assert(sizeof(void *) >= sizeof(ulong));
if ((res= mysql_thread_create(key_thread_checkpoint,
&checkpoint_control.thread, NULL,
ma_checkpoint_background,
(void*) intv)))
checkpoint_control.killed= TRUE;
}
else
checkpoint_control.killed= TRUE;
DBUG_RETURN(res);
} | O3 | c | ma_checkpoint_init:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x314378(%rip), %rdi # 0x3851d8
callq 0x716f4
movl $0x1, %r14d
testl %eax, %eax
jne 0x70eb5
testq %rbx, %rbx
je 0x70ea9
leaq 0x38e26d(%rip), %rax # 0x3ff0e8
movl (%rax), %edi
leaq 0x3161cc(%rip), %rax # 0x387050
movq (%rax), %rax
leaq 0x31434a(%rip), %rsi # 0x3851d8
leaq 0x28(%rip), %rcx # 0x70ebd
xorl %r14d, %r14d
xorl %edx, %edx
movq %rbx, %r8
callq *0xc0(%rax)
testl %eax, %eax
jne 0x70eab
jmp 0x70eb5
xorl %eax, %eax
movb $0x1, 0x31432e(%rip) # 0x3851e0
movl %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
| ma_checkpoint_init:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
lea rdi, checkpoint_control
call ma_service_thread_control_init
mov r14d, 1
test eax, eax
jnz short loc_70EB5
test rbx, rbx
jz short loc_70EA9
lea rax, key_thread_checkpoint
mov edi, [rax]
lea rax, PSI_server
mov rax, [rax]
lea rsi, checkpoint_control
lea rcx, ma_checkpoint_background
xor r14d, r14d
xor edx, edx
mov r8, rbx
call qword ptr [rax+0C0h]
test eax, eax
jnz short loc_70EAB
jmp short loc_70EB5
loc_70EA9:
xor eax, eax
loc_70EAB:
mov cs:byte_3851E0, 1
mov r14d, eax
loc_70EB5:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
| long long ma_checkpoint_init(long long a1)
{
unsigned int v1; // r14d
unsigned int v2; // eax
v1 = 1;
if ( !(unsigned int)ma_service_thread_control_init(&checkpoint_control) )
{
if ( a1 )
{
v1 = 0;
v2 = ((long long ( *)(_QWORD, void *, _QWORD, long long ( *)(), long long))PSI_server[24])(
key_thread_checkpoint,
&checkpoint_control,
0LL,
ma_checkpoint_background,
a1);
if ( !v2 )
return v1;
}
else
{
v2 = 0;
}
byte_3851E0 = 1;
return v2;
}
return v1;
}
| ma_checkpoint_init:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA RDI,[0x4851d8]
CALL 0x001716f4
MOV R14D,0x1
TEST EAX,EAX
JNZ 0x00170eb5
TEST RBX,RBX
JZ 0x00170ea9
LEA RAX,[0x4ff0e8]
MOV EDI,dword ptr [RAX]
LEA RAX,[0x487050]
MOV RAX,qword ptr [RAX]
LEA RSI,[0x4851d8]
LEA RCX,[0x170ebd]
XOR R14D,R14D
XOR EDX,EDX
MOV R8,RBX
CALL qword ptr [RAX + 0xc0]
TEST EAX,EAX
JNZ 0x00170eab
JMP 0x00170eb5
LAB_00170ea9:
XOR EAX,EAX
LAB_00170eab:
MOV byte ptr [0x004851e0],0x1
MOV R14D,EAX
LAB_00170eb5:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int ma_checkpoint_init(long param_1)
{
int iVar1;
int iVar2;
iVar1 = ma_service_thread_control_init(checkpoint_control);
iVar2 = 1;
if (iVar1 == 0) {
if (param_1 == 0) {
iVar2 = 0;
}
else {
iVar2 = (**(code **)(PSI_server + 0xc0))
(key_thread_checkpoint,checkpoint_control,0,ma_checkpoint_background,param_1
);
if (iVar2 == 0) {
return 0;
}
}
checkpoint_control[8] = 1;
}
return iVar2;
}
| |
22,963 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | SurfaceFactory::~SurfaceFactory() {
#ifdef _BFR_DEBUG_TOP_TYPE_STATS
// DEBUG - report and reset inventory:
printf("SurfaceFactory destructor:\n");
printf(" __numLinearPatches = %6d\n", __numLinearPatches);
printf(" __numExpRegularPatches = %6d\n", __numExpRegularPatches);
printf(" __numRegularPatches = %6d\n", __numRegularPatches);
printf(" __numIrregularPatches = %6d\n", __numIrregularPatches);
if (!_factoryOptions.DisableTopologyCache()) {
printf("\n");
printf(" __numIrregularUncached = %6d\n", __numIrregularUncached);
printf(" __numIrregularInCache = %6d\n", __numIrregularInCache);
}
__numLinearPatches = 0;
__numExpRegularPatches = 0;
__numRegularPatches = 0;
__numIrregularPatches = 0;
__numIrregularUncached = 0;
__numIrregularInCache = 0;
#endif
} | O0 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory():
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
ud2
nopw (%rax,%rax)
| _ZN10OpenSubdiv6v3_6_03Bfr14SurfaceFactoryD0Ev:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
ud2
| void __noreturn OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this)
{
BUG();
}
| |||
22,964 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | SurfaceFactory::~SurfaceFactory() {
#ifdef _BFR_DEBUG_TOP_TYPE_STATS
// DEBUG - report and reset inventory:
printf("SurfaceFactory destructor:\n");
printf(" __numLinearPatches = %6d\n", __numLinearPatches);
printf(" __numExpRegularPatches = %6d\n", __numExpRegularPatches);
printf(" __numRegularPatches = %6d\n", __numRegularPatches);
printf(" __numIrregularPatches = %6d\n", __numIrregularPatches);
if (!_factoryOptions.DisableTopologyCache()) {
printf("\n");
printf(" __numIrregularUncached = %6d\n", __numIrregularUncached);
printf(" __numIrregularInCache = %6d\n", __numIrregularInCache);
}
__numLinearPatches = 0;
__numExpRegularPatches = 0;
__numRegularPatches = 0;
__numIrregularPatches = 0;
__numIrregularUncached = 0;
__numIrregularInCache = 0;
#endif
} | O1 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory():
retq
nop
| _ZN10OpenSubdiv6v3_6_03Bfr14SurfaceFactoryD2Ev:
retn; Alternative name is 'OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory()'
| void OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory(OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this)
{
;
}
| ~SurfaceFactory:
RET
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory() */
void __thiscall OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory(SurfaceFactory *this)
{
return;
}
| |
22,965 | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/bfr/surfaceFactory.cpp | SurfaceFactory::~SurfaceFactory() {
#ifdef _BFR_DEBUG_TOP_TYPE_STATS
// DEBUG - report and reset inventory:
printf("SurfaceFactory destructor:\n");
printf(" __numLinearPatches = %6d\n", __numLinearPatches);
printf(" __numExpRegularPatches = %6d\n", __numExpRegularPatches);
printf(" __numRegularPatches = %6d\n", __numRegularPatches);
printf(" __numIrregularPatches = %6d\n", __numIrregularPatches);
if (!_factoryOptions.DisableTopologyCache()) {
printf("\n");
printf(" __numIrregularUncached = %6d\n", __numIrregularUncached);
printf(" __numIrregularInCache = %6d\n", __numIrregularInCache);
}
__numLinearPatches = 0;
__numExpRegularPatches = 0;
__numRegularPatches = 0;
__numIrregularPatches = 0;
__numIrregularUncached = 0;
__numIrregularInCache = 0;
#endif
} | O2 | cpp | OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory():
ud2
| _ZN10OpenSubdiv6v3_6_03Bfr14SurfaceFactoryD0Ev:
ud2
| void __noreturn OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory(
OpenSubdiv::v3_6_0::Bfr::SurfaceFactory *this)
{
BUG();
}
| ~SurfaceFactory:
UD2
|
/* OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory() */
void __thiscall OpenSubdiv::v3_6_0::Bfr::SurfaceFactory::~SurfaceFactory(SurfaceFactory *this)
{
code *pcVar1;
/* WARNING: Does not return */
pcVar1 = (code *)invalidInstructionException();
(*pcVar1)();
}
| |
22,966 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, bool) | llama.cpp/common/json.hpp | void update(const_iterator first, const_iterator last, bool merge_objects = false)
{
// implicitly convert null value to an empty object
if (is_null())
{
m_data.m_type = value_t::object;
m_data.m_value.object = create<object_t>();
assert_invariant();
}
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", type_name()), this));
}
// check if range iterators belong to the same JSON object
if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
{
JSON_THROW(invalid_iterator::create(210, "iterators do not fit", this));
}
// passed iterators must belong to objects
if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
{
JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
}
for (auto it = first; it != last; ++it)
{
if (merge_objects && it.value().is_object())
{
auto it2 = m_data.m_value.object->find(it.key());
if (it2 != m_data.m_value.object->end())
{
it2->second.update(it.value(), true);
continue;
}
}
m_data.m_value.object->operator[](it.key()) = it.value();
#if JSON_DIAGNOSTICS
m_data.m_value.object->operator[](it.key()).m_parent = this;
#endif
}
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
jne 0x9052b
movb $0x1, (%rbx)
movl $0x30, %edi
callq 0x21220
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x851c0
movb (%rbx), %al
cmpb $0x1, %al
jne 0x9063f
movq (%r15), %rax
cmpq (%r14), %rax
jne 0x9069e
cmpb $0x1, (%rax)
jne 0x906fa
movq %rsp, %rdi
movq %rax, (%rdi)
movups 0x8(%r15), %xmm0
movups %xmm0, 0x8(%rdi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rdi)
movq %r14, %rsi
callq 0x9097e
testb %al, %al
jne 0x90630
movq %rsp, %r15
leaq 0x28(%rsp), %r12
testb %bpl, %bpl
je 0x905ce
movq %r15, %rdi
callq 0x90c5e
cmpb $0x1, (%rax)
jne 0x905ce
movq 0x8(%rbx), %r13
movq %r15, %rdi
callq 0x90844
movq %r13, %rdi
movq %rax, %rsi
callq 0x90e22
movq %rax, %r13
movq 0x8(%rbx), %rax
addq $0x8, %rax
cmpq %rax, %r13
je 0x905ce
addq $0x40, %r13
movq %r15, %rdi
callq 0x90c5e
movq %r13, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x84f6a
jmp 0x90615
movq %r15, %rdi
callq 0x90c5e
movq %r12, %rdi
movq %rax, %rsi
callq 0x89ace
movq 0x8(%rbx), %r13
movq %r15, %rdi
callq 0x90844
movq %r13, %rdi
movq %rax, %rsi
callq 0x8b0c6
movq %rax, %rdi
movq %r12, %rsi
callq 0x87a52
movq %r12, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r12, %rdi
callq 0x89fae
movq %r15, %rdi
callq 0x90924
movq %r15, %rdi
movq %r14, %rsi
callq 0x9097e
testb %al, %al
je 0x90577
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x21660
movq %rax, %r14
movq %rbx, %rdi
callq 0x8af58
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x955ad(%rip), %rsi # 0x125c10
movq %rsp, %rdi
callq 0x907bc
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x138, %esi # imm = 0x138
movq %rbx, %rcx
callq 0x8ad80
xorl %ebp, %ebp
leaq 0xdb2fe(%rip), %rsi # 0x16b988
leaq -0x5ee87(%rip), %rdx # 0x3180a
movq %r14, %rdi
callq 0x21a80
jmp 0x90754
movl $0x20, %edi
callq 0x21660
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9556f(%rip), %rsi # 0x125c2a
leaq 0x9557c(%rip), %rdx # 0x125c3e
movq %rsp, %rdi
callq 0x3a58a
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0xd2, %esi
movq %rbx, %rcx
callq 0x8ab42
xorl %ebp, %ebp
leaq 0xdb347(%rip), %rsi # 0x16ba30
leaq -0x5eee6(%rip), %rdx # 0x3180a
movq %r14, %rdi
callq 0x21a80
jmp 0x90754
movl $0x20, %edi
callq 0x21660
movq %rax, %r14
movq (%r15), %rdi
callq 0x8af58
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x954f2(%rip), %rsi # 0x125c10
movq %rsp, %rdi
callq 0x907bc
movq (%r15), %rcx
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x138, %esi # imm = 0x138
callq 0x90220
xorl %ebp, %ebp
leaq 0xdb243(%rip), %rsi # 0x16b988
leaq -0x5ef42(%rip), %rdx # 0x3180a
movq %r14, %rdi
callq 0x21a80
movq %rax, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x851c0
movq %r14, %rdi
callq 0x89fae
jmp 0x907b4
jmp 0x90784
jmp 0x907a9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x90795
jmp 0x907a2
jmp 0x907a9
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x907a2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21180
testb %bpl, %bpl
jne 0x907ac
jmp 0x907b4
movq %rax, %rbx
movq %r14, %rdi
callq 0x21f50
movq %rbx, %rdi
callq 0x21b20
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6updateENS0_6detail9iter_implIKSD_EESH_b:
push rbp; void *
push r15; int
push r14; __int64
push r13; int
push r12; void *
push rbx; int
sub rsp, 38h
mov ebp, ecx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov al, [rdi]
test al, al
jnz short loc_9052B
mov byte ptr [rbx], 1
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
lea rcx, [rax+8]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
xor edx, edx
mov [rax+10h], rdx
mov [rax+18h], rcx
mov [rax+20h], rcx
mov [rax+28h], rdx
mov [rbx+8], rax
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov al, [rbx]
loc_9052B:
cmp al, 1
jnz loc_9063F
mov rax, [r15]
cmp rax, [r14]
jnz loc_9069E
cmp byte ptr [rax], 1
jnz loc_906FA
mov rdi, rsp
mov [rdi], rax
movups xmm0, xmmword ptr [r15+8]
movups xmmword ptr [rdi+8], xmm0
mov rax, [r15+18h]
mov [rdi+18h], rax
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jnz loc_90630
mov r15, rsp
lea r12, [rsp+68h+var_40]
loc_90577:
test bpl, bpl
jz short loc_905CE
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
cmp byte ptr [rax], 1
jnz short loc_905CE
mov r13, [rbx+8]
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNSt8_Rb_treeINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_N8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS5_blmdSaNS9_14adl_serializerESC_IhSaIhEEvEEESt10_Select1stISH_ESt4lessIvESaISH_EE4findERS7_; std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::find(std::string const&)
mov r13, rax
mov rax, [rbx+8]
add rax, 8
cmp r13, rax
jz short loc_905CE
add r13, 40h ; '@'
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, r13
mov rsi, rax
mov edx, 1
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6updateERKSD_b; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::update(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)
jmp short loc_90615
loc_905CE:
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEdeEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator*(void)
mov rdi, r12
mov rsi, rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
mov r13, [rbx+8]
mov rdi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE3keyEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::key(void)
mov rdi, r13
mov rsi, rax
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS5_SD_EEEixERSH_; std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator[](std::string const&)
mov rdi, rax
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r12
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_90615:
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>::operator++(void)
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
test al, al
jz loc_90577
loc_90630:
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9063F:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseUpdat; "cannot use update() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 138h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_90754
loc_9069E:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r15, [rsp+68h+var_58]
mov [r15-10h], r15
lea rsi, aIteratorsDoNot; "iterators do not fit"
lea rdx, aIteratorsDoNot+14h; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 0D2h; int
mov rcx, rbx
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_90754
loc_906FA:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
mov rdi, [r15]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_48]
mov [rdx], rax
lea rsi, aCannotUseUpdat; "cannot use update() with "
mov rdi, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA26_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(char const(&)[26],char const* &&)
mov rcx, [r15]
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 138h; int
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__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, r14; void *
call ___cxa_throw
loc_90754:
mov rbx, rax
lea r14, [rsp+68h+var_40]
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_907B4
jmp short loc_90784
jmp short loc_907A9
mov rbx, rax
mov rdi, [rsp+68h+var_68]
cmp rdi, r15
jnz short loc_90795
jmp short loc_907A2
jmp short loc_907A9
loc_90784:
mov rbx, rax
lea rax, [rsp+68h+var_58]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_907A2
loc_90795:
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_907A2:
test bpl, bpl
jnz short loc_907AC
jmp short loc_907B4
loc_907A9:
mov rbx, rax
loc_907AC:
mov rdi, r14; void *
call ___cxa_free_exception
loc_907B4:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::update(
long long a1,
long long a2,
_QWORD *a3,
char a4)
{
char v6; // al
long long v7; // rax
long long result; // rax
long long v9; // r13
long long v10; // rax
long long v11; // r13
long long v12; // rsi
unsigned __int8 *v13; // rax
long long v14; // r13
long long v15; // rax
long long v16; // rdx
long long v17; // rcx
long long v18; // r8
int v19; // r9d
long long v20; // rax
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
nlohmann::json_abi_v3_11_3::detail::exception *v26; // r14
nlohmann::json_abi_v3_11_3::detail::exception *v27; // r14
unsigned __int8 *v28; // [rsp+0h] [rbp-68h] BYREF
__int128 v29; // [rsp+8h] [rbp-60h] BYREF
long long v30; // [rsp+18h] [rbp-50h]
const char *v31; // [rsp+20h] [rbp-48h]
unsigned __int8 v32[64]; // [rsp+28h] [rbp-40h] BYREF
v6 = *(_BYTE *)a1;
if ( !*(_BYTE *)a1 )
{
*(_BYTE *)a1 = 1;
v7 = operator new(0x30uLL);
*(_OWORD *)v7 = 0LL;
*(_QWORD *)(v7 + 16) = 0LL;
*(_QWORD *)(v7 + 24) = v7 + 8;
*(_QWORD *)(v7 + 32) = v7 + 8;
*(_QWORD *)(v7 + 40) = 0LL;
*(_QWORD *)(a1 + 8) = v7;
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a1);
v6 = *(_BYTE *)a1;
}
if ( v6 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v31 = nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
&v28,
"cannot use update() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
312,
&v28);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( *(_QWORD *)a2 != *a3 )
{
v26 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v28 = (unsigned __int8 *)&v29 + 8;
std::string::_M_construct<char const*>((long long)&v28, "iterators do not fit", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v26,
210,
&v28);
__cxa_throw(
v26,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( **(_BYTE **)a2 != 1 )
{
v27 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v31 = nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(*(unsigned __int8 **)a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[26],char const*>(
&v28,
"cannot use update() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_(
v27,
312,
&v28);
__cxa_throw(
v27,
(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);
}
v28 = *(unsigned __int8 **)a2;
v29 = *(_OWORD *)(a2 + 8);
v30 = *(_QWORD *)(a2 + 24);
for ( result = ((long long ( *)(unsigned __int8 **, _QWORD *))ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_)(
&v28,
a3);
!(_BYTE)result;
result = ((long long ( *)(unsigned __int8 **, _QWORD *, long long, long long, long long, long long))ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_)(
&v28,
a3,
v21,
v22,
v23,
v24) )
{
if ( a4
&& *(_BYTE *)nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28) == 1
&& (v9 = *(_QWORD *)(a1 + 8),
v10 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(&v28),
v11 = std::_Rb_tree<std::string,std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::_Select1st<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::find(
v9,
v10),
v11 != *(_QWORD *)(a1 + 8) + 8LL) )
{
v12 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::update(
v11 + 64,
v12,
1u);
}
else
{
v13 = (unsigned __int8 *)nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator*(&v28);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
v32,
v13);
v14 = *(_QWORD *)(a1 + 8);
v15 = nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::key(&v28);
v20 = std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator[](
v14,
v15,
v16,
v17,
v18,
v19);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator=(
v20,
(long long)v32);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)v32);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v32);
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(&v28);
}
return result;
}
| update:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV EBP,ECX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV AL,byte ptr [RDI]
TEST AL,AL
JNZ 0x0019052b
MOV byte ptr [RBX],0x1
MOV EDI,0x30
CALL 0x00121220
LEA RCX,[RAX + 0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
XOR EDX,EDX
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],RDX
MOV qword ptr [RBX + 0x8],RAX
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001851c0
MOV AL,byte ptr [RBX]
LAB_0019052b:
CMP AL,0x1
JNZ 0x0019063f
MOV RAX,qword ptr [R15]
CMP RAX,qword ptr [R14]
JNZ 0x0019069e
CMP byte ptr [RAX],0x1
JNZ 0x001906fa
MOV RDI,RSP
MOV qword ptr [RDI],RAX
MOVUPS XMM0,xmmword ptr [R15 + 0x8]
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,qword ptr [R15 + 0x18]
MOV qword ptr [RDI + 0x18],RAX
MOV RSI,R14
CALL 0x0019097e
TEST AL,AL
JNZ 0x00190630
MOV R15,RSP
LEA R12,[RSP + 0x28]
LAB_00190577:
TEST BPL,BPL
JZ 0x001905ce
MOV RDI,R15
CALL 0x00190c5e
CMP byte ptr [RAX],0x1
JNZ 0x001905ce
MOV R13,qword ptr [RBX + 0x8]
MOV RDI,R15
CALL 0x00190844
MOV RDI,R13
MOV RSI,RAX
CALL 0x00190e22
MOV R13,RAX
MOV RAX,qword ptr [RBX + 0x8]
ADD RAX,0x8
CMP R13,RAX
JZ 0x001905ce
ADD R13,0x40
MOV RDI,R15
CALL 0x00190c5e
MOV RDI,R13
MOV RSI,RAX
MOV EDX,0x1
CALL 0x00184f6a
JMP 0x00190615
LAB_001905ce:
MOV RDI,R15
CALL 0x00190c5e
MOV RDI,R12
MOV RSI,RAX
CALL 0x00189ace
MOV R13,qword ptr [RBX + 0x8]
LAB_001905e5:
MOV RDI,R15
CALL 0x00190844
MOV RDI,R13
MOV RSI,RAX
CALL 0x0018b0c6
LAB_001905f8:
MOV RDI,RAX
MOV RSI,R12
CALL 0x00187a52
MOV RDI,R12
XOR ESI,ESI
CALL 0x001851c0
MOV RDI,R12
CALL 0x00189fae
LAB_00190615:
MOV RDI,R15
CALL 0x00190924
MOV RDI,R15
MOV RSI,R14
CALL 0x0019097e
TEST AL,AL
JZ 0x00190577
LAB_00190630:
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0019063f:
MOV EDI,0x20
CALL 0x00121660
MOV R14,RAX
MOV RDI,RBX
CALL 0x0018af58
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_0019065c:
LEA RSI,[0x225c10]
MOV RDI,RSP
CALL 0x001907bc
MOV BPL,0x1
LAB_0019066e:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x138
MOV RCX,RBX
CALL 0x0018ad80
XOR EBP,EBP
LEA RSI,[0x26b988]
LEA RDX,[0x13180a]
MOV RDI,R14
CALL 0x00121a80
LAB_0019069e:
MOV EDI,0x20
CALL 0x00121660
MOV R14,RAX
LEA R15,[RSP + 0x10]
MOV qword ptr [R15 + -0x10],R15
LAB_001906b4:
LEA RSI,[0x225c2a]
LEA RDX,[0x225c3e]
MOV RDI,RSP
CALL 0x0013a58a
MOV BPL,0x1
LAB_001906cd:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0xd2
MOV RCX,RBX
CALL 0x0018ab42
XOR EBP,EBP
LEA RSI,[0x26ba30]
LEA RDX,[0x13180a]
MOV RDI,R14
CALL 0x00121a80
LAB_001906fa:
MOV EDI,0x20
CALL 0x00121660
MOV R14,RAX
MOV RDI,qword ptr [R15]
CALL 0x0018af58
LEA RDX,[RSP + 0x20]
MOV qword ptr [RDX],RAX
LAB_00190717:
LEA RSI,[0x225c10]
MOV RDI,RSP
CALL 0x001907bc
MOV RCX,qword ptr [R15]
MOV BPL,0x1
LAB_0019072c:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x138
CALL 0x00190220
XOR EBP,EBP
LEA RSI,[0x26b988]
LEA RDX,[0x13180a]
MOV RDI,R14
CALL 0x00121a80
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::update(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>,
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>, bool) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::update(basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this,int8 *param_2,int8 *param_3,char param_4)
{
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_00;
map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*this_01;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
char cVar2;
int8 *puVar3;
char *pcVar4;
string *psVar5;
long lVar6;
basic_json *pbVar7;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*pbVar8;
int8 uVar9;
char *local_68;
int4 local_60;
int4 uStack_5c;
int4 uStack_58;
int4 uStack_54;
int8 local_50;
char *local_48;
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_40 [16];
bVar1 = *this;
if (bVar1 == (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
*this = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1;
puVar3 = (int8 *)operator_new(0x30);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
puVar3[3] = puVar3 + 1;
puVar3[4] = puVar3 + 1;
puVar3[5] = 0;
*(int8 **)(this + 8) = puVar3;
assert_invariant(SUB81(this,0));
bVar1 = *this;
}
if (bVar1 != (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x1) {
uVar9 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name(this);
/* try { // try from 0019065c to 0019066a has its CatchHandler @ 001907a9 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)&local_68,"cannot use update() with ",&local_48);
/* try { // try from 0019066e to 00190698 has its CatchHandler @ 00190784 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar9,0x138,&local_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_68 = (char *)*param_2;
if (local_68 != (char *)*param_3) {
uVar9 = __cxa_allocate_exception(0x20);
local_68 = (char *)&uStack_58;
/* try { // try from 001906b4 to 001906c9 has its CatchHandler @ 00190782 */
std::__cxx11::string::_M_construct<char_const*>(&local_68,"iterators do not fit","");
/* try { // try from 001906cd to 001906f7 has its CatchHandler @ 00190774 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar9,0xd2,&local_68,this);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::invalid_iterator::typeinfo,detail::exception::~exception);
}
if (*local_68 != '\x01') {
uVar9 = __cxa_allocate_exception(0x20);
local_48 = (char *)type_name((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_2);
/* try { // try from 00190717 to 00190725 has its CatchHandler @ 00190772 */
detail::concat<std::__cxx11::string,char_const(&)[26],char_const*>
((detail *)&local_68,"cannot use update() with ",&local_48);
/* try { // try from 0019072c to 00190753 has its CatchHandler @ 00190770 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SK_
(uVar9,0x138,&local_68,*param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar9,&detail::type_error::typeinfo,detail::exception::~exception);
}
local_60 = *(int4 *)(param_2 + 1);
uStack_5c = *(int4 *)((long)param_2 + 0xc);
uStack_58 = *(int4 *)(param_2 + 2);
uStack_54 = *(int4 *)((long)param_2 + 0x14);
local_50 = param_2[3];
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(&local_68,param_3);
if (cVar2 == '\0') {
do {
if (param_4 == '\0') {
LAB_001905ce:
pbVar7 = (basic_json *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
basic_json(local_40,pbVar7);
this_01 = *(map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
/* try { // try from 001905e5 to 001905f7 has its CatchHandler @ 00190754 */
psVar5 = (string *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
pbVar8 = (basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)std::
map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::operator[](this_01,psVar5);
operator=(pbVar8,local_40);
assert_invariant(SUB81(local_40,0));
data::~data((data *)local_40);
}
else {
pcVar4 = (char *)detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
if (*pcVar4 != '\x01') goto LAB_001905ce;
this_00 = *(_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)(this + 8);
psVar5 = (string *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::key((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
lVar6 = std::
_Rb_tree<std::__cxx11::string,std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::_Select1st<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::find(this_00,psVar5);
if (lVar6 == *(long *)(this + 8) + 8) goto LAB_001905ce;
pbVar7 = (basic_json *)
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator*((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
update((basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)(lVar6 + 0x40),pbVar7,true);
}
detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*)&local_68);
cVar2 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(&local_68,param_3);
} while (cVar2 == '\0');
}
return;
}
| |
22,967 | ma_setup_live_state | eloqsql/storage/maria/ma_state.c | my_bool _ma_setup_live_state(MARIA_HA *info)
{
TRN *trn;
MARIA_SHARE *share= info->s;
MARIA_USED_TABLES *tables;
MARIA_STATE_HISTORY *history;
DBUG_ENTER("_ma_setup_live_state");
DBUG_PRINT("enter", ("info: %p", info));
DBUG_ASSERT(share->lock_key_trees);
if (maria_create_trn_hook(info))
DBUG_RETURN(1);
trn= info->trn;
for (tables= (MARIA_USED_TABLES*) trn->used_tables;
tables;
tables= tables->next)
{
if (tables->share == share)
{
/* Table is already used by transaction */
goto end;
}
}
/* Table was not used before, create new table state entry */
if (!(tables= (MARIA_USED_TABLES*) my_malloc(PSI_INSTRUMENT_ME,
sizeof(*tables), MYF(MY_WME | MY_ZEROFILL))))
DBUG_RETURN(1);
tables->next= trn->used_tables;
trn->used_tables= tables;
tables->share= share;
mysql_mutex_lock(&share->intern_lock);
share->in_trans++;
DBUG_PRINT("info", ("share: %p in_trans: %d",
share, share->in_trans));
history= share->state_history;
/*
We must keep share locked to ensure that we don't access a history
link that is deleted by concurrently running checkpoint.
It's enough to compare trids here (instead of calling
tranman_can_read_from) as history->trid is a commit_trid
*/
while (trn->trid <= history->trid)
history= history->next;
mysql_mutex_unlock(&share->intern_lock);
/* The current item can't be deleted as it's the first one visible for us */
tables->state_start= tables->state_current= history->state;
tables->state_current.changed= tables->state_current.no_transid= 0;
DBUG_PRINT("info", ("records: %ld", (ulong) tables->state_start.records));
end:
info->state_start= &tables->state_start;
info->state= &tables->state_current;
info->used_tables= tables;
tables->use_count++;
/*
Mark in transaction state if we are not using transid (versioning)
on rows. If not, then we will in _ma_trnman_end_trans_hook()
ensure that the state is visible for all at end of transaction
*/
tables->state_current.no_transid|= !(info->row_flag & ROW_FLAG_TRANSID);
DBUG_PRINT("exit", ("tables: %p info->state: %p", tables, info->state));
DBUG_RETURN(0);
} | O3 | c | ma_setup_live_state:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x3b9e59(%rip), %rax # 0x3fcaf8
callq *(%rax)
movb $0x1, %r15b
testl %eax, %eax
jne 0x42dd2
movq 0x8(%rbx), %rax
leaq 0x58(%rax), %r13
movq %r13, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x42cca
cmpq %r12, 0x8(%r14)
jne 0x42cb7
jmp 0x42da4
movq %rax, -0x30(%rbp)
movl $0x88, %esi
movl $0x30, %edx
xorl %edi, %edi
callq 0x9fdb5
testq %rax, %rax
je 0x42dd2
movq %rax, %r14
movq (%r13), %rax
movq %rax, (%r14)
movq %r14, (%r13)
movq %r12, 0x8(%r14)
leaq 0x8f0(%r12), %r13
cmpq $0x0, 0x930(%r12)
jne 0x42de4
movq %r13, %rdi
callq 0x29200
incl 0x7ac(%r12)
leaq 0x450(%r12), %r15
movq -0x30(%rbp), %rax
movq 0x78(%rax), %rax
movq (%r15), %r15
cmpq 0x8(%r15), %rax
jbe 0x42d31
movq 0x930(%r12), %rdi
testq %rdi, %rdi
jne 0x42dfd
movq %r13, %rdi
callq 0x291c0
movups 0x10(%r15), %xmm0
movups 0x20(%r15), %xmm1
movups 0x30(%r15), %xmm2
movups %xmm0, 0x10(%r14)
movups %xmm1, 0x20(%r14)
movups %xmm2, 0x30(%r14)
movq 0x40(%r15), %rax
movq %rax, 0x40(%r14)
movq 0x40(%r15), %rax
movups 0x10(%r15), %xmm0
movups 0x20(%r15), %xmm1
movups 0x30(%r15), %xmm2
movups %xmm2, 0x68(%r14)
movups %xmm0, 0x48(%r14)
movq %rax, 0x78(%r14)
movups %xmm1, 0x58(%r14)
andb $-0x4, 0x44(%r14)
leaq 0x48(%r14), %rax
movq %rax, 0x60(%rbx)
leaq 0x10(%r14), %rax
movq %rax, 0x20(%rbx)
movq %r14, 0x68(%rbx)
incl 0x80(%r14)
movb 0x618(%rbx), %al
notb %al
addb %al, %al
andb $0x2, %al
orb %al, 0x44(%r14)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x97543(%rip), %rsi # 0xda32e
movq %r13, %rdi
movl $0x59, %edx
callq 0x2eb6f
jmp 0x42d19
leaq 0x34320c(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x42d4b
| _ma_setup_live_state:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi]
lea rax, maria_create_trn_hook
call qword ptr [rax]
mov r15b, 1
test eax, eax
jnz loc_42DD2
mov rax, [rbx+8]
lea r13, [rax+58h]
mov r14, r13
loc_42CB7:
mov r14, [r14]
test r14, r14
jz short loc_42CCA
cmp [r14+8], r12
jnz short loc_42CB7
jmp loc_42DA4
loc_42CCA:
mov [rbp+var_30], rax
mov esi, 88h
mov edx, 30h ; '0'
xor edi, edi
call my_malloc
test rax, rax
jz loc_42DD2
mov r14, rax
mov rax, [r13+0]
mov [r14], rax
mov [r13+0], r14
mov [r14+8], r12
lea r13, [r12+8F0h]
cmp qword ptr [r12+930h], 0
jnz loc_42DE4
mov rdi, r13
call _pthread_mutex_lock
loc_42D19:
inc dword ptr [r12+7ACh]
lea r15, [r12+450h]
mov rax, [rbp+var_30]
mov rax, [rax+78h]
loc_42D31:
mov r15, [r15]
cmp rax, [r15+8]
jbe short loc_42D31
mov rdi, [r12+930h]
test rdi, rdi
jnz loc_42DFD
loc_42D4B:
mov rdi, r13
call _pthread_mutex_unlock
movups xmm0, xmmword ptr [r15+10h]
movups xmm1, xmmword ptr [r15+20h]
movups xmm2, xmmword ptr [r15+30h]
movups xmmword ptr [r14+10h], xmm0
movups xmmword ptr [r14+20h], xmm1
movups xmmword ptr [r14+30h], xmm2
mov rax, [r15+40h]
mov [r14+40h], rax
mov rax, [r15+40h]
movups xmm0, xmmword ptr [r15+10h]
movups xmm1, xmmword ptr [r15+20h]
movups xmm2, xmmword ptr [r15+30h]
movups xmmword ptr [r14+68h], xmm2
movups xmmword ptr [r14+48h], xmm0
mov [r14+78h], rax
movups xmmword ptr [r14+58h], xmm1
and byte ptr [r14+44h], 0FCh
loc_42DA4:
lea rax, [r14+48h]
mov [rbx+60h], rax
lea rax, [r14+10h]
mov [rbx+20h], rax
mov [rbx+68h], r14
inc dword ptr [r14+80h]
mov al, [rbx+618h]
not al
add al, al
and al, 2
or [r14+44h], al
xor r15d, r15d
loc_42DD2:
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_42DE4:
lea rsi, aWorkspaceLlm4b_30; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, r13
mov edx, 59h ; 'Y'
call psi_mutex_lock
jmp loc_42D19
loc_42DFD:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp loc_42D4B
| long long ma_setup_live_state(long long *a1)
{
unsigned int v1; // r15d
long long v2; // r12
_QWORD *v3; // r13
_QWORD *v4; // r14
_QWORD *v5; // rax
long long *v6; // r15
__int128 v7; // xmm1
__int128 v8; // xmm2
long long v9; // rax
__int128 v10; // xmm0
__int128 v11; // xmm1
long long v13; // [rsp+0h] [rbp-30h]
v2 = *a1;
LOBYTE(v1) = 1;
if ( !(unsigned int)maria_create_trn_hook(a1) )
{
v3 = (_QWORD *)(a1[1] + 88);
v4 = v3;
while ( 1 )
{
v4 = (_QWORD *)*v4;
if ( !v4 )
break;
if ( v4[1] == v2 )
goto LABEL_14;
}
v13 = a1[1];
v5 = (_QWORD *)my_malloc(0LL, 136LL, 48LL);
if ( !v5 )
return v1;
v4 = v5;
*v5 = *v3;
*v3 = v5;
v5[1] = v2;
if ( *(_QWORD *)(v2 + 2352) )
psi_mutex_lock(v2 + 2288, (long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c", 0x59u);
else
pthread_mutex_lock(v2 + 2288);
++*(_DWORD *)(v2 + 1964);
v6 = (long long *)(v2 + 1104);
do
v6 = (long long *)*v6;
while ( *(_QWORD *)(v13 + 120) <= (unsigned long long)v6[1] );
if ( *(_QWORD *)(v2 + 2352) )
PSI_server[44]();
pthread_mutex_unlock(v2 + 2288);
v7 = *((_OWORD *)v6 + 2);
v8 = *((_OWORD *)v6 + 3);
*((_OWORD *)v4 + 1) = *((_OWORD *)v6 + 1);
*((_OWORD *)v4 + 2) = v7;
*((_OWORD *)v4 + 3) = v8;
v4[8] = v6[8];
v9 = v6[8];
v10 = *((_OWORD *)v6 + 1);
v11 = *((_OWORD *)v6 + 2);
*(_OWORD *)(v4 + 13) = *((_OWORD *)v6 + 3);
*(_OWORD *)(v4 + 9) = v10;
v4[15] = v9;
*(_OWORD *)(v4 + 11) = v11;
*((_BYTE *)v4 + 68) &= 0xFCu;
LABEL_14:
a1[12] = (long long)(v4 + 9);
a1[4] = (long long)(v4 + 2);
a1[13] = (long long)v4;
++*((_DWORD *)v4 + 32);
*((_BYTE *)v4 + 68) |= (2 * ~*((_BYTE *)a1 + 1560)) & 2;
return 0;
}
return v1;
}
| _ma_setup_live_state:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI]
LEA RAX,[0x4fcaf8]
CALL qword ptr [RAX]
MOV R15B,0x1
TEST EAX,EAX
JNZ 0x00142dd2
MOV RAX,qword ptr [RBX + 0x8]
LEA R13,[RAX + 0x58]
MOV R14,R13
LAB_00142cb7:
MOV R14,qword ptr [R14]
TEST R14,R14
JZ 0x00142cca
CMP qword ptr [R14 + 0x8],R12
JNZ 0x00142cb7
JMP 0x00142da4
LAB_00142cca:
MOV qword ptr [RBP + -0x30],RAX
MOV ESI,0x88
MOV EDX,0x30
XOR EDI,EDI
CALL 0x0019fdb5
TEST RAX,RAX
JZ 0x00142dd2
MOV R14,RAX
MOV RAX,qword ptr [R13]
MOV qword ptr [R14],RAX
MOV qword ptr [R13],R14
MOV qword ptr [R14 + 0x8],R12
LEA R13,[R12 + 0x8f0]
CMP qword ptr [R12 + 0x930],0x0
JNZ 0x00142de4
MOV RDI,R13
CALL 0x00129200
LAB_00142d19:
INC dword ptr [R12 + 0x7ac]
LEA R15,[R12 + 0x450]
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x78]
LAB_00142d31:
MOV R15,qword ptr [R15]
CMP RAX,qword ptr [R15 + 0x8]
JBE 0x00142d31
MOV RDI,qword ptr [R12 + 0x930]
TEST RDI,RDI
JNZ 0x00142dfd
LAB_00142d4b:
MOV RDI,R13
CALL 0x001291c0
MOVUPS XMM0,xmmword ptr [R15 + 0x10]
MOVUPS XMM1,xmmword ptr [R15 + 0x20]
MOVUPS XMM2,xmmword ptr [R15 + 0x30]
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOVUPS xmmword ptr [R14 + 0x20],XMM1
MOVUPS xmmword ptr [R14 + 0x30],XMM2
MOV RAX,qword ptr [R15 + 0x40]
MOV qword ptr [R14 + 0x40],RAX
MOV RAX,qword ptr [R15 + 0x40]
MOVUPS XMM0,xmmword ptr [R15 + 0x10]
MOVUPS XMM1,xmmword ptr [R15 + 0x20]
MOVUPS XMM2,xmmword ptr [R15 + 0x30]
MOVUPS xmmword ptr [R14 + 0x68],XMM2
MOVUPS xmmword ptr [R14 + 0x48],XMM0
MOV qword ptr [R14 + 0x78],RAX
MOVUPS xmmword ptr [R14 + 0x58],XMM1
AND byte ptr [R14 + 0x44],0xfc
LAB_00142da4:
LEA RAX,[R14 + 0x48]
MOV qword ptr [RBX + 0x60],RAX
LEA RAX,[R14 + 0x10]
MOV qword ptr [RBX + 0x20],RAX
MOV qword ptr [RBX + 0x68],R14
INC dword ptr [R14 + 0x80]
MOV AL,byte ptr [RBX + 0x618]
NOT AL
ADD AL,AL
AND AL,0x2
OR byte ptr [R14 + 0x44],AL
XOR R15D,R15D
LAB_00142dd2:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00142de4:
LEA RSI,[0x1da32e]
MOV RDI,R13
MOV EDX,0x59
CALL 0x0012eb6f
JMP 0x00142d19
LAB_00142dfd:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00142d4b
|
ulong _ma_setup_live_state(long *param_1)
{
pthread_mutex_t *__mutex;
long lVar1;
long lVar2;
long lVar3;
long lVar4;
long lVar5;
long lVar6;
int iVar7;
long *plVar8;
int8 unaff_R15;
ulong uVar9;
long *plVar10;
lVar1 = *param_1;
iVar7 = (*maria_create_trn_hook)();
uVar9 = CONCAT71((int7)((ulong)unaff_R15 >> 8),1);
if (iVar7 != 0) {
LAB_00142dd2:
return uVar9 & 0xffffffff;
}
lVar2 = param_1[1];
plVar10 = (long *)(lVar2 + 0x58);
plVar8 = plVar10;
while (plVar8 = (long *)*plVar8, plVar8 != (long *)0x0) {
if (plVar8[1] == lVar1) goto LAB_00142da4;
}
plVar8 = (long *)my_malloc(0,0x88,0x30);
if (plVar8 == (long *)0x0) goto LAB_00142dd2;
*plVar8 = *plVar10;
*plVar10 = (long)plVar8;
plVar8[1] = lVar1;
__mutex = (pthread_mutex_t *)(lVar1 + 0x8f0);
if (*(long *)(lVar1 + 0x930) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_state.c",0x59)
;
}
*(int *)(lVar1 + 0x7ac) = *(int *)(lVar1 + 0x7ac) + 1;
plVar10 = (long *)(lVar1 + 0x450);
do {
plVar10 = (long *)*plVar10;
} while (*(ulong *)(lVar2 + 0x78) <= (ulong)plVar10[1]);
if (*(long *)(lVar1 + 0x930) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar1 = plVar10[3];
lVar2 = plVar10[4];
lVar3 = plVar10[5];
lVar4 = plVar10[6];
lVar5 = plVar10[7];
plVar8[2] = plVar10[2];
plVar8[3] = lVar1;
plVar8[4] = lVar2;
plVar8[5] = lVar3;
plVar8[6] = lVar4;
plVar8[7] = lVar5;
plVar8[8] = plVar10[8];
lVar1 = plVar10[8];
lVar2 = plVar10[2];
lVar3 = plVar10[3];
lVar4 = plVar10[4];
lVar5 = plVar10[5];
lVar6 = plVar10[7];
plVar8[0xd] = plVar10[6];
plVar8[0xe] = lVar6;
plVar8[9] = lVar2;
plVar8[10] = lVar3;
plVar8[0xf] = lVar1;
plVar8[0xb] = lVar4;
plVar8[0xc] = lVar5;
*(byte *)((long)plVar8 + 0x44) = *(byte *)((long)plVar8 + 0x44) & 0xfc;
LAB_00142da4:
param_1[0xc] = (long)(plVar8 + 9);
param_1[4] = (long)(plVar8 + 2);
param_1[0xd] = (long)plVar8;
*(int *)(plVar8 + 0x10) = (int)plVar8[0x10] + 1;
*(byte *)((long)plVar8 + 0x44) =
*(byte *)((long)plVar8 + 0x44) | ~*(byte *)(param_1 + 0xc3) * '\x02' & 2;
uVar9 = 0;
goto LAB_00142dd2;
}
| |
22,968 | minja::Parser::peekSymbols(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | monkey531[P]llama/common/minja.hpp | MacroNode(const Location & location, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p, std::shared_ptr<TemplateNode> && b)
: TemplateNode(location), name(std::move(n)), params(std::move(p)), body(std::move(b)) {
for (size_t i = 0; i < params.size(); ++i) {
const auto & name = params[i].first;
if (!name.empty()) {
named_param_positions[name] = i;
}
}
} | O3 | cpp | minja::Parser::peekSymbols(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8ada0(%rip), %rax # 0x128fc8
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x9e258
movq 0x8bd36(%rip), %rdi # 0x129f80
cmpb $0x0, (%rdi)
je 0x9e254
incl 0x8(%rax)
jmp 0x9e258
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x8b1f1(%rip), %rax # 0x129458
addq $0x10, %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x28(%rbx)
movups (%rdx), %xmm0
movq %rax, 0x8(%rdx)
movups %xmm0, 0x20(%rbx)
movq %rax, (%rdx)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rbx)
movq 0x10(%rcx), %rdx
movq %rdx, 0x40(%rbx)
movq %rax, 0x10(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq %rax, 0x50(%rbx)
movups (%r8), %xmm1
movq %rax, 0x8(%r8)
movups %xmm1, 0x48(%rbx)
movq %rax, (%r8)
leaq 0x88(%rbx), %rax
movq %rax, 0x58(%rbx)
movq $0x1, 0x60(%rbx)
movups %xmm0, 0x68(%rbx)
movl $0x3f800000, 0x78(%rbx) # imm = 0x3F800000
movups %xmm0, 0x80(%rbx)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rax
cmpq %rsi, %rax
je 0x9e341
leaq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x28(%rbx), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30(%rbx), %r12
leaq 0x58(%rbx), %r13
xorl %ebp, %ebp
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r15d, %r15d
cmpq $0x0, 0x8(%rsi,%rbp)
je 0x9e327
addq %rbp, %rsi
movq %r13, %rdi
callq 0x9e6e4
movq %r15, (%rax)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rax
incq %r15
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
imulq %r14, %rcx
addq $0x30, %rbp
cmpq %rcx, %r15
jb 0x9e309
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq %r13, %rdi
callq 0x9eb06
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9e369
callq 0x6c8e8
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
movq 0x10(%rsp), %rcx
callq 0x1be9d
movq %rbp, %rdi
callq 0x1af20
| _ZN5minja9MacroNodeC2ERKNS_8LocationEOSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_INS_10ExpressionEEESaISI_EEOS4_INS_12TemplateNodeEE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rdi], rax
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_9E258
mov rdi, cs:__libc_single_threaded_ptr
cmp byte ptr [rdi], 0
jz short loc_9E254
inc dword ptr [rax+8]
jmp short loc_9E258
loc_9E254:
lock inc dword ptr [rax+8]
loc_9E258:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja9MacroNodeE; `vtable for'minja::MacroNode
add rax, 10h
mov [rbx], rax
xor eax, eax
mov [rbx+28h], rax
movups xmm0, xmmword ptr [rdx]
mov [rdx+8], rax
movups xmmword ptr [rbx+20h], xmm0
mov [rdx], rax
movups xmm0, xmmword ptr [rcx]
movups xmmword ptr [rbx+30h], xmm0
mov rdx, [rcx+10h]
mov [rbx+40h], rdx
mov [rcx+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [rcx], xmm0
mov [rbx+50h], rax
movups xmm1, xmmword ptr [r8]
mov [r8+8], rax
movups xmmword ptr [rbx+48h], xmm1
mov [r8], rax
lea rax, [rbx+88h]
mov [rbx+58h], rax
mov qword ptr [rbx+60h], 1
movups xmmword ptr [rbx+68h], xmm0
mov dword ptr [rbx+78h], 3F800000h
movups xmmword ptr [rbx+80h], xmm0
mov rsi, [rbx+30h]
mov rax, [rbx+38h]
cmp rax, rsi
jz short loc_9E341
lea rcx, [rbx+10h]
mov [rsp+48h+var_38], rcx
lea rcx, [rbx+28h]
mov [rsp+48h+var_40], rcx
lea r12, [rbx+30h]
lea r13, [rbx+58h]
xor ebp, ebp
mov r14, 0AAAAAAAAAAAAAAABh
xor r15d, r15d
loc_9E309:
cmp qword ptr [rsi+rbp+8], 0
jz short loc_9E327
add rsi, rbp
mov rdi, r13
call _ZNSt8__detail9_Map_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS6_mESaIS9_ENS_10_Select1stESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb0ELb1EEELb1EEixERS8_; std::__detail::_Map_base<std::string,std::pair<std::string const,ulong>,std::allocator<std::pair<std::string const,ulong>>,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>,true>::operator[](std::string const&)
mov [rax], r15
mov rsi, [rbx+30h]
mov rax, [rbx+38h]
loc_9E327:
inc r15
mov rcx, rax
sub rcx, rsi
sar rcx, 4
imul rcx, r14
add rbp, 30h ; '0'
cmp r15, rcx
jb short loc_9E309
loc_9E341:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbp, rax
mov rdi, r13
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_mESaIS8_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSA_18_Mod_range_hashingENSA_20_Default_ranged_hashENSA_20_Prime_rehash_policyENSA_17_Hashtable_traitsILb1ELb0ELb1EEEED2Ev; std::_Hashtable<std::string,std::pair<std::string const,ulong>,std::allocator<std::pair<std::string const,ulong>>,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>>::~_Hashtable()
mov rdi, [rbx+50h]
test rdi, rdi
jz short loc_9E369
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E369:
mov rdi, r12
mov rsi, [rsp+arg_0]
mov rdx, rbx
mov rcx, [rsp+arg_8]
call _ZN5minja9MacroNodeC2ERKNS_8LocationEOSt10shared_ptrINS_12VariableExprEEOSt6vectorISt4pairINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES4_INS_10ExpressionEEESaISI_EEOS4_INS_12TemplateNodeEE_cold_1; minja::MacroNode::MacroNode(minja::Location const&,std::shared_ptr<minja::VariableExpr> &&,std::vector<std::pair<std::string,std::shared_ptr<minja::Expression>>> &&,std::shared_ptr&&<minja::TemplateNode>) [clone]
mov rdi, rbp
call __Unwind_Resume
| long long minja::MacroNode::MacroNode(long long a1, _QWORD *a2, __int128 *a3, long long a4, __int128 *a5, int a6)
{
long long v6; // rax
__int128 v7; // xmm0
long long v8; // rdx
__int128 v9; // xmm1
long long v10; // rsi
long long result; // rax
unsigned long long v12; // rcx
long long v13; // rbp
unsigned long long v14; // r15
char v15; // [rsp+0h] [rbp-48h]
*(_QWORD *)a1 = &`vtable for'minja::TemplateNode + 2;
*(_QWORD *)(a1 + 8) = *a2;
v6 = a2[1];
*(_QWORD *)(a1 + 16) = v6;
if ( v6 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v6 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v6 + 8));
}
*(_QWORD *)(a1 + 24) = a2[2];
*(_QWORD *)a1 = &`vtable for'minja::MacroNode + 2;
*(_QWORD *)(a1 + 40) = 0LL;
v7 = *a3;
*((_QWORD *)a3 + 1) = 0LL;
*(_OWORD *)(a1 + 32) = v7;
*(_QWORD *)a3 = 0LL;
*(_OWORD *)(a1 + 48) = *(_OWORD *)a4;
v8 = *(_QWORD *)(a4 + 16);
*(_QWORD *)(a1 + 64) = v8;
*(_QWORD *)(a4 + 16) = 0LL;
*(_OWORD *)a4 = 0LL;
*(_QWORD *)(a1 + 80) = 0LL;
v9 = *a5;
*((_QWORD *)a5 + 1) = 0LL;
*(_OWORD *)(a1 + 72) = v9;
*(_QWORD *)a5 = 0LL;
*(_QWORD *)(a1 + 88) = a1 + 136;
*(_QWORD *)(a1 + 96) = 1LL;
*(_OWORD *)(a1 + 104) = 0LL;
*(_DWORD *)(a1 + 120) = 1065353216;
*(_OWORD *)(a1 + 128) = 0LL;
v10 = *(_QWORD *)(a1 + 48);
result = *(_QWORD *)(a1 + 56);
if ( result != v10 )
{
LODWORD(v12) = a1 + 40;
v13 = 0LL;
v14 = 0LL;
do
{
if ( *(_QWORD *)(v10 + v13 + 8) )
{
*(_QWORD *)std::__detail::_Map_base<std::string,std::pair<std::string const,unsigned long>,std::allocator<std::pair<std::string const,unsigned long>>,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>,true>::operator[](
(int)a1 + 88,
(int)v13 + (int)v10,
v8,
v12,
(_DWORD)a5,
a6,
v15) = v14;
v10 = *(_QWORD *)(a1 + 48);
result = *(_QWORD *)(a1 + 56);
}
++v14;
v12 = 0xAAAAAAAAAAAAAAABLL * ((result - v10) >> 4);
v13 += 48LL;
}
while ( v14 < v12 );
}
return result;
}
| MacroNode:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA RAX,[0x228fc8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x0019e258
MOV RDI,qword ptr [0x00229f80]
CMP byte ptr [RDI],0x0
JZ 0x0019e254
INC dword ptr [RAX + 0x8]
JMP 0x0019e258
LAB_0019e254:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019e258:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x229458]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
XOR EAX,EAX
MOV qword ptr [RBX + 0x28],RAX
MOVUPS XMM0,xmmword ptr [RDX]
MOV qword ptr [RDX + 0x8],RAX
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOV qword ptr [RDX],RAX
MOVUPS XMM0,xmmword ptr [RCX]
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV RDX,qword ptr [RCX + 0x10]
MOV qword ptr [RBX + 0x40],RDX
MOV qword ptr [RCX + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RCX],XMM0
MOV qword ptr [RBX + 0x50],RAX
MOVUPS XMM1,xmmword ptr [R8]
MOV qword ptr [R8 + 0x8],RAX
MOVUPS xmmword ptr [RBX + 0x48],XMM1
MOV qword ptr [R8],RAX
LEA RAX,[RBX + 0x88]
MOV qword ptr [RBX + 0x58],RAX
MOV qword ptr [RBX + 0x60],0x1
MOVUPS xmmword ptr [RBX + 0x68],XMM0
MOV dword ptr [RBX + 0x78],0x3f800000
MOVUPS xmmword ptr [RBX + 0x80],XMM0
MOV RSI,qword ptr [RBX + 0x30]
MOV RAX,qword ptr [RBX + 0x38]
CMP RAX,RSI
JZ 0x0019e341
LEA RCX,[RBX + 0x10]
MOV qword ptr [RSP + 0x10],RCX
LEA RCX,[RBX + 0x28]
MOV qword ptr [RSP + 0x8],RCX
LEA R12,[RBX + 0x30]
LEA R13,[RBX + 0x58]
XOR EBP,EBP
MOV R14,-0x5555555555555555
XOR R15D,R15D
LAB_0019e309:
CMP qword ptr [RSI + RBP*0x1 + 0x8],0x0
JZ 0x0019e327
ADD RSI,RBP
LAB_0019e314:
MOV RDI,R13
CALL 0x0019e6e4
LAB_0019e31c:
MOV qword ptr [RAX],R15
MOV RSI,qword ptr [RBX + 0x30]
MOV RAX,qword ptr [RBX + 0x38]
LAB_0019e327:
INC R15
MOV RCX,RAX
SUB RCX,RSI
SAR RCX,0x4
IMUL RCX,R14
ADD RBP,0x30
CMP R15,RCX
JC 0x0019e309
LAB_0019e341:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::MacroNode::MacroNode(minja::Location const&, std::shared_ptr<minja::VariableExpr>&&,
std::vector<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> >,
std::allocator<std::pair<std::__cxx11::string, std::shared_ptr<minja::Expression> > > >&&,
std::shared_ptr<minja::TemplateNode>&&) */
void __thiscall
minja::MacroNode::MacroNode
(MacroNode *this,Location *param_1,shared_ptr *param_2,vector *param_3,shared_ptr *param_4
)
{
int8 uVar1;
ulong *puVar2;
long lVar3;
long lVar4;
long lVar5;
ulong uVar6;
*(int ***)this = &PTR___cxa_pure_virtual_00228fd8;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar5 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar5;
if (lVar5 != 0) {
if (*PTR___libc_single_threaded_00229f80 == '\0') {
LOCK();
*(int *)(lVar5 + 8) = *(int *)(lVar5 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar5 + 8) = *(int *)(lVar5 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_render_00229468;
*(int8 *)(this + 0x28) = 0;
uVar1 = *(int8 *)(param_2 + 8);
*(int8 *)(param_2 + 8) = 0;
*(int8 *)(this + 0x20) = *(int8 *)param_2;
*(int8 *)(this + 0x28) = uVar1;
*(int8 *)param_2 = 0;
uVar1 = *(int8 *)(param_3 + 8);
*(int8 *)(this + 0x30) = *(int8 *)param_3;
*(int8 *)(this + 0x38) = uVar1;
*(int8 *)(this + 0x40) = *(int8 *)(param_3 + 0x10);
*(int8 *)(param_3 + 0x10) = 0;
*(int8 *)param_3 = 0;
*(int8 *)(param_3 + 8) = 0;
*(int8 *)(this + 0x50) = 0;
uVar1 = *(int8 *)(param_4 + 8);
*(int8 *)(param_4 + 8) = 0;
*(int8 *)(this + 0x48) = *(int8 *)param_4;
*(int8 *)(this + 0x50) = uVar1;
*(int8 *)param_4 = 0;
*(MacroNode **)(this + 0x58) = this + 0x88;
*(int8 *)(this + 0x60) = 1;
*(int8 *)(this + 0x68) = 0;
*(int8 *)(this + 0x70) = 0;
*(int4 *)(this + 0x78) = 0x3f800000;
*(int8 *)(this + 0x80) = 0;
*(int8 *)(this + 0x88) = 0;
lVar5 = *(long *)(this + 0x30);
lVar3 = *(long *)(this + 0x38);
if (lVar3 != lVar5) {
lVar4 = 0;
uVar6 = 0;
do {
if (*(long *)(lVar5 + 8 + lVar4) != 0) {
/* try { // try from 0019e314 to 0019e31b has its CatchHandler @ 0019e350 */
puVar2 = (ulong *)std::__detail::
_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>,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>,true>
::operator[]((_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,unsigned_long>,std::allocator<std::pair<std::__cxx11::string_const,unsigned_long>>,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>,true>
*)(this + 0x58),(string *)(lVar5 + lVar4));
*puVar2 = uVar6;
lVar5 = *(long *)(this + 0x30);
lVar3 = *(long *)(this + 0x38);
}
uVar6 = uVar6 + 1;
lVar4 = lVar4 + 0x30;
} while (uVar6 < (ulong)((lVar3 - lVar5 >> 4) * -0x5555555555555555));
}
return;
}
| |
22,969 | translog_lock | eloqsql/storage/maria/ma_loghandler.c | void translog_lock()
{
uint8 current_buffer;
DBUG_ENTER("translog_lock");
/*
Locking the loghandler mean locking current buffer, but it can change
during locking, so we should check it
*/
for (;;)
{
/*
log_descriptor.bc.buffer_no is only one byte so its reading is
an atomic operation
*/
current_buffer= log_descriptor.bc.buffer_no;
translog_buffer_lock(log_descriptor.buffers + current_buffer);
if (log_descriptor.bc.buffer_no == current_buffer)
break;
translog_buffer_unlock(log_descriptor.buffers + current_buffer);
}
DBUG_VOID_RETURN;
} | O3 | c | translog_lock:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0xbb6520(%rip), %r15d # 0xbff446
leaq 0x3b5893(%rip), %r14 # 0x3fe7c0
imulq $0x100120, %r15, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x48fb3
cmpb %r15b, 0xbb64f8(%rip) # 0xbff446
jne 0x48f59
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33d0b0(%rip), %r15 # 0x386010
movq 0x1000d0(%rbx), %rdi
testq %rdi, %rdi
jne 0x48fa8
addq $0x100090, %rbx # imm = 0x100090
movq %rbx, %rdi
callq 0x291e0
movzbl 0xbb64c3(%rip), %r12d # 0xbff446
imulq $0x100120, %r12, %rax # imm = 0x100120
leaq (%rax,%r14), %rbx
addq $0x2f8, %rbx # imm = 0x2F8
movq %rbx, %rdi
callq 0x48fb3
cmpb %r12b, 0xbb64a2(%rip) # 0xbff446
jne 0x48f60
jmp 0x48f50
movq (%r15), %rax
callq *0x160(%rax)
jmp 0x48f6c
| translog_lock:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
movzx r15d, byte ptr cs:xmmword_BFF440+6
lea r14, log_descriptor
imul rax, r15, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_BFF440+6, r15b
jnz short loc_48F59
loc_48F50:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_48F59:
lea r15, PSI_server
loc_48F60:
mov rdi, ds:qword_1000D0[rbx]
test rdi, rdi
jnz short loc_48FA8
loc_48F6C:
add rbx, 100090h
mov rdi, rbx
call _pthread_mutex_unlock
movzx r12d, byte ptr cs:xmmword_BFF440+6
imul rax, r12, 100120h
lea rbx, [rax+r14]
add rbx, 2F8h
mov rdi, rbx
call translog_buffer_lock
cmp byte ptr cs:xmmword_BFF440+6, r12b
jnz short loc_48F60
jmp short loc_48F50
loc_48FA8:
mov rax, [r15]
call qword ptr [rax+160h]
jmp short loc_48F6C
| long long translog_lock()
{
char v0; // r15
long long *v1; // rbx
long long result; // rax
char v3; // r12
v0 = BYTE6(xmmword_BFF440);
v1 = &log_descriptor[131108 * BYTE6(xmmword_BFF440) + 95];
result = translog_buffer_lock(v1);
if ( BYTE6(xmmword_BFF440) != v0 )
{
do
{
if ( *(long long *)((char *)&qword_1000D0 + (_QWORD)v1) )
PSI_server[44]();
pthread_mutex_unlock(v1 + 131090);
v3 = BYTE6(xmmword_BFF440);
v1 = &log_descriptor[131108 * BYTE6(xmmword_BFF440) + 95];
result = translog_buffer_lock(v1);
}
while ( BYTE6(xmmword_BFF440) != v3 );
}
return result;
}
| translog_lock:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOVZX R15D,byte ptr [0x00cff446]
LEA R14,[0x4fe7c0]
IMUL RAX,R15,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x00148fb3
CMP byte ptr [0x00cff446],R15B
JNZ 0x00148f59
LAB_00148f50:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00148f59:
LEA R15,[0x486010]
LAB_00148f60:
MOV RDI,qword ptr [RBX + 0x1000d0]
TEST RDI,RDI
JNZ 0x00148fa8
LAB_00148f6c:
ADD RBX,0x100090
MOV RDI,RBX
CALL 0x001291e0
MOVZX R12D,byte ptr [0x00cff446]
IMUL RAX,R12,0x100120
LEA RBX,[RAX + R14*0x1]
ADD RBX,0x2f8
MOV RDI,RBX
CALL 0x00148fb3
CMP byte ptr [0x00cff446],R12B
JNZ 0x00148f60
JMP 0x00148f50
LAB_00148fa8:
MOV RAX,qword ptr [R15]
CALL qword ptr [RAX + 0x160]
JMP 0x00148f6c
|
void translog_lock(void)
{
byte bVar1;
int *puVar2;
bVar1 = DAT_00cff446;
puVar2 = &DAT_004feab8 + (ulong)DAT_00cff446 * 0x100120;
translog_buffer_lock(puVar2);
if (DAT_00cff446 != bVar1) {
do {
if (*(long *)((long)&Elf64_Phdr_ARRAY_00100040[2].p_filesz + (long)puVar2) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock
((pthread_mutex_t *)((long)&Elf64_Phdr_ARRAY_00100040[1].p_paddr + (long)puVar2));
bVar1 = DAT_00cff446;
puVar2 = &DAT_004feab8 + (ulong)DAT_00cff446 * 0x100120;
translog_buffer_lock(puVar2);
} while (DAT_00cff446 != bVar1);
}
return;
}
| |
22,970 | 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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 0xb9100
xorb $-0x1, %al
testb $0x1, %al
jne 0xbfe20
jmp 0xbfe22
jmp 0xbfe41
leaq 0x10ee0b(%rip), %rdi # 0x1cec34
leaq 0x10caec(%rip), %rsi # 0x1cc91c
movl $0x1c28, %edx # imm = 0x1C28
leaq 0x10fc23(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xb9180
movq %rax, 0x110(%rsp)
movq %rdx, 0x118(%rsp)
leaq 0x110(%rsp), %rdi
callq 0xb72c0
xorb $-0x1, %al
testb $0x1, %al
jne 0xbfe74
jmp 0xbfeaa
movb $0x0, 0x10f(%rsp)
movq $0x0, 0x100(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x10f(%rsp), %rsi
leaq 0x100(%rsp), %rdx
callq 0xb9ca0
jmp 0xc031f
movq 0x128(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
callq 0xbd2c0
movb $0x1, %al
testb $0x1, 0x127(%rsp)
movb %al, 0x3f(%rsp)
jne 0xbff12
movq 0x40(%rsp), %rdi
movq %rdi, %rax
subq $-0x80, %rax
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
callq 0xb9280
movq 0x30(%rsp), %rdi
movl %eax, %esi
movl $0x5, %edx
leaq 0xf0(%rsp), %rcx
callq 0xb9220
movb %al, 0x3e(%rsp)
jmp 0xbff08
movb 0x3e(%rsp), %al
movb %al, 0x3f(%rsp)
jmp 0xbff12
movb 0x3f(%rsp), %al
andb $0x1, %al
movb %al, 0xef(%rsp)
testb $0x1, 0xef(%rsp)
jne 0xbff92
movb $0x0, 0xdb(%rsp)
movq $0x0, 0xd0(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xdb(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0xb9ca0
jmp 0xbff5c
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe0(%rsp)
movl %eax, 0xdc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x6e0f0
jmp 0xc0336
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9cd0
testb $0x1, %al
jne 0xbffa6
jmp 0xc0023
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x9f8d0
movq 0x28(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0xb3e10
movq 0x28(%rsp), %rdi
callq 0x6e0f0
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 0xb9d20
jmp 0xc0013
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
cmpq $0x0, (%rax)
jne 0xc007a
movb $0x0, 0xa7(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0xa7(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0xb9ca0
jmp 0xc006a
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c40
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x27(%rsp)
jne 0xc00b7
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c80
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xc00c1
jmp 0xc00c3
jmp 0xc00e2
leaq 0x10ec80(%rip), %rdi # 0x1ced4a
leaq 0x10c84b(%rip), %rsi # 0x1cc91c
movl $0x1c4b, %edx # imm = 0x1C4B
leaq 0x10f982(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c40
testb $0x1, %al
jne 0xc00fe
jmp 0xc017b
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xa36d0
jmp 0xc0122
movq 0x40(%rsp), %rdi
movb $0x1, 0x97(%rsp)
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0xa2be0
movq %rax, 0x88(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x97(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0xb9d20
jmp 0xc016b
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rdi
addq $0x8, %rdi
callq 0xb9880
movq (%rax), %rdi
callq 0xa2c80
testb $0x1, %al
jne 0xc0197
jmp 0xc0199
jmp 0xc01b8
leaq 0x10ebca(%rip), %rdi # 0x1ced6a
leaq 0x10c775(%rip), %rsi # 0x1cc91c
movl $0x1c55, %edx # imm = 0x1C55
leaq 0x10f8ac(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xb9100
xorb $-0x1, %al
testb $0x1, %al
jne 0xc01ce
jmp 0xc01d0
jmp 0xc01ef
leaq 0x10ebb1(%rip), %rdi # 0x1ced88
leaq 0x10c73e(%rip), %rsi # 0x1cc91c
movl $0x1c57, %edx # imm = 0x1C57
leaq 0x10f875(%rip), %rcx # 0x1cfa5f
callq 0x50230
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
callq 0xb9180
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xc0209
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xb72c0
movq 0x40(%rsp), %rdi
movb %al, 0x87(%rsp)
addq $0x48, %rdi
callq 0xb9200
jmp 0xc023e
testb $0x1, 0x87(%rsp)
jne 0xc027f
movb $0x0, 0x6f(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x6f(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xb9ca0
jmp 0xc026f
movl $0x1, 0xcc(%rsp)
jmp 0xc0312
movq 0x40(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0xc028d
jmp 0xc02ac
leaq 0x10eb0c(%rip), %rdi # 0x1ceda0
leaq 0x10c681(%rip), %rsi # 0x1cc91c
movl $0x1c60, %edx # imm = 0x1C60
leaq 0x10f7b8(%rip), %rcx # 0x1cfa5f
callq 0x50230
leaq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0xf0(%rsp), %rsi
callq 0x9f8d0
movq 0x40(%rsp), %rax
movq (%rsp), %rsi
movq %rax, %rcx
addq $0x70, %rcx
movq %rcx, 0x8(%rsp)
movq 0x70(%rax), %rdi
callq 0xb3e10
movq (%rsp), %rdi
callq 0x6e0f0
movq 0x8(%rsp), %rdx
movb $0x1, 0x4f(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x4f(%rsp), %rsi
callq 0xb9d50
jmp 0xc0307
movl $0x1, 0xcc(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x6e0f0
movb 0x138(%rsp), %al
movq 0x140(%rsp), %rdx
addq $0x148, %rsp # imm = 0x148
retq
movq 0xe0(%rsp), %rdi
callq 0x50940
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRSB_EESt4pairIbPSF_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)
xor al, 0FFh
test al, 1
jnz short loc_BFE20
jmp short loc_BFE22
loc_BFE20:
jmp short loc_BFE41
loc_BFE22:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C28h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_BFE41:
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_BFE74
jmp short loc_BFEAA
loc_BFE74:
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_C031F
loc_BFEAA:
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_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_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_BFF12
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_BFF08:
mov al, [rsp+148h+var_10A]
mov [rsp+148h+var_109], al
jmp short $+2
loc_BFF12:
mov al, [rsp+148h+var_109]
and al, 1
mov [rsp+148h+var_59], al
test [rsp+148h+var_59], 1
jnz short loc_BFF92
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_BFF5C:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
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_C0336
loc_BFF92:
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_BFFA6
jmp short loc_C0023
loc_BFFA6:
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_C0013:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C0023:
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_C007A
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_C006A:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C007A:
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)
mov cl, al
mov al, 1
test cl, 1
mov [rsp+148h+var_121], al
jnz short loc_C00B7
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)
mov [rsp+148h+var_121], al
loc_C00B7:
mov al, [rsp+148h+var_121]
test al, 1
jnz short loc_C00C1
jmp short loc_C00C3
loc_C00C1:
jmp short loc_C00E2
loc_C00C3:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C4Bh
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C00E2:
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_C00FE
jmp short loc_C017B
loc_C00FE:
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_C0122:
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_C016B:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C017B:
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_C0197
jmp short loc_C0199
loc_C0197:
jmp short loc_C01B8
loc_C0199:
lea rdi, aRefStackBackIs+20h; "ref_stack.back()->is_object()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C55h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C01B8:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_C01CE
jmp short loc_C01D0
loc_C01CE:
jmp short loc_C01EF
loc_C01D0:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C57h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C01EF:
mov rdi, [rsp+148h+var_108]
add rdi, 48h ; 'H'
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
mov [rsp+148h+var_138], rdx
mov [rsp+148h+var_130], rax
jmp short $+2
loc_C0209:
mov rax, [rsp+148h+var_138]
mov rcx, [rsp+148h+var_130]
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_C023E:
test [rsp+148h+var_C1], 1
jnz short loc_C027F
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_C026F:
mov [rsp+148h+var_7C], 1
jmp loc_C0312
loc_C027F:
mov rax, [rsp+148h+var_108]
cmp qword ptr [rax+70h], 0
jz short loc_C028D
jmp short loc_C02AC
loc_C028D:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
mov edx, 1C60h
lea rcx, aStdPairBoolBas_4; "std::pair<bool, BasicJsonType *> nlohma"...
call ___assert_fail
loc_C02AC:
lea rdi, [rsp+148h+var_F8]
mov [rsp+148h+var_148], 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_148]
mov rcx, rax
add rcx, 70h ; 'p'
mov [rsp+148h+var_140], 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_148]
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_140]
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_C0307:
mov [rsp+148h+var_7C], 1
loc_C0312:
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_C031F:
mov al, [rsp+148h+var_10]
mov rdx, [rsp+148h+var_8]
add rsp, 148h
retn
loc_C0336:
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<std::string&>(
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; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rax
_BYTE **v14; // rax
long long v15; // rdx
bool is_object; // [rsp+27h] [rbp-121h]
char v18; // [rsp+3Fh] [rbp-109h]
char v19; // [rsp+4Fh] [rbp-F9h] BYREF
__int128 v20; // [rsp+50h] [rbp-F8h] BYREF
long long v21; // [rsp+60h] [rbp-E8h]
char v22; // [rsp+6Fh] [rbp-D9h] BYREF
_QWORD v23[2]; // [rsp+70h] [rbp-D8h] BYREF
bool v24; // [rsp+87h] [rbp-C1h]
long long v25; // [rsp+88h] [rbp-C0h] BYREF
char v26; // [rsp+97h] [rbp-B1h] BYREF
long long v27; // [rsp+98h] [rbp-B0h]
char v28; // [rsp+A7h] [rbp-A1h] BYREF
long long v29; // [rsp+A8h] [rbp-A0h] BYREF
char v30; // [rsp+B7h] [rbp-91h] BYREF
__int128 v31; // [rsp+B8h] [rbp-90h] BYREF
int v32; // [rsp+CCh] [rbp-7Ch]
long long v33; // [rsp+D0h] [rbp-78h]
_BYTE v34[21]; // [rsp+DBh] [rbp-6Dh] BYREF
_BYTE v35[16]; // [rsp+F0h] [rbp-58h] BYREF
long long v36; // [rsp+100h] [rbp-48h]
char v37; // [rsp+10Fh] [rbp-39h] BYREF
_QWORD v38[2]; // [rsp+110h] [rbp-38h] BYREF
char v39; // [rsp+127h] [rbp-21h]
long long v40; // [rsp+128h] [rbp-20h]
long long v41; // [rsp+130h] [rbp-18h]
_BYTE v42[8]; // [rsp+138h] [rbp-10h] BYREF
v41 = a1;
v40 = a2;
v39 = a3 & 1;
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 32)) & 1) != 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value"
" = std::basic_string<char> &]");
v38[0] = std::vector<bool>::back(a1 + 32);
v38[1] = v3;
if ( std::_Bit_reference::operator bool((long long)v38) )
{
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_(
v35,
v40);
v18 = 1;
if ( (v39 & 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));
v18 = 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)v35);
}
v34[20] = v18 & 1;
if ( (v18 & 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(
&v31,
(long long)v35);
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)&v31);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)&v31);
v30 = 1;
v29 = *(_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)v42,
&v30,
&v29);
v32 = 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);
is_object = 1;
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);
is_object = 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);
}
if ( !is_object )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = std::basic_string<char> &]");
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)v35,
v9,
v10,
v11,
v12);
v26 = 1;
v13 = 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);
v25 = 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 *)v13 + 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)v42,
&v26,
&v25);
v32 = 1;
}
else
{
v14 = (_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(*v14) )
__assert_fail(
"ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7253LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::basic_string<char> &]");
if ( (std::vector<bool>::empty((unsigned long long **)(a1 + 72)) & 1) != 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::basic_string<char> &]");
v23[0] = std::vector<bool>::back(a1 + 72);
v23[1] = v15;
v24 = std::_Bit_reference::operator bool((long long)v23);
std::vector<bool>::pop_back(a1 + 72);
if ( v24 )
{
if ( !*(_QWORD *)(a1 + 112) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlo"
"hmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann:"
":ordered_map>, Value = std::basic_string<char> &]");
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,
(long long)v35);
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)&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);
v19 = 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)v42,
&v19,
(_QWORD *)(a1 + 112));
v32 = 1;
}
else
{
v22 = 0;
v21 = 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)v42,
&v22);
v32 = 1;
}
}
}
else
{
v28 = 0;
v27 = 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)v42,
&v28);
v32 = 1;
}
}
else
{
v34[0] = 0;
v33 = 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)v42,
v34);
v32 = 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)v35);
}
else
{
v37 = 0;
v36 = 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)v42,
&v37);
}
return v42[0];
}
| handle_value<std::__cxx11::string&>:
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 0x001b9100
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bfe20
JMP 0x001bfe22
LAB_001bfe20:
JMP 0x001bfe41
LAB_001bfe22:
LEA RDI,[0x2cec34]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c28
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001bfe41:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x20
CALL 0x001b9180
MOV qword ptr [RSP + 0x110],RAX
MOV qword ptr [RSP + 0x118],RDX
LEA RDI,[RSP + 0x110]
CALL 0x001b72c0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bfe74
JMP 0x001bfeaa
LAB_001bfe74:
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 0x001b9ca0
JMP 0x001c031f
LAB_001bfeaa:
MOV RSI,qword ptr [RSP + 0x128]
LEA RDI,[RSP + 0xf0]
CALL 0x001bd2c0
MOV AL,0x1
TEST byte ptr [RSP + 0x127],0x1
MOV byte ptr [RSP + 0x3f],AL
JNZ 0x001bff12
MOV RDI,qword ptr [RSP + 0x40]
MOV RAX,RDI
SUB RAX,-0x80
MOV qword ptr [RSP + 0x30],RAX
ADD RDI,0x8
CALL 0x001b9280
MOV RDI,qword ptr [RSP + 0x30]
MOV ESI,EAX
LAB_001bfef0:
MOV EDX,0x5
LEA RCX,[RSP + 0xf0]
CALL 0x001b9220
MOV byte ptr [RSP + 0x3e],AL
JMP 0x001bff08
LAB_001bff08:
MOV AL,byte ptr [RSP + 0x3e]
MOV byte ptr [RSP + 0x3f],AL
JMP 0x001bff12
LAB_001bff12:
MOV AL,byte ptr [RSP + 0x3f]
AND AL,0x1
MOV byte ptr [RSP + 0xef],AL
TEST byte ptr [RSP + 0xef],0x1
JNZ 0x001bff92
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 0x001b9ca0
JMP 0x001bff5c
LAB_001bff5c:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001bff92:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9cd0
TEST AL,0x1
JNZ 0x001bffa6
JMP 0x001c0023
LAB_001bffa6:
LEA RDI,[RSP + 0xb8]
MOV qword ptr [RSP + 0x28],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x0019f8d0
MOV RSI,qword ptr [RSP + 0x28]
MOV RAX,qword ptr [RSP + 0x40]
MOV RDI,qword ptr [RAX]
CALL 0x001b3e10
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0016e0f0
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 0x001b9d20
JMP 0x001c0013
LAB_001c0013:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c0023:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
CMP qword ptr [RAX],0x0
JNZ 0x001c007a
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 0x001b9ca0
JMP 0x001c006a
LAB_001c006a:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c007a:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c40
MOV CL,AL
MOV AL,0x1
TEST CL,0x1
MOV byte ptr [RSP + 0x27],AL
JNZ 0x001c00b7
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c80
MOV byte ptr [RSP + 0x27],AL
LAB_001c00b7:
MOV AL,byte ptr [RSP + 0x27]
TEST AL,0x1
JNZ 0x001c00c1
JMP 0x001c00c3
LAB_001c00c1:
JMP 0x001c00e2
LAB_001c00c3:
LEA RDI,[0x2ced4a]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c4b
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c00e2:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c40
TEST AL,0x1
JNZ 0x001c00fe
JMP 0x001c017b
LAB_001c00fe:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0xf0]
CALL 0x001a36d0
JMP 0x001c0122
LAB_001c0122:
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x97],0x1
ADD RDI,0x8
CALL 0x001b9880
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x001a2be0
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x97]
LEA RDX,[RSP + 0x88]
CALL 0x001b9d20
JMP 0x001c016b
LAB_001c016b:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c017b:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x8
CALL 0x001b9880
MOV RDI,qword ptr [RAX]
CALL 0x001a2c80
TEST AL,0x1
JNZ 0x001c0197
JMP 0x001c0199
LAB_001c0197:
JMP 0x001c01b8
LAB_001c0199:
LEA RDI,[0x2ced6a]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c55
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c01b8:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001b9100
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c01ce
JMP 0x001c01d0
LAB_001c01ce:
JMP 0x001c01ef
LAB_001c01d0:
LEA RDI,[0x2ced88]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c57
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c01ef:
MOV RDI,qword ptr [RSP + 0x40]
ADD RDI,0x48
CALL 0x001b9180
MOV qword ptr [RSP + 0x10],RDX
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001c0209
LAB_001c0209:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x70],RCX
MOV qword ptr [RSP + 0x78],RAX
LEA RDI,[RSP + 0x70]
CALL 0x001b72c0
MOV RDI,qword ptr [RSP + 0x40]
MOV byte ptr [RSP + 0x87],AL
ADD RDI,0x48
CALL 0x001b9200
JMP 0x001c023e
LAB_001c023e:
TEST byte ptr [RSP + 0x87],0x1
JNZ 0x001c027f
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 0x001b9ca0
JMP 0x001c026f
LAB_001c026f:
MOV dword ptr [RSP + 0xcc],0x1
JMP 0x001c0312
LAB_001c027f:
MOV RAX,qword ptr [RSP + 0x40]
CMP qword ptr [RAX + 0x70],0x0
JZ 0x001c028d
JMP 0x001c02ac
LAB_001c028d:
LEA RDI,[0x2ceda0]
LEA RSI,[0x2cc91c]
MOV EDX,0x1c60
LEA RCX,[0x2cfa5f]
CALL 0x00150230
LAB_001c02ac:
LEA RDI,[RSP + 0x50]
MOV qword ptr [RSP],RDI
LEA RSI,[RSP + 0xf0]
CALL 0x0019f8d0
MOV RAX,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP]
MOV RCX,RAX
ADD RCX,0x70
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,qword ptr [RAX + 0x70]
CALL 0x001b3e10
MOV RDI,qword ptr [RSP]
CALL 0x0016e0f0
MOV RDX,qword ptr [RSP + 0x8]
MOV byte ptr [RSP + 0x4f],0x1
LEA RDI,[RSP + 0x138]
LEA RSI,[RSP + 0x4f]
CALL 0x001b9d50
LAB_001c0305:
JMP 0x001c0307
LAB_001c0307:
MOV dword ptr [RSP + 0xcc],0x1
LAB_001c0312:
LEA RDI,[RSP + 0xf0]
CALL 0x0016e0f0
LAB_001c031f:
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<std::__cxx11::string&>(std::__cxx11::string&, 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<std::__cxx11::string&>
(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,string *param_1,bool param_2)
{
byte bVar1;
bool bVar2;
int4 uVar3;
ulong uVar4;
long *plVar5;
int8 *puVar6;
int8 uVar7;
int1 auVar8 [16];
byte local_121;
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 local_58 [16];
int8 local_48;
int1 local_39;
_Bit_reference local_38 [23];
byte local_21;
string *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;
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
0x1c28,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
local_38._0_16_ =
std::vector<bool,std::allocator<bool>>::back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
bVar2 = std::_Bit_reference::operator_cast_to_bool(local_38);
if (((bVar2 ^ 0xffU) & 1) == 0) {
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SH_EE5valueEiE4typeELi0EEEOT_
(local_58,local_20);
local_109 = 1;
if ((local_21 & 1) == 0) {
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>*>>
::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 001bfef0 to 001c0304 has its CatchHandler @ 001bff6c */
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),uVar3,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 {
uVar4 = 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 ((uVar4 & 1) == 0) {
plVar5 = (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 (*plVar5 == 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 {
puVar6 = (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));
bVar1 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)*puVar6);
local_121 = 1;
if ((bVar1 & 1) == 0) {
puVar6 = (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));
local_121 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)*puVar6);
}
if ((local_121 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c4b,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
puVar6 = (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));
uVar4 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)*puVar6);
if ((uVar4 & 1) == 0) {
puVar6 = (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));
uVar4 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)*puVar6);
if ((uVar4 & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c55,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
bVar1 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x48));
if (((bVar1 ^ 0xff) & 1) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c57,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
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) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c60,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = std::basic_string<char> &]"
);
}
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 {
plVar5 = (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>>>
**)(*plVar5 + 8),local_58);
local_b1 = 1;
plVar5 = (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>>>
**)(*plVar5 + 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;
uVar7 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)local_58);
}
else {
local_39 = 0;
local_48 = 0;
uVar7 = _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);
}
auVar8._1_7_ = (int7)((ulong)uVar7 >> 8);
auVar8[0] = local_10[0];
auVar8._8_8_ = local_8;
return auVar8;
}
| |
22,971 | 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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 0x4d0a2
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 0x4cf35
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movq (%rsi), %rsi
movq %r14, %rdi
callq 0x40218
movq %r14, %rdi
movl $0x1, %esi
callq 0x3efdc
testb %bpl, %bpl
jne 0x4cee2
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movl %eax, 0xc(%rsp)
movb $0x5, 0xb(%rsp)
cmpq $0x0, 0x90(%rbx)
je 0x4d0c1
leaq 0x80(%rbx), %rdi
leaq 0xc(%rsp), %rsi
leaq 0xb(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq *0x98(%rbx)
testb %al, %al
je 0x4d076
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x4cf3f
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x4d076
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x4cf99
cmpl $0x2, %ecx
jne 0x4d0c6
movq 0x8(%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40686
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x4d072
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4d092
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x30(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3efdc
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x487f0
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movq (%rbx), %r14
jmp 0x4d072
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 0x4d0e5
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 0x4d00b
movl $0x3f, 0x60(%rbx)
addq $-0x8, %rax
movq %rax, 0x58(%rbx)
testq %rdx, %rdx
je 0x4d076
cmpq $0x0, 0x70(%rbx)
je 0x4d104
leaq 0x10(%rsp), %r14
movaps (%r14), %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, (%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r15, %rdi
movl $0x1, %esi
callq 0x3efdc
movq 0x70(%rbx), %rdi
movq %r15, %rsi
callq 0x487f0
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x4d07b
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r15, %rdi
callq 0x4bfb8
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x700a4(%rip), %rdi # 0xbd14d
leaq 0x6dd7e(%rip), %rsi # 0xbae2e
leaq 0x70b3b(%rip), %rcx # 0xbdbf2
movl $0x1c28, %edx # imm = 0x1C28
callq 0x18470
callq 0x18260
leaq 0x70196(%rip), %rdi # 0xbd263
leaq 0x6dd5a(%rip), %rsi # 0xbae2e
leaq 0x70b17(%rip), %rcx # 0xbdbf2
movl $0x1c4b, %edx # imm = 0x1C4B
callq 0x18470
leaq 0x701b5(%rip), %rdi # 0xbd2a1
leaq 0x6dd3b(%rip), %rsi # 0xbae2e
leaq 0x70af8(%rip), %rcx # 0xbdbf2
movl $0x1c57, %edx # imm = 0x1C57
callq 0x18470
leaq 0x701ae(%rip), %rdi # 0xbd2b9
leaq 0x6dd1c(%rip), %rsi # 0xbae2e
leaq 0x70ad9(%rip), %rcx # 0xbdbf2
movl $0x1c60, %edx # imm = 0x1C60
callq 0x18470
movq %rax, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3efdc
movq %r14, %rdi
callq 0x4bfb8
movq %rbx, %rdi
callq 0x18b90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIRlEESt4pairIbPSF_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_4D0A2
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_4CF35
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_tE5EE9constructINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES8_IhSaIhEEvEEEEvRT_NSJ_16number_integer_tE; nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::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_integer_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_4CEE2
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_4D0C1
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_4D076
loc_4CEE2:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_4CF3F
mov rax, [rax-8]
test rax, rax
jz loc_4D076
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz loc_4CF99
cmp ecx, 2
jnz loc_4D0C6
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_4D072
loc_4CF35:
xor ebx, ebx
xor r14d, r14d
jmp loc_4D092
loc_4CF3F:
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_4D072
loc_4CF99:
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_4D0E5
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_4D00B
mov dword ptr [rbx+60h], 3Fh ; '?'
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+58h], rax
loc_4D00B:
test rdx, rdx
jz short loc_4D076
cmp qword ptr [rbx+70h], 0
jz loc_4D104
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_4D072:
mov bl, 1
jmp short loc_4D07B
loc_4D076:
xor ebx, ebx
xor r14d, r14d
loc_4D07B:
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_4D092:
mov eax, ebx
mov rdx, r14
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4D0A2:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C28h
call ___assert_fail
loc_4D0C1:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
loc_4D0C6:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C4Bh
call ___assert_fail
loc_4D0E5:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C57h
call ___assert_fail
loc_4D104:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_3; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C60h
call ___assert_fail
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<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
char v20; // [rsp+Bh] [rbp-5Dh] BYREF
int v21; // [rsp+Ch] [rbp-5Ch] BYREF
__int128 v22; // [rsp+10h] [rbp-58h] BYREF
__int128 v23; // [rsp+20h] [rbp-48h] BYREF
_OWORD v24[3]; // [rsp+30h] [rbp-38h] BYREF
v4 = a1;
v5 = *(_QWORD *)(a1 + 48);
v6 = *(_DWORD *)(a1 + 56);
if ( *(_QWORD *)(a1 + 32) == v5 && v6 == 0 )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]");
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) )
{
v22 = 0LL;
nlohmann::json_abi_v3_11_3::detail::external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::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>>(
&v22,
*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 *)&v22);
if ( a3 )
goto LABEL_8;
v21 = (*(_QWORD *)(a1 + 16) - *(_QWORD *)(a1 + 8)) >> 3;
v20 = 5;
if ( !*(_QWORD *)(a1 + 144) )
std::__throw_bad_function_call();
if ( (*(unsigned __int8 ( **)(long long, int *, char *, __int128 *))(a1 + 152))(a1 + 128, &v21, &v20, &v22) )
{
LABEL_8:
v10 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v10 )
{
v24[0] = v22;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v22);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 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 *)v24);
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)v24);
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 *)v24);
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((void **)v24);
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 *)&v22);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)&v22);
return v4;
}
v11 = *(unsigned __int8 **)(v10 - 8);
if ( v11 )
{
v12 = *v11;
if ( v12 != 1 )
{
if ( v12 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = long &]");
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)&v22);
goto LABEL_23;
}
v13 = *(_QWORD *)(a1 + 88);
v14 = *(_DWORD *)(a1 + 96);
if ( *(_QWORD *)(a1 + 72) == v13 && v14 == 0 )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = long &]");
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) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = long &]");
v23 = v22;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)&v22);
LOBYTE(v22) = 0;
*((_QWORD *)&v22 + 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 *)&v23);
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)&v23);
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 *)&v23);
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((void **)&v23);
goto LABEL_23;
}
}
}
v4 = 0;
goto LABEL_25;
}
return 0;
}
| handle_value<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 0x0014d0a2
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 0x0014cf35
XORPS XMM0,XMM0
LEA R14,[RSP + 0x10]
MOVAPS xmmword ptr [R14],XMM0
MOV RSI,qword ptr [RSI]
MOV RDI,R14
CALL 0x00140218
MOV RDI,R14
MOV ESI,0x1
CALL 0x0013efdc
TEST BPL,BPL
JNZ 0x0014cee2
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 0x0014d0c1
LEA RDI,[RBX + 0x80]
LAB_0014cec5:
LEA RSI,[RSP + 0xc]
LEA RDX,[RSP + 0xb]
LEA RCX,[RSP + 0x10]
CALL qword ptr [RBX + 0x98]
TEST AL,AL
JZ 0x0014d076
LAB_0014cee2:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x0014cf3f
MOV RAX,qword ptr [RAX + -0x8]
TEST RAX,RAX
JZ 0x0014d076
MOVZX ECX,byte ptr [RAX]
CMP ECX,0x1
JZ 0x0014cf99
CMP ECX,0x2
JNZ 0x0014d0c6
MOV RDI,qword ptr [RAX + 0x8]
LEA RSI,[RSP + 0x10]
CALL 0x00140686
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 0x0014d072
LAB_0014cf35:
XOR EBX,EBX
XOR R14D,R14D
JMP 0x0014d092
LAB_0014cf3f:
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 0x0013efdc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013efdc
MOV RDI,qword ptr [RBX]
MOV RSI,R15
CALL 0x001487f0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
MOV R14,qword ptr [RBX]
JMP 0x0014d072
LAB_0014cf99:
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 0x0014d0e5
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 0x0014d00b
MOV dword ptr [RBX + 0x60],0x3f
ADD RAX,-0x8
MOV qword ptr [RBX + 0x58],RAX
LAB_0014d00b:
TEST RDX,RDX
JZ 0x0014d076
CMP qword ptr [RBX + 0x70],0x0
JZ 0x0014d104
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 0x0013efdc
MOV byte ptr [R14],0x0
MOV qword ptr [R14 + 0x8],0x0
MOV RDI,R15
MOV ESI,0x1
CALL 0x0013efdc
MOV RDI,qword ptr [RBX + 0x70]
MOV RSI,R15
CALL 0x001487f0
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
MOV R14,qword ptr [RBX + 0x70]
LAB_0014d072:
MOV BL,0x1
JMP 0x0014d07b
LAB_0014d076:
XOR EBX,EBX
XOR R14D,R14D
LAB_0014d07b:
LEA R15,[RSP + 0x10]
MOV RDI,R15
XOR ESI,ESI
CALL 0x0013efdc
MOV RDI,R15
CALL 0x0014bfb8
LAB_0014d092:
MOV EAX,EBX
MOV RDX,R14
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0014d0a2:
LEA RDI,[0x1bd14d]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c28
CALL 0x00118470
LAB_0014d0c1:
CALL 0x00118260
LAB_0014d0c6:
LEA RDI,[0x1bd263]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c4b
CALL 0x00118470
LAB_0014d0e5:
LEA RDI,[0x1bd2a1]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c57
CALL 0x00118470
LAB_0014d104:
LEA RDI,[0x1bd2b9]
LEA RSI,[0x1bae2e]
LEA RCX,[0x1bdbf2]
MOV EDX,0x1c60
CALL 0x00118470
|
/* 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<long&>(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<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,long *param_1,bool param_2)
{
uint uVar1;
char *pcVar2;
char cVar3;
ulong uVar4;
ulong uVar5;
bool bVar6;
long lVar7;
int1 auVar8 [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 */
__assert_fail("!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
0x1c28,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
if ((*(ulong *)(*(long *)(this + 0x30) + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8) >> (uVar5 & 0x3f) &
1) == 0) {
uVar5 = 0;
lVar7 = 0;
goto LAB_0014d092;
}
local_58 = 0;
uStack_50 = 0;
external_constructor<(nlohmann::json_abi_v3_11_3::detail::value_t)5>::
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_0014cee2:
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;
bVar6 = 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(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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);
lVar7 = *(long *)this;
}
else {
pcVar2 = *(char **)(*(long *)(this + 0x10) + -8);
if (pcVar2 == (char *)0x0) goto LAB_0014d076;
if (*pcVar2 == '\x01') {
lVar7 = *(long *)(this + 0x58);
uVar1 = *(uint *)(this + 0x60);
if (uVar1 == 0 && *(long *)(this + 0x48) == lVar7) {
/* WARNING: Subroutine does not return */
__assert_fail("!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c57,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
uVar5 = (ulong)uVar1 - 1;
uVar4 = (ulong)uVar1 + 0x3e;
if (-1 < (long)uVar5) {
uVar4 = uVar5;
}
uVar4 = *(ulong *)(lVar7 + ((long)uVar4 >> 6) * 8 + -8 +
(ulong)((uVar5 & 0x800000000000003f) < 0x8000000000000001) * 8);
*(uint *)(this + 0x60) = uVar1 - 1;
if (uVar1 == 0) {
*(int4 *)(this + 0x60) = 0x3f;
*(long *)(this + 0x58) = lVar7 + -8;
}
if ((1L << ((byte)uVar5 & 0x3f) & uVar4) == 0) goto LAB_0014d076;
if (*(long *)(this + 0x70) == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c60,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = long &]"
);
}
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;
bVar6 = 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(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(bVar6);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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);
lVar7 = *(long *)(this + 0x70);
}
else {
if (*pcVar2 != '\x02') {
/* WARNING: Subroutine does not return */
__assert_fail("ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp"
,0x1c4b,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value = 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>>>
::
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),(basic_json *)&local_58);
lVar7 = *(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 */
std::__throw_bad_function_call();
}
/* try { // try from 0014cec5 to 0014d0c5 has its CatchHandler @ 0014d123 */
cVar3 = (**(code **)(this + 0x98))(this + 0x80,&local_5c,&local_5d,&local_58);
if (cVar3 != '\0') goto LAB_0014cee2;
LAB_0014d076:
uVar5 = 0;
lVar7 = 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_0014d092:
auVar8._0_8_ = uVar5 & 0xffffffff;
auVar8._8_8_ = lVar7;
return auVar8;
}
| |
22,972 | 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x45ec3
cmpl $0x0, 0x38(%rbx)
je 0x4601a
leaq 0x20(%rbx), %rdi
callq 0x442a8
testq %rdx, (%rax)
je 0x45f5d
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2b1d0
testb %bpl, %bpl
jne 0x45f0e
leaq 0x80(%rbx), %rdi
movq 0x10(%rbx), %rsi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
pushq $0x5
popq %rdx
leaq 0x8(%rsp), %rcx
callq 0x442d6
testb %al, %al
je 0x45ffb
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x45f67
movq -0x8(%rax), %rax
testq %rax, %rax
je 0x45ffb
movzbl (%rax), %ecx
cmpl $0x1, %ecx
je 0x45f91
cmpl $0x2, %ecx
jne 0x46039
movq 0x8(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3c71c
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %r14
addq $-0x10, %r14
jmp 0x45ff7
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x4600a
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3b352
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x429ca
movq %r14, %rdi
callq 0x2b1f0
movq (%rbx), %r14
jmp 0x45ff7
movq 0x48(%rbx), %rax
cmpq 0x58(%rbx), %rax
jne 0x45fa5
cmpl $0x0, 0x60(%rbx)
je 0x46058
leaq 0x48(%rbx), %rdi
callq 0x442a8
movq %rdx, %r14
leaq 0x58(%rbx), %rdi
movq (%rax), %r15
callq 0x4393c
testq %r14, %r15
je 0x45ffb
cmpq $0x0, 0x70(%rbx)
je 0x46077
leaq 0x18(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3b352
movq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x429ca
movq %r14, %rdi
callq 0x2b1f0
movq 0x70(%rbx), %r14
movb $0x1, %bl
jmp 0x46000
xorl %ebx, %ebx
xorl %r14d, %r14d
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
movl %ebx, %eax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5612c(%rip), %rdi # 0x9c14d
leaq 0x53e06(%rip), %rsi # 0x99e2e
leaq 0x56adb(%rip), %rcx # 0x9cb0a
movl $0x1c28, %edx # imm = 0x1C28
callq 0x204a0
leaq 0x56223(%rip), %rdi # 0x9c263
leaq 0x53de7(%rip), %rsi # 0x99e2e
leaq 0x56abc(%rip), %rcx # 0x9cb0a
movl $0x1c4b, %edx # imm = 0x1C4B
callq 0x204a0
leaq 0x56242(%rip), %rdi # 0x9c2a1
leaq 0x53dc8(%rip), %rsi # 0x99e2e
leaq 0x56a9d(%rip), %rcx # 0x9cb0a
movl $0x1c57, %edx # imm = 0x1C57
callq 0x204a0
leaq 0x5623b(%rip), %rdi # 0x9c2b9
leaq 0x53da9(%rip), %rsi # 0x99e2e
leaq 0x56a7e(%rip), %rcx # 0x9cb0a
movl $0x1c60, %edx # imm = 0x1C60
callq 0x204a0
jmp 0x46098
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2b1f0
movq %rbx, %rdi
callq 0x20b90
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE12handle_valueIDnEESt4pairIbPSF_EOT_b:
push rbp
push r15
push r14
push rbx
sub rsp, 38h
mov ebp, edx
mov rbx, rdi
mov rax, [rdi+20h]
cmp rax, [rdi+30h]
jnz short loc_45EC3
cmp dword ptr [rbx+38h], 0
jz loc_4601A
loc_45EC3:
lea rdi, [rbx+20h]
call _ZNSt6vectorIbSaIbEE4backEv; std::vector<bool>::back(void)
test [rax], rdx
jz loc_45F5D
lea rdi, [rsp+58h+var_50]
xor esi, esi
call _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))
test bpl, bpl
jnz short loc_45F0E
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_45FFB
loc_45F0E:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz short loc_45F67
mov rax, [rax-8]
test rax, rax
jz loc_45FFB
movzx ecx, byte ptr [rax]
cmp ecx, 1
jz short loc_45F91
cmp ecx, 2
jnz loc_46039
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_45FF7
loc_45F5D:
xor ebx, ebx
xor r14d, r14d
jmp loc_4600A
loc_45F67:
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_45FF7
loc_45F91:
mov rax, [rbx+48h]
cmp rax, [rbx+58h]
jnz short loc_45FA5
cmp dword ptr [rbx+60h], 0
jz loc_46058
loc_45FA5:
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_45FFB
cmp qword ptr [rbx+70h], 0
jz loc_46077
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_45FF7:
mov bl, 1
jmp short loc_46000
loc_45FFB:
xor ebx, ebx
xor r14d, r14d
loc_46000:
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_4600A:
mov eax, ebx
mov rdx, r14
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_4601A:
lea rdi, aKeepStackEmpty; "!keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C28h
call ___assert_fail
loc_46039:
lea rdi, aRefStackBackIs; "ref_stack.back()->is_array() || ref_sta"...
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C4Bh
call ___assert_fail
loc_46058:
lea rdi, aKeyKeepStackEm; "!key_keep_stack.empty()"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C57h
call ___assert_fail
loc_46077:
lea rdi, aObjectElement; "object_element"
lea rsi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aStdPairBoolBas_2; "std::pair<bool, BasicJsonType *> nlohma"...
mov edx, 1C60h
call ___assert_fail
jmp short $+2
loc_46098:
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<decltype(nullptr)>(
long long a1,
long long 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
_BYTE v15[16]; // [rsp+8h] [rbp-50h] BYREF
__int128 v16; // [rsp+18h] [rbp-40h] BYREF
_OWORD v17[3]; // [rsp+28h] [rbp-30h] BYREF
v4 = a1;
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
__assert_fail(
"!keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7208LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohmann::ord"
"ered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered_map>, Value"
" = std::nullptr_t]");
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((long long)v15);
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(
v17,
(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>::operator=(
*(_QWORD *)a1,
(long long)v17);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v17);
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)v15);
return v4;
}
v8 = *(unsigned __int8 **)(v7 - 8);
if ( v8 )
{
v9 = *v8;
if ( v9 != 1 )
{
if ( v9 != 2 )
__assert_fail(
"ref_stack.back()->is_array() || ref_stack.back()->is_object()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7243LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::nullptr_t]");
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),
(long long)v15);
goto LABEL_18;
}
if ( *(_QWORD *)(a1 + 72) == *(_QWORD *)(a1 + 88) && !*(_DWORD *)(a1 + 96) )
__assert_fail(
"!key_keep_stack.empty()",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7255LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohman"
"n::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ordered"
"_map>, Value = std::nullptr_t]");
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) )
__assert_fail(
"object_element",
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/./json.hpp",
7264LL,
"std::pair<bool, BasicJsonType *> nlohmann::detail::json_sax_dom_callback_parser<nlohmann::basic_json<nlohm"
"ann::ordered_map>>::handle_value(Value &&, const bool) [BasicJsonType = nlohmann::basic_json<nlohmann::ord"
"ered_map>, Value = std::nullptr_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>::basic_json(
&v16,
(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>::operator=(
*(_QWORD *)(a1 + 112),
(long long)&v16);
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)&v16);
goto LABEL_18;
}
}
}
v4 = 0;
goto LABEL_20;
}
return 0;
}
| |||
22,973 | Trie::Trie() | MikePodsytnik[P]TCRtrie/src/Trie.cpp | Trie::Trie() : root_(nullptr) {} | O3 | cpp | Trie::Trie():
movabsq $0x400000004, %rax # imm = 0x400000004
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
movl $0x20, 0xc(%rdi)
leaq 0x40(%rdi), %rax
movq %rax, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x3f800000, 0x30(%rdi) # imm = 0x3F800000
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
retq
nop
| _ZN4TrieC2Ev:
mov rax, 400000004h
mov [rdi], rax
mov byte ptr [rdi+8], 0
mov dword ptr [rdi+0Ch], 20h ; ' '
lea rax, [rdi+40h]
mov [rdi+10h], rax
mov qword ptr [rdi+18h], 1
xorps xmm0, xmm0
movups xmmword ptr [rdi+20h], xmm0
mov dword ptr [rdi+30h], 3F800000h
movups xmmword ptr [rdi+38h], xmm0
movups xmmword ptr [rdi+48h], xmm0
movups xmmword ptr [rdi+58h], xmm0
retn
| void Trie::Trie(Trie *this)
{
*(_QWORD *)this = 0x400000004LL;
*((_BYTE *)this + 8) = 0;
*((_DWORD *)this + 3) = 32;
*((_QWORD *)this + 2) = (char *)this + 64;
*((_QWORD *)this + 3) = 1LL;
*((_OWORD *)this + 2) = 0LL;
*((_DWORD *)this + 12) = 1065353216;
*(_OWORD *)((char *)this + 56) = 0LL;
*(_OWORD *)((char *)this + 72) = 0LL;
*(_OWORD *)((char *)this + 88) = 0LL;
}
| Trie:
MOV RAX,0x400000004
MOV qword ptr [RDI],RAX
MOV byte ptr [RDI + 0x8],0x0
MOV dword ptr [RDI + 0xc],0x20
LEA RAX,[RDI + 0x40]
MOV qword ptr [RDI + 0x10],RAX
MOV qword ptr [RDI + 0x18],0x1
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOV dword ptr [RDI + 0x30],0x3f800000
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOVUPS xmmword ptr [RDI + 0x58],XMM0
RET
|
/* Trie::Trie() */
void __thiscall Trie::Trie(Trie *this)
{
*(int8 *)this = 0x400000004;
this[8] = (Trie)0x0;
*(int4 *)(this + 0xc) = 0x20;
*(Trie **)(this + 0x10) = this + 0x40;
*(int8 *)(this + 0x18) = 1;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int4 *)(this + 0x30) = 0x3f800000;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
*(int8 *)(this + 0x60) = 0;
return;
}
| |
22,974 | httpparse_get_multipart_separator | navaro[P]qoraal-tictactoe/build_O3/_deps/qoraal_http-src/src/httpparse.c | char*
httpparse_get_multipart_separator( const HTTP_HEADER_T* headers,int headers_count)
{
char * separator = 0 ;
int i ;
// multipart/form-data; boundary=-------------------------7df19e1f9006a2
for (i=0; i<headers_count; i++) {
if (strcmp(headers[i].key, HTTP_HEADER_KEY_CONTENT_TYPE) == 0) {
separator = strstr (headers[i].value, "boundary=") ;
if (separator) {
separator = strchr (separator, '=') ;
if (separator) separator++ ;
}
DBG_MESSAGE_HTTP_PARSE (DBG_MESSAGE_SEVERITY_REPORT,
"httpparse_content : content-type %s : %s",
headers[i].value, separator ? separator : "(separator not found)") ;
break ;
}
}
return separator ;
} | O3 | c | httpparse_get_multipart_separator:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x1ec72
movq %rdi, %r14
movl %esi, %r12d
shlq $0x4, %r12
xorl %ebx, %ebx
leaq 0x13cfb(%rip), %r15 # 0x3294f
xorl %r13d, %r13d
movq (%r14,%r13), %rdi
movq %r15, %rsi
callq 0x6320
testl %eax, %eax
je 0x1ec76
addq $0x10, %r13
cmpq %r13, %r12
jne 0x1ec57
jmp 0x1ecd1
xorl %ebx, %ebx
jmp 0x1ecd1
movq 0x8(%r14,%r13), %r14
leaq 0x140b4(%rip), %rsi # 0x32d36
movq %r14, %rdi
callq 0x6590
testq %rax, %rax
je 0x1eca9
movq %rax, %rdi
movl $0x3d, %esi
callq 0x61d0
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %rax, %rbx
jmp 0x1ecab
xorl %ebx, %ebx
testq %rbx, %rbx
leaq 0x140b4(%rip), %r8 # 0x32d69
cmovneq %rbx, %r8
leaq 0x14080(%rip), %rdx # 0x32d40
movl $0x4, %edi
xorl %esi, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x160ad
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| httpparse_get_multipart_separator:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
test esi, esi
jle short loc_1EC72
mov r14, rdi
mov r12d, esi
shl r12, 4
xor ebx, ebx
lea r15, aContentType; "Content-Type"
xor r13d, r13d
loc_1EC57:
mov rdi, [r14+r13]
mov rsi, r15
call _strcmp
test eax, eax
jz short loc_1EC76
add r13, 10h
cmp r12, r13
jnz short loc_1EC57
jmp short loc_1ECD1
loc_1EC72:
xor ebx, ebx
jmp short loc_1ECD1
loc_1EC76:
mov r14, [r14+r13+8]
lea rsi, aBoundary; "boundary="
mov rdi, r14
call _strstr
test rax, rax
jz short loc_1ECA9
mov rdi, rax
mov esi, 3Dh ; '='
call _strchr
lea rbx, [rax+1]
test rax, rax
cmovz rbx, rax
jmp short loc_1ECAB
loc_1ECA9:
xor ebx, ebx
loc_1ECAB:
test rbx, rbx
lea r8, aSeparatorNotFo; "(separator not found)"
cmovnz r8, rbx
lea rdx, aHttpparseConte; "httpparse_content : content-type %s : %"...
mov edi, 4
xor esi, esi
mov rcx, r14
xor eax, eax
call svc_logger_type_log
loc_1ECD1:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| char * httpparse_get_multipart_separator(
long long a1,
int a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
char v10; // al
char *v11; // rbx
long long v12; // r13
long long v13; // r14
long long v14; // rax
long long v15; // r9
__m128 v16; // xmm4
__m128 v17; // xmm5
long long v18; // rax
char *v19; // r8
char v21; // [rsp-8h] [rbp-30h]
v21 = v10;
if ( a2 <= 0 )
return 0LL;
v11 = 0LL;
v12 = 0LL;
while ( (unsigned int)strcmp(*(_QWORD *)(a1 + v12), aContentType) )
{
v12 += 16LL;
if ( 16LL * (unsigned int)a2 == v12 )
return v11;
}
v13 = *(_QWORD *)(a1 + v12 + 8);
v14 = strstr(v13, aBoundary);
if ( v14 )
{
v18 = strchr(v14, 61LL);
v11 = (char *)(v18 + 1);
if ( !v18 )
v11 = 0LL;
}
else
{
v11 = 0LL;
}
v19 = aSeparatorNotFo;
if ( v11 )
v19 = v11;
svc_logger_type_log(4LL, 0, (long long)aHttpparseConte, v13, (long long)v19, v15, a3, a4, a5, a6, v16, v17, a9, a10, v21);
return v11;
}
| httpparse_get_multipart_separator:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
TEST ESI,ESI
JLE 0x0011ec72
MOV R14,RDI
MOV R12D,ESI
SHL R12,0x4
XOR EBX,EBX
LEA R15,[0x13294f]
XOR R13D,R13D
LAB_0011ec57:
MOV RDI,qword ptr [R14 + R13*0x1]
MOV RSI,R15
CALL 0x00106320
TEST EAX,EAX
JZ 0x0011ec76
ADD R13,0x10
CMP R12,R13
JNZ 0x0011ec57
JMP 0x0011ecd1
LAB_0011ec72:
XOR EBX,EBX
JMP 0x0011ecd1
LAB_0011ec76:
MOV R14,qword ptr [R14 + R13*0x1 + 0x8]
LEA RSI,[0x132d36]
MOV RDI,R14
CALL 0x00106590
TEST RAX,RAX
JZ 0x0011eca9
MOV RDI,RAX
MOV ESI,0x3d
CALL 0x001061d0
LEA RBX,[RAX + 0x1]
TEST RAX,RAX
CMOVZ RBX,RAX
JMP 0x0011ecab
LAB_0011eca9:
XOR EBX,EBX
LAB_0011ecab:
TEST RBX,RBX
LEA R8,[0x132d69]
CMOVNZ R8,RBX
LEA RDX,[0x132d40]
MOV EDI,0x4
XOR ESI,ESI
MOV RCX,R14
XOR EAX,EAX
CALL 0x001160ad
LAB_0011ecd1:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
char * httpparse_get_multipart_separator(long param_1,uint param_2)
{
char *__haystack;
int iVar1;
char *pcVar2;
char *pcVar3;
long lVar4;
if (0 < (int)param_2) {
lVar4 = 0;
do {
iVar1 = strcmp(*(char **)(param_1 + lVar4),s_Content_Type_0013294f);
if (iVar1 == 0) {
__haystack = *(char **)(param_1 + 8 + lVar4);
pcVar2 = strstr(__haystack,s_boundary__00132d36);
if (pcVar2 == (char *)0x0) {
pcVar2 = (char *)0x0;
}
else {
pcVar3 = strchr(pcVar2,0x3d);
pcVar2 = pcVar3 + 1;
if (pcVar3 == (char *)0x0) {
pcVar2 = (char *)0x0;
}
}
pcVar3 = s__separator_not_found__00132d69;
if (pcVar2 != (char *)0x0) {
pcVar3 = pcVar2;
}
svc_logger_type_log(4,0,s_httpparse_content___content_type_00132d40,__haystack,pcVar3);
return pcVar2;
}
lVar4 = lVar4 + 0x10;
} while ((ulong)param_2 << 4 != lVar4);
}
return (char *)0x0;
}
| |
22,975 | my_rw_trywrlock | eloqsql/mysys/thr_rwlock.c | int my_rw_trywrlock(my_rw_lock_t *rwp)
{
int res;
pthread_mutex_lock(&rwp->lock);
if (rwp->state)
res= EBUSY; /* Can't get lock */
else
{
res=0;
rwp->state = -1;
#ifdef SAFE_MUTEX
rwp->write_thread= pthread_self();
#endif
}
pthread_mutex_unlock(&rwp->lock);
return(res);
} | O0 | c | my_rw_trywrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x264b0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x5f99b
movl $0x10, -0xc(%rbp)
jmp 0x5f9b0
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x26260
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_rw_trywrlock:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
call _pthread_mutex_lock
mov rax, [rbp+var_8]
cmp dword ptr [rax+88h], 0
jz short loc_5F99B
mov [rbp+var_C], 10h
jmp short loc_5F9B0
loc_5F99B:
mov [rbp+var_C], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+88h], 0FFFFFFFFh
loc_5F9B0:
mov rdi, [rbp+var_8]
call _pthread_mutex_unlock
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
| long long my_rw_trywrlock(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-Ch]
pthread_mutex_lock(a1);
if ( *(_DWORD *)(a1 + 136) )
{
v2 = 16;
}
else
{
v2 = 0;
*(_DWORD *)(a1 + 136) = -1;
}
pthread_mutex_unlock(a1);
return v2;
}
| my_rw_trywrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001264b0
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x88],0x0
JZ 0x0015f99b
MOV dword ptr [RBP + -0xc],0x10
JMP 0x0015f9b0
LAB_0015f99b:
MOV dword ptr [RBP + -0xc],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x88],0xffffffff
LAB_0015f9b0:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00126260
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int4 my_rw_trywrlock(pthread_mutex_t *param_1)
{
int4 local_14;
pthread_mutex_lock(param_1);
if (*(int *)((long)param_1 + 0x88) == 0) {
local_14 = 0;
*(int4 *)((long)param_1 + 0x88) = 0xffffffff;
}
else {
local_14 = 0x10;
}
pthread_mutex_unlock(param_1);
return local_14;
}
| |
22,976 | my_well_formed_char_length_8bit | eloqsql/strings/ctype-simple.c | size_t
my_well_formed_char_length_8bit(CHARSET_INFO *cs __attribute__((unused)),
const char *start, const char *end,
size_t nchars, MY_STRCOPY_STATUS *status)
{
size_t nbytes= (size_t) (end - start);
size_t res= MY_MIN(nbytes, nchars);
status->m_well_formed_error_pos= NULL;
status->m_source_end_pos= start + res;
return res;
} | O0 | c | my_well_formed_char_length_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x7beeb
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x7bef3
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
addq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
popq %rbp
retq
nopl (%rax)
| my_well_formed_char_length_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
cmp rax, [rbp+var_20]
jnb short loc_7BEEB
mov rax, [rbp+var_30]
mov [rbp+var_40], rax
jmp short loc_7BEF3
loc_7BEEB:
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
loc_7BEF3:
mov rax, [rbp+var_40]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov qword ptr [rax+8], 0
mov rcx, [rbp+var_10]
add rcx, [rbp+var_38]
mov rax, [rbp+var_28]
mov [rax], rcx
mov rax, [rbp+var_38]
pop rbp
retn
| unsigned long long my_well_formed_char_length_8bit(
long long a1,
long long a2,
long long a3,
unsigned long long a4,
_QWORD *a5)
{
unsigned long long v6; // [rsp+0h] [rbp-40h]
if ( a3 - a2 >= a4 )
v6 = a4;
else
v6 = a3 - a2;
a5[1] = 0LL;
*a5 = v6 + a2;
return v6;
}
| my_well_formed_char_length_8bit:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x0017beeb
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0017bef3
LAB_0017beeb:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
LAB_0017bef3:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX + 0x8],0x0
MOV RCX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x38]
POP RBP
RET
|
ulong my_well_formed_char_length_8bit
(int8 param_1,long param_2,long param_3,ulong param_4,long *param_5)
{
ulong local_48;
local_48 = param_4;
if ((ulong)(param_3 - param_2) < param_4) {
local_48 = param_3 - param_2;
}
param_5[1] = 0;
*param_5 = param_2 + local_48;
return local_48;
}
| |
22,977 | js_load_file | bluesky950520[P]quickjs/quickjs-libc.c | uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
{
FILE *f;
uint8_t *buf;
size_t buf_len;
long lret;
f = fopen(filename, "rb");
if (!f)
return NULL;
if (fseek(f, 0, SEEK_END) < 0)
goto fail;
lret = ftell(f);
if (lret < 0)
goto fail;
/* XXX: on Linux, ftell() return LONG_MAX for directories */
if (lret == LONG_MAX) {
errno = EISDIR;
goto fail;
}
buf_len = lret;
if (fseek(f, 0, SEEK_SET) < 0)
goto fail;
if (ctx)
buf = js_malloc(ctx, buf_len + 1);
else
buf = malloc(buf_len + 1);
if (!buf)
goto fail;
if (fread(buf, 1, buf_len, f) != buf_len) {
errno = EIO;
if (ctx)
js_free(ctx, buf);
else
free(buf);
fail:
fclose(f);
return NULL;
}
buf[buf_len] = '\0';
fclose(f);
*pbuf_len = buf_len;
return buf;
} | O0 | c | js_load_file:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0xf967d(%rip), %rsi # 0x1082ac
callq 0xe7b0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xec4f
movq $0x0, 0x40(%rsp)
jmp 0xeda0
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xe6b0
cmpl $0x0, %eax
jge 0xec6c
jmp 0xed5c
movq 0x20(%rsp), %rdi
callq 0xe550
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0xec88
jmp 0xed5c
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, 0x8(%rsp)
jne 0xeca9
callq 0xe0b0
movl $0x15, (%rax)
jmp 0xed5c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xe6b0
cmpl $0x0, %eax
jge 0xeccd
jmp 0xed5c
cmpq $0x0, 0x38(%rsp)
je 0xecef
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x209f0
movq %rax, 0x18(%rsp)
jmp 0xed02
movq 0x10(%rsp), %rdi
addq $0x1, %rdi
callq 0xe650
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xed0c
jmp 0xed5c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl $0x1, %esi
callq 0xe170
cmpq 0x10(%rsp), %rax
je 0xed71
callq 0xe0b0
movl $0x5, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0xed50
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20af0
jmp 0xed5a
movq 0x18(%rsp), %rdi
callq 0xe060
jmp 0xed5c
movq 0x20(%rsp), %rdi
callq 0xe220
movq $0x0, 0x40(%rsp)
jmp 0xeda0
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x20(%rsp), %rdi
callq 0xe220
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| js_load_file:
sub rsp, 48h
mov [rsp+48h+var_10], rdi
mov [rsp+48h+var_18], rsi
mov [rsp+48h+var_20], rdx
mov rdi, [rsp+48h+var_20]
lea rsi, unk_1082AC
call _fopen
mov [rsp+48h+var_28], rax
cmp [rsp+48h+var_28], 0
jnz short loc_EC4F
mov [rsp+48h+var_8], 0
jmp loc_EDA0
loc_EC4F:
mov rdi, [rsp+48h+var_28]
xor eax, eax
mov esi, eax
mov edx, 2
call _fseek
cmp eax, 0
jge short loc_EC6C
jmp loc_ED5C
loc_EC6C:
mov rdi, [rsp+48h+var_28]
call _ftell
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jge short loc_EC88
jmp loc_ED5C
loc_EC88:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rsp+48h+var_40], rax
jnz short loc_ECA9
call ___errno_location
mov dword ptr [rax], 15h
jmp loc_ED5C
loc_ECA9:
mov rax, [rsp+48h+var_40]
mov [rsp+48h+var_38], rax
mov rdi, [rsp+48h+var_28]
xor eax, eax
mov esi, eax
xor edx, edx
call _fseek
cmp eax, 0
jge short loc_ECCD
jmp loc_ED5C
loc_ECCD:
cmp [rsp+48h+var_10], 0
jz short loc_ECEF
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_38]
add rsi, 1
call js_malloc
mov [rsp+48h+var_30], rax
jmp short loc_ED02
loc_ECEF:
mov rdi, [rsp+48h+var_38]
add rdi, 1
call _malloc
mov [rsp+48h+var_30], rax
loc_ED02:
cmp [rsp+48h+var_30], 0
jnz short loc_ED0C
jmp short loc_ED5C
loc_ED0C:
mov rdi, [rsp+48h+var_30]
mov rdx, [rsp+48h+var_38]
mov rcx, [rsp+48h+var_28]
mov esi, 1
call _fread
cmp rax, [rsp+48h+var_38]
jz short loc_ED71
call ___errno_location
mov dword ptr [rax], 5
cmp [rsp+48h+var_10], 0
jz short loc_ED50
mov rdi, [rsp+48h+var_10]
mov rsi, [rsp+48h+var_30]
call js_free
jmp short loc_ED5A
loc_ED50:
mov rdi, [rsp+48h+var_30]
call _free
loc_ED5A:
jmp short $+2
loc_ED5C:
mov rdi, [rsp+48h+var_28]
call _fclose
mov [rsp+48h+var_8], 0
jmp short loc_EDA0
loc_ED71:
mov rax, [rsp+48h+var_30]
mov rcx, [rsp+48h+var_38]
mov byte ptr [rax+rcx], 0
mov rdi, [rsp+48h+var_28]
call _fclose
mov rcx, [rsp+48h+var_38]
mov rax, [rsp+48h+var_18]
mov [rax], rcx
mov rax, [rsp+48h+var_30]
mov [rsp+48h+var_8], rax
loc_EDA0:
mov rax, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_load_file(long long a1, long long *a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-40h]
long long v5; // [rsp+18h] [rbp-30h]
long long v6; // [rsp+20h] [rbp-28h]
v6 = fopen(a3, &unk_1082AC);
if ( !v6 )
return 0LL;
if ( (int)fseek(v6, 0LL, 2LL) >= 0 )
{
v4 = ftell(v6);
if ( v4 >= 0 )
{
if ( v4 == 0x7FFFFFFFFFFFFFFFLL )
{
*(_DWORD *)__errno_location() = 21;
}
else if ( (int)fseek(v6, 0LL, 0LL) >= 0 )
{
v5 = a1 ? js_malloc(a1, v4 + 1) : malloc(v4 + 1);
if ( v5 )
{
if ( fread(v5, 1LL, v4, v6) == v4 )
{
*(_BYTE *)(v5 + v4) = 0;
fclose(v6);
*a2 = v4;
return v5;
}
*(_DWORD *)__errno_location() = 5;
if ( a1 )
js_free(a1, v5);
else
free(v5);
}
}
}
}
fclose(v6);
return 0LL;
}
| js_load_file:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDI
MOV qword ptr [RSP + 0x30],RSI
MOV qword ptr [RSP + 0x28],RDX
MOV RDI,qword ptr [RSP + 0x28]
LEA RSI,[0x2082ac]
CALL 0x0010e7b0
MOV qword ptr [RSP + 0x20],RAX
CMP qword ptr [RSP + 0x20],0x0
JNZ 0x0010ec4f
MOV qword ptr [RSP + 0x40],0x0
JMP 0x0010eda0
LAB_0010ec4f:
MOV RDI,qword ptr [RSP + 0x20]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x2
CALL 0x0010e6b0
CMP EAX,0x0
JGE 0x0010ec6c
JMP 0x0010ed5c
LAB_0010ec6c:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0010e550
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JGE 0x0010ec88
JMP 0x0010ed5c
LAB_0010ec88:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RSP + 0x8],RAX
JNZ 0x0010eca9
CALL 0x0010e0b0
MOV dword ptr [RAX],0x15
JMP 0x0010ed5c
LAB_0010eca9:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RSP + 0x20]
XOR EAX,EAX
MOV ESI,EAX
XOR EDX,EDX
CALL 0x0010e6b0
CMP EAX,0x0
JGE 0x0010eccd
JMP 0x0010ed5c
LAB_0010eccd:
CMP qword ptr [RSP + 0x38],0x0
JZ 0x0010ecef
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x10]
ADD RSI,0x1
CALL 0x001209f0
MOV qword ptr [RSP + 0x18],RAX
JMP 0x0010ed02
LAB_0010ecef:
MOV RDI,qword ptr [RSP + 0x10]
ADD RDI,0x1
CALL 0x0010e650
MOV qword ptr [RSP + 0x18],RAX
LAB_0010ed02:
CMP qword ptr [RSP + 0x18],0x0
JNZ 0x0010ed0c
JMP 0x0010ed5c
LAB_0010ed0c:
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
MOV ESI,0x1
CALL 0x0010e170
CMP RAX,qword ptr [RSP + 0x10]
JZ 0x0010ed71
CALL 0x0010e0b0
MOV dword ptr [RAX],0x5
CMP qword ptr [RSP + 0x38],0x0
JZ 0x0010ed50
MOV RDI,qword ptr [RSP + 0x38]
MOV RSI,qword ptr [RSP + 0x18]
CALL 0x00120af0
JMP 0x0010ed5a
LAB_0010ed50:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0010e060
LAB_0010ed5a:
JMP 0x0010ed5c
LAB_0010ed5c:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0010e220
MOV qword ptr [RSP + 0x40],0x0
JMP 0x0010eda0
LAB_0010ed71:
MOV RAX,qword ptr [RSP + 0x18]
MOV RCX,qword ptr [RSP + 0x10]
MOV byte ptr [RAX + RCX*0x1],0x0
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0010e220
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x40],RAX
LAB_0010eda0:
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
void * js_load_file(long param_1,size_t *param_2,char *param_3)
{
int iVar1;
FILE *__stream;
size_t __n;
int *piVar2;
size_t sVar3;
void *local_30;
__stream = fopen(param_3,"rb");
if (__stream != (FILE *)0x0) {
iVar1 = fseek(__stream,0,2);
if ((-1 < iVar1) && (__n = ftell(__stream), -1 < (long)__n)) {
if (__n == 0x7fffffffffffffff) {
piVar2 = __errno_location();
*piVar2 = 0x15;
}
else {
iVar1 = fseek(__stream,0,0);
if (-1 < iVar1) {
if (param_1 == 0) {
local_30 = malloc(__n + 1);
}
else {
local_30 = (void *)js_malloc(param_1,__n + 1);
}
if (local_30 != (void *)0x0) {
sVar3 = fread(local_30,1,__n,__stream);
if (sVar3 == __n) {
*(int1 *)((long)local_30 + __n) = 0;
fclose(__stream);
*param_2 = __n;
return local_30;
}
piVar2 = __errno_location();
*piVar2 = 5;
if (param_1 == 0) {
free(local_30);
}
else {
js_free(param_1,local_30);
}
}
}
}
}
fclose(__stream);
}
return (void *)0x0;
}
| |
22,978 | js_load_file | bluesky950520[P]quickjs/quickjs-libc.c | uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
{
FILE *f;
uint8_t *buf;
size_t buf_len;
long lret;
f = fopen(filename, "rb");
if (!f)
return NULL;
if (fseek(f, 0, SEEK_END) < 0)
goto fail;
lret = ftell(f);
if (lret < 0)
goto fail;
/* XXX: on Linux, ftell() return LONG_MAX for directories */
if (lret == LONG_MAX) {
errno = EISDIR;
goto fail;
}
buf_len = lret;
if (fseek(f, 0, SEEK_SET) < 0)
goto fail;
if (ctx)
buf = js_malloc(ctx, buf_len + 1);
else
buf = malloc(buf_len + 1);
if (!buf)
goto fail;
if (fread(buf, 1, buf_len, f) != buf_len) {
errno = EIO;
if (ctx)
js_free(ctx, buf);
else
free(buf);
fail:
fclose(f);
return NULL;
}
buf[buf_len] = '\0';
fclose(f);
*pbuf_len = buf_len;
return buf;
} | O3 | c | js_load_file:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x88c3e(%rip), %rsi # 0x9d1c8
movq %rdx, %rdi
callq 0xe7c0
testq %rax, %rax
je 0x14674
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xe6c0
testl %eax, %eax
js 0x1466c
movq %rbx, %rdi
callq 0xe550
testq %rax, %rax
js 0x1466c
movq %rax, %r12
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %r12
jne 0x145e8
callq 0xe0b0
movl $0x15, (%rax)
jmp 0x1466c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xe6c0
testl %eax, %eax
js 0x1466c
leaq 0x1(%r12), %rsi
testq %r14, %r14
je 0x1460c
movq %r14, %rdi
callq 0xed89
jmp 0x14614
movq %rsi, %rdi
callq 0xe650
movq %rax, %r13
testq %rax, %rax
je 0x1466c
movl $0x1, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0xe170
cmpq %r12, %rax
jne 0x14647
movb $0x0, (%r13,%r12)
movq %rbx, %rdi
callq 0xe220
movq %r12, (%r15)
jmp 0x14677
callq 0xe0b0
movl $0x5, (%rax)
testq %r14, %r14
je 0x14664
movq %r14, %rdi
movq %r13, %rsi
callq 0x1c845
jmp 0x1466c
movq %r13, %rdi
callq 0xe060
movq %rbx, %rdi
callq 0xe220
xorl %r13d, %r13d
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| js_load_file:
push r15
push r14
push r13
push r12
push rbx
mov r15, rsi
mov r14, rdi
lea rsi, unk_9D1C8
mov rdi, rdx
call _fopen
test rax, rax
jz loc_14674
mov rbx, rax
mov rdi, rax
xor esi, esi
mov edx, 2
call _fseek
test eax, eax
js loc_1466C
mov rdi, rbx
call _ftell
test rax, rax
js loc_1466C
mov r12, rax
mov rax, 7FFFFFFFFFFFFFFFh
cmp r12, rax
jnz short loc_145E8
call ___errno_location
mov dword ptr [rax], 15h
jmp loc_1466C
loc_145E8:
mov rdi, rbx
xor esi, esi
xor edx, edx
call _fseek
test eax, eax
js short loc_1466C
lea rsi, [r12+1]
test r14, r14
jz short loc_1460C
mov rdi, r14
call js_malloc
jmp short loc_14614
loc_1460C:
mov rdi, rsi
call _malloc
loc_14614:
mov r13, rax
test rax, rax
jz short loc_1466C
mov esi, 1
mov rdi, r13
mov rdx, r12
mov rcx, rbx
call _fread
cmp rax, r12
jnz short loc_14647
mov byte ptr [r13+r12+0], 0
mov rdi, rbx
call _fclose
mov [r15], r12
jmp short loc_14677
loc_14647:
call ___errno_location
mov dword ptr [rax], 5
test r14, r14
jz short loc_14664
mov rdi, r14
mov rsi, r13
call js_free
jmp short loc_1466C
loc_14664:
mov rdi, r13
call _free
loc_1466C:
mov rdi, rbx
call _fclose
loc_14674:
xor r13d, r13d
loc_14677:
mov rax, r13
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long js_load_file(long long a1, long long *a2, long long a3)
{
long long v3; // rax
long long v4; // rbx
long long v5; // rax
long long v6; // r12
long long v7; // rax
long long v8; // r13
v3 = fopen(a3, &unk_9D1C8);
if ( !v3 )
return 0LL;
v4 = v3;
if ( (int)fseek(v3, 0LL, 2LL) < 0 || (v5 = ftell(v4), v5 < 0) )
{
LABEL_16:
fclose(v4);
return 0LL;
}
v6 = v5;
if ( v5 == 0x7FFFFFFFFFFFFFFFLL )
{
*(_DWORD *)__errno_location() = 21;
goto LABEL_16;
}
if ( (int)fseek(v4, 0LL, 0LL) < 0 )
goto LABEL_16;
v7 = a1 ? js_malloc(a1, v6 + 1) : malloc(v6 + 1);
v8 = v7;
if ( !v7 )
goto LABEL_16;
if ( fread(v7, 1LL, v6, v4) != v6 )
{
*(_DWORD *)__errno_location() = 5;
if ( a1 )
js_free(a1, v8);
else
free(v8);
goto LABEL_16;
}
*(_BYTE *)(v8 + v6) = 0;
fclose(v4);
*a2 = v6;
return v8;
}
| js_load_file:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV R15,RSI
MOV R14,RDI
LEA RSI,[0x19d1c8]
MOV RDI,RDX
CALL 0x0010e7c0
TEST RAX,RAX
JZ 0x00114674
MOV RBX,RAX
MOV RDI,RAX
XOR ESI,ESI
MOV EDX,0x2
CALL 0x0010e6c0
TEST EAX,EAX
JS 0x0011466c
MOV RDI,RBX
CALL 0x0010e550
TEST RAX,RAX
JS 0x0011466c
MOV R12,RAX
MOV RAX,0x7fffffffffffffff
CMP R12,RAX
JNZ 0x001145e8
CALL 0x0010e0b0
MOV dword ptr [RAX],0x15
JMP 0x0011466c
LAB_001145e8:
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
CALL 0x0010e6c0
TEST EAX,EAX
JS 0x0011466c
LEA RSI,[R12 + 0x1]
TEST R14,R14
JZ 0x0011460c
MOV RDI,R14
CALL 0x0010ed89
JMP 0x00114614
LAB_0011460c:
MOV RDI,RSI
CALL 0x0010e650
LAB_00114614:
MOV R13,RAX
TEST RAX,RAX
JZ 0x0011466c
MOV ESI,0x1
MOV RDI,R13
MOV RDX,R12
MOV RCX,RBX
CALL 0x0010e170
CMP RAX,R12
JNZ 0x00114647
MOV byte ptr [R13 + R12*0x1],0x0
MOV RDI,RBX
CALL 0x0010e220
MOV qword ptr [R15],R12
JMP 0x00114677
LAB_00114647:
CALL 0x0010e0b0
MOV dword ptr [RAX],0x5
TEST R14,R14
JZ 0x00114664
MOV RDI,R14
MOV RSI,R13
CALL 0x0011c845
JMP 0x0011466c
LAB_00114664:
MOV RDI,R13
CALL 0x0010e060
LAB_0011466c:
MOV RDI,RBX
CALL 0x0010e220
LAB_00114674:
XOR R13D,R13D
LAB_00114677:
MOV RAX,R13
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
void * js_load_file(long param_1,size_t *param_2,char *param_3)
{
int iVar1;
FILE *__stream;
size_t __n;
int *piVar2;
void *__ptr;
size_t sVar3;
__stream = fopen(param_3,"rb");
if (__stream != (FILE *)0x0) {
iVar1 = fseek(__stream,0,2);
if ((-1 < iVar1) && (__n = ftell(__stream), -1 < (long)__n)) {
if (__n == 0x7fffffffffffffff) {
piVar2 = __errno_location();
*piVar2 = 0x15;
}
else {
iVar1 = fseek(__stream,0,0);
if (-1 < iVar1) {
if (param_1 == 0) {
__ptr = malloc(__n + 1);
}
else {
__ptr = (void *)js_malloc(param_1);
}
if (__ptr != (void *)0x0) {
sVar3 = fread(__ptr,1,__n,__stream);
if (sVar3 == __n) {
*(int1 *)((long)__ptr + __n) = 0;
fclose(__stream);
*param_2 = __n;
return __ptr;
}
piVar2 = __errno_location();
*piVar2 = 5;
if (param_1 == 0) {
free(__ptr);
}
else {
js_free(param_1,__ptr);
}
}
}
}
}
fclose(__stream);
}
return (void *)0x0;
}
| |
22,979 | minja::VariableExpr::~VariableExpr() | monkey531[P]llama/common/minja.hpp | VariableExpr(const Location & location, const std::string& n)
: Expression(location), name(n) {} | O3 | cpp | minja::VariableExpr::~VariableExpr():
pushq %rbx
movq %rdi, %rbx
leaq 0x91f71(%rip), %rax # 0x129dc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0x97e6e
movq (%rax), %rsi
incq %rsi
callq 0x1a8e0
leaq 0x91543(%rip), %rax # 0x1293b8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x97e8a
callq 0x6cd76
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8e0
| _ZN5minja12VariableExprD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja12VariableExprE; `vtable for'minja::VariableExpr
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+20h]; void *
lea rax, [rbx+30h]
cmp rdi, rax
jz short loc_97E6E
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_97E6E:
lea rax, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_97E8A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_97E8A:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::VariableExpr::~VariableExpr(minja::VariableExpr *this)
{
char *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::VariableExpr + 2;
v2 = (char *)*((_QWORD *)this + 4);
if ( v2 != (char *)this + 48 )
operator delete(v2, *((_QWORD *)this + 6) + 1LL);
*(_QWORD *)this = &`vtable for'minja::Expression + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~VariableExpr:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x229dc0]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x20]
LEA RAX,[RBX + 0x30]
CMP RDI,RAX
JZ 0x00197e6e
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0011a8e0
LAB_00197e6e:
LEA RAX,[0x2293b8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x00197e8a
CALL 0x0016cd76
LAB_00197e8a:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011a8e0
|
/* minja::VariableExpr::~VariableExpr() */
void __thiscall minja::VariableExpr::~VariableExpr(VariableExpr *this)
{
*(int ***)this = &PTR_do_evaluate_00229dd0;
if (*(VariableExpr **)(this + 0x20) != this + 0x30) {
operator_delete(*(VariableExpr **)(this + 0x20),*(long *)(this + 0x30) + 1);
}
*(int ***)this = &PTR___cxa_pure_virtual_002293c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_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 + 0x10));
}
operator_delete(this,0x40);
return;
}
| |
22,980 | 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
}
} | O1 | 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):
cmpl $0x10, %edi
ja 0x6e87c
movl %edi, %eax
leaq 0x8f784(%rip), %rcx # 0xfdff8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x8e99f(%rip), %rax # 0xfd222
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_6E87C
mov eax, edi
lea rcx, unk_FDFF8
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_6E87C:
lea rax, aUnknownToken; "unknown token"
retn
| const 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(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_FDFF8 + dword_FDFF8[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x0016e87c
MOV EAX,EDI
LEA RCX,[0x1fdff8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_0016e87c:
LEA RAX,[0x1fd222]
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(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001fdff8 + *(int *)(&DAT_001fdff8 + (ulong)param_1 * 4);
}
return "unknown token";
}
| |
22,981 | 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
}
} | O2 | 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):
cmpl $0x10, %edi
ja 0x50b84
movl %edi, %eax
leaq 0x6d43c(%rip), %rcx # 0xbdfb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq 0x6c659(%rip), %rax # 0xbd1e4
retq
| _ZN8nlohmann16json_abi_v3_11_36detail10lexer_baseINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15token_type_nameENSG_10token_typeE:
cmp edi, 10h
ja short loc_50B84
mov eax, edi
lea rcx, unk_BDFB8
movsxd rax, dword ptr [rcx+rax*4]
add rax, rcx
retn
loc_50B84:
lea rax, aUnknownToken; "unknown token"
retn
| const 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(
unsigned int a1)
{
if ( a1 > 0x10 )
return "unknown token";
else
return (char *)dword_BDFB8 + dword_BDFB8[a1];
}
| token_type_name:
CMP EDI,0x10
JA 0x00150b84
MOV EAX,EDI
LEA RCX,[0x1bdfb8]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
RET
LAB_00150b84:
LEA RAX,[0x1bd1e4]
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(uint param_1)
{
if (param_1 < 0x11) {
return &DAT_001bdfb8 + *(int *)(&DAT_001bdfb8 + (ulong)param_1 * 4);
}
return "unknown token";
}
| |
22,982 | ma_bin_search | eloqsql/storage/maria/ma_search.c | int _ma_bin_search(const MARIA_KEY *key, const MARIA_PAGE *ma_page,
uint32 comp_flag, uchar **ret_pos,
uchar *buff __attribute__((unused)), my_bool *last_key)
{
int UNINIT_VAR(flag);
uint page_flag;
uint start, mid, end, save_end, totlength, nod_flag;
uint not_used[2];
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_SHARE *share= keyinfo->share;
uchar *page;
DBUG_ENTER("_ma_bin_search");
page_flag= ma_page->flag;
if (page_flag & KEYPAGE_FLAG_HAS_TRANSID)
{
/* Keys have varying length, can't use binary search */
DBUG_RETURN(_ma_seq_search(key, ma_page, comp_flag, ret_pos, buff,
last_key));
}
nod_flag= ma_page->node;
totlength= keyinfo->keylength + nod_flag;
DBUG_ASSERT(ma_page->size >= share->keypage_header + nod_flag + totlength);
start=0;
mid=1;
save_end= end= ((ma_page->size - nod_flag - share->keypage_header) /
totlength-1);
DBUG_PRINT("test",("page_length: %u end: %u", ma_page->size, end));
page= ma_page->buff + share->keypage_header + nod_flag;
while (start != end)
{
mid= (start+end)/2;
if ((flag=ha_key_cmp(keyinfo->seg, page + (uint) mid * totlength,
key->data, key->data_length + key->ref_length,
comp_flag, not_used))
>= 0)
end=mid;
else
start=mid+1;
}
if (mid != start)
flag=ha_key_cmp(keyinfo->seg, page + (uint) start * totlength,
key->data, key->data_length + key->ref_length, comp_flag,
not_used);
if (flag < 0)
start++; /* point at next, bigger key */
*ret_pos= (page + (uint) start * totlength);
*last_key= end == save_end;
DBUG_PRINT("exit",("flag: %d keypos: %d",flag,start));
DBUG_RETURN(flag);
} | O3 | c | ma_bin_search:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %rbx
movq %rcx, %r14
movl %edx, %r10d
movq %rdi, %r9
testb $0x2, 0x2c(%rsi)
jne 0x6c872
movq 0x8(%r9), %rdx
movq (%rdx), %rcx
movl 0x20(%rsi), %eax
movl 0x28(%rsi), %edi
movq %rdx, -0x40(%rbp)
movzwl 0xaa(%rdx), %r13d
addl %edi, %r13d
movl 0x744(%rcx), %r12d
subl %r12d, %eax
subl %edi, %eax
xorl %edx, %edx
divl %r13d
addq 0x10(%rsi), %r12
xorl %r15d, %r15d
addq %rdi, %r12
decl %eax
movl %eax, -0x2c(%rbp)
je 0x6c81e
movq %r12, -0x38(%rbp)
movq %r14, -0x48(%rbp)
movq %rbx, -0x50(%rbp)
xorl %ecx, %ecx
movl -0x2c(%rbp), %eax
movl %eax, %r14d
movl %r13d, -0x30(%rbp)
leal (%rcx,%r14), %ebx
shrl %ebx
movq -0x40(%rbp), %rax
movq 0xc0(%rax), %rdi
movl %ebx, %esi
imull %r13d, %esi
addq -0x38(%rbp), %rsi
movq (%r9), %rdx
movq %rcx, %r15
movl 0x14(%r9), %ecx
movq %r9, %r12
addl 0x10(%r9), %ecx
movl %r10d, %r13d
movl %r10d, %r8d
leaq -0x58(%rbp), %r9
callq 0x9e826
movq %r15, %rcx
movl %ebx, %r15d
testl %eax, %eax
jns 0x6c7fb
leal 0x1(%rbx), %ecx
movl %r14d, %r15d
movl %r15d, %r14d
cmpl %r15d, %ecx
movl %r13d, %r10d
movl -0x30(%rbp), %r13d
movq %r12, %r9
jne 0x6c7b0
cmpl %r15d, %ebx
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r14
movq -0x38(%rbp), %r12
je 0x6c84a
movq -0x40(%rbp), %rax
movq 0xc0(%rax), %rdi
movl %r15d, %esi
imull %r13d, %esi
addq %r12, %rsi
movq (%r9), %rdx
movl 0x14(%r9), %ecx
addl 0x10(%r9), %ecx
leaq -0x58(%rbp), %r9
movl %r10d, %r8d
callq 0x9e826
movl %eax, %ecx
shrl $0x1f, %ecx
addl %r15d, %ecx
imull %r13d, %ecx
addq %rcx, %r12
movq %r12, (%r14)
cmpl -0x2c(%rbp), %r15d
sete (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %rdi
movl %r10d, %edx
movq %r14, %rcx
movq %rbx, %r9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6c891
| _ma_bin_search:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, r9
mov r14, rcx
mov r10d, edx
mov r9, rdi
test byte ptr [rsi+2Ch], 2
jnz loc_6C872
mov rdx, [r9+8]
mov rcx, [rdx]
mov eax, [rsi+20h]
mov edi, [rsi+28h]
mov [rbp+var_40], rdx
movzx r13d, word ptr [rdx+0AAh]
add r13d, edi
mov r12d, [rcx+744h]
sub eax, r12d
sub eax, edi
xor edx, edx
div r13d
add r12, [rsi+10h]
xor r15d, r15d
add r12, rdi
dec eax
mov [rbp+var_2C], eax
jz loc_6C81E
mov [rbp+var_38], r12
mov [rbp+var_48], r14
mov [rbp+var_50], rbx
xor ecx, ecx
mov eax, [rbp+var_2C]
mov r14d, eax
mov [rbp+var_30], r13d
loc_6C7B0:
lea ebx, [rcx+r14]
shr ebx, 1
mov rax, [rbp+var_40]
mov rdi, [rax+0C0h]
mov esi, ebx
imul esi, r13d
add rsi, [rbp+var_38]
mov rdx, [r9]
mov r15, rcx
mov ecx, [r9+14h]
mov r12, r9
add ecx, [r9+10h]
mov r13d, r10d
mov r8d, r10d
lea r9, [rbp+var_58]
call ha_key_cmp
mov rcx, r15
mov r15d, ebx
test eax, eax
jns short loc_6C7FB
lea ecx, [rbx+1]
mov r15d, r14d
loc_6C7FB:
mov r14d, r15d
cmp ecx, r15d
mov r10d, r13d
mov r13d, [rbp+var_30]
mov r9, r12
jnz short loc_6C7B0
cmp ebx, r15d
mov rbx, [rbp+var_50]
mov r14, [rbp+var_48]
mov r12, [rbp+var_38]
jz short loc_6C84A
loc_6C81E:
mov rax, [rbp+var_40]
mov rdi, [rax+0C0h]
mov esi, r15d
imul esi, r13d
add rsi, r12
mov rdx, [r9]
mov ecx, [r9+14h]
add ecx, [r9+10h]
lea r9, [rbp+var_58]
mov r8d, r10d
call ha_key_cmp
loc_6C84A:
mov ecx, eax
shr ecx, 1Fh
add ecx, r15d
imul ecx, r13d
add r12, rcx
mov [r14], r12
cmp r15d, [rbp+var_2C]
setz byte ptr [rbx]
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6C872:
mov rdi, r9
mov edx, r10d
mov rcx, r14
mov r9, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp $+5
| long long ma_bin_search(_QWORD *a1, long long a2, unsigned int a3, _QWORD *a4, long long a5, bool *a6)
{
_QWORD *v7; // r14
unsigned int v8; // r10d
_QWORD *v9; // r9
long long *v10; // rdx
long long v11; // rcx
int v12; // eax
long long v13; // rdi
unsigned int v14; // r13d
long long v15; // r12
unsigned int v16; // eax
unsigned int v17; // r15d
long long v18; // r12
long long v19; // rcx
unsigned int v20; // r14d
unsigned int v21; // ebx
long long v22; // rsi
long long v23; // r15
_QWORD *v24; // r12
unsigned int v25; // r13d
long long result; // rax
bool v27; // zf
char v28[8]; // [rsp+8h] [rbp-58h] BYREF
bool *v29; // [rsp+10h] [rbp-50h]
_QWORD *v30; // [rsp+18h] [rbp-48h]
long long v31; // [rsp+20h] [rbp-40h]
long long v32; // [rsp+28h] [rbp-38h]
unsigned int v33; // [rsp+30h] [rbp-30h]
unsigned int v34; // [rsp+34h] [rbp-2Ch]
v7 = a4;
v8 = a3;
v9 = a1;
if ( (*(_BYTE *)(a2 + 44) & 2) != 0 )
return ma_seq_search(a1, a2, a3, a4, a5, a6);
v10 = (long long *)a1[1];
v11 = *v10;
v12 = *(_DWORD *)(a2 + 32);
v13 = *(unsigned int *)(a2 + 40);
v31 = v9[1];
v14 = v13 + *((unsigned __int16 *)v10 + 85);
v15 = *(unsigned int *)(v11 + 1860);
v16 = (v12 - (int)v15 - (int)v13) / v14;
v17 = 0;
v18 = v13 + *(_QWORD *)(a2 + 16) + v15;
v34 = v16 - 1;
if ( v16 == 1 )
goto LABEL_8;
v32 = v18;
v30 = v7;
v29 = a6;
v19 = 0LL;
v20 = v34;
v33 = v14;
do
{
v21 = ((unsigned int)v19 + v20) >> 1;
v22 = v32 + v14 * v21;
v23 = v19;
v24 = v9;
v25 = v8;
result = ha_key_cmp(
*(_QWORD *)(v31 + 192),
v22,
*v9,
(unsigned int)(*((_DWORD *)v9 + 4) + *((_DWORD *)v9 + 5)),
v8,
v28);
v19 = v23;
v17 = v21;
if ( (int)result < 0 )
{
v19 = v21 + 1;
v17 = v20;
}
v20 = v17;
v8 = v25;
v14 = v33;
v9 = v24;
}
while ( (_DWORD)v19 != v17 );
v27 = v21 == v17;
a6 = v29;
v7 = v30;
v18 = v32;
if ( !v27 )
LABEL_8:
result = ha_key_cmp(
*(_QWORD *)(v31 + 192),
v18 + v14 * v17,
*v9,
(unsigned int)(*((_DWORD *)v9 + 4) + *((_DWORD *)v9 + 5)),
v8,
v28);
*v7 = v14 * (v17 + ((unsigned int)result >> 31)) + v18;
*a6 = v17 == v34;
return result;
}
| _ma_bin_search:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,R9
MOV R14,RCX
MOV R10D,EDX
MOV R9,RDI
TEST byte ptr [RSI + 0x2c],0x2
JNZ 0x0016c872
MOV RDX,qword ptr [R9 + 0x8]
MOV RCX,qword ptr [RDX]
MOV EAX,dword ptr [RSI + 0x20]
MOV EDI,dword ptr [RSI + 0x28]
MOV qword ptr [RBP + -0x40],RDX
MOVZX R13D,word ptr [RDX + 0xaa]
ADD R13D,EDI
MOV R12D,dword ptr [RCX + 0x744]
SUB EAX,R12D
SUB EAX,EDI
XOR EDX,EDX
DIV R13D
ADD R12,qword ptr [RSI + 0x10]
XOR R15D,R15D
ADD R12,RDI
DEC EAX
MOV dword ptr [RBP + -0x2c],EAX
JZ 0x0016c81e
MOV qword ptr [RBP + -0x38],R12
MOV qword ptr [RBP + -0x48],R14
MOV qword ptr [RBP + -0x50],RBX
XOR ECX,ECX
MOV EAX,dword ptr [RBP + -0x2c]
MOV R14D,EAX
MOV dword ptr [RBP + -0x30],R13D
LAB_0016c7b0:
LEA EBX,[RCX + R14*0x1]
SHR EBX,0x1
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0xc0]
MOV ESI,EBX
IMUL ESI,R13D
ADD RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [R9]
MOV R15,RCX
MOV ECX,dword ptr [R9 + 0x14]
MOV R12,R9
ADD ECX,dword ptr [R9 + 0x10]
MOV R13D,R10D
MOV R8D,R10D
LEA R9,[RBP + -0x58]
CALL 0x0019e826
MOV RCX,R15
MOV R15D,EBX
TEST EAX,EAX
JNS 0x0016c7fb
LEA ECX,[RBX + 0x1]
MOV R15D,R14D
LAB_0016c7fb:
MOV R14D,R15D
CMP ECX,R15D
MOV R10D,R13D
MOV R13D,dword ptr [RBP + -0x30]
MOV R9,R12
JNZ 0x0016c7b0
CMP EBX,R15D
MOV RBX,qword ptr [RBP + -0x50]
MOV R14,qword ptr [RBP + -0x48]
MOV R12,qword ptr [RBP + -0x38]
JZ 0x0016c84a
LAB_0016c81e:
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,qword ptr [RAX + 0xc0]
MOV ESI,R15D
IMUL ESI,R13D
ADD RSI,R12
MOV RDX,qword ptr [R9]
MOV ECX,dword ptr [R9 + 0x14]
ADD ECX,dword ptr [R9 + 0x10]
LEA R9,[RBP + -0x58]
MOV R8D,R10D
CALL 0x0019e826
LAB_0016c84a:
MOV ECX,EAX
SHR ECX,0x1f
ADD ECX,R15D
IMUL ECX,R13D
ADD R12,RCX
MOV qword ptr [R14],R12
CMP R15D,dword ptr [RBP + -0x2c]
SETZ byte ptr [RBX]
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016c872:
MOV RDI,R9
MOV EDX,R10D
MOV RCX,R14
MOV R9,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0016c891
|
void _ma_bin_search(int8 *param_1,long param_2,int4 param_3,long *param_4,
int8 param_5,int8 param_6)
{
uint uVar1;
int iVar2;
uint uVar3;
uint uVar4;
long lVar5;
uint uVar6;
int1 local_60 [8];
int8 local_58;
long *local_50;
long *local_48;
long local_40;
uint local_38;
uint local_34;
if ((*(byte *)(param_2 + 0x2c) & 2) != 0) {
_ma_seq_search(param_1,param_2,param_3,param_4,param_5,param_6);
return;
}
local_48 = (long *)param_1[1];
uVar3 = *(uint *)(param_2 + 0x28);
uVar6 = *(ushort *)((long)local_48 + 0xaa) + uVar3;
lVar5 = (ulong)*(uint *)(*local_48 + 0x744) + *(long *)(param_2 + 0x10) + (ulong)uVar3;
uVar1 = ((*(int *)(param_2 + 0x20) - *(uint *)(*local_48 + 0x744)) - uVar3) / uVar6 - 1;
uVar3 = 0;
local_34 = uVar1;
if (uVar1 != 0) {
uVar3 = 0;
local_58 = param_6;
local_50 = param_4;
local_40 = lVar5;
local_38 = uVar6;
do {
uVar4 = uVar3 + uVar1 >> 1;
iVar2 = ha_key_cmp(local_48[0x18],(ulong)(uVar4 * local_38) + local_40,*param_1,
*(int *)((long)param_1 + 0x14) + *(int *)(param_1 + 2),param_3,local_60);
uVar6 = uVar4;
if (iVar2 < 0) {
uVar3 = uVar4 + 1;
uVar6 = uVar1;
}
uVar1 = uVar6;
} while (uVar3 != uVar1);
param_6 = local_58;
lVar5 = local_40;
param_4 = local_50;
uVar6 = local_38;
uVar3 = uVar1;
if (uVar4 == uVar1) goto LAB_0016c84a;
}
iVar2 = ha_key_cmp(local_48[0x18],(ulong)(uVar3 * uVar6) + lVar5,*param_1,
*(int *)((long)param_1 + 0x14) + *(int *)(param_1 + 2),param_3,local_60);
local_58 = param_6;
local_50 = param_4;
LAB_0016c84a:
*local_50 = lVar5 + (ulong)((uVar3 - (iVar2 >> 0x1f)) * uVar6);
*(bool *)local_58 = uVar3 == local_34;
return;
}
| |
22,983 | my_hash_sort_bin | eloqsql/strings/ctype-bin.c | void my_hash_sort_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,ulong *nr1, ulong *nr2)
{
const uchar *end = key + len;
ulong tmp1= *nr1;
ulong tmp2= *nr2;
for (; key < end ; key++)
{
MY_HASH_ADD(tmp1, tmp2, (uint) *key);
}
*nr1= tmp1;
*nr2= tmp2;
} | O0 | c | my_hash_sort_bin:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x89b7e
jmp 0x89b36
movq -0x38(%rbp), %rax
andq $0x3f, %rax
addq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x38(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0x89b70
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x89b2a
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_bin:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_30], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_40], rax
loc_89B2A:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_30]
jnb short loc_89B7E
jmp short $+2
loc_89B36:
mov rax, [rbp+var_38]
and rax, 3Fh
add rax, [rbp+var_40]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx]
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_38]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_38]
mov [rbp+var_38], rax
mov rax, [rbp+var_40]
add rax, 3
mov [rbp+var_40], rax
jmp short $+2
loc_89B70:
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_89B2A
loc_89B7E:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_40]
mov rax, [rbp+var_28]
mov [rax], rcx
pop rbp
retn
| _QWORD * my_hash_sort_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, _QWORD *a5)
{
_QWORD *result; // rax
long long v6; // [rsp+0h] [rbp-40h]
long long v7; // [rsp+8h] [rbp-38h]
unsigned __int8 *v8; // [rsp+30h] [rbp-10h]
v8 = a2;
v7 = *a4;
v6 = *a5;
while ( v8 < &a2[a3] )
{
v7 ^= (v7 << 8) + *v8 * (v6 + (v7 & 0x3F));
v6 += 3LL;
++v8;
}
*a4 = v7;
result = a5;
*a5 = v6;
return result;
}
| my_hash_sort_bin:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
LAB_00189b2a:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x30]
JNC 0x00189b7e
JMP 0x00189b36
LAB_00189b36:
MOV RAX,qword ptr [RBP + -0x38]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX]
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x38]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
JMP 0x00189b70
LAB_00189b70:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00189b2a
LAB_00189b7e:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
POP RBP
RET
|
void my_hash_sort_bin(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
long local_48;
ulong local_40;
byte *local_18;
local_40 = *param_4;
local_48 = *param_5;
for (local_18 = param_2; local_18 < param_2 + param_3; local_18 = local_18 + 1) {
local_40 = ((local_40 & 0x3f) + local_48) * (ulong)*local_18 + local_40 * 0x100 ^ local_40;
local_48 = local_48 + 3;
}
*param_4 = local_40;
*param_5 = local_48;
return;
}
| |
22,984 | common_sampler_free(common_sampler*) | monkey531[P]llama/common/sampling.cpp | void common_sampler_free(struct common_sampler * gsmpl) {
if (gsmpl) {
llama_sampler_free(gsmpl->grmr);
llama_sampler_free(gsmpl->chain);
delete gsmpl;
}
} | O3 | cpp | common_sampler_free(common_sampler*):
testq %rdi, %rdi
je 0xcd096
pushq %rbx
movq %rdi, %rbx
movq 0x138(%rdi), %rdi
callq 0x1a750
movq 0x140(%rbx), %rdi
callq 0x1a750
movq 0x180(%rbx), %rdi
testq %rdi, %rdi
je 0xcd065
movq 0x190(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a8c0
movq 0x168(%rbx), %rdi
testq %rdi, %rdi
je 0xcd080
movq 0x178(%rbx), %rsi
subq %rdi, %rsi
callq 0x1a8c0
movq %rbx, %rdi
callq 0x21774
movl $0x1b8, %esi # imm = 0x1B8
movq %rbx, %rdi
popq %rbx
jmp 0x1a8c0
retq
| _Z19common_sampler_freeP14common_sampler:
test rdi, rdi
jz short locret_CD096
push rbx
mov rbx, rdi
mov rdi, [rdi+138h]
call _llama_sampler_free
mov rdi, [rbx+140h]
call _llama_sampler_free
mov rdi, [rbx+180h]; void *
test rdi, rdi
jz short loc_CD065
mov rsi, [rbx+190h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD065:
mov rdi, [rbx+168h]; void *
test rdi, rdi
jz short loc_CD080
mov rsi, [rbx+178h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_CD080:
mov rdi, rbx; this
call _ZN22common_params_samplingD2Ev; common_params_sampling::~common_params_sampling()
mov esi, 1B8h; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
locret_CD096:
retn
| void common_sampler_free(common_params_sampling *this)
{
void *v2; // rdi
void *v3; // rdi
if ( this )
{
llama_sampler_free(*((_QWORD *)this + 39));
llama_sampler_free(*((_QWORD *)this + 40));
v2 = (void *)*((_QWORD *)this + 48);
if ( v2 )
operator delete(v2, *((_QWORD *)this + 50) - (_QWORD)v2);
v3 = (void *)*((_QWORD *)this + 45);
if ( v3 )
operator delete(v3, *((_QWORD *)this + 47) - (_QWORD)v3);
common_params_sampling::~common_params_sampling(this);
operator delete(this, 0x1B8uLL);
}
}
| common_sampler_free:
TEST RDI,RDI
JZ 0x001cd096
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x138]
CALL 0x0011a750
MOV RDI,qword ptr [RBX + 0x140]
CALL 0x0011a750
MOV RDI,qword ptr [RBX + 0x180]
TEST RDI,RDI
JZ 0x001cd065
MOV RSI,qword ptr [RBX + 0x190]
SUB RSI,RDI
CALL 0x0011a8c0
LAB_001cd065:
MOV RDI,qword ptr [RBX + 0x168]
TEST RDI,RDI
JZ 0x001cd080
MOV RSI,qword ptr [RBX + 0x178]
SUB RSI,RDI
CALL 0x0011a8c0
LAB_001cd080:
MOV RDI,RBX
CALL 0x00121774
MOV ESI,0x1b8
MOV RDI,RBX
POP RBX
JMP 0x0011a8c0
LAB_001cd096:
RET
|
/* common_sampler_free(common_sampler*) */
void common_sampler_free(common_sampler *param_1)
{
void *pvVar1;
if (param_1 != (common_sampler *)0x0) {
llama_sampler_free(*(int8 *)(param_1 + 0x138));
llama_sampler_free(*(int8 *)(param_1 + 0x140));
pvVar1 = *(void **)(param_1 + 0x180);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(param_1 + 400) - (long)pvVar1);
}
pvVar1 = *(void **)(param_1 + 0x168);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(param_1 + 0x178) - (long)pvVar1);
}
common_params_sampling::~common_params_sampling((common_params_sampling *)param_1);
operator_delete(param_1,0x1b8);
return;
}
return;
}
| |
22,985 | blst_p1_serialize | corpus-core[P]colibri-stateless/build_O2/_deps/blst-src/src/e1.c | void blst_p1_serialize(unsigned char out[96], const POINTonE1 *in)
{ POINTonE1_Serialize(out, in); } | O2 | c | blst_p1_serialize:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsi), %rdi
pushq $0x30
popq %rsi
callq 0x510f5
testq %rax, %rax
je 0x5137c
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x512c5
movb $0x40, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x525c9
| blst_p1_serialize:
push rbp
mov rbp, rsp
push r14
push rbx
mov r14, rsi
mov rbx, rdi
lea rdi, [rsi+60h]
push 30h ; '0'
pop rsi
call vec_is_zero
test rax, rax
jz short loc_5137C
push 60h ; '`'
pop rsi
mov rdi, rbx
call bytes_zero
mov byte ptr [rbx], 40h ; '@'
pop rbx
pop r14
pop rbp
retn
loc_5137C:
mov rdi, rbx
mov rsi, r14
pop rbx
pop r14
pop rbp
jmp POINTonE1_Serialize_BE
| long long blst_p1_serialize(_BYTE *a1, long long a2)
{
long long result; // rax
if ( !vec_is_zero(a2 + 96, 0x30uLL) )
return POINTonE1_Serialize_BE(a1, a2);
result = bytes_zero((long long)a1, 96LL);
*a1 = 64;
return result;
}
| blst_p1_serialize:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
LEA RDI,[RSI + 0x60]
PUSH 0x30
POP RSI
CALL 0x001510f5
TEST RAX,RAX
JZ 0x0015137c
PUSH 0x60
POP RSI
MOV RDI,RBX
CALL 0x001512c5
MOV byte ptr [RBX],0x40
POP RBX
POP R14
POP RBP
RET
LAB_0015137c:
MOV RDI,RBX
MOV RSI,R14
POP RBX
POP R14
POP RBP
JMP 0x001525c9
|
void blst_p1_serialize(int1 *param_1,long param_2)
{
long lVar1;
lVar1 = vec_is_zero(param_2 + 0x60,0x30);
if (lVar1 != 0) {
bytes_zero(param_1,0x60);
*param_1 = 0x40;
return;
}
POINTonE1_Serialize_BE(param_1,param_2);
return;
}
| |
22,986 | ggml_concat | ngxson[P]ggml-easy/ggml/src/ggml.c | struct ggml_tensor * ggml_concat(
struct ggml_context * ctx,
struct ggml_tensor * a,
struct ggml_tensor * b,
int dim) {
GGML_ASSERT(dim >= 0 && dim < GGML_MAX_DIMS);
GGML_ASSERT(a->type == b->type);
int64_t ne[GGML_MAX_DIMS];
for (int d = 0; d < GGML_MAX_DIMS; ++d) {
if (d == dim) {
ne[d] = a->ne[d] + b->ne[d];
continue;
}
GGML_ASSERT(a->ne[d] == b->ne[d]);
ne[d] = a->ne[d];
}
struct ggml_tensor * result = ggml_new_tensor(ctx, a->type, GGML_MAX_DIMS, ne);
ggml_set_op_params_i32(result, 0, dim);
result->op = GGML_OP_CONCAT;
result->src[0] = a;
result->src[1] = b;
return result;
} | O2 | c | ggml_concat:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpl $0x4, %ecx
jae 0x20ebd
movq %rdx, %rbx
movq %rsi, %r14
movl (%rsi), %esi
cmpl (%rdx), %esi
jne 0x20ed9
movl %ecx, %ebp
movl %ecx, %eax
leaq (,%rax,8), %rcx
xorl %edx, %edx
cmpq $0x20, %rdx
je 0x20e70
cmpq %rdx, %rcx
jne 0x20e5a
movq 0x10(%rbx,%rax,8), %r8
addq 0x10(%r14,%rax,8), %r8
movq %r8, (%rsp,%rax,8)
jmp 0x20e6a
movq 0x10(%r14,%rdx), %r8
cmpq 0x10(%rbx,%rdx), %r8
jne 0x20e9c
movq %r8, (%rsp,%rdx)
addq $0x8, %rdx
jmp 0x20e3f
pushq $0x4
popq %rdx
movq %rsp, %rcx
callq 0x1c230
movl %ebp, 0x54(%rax)
movl $0x14, 0x50(%rax)
movq %r14, 0x98(%rax)
movq %rbx, 0xa0(%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2a6e0(%rip), %rdi # 0x4b583
leaq 0x2a724(%rip), %rdx # 0x4b5ce
leaq 0x2a8e5(%rip), %rcx # 0x4b796
movl $0x930, %esi # imm = 0x930
xorl %eax, %eax
callq 0x1e770
leaq 0x2a6bf(%rip), %rdi # 0x4b583
leaq 0x2a703(%rip), %rdx # 0x4b5ce
leaq 0x2a891(%rip), %rcx # 0x4b763
movl $0x927, %esi # imm = 0x927
jmp 0x20eb6
leaq 0x2a6a3(%rip), %rdi # 0x4b583
leaq 0x2a6e7(%rip), %rdx # 0x4b5ce
leaq 0x2a895(%rip), %rcx # 0x4b783
movl $0x928, %esi # imm = 0x928
jmp 0x20eb6
| ggml_concat:
push rbp
push r14
push rbx
sub rsp, 20h
cmp ecx, 4
jnb loc_20EBD
mov rbx, rdx
mov r14, rsi
mov esi, [rsi]
cmp esi, [rdx]
jnz loc_20ED9
mov ebp, ecx
mov eax, ecx
lea rcx, ds:0[rax*8]
xor edx, edx
loc_20E3F:
cmp rdx, 20h ; ' '
jz short loc_20E70
cmp rcx, rdx
jnz short loc_20E5A
mov r8, [rbx+rax*8+10h]
add r8, [r14+rax*8+10h]
mov [rsp+rax*8+38h+var_38], r8
jmp short loc_20E6A
loc_20E5A:
mov r8, [r14+rdx+10h]
cmp r8, [rbx+rdx+10h]
jnz short loc_20E9C
mov [rsp+rdx+38h+var_38], r8
loc_20E6A:
add rdx, 8
jmp short loc_20E3F
loc_20E70:
push 4
pop rdx
mov rcx, rsp
call _ggml_new_tensor
mov [rax+54h], ebp
mov dword ptr [rax+50h], 14h
mov [rax+98h], r14
mov [rax+0A0h], rbx
add rsp, 20h
pop rbx
pop r14
pop rbp
retn
loc_20E9C:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aANeDBNeD; "a->ne[d] == b->ne[d]"
mov esi, 930h
loc_20EB6:
xor eax, eax
call _ggml_abort
loc_20EBD:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aDim0DimGgmlMax; "dim >= 0 && dim < GGML_MAX_DIMS"
mov esi, 927h
jmp short loc_20EB6
loc_20ED9:
lea rdi, aWorkspaceLlm4b; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aATypeBType; "a->type == b->type"
mov esi, 928h
jmp short loc_20EB6
| long long ggml_concat(
long long a1,
unsigned int *a2,
_DWORD *a3,
unsigned int a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v16; // rsi
long long v18; // rax
long long v19; // rcx
unsigned long long i; // rdx
long long result; // rax
const char *v22; // rcx
int v23; // esi
_QWORD v24[7]; // [rsp+0h] [rbp-38h] BYREF
if ( a4 >= 4 )
{
v22 = "dim >= 0 && dim < GGML_MAX_DIMS";
v23 = 2343;
goto LABEL_12;
}
v16 = *a2;
if ( (_DWORD)v16 != *a3 )
{
v22 = "a->type == b->type";
v23 = 2344;
LABEL_12:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",
v23,
(long long)"GGML_ASSERT(%s) failed",
(long long)v22,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v24[0]);
}
v18 = a4;
v19 = 8LL * a4;
for ( i = 0LL; i != 32; i += 8LL )
{
if ( v19 == i )
{
v24[v18] = *(_QWORD *)&a2[2 * v18 + 4] + *(_QWORD *)&a3[2 * v18 + 4];
}
else
{
a5 = *(_QWORD *)&a2[i / 4 + 4];
if ( a5 != *(_QWORD *)&a3[i / 4 + 4] )
{
v22 = "a->ne[d] == b->ne[d]";
v23 = 2352;
goto LABEL_12;
}
v24[i / 8] = a5;
}
}
result = ggml_new_tensor(a1, v16, 4LL, (long long)v24);
*(_DWORD *)(result + 84) = a4;
*(_DWORD *)(result + 80) = 20;
*(_QWORD *)(result + 152) = a2;
*(_QWORD *)(result + 160) = a3;
return result;
}
| ggml_concat:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x20
CMP ECX,0x4
JNC 0x00120ebd
MOV RBX,RDX
MOV R14,RSI
MOV ESI,dword ptr [RSI]
CMP ESI,dword ptr [RDX]
JNZ 0x00120ed9
MOV EBP,ECX
MOV EAX,ECX
LEA RCX,[RAX*0x8]
XOR EDX,EDX
LAB_00120e3f:
CMP RDX,0x20
JZ 0x00120e70
CMP RCX,RDX
JNZ 0x00120e5a
MOV R8,qword ptr [RBX + RAX*0x8 + 0x10]
ADD R8,qword ptr [R14 + RAX*0x8 + 0x10]
MOV qword ptr [RSP + RAX*0x8],R8
JMP 0x00120e6a
LAB_00120e5a:
MOV R8,qword ptr [R14 + RDX*0x1 + 0x10]
CMP R8,qword ptr [RBX + RDX*0x1 + 0x10]
JNZ 0x00120e9c
MOV qword ptr [RSP + RDX*0x1],R8
LAB_00120e6a:
ADD RDX,0x8
JMP 0x00120e3f
LAB_00120e70:
PUSH 0x4
POP RDX
MOV RCX,RSP
CALL 0x0011c230
MOV dword ptr [RAX + 0x54],EBP
MOV dword ptr [RAX + 0x50],0x14
MOV qword ptr [RAX + 0x98],R14
MOV qword ptr [RAX + 0xa0],RBX
ADD RSP,0x20
POP RBX
POP R14
POP RBP
RET
LAB_00120e9c:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b796]
MOV ESI,0x930
LAB_00120eb6:
XOR EAX,EAX
CALL 0x0011e770
LAB_00120ebd:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b763]
MOV ESI,0x927
JMP 0x00120eb6
LAB_00120ed9:
LEA RDI,[0x14b583]
LEA RDX,[0x14b5ce]
LEA RCX,[0x14b783]
MOV ESI,0x928
JMP 0x00120eb6
|
void ggml_concat(int8 param_1,int *param_2,int *param_3,uint param_4)
{
int iVar1;
long lVar2;
ulong uVar3;
char *pcVar4;
long lVar5;
int8 uVar6;
long local_38 [4];
if (param_4 < 4) {
iVar1 = *param_2;
if (iVar1 == *param_3) {
uVar3 = (ulong)param_4;
lVar5 = 0;
do {
if (lVar5 == 0x20) {
lVar5 = ggml_new_tensor(param_1,iVar1,4,local_38);
*(uint *)(lVar5 + 0x54) = param_4;
*(int4 *)(lVar5 + 0x50) = 0x14;
*(int **)(lVar5 + 0x98) = param_2;
*(int **)(lVar5 + 0xa0) = param_3;
return;
}
if (uVar3 * 8 - lVar5 == 0) {
local_38[uVar3] = *(long *)(param_3 + uVar3 * 2 + 4) + *(long *)(param_2 + uVar3 * 2 + 4);
}
else {
lVar2 = *(long *)((long)param_2 + lVar5 + 0x10);
if (lVar2 != *(long *)((long)param_3 + lVar5 + 0x10)) {
pcVar4 = "a->ne[d] == b->ne[d]";
uVar6 = 0x930;
goto LAB_00120eb6;
}
*(long *)((long)local_38 + lVar5) = lVar2;
}
lVar5 = lVar5 + 8;
} while( true );
}
pcVar4 = "a->type == b->type";
uVar6 = 0x928;
}
else {
pcVar4 = "dim >= 0 && dim < GGML_MAX_DIMS";
uVar6 = 0x927;
}
LAB_00120eb6:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/ngxson[P]ggml-easy/ggml/src/ggml.c",uVar6,
"GGML_ASSERT(%s) failed",pcVar4);
}
| |
22,987 | rak_string_new | fabiosvm[P]rak/src/string.c | RakString *rak_string_new(RakError *err)
{
RakString *str = rak_memory_alloc(sizeof(*str), err);
if (!rak_is_ok(err)) return NULL;
rak_string_init(str, err);
if (rak_is_ok(err)) return str;
rak_memory_free(str);
return NULL;
} | O3 | c | rak_string_new:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
movq %r14, %rsi
callq 0x74a4
cmpb $0x1, (%r14)
jne 0x7e18
movq %rax, %rbx
movl $0x0, (%rax)
movl $0x8, %edi
movq %r14, %rsi
callq 0x74a4
cmpb $0x1, (%r14)
jne 0x7e10
movq $0x8, 0x8(%rbx)
movq %rax, 0x10(%rbx)
jmp 0x7e1a
movq %rbx, %rdi
callq 0x7504
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| rak_string_new:
push r14
push rbx
push rax
mov r14, rdi
mov edi, 18h
mov rsi, r14
call rak_memory_alloc
cmp byte ptr [r14], 1
jnz short loc_7E18
mov rbx, rax
mov dword ptr [rax], 0
mov edi, 8
mov rsi, r14
call rak_memory_alloc
cmp byte ptr [r14], 1
jnz short loc_7E10
mov qword ptr [rbx+8], 8
mov [rbx+10h], rax
jmp short loc_7E1A
loc_7E10:
mov rdi, rbx
call rak_memory_free
loc_7E18:
xor ebx, ebx
loc_7E1A:
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| long long rak_string_new(_BYTE *a1)
{
_DWORD *v1; // rax
long long v2; // rbx
long long v3; // rax
v1 = (_DWORD *)rak_memory_alloc(24LL, a1);
if ( *a1 != 1 )
return 0LL;
v2 = (long long)v1;
*v1 = 0;
v3 = rak_memory_alloc(8LL, a1);
if ( *a1 != 1 )
{
rak_memory_free(v2);
return 0LL;
}
*(_QWORD *)(v2 + 8) = 8LL;
*(_QWORD *)(v2 + 16) = v3;
return v2;
}
| rak_string_new:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV EDI,0x18
MOV RSI,R14
CALL 0x001074a4
CMP byte ptr [R14],0x1
JNZ 0x00107e18
MOV RBX,RAX
MOV dword ptr [RAX],0x0
MOV EDI,0x8
MOV RSI,R14
CALL 0x001074a4
CMP byte ptr [R14],0x1
JNZ 0x00107e10
MOV qword ptr [RBX + 0x8],0x8
MOV qword ptr [RBX + 0x10],RAX
JMP 0x00107e1a
LAB_00107e10:
MOV RDI,RBX
CALL 0x00107504
LAB_00107e18:
XOR EBX,EBX
LAB_00107e1a:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
int4 * rak_string_new(char *param_1)
{
int4 *__ptr;
int8 uVar1;
__ptr = (int4 *)rak_memory_alloc(0x18,param_1);
if (*param_1 == '\x01') {
*__ptr = 0;
uVar1 = rak_memory_alloc(8,param_1);
if (*param_1 == '\x01') {
*(int8 *)(__ptr + 2) = 8;
*(int8 *)(__ptr + 4) = uVar1;
return __ptr;
}
rak_memory_free(__ptr);
}
return (int4 *)0x0;
}
| |
22,988 | testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned int, int>(char const*, char const*, unsigned int const&, int const&) | AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/gtest.h | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression, const T1& lhs,
const T2& rhs) {
return EqFailure(lhs_expression, rhs_expression,
FormatForComparisonFailureMessage(lhs, rhs),
FormatForComparisonFailureMessage(rhs, lhs), false);
} | O3 | c | testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned int, int>(char const*, char const*, unsigned int const&, int const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x22e84
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x29898
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %r9d, %r9d
callq 0x5f456
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c0e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c104
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11120
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c136
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11120
jmp 0x2c136
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c151
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11120
movq %rbx, %rdi
callq 0x11760
nopl (%rax)
| _ZN7testing8internal18CmpHelperEQFailureIjiEENS_15AssertionResultEPKcS4_RKT_RKT0_:
push r15
push r14
push r12
push rbx
sub rsp, 48h
mov r12, r8
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rdi, [rsp+68h+var_40]
mov rsi, rcx
call _ZN7testing13PrintToStringIjEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<uint>(uint const&)
lea rdi, [rsp+68h+var_60]
mov rsi, r12
call _ZN7testing13PrintToStringIiEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<int>(int const&)
lea rcx, [rsp+68h+var_40]
lea r8, [rsp+68h+var_60]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
xor r9d, r9d
call _ZN7testing8internal9EqFailureEPKcS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_b; testing::internal::EqFailure(char const*,char const*,std::string const&,std::string const&,bool)
lea rax, [rsp+68h+var_50]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2C0E9
mov rsi, [rsp+68h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2C0E9:
lea rax, [rsp+68h+var_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2C104
mov rsi, [rsp+68h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2C104:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2C136
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_2C136
mov rbx, rax
loc_2C136:
lea rax, [rsp+arg_30]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_2C151
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_2C151:
mov rdi, rbx
call __Unwind_Resume
| long long testing::internal::CmpHelperEQFailure<unsigned int,int>(
long long a1,
long long a2,
long long a3,
unsigned int *a4,
unsigned int *a5)
{
void *v8[2]; // [rsp+8h] [rbp-60h] BYREF
long long v9; // [rsp+18h] [rbp-50h] BYREF
void *v10[2]; // [rsp+28h] [rbp-40h] BYREF
long long v11; // [rsp+38h] [rbp-30h] BYREF
testing::PrintToString<unsigned int>((long long)v10, a4);
testing::PrintToString<int>((long long)v8, a5);
testing::internal::EqFailure(a1, a2, a3, v10, v8, 0LL);
if ( v8[0] != &v9 )
operator delete(v8[0], v9 + 1);
if ( v10[0] != &v11 )
operator delete(v10[0], v11 + 1);
return a1;
}
| CmpHelperEQFailure<unsigned_int,int>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R12,R8
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RDI,[RSP + 0x28]
MOV RSI,RCX
CALL 0x00122e84
LAB_0012c0a6:
LEA RDI,[RSP + 0x8]
MOV RSI,R12
CALL 0x00129898
LAB_0012c0b3:
LEA RCX,[RSP + 0x28]
LEA R8,[RSP + 0x8]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
XOR R9D,R9D
CALL 0x0015f456
LAB_0012c0ce:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012c0e9
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00111120
LAB_0012c0e9:
LEA RAX,[RSP + 0x38]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0012c104
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x00111120
LAB_0012c104:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R14
POP R15
RET
|
/* testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned int, int>(char const*,
char const*, unsigned int const&, int const&) */
internal * __thiscall
testing::internal::CmpHelperEQFailure<unsigned_int,int>
(internal *this,char *param_1,char *param_2,uint *param_3,int *param_4)
{
long *local_60 [2];
long local_50 [2];
long *local_40 [2];
long local_30 [2];
PrintToString<unsigned_int>((uint *)local_40);
/* try { // try from 0012c0a6 to 0012c0b2 has its CatchHandler @ 0012c133 */
PrintToString<int>((testing *)local_60,param_4);
/* try { // try from 0012c0b3 to 0012c0cd has its CatchHandler @ 0012c113 */
EqFailure(this,param_1,param_2,(string *)local_40,(string *)local_60,false);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
return this;
}
| |
22,989 | end_pagecache | eloqsql/storage/maria/ma_pagecache.c | void end_pagecache(PAGECACHE *pagecache, my_bool cleanup)
{
DBUG_ENTER("end_pagecache");
DBUG_PRINT("enter", ("key_cache: %p", pagecache));
if (!pagecache->inited)
DBUG_VOID_RETURN;
if (pagecache->disk_blocks > 0)
{
#ifndef DBUG_OFF
check_pagecache_is_cleaned_up(pagecache);
#endif
if (pagecache->block_mem)
{
my_large_free(pagecache->block_mem, pagecache->mem_size);
pagecache->block_mem= NULL;
my_free(pagecache->block_root);
pagecache->block_root= NULL;
}
pagecache->disk_blocks= -1;
/* Reset blocks_changed to be safe if flush_all_key_blocks is called */
pagecache->blocks_changed= 0;
}
DBUG_PRINT("status", ("used: %zu changed: %zu w_requests: %llu "
"writes: %llu r_requests: %llu reads: %llu",
pagecache->blocks_used,
pagecache->global_blocks_changed,
pagecache->global_cache_w_requests,
pagecache->global_cache_write,
pagecache->global_cache_r_requests,
pagecache->global_cache_read));
if (cleanup)
{
my_hash_free(&pagecache->files_in_flush);
mysql_mutex_destroy(&pagecache->cache_lock);
pagecache->inited= pagecache->can_be_used= 0;
PAGECACHE_DEBUG_CLOSE;
}
DBUG_VOID_RETURN;
} | O0 | c | end_pagecache:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
jmp 0x2c5b4
movq -0x8(%rbp), %rax
cmpb $0x0, 0x1a8(%rax)
jne 0x2c5c8
jmp 0x2c5c3
jmp 0x2c682
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
jle 0x2c63e
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x2c626
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x101f30
movq -0x8(%rbp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0xf3be0
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq $-0x1, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
jmp 0x2c640
jmp 0x2c642
cmpb $0x0, -0x9(%rbp)
je 0x2c67e
movq -0x8(%rbp), %rdi
addq $0x1b0, %rdi # imm = 0x1B0
callq 0xddf80
movq -0x8(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2c690
movq -0x8(%rbp), %rax
movb $0x0, 0x1aa(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x1a8(%rax)
jmp 0x2c680
jmp 0x2c682
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| end_pagecache:
push rbp
mov rbp, rsp
sub rsp, 10h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
jmp short $+2
loc_2C5B4:
mov rax, [rbp+var_8]
cmp byte ptr [rax+1A8h], 0
jnz short loc_2C5C8
jmp short $+2
loc_2C5C3:
jmp loc_2C682
loc_2C5C8:
mov rax, [rbp+var_8]
cmp qword ptr [rax+40h], 0
jle short loc_2C63E
mov rax, [rbp+var_8]
cmp qword ptr [rax+0B0h], 0
jz short loc_2C626
mov rax, [rbp+var_8]
mov rdi, [rax+0B0h]
mov rax, [rbp+var_8]
mov rsi, [rax]
call my_large_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0B0h], 0
mov rax, [rbp+var_8]
mov rdi, [rax+0A8h]
call my_free
mov rax, [rbp+var_8]
mov qword ptr [rax+0A8h], 0
loc_2C626:
mov rax, [rbp+var_8]
mov qword ptr [rax+40h], 0FFFFFFFFFFFFFFFFh
mov rax, [rbp+var_8]
mov qword ptr [rax+58h], 0
loc_2C63E:
jmp short $+2
loc_2C640:
jmp short $+2
loc_2C642:
cmp [rbp+var_9], 0
jz short loc_2C67E
mov rdi, [rbp+var_8]
add rdi, 1B0h
call my_hash_free
mov rdi, [rbp+var_8]
add rdi, 0C8h
call inline_mysql_mutex_destroy
mov rax, [rbp+var_8]
mov byte ptr [rax+1AAh], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+1A8h], 0
loc_2C67E:
jmp short $+2
loc_2C680:
jmp short $+2
loc_2C682:
add rsp, 10h
pop rbp
retn
| long long end_pagecache(long long a1, char a2)
{
long long result; // rax
result = a1;
if ( *(_BYTE *)(a1 + 424) )
{
result = a1;
if ( *(long long *)(a1 + 64) > 0 )
{
if ( *(_QWORD *)(a1 + 176) )
{
my_large_free(*(_QWORD *)(a1 + 176), *(_QWORD *)a1);
*(_QWORD *)(a1 + 176) = 0LL;
my_free(*(_QWORD *)(a1 + 168));
*(_QWORD *)(a1 + 168) = 0LL;
}
*(_QWORD *)(a1 + 64) = -1LL;
result = a1;
*(_QWORD *)(a1 + 88) = 0LL;
}
if ( a2 )
{
my_hash_free(a1 + 432);
inline_mysql_mutex_destroy(a1 + 200);
*(_BYTE *)(a1 + 426) = 0;
result = a1;
*(_BYTE *)(a1 + 424) = 0;
}
}
return result;
}
| end_pagecache:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
JMP 0x0012c5b4
LAB_0012c5b4:
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x1a8],0x0
JNZ 0x0012c5c8
JMP 0x0012c5c3
LAB_0012c5c3:
JMP 0x0012c682
LAB_0012c5c8:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x40],0x0
JLE 0x0012c63e
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0xb0],0x0
JZ 0x0012c626
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xb0]
MOV RAX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RAX]
CALL 0x00201f30
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xb0],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0xa8]
CALL 0x001f3be0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa8],0x0
LAB_0012c626:
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x40],-0x1
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x58],0x0
LAB_0012c63e:
JMP 0x0012c640
LAB_0012c640:
JMP 0x0012c642
LAB_0012c642:
CMP byte ptr [RBP + -0x9],0x0
JZ 0x0012c67e
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x1b0
CALL 0x001ddf80
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0xc8
CALL 0x0012c690
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1aa],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x1a8],0x0
LAB_0012c67e:
JMP 0x0012c680
LAB_0012c680:
JMP 0x0012c682
LAB_0012c682:
ADD RSP,0x10
POP RBP
RET
|
void end_pagecache(int8 *param_1,char param_2)
{
if (*(char *)(param_1 + 0x35) != '\0') {
if (0 < (long)param_1[8]) {
if (param_1[0x16] != 0) {
my_large_free(param_1[0x16],*param_1);
param_1[0x16] = 0;
my_free(param_1[0x15]);
param_1[0x15] = 0;
}
param_1[8] = 0xffffffffffffffff;
param_1[0xb] = 0;
}
if (param_2 != '\0') {
my_hash_free(param_1 + 0x36);
inline_mysql_mutex_destroy(param_1 + 0x19);
*(int1 *)((long)param_1 + 0x1aa) = 0;
*(int1 *)(param_1 + 0x35) = 0;
}
}
return;
}
| |
22,990 | google::protobuf::FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal() const | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/descriptor.cc | void FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal() const {
auto* map = new FieldsByNameMap;
for (Symbol symbol : symbols_by_parent_) {
const FieldDescriptor* field = symbol.field_descriptor();
if (!field) continue;
(*map)[{FindParentForFieldsByMap(field), field->camelcase_name().c_str()}] =
field;
}
fields_by_camelcase_name_.store(map, std::memory_order_release);
} | O0 | cpp | google::protobuf::FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal() const:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x38, %edi
callq 0x13450
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0x33790
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x337a0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x337d0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x73410
testb $0x1, %al
jne 0x3395d
jmp 0x33a01
leaq 0x68(%rsp), %rdi
callq 0x73430
movq (%rax), %rax
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x73450
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x33988
jmp 0x339f2
movq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rsi
callq 0x335c0
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x73520
movq %rax, %rdi
callq 0x13190
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x734b0
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x33800
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x68(%rsp), %rdi
callq 0x734f0
jmp 0x33945
movq 0x20(%rsp), %rdi
addq $0x48, %rdi
movq 0x78(%rsp), %rsi
movl $0x3, %edx
callq 0x33830
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
| _ZNK6google8protobuf20FileDescriptorTables38FieldsByCamelcaseNamesLazyInitInternalEv:
sub rsp, 88h
mov [rsp+88h+var_8], rdi
mov rax, [rsp+88h+var_8]
mov [rsp+88h+var_68], rax
mov edi, 38h ; '8'; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax
mov [rsp+88h+var_70], rdi
call _ZNSt13unordered_mapISt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEPKNS4_15FieldDescriptorENS4_12_GLOBAL__N_121PointerStringPairHashESt8equal_toIS7_ESaIS0_IKS7_SA_EEEC2Ev; std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>>::unordered_map(void)
mov rcx, [rsp+88h+var_70]
mov rax, [rsp+88h+var_68]
mov [rsp+88h+var_10], rcx
mov [rsp+88h+var_18], rax
mov rdi, [rsp+88h+var_18]
call _ZNKSt13unordered_setIN6google8protobuf6SymbolENS1_12_GLOBAL__N_118SymbolByParentHashENS3_16SymbolByParentEqESaIS2_EE5beginEv; std::unordered_set<google::protobuf::Symbol,google::protobuf::`anonymous namespace'::SymbolByParentHash,google::protobuf::`anonymous namespace'::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>::begin(void)
mov [rsp+88h+var_20], rax
mov rdi, [rsp+88h+var_18]
call _ZNKSt13unordered_setIN6google8protobuf6SymbolENS1_12_GLOBAL__N_118SymbolByParentHashENS3_16SymbolByParentEqESaIS2_EE3endEv; std::unordered_set<google::protobuf::Symbol,google::protobuf::`anonymous namespace'::SymbolByParentHash,google::protobuf::`anonymous namespace'::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>::end(void)
mov [rsp+88h+var_28], rax
loc_33945:
lea rdi, [rsp+88h+var_20]
lea rsi, [rsp+88h+var_28]
call _ZNSt8__detailneERKNS_19_Node_iterator_baseIN6google8protobuf6SymbolELb1EEES6_; std::__detail::operator!=(std::__detail::_Node_iterator_base<google::protobuf::Symbol,true> const&,std::__detail::_Node_iterator_base<google::protobuf::Symbol,true> const&)
test al, 1
jnz short loc_3395D
jmp loc_33A01
loc_3395D:
lea rdi, [rsp+88h+var_20]
call _ZNKSt8__detail20_Node_const_iteratorIN6google8protobuf6SymbolELb1ELb1EEdeEv; std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator*(void)
mov rax, [rax]
mov [rsp+88h+var_30], rax
lea rdi, [rsp+88h+var_30]; this
call _ZNK6google8protobuf6Symbol16field_descriptorEv; google::protobuf::Symbol::field_descriptor(void)
mov [rsp+88h+var_38], rax
cmp [rsp+88h+var_38], 0
jnz short loc_33988
jmp short loc_339F2
loc_33988:
mov rdi, [rsp+88h+var_68]; this
mov rax, [rsp+88h+var_38]
mov [rsp+88h+var_78], rax
mov rax, [rsp+88h+var_10]
mov [rsp+88h+var_80], rax
mov rsi, [rsp+88h+var_38]; google::protobuf::FieldDescriptor *
call _ZNK6google8protobuf20FileDescriptorTables24FindParentForFieldsByMapEPKNS0_15FieldDescriptorE; google::protobuf::FileDescriptorTables::FindParentForFieldsByMap(google::protobuf::FieldDescriptor const*)
mov [rsp+88h+var_58], rax
mov rdi, [rsp+88h+var_38]
call _ZNK6google8protobuf15FieldDescriptor14camelcase_nameB5cxx11Ev; google::protobuf::FieldDescriptor::camelcase_name(void)
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+88h+var_60], rax
lea rdi, [rsp+88h+var_50]
lea rsi, [rsp+88h+var_58]
lea rdx, [rsp+88h+var_60]
call _ZNSt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEC2IS1_PKcTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISB_SC_EEEbE4typeELb1EEEOSB_OSC_
mov rdi, [rsp+88h+var_80]
lea rsi, [rsp+88h+var_50]
call _ZNSt13unordered_mapISt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEPKNS4_15FieldDescriptorENS4_12_GLOBAL__N_121PointerStringPairHashESt8equal_toIS7_ESaIS0_IKS7_SA_EEEixEOS7_; std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>>::operator[](std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>&&)
mov rcx, [rsp+88h+var_78]
mov [rax], rcx
loc_339F2:
lea rdi, [rsp+88h+var_20]
call _ZNSt8__detail20_Node_const_iteratorIN6google8protobuf6SymbolELb1ELb1EEppEv; std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator++(void)
jmp loc_33945
loc_33A01:
mov rdi, [rsp+88h+var_68]
add rdi, 48h ; 'H'
mov rsi, [rsp+88h+var_10]
mov edx, 3
call _ZNSt6atomicIPKSt13unordered_mapISt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEPKNS5_15FieldDescriptorENS5_12_GLOBAL__N_121PointerStringPairHashESt8equal_toIS8_ESaIS1_IKS8_SB_EEEE5storeESL_St12memory_order; std::atomic<std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>> const*>::store(std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>> const*,std::memory_order)
add rsp, 88h
retn
| long long google::protobuf::FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal(
google::protobuf::FileDescriptorTables *this)
{
long long v1; // rax
long long v3; // [rsp+8h] [rbp-80h]
google::protobuf::FieldDescriptor *v4; // [rsp+10h] [rbp-78h]
long long v5; // [rsp+18h] [rbp-70h]
long long v6; // [rsp+28h] [rbp-60h] BYREF
long long ParentForFieldsByMap; // [rsp+30h] [rbp-58h] BYREF
_BYTE v8[24]; // [rsp+38h] [rbp-50h] BYREF
google::protobuf::FieldDescriptor *v9; // [rsp+50h] [rbp-38h]
long long v10; // [rsp+58h] [rbp-30h] BYREF
long long v11; // [rsp+60h] [rbp-28h] BYREF
_QWORD v12[2]; // [rsp+68h] [rbp-20h] BYREF
long long v13; // [rsp+78h] [rbp-10h]
google::protobuf::FileDescriptorTables *v14; // [rsp+80h] [rbp-8h]
v14 = this;
v5 = operator new(0x38uLL);
std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>>::unordered_map(v5);
v13 = v5;
v12[1] = this;
v12[0] = std::unordered_set<google::protobuf::Symbol,google::protobuf::`anonymous namespace'::SymbolByParentHash,google::protobuf::`anonymous namespace'::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>::begin((long long)this);
v11 = std::unordered_set<google::protobuf::Symbol,google::protobuf::`anonymous namespace'::SymbolByParentHash,google::protobuf::`anonymous namespace'::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>::end((long long)this);
while ( (std::__detail::operator!=(v12, &v11) & 1) != 0 )
{
v10 = *(_QWORD *)std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator*(v12);
v9 = (google::protobuf::FieldDescriptor *)google::protobuf::Symbol::field_descriptor((google::protobuf::Symbol *)&v10);
if ( v9 )
{
v4 = v9;
v3 = v13;
ParentForFieldsByMap = google::protobuf::FileDescriptorTables::FindParentForFieldsByMap(this, v9);
v1 = google::protobuf::FieldDescriptor::camelcase_name[abi:cxx11](v9);
v6 = std::string::c_str(v1);
ZNSt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEC2IS1_PKcTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISB_SC_EEEbE4typeELb1EEEOSB_OSC_(
v8,
&ParentForFieldsByMap,
&v6);
*(_QWORD *)std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>>::operator[](
v3,
v8) = v4;
}
std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator++(v12);
}
return std::atomic<std::unordered_map<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor const*,google::protobuf::`anonymous namespace'::PointerStringPairHash,std::equal_to<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void const*,google::protobuf::stringpiece_internal::StringPiece> const,google::protobuf::FieldDescriptor const*>>> const*>::store(
(volatile long long *)this + 9,
v13,
3u);
}
| FieldsByCamelcaseNamesLazyInitInternal:
SUB RSP,0x88
MOV qword ptr [RSP + 0x80],RDI
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0x20],RAX
MOV EDI,0x38
CALL 0x00113450
MOV RDI,RAX
MOV qword ptr [RSP + 0x18],RDI
CALL 0x00133790
MOV RCX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x001337a0
MOV qword ptr [RSP + 0x68],RAX
MOV RDI,qword ptr [RSP + 0x70]
CALL 0x001337d0
MOV qword ptr [RSP + 0x60],RAX
LAB_00133945:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x60]
CALL 0x00173410
TEST AL,0x1
JNZ 0x0013395d
JMP 0x00133a01
LAB_0013395d:
LEA RDI,[RSP + 0x68]
CALL 0x00173430
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x58],RAX
LEA RDI,[RSP + 0x58]
CALL 0x00173450
MOV qword ptr [RSP + 0x50],RAX
CMP qword ptr [RSP + 0x50],0x0
JNZ 0x00133988
JMP 0x001339f2
LAB_00133988:
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x001335c0
MOV qword ptr [RSP + 0x30],RAX
MOV RDI,qword ptr [RSP + 0x50]
CALL 0x00173520
MOV RDI,RAX
CALL 0x00113190
MOV qword ptr [RSP + 0x28],RAX
LEA RDI,[RSP + 0x38]
LEA RSI,[RSP + 0x30]
LEA RDX,[RSP + 0x28]
CALL 0x001734b0
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[RSP + 0x38]
CALL 0x00133800
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX],RCX
LAB_001339f2:
LEA RDI,[RSP + 0x68]
CALL 0x001734f0
JMP 0x00133945
LAB_00133a01:
MOV RDI,qword ptr [RSP + 0x20]
ADD RDI,0x48
MOV RSI,qword ptr [RSP + 0x78]
MOV EDX,0x3
CALL 0x00133830
ADD RSP,0x88
RET
|
/* google::protobuf::FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal() const */
void __thiscall
google::protobuf::FileDescriptorTables::FieldsByCamelcaseNamesLazyInitInternal
(FileDescriptorTables *this)
{
unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>
*puVar1;
ulong uVar2;
int8 *puVar3;
FieldDescriptor *pFVar4;
int8 local_60;
int8 local_58;
pair local_50 [24];
FieldDescriptor *local_38;
int8 local_30;
int8 local_28;
int8 local_20;
FileDescriptorTables *local_18;
unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>
*local_10;
FileDescriptorTables *local_8;
local_8 = this;
puVar1 = (unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>
*)operator_new(0x38);
std::
unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>
::unordered_map(puVar1);
local_18 = this;
local_10 = puVar1;
local_20 = std::
unordered_set<google::protobuf::Symbol,google::protobuf::(anonymous_namespace)::SymbolByParentHash,google::protobuf::(anonymous_namespace)::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>
::begin((unordered_set<google::protobuf::Symbol,google::protobuf::(anonymous_namespace)::SymbolByParentHash,google::protobuf::(anonymous_namespace)::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>
*)this);
local_28 = std::
unordered_set<google::protobuf::Symbol,google::protobuf::(anonymous_namespace)::SymbolByParentHash,google::protobuf::(anonymous_namespace)::SymbolByParentEq,std::allocator<google::protobuf::Symbol>>
::end();
while (uVar2 = std::__detail::operator!=
((_Node_iterator_base *)&local_20,(_Node_iterator_base *)&local_28),
(uVar2 & 1) != 0) {
puVar3 = (int8 *)
std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator*
((_Node_const_iterator<google::protobuf::Symbol,true,true> *)&local_20);
local_30 = *puVar3;
pFVar4 = (FieldDescriptor *)Symbol::field_descriptor((Symbol *)&local_30);
puVar1 = local_10;
local_38 = pFVar4;
if (pFVar4 != (FieldDescriptor *)0x0) {
local_58 = FindParentForFieldsByMap(this,pFVar4);
FieldDescriptor::camelcase_name_abi_cxx11_(local_38);
local_60 = std::__cxx11::string::c_str();
_ZNSt4pairIPKvN6google8protobuf20stringpiece_internal11StringPieceEEC2IS1_PKcTnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISB_SC_EEEbE4typeELb1EEEOSB_OSC_
(local_50,&local_58,&local_60);
puVar3 = (int8 *)
std::
unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>
::operator[](puVar1,local_50);
*puVar3 = pFVar4;
}
std::__detail::_Node_const_iterator<google::protobuf::Symbol,true,true>::operator++
((_Node_const_iterator<google::protobuf::Symbol,true,true> *)&local_20);
}
std::
atomic<std::unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>const*>
::store((atomic<std::unordered_map<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>,google::protobuf::FieldDescriptor_const*,google::protobuf::(anonymous_namespace)::PointerStringPairHash,std::equal_to<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>>,std::allocator<std::pair<std::pair<void_const*,google::protobuf::stringpiece_internal::StringPiece>const,google::protobuf::FieldDescriptor_const*>>>const*>
*)(this + 0x48),local_10,3);
return;
}
| |
22,991 | nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void (nglog::LogMessage::*)()) | ng-log[P]ng-log/src/logging.cc | ErrnoLogMessage::ErrnoLogMessage(const char* file, int line,
LogSeverity severity, int64 ctr,
void (LogMessage::*send_method)())
: LogMessage(file, line, severity, ctr, send_method) {} | O1 | cpp | nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void (nglog::LogMessage::*)()):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, (%rsp)
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movq 0x40(%rsp), %r13
movq 0x48(%rsp), %rbx
movq $0x0, (%rdi)
addq $0x10, %rdi
callq 0xe208
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %r13, %r8
movq %rbx, %r9
callq 0x9946
movq 0x8(%r12), %rax
movq (%rsp), %rcx
movq %rcx, 0x7580(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN5nglog15ErrnoLogMessageC2EPKciNS_11LogSeverityElMNS_10LogMessageEFvvE:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov [rsp+38h+var_38], r8
mov ebp, ecx
mov r14d, edx
mov r15, rsi
mov r12, rdi
mov r13, [rsp+38h+arg_0]
mov rbx, [rsp+38h+arg_8]
mov qword ptr [rdi], 0
add rdi, 10h; this
call _ZN5nglog14LogMessageTimeC2Ev; nglog::LogMessageTime::LogMessageTime(void)
mov rdi, r12
mov rsi, r15
mov edx, r14d
mov ecx, ebp
mov r8, r13
mov r9, rbx
call _ZN5nglog10LogMessage4InitEPKciNS_11LogSeverityEMS0_FvvE; nglog::LogMessage::Init(char const*,int,nglog::LogSeverity,void (nglog::LogMessage::*)(void))
mov rax, [r12+8]
mov rcx, [rsp+38h+var_38]
mov [rax+7580h], rcx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nglog::ErrnoLogMessage::ErrnoLogMessage(
_QWORD *a1,
nglog::tools *a2,
int a3,
unsigned int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long result; // rax
*a1 = 0LL;
nglog::LogMessageTime::LogMessageTime((nglog::LogMessageTime *)(a1 + 2));
nglog::LogMessage::Init((long long)a1, a2, a3, a4, a7, a8);
result = a1[1];
*(_QWORD *)(result + 30080) = a5;
return result;
}
| ErrnoLogMessage:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV qword ptr [RSP],R8
MOV EBP,ECX
MOV R14D,EDX
MOV R15,RSI
MOV R12,RDI
MOV R13,qword ptr [RSP + 0x40]
MOV RBX,qword ptr [RSP + 0x48]
MOV qword ptr [RDI],0x0
ADD RDI,0x10
CALL 0x0010e208
MOV RDI,R12
MOV RSI,R15
MOV EDX,R14D
MOV ECX,EBP
MOV R8,R13
MOV R9,RBX
CALL 0x00109946
MOV RAX,qword ptr [R12 + 0x8]
MOV RCX,qword ptr [RSP]
MOV qword ptr [RAX + 0x7580],RCX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nglog::ErrnoLogMessage::ErrnoLogMessage(char const*, int, nglog::LogSeverity, long, void
(nglog::LogMessage::*)()) */
void __thiscall
nglog::ErrnoLogMessage::ErrnoLogMessage
(ErrnoLogMessage *this,int8 param_1,int4 param_2,int4 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8)
{
*(int8 *)this = 0;
LogMessageTime::LogMessageTime((LogMessageTime *)(this + 0x10));
LogMessage::Init(this,param_1,param_2,param_4,param_7,param_8);
*(int8 *)(*(long *)(this + 8) + 0x7580) = param_5;
return;
}
| |
22,992 | std::vector<double, std::allocator<double>> findPeaks::apply_mask<double>(std::vector<double, std::allocator<double>> const&, std::vector<bool, std::allocator<bool>> const&) | giladroyz[P]FindPeaks/src/cpp/find_peaks.cpp | std::vector<T> apply_mask(const std::vector<T> &vec, const std::vector<bool> &mask) {
std::vector<T> result;
for (size_t p = 0; p < vec.size(); p++)
if (mask[p]) result.push_back(vec[p]);
return result;
} | O0 | cpp | std::vector<double, std::allocator<double>> findPeaks::apply_mask<double>(std::vector<double, std::allocator<double>> const&, std::vector<bool, std::allocator<bool>> const&):
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7640
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6b40
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x7a0c
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7750
movb %al, -0x51(%rbp)
jmp 0x79bf
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x79c8
jmp 0x79fc
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6d90
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x7660
jmp 0x79e3
jmp 0x79fc
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x25e0
jmp 0x7a29
jmp 0x79fe
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x7990
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7a1f
movq -0x48(%rbp), %rdi
callq 0x25e0
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
nopl (%rax)
| _ZN9findPeaks10apply_maskIdEESt6vectorIT_SaIS2_EERKS4_RKS1_IbSaIbEE:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_48], rdi
mov rax, rdi
mov [rbp+var_40], rax
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_19], 0
call _ZNSt6vectorIdSaIdEEC2Ev; std::vector<double>::vector(void)
mov [rbp+var_28], 0
loc_7990:
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov rdi, [rbp+var_10]
call _ZNKSt6vectorIdSaIdEE4sizeEv; std::vector<double>::size(void)
mov rcx, rax
mov rax, [rbp+var_50]
cmp rax, rcx
jnb short loc_7A0C
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_28]
call _ZNKSt6vectorIbSaIbEEixEm; std::vector<bool>::operator[](ulong)
mov [rbp+var_51], al
jmp short $+2
loc_79BF:
mov al, [rbp+var_51]
test al, 1
jnz short loc_79C8
jmp short loc_79FC
loc_79C8:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_28]
call _ZNKSt6vectorIdSaIdEEixEm; std::vector<double>::operator[](ulong)
mov rdi, [rbp+var_48]
mov rsi, rax
call _ZNSt6vectorIdSaIdEE9push_backERKd; std::vector<double>::push_back(double const&)
jmp short $+2
loc_79E3:
jmp short loc_79FC
mov rdi, [rbp+var_48]
mov rcx, rax
mov eax, edx
mov [rbp+var_30], rcx
mov [rbp+var_34], eax
call _ZNSt6vectorIdSaIdEED2Ev; std::vector<double>::~vector()
jmp short loc_7A29
loc_79FC:
jmp short $+2
loc_79FE:
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_7990
loc_7A0C:
mov [rbp+var_19], 1
test [rbp+var_19], 1
jnz short loc_7A1F
mov rdi, [rbp+var_48]
call _ZNSt6vectorIdSaIdEED2Ev; std::vector<double>::~vector()
loc_7A1F:
mov rax, [rbp+var_40]
add rsp, 60h
pop rbp
retn
loc_7A29:
mov rdi, [rbp+var_30]
call __Unwind_Resume
| long long findPeaks::apply_mask<double>(long long a1, _QWORD *a2, long long a3)
{
long long v3; // rax
unsigned long long i; // [rsp+38h] [rbp-28h]
std::vector<double>::vector(a1);
for ( i = 0LL; i < std::vector<double>::size(a2); ++i )
{
if ( (std::vector<bool>::operator[](a3, i) & 1) != 0 )
{
v3 = std::vector<double>::operator[](a2, i);
std::vector<double>::push_back(a1, v3);
}
}
return a1;
}
| apply_mask<double>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x40],RAX
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV byte ptr [RBP + -0x19],0x0
CALL 0x00107640
MOV qword ptr [RBP + -0x28],0x0
LAB_00107990:
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106b40
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,RCX
JNC 0x00107a0c
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x28]
LAB_001079b5:
CALL 0x00107750
MOV byte ptr [RBP + -0x51],AL
JMP 0x001079bf
LAB_001079bf:
MOV AL,byte ptr [RBP + -0x51]
TEST AL,0x1
JNZ 0x001079c8
JMP 0x001079fc
LAB_001079c8:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00106d90
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,RAX
CALL 0x00107660
LAB_001079e1:
JMP 0x001079e3
LAB_001079e3:
JMP 0x001079fc
LAB_001079fc:
JMP 0x001079fe
LAB_001079fe:
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00107990
LAB_00107a0c:
MOV byte ptr [RBP + -0x19],0x1
TEST byte ptr [RBP + -0x19],0x1
JNZ 0x00107a1f
MOV RDI,qword ptr [RBP + -0x48]
CALL 0x001025e0
LAB_00107a1f:
MOV RAX,qword ptr [RBP + -0x40]
ADD RSP,0x60
POP RBP
RET
|
/* WARNING: Removing unreachable block (ram,0x00107a16) */
/* std::vector<double, std::allocator<double> > findPeaks::apply_mask<double>(std::vector<double,
std::allocator<double> > const&, std::vector<bool, std::allocator<bool> > const&) */
findPeaks * __thiscall
findPeaks::apply_mask<double>(findPeaks *this,vector *param_1,vector *param_2)
{
byte bVar1;
ulong uVar2;
double *pdVar3;
int8 local_30;
std::vector<double,std::allocator<double>>::vector((vector<double,std::allocator<double>> *)this);
for (local_30 = 0;
uVar2 = std::vector<double,std::allocator<double>>::size
((vector<double,std::allocator<double>> *)param_1), local_30 < uVar2;
local_30 = local_30 + 1) {
/* try { // try from 001079b5 to 001079e0 has its CatchHandler @ 001079e5 */
bVar1 = std::vector<bool,std::allocator<bool>>::operator[]
((vector<bool,std::allocator<bool>> *)param_2,local_30);
if ((bVar1 & 1) != 0) {
pdVar3 = (double *)
std::vector<double,std::allocator<double>>::operator[]
((vector<double,std::allocator<double>> *)param_1,local_30);
std::vector<double,std::allocator<double>>::push_back
((vector<double,std::allocator<double>> *)this,pdVar3);
}
}
return this;
}
| |
22,993 | 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 0x934e9(%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 0x9bf9d
movq 0x94ff1(%rip), %rcx # 0x130f80
cmpb $0x0, (%rcx)
je 0x9bf99
incl 0x8(%rax)
jmp 0x9bf9d
lock
incl 0x8(%rax)
leaq 0x40(%rbx), %r14
movb $0x0, 0x40(%rbx)
movq $0x0, 0x48(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x6b800
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6b800
movq %rax, %r14
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9bfdf
callq 0x33c02
movq %rbx, %rdi
callq 0x8d2ea
movq %r14, %rdi
callq 0x1bff0
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_9BF9D
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_9BF99
inc dword ptr [rax+8]
jmp short loc_9BF9D
loc_9BF99:
lock inc dword ptr [rax+8]
loc_9BF9D:
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_9BFDF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9BFDF:
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_0019bf30:
MOV EDI,0x30
CALL 0x0011b8f0
LAB_0019bf3a:
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 0x0019bf9d
MOV RCX,qword ptr [0x00230f80]
CMP byte ptr [RCX],0x0
JZ 0x0019bf99
INC dword ptr [RAX + 0x8]
JMP 0x0019bf9d
LAB_0019bf99:
INC.LOCK dword ptr [RAX + 0x8]
LAB_0019bf9d:
LEA R14,[RBX + 0x40]
MOV byte ptr [RBX + 0x40],0x0
MOV qword ptr [RBX + 0x48],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x0016b800
MOV RDI,R14
MOV ESI,0x1
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0016b800
|
/* 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 0019bf30 to 0019bf39 has its CatchHandler @ 0019bfce */
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;
}
| |
22,994 | warnAboutARBClipControl | aimrt_mujoco_sim/_deps/mujoco-src/src/render/render_gl2.c | static void warnAboutARBClipControl(void) {
// not thread safe, but the consequence is just too many log lines
static int warned = 0;
if (!warned) {
warned = 1;
mju_warning("ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, "
"depth accuracy will be limited");
}
} | O0 | c | warnAboutARBClipControl:
pushq %rax
cmpl $0x0, 0x18ca38(%rip) # 0x610bb0
jne 0x484192
movl $0x1, 0x18ca2c(%rip) # 0x610bb0
leaq 0xaeae9(%rip), %rdi # 0x532c74
movb $0x0, %al
callq 0x493f0
popq %rax
retq
nopw %cs:(%rax,%rax)
| warnAboutARBClipControl:
push rax
cmp cs:warnAboutARBClipControl_warned, 0
jnz short loc_484192
mov cs:warnAboutARBClipControl_warned, 1
lea rdi, aArbClipControl; "ARB_clip_control unavailable while mjDE"...
mov al, 0
call _mju_warning
loc_484192:
pop rax
retn
| void __spoils<rdx,rcx,r8,r9,r10,r11,xmm4,xmm5> warnAboutARBClipControl(
long long a1,
int a2,
int a3,
int a4,
int a5,
int a6)
{
if ( !warnAboutARBClipControl_warned )
{
warnAboutARBClipControl_warned = 1;
mju_warning(
(unsigned int)"ARB_clip_control unavailable while mjDEPTH_ZEROFAR requested, depth accuracy will be limited",
a2,
a3,
a4,
a5,
a6);
}
}
| __copy_move_a<true,std::pair<int,int>*,__gnu_cxx::__normal_iterator<std::pair<int,int>*,std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>>>:
SUB RSP,0x48
MOV qword ptr [RSP + 0x38],RDX
MOV qword ptr [RSP + 0x30],RDI
MOV qword ptr [RSP + 0x28],RSI
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x20],RAX
MOV RDI,qword ptr [RSP + 0x30]
CALL 0x0014bca0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0x28]
CALL 0x0014bca0
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x18],RAX
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x0014be50
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
MOV RDX,RAX
CALL 0x0014bec0
MOV RSI,RAX
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x0014be70
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
/* __gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>,
std::allocator<std::pair<int, int> > > > std::__copy_move_a<true, std::pair<int, int>*,
__gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>,
std::allocator<std::pair<int, int> > > > >(std::pair<int, int>*, std::pair<int, int>*,
__gnu_cxx::__normal_iterator<std::pair<int, int>*, std::vector<std::pair<int, int>,
std::allocator<std::pair<int, int> > > >) */
int8
std::
__copy_move_a<true,std::pair<int,int>*,__gnu_cxx::__normal_iterator<std::pair<int,int>*,std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>>>
(pair *param_1,pair *param_2,int8 param_3)
{
pair *ppVar1;
pair *ppVar2;
pair *ppVar3;
int8 uVar4;
ppVar1 = __niter_base<std::pair<int,int>*>(param_1);
ppVar2 = __niter_base<std::pair<int,int>*>(param_2);
ppVar3 = __niter_base<std::pair<int,int>*,std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>>
(param_3);
ppVar1 = __copy_move_a1<true,std::pair<int,int>*,std::pair<int,int>*>(ppVar1,ppVar2,ppVar3);
uVar4 = __niter_wrap<__gnu_cxx::__normal_iterator<std::pair<int,int>*,std::vector<std::pair<int,int>,std::allocator<std::pair<int,int>>>>,std::pair<int,int>*>
(param_3,ppVar1);
return uVar4;
}
| |
22,995 | my_mb_wc_gb2312 | eloqsql/strings/ctype-gb2312.c | static int
my_mb_wc_gb2312(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e){
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_gb2312_uni_onechar(((hi<<8)+s[1])&0x7F7F)))
return -2;
return 2;
} | O3 | c | my_mb_wc_gb2312:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x379ac
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x37988
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x379ac
leal 0x5f(%rdi), %ecx
xorl %eax, %eax
cmpb $0x56, %cl
ja 0x379ac
movzbl 0x1(%rdx), %ecx
leal 0x1(%rcx), %edx
cmpb $-0x5e, %dl
jae 0x379ad
retq
pushq %rbp
movq %rsp, %rbp
movzbl %dil, %eax
shll $0x8, %eax
orl %ecx, %eax
andl $0x7f7f, %eax # imm = 0x7F7F
leal -0x2121(%rax), %ecx
cmpl $0x537, %ecx # imm = 0x537
ja 0x379d8
movl %ecx, %eax
leaq 0x13138a(%rip), %rcx # 0x168d60
jmp 0x37a06
leal -0x2721(%rax), %ecx
cmpl $0x24e, %ecx # imm = 0x24E
ja 0x379f1
movl %ecx, %eax
leaq 0x131de1(%rip), %rcx # 0x1697d0
jmp 0x37a06
addl $0xffffcfdf, %eax # imm = 0xFFFFCFDF
cmpl $0x475e, %eax # imm = 0x475E
jae 0x37a1f
movl %eax, %eax
leaq 0x13226a(%rip), %rcx # 0x169c70
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x37a2b
jmp 0x37a26
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
| my_mb_wc_gb2312:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_379AC
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_37988
mov [rsi], rdi
mov eax, 1
retn
loc_37988:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_379AC
lea ecx, [rdi+5Fh]
xor eax, eax
cmp cl, 56h ; 'V'
ja short locret_379AC
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+1]
cmp dl, 0A2h
jnb short loc_379AD
locret_379AC:
retn
loc_379AD:
push rbp
mov rbp, rsp
movzx eax, dil
shl eax, 8
or eax, ecx
and eax, 7F7Fh
lea ecx, [rax-2121h]
cmp ecx, 537h
ja short loc_379D8
mov eax, ecx
lea rcx, tab_gb2312_uni0
jmp short loc_37A06
loc_379D8:
lea ecx, [rax-2721h]
cmp ecx, 24Eh
ja short loc_379F1
mov eax, ecx
lea rcx, tab_gb2312_uni1
jmp short loc_37A06
loc_379F1:
add eax, 0FFFFCFDFh
cmp eax, 475Eh
jnb short loc_37A1F
mov eax, eax
lea rcx, tab_gb2312_uni2
loc_37A06:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_37A2B
jmp short loc_37A26
loc_37A1F:
mov qword ptr [rsi], 0
loc_37A26:
mov eax, 0FFFFFFFEh
loc_37A2B:
pop rbp
retn
| long long my_mb_wc_gb2312(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
unsigned __int16 v6; // cx
int v7; // eax
long long v8; // rax
unsigned __int16 *v9; // rcx
long long v10; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)(v5 + 95) <= 0x56u )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) >= 0xA2u )
{
v7 = (v6 | (unsigned __int16)((unsigned __int8)v5 << 8)) & 0x7F7F;
if ( (unsigned int)(v7 - 8481) > 0x537 )
{
if ( (unsigned int)(v7 - 10017) > 0x24E )
{
LODWORD(v8) = v7 - 12321;
if ( (unsigned int)v8 >= 0x475E )
{
*a2 = 0LL;
return 4294967294LL;
}
v8 = (unsigned int)v8;
v9 = (unsigned __int16 *)&tab_gb2312_uni2;
}
else
{
v8 = (unsigned int)(v7 - 10017);
v9 = (unsigned __int16 *)&tab_gb2312_uni1;
}
}
else
{
v8 = (unsigned int)(v7 - 8481);
v9 = (unsigned __int16 *)&tab_gb2312_uni0;
}
v10 = v9[v8];
*a2 = v10;
result = 2LL;
if ( (_WORD)v10 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
| my_mb_wc_gb2312:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x001379ac
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x00137988
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_00137988:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001379ac
LEA ECX,[RDI + 0x5f]
XOR EAX,EAX
CMP CL,0x56
JA 0x001379ac
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x1]
CMP DL,0xa2
JNC 0x001379ad
LAB_001379ac:
RET
LAB_001379ad:
PUSH RBP
MOV RBP,RSP
MOVZX EAX,DIL
SHL EAX,0x8
OR EAX,ECX
AND EAX,0x7f7f
LEA ECX,[RAX + -0x2121]
CMP ECX,0x537
JA 0x001379d8
MOV EAX,ECX
LEA RCX,[0x268d60]
JMP 0x00137a06
LAB_001379d8:
LEA ECX,[RAX + -0x2721]
CMP ECX,0x24e
JA 0x001379f1
MOV EAX,ECX
LEA RCX,[0x2697d0]
JMP 0x00137a06
LAB_001379f1:
ADD EAX,0xffffcfdf
CMP EAX,0x475e
JNC 0x00137a1f
MOV EAX,EAX
LEA RCX,[0x269c70]
LAB_00137a06:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x00137a2b
JMP 0x00137a26
LAB_00137a1f:
MOV qword ptr [RSI],0x0
LAB_00137a26:
MOV EAX,0xfffffffe
LAB_00137a2b:
POP RBP
RET
|
int8 my_mb_wc_gb2312(int8 param_1,ulong *param_2,char *param_3,char *param_4)
{
char cVar1;
ushort uVar2;
uint uVar3;
ulong uVar4;
int1 *puVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
cVar1 = *param_3;
if (-1 < (long)cVar1) {
*param_2 = (long)cVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if ((byte)(cVar1 + 0x5fU) < 0x57) {
if ((byte)(param_3[1] + 1U) < 0xa2) {
return 0;
}
uVar3 = CONCAT11(cVar1,param_3[1]) & 0x7f7f;
if (uVar3 - 0x2121 < 0x538) {
uVar4 = (ulong)(uVar3 - 0x2121);
puVar5 = tab_gb2312_uni0;
}
else if (uVar3 - 0x2721 < 0x24f) {
uVar4 = (ulong)(uVar3 - 0x2721);
puVar5 = tab_gb2312_uni1;
}
else {
if (0x475d < uVar3 - 0x3021) {
*param_2 = 0;
return 0xfffffffe;
}
uVar4 = (ulong)(uVar3 - 0x3021);
puVar5 = tab_gb2312_uni2;
}
uVar2 = *(ushort *)(puVar5 + uVar4 * 2);
*param_2 = (ulong)uVar2;
if (uVar2 == 0) {
return 0xfffffffe;
}
return 2;
}
return 0;
}
| |
22,996 | mi_kpointer | eloqsql/storage/myisam/mi_search.c | void _mi_kpointer(register MI_INFO *info, register uchar *buff, my_off_t pos)
{
pos/=MI_MIN_KEY_BLOCK_LENGTH;
switch (info->s->base.key_reflength) {
#if SIZEOF_OFF_T > 4
case 7: mi_int7store(buff,pos); break;
case 6: mi_int6store(buff,pos); break;
case 5: mi_int5store(buff,pos); break;
#else
case 7: *buff++=0;
/* fall through */
case 6: *buff++=0;
/* fall through */
case 5: *buff++=0;
/* fall through */
#endif
case 4: mi_int4store(buff,pos); break;
case 3: mi_int3store(buff,pos); break;
case 2: mi_int2store(buff,(uint) pos); break;
case 1: buff[0]= (uchar) pos; break;
default: abort(); /* impossible */
}
} | O3 | c | mi_kpointer:
movq (%rdi), %rax
movl 0x17c(%rax), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0xa0163
movq %rdx, %rax
shrq $0xa, %rax
leaq 0x65d81(%rip), %rdi # 0x105e0c
movslq (%rdi,%rcx,4), %rcx
addq %rdi, %rcx
jmpq *%rcx
movb %al, 0x1(%rsi)
shrq $0x12, %rdx
jmp 0xa015d
movb %al, 0x4(%rsi)
movq %rdx, %rax
shrq $0x2a, %rax
movl %edx, %ecx
shrl $0x12, %ecx
movb %cl, 0x3(%rsi)
movq %rdx, %rcx
shrq $0x1a, %rcx
movb %cl, 0x2(%rsi)
shrq $0x22, %rdx
movb %dl, 0x1(%rsi)
jmp 0xa0160
movb %al, 0x2(%rsi)
movl %edx, %eax
shrl $0x12, %eax
movb %al, 0x1(%rsi)
shrq $0x1a, %rdx
jmp 0xa015d
movb %al, 0x3(%rsi)
movl %edx, %eax
shrl $0x12, %eax
movb %al, 0x2(%rsi)
movq %rdx, %rax
shrq $0x1a, %rax
movb %al, 0x1(%rsi)
shrq $0x22, %rdx
jmp 0xa015d
movq %rdx, %rcx
shrq $0x2a, %rcx
movb %al, 0x5(%rsi)
movl %edx, %eax
shrl $0x12, %eax
movb %al, 0x4(%rsi)
movq %rdx, %rax
shrq $0x1a, %rax
movb %al, 0x3(%rsi)
movq %rdx, %rax
shrq $0x22, %rax
movb %al, 0x2(%rsi)
movb %cl, 0x1(%rsi)
shrq $0x32, %rdx
jmp 0xa015d
movq %rdx, %rcx
shrq $0x2a, %rcx
movb %al, 0x6(%rsi)
movl %edx, %eax
shrl $0x12, %eax
movb %al, 0x5(%rsi)
movq %rdx, %rax
shrq $0x1a, %rax
movb %al, 0x4(%rsi)
movq %rdx, %rax
shrq $0x22, %rax
movb %al, 0x3(%rsi)
movb %cl, 0x2(%rsi)
movq %rdx, %rax
shrq $0x32, %rax
movb %al, 0x1(%rsi)
shrq $0x3a, %rdx
movq %rdx, %rax
movb %al, (%rsi)
retq
pushq %rbp
movq %rsp, %rbp
callq 0x2a690
| _mi_kpointer:
mov rax, [rdi]
mov ecx, [rax+17Ch]
dec ecx; switch 7 cases
cmp ecx, 6
ja def_A0092; jumptable 00000000000A0092 default case
mov rax, rdx
shr rax, 0Ah
lea rdi, jpt_A0092
movsxd rcx, ds:(jpt_A0092 - 105E0Ch)[rdi+rcx*4]
add rcx, rdi
jmp rcx; switch jump
loc_A0094:
mov [rsi+1], al; jumptable 00000000000A0092 case 2
shr rdx, 12h
jmp loc_A015D
loc_A00A0:
mov [rsi+4], al; jumptable 00000000000A0092 case 5
mov rax, rdx
shr rax, 2Ah
mov ecx, edx
shr ecx, 12h
mov [rsi+3], cl
mov rcx, rdx
shr rcx, 1Ah
mov [rsi+2], cl
shr rdx, 22h
mov [rsi+1], dl
jmp loc_A0160; jumptable 00000000000A0092 case 1
loc_A00C8:
mov [rsi+2], al; jumptable 00000000000A0092 case 3
mov eax, edx
shr eax, 12h
mov [rsi+1], al
shr rdx, 1Ah
jmp loc_A015D
loc_A00DC:
mov [rsi+3], al; jumptable 00000000000A0092 case 4
mov eax, edx
shr eax, 12h
mov [rsi+2], al
mov rax, rdx
shr rax, 1Ah
mov [rsi+1], al
shr rdx, 22h
jmp short loc_A015D
loc_A00F7:
mov rcx, rdx; jumptable 00000000000A0092 case 6
shr rcx, 2Ah
mov [rsi+5], al
mov eax, edx
shr eax, 12h
mov [rsi+4], al
mov rax, rdx
shr rax, 1Ah
mov [rsi+3], al
mov rax, rdx
shr rax, 22h
mov [rsi+2], al
mov [rsi+1], cl
shr rdx, 32h
jmp short loc_A015D
loc_A0126:
mov rcx, rdx; jumptable 00000000000A0092 case 7
shr rcx, 2Ah
mov [rsi+6], al
mov eax, edx
shr eax, 12h
mov [rsi+5], al
mov rax, rdx
shr rax, 1Ah
mov [rsi+4], al
mov rax, rdx
shr rax, 22h
mov [rsi+3], al
mov [rsi+2], cl
mov rax, rdx
shr rax, 32h
mov [rsi+1], al
shr rdx, 3Ah
loc_A015D:
mov rax, rdx
loc_A0160:
mov [rsi], al; jumptable 00000000000A0092 case 1
retn
def_A0092:
push rbp; jumptable 00000000000A0092 default case
mov rbp, rsp
call _abort
| unsigned long long mi_kpointer(long long a1, _BYTE *a2, unsigned long long a3)
{
unsigned long long result; // rax
unsigned long long v4; // rdx
result = a3 >> 10;
switch ( *(_DWORD *)(*(_QWORD *)a1 + 380LL) )
{
case 1:
goto LABEL_9;
case 2:
a2[1] = result;
v4 = a3 >> 18;
goto LABEL_8;
case 3:
a2[2] = result;
a2[1] = (unsigned int)a3 >> 18;
v4 = a3 >> 26;
goto LABEL_8;
case 4:
a2[3] = result;
a2[2] = (unsigned int)a3 >> 18;
a2[1] = a3 >> 26;
v4 = a3 >> 34;
goto LABEL_8;
case 5:
a2[4] = result;
result = a3 >> 42;
a2[3] = (unsigned int)a3 >> 18;
a2[2] = a3 >> 26;
a2[1] = a3 >> 34;
goto LABEL_9;
case 6:
a2[5] = result;
a2[4] = (unsigned int)a3 >> 18;
a2[3] = a3 >> 26;
a2[2] = a3 >> 34;
a2[1] = a3 >> 42;
v4 = a3 >> 50;
goto LABEL_8;
case 7:
a2[6] = result;
a2[5] = (unsigned int)a3 >> 18;
a2[4] = a3 >> 26;
a2[3] = a3 >> 34;
a2[2] = a3 >> 42;
a2[1] = a3 >> 50;
v4 = a3 >> 58;
LABEL_8:
result = v4;
LABEL_9:
*a2 = result;
return result;
default:
abort(a1, a2, a3);
}
}
| _mi_kpointer:
MOV RAX,qword ptr [RDI]
MOV ECX,dword ptr [RAX + 0x17c]
DEC ECX
CMP ECX,0x6
JA 0x001a0163
MOV RAX,RDX
SHR RAX,0xa
LEA RDI,[0x205e0c]
MOVSXD RCX,dword ptr [RDI + RCX*0x4]
ADD RCX,RDI
switchD:
JMP RCX
caseD_2:
MOV byte ptr [RSI + 0x1],AL
SHR RDX,0x12
JMP 0x001a015d
caseD_5:
MOV byte ptr [RSI + 0x4],AL
MOV RAX,RDX
SHR RAX,0x2a
MOV ECX,EDX
SHR ECX,0x12
MOV byte ptr [RSI + 0x3],CL
MOV RCX,RDX
SHR RCX,0x1a
MOV byte ptr [RSI + 0x2],CL
SHR RDX,0x22
MOV byte ptr [RSI + 0x1],DL
JMP 0x001a0160
caseD_3:
MOV byte ptr [RSI + 0x2],AL
MOV EAX,EDX
SHR EAX,0x12
MOV byte ptr [RSI + 0x1],AL
SHR RDX,0x1a
JMP 0x001a015d
caseD_4:
MOV byte ptr [RSI + 0x3],AL
MOV EAX,EDX
SHR EAX,0x12
MOV byte ptr [RSI + 0x2],AL
MOV RAX,RDX
SHR RAX,0x1a
MOV byte ptr [RSI + 0x1],AL
SHR RDX,0x22
JMP 0x001a015d
caseD_6:
MOV RCX,RDX
SHR RCX,0x2a
MOV byte ptr [RSI + 0x5],AL
MOV EAX,EDX
SHR EAX,0x12
MOV byte ptr [RSI + 0x4],AL
MOV RAX,RDX
SHR RAX,0x1a
MOV byte ptr [RSI + 0x3],AL
MOV RAX,RDX
SHR RAX,0x22
MOV byte ptr [RSI + 0x2],AL
MOV byte ptr [RSI + 0x1],CL
SHR RDX,0x32
JMP 0x001a015d
caseD_7:
MOV RCX,RDX
SHR RCX,0x2a
MOV byte ptr [RSI + 0x6],AL
MOV EAX,EDX
SHR EAX,0x12
MOV byte ptr [RSI + 0x5],AL
MOV RAX,RDX
SHR RAX,0x1a
MOV byte ptr [RSI + 0x4],AL
MOV RAX,RDX
SHR RAX,0x22
MOV byte ptr [RSI + 0x3],AL
MOV byte ptr [RSI + 0x2],CL
MOV RAX,RDX
SHR RAX,0x32
MOV byte ptr [RSI + 0x1],AL
SHR RDX,0x3a
LAB_001a015d:
MOV RAX,RDX
caseD_1:
MOV byte ptr [RSI],AL
RET
default:
PUSH RBP
MOV RBP,RSP
CALL 0x0012a690
|
void _mi_kpointer(long *param_1,byte *param_2,ulong param_3)
{
byte bVar1;
bVar1 = (byte)(param_3 >> 10);
switch(*(int4 *)(*param_1 + 0x17c)) {
case 1:
break;
case 2:
param_2[1] = bVar1;
bVar1 = (byte)(param_3 >> 0x12);
break;
case 3:
param_2[2] = bVar1;
param_2[1] = (byte)(param_3 >> 0x12);
bVar1 = (byte)(param_3 >> 0x1a);
break;
case 4:
param_2[3] = bVar1;
param_2[2] = (byte)(param_3 >> 0x12);
param_2[1] = (byte)(param_3 >> 0x1a);
bVar1 = (byte)(param_3 >> 0x22);
break;
case 5:
param_2[4] = bVar1;
bVar1 = (byte)(param_3 >> 0x2a);
param_2[3] = (byte)(param_3 >> 0x12);
param_2[2] = (byte)(param_3 >> 0x1a);
param_2[1] = (byte)(param_3 >> 0x22);
break;
case 6:
param_2[5] = bVar1;
param_2[4] = (byte)(param_3 >> 0x12);
param_2[3] = (byte)(param_3 >> 0x1a);
param_2[2] = (byte)(param_3 >> 0x22);
param_2[1] = (byte)(param_3 >> 0x2a);
bVar1 = (byte)(param_3 >> 0x32);
break;
case 7:
param_2[6] = bVar1;
param_2[5] = (byte)(param_3 >> 0x12);
param_2[4] = (byte)(param_3 >> 0x1a);
param_2[3] = (byte)(param_3 >> 0x22);
param_2[2] = (byte)(param_3 >> 0x2a);
param_2[1] = (byte)(param_3 >> 0x32);
bVar1 = (byte)(param_3 >> 0x3a);
break;
default:
/* WARNING: Subroutine does not return */
abort();
}
*param_2 = bVar1;
return;
}
| |
22,997 | update_dynamic_record | eloqsql/storage/myisam/mi_dynrec.c | static int update_dynamic_record(MI_INFO *info, my_off_t filepos, uchar *record,
ulong reclength)
{
int flag;
uint error;
ulong length;
MI_BLOCK_INFO block_info;
DBUG_ENTER("update_dynamic_record");
flag=block_info.second_read=0;
/*
Check if we have enough room for the record.
First we do simplified check to make usual case faster.
Then we do more precise check for the space left.
Though it still is not absolutely precise, as
we always use MI_MAX_DYN_BLOCK_HEADER while it can be
less in the most of the cases.
*/
/*
compare with just the reclength as we're going
to get some space from the old replaced record
*/
if (unlikely(info->s->base.max_data_file_length -
info->state->data_file_length < reclength))
{
/*
let's read the old record's block to find out the length of the
old record
*/
if ((error=_mi_get_block_info(&block_info,info->dfile,filepos))
& (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR | BLOCK_FATAL_ERROR))
{
DBUG_PRINT("error",("Got wrong block info"));
if (!(error & BLOCK_FATAL_ERROR))
my_errno=HA_ERR_WRONG_IN_RECORD;
goto err;
}
/*
if new record isn't longer, we can go on safely
*/
if (block_info.rec_len < reclength)
{
if (info->s->base.max_data_file_length - info->state->data_file_length +
info->state->empty - info->state->del * MI_MAX_DYN_BLOCK_HEADER <
reclength - block_info.rec_len + MI_MAX_DYN_BLOCK_HEADER)
{
my_errno=HA_ERR_RECORD_FILE_FULL;
goto err;
}
}
block_info.second_read=0;
}
while (reclength > 0)
{
if (filepos != info->s->state.dellink)
{
block_info.next_filepos= HA_OFFSET_ERROR;
if ((error=_mi_get_block_info(&block_info,info->dfile,filepos))
& (BLOCK_DELETED | BLOCK_ERROR | BLOCK_SYNC_ERROR |
BLOCK_FATAL_ERROR))
{
DBUG_PRINT("error",("Got wrong block info"));
if (!(error & BLOCK_FATAL_ERROR))
my_errno=HA_ERR_WRONG_IN_RECORD;
goto err;
}
length=(ulong) (block_info.filepos-filepos) + block_info.block_len;
if (length < reclength)
{
uint tmp=MY_ALIGN(reclength - length + 3 +
MY_TEST(reclength >= 65520L), MI_DYN_ALIGN_SIZE);
/* Don't create a block bigger than MI_MAX_BLOCK_LENGTH */
tmp= MY_MIN(length+tmp, MI_MAX_BLOCK_LENGTH)-length;
/* Check if we can extend this block */
if (block_info.filepos + block_info.block_len ==
info->state->data_file_length &&
info->state->data_file_length <
info->s->base.max_data_file_length-tmp)
{
/* extend file */
DBUG_PRINT("info",("Extending file with %d bytes",tmp));
if (info->nextpos == info->state->data_file_length)
info->nextpos+= tmp;
info->state->data_file_length+= tmp;
info->update|= HA_STATE_WRITE_AT_END | HA_STATE_EXTEND_BLOCK;
length+=tmp;
}
else if (length < MI_MAX_BLOCK_LENGTH - MI_MIN_BLOCK_LENGTH)
{
/*
Check if next block is a deleted block
Above we have MI_MIN_BLOCK_LENGTH to avoid the problem where
the next block is so small it can't be split which could
cause problems
*/
MI_BLOCK_INFO del_block;
del_block.second_read=0;
if (_mi_get_block_info(&del_block,info->dfile,
block_info.filepos + block_info.block_len) &
BLOCK_DELETED)
{
/* Use; Unlink it and extend the current block */
DBUG_PRINT("info",("Extending current block"));
if (unlink_deleted_block(info,&del_block))
goto err;
if ((length+=del_block.block_len) > MI_MAX_BLOCK_LENGTH)
{
/*
New block was too big, link overflow part back to
delete list
*/
my_off_t next_pos;
ulong rest_length= length-MI_MAX_BLOCK_LENGTH;
set_if_bigger(rest_length, MI_MIN_BLOCK_LENGTH);
next_pos= del_block.filepos+ del_block.block_len - rest_length;
if (update_backward_delete_link(info, info->s->state.dellink,
next_pos))
DBUG_RETURN(1);
/* create delete link for data that didn't fit into the page */
del_block.header[0]=0;
mi_int3store(del_block.header+1, rest_length);
mi_sizestore(del_block.header+4,info->s->state.dellink);
bfill(del_block.header+12,8,255);
if (info->s->file_write(info,(uchar*) del_block.header,20, next_pos,
MYF(MY_NABP)))
DBUG_RETURN(1);
info->s->state.dellink= next_pos;
info->s->state.split++;
info->state->del++;
info->state->empty+= rest_length;
length-= rest_length;
}
}
}
}
}
else
{
if (_mi_find_writepos(info,reclength,&filepos,&length))
goto err;
}
if (_mi_write_part_record(info,filepos,length,block_info.next_filepos,
&record,&reclength,&flag))
goto err;
if ((filepos=block_info.next_filepos) == HA_OFFSET_ERROR)
{
/* Start writing data on deleted blocks */
filepos=info->s->state.dellink;
}
}
if (block_info.next_filepos != HA_OFFSET_ERROR)
{
/*
delete_dynamic_record() may change data file position.
IO cache must be notified as it may still have cached
data, which has to be flushed later.
*/
info->rec_cache.seek_not_done= 1;
if (delete_dynamic_record(info,block_info.next_filepos,1))
goto err;
}
DBUG_RETURN(0);
err:
DBUG_RETURN(1);
} | O3 | c | update_dynamic_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0xf0(%rbp)
movq %rdx, -0x110(%rbp)
movq %rcx, -0x108(%rbp)
xorl %eax, %eax
movl %eax, -0x38(%rbp)
movl %eax, -0xf4(%rbp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq 0x110(%rax), %rax
subq 0x28(%rcx), %rax
cmpq %r13, %rax
jb 0x317bc
testq %r13, %r13
je 0x3178e
leaq -0x108(%rbp), %r15
movq (%rbx), %rax
cmpq 0x58(%rax), %r14
jne 0x314ec
movq %rbx, %rdi
movq %r13, %rsi
leaq -0xf0(%rbp), %rdx
leaq -0xe8(%rbp), %rcx
callq 0x33d21
testl %eax, %eax
jne 0x3182b
movq -0xf0(%rbp), %r14
movq -0xe8(%rbp), %r12
jmp 0x3172b
movq $-0x1, -0x48(%rbp)
movl 0x1c0(%rbx), %esi
leaq -0x88(%rbp), %rdi
movq %r14, %rdx
callq 0x322cf
cmpl $0x4, %eax
jae 0x31820
movq -0x60(%rbp), %rdx
movq -0x50(%rbp), %rax
movq %rax, %r12
subq %r14, %r12
addq %rdx, %r12
movq %r12, -0xe8(%rbp)
cmpq %r13, %r12
jae 0x3172b
addq %rax, %rdx
movq 0x8(%rbx), %rax
cmpq 0x28(%rax), %rdx
jne 0x315a7
cmpq $0xfff0, %r13 # imm = 0xFFF0
sbbl $-0x1, %r13d
subl %r12d, %r13d
addl $0x6, %r13d
andl $-0x4, %r13d
addq %r12, %r13
movl $0xfffffc, %ecx # imm = 0xFFFFFC
cmpq %rcx, %r13
cmovaeq %rcx, %r13
subl %r12d, %r13d
movq (%rbx), %rcx
movq 0x110(%rcx), %rcx
subq %r13, %rcx
cmpq %rcx, %rdx
jae 0x315a7
cmpq %rdx, 0x178(%rbx)
jne 0x31591
addq %r13, %rdx
movq %rdx, 0x178(%rbx)
movq 0x28(%rax), %rdx
addq %r13, %rdx
movq %rdx, 0x28(%rax)
orb $0x9, 0x1d1(%rbx)
addq %r13, %r12
jmp 0x31724
cmpq $0xffffe7, %r12 # imm = 0xFFFFE7
ja 0x3172b
movl $0x0, -0x90(%rbp)
movl 0x1c0(%rbx), %esi
leaq -0xe0(%rbp), %r13
movq %r13, %rdi
callq 0x322cf
testb $0x4, %al
je 0x3172b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x326a5
testb %al, %al
jne 0x3182b
movq -0xb8(%rbp), %r13
addq %r13, %r12
movq %r12, -0xe8(%rbp)
cmpq $0xfffffd, %r12 # imm = 0xFFFFFD
jb 0x3172b
leaq -0xfffffc(%r12), %rcx
cmpq $0x15, %rcx
movl $0x14, %eax
cmovbq %rax, %rcx
movq %rcx, -0x100(%rbp)
subq %rcx, %r13
addq -0xa8(%rbp), %r13
movq (%rbx), %rax
movq 0x58(%rax), %rsi
movq %rbx, %rdi
movq %r13, %rdx
callq 0x327d6
testl %eax, %eax
jne 0x3182b
movb $0x0, -0xe0(%rbp)
movq -0x100(%rbp), %rax
movb %al, -0xdd(%rbp)
movb %ah, -0xde(%rbp)
shrl $0x10, %eax
movb %al, -0xdf(%rbp)
movq (%rbx), %rax
movq 0x58(%rax), %rcx
movq %rcx, %rdx
shrq $0x20, %rdx
movb %dl, -0xd9(%rbp)
movq %rcx, %rdx
shrq $0x28, %rdx
movb %dl, -0xda(%rbp)
movq %rcx, %rdx
shrq $0x30, %rdx
movb %dl, -0xdb(%rbp)
movq %rcx, %rdx
shrq $0x38, %rdx
movb %dl, -0xdc(%rbp)
movb %cl, -0xd5(%rbp)
movb %ch, -0xd6(%rbp)
movl %ecx, %edx
shrl $0x10, %edx
movb %dl, -0xd7(%rbp)
shrl $0x18, %ecx
movb %cl, -0xd8(%rbp)
movq $-0x1, -0xd4(%rbp)
movl $0x14, %edx
movl $0x4, %r8d
movq %rbx, %rdi
leaq -0xe0(%rbp), %rsi
movq %r13, %rcx
callq *0x2e8(%rax)
testq %rax, %rax
jne 0x3182b
movq (%rbx), %rax
movq %r13, 0x58(%rax)
movq (%rbx), %rax
incq 0x50(%rax)
movq 0x8(%rbx), %rax
incq 0x8(%rax)
movq 0x8(%rbx), %rax
movq -0x100(%rbp), %rcx
addq %rcx, 0x10(%rax)
subq %rcx, %r12
movq %r12, -0xe8(%rbp)
movq -0x48(%rbp), %rcx
leaq -0xf4(%rbp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
leaq -0x110(%rbp), %r8
movq %r15, %r9
callq 0x31be8
testl %eax, %eax
jne 0x3182b
movq -0x48(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
movq %rsi, %r14
cmpq $-0x1, %rsi
jne 0x3177c
movq (%rbx), %rax
movq 0x58(%rax), %r14
movq %r14, -0xf0(%rbp)
movq -0x108(%rbp), %r13
testq %r13, %r13
jne 0x314af
jmp 0x31792
movq -0x48(%rbp), %rsi
xorl %r14d, %r14d
cmpq $-0x1, %rsi
je 0x31831
movl $0x1, 0x300(%rbx)
movq %rbx, %rdi
movl $0x1, %edx
callq 0x31a13
testl %eax, %eax
jne 0x3182b
jmp 0x31831
movl 0x1c0(%rbx), %esi
leaq -0x88(%rbp), %rdi
movq %r14, %rdx
callq 0x322cf
cmpl $0x4, %eax
jae 0x31820
movq -0x70(%rbp), %rax
cmpq %r13, %rax
jae 0x31855
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq 0x110(%rcx), %rcx
subq 0x28(%rdx), %rcx
addq 0x10(%rdx), %rcx
movq 0x8(%rdx), %rdx
shlq $0x2, %rdx
leaq (%rdx,%rdx,4), %rdx
subq %rdx, %rcx
movq %r13, %rdx
subq %rax, %rdx
addq $0x14, %rdx
cmpq %rdx, %rcx
jae 0x31855
callq 0x5ed5e
movl $0x87, (%rax)
jmp 0x3182b
callq 0x5ed5e
movl $0x7f, (%rax)
movl $0x1, %r14d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x31861
movl %r14d, %eax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, -0x38(%rbp)
jmp 0x314a8
callq 0x28430
| update_dynamic_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0F8h
mov r13, rcx
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov [rbp+var_F0], rsi
mov [rbp+var_110], rdx
mov [rbp+var_108], rcx
xor eax, eax
mov [rbp+var_38], eax
mov [rbp+var_F4], eax
mov rax, [rdi]
mov rcx, [rdi+8]
mov rax, [rax+110h]
sub rax, [rcx+28h]
cmp rax, r13
jb loc_317BC
test r13, r13
jz loc_3178E
loc_314A8:
lea r15, [rbp+var_108]
loc_314AF:
mov rax, [rbx]
cmp r14, [rax+58h]
jnz short loc_314EC
mov rdi, rbx
mov rsi, r13
lea rdx, [rbp+var_F0]
lea rcx, [rbp+var_E8]
call _mi_find_writepos
test eax, eax
jnz loc_3182B
mov r14, [rbp+var_F0]
mov r12, [rbp+var_E8]
jmp loc_3172B
loc_314EC:
mov [rbp+var_48], 0FFFFFFFFFFFFFFFFh
mov esi, [rbx+1C0h]
lea rdi, [rbp+var_88]
mov rdx, r14
call _mi_get_block_info
cmp eax, 4
jnb loc_31820
mov rdx, [rbp+var_60]
mov rax, [rbp+var_50]
mov r12, rax
sub r12, r14
add r12, rdx
mov [rbp+var_E8], r12
cmp r12, r13
jnb loc_3172B
add rdx, rax
mov rax, [rbx+8]
cmp rdx, [rax+28h]
jnz short loc_315A7
cmp r13, 0FFF0h
sbb r13d, 0FFFFFFFFh
sub r13d, r12d
add r13d, 6
and r13d, 0FFFFFFFCh
add r13, r12
mov ecx, 0FFFFFCh
cmp r13, rcx
cmovnb r13, rcx
sub r13d, r12d
mov rcx, [rbx]
mov rcx, [rcx+110h]
sub rcx, r13
cmp rdx, rcx
jnb short loc_315A7
cmp [rbx+178h], rdx
jnz short loc_31591
add rdx, r13
mov [rbx+178h], rdx
mov rdx, [rax+28h]
loc_31591:
add rdx, r13
mov [rax+28h], rdx
or byte ptr [rbx+1D1h], 9
add r12, r13
jmp loc_31724
loc_315A7:
cmp r12, 0FFFFE7h
ja loc_3172B
mov [rbp+var_90], 0
mov esi, [rbx+1C0h]
lea r13, [rbp+var_E0]
mov rdi, r13
call _mi_get_block_info
test al, 4
jz loc_3172B
mov rdi, rbx
mov rsi, r13
call unlink_deleted_block
test al, al
jnz loc_3182B
mov r13, [rbp+var_B8]
add r12, r13
mov [rbp+var_E8], r12
cmp r12, 0FFFFFDh
jb loc_3172B
lea rcx, [r12-0FFFFFCh]
cmp rcx, 15h
mov eax, 14h
cmovb rcx, rax
mov [rbp+var_100], rcx
sub r13, rcx
add r13, [rbp+var_A8]
mov rax, [rbx]
mov rsi, [rax+58h]
mov rdi, rbx
mov rdx, r13
call update_backward_delete_link
test eax, eax
jnz loc_3182B
mov [rbp+var_E0], 0
mov rax, [rbp+var_100]
mov [rbp+var_DD], al
mov [rbp+var_DE], ah
shr eax, 10h
mov [rbp+var_DF], al
mov rax, [rbx]
mov rcx, [rax+58h]
mov rdx, rcx
shr rdx, 20h
mov [rbp+var_D9], dl
mov rdx, rcx
shr rdx, 28h
mov [rbp+var_DA], dl
mov rdx, rcx
shr rdx, 30h
mov [rbp+var_DB], dl
mov rdx, rcx
shr rdx, 38h
mov [rbp+var_DC], dl
mov [rbp+var_D5], cl
mov [rbp+var_D6], ch
mov edx, ecx
shr edx, 10h
mov [rbp+var_D7], dl
shr ecx, 18h
mov [rbp+var_D8], cl
mov [rbp+var_D4], 0FFFFFFFFFFFFFFFFh
mov edx, 14h
mov r8d, 4
mov rdi, rbx
lea rsi, [rbp+var_E0]
mov rcx, r13
call qword ptr [rax+2E8h]
test rax, rax
jnz loc_3182B
mov rax, [rbx]
mov [rax+58h], r13
mov rax, [rbx]
inc qword ptr [rax+50h]
mov rax, [rbx+8]
inc qword ptr [rax+8]
mov rax, [rbx+8]
mov rcx, [rbp+var_100]
add [rax+10h], rcx
sub r12, rcx
loc_31724:
mov [rbp+var_E8], r12
loc_3172B:
mov rcx, [rbp+var_48]
lea rax, [rbp+var_F4]
mov [rsp+120h+var_120], rax
mov rdi, rbx
mov rsi, r14
mov rdx, r12
lea r8, [rbp+var_110]
mov r9, r15
call _mi_write_part_record
test eax, eax
jnz loc_3182B
mov rsi, [rbp+var_48]
mov [rbp+var_F0], rsi
mov r14, rsi
cmp rsi, 0FFFFFFFFFFFFFFFFh
jnz short loc_3177C
mov rax, [rbx]
mov r14, [rax+58h]
mov [rbp+var_F0], r14
loc_3177C:
mov r13, [rbp+var_108]
test r13, r13
jnz loc_314AF
jmp short loc_31792
loc_3178E:
mov rsi, [rbp+var_48]
loc_31792:
xor r14d, r14d
cmp rsi, 0FFFFFFFFFFFFFFFFh
jz loc_31831
mov dword ptr [rbx+300h], 1
mov rdi, rbx
mov edx, 1
call delete_dynamic_record
test eax, eax
jnz short loc_3182B
jmp short loc_31831
loc_317BC:
mov esi, [rbx+1C0h]
lea rdi, [rbp+var_88]
mov rdx, r14
call _mi_get_block_info
cmp eax, 4
jnb short loc_31820
mov rax, [rbp+var_70]
cmp rax, r13
jnb short loc_31855
mov rcx, [rbx]
mov rdx, [rbx+8]
mov rcx, [rcx+110h]
sub rcx, [rdx+28h]
add rcx, [rdx+10h]
mov rdx, [rdx+8]
shl rdx, 2
lea rdx, [rdx+rdx*4]
sub rcx, rdx
mov rdx, r13
sub rdx, rax
add rdx, 14h
cmp rcx, rdx
jnb short loc_31855
call _my_thread_var
mov dword ptr [rax], 87h
jmp short loc_3182B
loc_31820:
call _my_thread_var
mov dword ptr [rax], 7Fh
loc_3182B:
mov r14d, 1
loc_31831:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_31861
mov eax, r14d
add rsp, 0F8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_31855:
mov [rbp+var_38], 0
jmp loc_314A8
loc_31861:
call ___stack_chk_fail
| long long update_dynamic_record(long long *a1, long long a2, long long a3, unsigned long long a4)
{
unsigned long long v4; // r13
long long v5; // r14
unsigned long long v6; // r12
const char *v7; // rsi
unsigned long long v8; // rdx
long long v9; // rax
unsigned long long v10; // r13
long long v11; // r13
long long v12; // rcx
long long v13; // r13
long long v14; // rax
long long v15; // rcx
long long v16; // rcx
long long v17; // rsi
unsigned int v18; // r14d
long long v20; // [rsp+10h] [rbp-110h] BYREF
unsigned long long v21; // [rsp+18h] [rbp-108h] BYREF
long long v22; // [rsp+20h] [rbp-100h]
int v23; // [rsp+2Ch] [rbp-F4h] BYREF
long long v24; // [rsp+30h] [rbp-F0h] BYREF
unsigned long long v25; // [rsp+38h] [rbp-E8h] BYREF
_BYTE v26[12]; // [rsp+40h] [rbp-E0h] BYREF
long long v27; // [rsp+4Ch] [rbp-D4h]
long long v28; // [rsp+68h] [rbp-B8h]
long long v29; // [rsp+78h] [rbp-A8h]
int v30; // [rsp+90h] [rbp-90h]
_BYTE v31[24]; // [rsp+98h] [rbp-88h] BYREF
unsigned long long v32; // [rsp+B0h] [rbp-70h]
long long v33; // [rsp+C0h] [rbp-60h]
long long v34; // [rsp+D0h] [rbp-50h]
long long v35; // [rsp+D8h] [rbp-48h]
int v36; // [rsp+E8h] [rbp-38h]
unsigned long long v37; // [rsp+F0h] [rbp-30h]
v4 = a4;
v5 = a2;
v37 = __readfsqword(0x28u);
v24 = a2;
v20 = a3;
v21 = a4;
v36 = 0;
v23 = 0;
if ( *(_QWORD *)(*a1 + 272) - *(_QWORD *)(a1[1] + 40) < a4 )
{
v7 = (const char *)*((unsigned int *)a1 + 112);
if ( (unsigned int)mi_get_block_info(v31, v7, v5) >= 4 )
{
LABEL_38:
*(_DWORD *)my_thread_var(v31, v7) = 127;
return 1;
}
if ( v32 < v4
&& *(_QWORD *)(a1[1] + 16) + *(_QWORD *)(*a1 + 272) - *(_QWORD *)(a1[1] + 40) - 20LL * *(_QWORD *)(a1[1] + 8) < v4 - v32 + 20 )
{
*(_DWORD *)my_thread_var(v31, v7) = 135;
return 1;
}
v36 = 0;
while ( 1 )
{
LABEL_3:
if ( v5 == *(_QWORD *)(*a1 + 88) )
{
if ( (unsigned int)mi_find_writepos(a1, v4, &v24, &v25) )
return 1;
LODWORD(v5) = v24;
LODWORD(v6) = v25;
}
else
{
v35 = -1LL;
v7 = (const char *)*((unsigned int *)a1 + 112);
if ( (unsigned int)mi_get_block_info(v31, v7, v5) >= 4 )
goto LABEL_38;
v6 = v33 + v34 - v5;
v25 = v6;
if ( v6 < v4 )
{
v8 = v34 + v33;
v9 = a1[1];
if ( v34 + v33 != *(_QWORD *)(v9 + 40) )
goto LABEL_44;
v10 = v6 + (((_DWORD)v4 - ((v4 < 0xFFF0) - 1) - (_DWORD)v6 + 6) & 0xFFFFFFFC);
if ( v10 >= 0xFFFFFC )
LODWORD(v10) = 16777212;
v11 = (unsigned int)(v10 - v6);
if ( v8 < *(_QWORD *)(*a1 + 272) - v11 )
{
if ( a1[47] == v8 )
{
a1[47] = v11 + v8;
v8 = *(_QWORD *)(v9 + 40);
}
*(_QWORD *)(v9 + 40) = v11 + v8;
*((_BYTE *)a1 + 465) |= 9u;
v6 += v11;
}
else
{
LABEL_44:
if ( v6 > 0xFFFFE7 )
goto LABEL_25;
v30 = 0;
if ( (mi_get_block_info(v26, *((unsigned int *)a1 + 112), v8) & 4) == 0 )
goto LABEL_25;
if ( (unsigned __int8)unlink_deleted_block(a1, v26) )
return 1;
v6 += v28;
v25 = v6;
if ( v6 < 0xFFFFFD )
goto LABEL_25;
v12 = v6 - 16777212;
if ( v6 - 16777212 < 0x15 )
v12 = 20LL;
v22 = v12;
v13 = v29 + v28 - v12;
if ( (unsigned int)update_backward_delete_link(a1, *(_QWORD *)(*a1 + 88), v13) )
return 1;
v26[0] = 0;
v26[2] = BYTE1(v22);
v26[3] = v22;
v26[1] = BYTE2(v22);
v14 = *a1;
v15 = *(_QWORD *)(*a1 + 88);
v26[7] = BYTE4(v15);
v26[6] = BYTE5(v15);
v26[5] = BYTE6(v15);
v26[4] = HIBYTE(v15);
v26[10] = BYTE1(v15);
v26[11] = v15;
v26[9] = BYTE2(v15);
v26[8] = BYTE3(v15);
v27 = -1LL;
if ( (*(long long ( **)(long long *, _BYTE *, long long, long long, long long))(v14 + 744))(
a1,
v26,
20LL,
v13,
4LL) )
{
return 1;
}
*(_QWORD *)(*a1 + 88) = v13;
++*(_QWORD *)(*a1 + 80);
++*(_QWORD *)(a1[1] + 8);
v16 = v22;
*(_QWORD *)(a1[1] + 16) += v22;
v6 -= v16;
}
v25 = v6;
}
}
LABEL_25:
if ( (unsigned int)mi_write_part_record(
(_DWORD)a1,
v5,
v6,
v35,
(unsigned int)&v20,
(unsigned int)&v21,
(long long)&v23) )
return 1;
v17 = v35;
v24 = v35;
v5 = v35;
if ( v35 == -1 )
{
v5 = *(_QWORD *)(*a1 + 88);
v24 = v5;
}
v4 = v21;
if ( !v21 )
goto LABEL_31;
}
}
if ( a4 )
goto LABEL_3;
v17 = v35;
LABEL_31:
v18 = 0;
if ( v17 != -1 )
{
*((_DWORD *)a1 + 192) = 1;
if ( (unsigned int)delete_dynamic_record(a1, v17, 1LL) )
return 1;
}
return v18;
}
| update_dynamic_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xf8
MOV R13,RCX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV qword ptr [RBP + -0xf0],RSI
MOV qword ptr [RBP + -0x110],RDX
MOV qword ptr [RBP + -0x108],RCX
XOR EAX,EAX
MOV dword ptr [RBP + -0x38],EAX
MOV dword ptr [RBP + -0xf4],EAX
MOV RAX,qword ptr [RDI]
MOV RCX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RAX + 0x110]
SUB RAX,qword ptr [RCX + 0x28]
CMP RAX,R13
JC 0x001317bc
TEST R13,R13
JZ 0x0013178e
LAB_001314a8:
LEA R15,[RBP + -0x108]
LAB_001314af:
MOV RAX,qword ptr [RBX]
CMP R14,qword ptr [RAX + 0x58]
JNZ 0x001314ec
MOV RDI,RBX
MOV RSI,R13
LEA RDX,[RBP + -0xf0]
LEA RCX,[RBP + -0xe8]
CALL 0x00133d21
TEST EAX,EAX
JNZ 0x0013182b
MOV R14,qword ptr [RBP + -0xf0]
MOV R12,qword ptr [RBP + -0xe8]
JMP 0x0013172b
LAB_001314ec:
MOV qword ptr [RBP + -0x48],-0x1
MOV ESI,dword ptr [RBX + 0x1c0]
LEA RDI,[RBP + -0x88]
MOV RDX,R14
CALL 0x001322cf
CMP EAX,0x4
JNC 0x00131820
MOV RDX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x50]
MOV R12,RAX
SUB R12,R14
ADD R12,RDX
MOV qword ptr [RBP + -0xe8],R12
CMP R12,R13
JNC 0x0013172b
ADD RDX,RAX
MOV RAX,qword ptr [RBX + 0x8]
CMP RDX,qword ptr [RAX + 0x28]
JNZ 0x001315a7
CMP R13,0xfff0
SBB R13D,-0x1
SUB R13D,R12D
ADD R13D,0x6
AND R13D,0xfffffffc
ADD R13,R12
MOV ECX,0xfffffc
CMP R13,RCX
CMOVNC R13,RCX
SUB R13D,R12D
MOV RCX,qword ptr [RBX]
MOV RCX,qword ptr [RCX + 0x110]
SUB RCX,R13
CMP RDX,RCX
JNC 0x001315a7
CMP qword ptr [RBX + 0x178],RDX
JNZ 0x00131591
ADD RDX,R13
MOV qword ptr [RBX + 0x178],RDX
MOV RDX,qword ptr [RAX + 0x28]
LAB_00131591:
ADD RDX,R13
MOV qword ptr [RAX + 0x28],RDX
OR byte ptr [RBX + 0x1d1],0x9
ADD R12,R13
JMP 0x00131724
LAB_001315a7:
CMP R12,0xffffe7
JA 0x0013172b
MOV dword ptr [RBP + -0x90],0x0
MOV ESI,dword ptr [RBX + 0x1c0]
LEA R13,[RBP + -0xe0]
MOV RDI,R13
CALL 0x001322cf
TEST AL,0x4
JZ 0x0013172b
MOV RDI,RBX
MOV RSI,R13
CALL 0x001326a5
TEST AL,AL
JNZ 0x0013182b
MOV R13,qword ptr [RBP + -0xb8]
ADD R12,R13
MOV qword ptr [RBP + -0xe8],R12
CMP R12,0xfffffd
JC 0x0013172b
LEA RCX,[R12 + -0xfffffc]
CMP RCX,0x15
MOV EAX,0x14
CMOVC RCX,RAX
MOV qword ptr [RBP + -0x100],RCX
SUB R13,RCX
ADD R13,qword ptr [RBP + -0xa8]
MOV RAX,qword ptr [RBX]
MOV RSI,qword ptr [RAX + 0x58]
MOV RDI,RBX
MOV RDX,R13
CALL 0x001327d6
TEST EAX,EAX
JNZ 0x0013182b
MOV byte ptr [RBP + -0xe0],0x0
MOV RAX,qword ptr [RBP + -0x100]
MOV byte ptr [RBP + -0xdd],AL
MOV byte ptr [RBP + -0xde],AH
SHR EAX,0x10
MOV byte ptr [RBP + -0xdf],AL
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RAX + 0x58]
MOV RDX,RCX
SHR RDX,0x20
MOV byte ptr [RBP + -0xd9],DL
MOV RDX,RCX
SHR RDX,0x28
MOV byte ptr [RBP + -0xda],DL
MOV RDX,RCX
SHR RDX,0x30
MOV byte ptr [RBP + -0xdb],DL
MOV RDX,RCX
SHR RDX,0x38
MOV byte ptr [RBP + -0xdc],DL
MOV byte ptr [RBP + -0xd5],CL
MOV byte ptr [RBP + -0xd6],CH
MOV EDX,ECX
SHR EDX,0x10
MOV byte ptr [RBP + -0xd7],DL
SHR ECX,0x18
MOV byte ptr [RBP + -0xd8],CL
MOV qword ptr [RBP + -0xd4],-0x1
MOV EDX,0x14
MOV R8D,0x4
MOV RDI,RBX
LEA RSI,[RBP + -0xe0]
MOV RCX,R13
CALL qword ptr [RAX + 0x2e8]
TEST RAX,RAX
JNZ 0x0013182b
MOV RAX,qword ptr [RBX]
MOV qword ptr [RAX + 0x58],R13
MOV RAX,qword ptr [RBX]
INC qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBX + 0x8]
INC qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RBP + -0x100]
ADD qword ptr [RAX + 0x10],RCX
SUB R12,RCX
LAB_00131724:
MOV qword ptr [RBP + -0xe8],R12
LAB_0013172b:
MOV RCX,qword ptr [RBP + -0x48]
LEA RAX,[RBP + -0xf4]
MOV qword ptr [RSP],RAX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R12
LEA R8,[RBP + -0x110]
MOV R9,R15
CALL 0x00131be8
TEST EAX,EAX
JNZ 0x0013182b
MOV RSI,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0xf0],RSI
MOV R14,RSI
CMP RSI,-0x1
JNZ 0x0013177c
MOV RAX,qword ptr [RBX]
MOV R14,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0xf0],R14
LAB_0013177c:
MOV R13,qword ptr [RBP + -0x108]
TEST R13,R13
JNZ 0x001314af
JMP 0x00131792
LAB_0013178e:
MOV RSI,qword ptr [RBP + -0x48]
LAB_00131792:
XOR R14D,R14D
CMP RSI,-0x1
JZ 0x00131831
MOV dword ptr [RBX + 0x300],0x1
MOV RDI,RBX
MOV EDX,0x1
CALL 0x00131a13
TEST EAX,EAX
JNZ 0x0013182b
JMP 0x00131831
LAB_001317bc:
MOV ESI,dword ptr [RBX + 0x1c0]
LEA RDI,[RBP + -0x88]
MOV RDX,R14
CALL 0x001322cf
CMP EAX,0x4
JNC 0x00131820
MOV RAX,qword ptr [RBP + -0x70]
CMP RAX,R13
JNC 0x00131855
MOV RCX,qword ptr [RBX]
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,qword ptr [RCX + 0x110]
SUB RCX,qword ptr [RDX + 0x28]
ADD RCX,qword ptr [RDX + 0x10]
MOV RDX,qword ptr [RDX + 0x8]
SHL RDX,0x2
LEA RDX,[RDX + RDX*0x4]
SUB RCX,RDX
MOV RDX,R13
SUB RDX,RAX
ADD RDX,0x14
CMP RCX,RDX
JNC 0x00131855
CALL 0x0015ed5e
MOV dword ptr [RAX],0x87
JMP 0x0013182b
LAB_00131820:
CALL 0x0015ed5e
MOV dword ptr [RAX],0x7f
LAB_0013182b:
MOV R14D,0x1
LAB_00131831:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00131861
MOV EAX,R14D
ADD RSP,0xf8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00131855:
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001314a8
LAB_00131861:
CALL 0x00128430
|
int8 update_dynamic_record(long *param_1,long param_2,int8 param_3,ulong param_4)
{
char cVar1;
int iVar2;
uint uVar3;
long lVar4;
int4 *puVar5;
ulong uVar6;
ulong uVar7;
ulong uVar8;
long lVar9;
int8 uVar10;
long in_FS_OFFSET;
int8 local_118;
ulong local_110;
ulong local_108;
int4 local_fc;
long local_f8;
ulong local_f0;
int1 local_e8;
int1 local_e7;
int1 local_e6;
int1 local_e5;
int1 local_e4;
int1 local_e3;
int1 local_e2;
int1 local_e1;
int1 local_e0;
int1 local_df;
int1 local_de;
int1 local_dd;
int8 local_dc;
long local_c0;
long local_b0;
int4 local_98;
int1 local_90 [24];
ulong local_78;
long local_68;
long local_58;
long local_50;
int4 local_40;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_40 = 0;
local_fc = 0;
local_118 = param_3;
local_110 = param_4;
local_f8 = param_2;
if ((ulong)(*(long *)(*param_1 + 0x110) - *(long *)(param_1[1] + 0x28)) < param_4) {
uVar3 = _mi_get_block_info(local_90,(int)param_1[0x38],param_2);
if (uVar3 < 4) {
if ((param_4 <= local_78) ||
(lVar9 = param_1[1],
(param_4 - local_78) + 0x14 <=
(ulong)((*(long *)(*param_1 + 0x110) - *(long *)(lVar9 + 0x28)) + *(long *)(lVar9 + 0x10) +
*(long *)(lVar9 + 8) * -0x14))) goto LAB_001314a8;
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x87;
}
else {
LAB_00131820:
puVar5 = (int4 *)_my_thread_var();
*puVar5 = 0x7f;
}
}
else {
if (param_4 != 0) {
LAB_001314a8:
local_40 = 0;
do {
if (param_2 == *(long *)(*param_1 + 0x58)) {
iVar2 = _mi_find_writepos(param_1,param_4,&local_f8,&local_f0);
uVar7 = local_f0;
param_2 = local_f8;
if (iVar2 != 0) goto LAB_0013182b;
}
else {
local_50 = -1;
uVar3 = _mi_get_block_info(local_90,(int)param_1[0x38],param_2);
if (3 < uVar3) goto LAB_00131820;
uVar7 = (local_58 - param_2) + local_68;
local_f0 = uVar7;
if (uVar7 < param_4) {
uVar6 = local_68 + local_58;
lVar9 = param_1[1];
if (uVar6 == *(ulong *)(lVar9 + 0x28)) {
uVar8 = ((((int)param_4 - (uint)(param_4 < 0xfff0)) - (int)uVar7) + 7 & 0xfffffffc) +
uVar7;
if (0xfffffb < uVar8) {
uVar8 = 0xfffffc;
}
uVar8 = (ulong)(uint)((int)uVar8 - (int)uVar7);
if (uVar6 < *(long *)(*param_1 + 0x110) - uVar8) {
if (param_1[0x2f] == uVar6) {
param_1[0x2f] = uVar6 + uVar8;
uVar6 = *(ulong *)(lVar9 + 0x28);
}
*(ulong *)(lVar9 + 0x28) = uVar6 + uVar8;
*(byte *)((long)param_1 + 0x1d1) = *(byte *)((long)param_1 + 0x1d1) | 9;
local_f0 = uVar7 + uVar8;
uVar7 = local_f0;
goto LAB_0013172b;
}
}
if (uVar7 < 0xffffe8) {
local_98 = 0;
uVar6 = _mi_get_block_info(&local_e8,(int)param_1[0x38]);
if ((uVar6 & 4) != 0) {
cVar1 = unlink_deleted_block(param_1,&local_e8);
if (cVar1 != '\0') goto LAB_0013182b;
uVar7 = uVar7 + local_c0;
local_f0 = uVar7;
if (0xfffffc < uVar7) {
local_108 = uVar7 - 0xfffffc;
if (local_108 < 0x15) {
local_108 = 0x14;
}
lVar9 = (local_c0 - local_108) + local_b0;
iVar2 = update_backward_delete_link
(param_1,*(int8 *)(*param_1 + 0x58),lVar9);
if (iVar2 != 0) goto LAB_0013182b;
local_e8 = 0;
local_e5 = (int1)local_108;
local_e6 = (int1)(local_108 >> 8);
local_e7 = (int1)(local_108 >> 0x10);
uVar10 = *(int8 *)(*param_1 + 0x58);
local_e1 = (int1)((ulong)uVar10 >> 0x20);
local_e2 = (int1)((ulong)uVar10 >> 0x28);
local_e3 = (int1)((ulong)uVar10 >> 0x30);
local_e4 = (int1)((ulong)uVar10 >> 0x38);
local_dd = (int1)uVar10;
local_de = (int1)((ulong)uVar10 >> 8);
local_df = (int1)((ulong)uVar10 >> 0x10);
local_e0 = (int1)((ulong)uVar10 >> 0x18);
local_dc = 0xffffffffffffffff;
lVar4 = (**(code **)(*param_1 + 0x2e8))(param_1,&local_e8,0x14,lVar9,4);
if (lVar4 != 0) goto LAB_0013182b;
*(long *)(*param_1 + 0x58) = lVar9;
*(long *)(*param_1 + 0x50) = *(long *)(*param_1 + 0x50) + 1;
*(long *)(param_1[1] + 8) = *(long *)(param_1[1] + 8) + 1;
*(long *)(param_1[1] + 0x10) = *(long *)(param_1[1] + 0x10) + local_108;
local_f0 = uVar7 - local_108;
uVar7 = local_f0;
}
}
}
}
}
LAB_0013172b:
iVar2 = _mi_write_part_record
(param_1,param_2,uVar7,local_50,&local_118,&local_110,&local_fc);
if (iVar2 != 0) goto LAB_0013182b;
param_2 = local_50;
if (local_50 == -1) {
param_2 = *(long *)(*param_1 + 0x58);
}
param_4 = local_110;
local_f8 = param_2;
} while (local_110 != 0);
}
uVar10 = 0;
if (local_50 == -1) goto LAB_00131831;
*(int4 *)(param_1 + 0x60) = 1;
iVar2 = delete_dynamic_record(param_1,local_50,1);
if (iVar2 == 0) goto LAB_00131831;
}
LAB_0013182b:
uVar10 = 1;
LAB_00131831:
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return uVar10;
}
| |
22,998 | js_os_chdir | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_chdir(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *target;
int err;
target = JS_ToCString(ctx, argv[0]);
if (!target)
return JS_EXCEPTION;
err = js_get_errno(chdir(target));
JS_FreeCString(ctx, target);
return JS_NewInt32(ctx, err);
} | O0 | c | js_os_chdir:
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x147e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x198f2
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x1994e
movq 0x8(%rsp), %rdi
callq 0xe250
movslq %eax, %rdi
callq 0x13a50
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x29e50
movq 0x20(%rsp), %rcx
movl 0x4(%rsp), %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x58(%rsp)
movq $0x0, 0x60(%rsp)
movq 0x58(%rsp), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x68, %rsp
retq
nopl (%rax)
| js_os_chdir:
sub rsp, 68h
mov [rsp+68h+var_40], rsi
mov [rsp+68h+var_38], rdx
mov [rsp+68h+var_48], rdi
mov [rsp+68h+var_4C], ecx
mov [rsp+68h+var_58], r8
mov rdi, [rsp+68h+var_48]
mov rax, [rsp+68h+var_58]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToCString
mov [rsp+68h+var_60], rax
cmp [rsp+68h+var_60], 0
jnz short loc_198F2
mov dword ptr [rsp+68h+var_30], 0
mov [rsp+68h+var_28], 6
jmp short loc_1994E
loc_198F2:
mov rdi, [rsp+68h+var_60]
call _chdir
movsxd rdi, eax
call js_get_errno
mov [rsp+68h+var_64], eax
mov rdi, [rsp+68h+var_48]
mov rsi, [rsp+68h+var_60]
call JS_FreeCString
mov rcx, [rsp+68h+var_48]
mov eax, [rsp+68h+var_64]
mov [rsp+68h+var_18], rcx
mov [rsp+68h+var_1C], eax
mov eax, [rsp+68h+var_1C]
mov dword ptr [rsp+68h+var_10], eax
mov [rsp+68h+var_8], 0
mov rcx, [rsp+68h+var_10]
mov rax, [rsp+68h+var_8]
mov [rsp+68h+var_30], rcx
mov [rsp+68h+var_28], rax
loc_1994E:
mov rax, [rsp+68h+var_30]
mov rdx, [rsp+68h+var_28]
add rsp, 68h
retn
| long long js_os_chdir(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
int v5; // eax
int errno; // [rsp+4h] [rbp-64h]
long long v8; // [rsp+8h] [rbp-60h]
long long v9; // [rsp+38h] [rbp-30h]
long long v10; // [rsp+58h] [rbp-10h]
v8 = JS_ToCString(a1, *a5, a5[1]);
if ( v8 )
{
v5 = chdir(v8);
errno = js_get_errno(v5);
JS_FreeCString(a1, v8);
LODWORD(v10) = errno;
return v10;
}
else
{
LODWORD(v9) = 0;
}
return v9;
}
| js_os_chdir:
SUB RSP,0x68
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x001147e0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001198f2
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x0011994e
LAB_001198f2:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x0010e250
MOVSXD RDI,EAX
CALL 0x00113a50
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00129e50
MOV RCX,qword ptr [RSP + 0x20]
MOV EAX,dword ptr [RSP + 0x4]
MOV qword ptr [RSP + 0x50],RCX
MOV dword ptr [RSP + 0x4c],EAX
MOV EAX,dword ptr [RSP + 0x4c]
MOV dword ptr [RSP + 0x58],EAX
MOV qword ptr [RSP + 0x60],0x0
MOV RCX,qword ptr [RSP + 0x58]
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x40],RAX
LAB_0011994e:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x68
RET
|
int1 [16] js_os_chdir(int8 param_1)
{
int1 auVar1 [16];
int iVar2;
char *__path;
int8 *in_R8;
int4 local_30;
int4 uStack_2c;
int8 local_28;
int4 uStack_c;
__path = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__path == (char *)0x0) {
local_30 = 0;
local_28 = 6;
}
else {
iVar2 = chdir(__path);
local_30 = js_get_errno((long)iVar2);
JS_FreeCString(param_1,__path);
uStack_2c = uStack_c;
local_28 = 0;
}
auVar1._4_4_ = uStack_2c;
auVar1._0_4_ = local_30;
auVar1._8_8_ = local_28;
return auVar1;
}
| |
22,999 | js_os_chdir | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_chdir(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *target;
int err;
target = JS_ToCString(ctx, argv[0]);
if (!target)
return JS_EXCEPTION;
err = js_get_errno(chdir(target));
JS_FreeCString(ctx, target);
return JS_NewInt32(ctx, err);
} | O2 | c | js_os_chdir:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%r8), %rsi
movq 0x8(%r8), %rdx
callq 0x11a6c
testq %rax, %rax
je 0x141a1
movq %rax, %r14
movq %rax, %rdi
callq 0xe260
movslq %eax, %rdi
callq 0x113ab
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b057
movl %r15d, %eax
xorl %edx, %edx
jmp 0x141a6
pushq $0x6
popq %rdx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
| js_os_chdir:
push r15
push r14
push rbx
mov rbx, rdi
mov rsi, [r8]
mov rdx, [r8+8]
call JS_ToCString
test rax, rax
jz short loc_141A1
mov r14, rax
mov rdi, rax
call _chdir
movsxd rdi, eax
call js_get_errno
mov r15, rax
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
mov eax, r15d
xor edx, edx
jmp short loc_141A6
loc_141A1:
push 6
pop rdx
xor eax, eax
loc_141A6:
pop rbx
pop r14
pop r15
retn
| long long js_os_chdir(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v5; // rax
long long v6; // r14
int v7; // eax
unsigned int errno; // r15d
v5 = JS_ToCString(a1, *a5, a5[1]);
if ( !v5 )
return 0LL;
v6 = v5;
v7 = chdir(v5);
errno = js_get_errno(v7);
JS_FreeCString(a1, v6);
return errno;
}
| js_os_chdir:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RSI,qword ptr [R8]
MOV RDX,qword ptr [R8 + 0x8]
CALL 0x00111a6c
TEST RAX,RAX
JZ 0x001141a1
MOV R14,RAX
MOV RDI,RAX
CALL 0x0010e260
MOVSXD RDI,EAX
CALL 0x001113ab
MOV R15,RAX
MOV RDI,RBX
MOV RSI,R14
CALL 0x0011b057
MOV EAX,R15D
XOR EDX,EDX
JMP 0x001141a6
LAB_001141a1:
PUSH 0x6
POP RDX
XOR EAX,EAX
LAB_001141a6:
POP RBX
POP R14
POP R15
RET
|
int4 js_os_chdir(int8 param_1)
{
int iVar1;
int4 uVar2;
char *__path;
int8 *in_R8;
__path = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__path == (char *)0x0) {
uVar2 = 0;
}
else {
iVar1 = chdir(__path);
uVar2 = js_get_errno((long)iVar1);
JS_FreeCString(param_1,__path);
}
return uVar2;
}
|
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.