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,200 | check_mb_utf8mb3_valid | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_utf8mb3_valid(const char *start, const char *end)
{
unsigned int len = check_mb_utf8mb3_sequence(start, end);
return (len > 1)? len:0;
} | O3 | c | check_mb_utf8mb3_valid:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
jae 0x32ae9
movb (%rdi), %al
cmpb $-0x3e, %al
jae 0x32aed
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %al
ja 0x32b07
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
ja 0x32ae9
movl $0x2, %eax
cmpb $-0x40, 0x1(%rdi)
jge 0x32ae9
jmp 0x32aeb
cmpb $-0x10, %al
setae %cl
leaq 0x3(%rdi), %rdx
cmpq %rsi, %rdx
seta %dl
orb %cl, %dl
jne 0x32ae9
movb 0x1(%rdi), %cl
cmpb $-0x41, %cl
jg 0x32ae9
cmpb $-0x41, 0x2(%rdi)
jg 0x32ae9
cmpb $-0x20, %al
setne %al
cmpb $-0x60, %cl
setae %cl
orb %al, %cl
movl $0x3, %eax
je 0x32ae9
jmp 0x32aeb
| check_mb_utf8mb3_valid:
push rbp
mov rbp, rsp
cmp rdi, rsi
jnb short loc_32AE9
mov al, [rdi]
cmp al, 0C2h
jnb short loc_32AED
loc_32AE9:
xor eax, eax
loc_32AEB:
pop rbp
retn
loc_32AED:
cmp al, 0DFh
ja short loc_32B07
lea rax, [rdi+2]
cmp rax, rsi
ja short loc_32AE9
mov eax, 2
cmp byte ptr [rdi+1], 0C0h
jge short loc_32AE9
jmp short loc_32AEB
loc_32B07:
cmp al, 0F0h
setnb cl
lea rdx, [rdi+3]
cmp rdx, rsi
setnbe dl
or dl, cl
jnz short loc_32AE9
mov cl, [rdi+1]
cmp cl, 0BFh
jg short loc_32AE9
cmp byte ptr [rdi+2], 0BFh
jg short loc_32AE9
cmp al, 0E0h
setnz al
cmp cl, 0A0h
setnb cl
or cl, al
mov eax, 3
jz short loc_32AE9
jmp short loc_32AEB
| long long check_mb_utf8mb3_valid(unsigned __int8 *a1, unsigned long long a2)
{
unsigned __int8 v2; // al
long long result; // rax
char v4; // cl
bool v5; // cl
if ( (unsigned long long)a1 >= a2 )
return 0LL;
v2 = *a1;
if ( *a1 < 0xC2u )
return 0LL;
if ( v2 <= 0xDFu )
{
if ( (unsigned long long)(a1 + 2) <= a2 )
{
result = 2LL;
if ( (char)a1[1] < -64 )
return result;
}
return 0LL;
}
if ( v2 >= 0xF0u || (unsigned long long)(a1 + 3) > a2 )
return 0LL;
v4 = a1[1];
if ( v4 > -65 )
return 0LL;
if ( (char)a1[2] > -65 )
return 0LL;
v5 = v2 != 0xE0 || (unsigned __int8)v4 >= 0xA0u;
result = 3LL;
if ( !v5 )
return 0LL;
return result;
}
| check_mb_utf8mb3_valid:
PUSH RBP
MOV RBP,RSP
CMP RDI,RSI
JNC 0x00132ae9
MOV AL,byte ptr [RDI]
CMP AL,0xc2
JNC 0x00132aed
LAB_00132ae9:
XOR EAX,EAX
LAB_00132aeb:
POP RBP
RET
LAB_00132aed:
CMP AL,0xdf
JA 0x00132b07
LEA RAX,[RDI + 0x2]
CMP RAX,RSI
JA 0x00132ae9
MOV EAX,0x2
CMP byte ptr [RDI + 0x1],0xc0
JGE 0x00132ae9
JMP 0x00132aeb
LAB_00132b07:
CMP AL,0xf0
SETNC CL
LEA RDX,[RDI + 0x3]
CMP RDX,RSI
SETA DL
OR DL,CL
JNZ 0x00132ae9
MOV CL,byte ptr [RDI + 0x1]
CMP CL,0xbf
JG 0x00132ae9
CMP byte ptr [RDI + 0x2],0xbf
JG 0x00132ae9
CMP AL,0xe0
SETNZ AL
CMP CL,0xa0
SETNC CL
OR CL,AL
MOV EAX,0x3
JZ 0x00132ae9
JMP 0x00132aeb
|
int8 check_mb_utf8mb3_valid(byte *param_1,byte *param_2)
{
byte bVar1;
if ((param_1 < param_2) && (bVar1 = *param_1, 0xc1 < bVar1)) {
if (bVar1 < 0xe0) {
if ((param_1 + 2 <= param_2) && ((char)param_1[1] < -0x40)) {
return 2;
}
}
else if ((((param_1 + 3 <= param_2 && bVar1 < 0xf0) && ((char)param_1[1] < -0x40)) &&
((char)param_1[2] < -0x40)) && (0x9f < param_1[1] || bVar1 != 0xe0)) {
return 3;
}
}
return 0;
}
| |
22,201 | ma_calc_total_blob_length | eloqsql/storage/maria/ma_dynrec.c | ulong _ma_calc_total_blob_length(MARIA_HA *info, const uchar *record)
{
ulong length;
MARIA_BLOB *blob,*end;
for (length=0, blob= info->blobs, end=blob+info->s->base.blobs ;
blob != end;
blob++)
{
blob->length= _ma_calc_blob_length(blob->pack_length,
record + blob->offset);
length+=blob->length;
}
return length;
} | O0 | c | ma_calc_total_blob_length:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x288(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x3f0(%rcx), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x3df6d
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
addq (%rax), %rsi
callq 0x408c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
jmp 0x3df23
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| _ma_calc_total_blob_length:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], 0
mov rax, [rbp+var_8]
mov rax, [rax+288h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
mov ecx, [rcx+3F0h]
imul rcx, 18h
add rax, rcx
mov [rbp+var_28], rax
loc_3DF23:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jz short loc_3DF6D
mov rax, [rbp+var_20]
mov edi, [rax+8]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_20]
add rsi, [rax]
call _ma_calc_blob_length
mov rcx, rax
mov rax, [rbp+var_20]
mov [rax+10h], rcx
mov rax, [rbp+var_20]
mov rax, [rax+10h]
add rax, [rbp+var_18]
mov [rbp+var_18], rax
mov rax, [rbp+var_20]
add rax, 18h
mov [rbp+var_20], rax
jmp short loc_3DF23
loc_3DF6D:
mov rax, [rbp+var_18]
add rsp, 30h
pop rbp
retn
| long long ma_calc_total_blob_length(_QWORD *a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
long long v6; // [rsp+18h] [rbp-18h]
v6 = 0LL;
v5 = a1[81];
v4 = 24LL * *(unsigned int *)(*a1 + 1008LL) + v5;
while ( v5 != v4 )
{
*(_QWORD *)(v5 + 16) = ma_calc_blob_length(*(unsigned int *)(v5 + 8), *(_QWORD *)v5 + a2, a3);
v6 += *(_QWORD *)(v5 + 16);
v5 += 24LL;
}
return v6;
}
| _ma_calc_total_blob_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x288]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
MOV ECX,dword ptr [RCX + 0x3f0]
IMUL RCX,RCX,0x18
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
LAB_0013df23:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JZ 0x0013df6d
MOV RAX,qword ptr [RBP + -0x20]
MOV EDI,dword ptr [RAX + 0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x20]
ADD RSI,qword ptr [RAX]
CALL 0x001408c0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x10],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX + 0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x18
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0013df23
LAB_0013df6d:
MOV RAX,qword ptr [RBP + -0x18]
ADD RSP,0x30
POP RBP
RET
|
long _ma_calc_total_blob_length(long *param_1,long param_2)
{
long *plVar1;
long lVar2;
long *local_28;
long local_20;
local_20 = 0;
local_28 = (long *)param_1[0x51];
plVar1 = local_28 + (ulong)*(uint *)(*param_1 + 0x3f0) * 3;
for (; local_28 != plVar1; local_28 = local_28 + 3) {
lVar2 = _ma_calc_blob_length((int)local_28[1],param_2 + *local_28);
local_28[2] = lVar2;
local_20 = local_28[2] + local_20;
}
return local_20;
}
| |
22,202 | my_uni_utf16le | eloqsql/strings/ctype-ucs2.c | static int
my_uni_utf16le(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
uint32 first, second, total;
if (wc < MY_UTF16_SURROGATE_HIGH_FIRST ||
(wc > MY_UTF16_SURROGATE_LOW_LAST &&
wc <= 0xFFFF))
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
int2store(s, wc);
return 2; /* [0000-D7FF,E000-FFFF] */
}
if (wc < 0xFFFF || wc > 0x10FFFF)
return MY_CS_ILUNI; /* [D800-DFFF,10FFFF+] */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
wc-= 0x10000;
first= (0xD800 | ((wc >> 10) & 0x3FF));
second= (0xDC00 | (wc & 0x3FF));
total= first | (second << 16);
int4store(s, total);
return 4; /* [010000-10FFFF] */
} | O0 | c | my_uni_utf16le:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0xd800, -0x18(%rbp) # imm = 0xD800
jb 0x67512
cmpq $0xdfff, -0x18(%rbp) # imm = 0xDFFF
jbe 0x67550
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
ja 0x67550
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x6752c
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x675e2
jmp 0x6752e
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movw %ax, %cx
movq -0x40(%rbp), %rax
movw %cx, (%rax)
movl $0x2, -0x4(%rbp)
jmp 0x675e2
cmpq $0xffff, -0x18(%rbp) # imm = 0xFFFF
jb 0x67564
cmpq $0x10ffff, -0x18(%rbp) # imm = 0x10FFFF
jbe 0x6756d
movl $0x0, -0x4(%rbp)
jmp 0x675e2
movq -0x20(%rbp), %rax
addq $0x4, %rax
cmpq -0x28(%rbp), %rax
jbe 0x67584
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x675e2
movq -0x18(%rbp), %rax
subq $0x10000, %rax # imm = 0x10000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0xa, %rax
andq $0x3ff, %rax # imm = 0x3FF
orq $0xd800, %rax # imm = 0xD800
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
andq $0x3ff, %rax # imm = 0x3FF
orq $0xdc00, %rax # imm = 0xDC00
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x34(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| my_uni_utf16le:
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
cmp [rbp+var_18], 0D800h
jb short loc_67512
cmp [rbp+var_18], 0DFFFh
jbe short loc_67550
cmp [rbp+var_18], 0FFFFh
ja short loc_67550
loc_67512:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_6752C
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_675E2
loc_6752C:
jmp short $+2
loc_6752E:
mov rax, [rbp+var_20]
mov [rbp+var_40], rax
mov rax, [rbp+var_18]
mov cx, ax
mov rax, [rbp+var_40]
mov [rax], cx
mov [rbp+var_4], 2
jmp loc_675E2
loc_67550:
cmp [rbp+var_18], 0FFFFh
jb short loc_67564
cmp [rbp+var_18], offset unk_10FFFF
jbe short loc_6756D
loc_67564:
mov [rbp+var_4], 0
jmp short loc_675E2
loc_6756D:
mov rax, [rbp+var_20]
add rax, 4
cmp rax, [rbp+var_28]
jbe short loc_67584
mov [rbp+var_4], 0FFFFFF98h
jmp short loc_675E2
loc_67584:
mov rax, [rbp+var_18]
sub rax, offset stru_10000
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
shr rax, 0Ah
and rax, 3FFh
or rax, 0D800h
mov [rbp+var_2C], eax
mov rax, [rbp+var_18]
and rax, 3FFh
or rax, 0DC00h
mov [rbp+var_30], eax
mov eax, [rbp+var_2C]
mov ecx, [rbp+var_30]
shl ecx, 10h
or eax, ecx
mov [rbp+var_34], eax
mov rax, [rbp+var_20]
mov [rbp+var_48], rax
mov ecx, [rbp+var_34]
mov rax, [rbp+var_48]
mov [rax], ecx
mov [rbp+var_4], 4
loc_675E2:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_uni_utf16le(long long a1, unsigned long long a2, _DWORD *a3, unsigned long long a4)
{
if ( a2 >= 0xD800 && (a2 <= 0xDFFF || a2 > 0xFFFF) )
{
if ( a2 >= 0xFFFF && a2 <= (unsigned long long)&unk_10FFFF )
{
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = (((a2 - (_QWORD)&stru_10000) & 0x3FF | 0xDC00) << 16) | ((a2 - (unsigned long long)&stru_10000) >> 10) & 0x3FF | 0xD800;
return 4;
}
else
{
return (unsigned int)-104;
}
}
else
{
return 0;
}
}
else if ( (unsigned long long)a3 + 2 <= a4 )
{
*(_WORD *)a3 = a2;
return 2;
}
else
{
return (unsigned int)-102;
}
}
| my_uni_utf16le:
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
CMP qword ptr [RBP + -0x18],0xd800
JC 0x00167512
CMP qword ptr [RBP + -0x18],0xdfff
JBE 0x00167550
CMP qword ptr [RBP + -0x18],0xffff
JA 0x00167550
LAB_00167512:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0016752c
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x001675e2
LAB_0016752c:
JMP 0x0016752e
LAB_0016752e:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x40]
MOV word ptr [RAX],CX
MOV dword ptr [RBP + -0x4],0x2
JMP 0x001675e2
LAB_00167550:
CMP qword ptr [RBP + -0x18],0xffff
JC 0x00167564
CMP qword ptr [RBP + -0x18],0x10ffff
JBE 0x0016756d
LAB_00167564:
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001675e2
LAB_0016756d:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x00167584
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x001675e2
LAB_00167584:
MOV RAX,qword ptr [RBP + -0x18]
SUB RAX,0x10000
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
SHR RAX,0xa
AND RAX,0x3ff
OR RAX,0xd800
MOV dword ptr [RBP + -0x2c],EAX
MOV RAX,qword ptr [RBP + -0x18]
AND RAX,0x3ff
OR RAX,0xdc00
MOV dword ptr [RBP + -0x30],EAX
MOV EAX,dword ptr [RBP + -0x2c]
MOV ECX,dword ptr [RBP + -0x30]
SHL ECX,0x10
OR EAX,ECX
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x48],RAX
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x48]
MOV dword ptr [RAX],ECX
MOV dword ptr [RBP + -0x4],0x4
LAB_001675e2:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_uni_utf16le(int8 param_1,ulong param_2,uint *param_3,uint *param_4)
{
int4 local_c;
if ((param_2 < 0xd800) || ((0xdfff < param_2 && (param_2 < 0x10000)))) {
if (param_4 < (uint *)((long)param_3 + 2)) {
local_c = 0xffffff9a;
}
else {
*(short *)param_3 = (short)param_2;
local_c = 2;
}
}
else if ((param_2 < 0xffff) || (0x10ffff < param_2)) {
local_c = 0;
}
else if (param_4 < param_3 + 1) {
local_c = 0xffffff98;
}
else {
*param_3 = (uint)(param_2 - 0x10000 >> 10) & 0x3ff | 0xd800 |
((uint)(param_2 - 0x10000) & 0x3ff | 0xdc00) << 0x10;
local_c = 4;
}
return local_c;
}
| |
22,203 | my_uni_utf16le | eloqsql/strings/ctype-ucs2.c | static int
my_uni_utf16le(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
uint32 first, second, total;
if (wc < MY_UTF16_SURROGATE_HIGH_FIRST ||
(wc > MY_UTF16_SURROGATE_LOW_LAST &&
wc <= 0xFFFF))
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
int2store(s, wc);
return 2; /* [0000-D7FF,E000-FFFF] */
}
if (wc < 0xFFFF || wc > 0x10FFFF)
return MY_CS_ILUNI; /* [D800-DFFF,10FFFF+] */
if (s + 4 > e)
return MY_CS_TOOSMALL4;
wc-= 0x10000;
first= (0xD800 | ((wc >> 10) & 0x3FF));
second= (0xDC00 | (wc & 0x3FF));
total= first | (second << 16);
int4store(s, total);
return 4; /* [010000-10FFFF] */
} | O3 | c | my_uni_utf16le:
pushq %rbp
movq %rsp, %rbp
cmpq $0xd800, %rsi # imm = 0xD800
setae %al
movq %rsi, %rdi
andq $-0x2000, %rdi # imm = 0xE000
cmpq $0xe000, %rdi # imm = 0xE000
setne %dil
testb %dil, %al
jne 0x4ed6f
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x4edb4
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x4edb4
leaq -0x110000(%rsi), %rdi
xorl %eax, %eax
cmpq $-0x100001, %rdi # imm = 0xFFEFFFFF
jb 0x4edb4
leaq 0x4(%rdx), %rdi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %rdi
ja 0x4edb4
leal 0xf0000(%rsi), %eax
shrl $0xa, %eax
andl $0x3ff, %eax # imm = 0x3FF
shll $0x10, %esi
andl $0x3ff0000, %esi # imm = 0x3FF0000
addl %esi, %eax
addl $0xdc00d800, %eax # imm = 0xDC00D800
movl %eax, (%rdx)
movl $0x4, %eax
popq %rbp
retq
| my_uni_utf16le:
push rbp
mov rbp, rsp
cmp rsi, 0D800h
setnb al
mov rdi, rsi
and rdi, 0FFFFFFFFFFFFE000h
cmp rdi, 0E000h
setnz dil
test al, dil
jnz short loc_4ED6F
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_4EDB4
mov [rdx], si
mov eax, 2
jmp short loc_4EDB4
loc_4ED6F:
lea rdi, [rsi-110000h]
xor eax, eax
cmp rdi, 0FFFFFFFFFFEFFFFFh
jb short loc_4EDB4
lea rdi, [rdx+4]
mov eax, 0FFFFFF98h
cmp rdi, rcx
ja short loc_4EDB4
lea eax, unk_F0000[rsi]
shr eax, 0Ah
and eax, 3FFh
shl esi, 10h
and esi, 3FF0000h
add eax, esi
add eax, 0DC00D800h
mov [rdx], eax
mov eax, 4
loc_4EDB4:
pop rbp
retn
| long long my_uni_utf16le(long long a1, unsigned long long a2, _DWORD *a3, unsigned long long a4)
{
long long result; // rax
if ( (a2 & 0xFFFFFFFFFFFFE000LL) != 57344 && a2 >= 0xD800 )
{
result = 0LL;
if ( a2 - 1114112 >= 0xFFFFFFFFFFEFFFFFLL )
{
result = 4294967192LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = (((_DWORD)a2 << 16) & 0x3FF0000)
+ (((unsigned int)((unsigned int)&unk_F0000 + a2) >> 10) & 0x3FF)
- 603924480;
return 4LL;
}
}
}
else
{
result = 4294967194LL;
if ( (unsigned long long)a3 + 2 <= a4 )
{
*(_WORD *)a3 = a2;
return 2LL;
}
}
return result;
}
| my_uni_utf16le:
PUSH RBP
MOV RBP,RSP
CMP RSI,0xd800
SETNC AL
MOV RDI,RSI
AND RDI,-0x2000
CMP RDI,0xe000
SETNZ DIL
TEST AL,DIL
JNZ 0x0014ed6f
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x0014edb4
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x0014edb4
LAB_0014ed6f:
LEA RDI,[RSI + -0x110000]
XOR EAX,EAX
CMP RDI,-0x100001
JC 0x0014edb4
LEA RDI,[RDX + 0x4]
MOV EAX,0xffffff98
CMP RDI,RCX
JA 0x0014edb4
LEA EAX,[RSI + 0xf0000]
SHR EAX,0xa
AND EAX,0x3ff
SHL ESI,0x10
AND ESI,0x3ff0000
ADD EAX,ESI
ADD EAX,0xdc00d800
MOV dword ptr [RDX],EAX
MOV EAX,0x4
LAB_0014edb4:
POP RBP
RET
|
int8 my_uni_utf16le(int8 param_1,ulong param_2,int *param_3,int *param_4)
{
int8 uVar1;
if (param_2 < 0xd800 || (param_2 & 0xffffffffffffe000) == 0xe000) {
uVar1 = 0xffffff9a;
if ((int *)((long)param_3 + 2U) <= param_4) {
*(short *)param_3 = (short)param_2;
uVar1 = 2;
}
}
else {
uVar1 = 0;
if ((0xffffffffffeffffe < param_2 - 0x110000) && (uVar1 = 0xffffff98, param_3 + 1 <= param_4)) {
*param_3 = ((uint)param_2 + 0xf0000 >> 10 & 0x3ff) + ((uint)param_2 & 0x3ff) * 0x10000 +
-0x23ff2800;
uVar1 = 4;
}
}
return uVar1;
}
| |
22,204 | my_hash_first_from_hash_value | eloqsql/mysys/hash.c | uchar* my_hash_first_from_hash_value(const HASH *hash,
my_hash_value_type hash_value,
const uchar *key,
size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
DBUG_ENTER("my_hash_first_from_hash_value");
if (hash->records)
{
uint flag= 1;
uint idx= my_hash_mask(hash_value,
hash->blength, hash->records);
do
{
pos= dynamic_element(&hash->array,idx,HASH_LINK*);
if (!hashcmp(hash,pos,key,length))
{
DBUG_PRINT("exit",("found key at %d",idx));
*current_record= idx;
DBUG_RETURN (pos->data);
}
if (flag)
{
flag=0; /* Reset flag */
if (my_hash_rec_mask(pos, hash->blength, hash->records) != idx)
break; /* Wrong link */
}
}
while ((idx=pos->next) != NO_RECORD);
}
*current_record= NO_RECORD;
DBUG_RETURN(0);
} | O0 | c | my_hash_first_from_hash_value:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6260c
movl $0x1, -0x3c(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x62630
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x40(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x62680
cmpl $0x0, %eax
jne 0x625c7
jmp 0x625ae
jmp 0x625b0
movl -0x40(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6261e
cmpl $0x0, -0x3c(%rbp)
je 0x625f6
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x62720
cmpl -0x40(%rbp), %eax
je 0x625f4
jmp 0x6260a
jmp 0x625f6
jmp 0x625f8
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
cmpl $-0x1, %eax
jne 0x6257c
jmp 0x6260c
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_hash_first_from_hash_value:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov rax, [rbp+var_10]
cmp qword ptr [rax+18h], 0
jz loc_6260C
mov [rbp+var_3C], 1
mov edi, [rbp+var_14]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_mask
mov [rbp+var_40], eax
loc_6257C:
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov ecx, [rbp+var_40]
shl rcx, 4
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call hashcmp
cmp eax, 0
jnz short loc_625C7
jmp short $+2
loc_625AE:
jmp short $+2
loc_625B0:
mov ecx, [rbp+var_40]
mov rax, [rbp+var_30]
mov [rax], ecx
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_6261E
loc_625C7:
cmp [rbp+var_3C], 0
jz short loc_625F6
mov [rbp+var_3C], 0
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov rsi, [rax+10h]
mov rax, [rbp+var_10]
mov rdx, [rax+18h]
call my_hash_rec_mask
cmp eax, [rbp+var_40]
jz short loc_625F4
jmp short loc_6260A
loc_625F4:
jmp short $+2
loc_625F6:
jmp short $+2
loc_625F8:
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_40], eax
cmp eax, 0FFFFFFFFh
jnz loc_6257C
loc_6260A:
jmp short $+2
loc_6260C:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
mov [rbp+var_8], 0
loc_6261E:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_hash_first_from_hash_value(_QWORD *a1, unsigned int a2, long long a3, long long a4, unsigned int *a5)
{
unsigned int v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h]
if ( a1[3] )
{
v7 = 1;
v6 = my_hash_mask(a2, a1[2], a1[3]);
while ( 1 )
{
v8 = 16LL * v6 + a1[5];
if ( !(unsigned int)hashcmp(a1, v8, a3, a4) )
break;
if ( !v7 || (v7 = 0, (unsigned int)my_hash_rec_mask(v8, a1[2], a1[3]) == v6) )
{
v6 = *(_DWORD *)v8;
if ( *(_DWORD *)v8 != -1 )
continue;
}
goto LABEL_8;
}
*a5 = v6;
return *(_QWORD *)(v8 + 8);
}
else
{
LABEL_8:
*a5 = -1;
return 0LL;
}
}
| my_hash_first_from_hash_value:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x18],0x0
JZ 0x0016260c
MOV dword ptr [RBP + -0x3c],0x1
MOV EDI,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00162630
MOV dword ptr [RBP + -0x40],EAX
LAB_0016257c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV ECX,dword ptr [RBP + -0x40]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x00162680
CMP EAX,0x0
JNZ 0x001625c7
JMP 0x001625ae
LAB_001625ae:
JMP 0x001625b0
LAB_001625b0:
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016261e
LAB_001625c7:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x001625f6
MOV dword ptr [RBP + -0x3c],0x0
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00162720
CMP EAX,dword ptr [RBP + -0x40]
JZ 0x001625f4
JMP 0x0016260a
LAB_001625f4:
JMP 0x001625f6
LAB_001625f6:
JMP 0x001625f8
LAB_001625f8:
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x40],EAX
CMP EAX,-0x1
JNZ 0x0016257c
LAB_0016260a:
JMP 0x0016260c
LAB_0016260c:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
MOV qword ptr [RBP + -0x8],0x0
LAB_0016261e:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
my_hash_first_from_hash_value
(long param_1,int4 param_2,int8 param_3,int8 param_4,uint *param_5)
{
bool bVar1;
int iVar2;
uint uVar3;
uint *puVar4;
uint local_48;
if (*(long *)(param_1 + 0x18) != 0) {
bVar1 = true;
local_48 = my_hash_mask(param_2,*(int8 *)(param_1 + 0x10),*(int8 *)(param_1 + 0x18))
;
do {
puVar4 = (uint *)(*(long *)(param_1 + 0x28) + (ulong)local_48 * 0x10);
iVar2 = hashcmp(param_1,puVar4,param_3,param_4);
if (iVar2 == 0) {
*param_5 = local_48;
return *(int8 *)(puVar4 + 2);
}
if (bVar1) {
bVar1 = false;
uVar3 = my_hash_rec_mask(puVar4,*(int8 *)(param_1 + 0x10),
*(int8 *)(param_1 + 0x18));
if (uVar3 != local_48) break;
}
local_48 = *puVar4;
} while (local_48 != 0xffffffff);
}
*param_5 = 0xffffffff;
return 0;
}
| |
22,205 | get_hash_link | eloqsql/mysys/mf_keycache.c | static HASH_LINK *get_hash_link(SIMPLE_KEY_CACHE_CB *keycache,
int file, my_off_t filepos)
{
reg1 HASH_LINK *hash_link, **start;
#if defined(KEYCACHE_DEBUG)
int cnt;
#endif
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) file,(ulong) filepos));
restart:
/*
Find the bucket in the hash table for the pair (file, filepos);
start contains the head of the bucket list,
hash_link points to the first member of the list
*/
hash_link= *(start= &keycache->hash_root[KEYCACHE_HASH(file, filepos)]);
#if defined(KEYCACHE_DEBUG)
cnt= 0;
#endif
/* Look for an element for the pair (file, filepos) in the bucket chain */
while (hash_link &&
(hash_link->diskpos != filepos || hash_link->file != file))
{
hash_link= hash_link->next;
#if defined(KEYCACHE_DEBUG)
cnt++;
if (! (cnt <= keycache->hash_links_used))
{
int i;
for (i=0, hash_link= *start ;
i < cnt ; i++, hash_link= hash_link->next)
{
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) hash_link->file,(ulong) hash_link->diskpos));
}
}
KEYCACHE_DBUG_ASSERT(cnt <= keycache->hash_links_used);
#endif
}
if (! hash_link)
{
/* There is no hash link in the hash table for the pair (file, filepos) */
if (keycache->free_hash_list)
{
hash_link= keycache->free_hash_list;
keycache->free_hash_list= hash_link->next;
}
else if (keycache->hash_links_used < keycache->hash_links)
{
hash_link= &keycache->hash_link_root[keycache->hash_links_used++];
}
else
{
/* Wait for a free hash link */
struct st_my_thread_var *thread= my_thread_var;
KEYCACHE_PAGE page;
KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting"));
page.file= file;
page.filepos= filepos;
thread->keycache_link= (void *) &page;
link_into_queue(&keycache->waiting_for_hash_link, thread);
KEYCACHE_DBUG_PRINT("get_hash_link: wait",
("suspend thread %ld", (ulong) thread->id));
keycache_pthread_cond_wait(&thread->suspend,
&keycache->cache_lock);
thread->keycache_link= NULL;
goto restart;
}
hash_link->file= file;
hash_link->diskpos= filepos;
link_hash(start, hash_link);
}
/* Register the request for the page */
hash_link->requests++;
return hash_link;
} | O0 | c | get_hash_link:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0xe6265
jmp 0xe6267
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x18(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movl 0x164(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rdx
movl 0x38(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
andq %rdx, %rcx
movq %rcx, %rsi
shlq $0x3, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movq %rdx, -0x28(%rbp)
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x49(%rbp)
je 0xe6300
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movb $0x1, %al
cmpq -0x18(%rbp), %rcx
movb %al, -0x4a(%rbp)
jne 0xe62fa
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
setne %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0xe6309
jmp 0xe6316
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xe62cb
cmpq $0x0, -0x20(%rbp)
jne 0xe642a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
je 0xe6355
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
jmp 0xe6407
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jge 0xe638f
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x8(%rbp), %rdx
movl 0x44(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x44(%rdx)
movslq %ecx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xe6405
callq 0xf7440
movq %rax, -0x30(%rbp)
jmp 0xe639a
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
leaq -0x40(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x30(%rbp), %rsi
callq 0xe6600
jmp 0xe63cd
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0xc0, %rsi
leaq 0x6f0ea(%rip), %rdx # 0x1554d1
movl $0x71e, %ecx # imm = 0x71E
callq 0xe61e0
movq -0x30(%rbp), %rax
movq $0x0, 0xa8(%rax)
jmp 0xe6267
jmp 0xe6407
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe6930
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| get_hash_link_0:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
jmp short $+2
loc_E6265:
jmp short $+2
loc_E6267:
mov rax, [rbp+var_8]
mov rax, [rax+80h]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov rcx, [rbp+var_8]
mov ecx, [rcx+18h]
xor edx, edx
div rcx
movsxd rcx, [rbp+var_C]
add rax, rcx
mov rcx, [rbp+var_8]
mov ecx, [rcx+164h]
xor edx, edx
div rcx
mov rcx, rax
mov rax, [rbp+var_48]
mov rdx, [rbp+var_8]
mov edx, [rdx+38h]
sub edx, 1
mov edx, edx
and rcx, rdx
mov rsi, rcx
shl rsi, 3
mov rdx, rax
add rdx, rsi
mov [rbp+var_28], rdx
mov rax, [rax+rcx*8]
mov [rbp+var_20], rax
loc_E62CB:
xor eax, eax
cmp [rbp+var_20], 0
mov [rbp+var_49], al
jz short loc_E6300
mov rax, [rbp+var_20]
mov rcx, [rax+20h]
mov al, 1
cmp rcx, [rbp+var_18]
mov [rbp+var_4A], al
jnz short loc_E62FA
mov rax, [rbp+var_20]
mov eax, [rax+18h]
cmp eax, [rbp+var_C]
setnz al
mov [rbp+var_4A], al
loc_E62FA:
mov al, [rbp+var_4A]
mov [rbp+var_49], al
loc_E6300:
mov al, [rbp+var_49]
test al, 1
jnz short loc_E6309
jmp short loc_E6316
loc_E6309:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_E62CB
loc_E6316:
cmp [rbp+var_20], 0
jnz loc_E642A
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
jz short loc_E6355
mov rax, [rbp+var_8]
mov rax, [rax+90h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+90h], rcx
jmp loc_E6407
loc_E6355:
mov rax, [rbp+var_8]
mov eax, [rax+44h]
mov rcx, [rbp+var_8]
cmp eax, [rcx+40h]
jge short loc_E638F
mov rax, [rbp+var_8]
mov rax, [rax+88h]
mov rdx, [rbp+var_8]
mov ecx, [rdx+44h]
mov esi, ecx
add esi, 1
mov [rdx+44h], esi
movsxd rcx, ecx
imul rcx, 30h ; '0'
add rax, rcx
mov [rbp+var_20], rax
jmp short loc_E6405
loc_E638F:
call _my_thread_var
mov [rbp+var_30], rax
jmp short $+2
loc_E639A:
mov eax, [rbp+var_C]
mov [rbp+var_40], eax
mov rax, [rbp+var_18]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
lea rcx, [rbp+var_40]
mov [rax+0A8h], rcx
mov rdi, [rbp+var_8]
add rdi, 118h
mov rsi, [rbp+var_30]
call link_into_queue
jmp short $+2
loc_E63CD:
mov rdi, [rbp+var_30]
add rdi, 8
mov rsi, [rbp+var_8]
add rsi, 0C0h
lea rdx, aWorkspaceLlm4b_36; "/workspace/llm4binary/github2025/eloqsq"...
mov ecx, 71Eh
call inline_mysql_cond_wait_4
mov rax, [rbp+var_30]
mov qword ptr [rax+0A8h], 0
jmp loc_E6267
loc_E6405:
jmp short $+2
loc_E6407:
mov ecx, [rbp+var_C]
mov rax, [rbp+var_20]
mov [rax+18h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_20]
mov [rax+20h], rcx
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
call link_hash_0
loc_E642A:
mov rax, [rbp+var_20]
mov ecx, [rax+28h]
add ecx, 1
mov [rax+28h], ecx
mov rax, [rbp+var_20]
add rsp, 50h
pop rbp
retn
| long long * get_hash_link_0(long long a1, int a2, unsigned long long a3)
{
const char *v3; // rsi
long long v4; // rax
int v5; // ecx
bool v7; // [rsp+6h] [rbp-4Ah]
bool v8; // [rsp+7h] [rbp-49h]
int v9; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-38h]
long long v11; // [rsp+20h] [rbp-30h]
const char *v12; // [rsp+28h] [rbp-28h]
long long *i; // [rsp+30h] [rbp-20h]
unsigned long long v14; // [rsp+38h] [rbp-18h]
int v15; // [rsp+44h] [rbp-Ch]
long long v16; // [rsp+48h] [rbp-8h]
v16 = a1;
v15 = a2;
v14 = a3;
while ( 1 )
{
v3 = (const char *)(8
* ((unsigned int)(*(_DWORD *)(v16 + 56) - 1) & ((v15 + v14 / *(unsigned int *)(v16 + 24))
/ *(unsigned int *)(v16 + 356))));
v12 = &v3[*(_QWORD *)(v16 + 128)];
for ( i = *(long long **)v12; ; i = (long long *)*i )
{
v8 = 0;
if ( i )
{
v7 = 1;
if ( i[4] == v14 )
v7 = *((_DWORD *)i + 6) != v15;
v8 = v7;
}
if ( !v8 )
break;
}
if ( i )
break;
if ( *(_QWORD *)(v16 + 144) )
{
i = *(long long **)(v16 + 144);
*(_QWORD *)(v16 + 144) = *i;
LABEL_15:
*((_DWORD *)i + 6) = v15;
i[4] = v14;
link_hash_0(v12, i);
break;
}
if ( *(_DWORD *)(v16 + 68) < *(_DWORD *)(v16 + 64) )
{
v4 = *(_QWORD *)(v16 + 136);
v5 = *(_DWORD *)(v16 + 68);
*(_DWORD *)(v16 + 68) = v5 + 1;
i = (long long *)(48LL * v5 + v4);
goto LABEL_15;
}
v11 = my_thread_var(a1, v3);
v9 = v15;
v10 = v14;
*(_QWORD *)(v11 + 168) = &v9;
link_into_queue(v16 + 280, v11);
a1 = v11 + 8;
inline_mysql_cond_wait_4(
v11 + 8,
v16 + 192,
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",
0x71Eu);
*(_QWORD *)(v11 + 168) = 0LL;
}
++*((_DWORD *)i + 10);
return i;
}
| get_hash_link:
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
JMP 0x001e6265
LAB_001e6265:
JMP 0x001e6267
LAB_001e6267:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x18]
XOR EDX,EDX
DIV RCX
MOVSXD RCX,dword ptr [RBP + -0xc]
ADD RAX,RCX
MOV RCX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RCX + 0x164]
XOR EDX,EDX
DIV RCX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RDX + 0x38]
SUB EDX,0x1
MOV EDX,EDX
AND RCX,RDX
MOV RSI,RCX
SHL RSI,0x3
MOV RDX,RAX
ADD RDX,RSI
MOV qword ptr [RBP + -0x28],RDX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RBP + -0x20],RAX
LAB_001e62cb:
XOR EAX,EAX
CMP qword ptr [RBP + -0x20],0x0
MOV byte ptr [RBP + -0x49],AL
JZ 0x001e6300
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX + 0x20]
MOV AL,0x1
CMP RCX,qword ptr [RBP + -0x18]
MOV byte ptr [RBP + -0x4a],AL
JNZ 0x001e62fa
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x18]
CMP EAX,dword ptr [RBP + -0xc]
SETNZ AL
MOV byte ptr [RBP + -0x4a],AL
LAB_001e62fa:
MOV AL,byte ptr [RBP + -0x4a]
MOV byte ptr [RBP + -0x49],AL
LAB_001e6300:
MOV AL,byte ptr [RBP + -0x49]
TEST AL,0x1
JNZ 0x001e6309
JMP 0x001e6316
LAB_001e6309:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e62cb
LAB_001e6316:
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001e642a
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x001e6355
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x90]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x90],RCX
JMP 0x001e6407
LAB_001e6355:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x44]
MOV RCX,qword ptr [RBP + -0x8]
CMP EAX,dword ptr [RCX + 0x40]
JGE 0x001e638f
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV RDX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RDX + 0x44]
MOV ESI,ECX
ADD ESI,0x1
MOV dword ptr [RDX + 0x44],ESI
MOVSXD RCX,ECX
IMUL RCX,RCX,0x30
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x001e6405
LAB_001e638f:
CALL 0x001f7440
MOV qword ptr [RBP + -0x30],RAX
JMP 0x001e639a
LAB_001e639a:
MOV EAX,dword ptr [RBP + -0xc]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
LEA RCX,[RBP + -0x40]
MOV qword ptr [RAX + 0xa8],RCX
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x118
MOV RSI,qword ptr [RBP + -0x30]
CALL 0x001e6600
JMP 0x001e63cd
LAB_001e63cd:
MOV RDI,qword ptr [RBP + -0x30]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0xc0
LEA RDX,[0x2554d1]
MOV ECX,0x71e
CALL 0x001e61e0
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX + 0xa8],0x0
JMP 0x001e6267
LAB_001e6405:
JMP 0x001e6407
LAB_001e6407:
MOV ECX,dword ptr [RBP + -0xc]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x18],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001e6930
LAB_001e642a:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x28]
ADD ECX,0x1
MOV dword ptr [RAX + 0x28],ECX
MOV RAX,qword ptr [RBP + -0x20]
ADD RSP,0x50
POP RBP
RET
|
int8 * get_hash_link(long param_1,int param_2,ulong param_3)
{
int iVar1;
ulong uVar2;
bool bVar3;
int local_48 [2];
ulong local_40;
long local_38;
long local_30;
int8 *local_28;
ulong local_20;
int local_14;
long local_10;
local_20 = param_3;
local_14 = param_2;
local_10 = param_1;
while( true ) {
uVar2 = (local_20 / *(uint *)(local_10 + 0x18) + (long)local_14) /
(ulong)*(uint *)(local_10 + 0x164) & (ulong)(*(int *)(local_10 + 0x38) - 1);
local_30 = *(long *)(local_10 + 0x80) + uVar2 * 8;
local_28 = *(int8 **)(*(long *)(local_10 + 0x80) + uVar2 * 8);
while( true ) {
bVar3 = false;
if ((local_28 != (int8 *)0x0) && (bVar3 = true, local_28[4] == local_20)) {
bVar3 = *(int *)(local_28 + 3) != local_14;
}
if (!bVar3) break;
local_28 = (int8 *)*local_28;
}
if (local_28 != (int8 *)0x0) goto LAB_001e642a;
if (*(long *)(local_10 + 0x90) != 0) break;
if (*(int *)(local_10 + 0x44) < *(int *)(local_10 + 0x40)) {
iVar1 = *(int *)(local_10 + 0x44);
*(int *)(local_10 + 0x44) = iVar1 + 1;
local_28 = (int8 *)(*(long *)(local_10 + 0x88) + (long)iVar1 * 0x30);
LAB_001e6407:
*(int *)(local_28 + 3) = local_14;
local_28[4] = local_20;
link_hash(local_30,local_28);
LAB_001e642a:
*(int *)(local_28 + 5) = *(int *)(local_28 + 5) + 1;
return local_28;
}
local_38 = _my_thread_var();
local_48[0] = local_14;
local_40 = local_20;
*(int **)(local_38 + 0xa8) = local_48;
link_into_queue(local_10 + 0x118,local_38);
inline_mysql_cond_wait
(local_38 + 8,local_10 + 0xc0,
"/workspace/llm4binary/github2025/eloqsql/mysys/mf_keycache.c",0x71e);
*(int8 *)(local_38 + 0xa8) = 0;
}
local_28 = *(int8 **)(local_10 + 0x90);
*(int8 *)(local_10 + 0x90) = *local_28;
goto LAB_001e6407;
}
| |
22,206 | quantize_row_q4_1_ref | llama.cpp/ggml/src/ggml-quants.c | void quantize_row_q4_1_ref(const float * GGML_RESTRICT x, block_q4_1 * GGML_RESTRICT y, int64_t k) {
const int qk = QK4_1;
assert(k % qk == 0);
const int nb = k / qk;
for (int i = 0; i < nb; i++) {
float min = FLT_MAX;
float max = -FLT_MAX;
for (int j = 0; j < qk; j++) {
const float v = x[i*qk + j];
if (v < min) min = v;
if (v > max) max = v;
}
const float d = (max - min) / ((1 << 4) - 1);
const float id = d ? 1.0f/d : 0.0f;
y[i].d = GGML_FP32_TO_FP16(d);
y[i].m = GGML_FP32_TO_FP16(min);
for (int j = 0; j < qk/2; ++j) {
const float x0 = (x[i*qk + 0 + j] - min)*id;
const float x1 = (x[i*qk + qk/2 + j] - min)*id;
const uint8_t xi0 = MIN(15, (int8_t)(x0 + 0.5f));
const uint8_t xi1 = MIN(15, (int8_t)(x1 + 0.5f));
y[i].qs[j] = xi0;
y[i].qs[j] |= xi1 << 4;
}
}
} | O3 | c | quantize_row_q4_1_ref:
leaq 0x1f(%rdx), %rax
testq %rdx, %rdx
cmovnsq %rdx, %rax
sarq $0x5, %rax
testl %eax, %eax
jle 0x2bcad
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
leaq 0x4(%rsi), %rcx
xorl %edx, %edx
movdqa 0x22ad7(%rip), %xmm11 # 0x4e580
movaps 0x22adf(%rip), %xmm12 # 0x4e590
movdqa 0x22ae6(%rip), %xmm13 # 0x4e5a0
movdqa 0x22aed(%rip), %xmm14 # 0x4e5b0
movdqa 0x22af4(%rip), %xmm15 # 0x4e5c0
movss 0x1e61c(%rip), %xmm2 # 0x4a0f0
xorps %xmm0, %xmm0
movaps 0x1e592(%rip), %xmm3 # 0x4a070
movdqa 0x22a1a(%rip), %xmm1 # 0x4e500
movdqa 0x22a22(%rip), %xmm4 # 0x4e510
xorl %r8d, %r8d
movss 0x22f7f(%rip), %xmm6 # 0x4ea78
movss 0x22f73(%rip), %xmm5 # 0x4ea74
movaps %xmm5, %xmm7
movaps %xmm6, %xmm8
movss (%rdi,%r8,4), %xmm5
movaps %xmm5, %xmm6
minss %xmm8, %xmm6
maxss %xmm7, %xmm5
incq %r8
cmpq $0x20, %r8
jne 0x2bb01
subss %xmm6, %xmm5
divss 0x22f4d(%rip), %xmm5 # 0x4ea7c
movaps %xmm5, %xmm10
unpcklps %xmm6, %xmm10 # xmm10 = xmm10[0],xmm6[0],xmm10[1],xmm6[1]
movaps %xmm10, %xmm8
paddd %xmm10, %xmm8
pxor 0x1e537(%rip), %xmm8 # 0x4a080
movdqa %xmm8, %xmm7
pcmpgtd 0x229ea(%rip), %xmm7 # 0x4e540
movdqa %xmm10, %xmm9
pand 0x229ec(%rip), %xmm9 # 0x4e550
paddd 0x229f3(%rip), %xmm9 # 0x4e560
pand %xmm7, %xmm9
pandn 0x229f6(%rip), %xmm7 # 0x4e570
por %xmm9, %xmm7
movaps %xmm10, %xmm9
andps 0x1e495(%rip), %xmm9 # 0x4a020
mulps 0x2298d(%rip), %xmm9 # 0x4e520
mulps 0x22995(%rip), %xmm9 # 0x4e530
addps %xmm9, %xmm7
movaps %xmm7, %xmm9
psrld $0xd, %xmm9
pand %xmm11, %xmm9
andps %xmm12, %xmm7
paddd %xmm9, %xmm7
pcmpgtd %xmm14, %xmm8
movdqa %xmm8, %xmm9
pandn %xmm7, %xmm9
psrld $0x10, %xmm10
pand %xmm13, %xmm10
pand %xmm15, %xmm8
por %xmm10, %xmm8
por %xmm9, %xmm8
leaq (%rdx,%rdx,4), %r8
pshuflw $0xe8, %xmm8, %xmm7 # xmm7 = xmm8[0,2,2,3,4,5,6,7]
movd %xmm7, (%rsi,%r8,4)
movaps %xmm2, %xmm7
divss %xmm5, %xmm7
cmpneqss %xmm0, %xmm5
andps %xmm7, %xmm5
shufps $0x0, %xmm6, %xmm6 # xmm6 = xmm6[0,0,0,0]
shufps $0x0, %xmm5, %xmm5 # xmm5 = xmm5[0,0,0,0]
xorl %r8d, %r8d
movups (%rdi,%r8,4), %xmm7
movups 0x40(%rdi,%r8,4), %xmm8
subps %xmm6, %xmm7
mulps %xmm5, %xmm7
subps %xmm6, %xmm8
mulps %xmm5, %xmm8
addps %xmm3, %xmm7
cvttps2dq %xmm7, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
movdqa %xmm1, %xmm9
pcmpgtb %xmm7, %xmm9
pand %xmm9, %xmm7
pandn %xmm1, %xmm9
por %xmm7, %xmm9
addps %xmm3, %xmm8
cvttps2dq %xmm8, %xmm7
packssdw %xmm7, %xmm7
packsswb %xmm7, %xmm7
movdqa %xmm1, %xmm8
pcmpgtb %xmm7, %xmm8
pand %xmm8, %xmm7
pandn %xmm1, %xmm8
por %xmm7, %xmm8
psllw $0x4, %xmm8
pand %xmm4, %xmm8
por %xmm9, %xmm8
movd %xmm8, (%rcx,%r8)
addq $0x4, %r8
cmpq $0x10, %r8
jne 0x2bc0a
incq %rdx
subq $-0x80, %rdi
addq $0x14, %rcx
cmpq %rax, %rdx
jne 0x2baee
retq
| quantize_row_q4_1_ref:
lea rax, [rdx+1Fh]
test rdx, rdx
cmovns rax, rdx
sar rax, 5
test eax, eax
jle locret_2BCAD
and eax, 7FFFFFFFh
lea rcx, [rsi+4]
xor edx, edx
movdqa xmm11, cs:xmmword_4E580
movaps xmm12, cs:xmmword_4E590
movdqa xmm13, cs:xmmword_4E5A0
movdqa xmm14, cs:xmmword_4E5B0
movdqa xmm15, cs:xmmword_4E5C0
movss xmm2, cs:dword_4A0F0
xorps xmm0, xmm0
movaps xmm3, cs:xmmword_4A070
movdqa xmm1, cs:xmmword_4E500
movdqa xmm4, cs:xmmword_4E510
loc_2BAEE:
xor r8d, r8d
movss xmm6, cs:dword_4EA78
movss xmm5, cs:dword_4EA74
loc_2BB01:
movaps xmm7, xmm5
movaps xmm8, xmm6
movss xmm5, dword ptr [rdi+r8*4]
movaps xmm6, xmm5
minss xmm6, xmm8
maxss xmm5, xmm7
inc r8
cmp r8, 20h ; ' '
jnz short loc_2BB01
subss xmm5, xmm6
divss xmm5, cs:dword_4EA7C
movaps xmm10, xmm5
unpcklps xmm10, xmm6
movaps xmm8, xmm10
paddd xmm8, xmm10
pxor xmm8, cs:xmmword_4A080
movdqa xmm7, xmm8
pcmpgtd xmm7, cs:xmmword_4E540
movdqa xmm9, xmm10
pand xmm9, cs:xmmword_4E550
paddd xmm9, cs:xmmword_4E560
pand xmm9, xmm7
pandn xmm7, cs:xmmword_4E570
por xmm7, xmm9
movaps xmm9, xmm10
andps xmm9, cs:xmmword_4A020
mulps xmm9, cs:xmmword_4E520
mulps xmm9, cs:xmmword_4E530
addps xmm7, xmm9
movaps xmm9, xmm7
psrld xmm9, 0Dh
pand xmm9, xmm11
andps xmm7, xmm12
paddd xmm7, xmm9
pcmpgtd xmm8, xmm14
movdqa xmm9, xmm8
pandn xmm9, xmm7
psrld xmm10, 10h
pand xmm10, xmm13
pand xmm8, xmm15
por xmm8, xmm10
por xmm8, xmm9
lea r8, [rdx+rdx*4]
pshuflw xmm7, xmm8, 0E8h
movd dword ptr [rsi+r8*4], xmm7
movaps xmm7, xmm2
divss xmm7, xmm5
cmpneqss xmm5, xmm0
andps xmm5, xmm7
shufps xmm6, xmm6, 0
shufps xmm5, xmm5, 0
xor r8d, r8d
loc_2BC0A:
movups xmm7, xmmword ptr [rdi+r8*4]
movups xmm8, xmmword ptr [rdi+r8*4+40h]
subps xmm7, xmm6
mulps xmm7, xmm5
subps xmm8, xmm6
mulps xmm8, xmm5
addps xmm7, xmm3
cvttps2dq xmm7, xmm7
packssdw xmm7, xmm7
packsswb xmm7, xmm7
movdqa xmm9, xmm1
pcmpgtb xmm9, xmm7
pand xmm7, xmm9
pandn xmm9, xmm1
por xmm9, xmm7
addps xmm8, xmm3
cvttps2dq xmm7, xmm8
packssdw xmm7, xmm7
packsswb xmm7, xmm7
movdqa xmm8, xmm1
pcmpgtb xmm8, xmm7
pand xmm7, xmm8
pandn xmm8, xmm1
por xmm8, xmm7
psllw xmm8, 4
pand xmm8, xmm4
por xmm8, xmm9
movd dword ptr [rcx+r8], xmm8
add r8, 4
cmp r8, 10h
jnz loc_2BC0A
inc rdx
sub rdi, 0FFFFFFFFFFFFFF80h
add rcx, 14h
cmp rdx, rax
jnz loc_2BAEE
locret_2BCAD:
retn
| long long quantize_row_q4_1_ref(long long a1, long long a2, long long a3)
{
long long result; // rax
long long v4; // rcx
long long v5; // rdx
__m128i si128; // xmm11
__m128i v7; // xmm13
__m128i v8; // xmm14
__m128i v9; // xmm15
__m128 v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm4
long long v13; // r8
__m128 v14; // xmm6
__m128 v15; // xmm5
float v16; // xmm7_4
float v17; // xmm8_4
__m128 v18; // xmm10
__m128i v19; // xmm8
__m128i v20; // xmm7
__m128 v21; // xmm7
__m128i v22; // xmm8
__m128 v23; // xmm7
__m128 v24; // xmm5
__m128 v25; // xmm6
__m128 v26; // xmm5
long long i; // r8
__m128i v28; // xmm7
__m128i v29; // xmm7
__m128i v30; // xmm7
__m128i v31; // xmm9
__m128i v32; // xmm9
__m128i v33; // xmm7
__m128i v34; // xmm7
__m128i v35; // xmm7
__m128i v36; // xmm8
result = a3 / 32;
if ( (int)(a3 / 32) > 0 )
{
result = (a3 / 32) & 0x7FFFFFFF;
v4 = a2 + 4;
v5 = 0LL;
si128 = _mm_load_si128((const __m128i *)&xmmword_4E580);
v7 = _mm_load_si128((const __m128i *)&xmmword_4E5A0);
v8 = _mm_load_si128((const __m128i *)&xmmword_4E5B0);
v9 = _mm_load_si128((const __m128i *)&xmmword_4E5C0);
v10.m128_i32[0] = 0;
v11 = _mm_load_si128((const __m128i *)&xmmword_4E500);
v12 = _mm_load_si128((const __m128i *)&xmmword_4E510);
do
{
v13 = 0LL;
v14.m128_i32[0] = 2139095039;
v15.m128_i32[0] = -8388609;
do
{
v16 = v15.m128_f32[0];
v17 = v14.m128_f32[0];
v15 = (__m128)*(unsigned int *)(a1 + 4 * v13);
v14 = v15;
v14.m128_f32[0] = fminf(v15.m128_f32[0], v17);
v15.m128_f32[0] = fmaxf(v15.m128_f32[0], v16);
++v13;
}
while ( v13 != 32 );
v15.m128_f32[0] = (float)(v15.m128_f32[0] - v14.m128_f32[0]) / 15.0;
v18 = _mm_unpacklo_ps(v15, v14);
v19 = _mm_xor_si128(_mm_add_epi32((__m128i)v18, (__m128i)v18), (__m128i)xmmword_4A080);
v20 = _mm_cmpgt_epi32(v19, (__m128i)xmmword_4E540);
v21 = _mm_add_ps(
(__m128)_mm_or_si128(
_mm_andnot_si128(v20, (__m128i)xmmword_4E570),
_mm_and_si128(
_mm_add_epi32(_mm_and_si128((__m128i)v18, (__m128i)xmmword_4E550), (__m128i)xmmword_4E560),
v20)),
_mm_mul_ps(
_mm_mul_ps(_mm_and_ps(v18, (__m128)xmmword_4A020), (__m128)xmmword_4E520),
(__m128)xmmword_4E530));
v22 = _mm_cmpgt_epi32(v19, v8);
*(_DWORD *)(a2 + 20 * v5) = _mm_cvtsi128_si32(
_mm_shufflelo_epi16(
_mm_or_si128(
_mm_or_si128(
_mm_and_si128(v22, v9),
_mm_and_si128(_mm_srli_epi32((__m128i)v18, 0x10u), v7)),
_mm_andnot_si128(
v22,
_mm_add_epi32(
(__m128i)_mm_and_ps(v21, (__m128)xmmword_4E590),
_mm_and_si128(_mm_srli_epi32((__m128i)v21, 0xDu), si128)))),
232));
v23 = (__m128)0x3F800000u;
v23.m128_f32[0] = 1.0 / v15.m128_f32[0];
v24 = _mm_and_ps(_mm_cmpneq_ss(v15, v10), v23);
v25 = _mm_shuffle_ps(v14, v14, 0);
v26 = _mm_shuffle_ps(v24, v24, 0);
for ( i = 0LL; i != 16; i += 4LL )
{
v28 = _mm_cvttps_epi32(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(*(__m128 *)(a1 + 4 * i), v25), v26), (__m128)xmmword_4A070));
v29 = _mm_packs_epi32(v28, v28);
v30 = _mm_packs_epi16(v29, v29);
v31 = _mm_cmpgt_epi8(v11, v30);
v32 = _mm_or_si128(_mm_andnot_si128(v31, v11), _mm_and_si128(v30, v31));
v33 = _mm_cvttps_epi32(_mm_add_ps(_mm_mul_ps(_mm_sub_ps(*(__m128 *)(a1 + 4 * i + 64), v25), v26), (__m128)xmmword_4A070));
v34 = _mm_packs_epi32(v33, v33);
v35 = _mm_packs_epi16(v34, v34);
v36 = _mm_cmpgt_epi8(v11, v35);
*(_DWORD *)(v4 + i) = _mm_cvtsi128_si32(
_mm_or_si128(
_mm_and_si128(
_mm_slli_epi16(
_mm_or_si128(_mm_andnot_si128(v36, v11), _mm_and_si128(v35, v36)),
4u),
v12),
v32));
}
++v5;
a1 += 128LL;
v4 += 20LL;
}
while ( v5 != result );
}
return result;
}
| quantize_row_q4_1_ref:
LEA RAX,[RDX + 0x1f]
TEST RDX,RDX
CMOVNS RAX,RDX
SAR RAX,0x5
TEST EAX,EAX
JLE 0x0012bcad
AND EAX,0x7fffffff
LEA RCX,[RSI + 0x4]
XOR EDX,EDX
MOVDQA XMM11,xmmword ptr [0x0014e580]
MOVAPS XMM12,xmmword ptr [0x0014e590]
MOVDQA XMM13,xmmword ptr [0x0014e5a0]
MOVDQA XMM14,xmmword ptr [0x0014e5b0]
MOVDQA XMM15,xmmword ptr [0x0014e5c0]
MOVSS XMM2,dword ptr [0x0014a0f0]
XORPS XMM0,XMM0
MOVAPS XMM3,xmmword ptr [0x0014a070]
MOVDQA XMM1,xmmword ptr [0x0014e500]
MOVDQA XMM4,xmmword ptr [0x0014e510]
LAB_0012baee:
XOR R8D,R8D
MOVSS XMM6,dword ptr [0x0014ea78]
MOVSS XMM5,dword ptr [0x0014ea74]
LAB_0012bb01:
MOVAPS XMM7,XMM5
MOVAPS XMM8,XMM6
MOVSS XMM5,dword ptr [RDI + R8*0x4]
MOVAPS XMM6,XMM5
MINSS XMM6,XMM8
MAXSS XMM5,XMM7
INC R8
CMP R8,0x20
JNZ 0x0012bb01
SUBSS XMM5,XMM6
DIVSS XMM5,dword ptr [0x0014ea7c]
MOVAPS XMM10,XMM5
UNPCKLPS XMM10,XMM6
MOVAPS XMM8,XMM10
PADDD XMM8,XMM10
PXOR XMM8,xmmword ptr [0x0014a080]
MOVDQA XMM7,XMM8
PCMPGTD XMM7,xmmword ptr [0x0014e540]
MOVDQA XMM9,XMM10
PAND XMM9,xmmword ptr [0x0014e550]
PADDD XMM9,xmmword ptr [0x0014e560]
PAND XMM9,XMM7
PANDN XMM7,xmmword ptr [0x0014e570]
POR XMM7,XMM9
MOVAPS XMM9,XMM10
ANDPS XMM9,xmmword ptr [0x0014a020]
MULPS XMM9,xmmword ptr [0x0014e520]
MULPS XMM9,xmmword ptr [0x0014e530]
ADDPS XMM7,XMM9
MOVAPS XMM9,XMM7
PSRLD XMM9,0xd
PAND XMM9,XMM11
ANDPS XMM7,XMM12
PADDD XMM7,XMM9
PCMPGTD XMM8,XMM14
MOVDQA XMM9,XMM8
PANDN XMM9,XMM7
PSRLD XMM10,0x10
PAND XMM10,XMM13
PAND XMM8,XMM15
POR XMM8,XMM10
POR XMM8,XMM9
LEA R8,[RDX + RDX*0x4]
PSHUFLW XMM7,XMM8,0xe8
MOVD dword ptr [RSI + R8*0x4],XMM7
MOVAPS XMM7,XMM2
DIVSS XMM7,XMM5
CMPNEQSS XMM5,XMM0
ANDPS XMM5,XMM7
SHUFPS XMM6,XMM6,0x0
SHUFPS XMM5,XMM5,0x0
XOR R8D,R8D
LAB_0012bc0a:
MOVUPS XMM7,xmmword ptr [RDI + R8*0x4]
MOVUPS XMM8,xmmword ptr [RDI + R8*0x4 + 0x40]
SUBPS XMM7,XMM6
MULPS XMM7,XMM5
SUBPS XMM8,XMM6
MULPS XMM8,XMM5
ADDPS XMM7,XMM3
CVTTPS2DQ XMM7,XMM7
PACKSSDW XMM7,XMM7
PACKSSWB XMM7,XMM7
MOVDQA XMM9,XMM1
PCMPGTB XMM9,XMM7
PAND XMM7,XMM9
PANDN XMM9,XMM1
POR XMM9,XMM7
ADDPS XMM8,XMM3
CVTTPS2DQ XMM7,XMM8
PACKSSDW XMM7,XMM7
PACKSSWB XMM7,XMM7
MOVDQA XMM8,XMM1
PCMPGTB XMM8,XMM7
PAND XMM7,XMM8
PANDN XMM8,XMM1
POR XMM8,XMM7
PSLLW XMM8,0x4
PAND XMM8,XMM4
POR XMM8,XMM9
MOVD dword ptr [RCX + R8*0x1],XMM8
ADD R8,0x4
CMP R8,0x10
JNZ 0x0012bc0a
INC RDX
SUB RDI,-0x80
ADD RCX,0x14
CMP RDX,RAX
JNZ 0x0012baee
LAB_0012bcad:
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void quantize_row_q4_1_ref(long param_1,long param_2,long param_3)
{
float *pfVar1;
float *pfVar2;
float fVar3;
float fVar4;
float fVar5;
float fVar6;
float fVar7;
int1 auVar8 [16];
uint uVar9;
uint uVar10;
uint uVar11;
uint uVar12;
uint uVar13;
uint uVar14;
uint uVar15;
uint uVar16;
uint uVar17;
int1 auVar18 [16];
int iVar19;
int iVar20;
int iVar21;
int iVar22;
int1 auVar23 [16];
uint uVar24;
long lVar25;
ulong uVar26;
long lVar27;
float fVar28;
float fVar29;
uint uVar30;
float fVar31;
uint uVar36;
float fVar37;
float fVar38;
float fVar39;
int1 auVar32 [16];
int1 auVar33 [16];
int1 auVar34 [16];
int1 auVar35 [16];
uint uVar40;
uint uVar42;
int1 auVar41 [16];
int1 auVar43 [16];
auVar23 = _DAT_0014e5c0;
iVar22 = _UNK_0014e5bc;
iVar21 = _UNK_0014e5b8;
iVar20 = _UNK_0014e5b4;
iVar19 = _DAT_0014e5b0;
auVar18 = _DAT_0014e5a0;
uVar17 = _UNK_0014e59c;
uVar16 = _UNK_0014e598;
uVar15 = _UNK_0014e594;
uVar14 = _DAT_0014e590;
uVar13 = _UNK_0014e58c;
uVar12 = _UNK_0014e588;
uVar11 = _UNK_0014e584;
uVar10 = _DAT_0014e580;
uVar9 = _DAT_0014e510;
auVar8 = _DAT_0014e500;
fVar7 = DAT_0014a0f0;
fVar6 = _UNK_0014a07c;
fVar5 = _UNK_0014a078;
fVar4 = _UNK_0014a074;
fVar3 = _DAT_0014a070;
lVar25 = param_3 + 0x1f;
if (-1 < param_3) {
lVar25 = param_3;
}
uVar24 = (uint)(lVar25 >> 5);
if (0 < (int)uVar24) {
lVar25 = param_2 + 4;
uVar26 = 0;
do {
lVar27 = 0;
fVar28 = DAT_0014ea74;
fVar31 = DAT_0014ea78;
do {
fVar37 = *(float *)(param_1 + lVar27 * 4);
fVar29 = fVar37;
if (fVar31 <= fVar37) {
fVar29 = fVar31;
}
if (fVar37 <= fVar28) {
fVar37 = fVar28;
}
lVar27 = lVar27 + 1;
fVar28 = fVar37;
fVar31 = fVar29;
} while (lVar27 != 0x20);
fVar28 = (fVar37 - fVar29) / DAT_0014ea7c;
uVar40 = (int)fVar28 * 2 ^ _DAT_0014a080;
uVar42 = (int)fVar29 * 2 ^ _UNK_0014a084;
uVar30 = -(uint)(_DAT_0014e540 < (int)uVar40);
uVar36 = -(uint)(_UNK_0014e544 < (int)uVar42);
fVar31 = (float)(~uVar30 & _DAT_0014e570 |
((uint)fVar28 & _DAT_0014e550) + _DAT_0014e560 & uVar30) +
(float)((uint)fVar28 & _DAT_0014a020) * _DAT_0014e520 * _DAT_0014e530;
fVar37 = (float)(~uVar36 & _UNK_0014e574 |
((uint)fVar29 & _UNK_0014e554) + _UNK_0014e564 & uVar36) +
(float)((uint)fVar29 & _UNK_0014a024) * _UNK_0014e524 * _UNK_0014e534;
fVar38 = (float)(~-(uint)(_UNK_0014e548 < _UNK_0014a088) & _UNK_0014e578 |
_UNK_0014e568 & -(uint)(_UNK_0014e548 < _UNK_0014a088)) +
_UNK_0014e528 * 0.0 * _UNK_0014e538;
fVar39 = (float)(~-(uint)(_UNK_0014e54c < _UNK_0014a08c) & _UNK_0014e57c |
_UNK_0014e56c & -(uint)(_UNK_0014e54c < _UNK_0014a08c)) +
_UNK_0014e52c * 0.0 * _UNK_0014e53c;
auVar32._0_4_ = ((uint)fVar31 & uVar14) + ((uint)fVar31 >> 0xd & uVar10);
auVar32._4_4_ = ((uint)fVar37 & uVar15) + ((uint)fVar37 >> 0xd & uVar11);
auVar32._8_4_ = ((uint)fVar38 & uVar16) + ((uint)fVar38 >> 0xd & uVar12);
auVar32._12_4_ = ((uint)fVar39 & uVar17) + ((uint)fVar39 >> 0xd & uVar13);
auVar35._0_4_ = -(uint)(iVar19 < (int)uVar40);
auVar35._4_4_ = -(uint)(iVar20 < (int)uVar42);
auVar35._8_4_ = -(uint)(iVar21 < _UNK_0014a088);
auVar35._12_4_ = -(uint)(iVar22 < _UNK_0014a08c);
auVar43._0_4_ = (uint)fVar28 >> 0x10;
auVar43._4_4_ = (uint)fVar29 >> 0x10;
auVar43._8_8_ = 0;
auVar32 = pshuflw(auVar32,auVar35 & auVar23 | auVar43 & auVar18 | ~auVar35 & auVar32,0xe8);
*(int *)(param_2 + uVar26 * 0x14) = auVar32._0_4_;
fVar28 = (float)(-(uint)(fVar28 != 0.0) & (uint)(fVar7 / fVar28));
lVar27 = 0;
do {
pfVar1 = (float *)(param_1 + lVar27 * 4);
pfVar2 = (float *)(param_1 + 0x40 + lVar27 * 4);
auVar33._0_4_ = (int)((*pfVar1 - fVar29) * fVar28 + fVar3);
auVar33._4_4_ = (int)((pfVar1[1] - fVar29) * fVar28 + fVar4);
auVar33._8_4_ = (int)((pfVar1[2] - fVar29) * fVar28 + fVar5);
auVar33._12_4_ = (int)((pfVar1[3] - fVar29) * fVar28 + fVar6);
auVar32 = packssdw(auVar33,auVar33);
auVar32 = packsswb(auVar32,auVar32);
uVar30 = CONCAT13(-(auVar32[3] < auVar8[3]),
CONCAT12(-(auVar32[2] < auVar8[2]),
CONCAT11(-(auVar32[1] < auVar8[1]),-(auVar32[0] < auVar8[0]))));
auVar34._0_4_ = (int)((*pfVar2 - fVar29) * fVar28 + fVar3);
auVar34._4_4_ = (int)((pfVar2[1] - fVar29) * fVar28 + fVar4);
auVar34._8_4_ = (int)((pfVar2[2] - fVar29) * fVar28 + fVar5);
auVar34._12_4_ = (int)((pfVar2[3] - fVar29) * fVar28 + fVar6);
auVar35 = packssdw(auVar34,auVar34);
auVar35 = packsswb(auVar35,auVar35);
auVar41[0] = -(auVar35[0] < auVar8[0]);
auVar41[1] = -(auVar35[1] < auVar8[1]);
auVar41[2] = -(auVar35[2] < auVar8[2]);
auVar41[3] = -(auVar35[3] < auVar8[3]);
auVar41[4] = -(auVar35[4] < auVar8[4]);
auVar41[5] = -(auVar35[5] < auVar8[5]);
auVar41[6] = -(auVar35[6] < auVar8[6]);
auVar41[7] = -(auVar35[7] < auVar8[7]);
auVar41[8] = -(auVar35[8] < auVar8[8]);
auVar41[9] = -(auVar35[9] < auVar8[9]);
auVar41[10] = -(auVar35[10] < auVar8[10]);
auVar41[0xb] = -(auVar35[0xb] < auVar8[0xb]);
auVar41[0xc] = -(auVar35[0xc] < auVar8[0xc]);
auVar41[0xd] = -(auVar35[0xd] < auVar8[0xd]);
auVar41[0xe] = -(auVar35[0xe] < auVar8[0xe]);
auVar41[0xf] = -(auVar35[0xf] < auVar8[0xf]);
auVar35 = psllw(~auVar41 & auVar8 | auVar35 & auVar41,4);
*(uint *)(lVar25 + lVar27) =
auVar35._0_4_ & uVar9 | ~uVar30 & auVar8._0_4_ | auVar32._0_4_ & uVar30;
lVar27 = lVar27 + 4;
} while (lVar27 != 0x10);
uVar26 = uVar26 + 1;
param_1 = param_1 + 0x80;
lVar25 = lVar25 + 0x14;
} while (uVar26 != (uVar24 & 0x7fffffff));
}
return;
}
| |
22,207 | dequantize_row_tq1_0 | llama.cpp/ggml/src/ggml-quants.c | void dequantize_row_tq1_0(const block_tq1_0 * GGML_RESTRICT x, float * GGML_RESTRICT y, int64_t k) {
assert(k % QK_K == 0);
const int64_t nb = k / QK_K;
const uint8_t pow3[6] = {1, 3, 9, 27, 81, 243};
for (int64_t i = 0; i < nb; ++i) {
const float d = GGML_FP16_TO_FP32(x[i].d);
for (size_t j = 0; j < sizeof(x->qs) - sizeof(x->qs) % 32; j += 32) {
for (size_t n = 0; n < 5; ++n) {
for (size_t m = 0; m < 32; ++m) {
uint8_t q = x[i].qs[j + m] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
for (size_t j = sizeof(x->qs) - sizeof(x->qs) % 32; j < sizeof(x->qs); j += 16) {
for (size_t n = 0; n < 5; ++n) {
for (size_t m = 0; m < 16; ++m) {
uint8_t q = x[i].qs[j + m] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
for (size_t n = 0; n < 4; ++n) {
for (size_t j = 0; j < sizeof(x->qh); ++j) {
uint8_t q = x[i].qh[j] * pow3[n];
int16_t xi = ((uint16_t) q * 3) >> 8;
*y++ = (float) (xi - 1) * d;
}
}
}
} | O3 | c | dequantize_row_tq1_0:
leaq 0xff(%rdx), %r8
testq %rdx, %rdx
cmovnsq %rdx, %r8
cmpq $0x100, %rdx # imm = 0x100
jl 0x32320
pushq %r14
pushq %rbx
sarq $0x8, %r8
xorl %edx, %edx
movq 0x37d77(%rip), %r9 # 0x69fa8
leaq 0x1c9c0(%rip), %r10 # 0x4ebf8
movq %rdi, %r11
imulq $0x36, %rdx, %rax
movzwl 0x34(%rdi,%rax), %eax
movss (%r9,%rax,4), %xmm0
xorl %ebx, %ebx
movb (%rbx,%r10), %cl
xorl %r14d, %r14d
movl %ecx, %eax
mulb (%r11,%r14)
movzbl %al, %eax
leal (%rax,%rax,2), %eax
shrl $0x8, %eax
decl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi)
addq $0x4, %rsi
incq %r14
cmpq $0x20, %r14
jne 0x32253
incq %rbx
cmpq $0x5, %rbx
jne 0x3224c
xorl %ebx, %ebx
movb (%rbx,%r10), %cl
movl $0x20, %r14d
movl %ecx, %eax
mulb (%r11,%r14)
movzbl %al, %eax
leal (%rax,%rax,2), %eax
shrl $0x8, %eax
decl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi)
addq $0x4, %rsi
incq %r14
cmpq $0x30, %r14
jne 0x32295
incq %rbx
cmpq $0x5, %rbx
jne 0x3228b
xorl %ebx, %ebx
movb (%rbx,%r10), %cl
movl $0x30, %r14d
movl %ecx, %eax
mulb (%r11,%r14)
movzbl %al, %eax
leal (%rax,%rax,2), %eax
shrl $0x8, %eax
decl %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rsi)
addq $0x4, %rsi
incq %r14
cmpq $0x34, %r14
jne 0x322d7
incq %rbx
cmpq $0x4, %rbx
jne 0x322cd
incq %rdx
addq $0x36, %r11
cmpq %r8, %rdx
jne 0x3223b
popq %rbx
popq %r14
retq
| dequantize_row_tq1_0:
lea r8, [rdx+0FFh]
test rdx, rdx
cmovns r8, rdx
cmp rdx, 100h
jl locret_32320
push r14
push rbx
sar r8, 8
xor edx, edx
mov r9, cs:ggml_table_f32_f16_ptr
lea r10, unk_4EBF8
mov r11, rdi
loc_3223B:
imul rax, rdx, 36h ; '6'
movzx eax, word ptr [rdi+rax+34h]
movss xmm0, dword ptr [r9+rax*4]
xor ebx, ebx
loc_3224C:
mov cl, [rbx+r10]
xor r14d, r14d
loc_32253:
mov eax, ecx
mul byte ptr [r11+r14]
movzx eax, al
lea eax, [rax+rax*2]
shr eax, 8
dec eax
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rsi], xmm1
add rsi, 4
inc r14
cmp r14, 20h ; ' '
jnz short loc_32253
inc rbx
cmp rbx, 5
jnz short loc_3224C
xor ebx, ebx
loc_3228B:
mov cl, [rbx+r10]
mov r14d, 20h ; ' '
loc_32295:
mov eax, ecx
mul byte ptr [r11+r14]
movzx eax, al
lea eax, [rax+rax*2]
shr eax, 8
dec eax
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rsi], xmm1
add rsi, 4
inc r14
cmp r14, 30h ; '0'
jnz short loc_32295
inc rbx
cmp rbx, 5
jnz short loc_3228B
xor ebx, ebx
loc_322CD:
mov cl, [rbx+r10]
mov r14d, 30h ; '0'
loc_322D7:
mov eax, ecx
mul byte ptr [r11+r14]
movzx eax, al
lea eax, [rax+rax*2]
shr eax, 8
dec eax
xorps xmm1, xmm1
cvtsi2ss xmm1, eax
mulss xmm1, xmm0
movss dword ptr [rsi], xmm1
add rsi, 4
inc r14
cmp r14, 34h ; '4'
jnz short loc_322D7
inc rbx
cmp rbx, 4
jnz short loc_322CD
inc rdx
add r11, 36h ; '6'
cmp rdx, r8
jnz loc_3223B
pop rbx
pop r14
locret_32320:
retn
| long long dequantize_row_tq1_0(long long a1, float *a2, long long a3)
{
long long v3; // r8
long long v4; // r8
long long v5; // rdx
long long v6; // r11
float v7; // xmm0_4
long long i; // rbx
char v9; // cl
long long j; // r14
long long k; // rbx
char v12; // cl
long long m; // r14
long long n; // rbx
char v15; // cl
long long ii; // r14
long long result; // rax
v3 = a3 + 255;
if ( a3 >= 0 )
v3 = a3;
if ( a3 >= 256 )
{
v4 = v3 >> 8;
v5 = 0LL;
v6 = a1;
do
{
v7 = ggml_table_f32_f16[*(unsigned __int16 *)(a1 + 54 * v5 + 52)];
for ( i = 0LL; i != 5; ++i )
{
v9 = byte_4EBF8[i];
for ( j = 0LL; j != 32; ++j )
*a2++ = (float)(int)(((3 * (unsigned int)(unsigned __int8)(*(_BYTE *)(v6 + j) * v9)) >> 8) - 1) * v7;
}
for ( k = 0LL; k != 5; ++k )
{
v12 = byte_4EBF8[k];
for ( m = 32LL; m != 48; ++m )
*a2++ = (float)(int)(((3 * (unsigned int)(unsigned __int8)(*(_BYTE *)(v6 + m) * v12)) >> 8) - 1) * v7;
}
for ( n = 0LL; n != 4; ++n )
{
v15 = byte_4EBF8[n];
for ( ii = 48LL; ii != 52; ++ii )
{
result = ((3 * (unsigned int)(unsigned __int8)(*(_BYTE *)(v6 + ii) * v15)) >> 8) - 1;
*a2++ = (float)(int)result * v7;
}
}
++v5;
v6 += 54LL;
}
while ( v5 != v4 );
}
return result;
}
| dequantize_row_tq1_0:
LEA R8,[RDX + 0xff]
TEST RDX,RDX
CMOVNS R8,RDX
CMP RDX,0x100
JL 0x00132320
PUSH R14
PUSH RBX
SAR R8,0x8
XOR EDX,EDX
MOV R9,qword ptr [0x00169fa8]
LEA R10,[0x14ebf8]
MOV R11,RDI
LAB_0013223b:
IMUL RAX,RDX,0x36
MOVZX EAX,word ptr [RDI + RAX*0x1 + 0x34]
MOVSS XMM0,dword ptr [R9 + RAX*0x4]
XOR EBX,EBX
LAB_0013224c:
MOV CL,byte ptr [RBX + R10*0x1]
XOR R14D,R14D
LAB_00132253:
MOV EAX,ECX
MUL byte ptr [R11 + R14*0x1]
MOVZX EAX,AL
LEA EAX,[RAX + RAX*0x2]
SHR EAX,0x8
DEC EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RSI],XMM1
ADD RSI,0x4
INC R14
CMP R14,0x20
JNZ 0x00132253
INC RBX
CMP RBX,0x5
JNZ 0x0013224c
XOR EBX,EBX
LAB_0013228b:
MOV CL,byte ptr [RBX + R10*0x1]
MOV R14D,0x20
LAB_00132295:
MOV EAX,ECX
MUL byte ptr [R11 + R14*0x1]
MOVZX EAX,AL
LEA EAX,[RAX + RAX*0x2]
SHR EAX,0x8
DEC EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RSI],XMM1
ADD RSI,0x4
INC R14
CMP R14,0x30
JNZ 0x00132295
INC RBX
CMP RBX,0x5
JNZ 0x0013228b
XOR EBX,EBX
LAB_001322cd:
MOV CL,byte ptr [RBX + R10*0x1]
MOV R14D,0x30
LAB_001322d7:
MOV EAX,ECX
MUL byte ptr [R11 + R14*0x1]
MOVZX EAX,AL
LEA EAX,[RAX + RAX*0x2]
SHR EAX,0x8
DEC EAX
XORPS XMM1,XMM1
CVTSI2SS XMM1,EAX
MULSS XMM1,XMM0
MOVSS dword ptr [RSI],XMM1
ADD RSI,0x4
INC R14
CMP R14,0x34
JNZ 0x001322d7
INC RBX
CMP RBX,0x4
JNZ 0x001322cd
INC RDX
ADD R11,0x36
CMP RDX,R8
JNZ 0x0013223b
POP RBX
POP R14
LAB_00132320:
RET
|
void dequantize_row_tq1_0(long param_1,float *param_2,long param_3)
{
float fVar1;
char cVar2;
int *puVar3;
byte bVar4;
long lVar5;
long lVar6;
long lVar7;
long lVar8;
long lVar9;
puVar3 = PTR_ggml_table_f32_f16_00169fa8;
lVar7 = param_3 + 0xff;
if (-1 < param_3) {
lVar7 = param_3;
}
if (0xff < param_3) {
lVar5 = 0;
lVar8 = param_1;
do {
fVar1 = *(float *)(puVar3 + (ulong)*(ushort *)(param_1 + 0x34 + lVar5 * 0x36) * 4);
lVar6 = 0;
do {
cVar2 = (&DAT_0014ebf8)[lVar6];
lVar9 = 0;
do {
bVar4 = cVar2 * *(char *)(lVar8 + lVar9);
*param_2 = (float)(int)(((uint)bVar4 + (uint)bVar4 * 2 >> 8) - 1) * fVar1;
param_2 = param_2 + 1;
lVar9 = lVar9 + 1;
} while (lVar9 != 0x20);
lVar6 = lVar6 + 1;
} while (lVar6 != 5);
lVar6 = 0;
do {
cVar2 = (&DAT_0014ebf8)[lVar6];
lVar9 = 0x20;
do {
bVar4 = cVar2 * *(char *)(lVar8 + lVar9);
*param_2 = (float)(int)(((uint)bVar4 + (uint)bVar4 * 2 >> 8) - 1) * fVar1;
param_2 = param_2 + 1;
lVar9 = lVar9 + 1;
} while (lVar9 != 0x30);
lVar6 = lVar6 + 1;
} while (lVar6 != 5);
lVar6 = 0;
do {
cVar2 = (&DAT_0014ebf8)[lVar6];
lVar9 = 0x30;
do {
bVar4 = cVar2 * *(char *)(lVar8 + lVar9);
*param_2 = (float)(int)(((uint)bVar4 + (uint)bVar4 * 2 >> 8) - 1) * fVar1;
param_2 = param_2 + 1;
lVar9 = lVar9 + 1;
} while (lVar9 != 0x34);
lVar6 = lVar6 + 1;
} while (lVar6 != 4);
lVar5 = lVar5 + 1;
lVar8 = lVar8 + 0x36;
} while (lVar5 != lVar7 >> 8);
}
return;
}
| |
22,208 | stbtt__get_subrs | dmazzella[P]pylunasvg/lunasvg/plutovg/source/plutovg-stb-truetype.h | static stbtt__buf stbtt__get_subrs(stbtt__buf cff, stbtt__buf fontdict)
{
stbtt_uint32 subrsoff = 0, private_loc[2] = { 0, 0 };
stbtt__buf pdict;
stbtt__dict_get_ints(&fontdict, 18, 2, private_loc);
if (!private_loc[1] || !private_loc[0]) return stbtt__new_buf(NULL, 0);
pdict = stbtt__buf_range(&cff, private_loc[1], private_loc[0]);
stbtt__dict_get_ints(&pdict, 19, 1, &subrsoff);
if (!subrsoff) return stbtt__new_buf(NULL, 0);
stbtt__buf_seek(&cff, private_loc[1]+subrsoff);
return stbtt__cff_get_index(&cff);
} | O0 | c | stbtt__get_subrs:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0xb1d0
leaq -0x3c(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x12, %esi
movl $0x2, %edx
callq 0x58d40
cmpl $0x0, -0x38(%rbp)
je 0x58e12
cmpl $0x0, -0x3c(%rbp)
jne 0x58e28
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x58910
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x58ea2
movl -0x38(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x20(%rbp), %rdi
callq 0x58eb0
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x13, %esi
movl $0x1, %edx
leaq -0x34(%rbp), %rcx
callq 0x58d40
cmpl $0x0, -0x34(%rbp)
jne 0x58e82
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x58910
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x58ea2
movl -0x38(%rbp), %esi
addl -0x34(%rbp), %esi
leaq -0x20(%rbp), %rdi
callq 0x58a90
leaq -0x20(%rbp), %rdi
callq 0x58b60
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
| stbtt__get_subrs:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_20], rdi
mov [rbp+var_18], rsi
mov [rbp+var_30], rdx
mov [rbp+var_28], rcx
mov [rbp+var_34], 0
lea rdi, [rbp+var_3C]
xor esi, esi
mov edx, 8
call _memset
lea rcx, [rbp+var_3C]
lea rdi, [rbp+var_30]
mov esi, 12h
mov edx, 2
call stbtt__dict_get_ints
cmp [rbp+var_38], 0
jz short loc_58E12
cmp [rbp+var_3C], 0
jnz short loc_58E28
loc_58E12:
xor eax, eax
mov esi, eax
mov rdi, rsi
call stbtt__new_buf
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_58EA2
loc_58E28:
mov esi, [rbp+var_38]
mov edx, [rbp+var_3C]
lea rdi, [rbp+var_20]
call stbtt__buf_range
mov [rbp+var_60], rax
mov [rbp+var_58], rdx
mov rax, [rbp+var_60]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
mov [rbp+var_48], rax
lea rdi, [rbp+var_50]
mov esi, 13h
mov edx, 1
lea rcx, [rbp+var_34]
call stbtt__dict_get_ints
cmp [rbp+var_34], 0
jnz short loc_58E82
xor eax, eax
mov esi, eax
mov rdi, rsi
call stbtt__new_buf
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
jmp short loc_58EA2
loc_58E82:
mov esi, [rbp+var_38]
add esi, [rbp+var_34]
lea rdi, [rbp+var_20]
call stbtt__buf_seek
lea rdi, [rbp+var_20]
call stbtt__cff_get_index
mov [rbp+var_10], rax
mov [rbp+var_8], rdx
loc_58EA2:
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 60h
pop rbp
retn
| long long stbtt__get_subrs(long long a1, long long a2, long long a3, long long a4)
{
long long v4; // rdx
long long v5; // rdx
long long v6; // rdx
_QWORD v8[2]; // [rsp+10h] [rbp-50h] BYREF
unsigned int v9; // [rsp+24h] [rbp-3Ch] BYREF
unsigned int v10; // [rsp+28h] [rbp-38h]
int v11; // [rsp+2Ch] [rbp-34h] BYREF
_QWORD v12[2]; // [rsp+30h] [rbp-30h] BYREF
_QWORD v13[2]; // [rsp+40h] [rbp-20h] BYREF
long long index; // [rsp+50h] [rbp-10h]
long long v15; // [rsp+58h] [rbp-8h]
v13[0] = a1;
v13[1] = a2;
v12[0] = a3;
v12[1] = a4;
v11 = 0;
memset(&v9, 0LL, 8LL);
stbtt__dict_get_ints((long long)v12, 0x12u, 2, (long long)&v9);
if ( v10 && v9 )
{
v8[0] = stbtt__buf_range(v13, v10, v9);
v8[1] = v5;
stbtt__dict_get_ints((long long)v8, 0x13u, 1, (long long)&v11);
if ( v11 )
{
stbtt__buf_seek((long long)v13, v11 + v10);
index = stbtt__cff_get_index((long long)v13);
}
else
{
index = stbtt__new_buf(0LL, 0LL);
}
v15 = v6;
}
else
{
index = stbtt__new_buf(0LL, 0LL);
v15 = v4;
}
return index;
}
| stbtt__get_subrs:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x30],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV dword ptr [RBP + -0x34],0x0
LEA RDI,[RBP + -0x3c]
XOR ESI,ESI
MOV EDX,0x8
CALL 0x0010b1d0
LEA RCX,[RBP + -0x3c]
LEA RDI,[RBP + -0x30]
MOV ESI,0x12
MOV EDX,0x2
CALL 0x00158d40
CMP dword ptr [RBP + -0x38],0x0
JZ 0x00158e12
CMP dword ptr [RBP + -0x3c],0x0
JNZ 0x00158e28
LAB_00158e12:
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00158910
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x00158ea2
LAB_00158e28:
MOV ESI,dword ptr [RBP + -0x38]
MOV EDX,dword ptr [RBP + -0x3c]
LEA RDI,[RBP + -0x20]
CALL 0x00158eb0
MOV qword ptr [RBP + -0x60],RAX
MOV qword ptr [RBP + -0x58],RDX
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x50]
MOV ESI,0x13
MOV EDX,0x1
LEA RCX,[RBP + -0x34]
CALL 0x00158d40
CMP dword ptr [RBP + -0x34],0x0
JNZ 0x00158e82
XOR EAX,EAX
MOV ESI,EAX
MOV RDI,RSI
CALL 0x00158910
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
JMP 0x00158ea2
LAB_00158e82:
MOV ESI,dword ptr [RBP + -0x38]
ADD ESI,dword ptr [RBP + -0x34]
LEA RDI,[RBP + -0x20]
CALL 0x00158a90
LEA RDI,[RBP + -0x20]
CALL 0x00158b60
MOV qword ptr [RBP + -0x10],RAX
MOV qword ptr [RBP + -0x8],RDX
LAB_00158ea2:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
int1 [16]
stbtt__get_subrs(int8 param_1,int8 param_2,int8 param_3,int8 param_4)
{
int1 auVar1 [16];
int1 local_58 [16];
int local_44;
int local_40;
int local_3c;
int8 local_38;
int8 local_30;
int8 local_28;
int8 local_20;
local_3c = 0;
local_38 = param_3;
local_30 = param_4;
local_28 = param_1;
local_20 = param_2;
memset(&local_44,0,8);
stbtt__dict_get_ints(&local_38,0x12,2,&local_44);
if ((local_40 == 0) || (local_44 == 0)) {
auVar1 = stbtt__new_buf(0);
}
else {
local_58 = stbtt__buf_range(&local_28,local_40,local_44);
stbtt__dict_get_ints(local_58,0x13,1,&local_3c);
if (local_3c == 0) {
auVar1 = stbtt__new_buf(0);
}
else {
stbtt__buf_seek(&local_28,local_40 + local_3c);
auVar1 = stbtt__cff_get_index(&local_28);
}
}
return auVar1;
}
| |
22,209 | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) | hkr04[P]cpp-mcp/common/json.hpp | Target reinterpret_bits(const Source source)
{
static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
Target target;
std::memcpy(&target, &source, sizeof(Source));
return target;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %xmm0, %rax
movabsq $0x10000000000000, %rcx # imm = 0x10000000000000
decq %rcx
andq %rax, %rcx
movq %rax, %rdx
shrq $0x34, %rdx
movq %rcx, %r14
btsq $0x34, %r14
testq %rdx, %rdx
cmoveq %rcx, %r14
leal -0x433(%rdx), %edx
movl $0xfffffbce, %r15d # imm = 0xFFFFFBCE
cmovnel %edx, %r15d
movq %rdi, %rbx
testq %rcx, %rcx
sete %cl
shrq $0x35, %rax
setne %al
leaq (%r14,%r14), %rdx
leaq 0x1(,%r14,2), %rdi
leal -0x1(%r15), %esi
leal -0x2(%r15), %ebp
testb %cl, %al
cmovel %esi, %ebp
leaq (,%r14,4), %r12
cmoveq %rdx, %r12
decq %r12
callq 0xa750
movq %rax, (%rsp)
movl %edx, %r13d
subl %edx, %ebp
movl %ebp, %ecx
shlq %cl, %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0xa750
movq %rax, (%rbx)
movl %edx, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movl %r13d, 0x18(%rbx)
movq (%rsp), %rax
movq %rax, 0x20(%rbx)
movl %r13d, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl18compute_boundariesIdEENS2_10boundariesET_:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
movq rax, xmm0
mov rcx, 10000000000000h
dec rcx
and rcx, rax
mov rdx, rax
shr rdx, 34h
mov r14, rcx
bts r14, 34h ; '4'
test rdx, rdx
cmovz r14, rcx
lea edx, [rdx-433h]
mov r15d, 0FFFFFBCEh
cmovnz r15d, edx
mov rbx, rdi
test rcx, rcx
setz cl
shr rax, 35h
setnz al
lea rdx, [r14+r14]
lea rdi, ds:1[r14*2]
lea esi, [r15-1]
lea ebp, [r15-2]
test al, cl
cmovz ebp, esi
lea r12, ds:0[r14*4]
cmovz r12, rdx
dec r12
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rsp+38h+var_38], rax
mov r13d, edx
sub ebp, edx
mov ecx, ebp
shl r12, cl
mov rdi, r14
mov esi, r15d
call _ZN8nlohmann16json_abi_v3_11_36detail9dtoa_impl5diyfp9normalizeES3_; nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp)
mov [rbx], rax
mov [rbx+8], edx
mov [rbx+10h], r12
mov [rbx+18h], r13d
mov rax, [rsp+38h+var_38]
mov [rbx+20h], rax
mov [rbx+28h], r13d
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(long long a1, double a2)
{
long long v2; // r14
unsigned int v3; // r15d
bool v4; // cl
bool v5; // al
char v6; // bp
long long v7; // r12
long long v8; // rdx
int v9; // r13d
long long v10; // r12
int v11; // edx
long long v13; // [rsp+0h] [rbp-38h]
v2 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL | 0x10000000000000LL;
if ( !(*(_QWORD *)&a2 >> 52) )
v2 = *(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL;
v3 = -1074;
if ( *(_QWORD *)&a2 >> 52 )
v3 = (*(_QWORD *)&a2 >> 52) - 1075;
v4 = (*(_QWORD *)&a2 & 0xFFFFFFFFFFFFFLL) == 0;
v5 = *(_QWORD *)&a2 >> 53 != 0LL;
v6 = v3 - 2;
if ( !v4 || !v5 )
v6 = v3 - 1;
v7 = 4 * v2;
if ( !v4 || !v5 )
v7 = 2 * v2;
v13 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(2 * v2 + 1, v3 - 1, 2 * v2);
v9 = v8;
v10 = (v7 - 1) << (v6 - (unsigned __int8)v8);
*(_QWORD *)a1 = nlohmann::json_abi_v3_11_3::detail::dtoa_impl::diyfp::normalize(v2, v3, v8);
*(_DWORD *)(a1 + 8) = v11;
*(_QWORD *)(a1 + 16) = v10;
*(_DWORD *)(a1 + 24) = v9;
*(_QWORD *)(a1 + 32) = v13;
*(_DWORD *)(a1 + 40) = v9;
return a1;
}
| compute_boundaries<double>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOVQ RAX,XMM0
MOV RCX,0x10000000000000
DEC RCX
AND RCX,RAX
MOV RDX,RAX
SHR RDX,0x34
MOV R14,RCX
BTS R14,0x34
TEST RDX,RDX
CMOVZ R14,RCX
LEA EDX,[RDX + -0x433]
MOV R15D,0xfffffbce
CMOVNZ R15D,EDX
MOV RBX,RDI
TEST RCX,RCX
SETZ CL
SHR RAX,0x35
SETNZ AL
LEA RDX,[R14 + R14*0x1]
LEA RDI,[0x1 + R14*0x2]
LEA ESI,[R15 + -0x1]
LEA EBP,[R15 + -0x2]
TEST AL,CL
CMOVZ EBP,ESI
LEA R12,[R14*0x4]
CMOVZ R12,RDX
DEC R12
CALL 0x0010a750
MOV qword ptr [RSP],RAX
MOV R13D,EDX
SUB EBP,EDX
MOV ECX,EBP
SHL R12,CL
MOV RDI,R14
MOV ESI,R15D
CALL 0x0010a750
MOV qword ptr [RBX],RAX
MOV dword ptr [RBX + 0x8],EDX
MOV qword ptr [RBX + 0x10],R12
MOV dword ptr [RBX + 0x18],R13D
MOV RAX,qword ptr [RSP]
MOV qword ptr [RBX + 0x20],RAX
MOV dword ptr [RBX + 0x28],R13D
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::dtoa_impl::boundaries
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>(double) */
dtoa_impl * __thiscall
nlohmann::json_abi_v3_11_3::detail::dtoa_impl::compute_boundaries<double>
(dtoa_impl *this,double param_1)
{
ulong uVar1;
char cVar2;
long lVar3;
ulong uVar4;
int iVar5;
bool bVar6;
int1 auVar7 [12];
int1 auVar8 [12];
uVar1 = (ulong)param_1 & 0xfffffffffffff;
bVar6 = (ulong)param_1 >> 0x34 == 0;
uVar4 = uVar1 | 0x10000000000000;
if (bVar6) {
uVar4 = uVar1;
}
iVar5 = -0x432;
if (!bVar6) {
iVar5 = (uint)((ulong)param_1 >> 0x34) - 0x433;
}
bVar6 = (ulong)param_1 >> 0x35 == 0;
cVar2 = (char)iVar5 + -2;
if (bVar6 || uVar1 != 0) {
cVar2 = (char)iVar5 + -1;
}
lVar3 = uVar4 * 4;
if (bVar6 || uVar1 != 0) {
lVar3 = uVar4 * 2;
}
auVar7 = diyfp::normalize(uVar4 * 2 + 1);
auVar8 = diyfp::normalize(uVar4,iVar5);
*(int1 (*) [12])this = auVar8;
*(long *)(this + 0x10) = lVar3 + -1 << (cVar2 - auVar7[8] & 0x3fU);
*(int *)(this + 0x18) = auVar7._8_4_;
*(int1 (*) [12])(this + 0x20) = auVar7;
return this;
}
| |
22,210 | LefDefParser::lefiArray::addTrack(LefDefParser::lefiTrackPattern*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiArray.cpp | void
lefiArray::addTrack(lefiTrackPattern *t)
{
if (numTracks_ == tracksAllocated_) {
lefiTrackPattern **tracks;
int i;
if (tracksAllocated_ == 0)
tracksAllocated_ = 2;
else
tracksAllocated_ = tracksAllocated_ * 2;
tracks = (lefiTrackPattern**) lefMalloc(sizeof(lefiTrackPattern*) *
tracksAllocated_);
for (i = 0; i < numTracks_; i++) {
tracks[i] = track_[i];
}
if (track_)
lefFree((char*) (track_));
track_ = tracks;
}
/*
if (numTracks_ == tracksAllocated_)
bump((void***)(&(track_)), numTracks_, &(tracksAllocated_));
*/
track_[numTracks_] = t;
numTracks_ += 1;
} | O3 | cpp | LefDefParser::lefiArray::addTrack(LefDefParser::lefiTrackPattern*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x44(%rdi), %eax
cmpl 0x40(%rdi), %eax
jne 0xb40a
leal (%rax,%rax), %ecx
testl %eax, %eax
movl $0x2, %eax
cmovnel %ecx, %eax
movl %eax, 0x40(%rbx)
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x30c15
movq %rax, %r15
movslq 0x44(%rbx), %rax
testq %rax, %rax
jle 0xb3f3
xorl %ecx, %ecx
movq 0x48(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movq %rdx, (%r15,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xb3df
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xb404
callq 0x322d0
movl 0x44(%rbx), %eax
movq %r15, 0x48(%rbx)
jmp 0xb40e
movq 0x48(%rbx), %r15
cltq
movq %r14, (%r15,%rax,8)
incl %eax
movl %eax, 0x44(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN12LefDefParser9lefiArray8addTrackEPNS_16lefiTrackPatternE:
push r15
push r14
push rbx
mov r14, rsi
mov rbx, rdi
mov eax, [rdi+44h]
cmp eax, [rdi+40h]
jnz short loc_B40A
lea ecx, [rax+rax]
test eax, eax
mov eax, 2
cmovnz eax, ecx
mov [rbx+40h], eax
movsxd rdi, eax
shl rdi, 3; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
movsxd rax, dword ptr [rbx+44h]
test rax, rax
jle short loc_B3F3
xor ecx, ecx
loc_B3DF:
mov rdx, [rbx+48h]
mov rdx, [rdx+rcx*8]
mov [r15+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_B3DF
loc_B3F3:
mov rdi, [rbx+48h]; this
test rdi, rdi
jz short loc_B404
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov eax, [rbx+44h]
loc_B404:
mov [rbx+48h], r15
jmp short loc_B40E
loc_B40A:
mov r15, [rbx+48h]
loc_B40E:
cdqe
mov [r15+rax*8], r14
inc eax
mov [rbx+44h], eax
pop rbx
pop r14
pop r15
retn
| long long LefDefParser::lefiArray::addTrack(LefDefParser::lefiArray *this, LefDefParser::lefiTrackPattern *a2)
{
long long v3; // rax
int v4; // ecx
bool v5; // zf
int v6; // eax
long long v7; // r15
long long i; // rcx
LefDefParser *v9; // rdi
long long result; // rax
LODWORD(v3) = *((_DWORD *)this + 17);
if ( (_DWORD)v3 == *((_DWORD *)this + 16) )
{
v4 = 2 * v3;
v5 = (_DWORD)v3 == 0;
v6 = 2;
if ( !v5 )
v6 = v4;
*((_DWORD *)this + 16) = v6;
v7 = LefDefParser::lefMalloc((LefDefParser *)(8LL * v6), (unsigned long long)a2);
v3 = *((int *)this + 17);
if ( v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 9) + 8 * i);
}
v9 = (LefDefParser *)*((_QWORD *)this + 9);
if ( v9 )
{
LefDefParser::lefFree(v9, a2);
LODWORD(v3) = *((_DWORD *)this + 17);
}
*((_QWORD *)this + 9) = v7;
}
else
{
v7 = *((_QWORD *)this + 9);
}
*(_QWORD *)(v7 + 8LL * (int)v3) = a2;
result = (unsigned int)(v3 + 1);
*((_DWORD *)this + 17) = result;
return result;
}
| addTrack:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RSI
MOV RBX,RDI
MOV EAX,dword ptr [RDI + 0x44]
CMP EAX,dword ptr [RDI + 0x40]
JNZ 0x0010b40a
LEA ECX,[RAX + RAX*0x1]
TEST EAX,EAX
MOV EAX,0x2
CMOVNZ EAX,ECX
MOV dword ptr [RBX + 0x40],EAX
MOVSXD RDI,EAX
SHL RDI,0x3
CALL 0x00130c15
MOV R15,RAX
MOVSXD RAX,dword ptr [RBX + 0x44]
TEST RAX,RAX
JLE 0x0010b3f3
XOR ECX,ECX
LAB_0010b3df:
MOV RDX,qword ptr [RBX + 0x48]
MOV RDX,qword ptr [RDX + RCX*0x8]
MOV qword ptr [R15 + RCX*0x8],RDX
INC RCX
CMP RAX,RCX
JNZ 0x0010b3df
LAB_0010b3f3:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x0010b404
CALL 0x001322d0
MOV EAX,dword ptr [RBX + 0x44]
LAB_0010b404:
MOV qword ptr [RBX + 0x48],R15
JMP 0x0010b40e
LAB_0010b40a:
MOV R15,qword ptr [RBX + 0x48]
LAB_0010b40e:
CDQE
MOV qword ptr [R15 + RAX*0x8],R14
INC EAX
MOV dword ptr [RBX + 0x44],EAX
POP RBX
POP R14
POP R15
RET
|
/* LefDefParser::lefiArray::addTrack(LefDefParser::lefiTrackPattern*) */
void __thiscall LefDefParser::lefiArray::addTrack(lefiArray *this,lefiTrackPattern *param_1)
{
int iVar1;
int iVar2;
long lVar3;
long lVar4;
iVar2 = *(int *)(this + 0x44);
if (iVar2 == *(int *)(this + 0x40)) {
iVar1 = 2;
if (iVar2 != 0) {
iVar1 = iVar2 * 2;
}
*(int *)(this + 0x40) = iVar1;
lVar3 = lefMalloc((LefDefParser *)((long)iVar1 << 3),(ulong)param_1);
iVar2 = *(int *)(this + 0x44);
if (0 < (long)iVar2) {
lVar4 = 0;
do {
*(int8 *)(lVar3 + lVar4 * 8) = *(int8 *)(*(long *)(this + 0x48) + lVar4 * 8);
lVar4 = lVar4 + 1;
} while (iVar2 != lVar4);
}
if (*(void **)(this + 0x48) != (void *)0x0) {
lefFree(*(void **)(this + 0x48));
iVar2 = *(int *)(this + 0x44);
}
*(long *)(this + 0x48) = lVar3;
}
else {
lVar3 = *(long *)(this + 0x48);
}
*(lefiTrackPattern **)(lVar3 + (long)iVar2 * 8) = param_1;
*(int *)(this + 0x44) = iVar2 + 1;
return;
}
| |
22,211 | nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | monkey531[P]llama/common/json.hpp | static std::string name(const std::string& ename, int id_)
{
return concat("[json.exception.", ename, '.', std::to_string(id_), "] ");
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movb $0x2e, 0xf(%rsp)
movl %edx, %ebp
negl %ebp
cmovsl %edx, %ebp
movl $0x1, %r12d
cmpl $0xa, %ebp
jb 0x588a5
movl $0x4, %r12d
movl $0xd1b71759, %eax # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x5889c
cmpl $0x3e7, %ecx # imm = 0x3E7
jbe 0x588a2
cmpl $0x2710, %ecx # imm = 0x2710
jb 0x588a5
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx # imm = 0x1869F
movl %edx, %ecx
ja 0x58869
addl $-0x3, %r12d
jmp 0x588a5
addl $-0x2, %r12d
jmp 0x588a5
decl %r12d
shrl $0x1f, %r15d
leal (%r12,%r15), %esi
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl $0x2d, %edx
callq 0x1aa30
addq (%r13), %r15
movq %r15, %rdi
movl %r12d, %esi
movl %ebp, %edx
callq 0x58a27
leaq 0x9354e(%rip), %rsi # 0xebe2e
leaq 0x9c27d(%rip), %r9 # 0xf4b64
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq 0x10(%rsp), %rdx
movq %r13, %r8
callq 0x58947
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x58913
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a8d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x5893f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x1a8d0
movq %rbx, %rdi
callq 0x1afc0
| _ZN8nlohmann16json_abi_v3_11_36detail9exception4nameERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov r15d, edx
mov [rsp+68h+var_58], rsi
mov rbx, rdi
mov [rsp+68h+var_59], 2Eh ; '.'
mov ebp, edx
neg ebp
cmovs ebp, edx
mov r12d, 1
cmp ebp, 0Ah
jb short loc_588A5
mov r12d, 4
mov eax, 0D1B71759h
mov ecx, ebp
loc_58869:
cmp ecx, 63h ; 'c'
jbe short loc_5889C
cmp ecx, 3E7h
jbe short loc_588A2
cmp ecx, 2710h
jb short loc_588A5
mov edx, ecx
imul rdx, rax
shr rdx, 2Dh
add r12d, 4
cmp ecx, 1869Fh
mov ecx, edx
ja short loc_58869
add r12d, 0FFFFFFFDh
jmp short loc_588A5
loc_5889C:
add r12d, 0FFFFFFFEh
jmp short loc_588A5
loc_588A2:
dec r12d
loc_588A5:
shr r15d, 1Fh
lea esi, [r12+r15]
lea r14, [rsp+68h+var_40]
mov [r14-10h], r14
lea r13, [rsp+68h+var_50]
mov rdi, r13
mov edx, 2Dh ; '-'
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
add r15, [r13+0]
mov rdi, r15
mov esi, r12d
mov edx, ebp
call _ZNSt8__detail18__to_chars_10_implIjEEvPcjT_; std::__detail::__to_chars_10_impl<uint>(char *,uint,uint)
lea rsi, aJsonException; "[json.exception."
lea r9, a19+8; "] "
lea rcx, [rsp+68h+var_59]
mov rdi, rbx
mov rdx, [rsp+68h+var_58]
mov r8, r13
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA17_KcRKS8_cS8_RA3_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(char const(&)[17],std::string const&,char,std::string,char const(&)[3] &&)
mov rdi, [rsp+68h+var_50]; void *
cmp rdi, r14
jz short loc_58913
mov rsi, [rsp+68h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_58913:
mov rax, rbx
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, [rsp+arg_10]; void *
cmp rdi, r14
jz short loc_5893F
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5893F:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::exception::name(long long a1, long long a2, int a3)
{
unsigned int v3; // ebp
unsigned int v4; // r12d
unsigned int v5; // ecx
bool v6; // cc
unsigned int v7; // r15d
char v9; // [rsp+Fh] [rbp-59h] BYREF
long long v10; // [rsp+10h] [rbp-58h]
void *v11[2]; // [rsp+18h] [rbp-50h] BYREF
_QWORD v12[8]; // [rsp+28h] [rbp-40h] BYREF
v10 = a2;
v9 = 46;
v3 = -a3;
if ( a3 > 0 )
v3 = a3;
v4 = 1;
if ( v3 >= 0xA )
{
v4 = 4;
v5 = v3;
while ( 1 )
{
if ( v5 <= 0x63 )
{
v4 -= 2;
goto LABEL_12;
}
if ( v5 <= 0x3E7 )
break;
if ( v5 < 0x2710 )
goto LABEL_12;
v4 += 4;
v6 = v5 <= 0x1869F;
v5 /= 0x2710u;
if ( v6 )
{
v4 -= 3;
goto LABEL_12;
}
}
--v4;
}
LABEL_12:
v7 = (unsigned int)a3 >> 31;
v11[0] = v12;
std::string::_M_construct(v11, v4 + ((unsigned int)a3 >> 31), 45LL);
std::__detail::__to_chars_10_impl<unsigned int>((char *)v11[0] + v7, v4, v3);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[17],std::string const&,char,std::string,char const(&)[3]>(
a1,
(unsigned int)"[json.exception.",
v10,
(unsigned int)&v9,
(unsigned int)v11,
(unsigned int)"] ");
if ( v11[0] != v12 )
operator delete(v11[0], v12[0] + 1LL);
return a1;
}
| name:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV R15D,EDX
MOV qword ptr [RSP + 0x10],RSI
MOV RBX,RDI
MOV byte ptr [RSP + 0xf],0x2e
MOV EBP,EDX
NEG EBP
CMOVS EBP,EDX
MOV R12D,0x1
CMP EBP,0xa
JC 0x001588a5
MOV R12D,0x4
MOV EAX,0xd1b71759
MOV ECX,EBP
LAB_00158869:
CMP ECX,0x63
JBE 0x0015889c
CMP ECX,0x3e7
JBE 0x001588a2
CMP ECX,0x2710
JC 0x001588a5
MOV EDX,ECX
IMUL RDX,RAX
SHR RDX,0x2d
ADD R12D,0x4
CMP ECX,0x1869f
MOV ECX,EDX
JA 0x00158869
ADD R12D,-0x3
JMP 0x001588a5
LAB_0015889c:
ADD R12D,-0x2
JMP 0x001588a5
LAB_001588a2:
DEC R12D
LAB_001588a5:
SHR R15D,0x1f
LEA ESI,[R12 + R15*0x1]
LEA R14,[RSP + 0x28]
MOV qword ptr [R14 + -0x10],R14
LEA R13,[RSP + 0x18]
MOV RDI,R13
MOV EDX,0x2d
CALL 0x0011aa30
ADD R15,qword ptr [R13]
MOV RDI,R15
MOV ESI,R12D
MOV EDX,EBP
CALL 0x00158a27
LAB_001588d9:
LEA RSI,[0x1ebe2e]
LEA R9,[0x1f4b64]
LEA RCX,[RSP + 0xf]
MOV RDI,RBX
MOV RDX,qword ptr [RSP + 0x10]
MOV R8,R13
CALL 0x00158947
LAB_001588fc:
MOV RDI,qword ptr [RSP + 0x18]
CMP RDI,R14
JZ 0x00158913
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x0011a8d0
LAB_00158913:
MOV RAX,RBX
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::exception::name(std::__cxx11::string const&, int) */
exception * __thiscall
nlohmann::json_abi_v3_11_3::detail::exception::name(exception *this,string *param_1,int param_2)
{
uint uVar1;
uint uVar2;
ulong uVar3;
uint uVar4;
uint uVar5;
char local_59;
string *local_58;
long *local_50 [2];
long local_40 [2];
local_59 = '.';
uVar4 = -param_2;
if (0 < param_2) {
uVar4 = param_2;
}
uVar5 = 1;
if (9 < uVar4) {
uVar3 = (ulong)uVar4;
uVar1 = 4;
do {
uVar5 = uVar1;
uVar2 = (uint)uVar3;
if (uVar2 < 100) {
uVar5 = uVar5 - 2;
goto LAB_001588a5;
}
if (uVar2 < 1000) {
uVar5 = uVar5 - 1;
goto LAB_001588a5;
}
if (uVar2 < 10000) goto LAB_001588a5;
uVar3 = uVar3 / 10000;
uVar1 = uVar5 + 4;
} while (99999 < uVar2);
uVar5 = uVar5 + 1;
}
LAB_001588a5:
local_58 = param_1;
local_50[0] = local_40;
std::__cxx11::string::_M_construct((ulong)local_50,(char)uVar5 - (char)(param_2 >> 0x1f));
std::__detail::__to_chars_10_impl<unsigned_int>
((char *)((ulong)((uint)param_2 >> 0x1f) + (long)local_50[0]),uVar5,uVar4);
/* try { // try from 001588d9 to 001588fb has its CatchHandler @ 00158925 */
concat<std::__cxx11::string,char_const(&)[17],std::__cxx11::string_const&,char,std::__cxx11::string,char_const(&)[3]>
((detail *)this,"[json.exception.",local_58,&local_59,(string *)local_50,"] ");
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return this;
}
| |
22,212 | bf_clear_cache | bluesky950520[P]quickjs/libbf.c | void bf_clear_cache(bf_context_t *s)
{
#ifdef USE_FFT_MUL
fft_clear_cache(s);
#endif
bf_const_free(&s->log2_cache);
bf_const_free(&s->pi_cache);
} | O2 | c | bf_clear_cache:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %r14
testq %r14, %r14
je 0x7307f
movq %rbx, (%rsp)
leaq 0x20b0(%r14), %r15
xorl %r12d, %r12d
cmpq $0x5, %r12
je 0x7306b
movq %r15, %r13
xorl %ebp, %ebp
cmpq $0x2, %rbp
je 0x7305f
xorl %ebx, %ebx
cmpq $0x14, %rbx
je 0x73053
movq (%r13,%rbx,8), %rsi
testq %rsi, %rsi
je 0x7304e
movq (%r14), %rax
movq (%rax), %rdi
xorl %edx, %edx
callq *0x8(%rax)
andq $0x0, (%r13,%rbx,8)
incq %rbx
jmp 0x7302d
incq %rbp
addq $0xa0, %r13
jmp 0x73025
incq %r12
addq $0x140, %r15 # imm = 0x140
jmp 0x7301a
movq (%rsp), %rbx
movq (%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rbx)
andq $0x0, 0x70(%rbx)
leaq 0x10(%rbx), %rdi
callq 0x77ccf
addq $0x40, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x77ccf
| bf_clear_cache:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rdi
mov r14, [rdi+70h]
test r14, r14
jz short loc_7307F
mov [rsp+38h+var_38], rbx
lea r15, [r14+20B0h]
xor r12d, r12d
loc_7301A:
cmp r12, 5
jz short loc_7306B
mov r13, r15
xor ebp, ebp
loc_73025:
cmp rbp, 2
jz short loc_7305F
xor ebx, ebx
loc_7302D:
cmp rbx, 14h
jz short loc_73053
mov rsi, [r13+rbx*8+0]
test rsi, rsi
jz short loc_7304E
mov rax, [r14]
mov rdi, [rax]
xor edx, edx
call qword ptr [rax+8]
and qword ptr [r13+rbx*8+0], 0
loc_7304E:
inc rbx
jmp short loc_7302D
loc_73053:
inc rbp
add r13, 0A0h
jmp short loc_73025
loc_7305F:
inc r12
add r15, 140h
jmp short loc_7301A
loc_7306B:
mov rbx, [rsp+38h+var_38]
mov rdi, [rbx]
mov rsi, r14
xor edx, edx
call qword ptr [rbx+8]
and qword ptr [rbx+70h], 0
loc_7307F:
lea rdi, [rbx+10h]
call bf_const_free
add rbx, 40h ; '@'
mov rdi, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp bf_const_free
| long long bf_clear_cache(long long a1)
{
long long v1; // rbx
_QWORD **v2; // r14
_QWORD **v3; // r15
long long i; // r12
_QWORD **v5; // r13
long long j; // rbp
long long k; // rbx
_QWORD *v8; // rsi
v1 = a1;
v2 = *(_QWORD ***)(a1 + 112);
if ( v2 )
{
v3 = v2 + 1046;
for ( i = 0LL; i != 5; ++i )
{
v5 = v3;
for ( j = 0LL; j != 2; ++j )
{
for ( k = 0LL; k != 20; ++k )
{
v8 = v5[k];
if ( v8 )
{
((void ( *)(_QWORD, _QWORD *, _QWORD))(*v2)[1])(**v2, v8, 0LL);
v5[k] = 0LL;
}
}
v5 += 20;
}
v3 += 40;
}
v1 = a1;
(*(void ( **)(_QWORD, _QWORD **, _QWORD))(a1 + 8))(*(_QWORD *)a1, v2, 0LL);
*(_QWORD *)(a1 + 112) = 0LL;
}
bf_const_free(v1 + 16);
return bf_const_free(v1 + 64);
}
| bf_clear_cache:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R14,qword ptr [RDI + 0x70]
TEST R14,R14
JZ 0x0017307f
MOV qword ptr [RSP],RBX
LEA R15,[R14 + 0x20b0]
XOR R12D,R12D
LAB_0017301a:
CMP R12,0x5
JZ 0x0017306b
MOV R13,R15
XOR EBP,EBP
LAB_00173025:
CMP RBP,0x2
JZ 0x0017305f
XOR EBX,EBX
LAB_0017302d:
CMP RBX,0x14
JZ 0x00173053
MOV RSI,qword ptr [R13 + RBX*0x8]
TEST RSI,RSI
JZ 0x0017304e
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RAX]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
AND qword ptr [R13 + RBX*0x8],0x0
LAB_0017304e:
INC RBX
JMP 0x0017302d
LAB_00173053:
INC RBP
ADD R13,0xa0
JMP 0x00173025
LAB_0017305f:
INC R12
ADD R15,0x140
JMP 0x0017301a
LAB_0017306b:
MOV RBX,qword ptr [RSP]
MOV RDI,qword ptr [RBX]
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RBX + 0x8]
AND qword ptr [RBX + 0x70],0x0
LAB_0017307f:
LEA RDI,[RBX + 0x10]
CALL 0x00177ccf
ADD RBX,0x40
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00177ccf
|
void bf_clear_cache(int8 *param_1)
{
long *plVar1;
long lVar2;
long lVar3;
long lVar4;
long *plVar5;
long *plVar6;
plVar1 = (long *)param_1[0xe];
if (plVar1 != (long *)0x0) {
plVar6 = plVar1 + 0x416;
for (lVar4 = 0; lVar4 != 5; lVar4 = lVar4 + 1) {
plVar5 = plVar6;
for (lVar3 = 0; lVar3 != 2; lVar3 = lVar3 + 1) {
for (lVar2 = 0; lVar2 != 0x14; lVar2 = lVar2 + 1) {
if (plVar5[lVar2] != 0) {
(*(code *)((int8 *)*plVar1)[1])(*(int8 *)*plVar1,plVar5[lVar2],0);
plVar5[lVar2] = 0;
}
}
plVar5 = plVar5 + 0x14;
}
plVar6 = plVar6 + 0x28;
}
(*(code *)param_1[1])(*param_1,plVar1,0);
param_1[0xe] = 0;
}
bf_const_free(param_1 + 2);
bf_const_free(param_1 + 8);
return;
}
| |
22,213 | nglog::LogMessage::LogStream::~LogStream() | ng-log[P]ng-log/src/ng-log/logging.h | class NGLOG_EXPORT LogStream : public std::ostream {
NGLOG_MSVC_POP_WARNING()
public:
// In some cases, like when compiling glog as a static library with GCC and
// linking against a Clang-built executable, this constructor will be
// removed by the linker. We use this attribute to prevent the linker from
// discarding it.
NGLOG_USED
LogStream(char* buf, int len, int64 ctr)
: std::ostream(nullptr), streambuf_(buf, len), ctr_(ctr), self_(this) {
rdbuf(&streambuf_);
}
LogStream(LogStream&& other) noexcept
: std::ostream(nullptr),
streambuf_(std::move(other.streambuf_)),
ctr_(std::exchange(other.ctr_, 0)),
self_(this) {
rdbuf(&streambuf_);
}
LogStream& operator=(LogStream&& other) noexcept {
streambuf_ = std::move(other.streambuf_);
ctr_ = std::exchange(other.ctr_, 0);
rdbuf(&streambuf_);
return *this;
}
int64 ctr() const { return ctr_; }
void set_ctr(int64 ctr) { ctr_ = ctr; }
LogStream* self() const { return self_; }
// Legacy std::streambuf methods.
size_t pcount() const { return streambuf_.pcount(); }
char* pbase() const { return streambuf_.pbase(); }
char* str() const { return pbase(); }
LogStream(const LogStream&) = delete;
LogStream& operator=(const LogStream&) = delete;
private:
base_logging::LogStreamBuf streambuf_;
int64 ctr_; // Counter hack (for the LOG_EVERY_X() macro)
LogStream* self_; // Consistency check hack
} | O1 | c | nglog::LogMessage::LogStream::~LogStream():
pushq %rbx
leaq 0x24fe6(%rip), %rax # 0x2e3d8
movq %rax, (%rdi)
leaq 0x58(%rdi), %rbx
leaq 0x25000(%rip), %rax # 0x2e400
movq %rax, 0x58(%rdi)
movq 0x25b3d(%rip), %rax # 0x2ef48
addq $0x10, %rax
movq %rax, 0x8(%rdi)
addq $0x40, %rdi
callq 0x7790
movq %rbx, %rdi
popq %rbx
jmp 0x7170
nop
| _ZN5nglog10LogMessage9LogStreamD1Ev:
push rbx
lea rax, off_2E3D8
mov [rdi], rax
lea rbx, [rdi+58h]
lea rax, off_2E400
mov [rdi+58h], rax
mov rax, cs:_ZTVSt15basic_streambufIcSt11char_traitsIcEE_ptr
add rax, 10h
mov [rdi+8], rax
add rdi, 40h ; '@'; this
call __ZNSt6localeD1Ev; std::locale::~locale()
mov rdi, rbx; this
pop rbx
jmp __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
| void nglog::LogMessage::LogStream::~LogStream(nglog::LogMessage::LogStream *this)
{
*(_QWORD *)this = off_2E3D8;
*((_QWORD *)this + 11) = off_2E400;
*((_QWORD *)this + 1) = (char *)&`vtable for'std::streambuf + 16;
std::locale::~locale((nglog::LogMessage::LogStream *)((char *)this + 64));
std::ios_base::~ios_base((nglog::LogMessage::LogStream *)((char *)this + 88));
}
| ~LogStream:
PUSH RBX
LEA RAX,[0x12e3d8]
MOV qword ptr [RDI],RAX
LEA RBX,[RDI + 0x58]
LEA RAX,[0x12e400]
MOV qword ptr [RDI + 0x58],RAX
MOV RAX,qword ptr [0x0012ef48]
ADD RAX,0x10
MOV qword ptr [RDI + 0x8],RAX
ADD RDI,0x40
CALL 0x00107790
MOV RDI,RBX
POP RBX
JMP 0x00107170
|
/* nglog::LogMessage::LogStream::~LogStream() */
void __thiscall nglog::LogMessage::LogStream::~LogStream(LogStream *this)
{
*(int ***)this = &PTR__LogStream_0012e3d8;
*(int ***)(this + 0x58) = &PTR__LogStream_0012e400;
*(int **)(this + 8) = PTR_vtable_0012ef48 + 0x10;
std::locale::~locale((locale *)(this + 0x40));
std::ios_base::~ios_base((ios_base *)(this + 0x58));
return;
}
| |
22,214 | item_registry::construct(char const*) | untodesu[P]voxelius/game/shared/item_registry.cc | ItemInfoBuilder &item_registry::construct(const char *name)
{
const auto it = item_registry::builders.find(name);
if(it != item_registry::builders.cend())
return it->second;
return item_registry::builders.emplace(name, ItemInfoBuilder(name)).first->second;
} | O3 | cpp | item_registry::construct(char const*):
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq %rdi, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x2f9b0
leaq 0x1e195a(%rip), %rdi # 0x25c8b8
leaq 0x18(%rsp), %rsi
callq 0x7ba94
movq %rax, %r14
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7af86
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x268e0
testq %r14, %r14
jne 0x7afbc
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7ac68
leaq 0x1e1916(%rip), %rdi # 0x25c8b8
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x7bb96
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x7b222
addq $0x28, %r14
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7b222
jmp 0x7affd
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7affd
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x268e0
jmp 0x7affd
movq %rax, %rbx
movq %rbx, %rdi
callq 0x26ff0
| _ZN13item_registry9constructEPKc:
push r14
push rbx
sub rsp, 78h
mov rbx, rdi
mov [rsp+88h+var_78], rdi
lea rdi, [rsp+88h+var_70]
lea rdx, [rsp+88h+var_79]
mov rsi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, _ZN13item_registry8buildersB5cxx11E; item_registry::builders
lea rsi, [rsp+88h+var_70]
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_15ItemInfoBuilderESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE4findERS7_; std::_Hashtable<std::string,std::pair<std::string const,ItemInfoBuilder>,std::allocator<std::pair<std::string const,ItemInfoBuilder>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(std::string const&)
mov r14, rax
lea rax, [rsp+88h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7AF86
mov rsi, [rsp+88h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7AF86:
test r14, r14
jnz short loc_7AFBC
lea r14, [rsp+88h+var_70]
mov rdi, r14; this
mov rsi, rbx; char *
call _ZN15ItemInfoBuilderC2EPKc; ItemInfoBuilder::ItemInfoBuilder(char const*)
lea rdi, _ZN13item_registry8buildersB5cxx11E; item_registry::builders
lea rsi, [rsp+88h+var_78]
mov rdx, r14
call _ZNSt10_HashtableINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS5_15ItemInfoBuilderESaIS9_ENSt8__detail10_Select1stESt8equal_toIS5_ESt4hashIS5_ENSB_18_Mod_range_hashingENSB_20_Default_ranged_hashENSB_20_Prime_rehash_policyENSB_17_Hashtable_traitsILb1ELb0ELb1EEEE10_M_emplaceIJRPKcS8_EEES6_INSB_14_Node_iteratorIS9_Lb0ELb1EEEbESt17integral_constantIbLb1EEDpOT_; std::_Hashtable<std::string,std::pair<std::string const,ItemInfoBuilder>,std::allocator<std::pair<std::string const,ItemInfoBuilder>>,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>>::_M_emplace<char const*&,ItemInfoBuilder>(std::integral_constant<bool,true>,char const*&,ItemInfoBuilder &&)
mov r14, rax
lea rdi, [rsp+88h+var_70]; this
call _ZN15ItemInfoBuilderD2Ev; ItemInfoBuilder::~ItemInfoBuilder()
loc_7AFBC:
add r14, 28h ; '('
mov rax, r14
add rsp, 78h
pop rbx
pop r14
retn
mov rbx, rax
lea rdi, [rsp+arg_10]; this
call _ZN15ItemInfoBuilderD2Ev; ItemInfoBuilder::~ItemInfoBuilder()
jmp short loc_7AFFD
mov rbx, rax
lea rax, [rsp+arg_20]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_7AFFD
mov rsi, [rsp+arg_20]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_7AFFD
mov rbx, rax
loc_7AFFD:
mov rdi, rbx
call __Unwind_Resume
| long long item_registry::construct(item_registry *this, const char *a2)
{
long long v2; // r14
item_registry *v4; // [rsp+10h] [rbp-78h] BYREF
void *v5[2]; // [rsp+18h] [rbp-70h] BYREF
long long v6; // [rsp+28h] [rbp-60h] BYREF
v4 = this;
std::string::basic_string<std::allocator<char>>(v5, (long long)this);
v2 = std::_Hashtable<std::string,std::pair<std::string const,ItemInfoBuilder>,std::allocator<std::pair<std::string const,ItemInfoBuilder>>,std::__detail::_Select1st,std::equal_to<std::string>,std::hash<std::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>::find(
&item_registry::builders[abi:cxx11],
v5);
if ( v5[0] != &v6 )
operator delete(v5[0], v6 + 1);
if ( !v2 )
{
ItemInfoBuilder::ItemInfoBuilder((ItemInfoBuilder *)v5, (const char *)this);
v2 = std::_Hashtable<std::string,std::pair<std::string const,ItemInfoBuilder>,std::allocator<std::pair<std::string const,ItemInfoBuilder>>,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>>::_M_emplace<char const*&,ItemInfoBuilder>(
&item_registry::builders[abi:cxx11],
&v4,
v5);
ItemInfoBuilder::~ItemInfoBuilder((ItemInfoBuilder *)v5);
}
return v2 + 40;
}
| construct:
PUSH R14
PUSH RBX
SUB RSP,0x78
MOV RBX,RDI
MOV qword ptr [RSP + 0x10],RDI
LAB_0017af45:
LEA RDI,[RSP + 0x18]
LEA RDX,[RSP + 0xf]
MOV RSI,RBX
CALL 0x0012f9b0
LAB_0017af57:
LEA RDI,[0x35c8b8]
LEA RSI,[RSP + 0x18]
CALL 0x0017ba94
LAB_0017af68:
MOV R14,RAX
LEA RAX,[RSP + 0x28]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x0017af86
MOV RSI,qword ptr [RSP + 0x28]
INC RSI
CALL 0x001268e0
LAB_0017af86:
TEST R14,R14
JNZ 0x0017afbc
LEA R14,[RSP + 0x18]
MOV RDI,R14
MOV RSI,RBX
CALL 0x0017ac68
LAB_0017af9b:
LEA RDI,[0x35c8b8]
LEA RSI,[RSP + 0x10]
MOV RDX,R14
CALL 0x0017bb96
LAB_0017afaf:
MOV R14,RAX
LEA RDI,[RSP + 0x18]
CALL 0x0017b222
LAB_0017afbc:
ADD R14,0x28
MOV RAX,R14
ADD RSP,0x78
POP RBX
POP R14
RET
|
/* item_registry::construct(char const*) */
long item_registry::construct(char *param_1)
{
long lVar1;
allocator local_79;
char *local_78;
long *local_70 [2];
long local_60 [10];
/* try { // try from 0017af45 to 0017af56 has its CatchHandler @ 0017affa */
local_78 = param_1;
std::__cxx11::string::string<std::allocator<char>>((string *)local_70,param_1,&local_79);
/* try { // try from 0017af57 to 0017af67 has its CatchHandler @ 0017afda */
lVar1 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,ItemInfoBuilder>,std::allocator<std::pair<std::__cxx11::string_const,ItemInfoBuilder>>,std::__detail::_Select1st,std::equal_to<std::__cxx11::string>,std::hash<std::__cxx11::string>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<true,false,true>>
::find((_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,ItemInfoBuilder>,std::allocator<std::pair<std::__cxx11::string_const,ItemInfoBuilder>>,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>>
*)builders_abi_cxx11_,(string *)local_70);
if (local_70[0] != local_60) {
operator_delete(local_70[0],local_60[0] + 1);
}
if (lVar1 == 0) {
ItemInfoBuilder::ItemInfoBuilder((ItemInfoBuilder *)local_70,param_1);
/* try { // try from 0017af9b to 0017afae has its CatchHandler @ 0017afcb */
lVar1 = std::
_Hashtable<std::__cxx11::string,std::pair<std::__cxx11::string_const,ItemInfoBuilder>,std::allocator<std::pair<std::__cxx11::string_const,ItemInfoBuilder>>,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>>
::_M_emplace<char_const*&,ItemInfoBuilder>
(builders_abi_cxx11_,&local_78,(ItemInfoBuilder *)local_70);
ItemInfoBuilder::~ItemInfoBuilder((ItemInfoBuilder *)local_70);
}
return lVar1 + 0x28;
}
| |
22,215 | create_tailoring | eloqsql/strings/ctype-uca.c | static my_bool
create_tailoring(struct charset_info_st *cs,
MY_CHARSET_LOADER *loader)
{
MY_COLL_RULES rules;
MY_UCA_INFO new_uca, *src_uca= NULL;
int rc= 0;
uint i;
*loader->error= '\0';
if (!cs->tailoring)
return 0; /* Ok to add a collation without tailoring */
memset(&rules, 0, sizeof(rules));
rules.loader= loader;
rules.uca= cs->uca ? cs->uca : &my_uca_v400; /* For logical positions, etc */
memset(&new_uca, 0, sizeof(new_uca));
/* Parse ICU Collation Customization expression */
if ((rc= my_coll_rule_parse(&rules,
cs->tailoring,
cs->tailoring + strlen(cs->tailoring))))
goto ex;
if (rules.version == 520) /* Unicode-5.2.0 requested */
{
src_uca= &my_uca_v520;
cs->caseinfo= &my_unicase_unicode520;
}
else if (rules.version == 400) /* Unicode-4.0.0 requested */
{
src_uca= &my_uca_v400;
cs->caseinfo= &my_unicase_default;
}
else /* No Unicode version specified */
{
src_uca= cs->uca ? cs->uca : &my_uca_v400;
if (!cs->caseinfo)
cs->caseinfo= &my_unicase_default;
}
cs->levels_for_order= rules.strength ? rules.strength : 1;
for (i= 0; i != cs->levels_for_order; i++)
{
if ((rc= (src_uca->level[i].maxchar == 0)))
{
my_snprintf(loader->error, sizeof(loader->error) - 1,
"%s: no level #%d data for this Unicode version.",
cs->coll_name.str, i + 1);
goto ex;
}
if ((rc= init_weight_level(loader, &rules,
&new_uca.level[i], &src_uca->level[i])))
goto ex;
}
if (!(cs->uca= (MY_UCA_INFO *) (loader->once_alloc)(sizeof(MY_UCA_INFO))))
{
rc= 1;
goto ex;
}
cs->uca[0]= new_uca;
if (cs->levels_for_order > 1)
cs->coll= (cs->state & MY_CS_NOPAD) ?
&my_uca_collation_handler_nopad_multilevel_generic :
&my_uca_collation_handler_multilevel_generic;
ex:
(loader->free)(rules.rule);
if (rc != 0 && loader->error[0])
loader->reporter(ERROR_LEVEL, "%s", loader->error);
return rc;
} | O0 | c | create_tailoring:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x128(%rbp)
movl $0x0, -0x12c(%rbp)
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x9f563
movb $0x0, -0x1(%rbp)
jmp 0x9f8a0
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x362e0
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x9f597
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x138(%rbp)
jmp 0x9f5a7
leaq 0x280c12(%rip), %rax # 0x3201b0
movq %rax, -0x138(%rbp)
jmp 0x9f5a7
movq -0x138(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0xd0, %edx
callq 0x362e0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x36400
movq -0x148(%rbp), %rdx
movq -0x140(%rbp), %rsi
addq %rax, %rdx
leaq -0x50(%rbp), %rdi
callq 0x9f8b0
movl %eax, -0x12c(%rbp)
cmpl $0x0, %eax
je 0x9f61a
jmp 0x9f855
cmpl $0x208, -0x50(%rbp) # imm = 0x208
jne 0x9f645
leaq 0x285cee(%rip), %rax # 0x325318
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1913c4(%rip), %rcx # 0x230a00
movq %rcx, 0x78(%rax)
jmp 0x9f6c5
cmpl $0x190, -0x50(%rbp) # imm = 0x190
jne 0x9f66d
leaq 0x280b5b(%rip), %rax # 0x3201b0
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
leaq 0x191369(%rip), %rcx # 0x2309d0
movq %rcx, 0x78(%rax)
jmp 0x9f6c3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x9f689
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x150(%rbp)
jmp 0x9f699
leaq 0x280b20(%rip), %rax # 0x3201b0
movq %rax, -0x150(%rbp)
jmp 0x9f699
movq -0x150(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x9f6c1
movq -0x10(%rbp), %rax
leaq 0x191313(%rip), %rcx # 0x2309d0
movq %rcx, 0x78(%rax)
jmp 0x9f6c3
jmp 0x9f6c5
cmpl $0x0, -0x4c(%rbp)
je 0x9f6d6
movl -0x4c(%rbp), %eax
movl %eax, -0x154(%rbp)
jmp 0x9f6e3
movl $0x1, %eax
movl %eax, -0x154(%rbp)
jmp 0x9f6e3
movl -0x154(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xb2(%rax)
movl $0x0, -0x130(%rbp)
movl -0x130(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0xb2(%rcx), %ecx
cmpl %ecx, %eax
je 0x9f7d4
movq -0x128(%rbp), %rax
movl -0x130(%rbp), %ecx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
sete %al
movb %al, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movl %ecx, -0x12c(%rbp)
testb $0x1, %al
jne 0x9f747
jmp 0x9f776
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movl -0x130(%rbp), %r8d
addl $0x1, %r8d
movl $0x7f, %esi
leaq 0x32829(%rip), %rdx # 0xd1f93
movb $0x0, %al
callq 0xc7b80
jmp 0x9f855
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rdx
movl -0x130(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rdx
movq -0x128(%rbp), %rcx
movl -0x130(%rbp), %eax
imulq $0x38, %rax, %rax
addq %rax, %rcx
leaq -0x50(%rbp), %rsi
callq 0x9f990
movsbl %al, %eax
movl %eax, -0x12c(%rbp)
cmpl $0x0, %eax
je 0x9f7be
jmp 0x9f855
jmp 0x9f7c0
movl -0x130(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x130(%rbp)
jmp 0x9f6ff
movq -0x18(%rbp), %rax
movl $0xd0, %edi
callq *0x80(%rax)
movq -0x10(%rbp), %rcx
movq %rax, 0x60(%rcx)
cmpq $0x0, %rax
jne 0x9f7fd
movl $0x1, -0x12c(%rbp)
jmp 0x9f855
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
leaq -0x120(%rbp), %rsi
movl $0xd0, %edx
callq 0x360b0
movq -0x10(%rbp), %rax
movzbl 0xb2(%rax), %eax
cmpl $0x1, %eax
jle 0x9f853
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
andl $0x20000, %edx # imm = 0x20000
leaq 0x18e716(%rip), %rcx # 0x22df50
leaq 0x18e77f(%rip), %rax # 0x22dfc0
cmpl $0x0, %edx
cmovneq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xc0(%rax)
jmp 0x9f855
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x30(%rbp), %rdi
callq *%rax
cmpl $0x0, -0x12c(%rbp)
je 0x9f897
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9f897
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rcx
movq -0x18(%rbp), %rdx
xorl %edi, %edi
leaq 0x32ab9(%rip), %rsi # 0xd234c
movb $0x0, %al
callq *%rcx
movl -0x12c(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x160, %rsp # imm = 0x160
popq %rbp
retq
nopl (%rax)
| create_tailoring:
push rbp
mov rbp, rsp
sub rsp, 160h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_128], 0
mov [rbp+var_12C], 0
mov rax, [rbp+var_18]
mov byte ptr [rax], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+38h], 0
jnz short loc_9F563
mov [rbp+var_1], 0
jmp loc_9F8A0
loc_9F563:
lea rdi, [rbp+var_50]
xor esi, esi
mov edx, 38h ; '8'
call _memset
mov rax, [rbp+var_18]
mov [rbp+var_28], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+60h], 0
jz short loc_9F597
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov [rbp+var_138], rax
jmp short loc_9F5A7
loc_9F597:
lea rax, my_uca_v400
mov [rbp+var_138], rax
jmp short $+2
loc_9F5A7:
mov rax, [rbp+var_138]
mov [rbp+var_48], rax
lea rdi, [rbp+var_120]
xor esi, esi
mov edx, 0D0h
call _memset
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_140], rax
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_148], rax
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
call _strlen
mov rdx, [rbp+var_148]
mov rsi, [rbp+var_140]
add rdx, rax
lea rdi, [rbp+var_50]
call my_coll_rule_parse
mov [rbp+var_12C], eax
cmp eax, 0
jz short loc_9F61A
jmp loc_9F855
loc_9F61A:
cmp [rbp+var_50], 208h
jnz short loc_9F645
lea rax, my_uca_v520
mov [rbp+var_128], rax
mov rax, [rbp+var_10]
lea rcx, my_unicase_unicode520
mov [rax+78h], rcx
jmp loc_9F6C5
loc_9F645:
cmp [rbp+var_50], 190h
jnz short loc_9F66D
lea rax, my_uca_v400
mov [rbp+var_128], rax
mov rax, [rbp+var_10]
lea rcx, my_unicase_default
mov [rax+78h], rcx
jmp short loc_9F6C3
loc_9F66D:
mov rax, [rbp+var_10]
cmp qword ptr [rax+60h], 0
jz short loc_9F689
mov rax, [rbp+var_10]
mov rax, [rax+60h]
mov [rbp+var_150], rax
jmp short loc_9F699
loc_9F689:
lea rax, my_uca_v400
mov [rbp+var_150], rax
jmp short $+2
loc_9F699:
mov rax, [rbp+var_150]
mov [rbp+var_128], rax
mov rax, [rbp+var_10]
cmp qword ptr [rax+78h], 0
jnz short loc_9F6C1
mov rax, [rbp+var_10]
lea rcx, my_unicase_default
mov [rax+78h], rcx
loc_9F6C1:
jmp short $+2
loc_9F6C3:
jmp short $+2
loc_9F6C5:
cmp [rbp+var_4C], 0
jz short loc_9F6D6
mov eax, [rbp+var_4C]
mov [rbp+var_154], eax
jmp short loc_9F6E3
loc_9F6D6:
mov eax, 1
mov [rbp+var_154], eax
jmp short $+2
loc_9F6E3:
mov eax, [rbp+var_154]
mov cl, al
mov rax, [rbp+var_10]
mov [rax+0B2h], cl
mov [rbp+var_130], 0
loc_9F6FF:
mov eax, [rbp+var_130]
mov rcx, [rbp+var_10]
movzx ecx, byte ptr [rcx+0B2h]
cmp eax, ecx
jz loc_9F7D4
mov rax, [rbp+var_128]
mov ecx, [rbp+var_130]
imul rcx, 38h ; '8'
add rax, rcx
cmp qword ptr [rax], 0
setz al
mov cl, al
and cl, 1
movzx ecx, cl
mov [rbp+var_12C], ecx
test al, 1
jnz short loc_9F747
jmp short loc_9F776
loc_9F747:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov rcx, [rax+20h]
mov r8d, [rbp+var_130]
add r8d, 1
mov esi, 7Fh
lea rdx, aSNoLevelDDataF; "%s: no level #%d data for this Unicode "...
mov al, 0
call my_snprintf
jmp loc_9F855
loc_9F776:
mov rdi, [rbp+var_18]
lea rdx, [rbp+var_120]
mov eax, [rbp+var_130]
imul rax, 38h ; '8'
add rdx, rax
mov rcx, [rbp+var_128]
mov eax, [rbp+var_130]
imul rax, 38h ; '8'
add rcx, rax
lea rsi, [rbp+var_50]
call init_weight_level
movsx eax, al
mov [rbp+var_12C], eax
cmp eax, 0
jz short loc_9F7BE
jmp loc_9F855
loc_9F7BE:
jmp short $+2
loc_9F7C0:
mov eax, [rbp+var_130]
add eax, 1
mov [rbp+var_130], eax
jmp loc_9F6FF
loc_9F7D4:
mov rax, [rbp+var_18]
mov edi, 0D0h
call qword ptr [rax+80h]
mov rcx, [rbp+var_10]
mov [rcx+60h], rax
cmp rax, 0
jnz short loc_9F7FD
mov [rbp+var_12C], 1
jmp short loc_9F855
loc_9F7FD:
mov rax, [rbp+var_10]
mov rdi, [rax+60h]
lea rsi, [rbp+var_120]
mov edx, 0D0h
call _memcpy
mov rax, [rbp+var_10]
movzx eax, byte ptr [rax+0B2h]
cmp eax, 1
jle short loc_9F853
mov rax, [rbp+var_10]
mov edx, [rax+0Ch]
and edx, 20000h
lea rcx, my_uca_collation_handler_multilevel_generic
lea rax, my_uca_collation_handler_nopad_multilevel_generic
cmp edx, 0
cmovnz rcx, rax
mov rax, [rbp+var_10]
mov [rax+0C0h], rcx
loc_9F853:
jmp short $+2
loc_9F855:
mov rax, [rbp+var_18]
mov rax, [rax+98h]
mov rdi, [rbp+var_30]
call rax
cmp [rbp+var_12C], 0
jz short loc_9F897
mov rax, [rbp+var_18]
movsx eax, byte ptr [rax]
cmp eax, 0
jz short loc_9F897
mov rax, [rbp+var_18]
mov rcx, [rax+0A0h]
mov rdx, [rbp+var_18]
xor edi, edi
lea rsi, aAtLineDPosDS+13h; "%s"
mov al, 0
call rcx
loc_9F897:
mov eax, [rbp+var_12C]
mov [rbp+var_1], al
loc_9F8A0:
mov al, [rbp+var_1]
add rsp, 160h
pop rbp
retn
| char create_tailoring(long long a1, const char *a2)
{
long long v2; // rax
int v3; // r9d
char inited; // al
long long v5; // rax
long long ( **v6)(); // rcx
char v8; // [rsp+Ch] [rbp-154h]
_UNKNOWN **v9; // [rsp+10h] [rbp-150h]
long long v10; // [rsp+20h] [rbp-140h]
void *v11; // [rsp+28h] [rbp-138h]
unsigned int i; // [rsp+30h] [rbp-130h]
int v13; // [rsp+34h] [rbp-12Ch]
_UNKNOWN **v14; // [rsp+38h] [rbp-128h]
_QWORD v15[26]; // [rsp+40h] [rbp-120h] BYREF
int v16; // [rsp+110h] [rbp-50h] BYREF
int v17; // [rsp+114h] [rbp-4Ch]
void *v18; // [rsp+118h] [rbp-48h]
long long v19; // [rsp+130h] [rbp-30h]
const char *v20; // [rsp+138h] [rbp-28h]
const char *v21; // [rsp+148h] [rbp-18h]
long long v22; // [rsp+150h] [rbp-10h]
v22 = a1;
v21 = a2;
*a2 = 0;
if ( !*(_QWORD *)(v22 + 56) )
return 0;
memset(&v16, 0LL, 56LL);
v20 = v21;
if ( *(_QWORD *)(v22 + 96) )
v11 = *(void **)(v22 + 96);
else
v11 = &my_uca_v400;
v18 = v11;
memset(v15, 0LL, sizeof(v15));
v10 = *(_QWORD *)(v22 + 56);
v2 = strlen(v10);
v13 = my_coll_rule_parse(&v16, v10, v2 + v10);
if ( !v13 )
{
if ( v16 == 520 )
{
v14 = &my_uca_v520;
*(_QWORD *)(v22 + 120) = &my_unicase_unicode520;
}
else if ( v16 == 400 )
{
v14 = (_UNKNOWN **)&my_uca_v400;
*(_QWORD *)(v22 + 120) = &my_unicase_default;
}
else
{
if ( *(_QWORD *)(v22 + 96) )
v9 = *(_UNKNOWN ***)(v22 + 96);
else
v9 = (_UNKNOWN **)&my_uca_v400;
v14 = v9;
if ( !*(_QWORD *)(v22 + 120) )
*(_QWORD *)(v22 + 120) = &my_unicase_default;
}
if ( v17 )
v8 = v17;
else
v8 = 1;
*(_BYTE *)(v22 + 178) = v8;
for ( i = 0; i != *(unsigned __int8 *)(v22 + 178); ++i )
{
v13 = v14[7 * i] == 0LL;
if ( !v14[7 * i] )
{
my_snprintf(
(_DWORD)v21,
127,
(unsigned int)"%s: no level #%d data for this Unicode version.",
*(_QWORD *)(v22 + 32),
i + 1,
v3);
goto LABEL_31;
}
inited = init_weight_level(v21, &v16, &v15[7 * i], &v14[7 * i]);
v13 = inited;
if ( inited )
goto LABEL_31;
}
v5 = (*((long long ( **)(long long))v21 + 16))(208LL);
*(_QWORD *)(v22 + 96) = v5;
if ( v5 )
{
memcpy(*(_QWORD *)(v22 + 96), v15, 208LL);
if ( *(unsigned __int8 *)(v22 + 178) > 1u )
{
v6 = my_uca_collation_handler_multilevel_generic;
if ( (*(_DWORD *)(v22 + 12) & 0x20000) != 0 )
v6 = my_uca_collation_handler_nopad_multilevel_generic;
*(_QWORD *)(v22 + 192) = v6;
}
}
else
{
v13 = 1;
}
}
LABEL_31:
(*((void ( **)(long long))v21 + 19))(v19);
if ( v13 && *v21 )
(*((void (**)(_QWORD, const char *, ...))v21 + 20))(0LL, "%s", v21);
return v13;
}
| create_tailoring:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x160
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x128],0x0
MOV dword ptr [RBP + -0x12c],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x38],0x0
JNZ 0x0019f563
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0019f8a0
LAB_0019f563:
LEA RDI,[RBP + -0x50]
XOR ESI,ESI
MOV EDX,0x38
CALL 0x001362e0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0019f597
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x138],RAX
JMP 0x0019f5a7
LAB_0019f597:
LEA RAX,[0x4201b0]
MOV qword ptr [RBP + -0x138],RAX
JMP 0x0019f5a7
LAB_0019f5a7:
MOV RAX,qword ptr [RBP + -0x138]
MOV qword ptr [RBP + -0x48],RAX
LEA RDI,[RBP + -0x120]
XOR ESI,ESI
MOV EDX,0xd0
CALL 0x001362e0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x140],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x148],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
CALL 0x00136400
MOV RDX,qword ptr [RBP + -0x148]
MOV RSI,qword ptr [RBP + -0x140]
ADD RDX,RAX
LEA RDI,[RBP + -0x50]
CALL 0x0019f8b0
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x0
JZ 0x0019f61a
JMP 0x0019f855
LAB_0019f61a:
CMP dword ptr [RBP + -0x50],0x208
JNZ 0x0019f645
LEA RAX,[0x425318]
MOV qword ptr [RBP + -0x128],RAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x330a00]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x0019f6c5
LAB_0019f645:
CMP dword ptr [RBP + -0x50],0x190
JNZ 0x0019f66d
LEA RAX,[0x4201b0]
MOV qword ptr [RBP + -0x128],RAX
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3309d0]
MOV qword ptr [RAX + 0x78],RCX
JMP 0x0019f6c3
LAB_0019f66d:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x60],0x0
JZ 0x0019f689
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x60]
MOV qword ptr [RBP + -0x150],RAX
JMP 0x0019f699
LAB_0019f689:
LEA RAX,[0x4201b0]
MOV qword ptr [RBP + -0x150],RAX
JMP 0x0019f699
LAB_0019f699:
MOV RAX,qword ptr [RBP + -0x150]
MOV qword ptr [RBP + -0x128],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x78],0x0
JNZ 0x0019f6c1
MOV RAX,qword ptr [RBP + -0x10]
LEA RCX,[0x3309d0]
MOV qword ptr [RAX + 0x78],RCX
LAB_0019f6c1:
JMP 0x0019f6c3
LAB_0019f6c3:
JMP 0x0019f6c5
LAB_0019f6c5:
CMP dword ptr [RBP + -0x4c],0x0
JZ 0x0019f6d6
MOV EAX,dword ptr [RBP + -0x4c]
MOV dword ptr [RBP + -0x154],EAX
JMP 0x0019f6e3
LAB_0019f6d6:
MOV EAX,0x1
MOV dword ptr [RBP + -0x154],EAX
JMP 0x0019f6e3
LAB_0019f6e3:
MOV EAX,dword ptr [RBP + -0x154]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xb2],CL
MOV dword ptr [RBP + -0x130],0x0
LAB_0019f6ff:
MOV EAX,dword ptr [RBP + -0x130]
MOV RCX,qword ptr [RBP + -0x10]
MOVZX ECX,byte ptr [RCX + 0xb2]
CMP EAX,ECX
JZ 0x0019f7d4
MOV RAX,qword ptr [RBP + -0x128]
MOV ECX,dword ptr [RBP + -0x130]
IMUL RCX,RCX,0x38
ADD RAX,RCX
CMP qword ptr [RAX],0x0
SETZ AL
MOV CL,AL
AND CL,0x1
MOVZX ECX,CL
MOV dword ptr [RBP + -0x12c],ECX
TEST AL,0x1
JNZ 0x0019f747
JMP 0x0019f776
LAB_0019f747:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x20]
MOV R8D,dword ptr [RBP + -0x130]
ADD R8D,0x1
MOV ESI,0x7f
LEA RDX,[0x1d1f93]
MOV AL,0x0
CALL 0x001c7b80
JMP 0x0019f855
LAB_0019f776:
MOV RDI,qword ptr [RBP + -0x18]
LEA RDX,[RBP + -0x120]
MOV EAX,dword ptr [RBP + -0x130]
IMUL RAX,RAX,0x38
ADD RDX,RAX
MOV RCX,qword ptr [RBP + -0x128]
MOV EAX,dword ptr [RBP + -0x130]
IMUL RAX,RAX,0x38
ADD RCX,RAX
LEA RSI,[RBP + -0x50]
CALL 0x0019f990
MOVSX EAX,AL
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x0
JZ 0x0019f7be
JMP 0x0019f855
LAB_0019f7be:
JMP 0x0019f7c0
LAB_0019f7c0:
MOV EAX,dword ptr [RBP + -0x130]
ADD EAX,0x1
MOV dword ptr [RBP + -0x130],EAX
JMP 0x0019f6ff
LAB_0019f7d4:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,0xd0
CALL qword ptr [RAX + 0x80]
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x60],RAX
CMP RAX,0x0
JNZ 0x0019f7fd
MOV dword ptr [RBP + -0x12c],0x1
JMP 0x0019f855
LAB_0019f7fd:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x60]
LEA RSI,[RBP + -0x120]
MOV EDX,0xd0
CALL 0x001360b0
MOV RAX,qword ptr [RBP + -0x10]
MOVZX EAX,byte ptr [RAX + 0xb2]
CMP EAX,0x1
JLE 0x0019f853
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xc]
AND EDX,0x20000
LEA RCX,[0x32df50]
LEA RAX,[0x32dfc0]
CMP EDX,0x0
CMOVNZ RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0xc0],RCX
LAB_0019f853:
JMP 0x0019f855
LAB_0019f855:
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX + 0x98]
MOV RDI,qword ptr [RBP + -0x30]
CALL RAX
CMP dword ptr [RBP + -0x12c],0x0
JZ 0x0019f897
MOV RAX,qword ptr [RBP + -0x18]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x0
JZ 0x0019f897
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX + 0xa0]
MOV RDX,qword ptr [RBP + -0x18]
XOR EDI,EDI
LEA RSI,[0x1d234c]
MOV AL,0x0
CALL RCX
LAB_0019f897:
MOV EAX,dword ptr [RBP + -0x12c]
MOV byte ptr [RBP + -0x1],AL
LAB_0019f8a0:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x160
POP RBP
RET
|
int1 create_tailoring(long param_1,char *param_2)
{
int8 uVar1;
char cVar2;
size_t sVar3;
long lVar4;
int1 *puVar5;
int1 local_15c;
int1 *local_158;
int1 *local_140;
uint local_138;
uint local_134;
int1 *local_130;
int1 local_128 [208];
int local_58;
int local_54;
int1 *local_50;
int8 local_38;
char *local_30;
char *local_20;
long local_18;
int1 local_9;
*param_2 = '\0';
if (*(long *)(param_1 + 0x38) == 0) {
local_9 = 0;
}
else {
local_20 = param_2;
local_18 = param_1;
memset(&local_58,0,0x38);
local_30 = local_20;
if (*(long *)(local_18 + 0x60) == 0) {
local_140 = my_uca_v400;
}
else {
local_140 = *(int1 **)(local_18 + 0x60);
}
local_50 = local_140;
memset(local_128,0,0xd0);
uVar1 = *(int8 *)(local_18 + 0x38);
lVar4 = *(long *)(local_18 + 0x38);
sVar3 = strlen(*(char **)(local_18 + 0x38));
local_134 = my_coll_rule_parse(&local_58,uVar1,lVar4 + sVar3);
if (local_134 == 0) {
if (local_58 == 0x208) {
local_130 = my_uca_v520;
*(int1 **)(local_18 + 0x78) = my_unicase_unicode520;
}
else if (local_58 == 400) {
local_130 = my_uca_v400;
*(int1 **)(local_18 + 0x78) = my_unicase_default;
}
else {
if (*(long *)(local_18 + 0x60) == 0) {
local_158 = my_uca_v400;
}
else {
local_158 = *(int1 **)(local_18 + 0x60);
}
local_130 = local_158;
if (*(long *)(local_18 + 0x78) == 0) {
*(int1 **)(local_18 + 0x78) = my_unicase_default;
}
}
if (local_54 == 0) {
local_15c = 1;
}
else {
local_15c = (int1)local_54;
}
*(int1 *)(local_18 + 0xb2) = local_15c;
for (local_138 = 0; local_138 != *(byte *)(local_18 + 0xb2); local_138 = local_138 + 1) {
local_134 = (uint)(*(long *)(local_130 + (ulong)local_138 * 0x38) == 0);
if (*(long *)(local_130 + (ulong)local_138 * 0x38) == 0) {
my_snprintf(local_20,0x7f,"%s: no level #%d data for this Unicode version.",
*(int8 *)(local_18 + 0x20),local_138 + 1);
goto LAB_0019f855;
}
cVar2 = init_weight_level(local_20,&local_58,local_128 + (ulong)local_138 * 0x38,
local_130 + (ulong)local_138 * 0x38);
local_134 = (uint)cVar2;
if (local_134 != 0) goto LAB_0019f855;
}
lVar4 = (**(code **)(local_20 + 0x80))(0xd0);
*(long *)(local_18 + 0x60) = lVar4;
if (lVar4 == 0) {
local_134 = 1;
}
else {
memcpy(*(void **)(local_18 + 0x60),local_128,0xd0);
if (1 < *(byte *)(local_18 + 0xb2)) {
puVar5 = my_uca_collation_handler_multilevel_generic;
if ((*(uint *)(local_18 + 0xc) & 0x20000) != 0) {
puVar5 = my_uca_collation_handler_nopad_multilevel_generic;
}
*(int1 **)(local_18 + 0xc0) = puVar5;
}
}
}
LAB_0019f855:
(**(code **)(local_20 + 0x98))(local_38);
if ((local_134 != 0) && (*local_20 != '\0')) {
(**(code **)(local_20 + 0xa0))(0,"%s",local_20);
}
local_9 = (int1)local_134;
}
return local_9;
}
| |
22,216 | js_std_fdopen | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_fdopen(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *mode;
FILE *f;
int fd, err;
if (JS_ToInt32(ctx, &fd, argv[0]))
return JS_EXCEPTION;
mode = JS_ToCString(ctx, argv[1]);
if (!mode)
goto fail;
if (mode[strspn(mode, "rwa+")] != '\0') {
JS_ThrowTypeError(ctx, "invalid file mode");
goto fail;
}
f = fdopen(fd, mode);
if (!f)
err = errno;
else
err = 0;
if (argc >= 3)
js_set_error_object(ctx, argv[2], err);
JS_FreeCString(ctx, mode);
if (!f)
return JS_NULL;
return js_new_std_file(ctx, f, FALSE);
fail:
JS_FreeCString(ctx, mode);
return JS_EXCEPTION;
} | O1 | c | js_std_fdopen:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0xc(%rsp), %rsi
callq 0x26d9c
movl $0x6, %r14d
testl %eax, %eax
jne 0x170ba
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1ffe3
movq %rax, %r15
testq %rax, %rax
je 0x170af
leaq 0x83595(%rip), %rsi # 0x9a624
movq %r15, %rdi
callq 0xe3e0
cmpb $0x0, (%r15,%rax)
je 0x170d1
leaq 0x83564(%rip), %rsi # 0x9a609
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
movq %rbx, %rdi
movq %r15, %rsi
callq 0x202c9
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edi
movq %r15, %rsi
callq 0xe6e0
movq %rax, %r14
testq %rax, %rax
je 0x170ea
xorl %r8d, %r8d
jmp 0x170f2
callq 0xe0b0
movl (%rax), %r8d
cmpl $0x3, %ebp
jl 0x17118
movq 0x28(%r12), %rdx
cmpl $0x3, %edx
je 0x17118
movq 0x20(%r12), %rsi
leaq 0x8350e(%rip), %rcx # 0x9a61b
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x24814
movq %rbx, %rdi
movq %r15, %rsi
callq 0x202c9
testq %r14, %r14
je 0x1714c
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x15163
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
jmp 0x170be
xorl %eax, %eax
movl $0x2, %r14d
jmp 0x170bc
| js_std_fdopen:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r12, r8
mov ebp, ecx
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+38h+var_2C]
call JS_ToInt32
mov r14d, 6
test eax, eax
jnz short loc_170BA
mov rdx, [r12+10h]
mov rcx, [r12+18h]
mov rdi, rbx
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
mov r15, rax
test rax, rax
jz short loc_170AF
lea rsi, aRwa; "rwa+"
mov rdi, r15
call _strspn
cmp byte ptr [r15+rax], 0
jz short loc_170D1
lea rsi, aInvalidFileMod; "invalid file mode"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_170AF:
mov rdi, rbx
mov rsi, r15
call JS_FreeCString
loc_170BA:
xor eax, eax
loc_170BC:
xor ecx, ecx
loc_170BE:
or rax, rcx
mov rdx, r14
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_170D1:
mov edi, [rsp+38h+var_2C]
mov rsi, r15
call _fdopen
mov r14, rax
test rax, rax
jz short loc_170EA
xor r8d, r8d
jmp short loc_170F2
loc_170EA:
call ___errno_location
mov r8d, [rax]
loc_170F2:
cmp ebp, 3
jl short loc_17118
mov rdx, [r12+28h]
cmp edx, 3
jz short loc_17118
mov rsi, [r12+20h]
lea rcx, aErrno; "errno"
mov rdi, rbx
xor r9d, r9d
call JS_SetPropertyStr
loc_17118:
mov rdi, rbx
mov rsi, r15
call JS_FreeCString
test r14, r14
jz short loc_1714C
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_new_std_file
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
jmp loc_170BE
loc_1714C:
xor eax, eax
mov r14d, 2
jmp loc_170BC
| unsigned long long js_std_fdopen(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v8; // rax
long long v9; // r15
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
unsigned long long v14; // rax
unsigned long long v15; // rcx
long long v17; // rdi
long long v18; // r14
long long v19; // r8
long long v20; // rdx
_DWORD v21[11]; // [rsp+Ch] [rbp-2Ch] BYREF
if ( (unsigned int)JS_ToInt32(a1, v21, *a5, a5[1]) )
goto LABEL_6;
v8 = JS_ToCStringLen2(a1, 0LL, a5[2], a5[3], 0LL);
v9 = v8;
if ( !v8 )
{
LABEL_5:
JS_FreeCString(a1, v9);
LABEL_6:
v14 = 0LL;
goto LABEL_7;
}
if ( *(_BYTE *)(v8 + strspn(v8, "rwa+")) )
{
JS_ThrowTypeError(a1, (unsigned int)"invalid file mode", v10, v11, v12, v13);
goto LABEL_5;
}
v17 = v21[0];
v18 = fdopen(v21[0], v9);
if ( v18 )
v19 = 0LL;
else
v19 = *(unsigned int *)__errno_location(v17);
if ( a4 >= 3 )
{
v20 = a5[5];
if ( (_DWORD)v20 != 3 )
JS_SetPropertyStr(a1, a5[4], v20, "errno", v19, 0LL);
}
JS_FreeCString(a1, v9);
if ( v18 )
{
v14 = js_new_std_file(a1, v18, 0);
v15 = v14 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v14;
return v15 | v14;
}
v14 = 0LL;
LABEL_7:
v15 = 0LL;
return v15 | v14;
}
| js_std_fdopen:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,R8
MOV EBP,ECX
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0xc]
CALL 0x00126d9c
MOV R14D,0x6
TEST EAX,EAX
JNZ 0x001170ba
MOV RDX,qword ptr [R12 + 0x10]
MOV RCX,qword ptr [R12 + 0x18]
MOV RDI,RBX
XOR ESI,ESI
XOR R8D,R8D
CALL 0x0011ffe3
MOV R15,RAX
TEST RAX,RAX
JZ 0x001170af
LEA RSI,[0x19a624]
MOV RDI,R15
CALL 0x0010e3e0
CMP byte ptr [R15 + RAX*0x1],0x0
JZ 0x001170d1
LEA RSI,[0x19a609]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
LAB_001170af:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001202c9
LAB_001170ba:
XOR EAX,EAX
LAB_001170bc:
XOR ECX,ECX
LAB_001170be:
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001170d1:
MOV EDI,dword ptr [RSP + 0xc]
MOV RSI,R15
CALL 0x0010e6e0
MOV R14,RAX
TEST RAX,RAX
JZ 0x001170ea
XOR R8D,R8D
JMP 0x001170f2
LAB_001170ea:
CALL 0x0010e0b0
MOV R8D,dword ptr [RAX]
LAB_001170f2:
CMP EBP,0x3
JL 0x00117118
MOV RDX,qword ptr [R12 + 0x28]
CMP EDX,0x3
JZ 0x00117118
MOV RSI,qword ptr [R12 + 0x20]
LEA RCX,[0x19a61b]
MOV RDI,RBX
XOR R9D,R9D
CALL 0x00124814
LAB_00117118:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001202c9
TEST R14,R14
JZ 0x0011714c
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00115163
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
JMP 0x001170be
LAB_0011714c:
XOR EAX,EAX
MOV R14D,0x2
JMP 0x001170bc
|
int1 [16]
js_std_fdopen(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int iVar1;
char *__s;
size_t sVar2;
FILE *pFVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
int8 uVar7;
int1 auVar8 [16];
int local_2c;
iVar1 = JS_ToInt32(param_1,&local_2c,*param_5,param_5[1]);
uVar7 = 6;
if (iVar1 == 0) {
__s = (char *)JS_ToCStringLen2(param_1,0,param_5[2],param_5[3],0);
if (__s != (char *)0x0) {
sVar2 = strspn(__s,"rwa+");
if (__s[sVar2] == '\0') {
pFVar3 = fdopen(local_2c,__s);
if (pFVar3 == (FILE *)0x0) {
piVar4 = __errno_location();
iVar1 = *piVar4;
}
else {
iVar1 = 0;
}
if ((2 < param_4) && ((int)param_5[5] != 3)) {
JS_SetPropertyStr(param_1,param_5[4],param_5[5],"errno",iVar1,0);
}
JS_FreeCString(param_1,__s);
if (pFVar3 != (FILE *)0x0) {
auVar8 = js_new_std_file(param_1,pFVar3,0);
uVar7 = auVar8._8_8_;
uVar6 = auVar8._0_8_ & 0xffffffff00000000;
uVar5 = auVar8._0_8_ & 0xffffffff;
goto LAB_001170be;
}
uVar7 = 2;
goto LAB_001170bc;
}
JS_ThrowTypeError(param_1,"invalid file mode");
}
JS_FreeCString(param_1,__s);
}
LAB_001170bc:
uVar5 = 0;
uVar6 = 0;
LAB_001170be:
auVar8._0_8_ = uVar5 | uVar6;
auVar8._8_8_ = uVar7;
return auVar8;
}
| |
22,217 | js_std_fdopen | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_fdopen(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *mode;
FILE *f;
int fd, err;
if (JS_ToInt32(ctx, &fd, argv[0]))
return JS_EXCEPTION;
mode = JS_ToCString(ctx, argv[1]);
if (!mode)
goto fail;
if (mode[strspn(mode, "rwa+")] != '\0') {
JS_ThrowTypeError(ctx, "invalid file mode");
goto fail;
}
f = fdopen(fd, mode);
if (!f)
err = errno;
else
err = 0;
if (argc >= 3)
js_set_error_object(ctx, argv[2], err);
JS_FreeCString(ctx, mode);
if (!f)
return JS_NULL;
return js_new_std_file(ctx, f, FALSE);
fail:
JS_FreeCString(ctx, mode);
return JS_EXCEPTION;
} | O3 | c | js_std_fdopen:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r12
movl %ecx, %ebp
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
leaq 0xc(%rsp), %rsi
callq 0x273ff
movl $0x6, %r14d
testl %eax, %eax
jne 0x17ac4
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x20717
movq %rax, %r15
testq %rax, %rax
je 0x17ab9
leaq 0x85b34(%rip), %rsi # 0x9d5cd
movq %r15, %rdi
callq 0xe3e0
cmpb $0x0, (%r15,%rax)
je 0x17adb
leaq 0x85b03(%rip), %rsi # 0x9d5b2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2214f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x209ed
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rsp), %edi
movq %r15, %rsi
callq 0xe6e0
movq %rax, %r14
testq %rax, %rax
je 0x17af4
xorl %r8d, %r8d
jmp 0x17afc
callq 0xe0b0
movl (%rax), %r8d
cmpl $0x3, %ebp
jl 0x17b22
movq 0x28(%r12), %rdx
cmpl $0x3, %edx
je 0x17b22
movq 0x20(%r12), %rsi
leaq 0x85aad(%rip), %rcx # 0x9d5c4
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x24dfb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x209ed
testq %r14, %r14
je 0x17b56
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x15b45
movq %rdx, %r14
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
jmp 0x17ac8
xorl %eax, %eax
movl $0x2, %r14d
jmp 0x17ac6
| js_std_fdopen:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r12, r8
mov ebp, ecx
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
lea rsi, [rsp+38h+var_2C]
call JS_ToInt32
mov r14d, 6
test eax, eax
jnz short loc_17AC4
mov rdx, [r12+10h]
mov rcx, [r12+18h]
mov rdi, rbx
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
mov r15, rax
test rax, rax
jz short loc_17AB9
lea rsi, aRwa; "rwa+"
mov rdi, r15
call _strspn
cmp byte ptr [r15+rax], 0
jz short loc_17ADB
lea rsi, aInvalidFileMod; "invalid file mode"
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
loc_17AB9:
mov rdi, rbx
mov rsi, r15
call JS_FreeCString
loc_17AC4:
xor eax, eax
loc_17AC6:
xor ecx, ecx
loc_17AC8:
or rax, rcx
mov rdx, r14
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_17ADB:
mov edi, [rsp+38h+var_2C]
mov rsi, r15
call _fdopen
mov r14, rax
test rax, rax
jz short loc_17AF4
xor r8d, r8d
jmp short loc_17AFC
loc_17AF4:
call ___errno_location
mov r8d, [rax]
loc_17AFC:
cmp ebp, 3
jl short loc_17B22
mov rdx, [r12+28h]
cmp edx, 3
jz short loc_17B22
mov rsi, [r12+20h]
lea rcx, aErrno; "errno"
mov rdi, rbx
xor r9d, r9d
call JS_SetPropertyStr
loc_17B22:
mov rdi, rbx
mov rsi, r15
call JS_FreeCString
test r14, r14
jz short loc_17B56
mov rdi, rbx
mov rsi, r14
xor edx, edx
call js_new_std_file
mov r14, rdx
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov eax, eax
jmp loc_17AC8
loc_17B56:
xor eax, eax
mov r14d, 2
jmp loc_17AC6
| unsigned long long js_std_fdopen(long long a1, long long a2, long long a3, int a4, _QWORD *a5)
{
long long v8; // rax
long long v9; // r15
int v10; // edx
int v11; // ecx
int v12; // r8d
int v13; // r9d
unsigned long long v14; // rax
unsigned long long v15; // rcx
long long v17; // rdi
long long v18; // r14
long long v19; // r8
long long v20; // rdx
_DWORD v21[11]; // [rsp+Ch] [rbp-2Ch] BYREF
if ( (unsigned int)JS_ToInt32(a1, v21, *a5, a5[1]) )
goto LABEL_6;
v8 = JS_ToCStringLen2(a1, 0LL, a5[2], a5[3], 0LL);
v9 = v8;
if ( !v8 )
{
LABEL_5:
JS_FreeCString(a1, v9);
LABEL_6:
v14 = 0LL;
goto LABEL_7;
}
if ( *(_BYTE *)(v8 + strspn(v8, "rwa+")) )
{
JS_ThrowTypeError(a1, (unsigned int)"invalid file mode", v10, v11, v12, v13);
goto LABEL_5;
}
v17 = v21[0];
v18 = fdopen(v21[0], v9);
if ( v18 )
v19 = 0LL;
else
v19 = *(unsigned int *)__errno_location(v17);
if ( a4 >= 3 )
{
v20 = a5[5];
if ( (_DWORD)v20 != 3 )
JS_SetPropertyStr(a1, a5[4], v20, "errno", v19, 0LL);
}
JS_FreeCString(a1, v9);
if ( v18 )
{
v14 = js_new_std_file(a1, v18, 0);
v15 = v14 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v14;
return v15 | v14;
}
v14 = 0LL;
LABEL_7:
v15 = 0LL;
return v15 | v14;
}
| js_std_fdopen:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R12,R8
MOV EBP,ECX
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
LEA RSI,[RSP + 0xc]
CALL 0x001273ff
MOV R14D,0x6
TEST EAX,EAX
JNZ 0x00117ac4
MOV RDX,qword ptr [R12 + 0x10]
MOV RCX,qword ptr [R12 + 0x18]
MOV RDI,RBX
XOR ESI,ESI
XOR R8D,R8D
CALL 0x00120717
MOV R15,RAX
TEST RAX,RAX
JZ 0x00117ab9
LEA RSI,[0x19d5cd]
MOV RDI,R15
CALL 0x0010e3e0
CMP byte ptr [R15 + RAX*0x1],0x0
JZ 0x00117adb
LEA RSI,[0x19d5b2]
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012214f
LAB_00117ab9:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001209ed
LAB_00117ac4:
XOR EAX,EAX
LAB_00117ac6:
XOR ECX,ECX
LAB_00117ac8:
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00117adb:
MOV EDI,dword ptr [RSP + 0xc]
MOV RSI,R15
CALL 0x0010e6e0
MOV R14,RAX
TEST RAX,RAX
JZ 0x00117af4
XOR R8D,R8D
JMP 0x00117afc
LAB_00117af4:
CALL 0x0010e0b0
MOV R8D,dword ptr [RAX]
LAB_00117afc:
CMP EBP,0x3
JL 0x00117b22
MOV RDX,qword ptr [R12 + 0x28]
CMP EDX,0x3
JZ 0x00117b22
MOV RSI,qword ptr [R12 + 0x20]
LEA RCX,[0x19d5c4]
MOV RDI,RBX
XOR R9D,R9D
CALL 0x00124dfb
LAB_00117b22:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001209ed
TEST R14,R14
JZ 0x00117b56
MOV RDI,RBX
MOV RSI,R14
XOR EDX,EDX
CALL 0x00115b45
MOV R14,RDX
MOV RCX,-0x100000000
AND RCX,RAX
MOV EAX,EAX
JMP 0x00117ac8
LAB_00117b56:
XOR EAX,EAX
MOV R14D,0x2
JMP 0x00117ac6
|
int1 [16]
js_std_fdopen(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5)
{
int iVar1;
char *__s;
size_t sVar2;
FILE *pFVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
int8 uVar7;
int1 auVar8 [16];
int local_2c;
iVar1 = JS_ToInt32(param_1,&local_2c,*param_5,param_5[1]);
uVar7 = 6;
if (iVar1 == 0) {
__s = (char *)JS_ToCStringLen2(param_1,0,param_5[2],param_5[3],0);
if (__s != (char *)0x0) {
sVar2 = strspn(__s,"rwa+");
if (__s[sVar2] == '\0') {
pFVar3 = fdopen(local_2c,__s);
if (pFVar3 == (FILE *)0x0) {
piVar4 = __errno_location();
iVar1 = *piVar4;
}
else {
iVar1 = 0;
}
if ((2 < param_4) && ((int)param_5[5] != 3)) {
JS_SetPropertyStr(param_1,param_5[4],param_5[5],"errno",iVar1,0);
}
JS_FreeCString(param_1,__s);
if (pFVar3 != (FILE *)0x0) {
auVar8 = js_new_std_file(param_1,pFVar3,0);
uVar7 = auVar8._8_8_;
uVar6 = auVar8._0_8_ & 0xffffffff00000000;
uVar5 = auVar8._0_8_ & 0xffffffff;
goto LAB_00117ac8;
}
uVar7 = 2;
goto LAB_00117ac6;
}
JS_ThrowTypeError(param_1,"invalid file mode");
}
JS_FreeCString(param_1,__s);
}
LAB_00117ac6:
uVar5 = 0;
uVar6 = 0;
LAB_00117ac8:
auVar8._0_8_ = uVar5 | uVar6;
auVar8._8_8_ = uVar7;
return auVar8;
}
| |
22,218 | httplib::detail::mmap::mmap(char const*) | hkr04[P]cpp-mcp/common/httplib.h | inline mmap::mmap(const char *path) { open(path); } | O0 | c | httplib::detail::mmap::mmap(char const*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0xffffffff, (%rdi) # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movq 0x8(%rsp), %rsi
callq 0x63e50
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN7httplib6detail4mmapC2EPKc:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rdi, [rsp+18h+var_8]; this
mov dword ptr [rdi], 0FFFFFFFFh
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov byte ptr [rdi+18h], 0
mov rsi, [rsp+18h+var_10]; char *
call _ZN7httplib6detail4mmap4openEPKc; httplib::detail::mmap::open(char const*)
add rsp, 18h
retn
| long long httplib::detail::mmap::mmap(httplib::detail::mmap *this, const char *a2)
{
*(_DWORD *)this = -1;
*((_QWORD *)this + 1) = 0LL;
*((_QWORD *)this + 2) = 0LL;
*((_BYTE *)this + 24) = 0;
return httplib::detail::mmap::open(this, a2);
}
| mmap:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RDI,qword ptr [RSP + 0x10]
MOV dword ptr [RDI],0xffffffff
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV byte ptr [RDI + 0x18],0x0
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00163e50
ADD RSP,0x18
RET
|
/* httplib::detail::mmap::mmap(char const*) */
void __thiscall httplib::detail::mmap::mmap(mmap *this,char *param_1)
{
*(int4 *)this = 0xffffffff;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
this[0x18] = (mmap)0x0;
open(this,param_1);
return;
}
| |
22,219 | my_strnncoll_simple | eloqsql/strings/ctype-simple.c | int my_strnncoll_simple(CHARSET_INFO * cs, const uchar *s, size_t slen,
const uchar *t, size_t tlen,
my_bool t_is_prefix)
{
size_t len = ( slen > tlen ) ? tlen : slen;
const uchar *map= cs->sort_order;
if (t_is_prefix && slen > tlen)
slen=tlen;
while (len--)
{
if (map[*s++] != map[*t++])
return ((int) map[s[-1]] - (int) map[t[-1]]);
}
/*
We can't use (slen - tlen) here as the result may be outside of the
precision of a signed int
*/
return slen > tlen ? 1 : slen < tlen ? -1 : 0 ;
} | O0 | c | my_strnncoll_simple:
pushq %rbp
movq %rsp, %rbp
movb %r9b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x42262
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x4226a
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x48(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x0, %eax
je 0x42299
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x42299
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x4229b
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x40(%rbp)
cmpq $0x0, %rax
je 0x42311
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4230f
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl -0x1(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x48(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl -0x1(%rdx), %edx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x42343
jmp 0x4229b
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x42325
movl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4233d
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rsi
xorl %eax, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
| my_strnncoll_simple:
push rbp
mov rbp, rsp
mov al, r9b
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_31], al
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jbe short loc_42262
mov rax, [rbp+var_30]
mov [rbp+var_50], rax
jmp short loc_4226A
loc_42262:
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
loc_4226A:
mov rax, [rbp+var_50]
mov [rbp+var_40], rax
mov rax, [rbp+var_10]
mov rax, [rax+58h]
mov [rbp+var_48], rax
movsx eax, [rbp+var_31]
cmp eax, 0
jz short loc_42299
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jbe short loc_42299
mov rax, [rbp+var_30]
mov [rbp+var_20], rax
loc_42299:
jmp short $+2
loc_4229B:
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_40], rcx
cmp rax, 0
jz short loc_42311
mov rax, [rbp+var_48]
mov rcx, [rbp+var_18]
mov rdx, rcx
add rdx, 1
mov [rbp+var_18], rdx
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_48]
mov rdx, [rbp+var_28]
mov rsi, rdx
add rsi, 1
mov [rbp+var_28], rsi
movzx edx, byte ptr [rdx]
movzx ecx, byte ptr [rcx+rdx]
cmp eax, ecx
jz short loc_4230F
mov rax, [rbp+var_48]
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx-1]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_48]
mov rdx, [rbp+var_28]
movzx edx, byte ptr [rdx-1]
movzx ecx, byte ptr [rcx+rdx]
sub eax, ecx
mov [rbp+var_4], eax
jmp short loc_42343
loc_4230F:
jmp short loc_4229B
loc_42311:
mov rax, [rbp+var_20]
cmp rax, [rbp+var_30]
jbe short loc_42325
mov eax, 1
mov [rbp+var_54], eax
jmp short loc_4233D
loc_42325:
mov rdx, [rbp+var_20]
mov rsi, [rbp+var_30]
xor eax, eax
mov ecx, 0FFFFFFFFh
cmp rdx, rsi
cmovb eax, ecx
mov [rbp+var_54], eax
loc_4233D:
mov eax, [rbp+var_54]
mov [rbp+var_4], eax
loc_42343:
mov eax, [rbp+var_4]
pop rbp
retn
| long long my_strnncoll_simple(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
unsigned __int8 *a4,
unsigned long long a5,
char a6)
{
unsigned __int8 *v7; // rcx
unsigned __int8 *v8; // rdx
unsigned int v9; // eax
unsigned long long v12; // [rsp+4h] [rbp-50h]
long long v13; // [rsp+Ch] [rbp-48h]
unsigned long long v14; // [rsp+14h] [rbp-40h]
unsigned long long v16; // [rsp+34h] [rbp-20h]
v16 = a3;
if ( a3 <= a5 )
v12 = a3;
else
v12 = a5;
v14 = v12;
v13 = *(_QWORD *)(a1 + 88);
if ( a6 && a3 > a5 )
v16 = a5;
while ( v14-- )
{
v7 = a2++;
v8 = a4++;
if ( *(unsigned __int8 *)(v13 + *v7) != *(unsigned __int8 *)(v13 + *v8) )
return (unsigned int)(*(unsigned __int8 *)(v13 + *(a2 - 1)) - *(unsigned __int8 *)(v13 + *(a4 - 1)));
}
if ( v16 <= a5 )
{
v9 = 0;
if ( v16 < a5 )
v9 = -1;
return v9;
}
else
{
return 1;
}
}
| my_strnncoll_simple:
PUSH RBP
MOV RBP,RSP
MOV AL,R9B
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV byte ptr [RBP + -0x31],AL
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00142262
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x50],RAX
JMP 0x0014226a
LAB_00142262:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
LAB_0014226a:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x58]
MOV qword ptr [RBP + -0x48],RAX
MOVSX EAX,byte ptr [RBP + -0x31]
CMP EAX,0x0
JZ 0x00142299
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00142299
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x20],RAX
LAB_00142299:
JMP 0x0014229b
LAB_0014229b:
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x40],RCX
CMP RAX,0x0
JZ 0x00142311
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x18],RDX
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x28]
MOV RSI,RDX
ADD RSI,0x1
MOV qword ptr [RBP + -0x28],RSI
MOVZX EDX,byte ptr [RDX]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
CMP EAX,ECX
JZ 0x0014230f
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + -0x1]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x28]
MOVZX EDX,byte ptr [RDX + -0x1]
MOVZX ECX,byte ptr [RCX + RDX*0x1]
SUB EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00142343
LAB_0014230f:
JMP 0x0014229b
LAB_00142311:
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x30]
JBE 0x00142325
MOV EAX,0x1
MOV dword ptr [RBP + -0x54],EAX
JMP 0x0014233d
LAB_00142325:
MOV RDX,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x30]
XOR EAX,EAX
MOV ECX,0xffffffff
CMP RDX,RSI
CMOVC EAX,ECX
MOV dword ptr [RBP + -0x54],EAX
LAB_0014233d:
MOV EAX,dword ptr [RBP + -0x54]
MOV dword ptr [RBP + -0x4],EAX
LAB_00142343:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int my_strnncoll_simple(long param_1,byte *param_2,ulong param_3,byte *param_4,ulong param_5,
char param_6)
{
long lVar1;
byte *pbVar2;
byte *pbVar3;
int local_5c;
ulong local_58;
ulong local_48;
byte *local_30;
ulong local_28;
byte *local_20;
local_58 = param_3;
if (param_5 < param_3) {
local_58 = param_5;
}
local_48 = local_58;
lVar1 = *(long *)(param_1 + 0x58);
pbVar2 = param_4;
pbVar3 = param_2;
local_28 = param_3;
if ((param_6 != '\0') && (pbVar2 = param_4, pbVar3 = param_2, param_5 < param_3)) {
pbVar2 = param_4;
pbVar3 = param_2;
local_28 = param_5;
}
do {
local_20 = pbVar3;
local_30 = pbVar2;
if (local_48 == 0) {
if (param_5 < local_28) {
local_5c = 1;
}
else {
local_5c = 0;
if (local_28 < param_5) {
local_5c = -1;
}
}
return local_5c;
}
local_48 = local_48 - 1;
pbVar2 = local_30 + 1;
pbVar3 = local_20 + 1;
} while (*(char *)(lVar1 + (ulong)*local_20) == *(char *)(lVar1 + (ulong)*local_30));
return (uint)*(byte *)(lVar1 + (ulong)*local_20) - (uint)*(byte *)(lVar1 + (ulong)*local_30);
}
| |
22,220 | spdlog::logger::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::pattern_time_type) | AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/logger-inl.h | SPDLOG_INLINE void logger::set_pattern(std::string pattern, pattern_time_type time_type) {
auto new_formatter = details::make_unique<pattern_formatter>(std::move(pattern), time_type);
set_formatter(std::move(new_formatter));
} | O3 | c | spdlog::logger::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, spdlog::pattern_time_type):
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14(%rsp), %rax
movl %edx, (%rax)
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x2ff3e
movq (%r14), %rax
movq $0x0, (%r14)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x2d73c
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2e58b
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rsi
testq %rsi, %rsi
je 0x2e59c
movq %rsp, %rdi
callq 0x33eaa
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2e5b7
movq (%rdi), %rax
callq *0x8(%rax)
movq %rsp, %rdi
callq 0x12624
movq %rbx, %rdi
callq 0x11760
nop
| _ZN6spdlog6logger11set_patternENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_17pattern_time_typeE:
push r14; int
push rbx; void *
sub rsp, 18h
mov rbx, rdi
lea rax, [rsp+28h+var_14]
mov [rax], edx
mov r14, rsp
mov rdi, r14; int
mov rdx, rax; int
call _ZSt11make_uniqueIN6spdlog17pattern_formatterEJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERNS0_17pattern_time_typeEEENSt9_MakeUniqIT_E15__single_objectEDpOT0_; std::make_unique<spdlog::pattern_formatter,std::string,spdlog::pattern_time_type &>(std::string,spdlog::pattern_time_type &)
mov rax, [r14]
mov qword ptr [r14], 0
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
mov rdi, rbx
call _ZN6spdlog6logger13set_formatterESt10unique_ptrINS_9formatterESt14default_deleteIS2_EE; spdlog::logger::set_formatter(std::unique_ptr<spdlog::formatter>)
mov rdi, [rsp+28h+var_20]
test rdi, rdi
jz short loc_2E58B
mov rax, [rdi]
call qword ptr [rax+8]
loc_2E58B:
mov rsi, [rsp+28h+var_28]
test rsi, rsi
jz short loc_2E59C
mov rdi, rsp
call _ZNKSt14default_deleteIN6spdlog17pattern_formatterEEclEPS1_; std::default_delete<spdlog::pattern_formatter>::operator()(spdlog::pattern_formatter*)
loc_2E59C:
add rsp, 18h
pop rbx
pop r14
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_2E5B7
mov rax, [rdi]
call qword ptr [rax+8]
loc_2E5B7:
mov rdi, rsp
call _ZN6spdlog6logger11set_patternENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS_17pattern_time_typeE_cold_1; spdlog::logger::set_pattern(std::string,spdlog::pattern_time_type) [clone]
mov rdi, rbx
call __Unwind_Resume
| set_pattern:
PUSH R14
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA RAX,[RSP + 0x14]
MOV dword ptr [RAX],EDX
MOV R14,RSP
MOV RDI,R14
MOV RDX,RAX
CALL 0x0012ff3e
MOV RAX,qword ptr [R14]
MOV qword ptr [R14],0x0
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
LAB_0012e573:
MOV RDI,RBX
CALL 0x0012d73c
LAB_0012e57b:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0012e58b
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0012e58b:
MOV RSI,qword ptr [RSP]
TEST RSI,RSI
JZ 0x0012e59c
MOV RDI,RSP
CALL 0x00133eaa
LAB_0012e59c:
ADD RSP,0x18
POP RBX
POP R14
RET
|
/* spdlog::logger::set_pattern(std::__cxx11::string, spdlog::pattern_time_type) */
void __thiscall
spdlog::logger::set_pattern(logger *this,pattern_time_type *param_2,int4 param_3)
{
pattern_formatter *local_28;
long *local_20;
int4 local_14;
local_14 = param_3;
std::make_unique<spdlog::pattern_formatter,std::__cxx11::string,spdlog::pattern_time_type&>
((string *)&local_28,param_2);
local_20 = (long *)local_28;
local_28 = (pattern_formatter *)0x0;
/* try { // try from 0012e573 to 0012e57a has its CatchHandler @ 0012e5a4 */
set_formatter(this);
if (local_20 != (long *)0x0) {
(**(code **)(*local_20 + 8))();
}
if (local_28 != (pattern_formatter *)0x0) {
std::default_delete<spdlog::pattern_formatter>::operator()
((default_delete<spdlog::pattern_formatter> *)&local_28,local_28);
}
return;
}
| ||
22,221 | maria_page_crc_set_normal | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_set_normal(PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
int data_length= share->block_size - CRC_SIZE;
uint32 crc= maria_page_crc((uint32) page_no, page, data_length);
DBUG_ENTER("maria_page_crc_set_normal");
DBUG_PRINT("info", ("Page %lu crc: %lu", (ulong) page_no, (ulong)crc));
/* crc is on the stack so it is aligned, pagecache buffer is aligned, too */
int4store_aligned(page + data_length, crc);
DBUG_RETURN(0);
} | O0 | c | maria_page_crc_set_normal:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x7bc(%rax), %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x9daa0
movl %eax, -0x28(%rbp)
jmp 0x9db36
jmp 0x9db38
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
jmp 0x9db52
jmp 0x9db54
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| maria_page_crc_set_normal:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
mov rax, [rax+8]
mov [rbp+var_18], rax
mov rax, [rbp+var_8]
mov rax, [rax+10h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
mov eax, [rax+7BCh]
sub eax, 4
mov [rbp+var_24], eax
mov rax, [rbp+var_18]
mov edi, eax
mov rsi, [rbp+var_10]
mov edx, [rbp+var_24]
call maria_page_crc
mov [rbp+var_28], eax
jmp short $+2
loc_9DB36:
jmp short $+2
loc_9DB38:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_24]
add rax, rcx
mov [rbp+var_30], rax
mov ecx, [rbp+var_28]
mov rax, [rbp+var_30]
mov [rax], ecx
jmp short $+2
loc_9DB52:
jmp short $+2
loc_9DB54:
xor eax, eax
add rsp, 30h
pop rbp
retn
| long long maria_page_crc_set_normal(long long *a1)
{
_DWORD *v2; // [rsp+0h] [rbp-30h]
long long v3; // [rsp+10h] [rbp-20h]
v3 = a1[2];
v2 = (_DWORD *)(*(_DWORD *)(v3 + 1980) - 4 + *a1);
*v2 = maria_page_crc(a1[1], *a1, *(_DWORD *)(v3 + 1980) - 4);
return 0LL;
}
| maria_page_crc_set_normal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x7bc]
SUB EAX,0x4
MOV dword ptr [RBP + -0x24],EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
MOV RSI,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RBP + -0x24]
CALL 0x0019daa0
MOV dword ptr [RBP + -0x28],EAX
JMP 0x0019db36
LAB_0019db36:
JMP 0x0019db38
LAB_0019db38:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x24]
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,dword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
JMP 0x0019db52
LAB_0019db52:
JMP 0x0019db54
LAB_0019db54:
XOR EAX,EAX
ADD RSP,0x30
POP RBP
RET
|
int8 maria_page_crc_set_normal(long *param_1)
{
long lVar1;
int iVar2;
int4 uVar3;
lVar1 = *param_1;
iVar2 = *(int *)(param_1[2] + 0x7bc) + -4;
uVar3 = maria_page_crc(param_1[1] & 0xffffffff,lVar1,iVar2);
*(int4 *)(lVar1 + iVar2) = uVar3;
return 0;
}
| |
22,222 | my_hash_next | eloqsql/mysys/hash.c | uchar* my_hash_next(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
uint idx;
if (*current_record != NO_RECORD)
{
HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
{
pos=data+idx;
if (!hashcmp(hash,pos,key,length))
{
*current_record= idx;
return pos->data;
}
}
*current_record= NO_RECORD;
}
return 0;
} | O0 | c | my_hash_next:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x37c37
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $-0x1, -0x34(%rbp)
je 0x37c2d
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x37ac0
cmpl $0x0, %eax
jne 0x37c20
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x37c3f
jmp 0x37c22
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x37bd7
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
| my_hash_next:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_28]
cmp dword ptr [rax], 0FFFFFFFFh
jz loc_37C37
mov rax, [rbp+var_10]
mov rax, [rax+28h]
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov rcx, [rbp+var_28]
mov ecx, [rcx]
shl rcx, 4
add rax, rcx
mov eax, [rax]
mov [rbp+var_34], eax
loc_37BD7:
cmp [rbp+var_34], 0FFFFFFFFh
jz short loc_37C2D
mov rax, [rbp+var_40]
mov ecx, [rbp+var_34]
shl rcx, 4
add rax, rcx
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
call hashcmp
cmp eax, 0
jnz short loc_37C20
mov ecx, [rbp+var_34]
mov rax, [rbp+var_28]
mov [rax], ecx
mov rax, [rbp+var_30]
mov rax, [rax+8]
mov [rbp+var_8], rax
jmp short loc_37C3F
loc_37C20:
jmp short $+2
loc_37C22:
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_34], eax
jmp short loc_37BD7
loc_37C2D:
mov rax, [rbp+var_28]
mov dword ptr [rax], 0FFFFFFFFh
loc_37C37:
mov [rbp+var_8], 0
loc_37C3F:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
| long long my_hash_next(long long a1, long long a2, long long a3, unsigned int *a4)
{
long long v5; // [rsp+0h] [rbp-40h]
unsigned int i; // [rsp+Ch] [rbp-34h]
long long v7; // [rsp+10h] [rbp-30h]
if ( *a4 != -1 )
{
v5 = *(_QWORD *)(a1 + 40);
for ( i = *(_DWORD *)(16LL * *a4 + v5); i != -1; i = *(_DWORD *)v7 )
{
v7 = 16LL * i + v5;
if ( !hashcmp(a1, v7, a2, a3) )
{
*a4 = i;
return *(_QWORD *)(v7 + 8);
}
}
*a4 = -1;
}
return 0LL;
}
| my_hash_next:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x28]
CMP dword ptr [RAX],-0x1
JZ 0x00137c37
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX]
SHL RCX,0x4
ADD RAX,RCX
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
LAB_00137bd7:
CMP dword ptr [RBP + -0x34],-0x1
JZ 0x00137c2d
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x34]
SHL RCX,0x4
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
CALL 0x00137ac0
CMP EAX,0x0
JNZ 0x00137c20
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x00137c3f
LAB_00137c20:
JMP 0x00137c22
LAB_00137c22:
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x00137bd7
LAB_00137c2d:
MOV RAX,qword ptr [RBP + -0x28]
MOV dword ptr [RAX],0xffffffff
LAB_00137c37:
MOV qword ptr [RBP + -0x8],0x0
LAB_00137c3f:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8 my_hash_next(long param_1,int8 param_2,int8 param_3,uint *param_4)
{
long lVar1;
int iVar2;
uint *puVar3;
uint local_3c;
if (*param_4 != 0xffffffff) {
lVar1 = *(long *)(param_1 + 0x28);
local_3c = *(uint *)(lVar1 + (ulong)*param_4 * 0x10);
while (local_3c != 0xffffffff) {
puVar3 = (uint *)(lVar1 + (ulong)local_3c * 0x10);
iVar2 = hashcmp(param_1,puVar3,param_2,param_3);
if (iVar2 == 0) {
*param_4 = local_3c;
return *(int8 *)(puVar3 + 2);
}
local_3c = *puVar3;
}
*param_4 = 0xffffffff;
}
return 0;
}
| |
22,223 | my_hash_next | eloqsql/mysys/hash.c | uchar* my_hash_next(const HASH *hash, const uchar *key, size_t length,
HASH_SEARCH_STATE *current_record)
{
HASH_LINK *pos;
uint idx;
if (*current_record != NO_RECORD)
{
HASH_LINK *data=dynamic_element(&hash->array,0,HASH_LINK*);
for (idx=data[*current_record].next; idx != NO_RECORD ; idx=pos->next)
{
pos=data+idx;
if (!hashcmp(hash,pos,key,length))
{
*current_record= idx;
return pos->data;
}
}
*current_record= NO_RECORD;
}
return 0;
} | O3 | c | my_hash_next:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x38(%rbp)
movl (%rcx), %ebx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x30255
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, -0x30(%rbp)
movq 0x28(%rdi), %r13
shlq $0x4, %rbx
addq %r13, %rbx
movl (%rbx), %r14d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x3024b
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%r13), %rbx
movq 0x8(%r13,%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq -0x38(%rbp), %rcx
callq 0x3014d
testl %eax, %eax
jne 0x3020e
movq -0x30(%rbp), %rax
movl %r14d, (%rax)
movq 0x8(%rbx), %rax
jmp 0x30257
movq -0x30(%rbp), %rax
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| my_hash_next:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov [rbp+var_38], rdx
mov ebx, [rcx]
mov eax, 0FFFFFFFFh
cmp rbx, rax
jz short loc_30255
mov r15, rsi
mov r12, rdi
mov [rbp+var_30], rcx
mov r13, [rdi+28h]
shl rbx, 4
add rbx, r13
loc_3020E:
mov r14d, [rbx]
mov eax, 0FFFFFFFFh
cmp r14, rax
jz short loc_3024B
mov rax, r14
shl rax, 4
lea rbx, [rax+r13]
mov rsi, [r13+rax+8]
mov rdi, r12
mov rdx, r15
mov rcx, [rbp+var_38]
call hashcmp
test eax, eax
jnz short loc_3020E
mov rax, [rbp+var_30]
mov [rax], r14d
mov rax, [rbx+8]
jmp short loc_30257
loc_3024B:
mov rax, [rbp+var_30]
mov dword ptr [rax], 0FFFFFFFFh
loc_30255:
xor eax, eax
loc_30257:
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long my_hash_next(_QWORD *a1, long long a2, long long a3, _DWORD *a4)
{
long long v4; // rbx
long long v5; // r13
unsigned int *v6; // rbx
long long v7; // r14
v4 = (unsigned int)*a4;
if ( v4 != 0xFFFFFFFFLL )
{
v5 = a1[5];
v6 = (unsigned int *)(v5 + 16 * v4);
while ( 1 )
{
v7 = *v6;
if ( v7 == 0xFFFFFFFFLL )
break;
v6 = (unsigned int *)(16 * v7 + v5);
if ( !hashcmp(a1, *((_QWORD *)v6 + 1), a2, a3) )
{
*a4 = v7;
return *((_QWORD *)v6 + 1);
}
}
*a4 = -1;
}
return 0LL;
}
| my_hash_next:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV qword ptr [RBP + -0x38],RDX
MOV EBX,dword ptr [RCX]
MOV EAX,0xffffffff
CMP RBX,RAX
JZ 0x00130255
MOV R15,RSI
MOV R12,RDI
MOV qword ptr [RBP + -0x30],RCX
MOV R13,qword ptr [RDI + 0x28]
SHL RBX,0x4
ADD RBX,R13
LAB_0013020e:
MOV R14D,dword ptr [RBX]
MOV EAX,0xffffffff
CMP R14,RAX
JZ 0x0013024b
MOV RAX,R14
SHL RAX,0x4
LEA RBX,[RAX + R13*0x1]
MOV RSI,qword ptr [R13 + RAX*0x1 + 0x8]
MOV RDI,R12
MOV RDX,R15
MOV RCX,qword ptr [RBP + -0x38]
CALL 0x0013014d
TEST EAX,EAX
JNZ 0x0013020e
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],R14D
MOV RAX,qword ptr [RBX + 0x8]
JMP 0x00130257
LAB_0013024b:
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],0xffffffff
LAB_00130255:
XOR EAX,EAX
LAB_00130257:
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8 my_hash_next(long param_1,int8 param_2,int8 param_3,uint *param_4)
{
uint uVar1;
long lVar2;
int iVar3;
long lVar4;
int8 uVar5;
uint *puVar6;
if ((ulong)*param_4 == 0xffffffff) {
LAB_00130255:
uVar5 = 0;
}
else {
lVar2 = *(long *)(param_1 + 0x28);
puVar6 = (uint *)((ulong)*param_4 * 0x10 + lVar2);
do {
uVar1 = *puVar6;
if ((ulong)uVar1 == 0xffffffff) {
*param_4 = 0xffffffff;
goto LAB_00130255;
}
lVar4 = (ulong)uVar1 * 0x10;
puVar6 = (uint *)(lVar4 + lVar2);
iVar3 = hashcmp(param_1,*(int8 *)(lVar2 + 8 + lVar4),param_2,param_3);
} while (iVar3 != 0);
*param_4 = uVar1;
uVar5 = *(int8 *)(puVar6 + 2);
}
return uVar5;
}
| |
22,224 | OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level() | NVIDIA-RTX[P]OSD-Lite/opensubdiv/vtr/level.cpp | Level::~Level() {
for (int i = 0; i < (int)_fvarChannels.size(); ++i) {
delete _fvarChannels[i];
}
} | O3 | cpp | OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level():
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x1c8(%rdi), %rdi
movq 0x1d0(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x42929
xorl %r15d, %r15d
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x428fd
movq %r14, %rdi
callq 0x39ac0
movl $0xd8, %esi
movq %r14, %rdi
callq 0x3a2b0
incq %r15
movq 0x1c8(%rbx), %rdi
movq 0x1d0(%rbx), %rax
subq %rdi, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jl 0x428ec
testq %rdi, %rdi
je 0x4293d
movq 0x1d8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x1b0(%rbx), %rdi
testq %rdi, %rdi
je 0x42958
movq 0x1c0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x198(%rbx), %rdi
testq %rdi, %rdi
je 0x42973
movq 0x1a8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x180(%rbx), %rdi
testq %rdi, %rdi
je 0x4298e
movq 0x190(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x168(%rbx), %rdi
testq %rdi, %rdi
je 0x429a9
movq 0x178(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x150(%rbx), %rdi
testq %rdi, %rdi
je 0x429c4
movq 0x160(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x138(%rbx), %rdi
testq %rdi, %rdi
je 0x429df
movq 0x148(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x429fa
movq 0x130(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x42a15
movq 0x118(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0xf0(%rbx), %rdi
testq %rdi, %rdi
je 0x42a30
movq 0x100(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0x42a4b
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
je 0x42a66
movq 0xd0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x42a81
movq 0xb8(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x42a9c
movq 0xa0(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x42ab4
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x42ac9
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x42ade
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x42af3
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x3a2b0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x42b0d
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3a2b0
popq %rbx
popq %r14
popq %r15
retq
nop
| _ZN10OpenSubdiv6v3_6_03Vtr8internal5LevelD2Ev:
push r15; Alternative name is 'OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level()'
push r14
push rbx
mov rbx, rdi
mov rdi, [rdi+1C8h]
mov rax, [rbx+1D0h]
sub rax, rdi
shr rax, 3
test eax, eax
jle short loc_42929
xor r15d, r15d
loc_428EC:
mov r14, [rdi+r15*8]
test r14, r14
jz short loc_428FD
mov rdi, r14; this
call __ZN10OpenSubdiv6v3_6_03Vtr8internal9FVarLevelD2Ev; OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel()
loc_428FD:
mov esi, 0D8h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
inc r15
mov rdi, [rbx+1C8h]; void *
mov rax, [rbx+1D0h]
sub rax, rdi
shr rax, 3
cdqe
cmp r15, rax
jl short loc_428EC
loc_42929:
test rdi, rdi
jz short loc_4293D
mov rsi, [rbx+1D8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4293D:
mov rdi, [rbx+1B0h]; void *
test rdi, rdi
jz short loc_42958
mov rsi, [rbx+1C0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42958:
mov rdi, [rbx+198h]; void *
test rdi, rdi
jz short loc_42973
mov rsi, [rbx+1A8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42973:
mov rdi, [rbx+180h]; void *
test rdi, rdi
jz short loc_4298E
mov rsi, [rbx+190h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4298E:
mov rdi, [rbx+168h]; void *
test rdi, rdi
jz short loc_429A9
mov rsi, [rbx+178h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_429A9:
mov rdi, [rbx+150h]; void *
test rdi, rdi
jz short loc_429C4
mov rsi, [rbx+160h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_429C4:
mov rdi, [rbx+138h]; void *
test rdi, rdi
jz short loc_429DF
mov rsi, [rbx+148h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_429DF:
mov rdi, [rbx+120h]; void *
test rdi, rdi
jz short loc_429FA
mov rsi, [rbx+130h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_429FA:
mov rdi, [rbx+108h]; void *
test rdi, rdi
jz short loc_42A15
mov rsi, [rbx+118h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A15:
mov rdi, [rbx+0F0h]; void *
test rdi, rdi
jz short loc_42A30
mov rsi, [rbx+100h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A30:
mov rdi, [rbx+0D8h]; void *
test rdi, rdi
jz short loc_42A4B
mov rsi, [rbx+0E8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A4B:
mov rdi, [rbx+0C0h]; void *
test rdi, rdi
jz short loc_42A66
mov rsi, [rbx+0D0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A66:
mov rdi, [rbx+0A8h]; void *
test rdi, rdi
jz short loc_42A81
mov rsi, [rbx+0B8h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A81:
mov rdi, [rbx+90h]; void *
test rdi, rdi
jz short loc_42A9C
mov rsi, [rbx+0A0h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42A9C:
mov rdi, [rbx+78h]; void *
test rdi, rdi
jz short loc_42AB4
mov rsi, [rbx+88h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42AB4:
mov rdi, [rbx+60h]; void *
test rdi, rdi
jz short loc_42AC9
mov rsi, [rbx+70h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42AC9:
mov rdi, [rbx+48h]; void *
test rdi, rdi
jz short loc_42ADE
mov rsi, [rbx+58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42ADE:
mov rdi, [rbx+30h]; void *
test rdi, rdi
jz short loc_42AF3
mov rsi, [rbx+40h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_42AF3:
mov rdi, [rbx+18h]; void *
test rdi, rdi
jz short loc_42B0D
mov rsi, [rbx+28h]
sub rsi, rdi; unsigned __int64
pop rbx
pop r14
pop r15
jmp __ZdlPvm; operator delete(void *,ulong)
loc_42B0D:
pop rbx
pop r14
pop r15
retn
| void OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level(OpenSubdiv::v3_6_0::Vtr::internal::Level *this)
{
_QWORD *v2; // rdi
long long v3; // r15
void *v4; // r14
void *v5; // rdi
void *v6; // rdi
void *v7; // rdi
void *v8; // rdi
void *v9; // rdi
void *v10; // rdi
void *v11; // rdi
void *v12; // rdi
void *v13; // rdi
void *v14; // rdi
void *v15; // rdi
void *v16; // rdi
void *v17; // rdi
void *v18; // rdi
void *v19; // rdi
void *v20; // rdi
void *v21; // rdi
void *v22; // rdi
v2 = (_QWORD *)*((_QWORD *)this + 57);
if ( (int)((*((_QWORD *)this + 58) - (_QWORD)v2) >> 3) > 0 )
{
v3 = 0LL;
do
{
v4 = (void *)v2[v3];
if ( v4 )
OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel::~FVarLevel((OpenSubdiv::v3_6_0::Vtr::internal::FVarLevel *)v2[v3]);
operator delete(v4, 0xD8uLL);
++v3;
v2 = (_QWORD *)*((_QWORD *)this + 57);
}
while ( v3 < (int)((*((_QWORD *)this + 58) - (_QWORD)v2) >> 3) );
}
if ( v2 )
operator delete(v2, *((_QWORD *)this + 59) - (_QWORD)v2);
v5 = (void *)*((_QWORD *)this + 54);
if ( v5 )
operator delete(v5, *((_QWORD *)this + 56) - (_QWORD)v5);
v6 = (void *)*((_QWORD *)this + 51);
if ( v6 )
operator delete(v6, *((_QWORD *)this + 53) - (_QWORD)v6);
v7 = (void *)*((_QWORD *)this + 48);
if ( v7 )
operator delete(v7, *((_QWORD *)this + 50) - (_QWORD)v7);
v8 = (void *)*((_QWORD *)this + 45);
if ( v8 )
operator delete(v8, *((_QWORD *)this + 47) - (_QWORD)v8);
v9 = (void *)*((_QWORD *)this + 42);
if ( v9 )
operator delete(v9, *((_QWORD *)this + 44) - (_QWORD)v9);
v10 = (void *)*((_QWORD *)this + 39);
if ( v10 )
operator delete(v10, *((_QWORD *)this + 41) - (_QWORD)v10);
v11 = (void *)*((_QWORD *)this + 36);
if ( v11 )
operator delete(v11, *((_QWORD *)this + 38) - (_QWORD)v11);
v12 = (void *)*((_QWORD *)this + 33);
if ( v12 )
operator delete(v12, *((_QWORD *)this + 35) - (_QWORD)v12);
v13 = (void *)*((_QWORD *)this + 30);
if ( v13 )
operator delete(v13, *((_QWORD *)this + 32) - (_QWORD)v13);
v14 = (void *)*((_QWORD *)this + 27);
if ( v14 )
operator delete(v14, *((_QWORD *)this + 29) - (_QWORD)v14);
v15 = (void *)*((_QWORD *)this + 24);
if ( v15 )
operator delete(v15, *((_QWORD *)this + 26) - (_QWORD)v15);
v16 = (void *)*((_QWORD *)this + 21);
if ( v16 )
operator delete(v16, *((_QWORD *)this + 23) - (_QWORD)v16);
v17 = (void *)*((_QWORD *)this + 18);
if ( v17 )
operator delete(v17, *((_QWORD *)this + 20) - (_QWORD)v17);
v18 = (void *)*((_QWORD *)this + 15);
if ( v18 )
operator delete(v18, *((_QWORD *)this + 17) - (_QWORD)v18);
v19 = (void *)*((_QWORD *)this + 12);
if ( v19 )
operator delete(v19, *((_QWORD *)this + 14) - (_QWORD)v19);
v20 = (void *)*((_QWORD *)this + 9);
if ( v20 )
operator delete(v20, *((_QWORD *)this + 11) - (_QWORD)v20);
v21 = (void *)*((_QWORD *)this + 6);
if ( v21 )
operator delete(v21, *((_QWORD *)this + 8) - (_QWORD)v21);
v22 = (void *)*((_QWORD *)this + 3);
if ( v22 )
operator delete(v22, *((_QWORD *)this + 5) - (_QWORD)v22);
}
| ~Level:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x1c8]
MOV RAX,qword ptr [RBX + 0x1d0]
SUB RAX,RDI
SHR RAX,0x3
TEST EAX,EAX
JLE 0x00142929
XOR R15D,R15D
LAB_001428ec:
MOV R14,qword ptr [RDI + R15*0x8]
TEST R14,R14
JZ 0x001428fd
MOV RDI,R14
CALL 0x00139ac0
LAB_001428fd:
MOV ESI,0xd8
MOV RDI,R14
CALL 0x0013a2b0
INC R15
MOV RDI,qword ptr [RBX + 0x1c8]
MOV RAX,qword ptr [RBX + 0x1d0]
SUB RAX,RDI
SHR RAX,0x3
CDQE
CMP R15,RAX
JL 0x001428ec
LAB_00142929:
TEST RDI,RDI
JZ 0x0014293d
MOV RSI,qword ptr [RBX + 0x1d8]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0014293d:
MOV RDI,qword ptr [RBX + 0x1b0]
TEST RDI,RDI
JZ 0x00142958
MOV RSI,qword ptr [RBX + 0x1c0]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142958:
MOV RDI,qword ptr [RBX + 0x198]
TEST RDI,RDI
JZ 0x00142973
MOV RSI,qword ptr [RBX + 0x1a8]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142973:
MOV RDI,qword ptr [RBX + 0x180]
TEST RDI,RDI
JZ 0x0014298e
MOV RSI,qword ptr [RBX + 0x190]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_0014298e:
MOV RDI,qword ptr [RBX + 0x168]
TEST RDI,RDI
JZ 0x001429a9
MOV RSI,qword ptr [RBX + 0x178]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001429a9:
MOV RDI,qword ptr [RBX + 0x150]
TEST RDI,RDI
JZ 0x001429c4
MOV RSI,qword ptr [RBX + 0x160]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001429c4:
MOV RDI,qword ptr [RBX + 0x138]
TEST RDI,RDI
JZ 0x001429df
MOV RSI,qword ptr [RBX + 0x148]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001429df:
MOV RDI,qword ptr [RBX + 0x120]
TEST RDI,RDI
JZ 0x001429fa
MOV RSI,qword ptr [RBX + 0x130]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_001429fa:
MOV RDI,qword ptr [RBX + 0x108]
TEST RDI,RDI
JZ 0x00142a15
MOV RSI,qword ptr [RBX + 0x118]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a15:
MOV RDI,qword ptr [RBX + 0xf0]
TEST RDI,RDI
JZ 0x00142a30
MOV RSI,qword ptr [RBX + 0x100]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a30:
MOV RDI,qword ptr [RBX + 0xd8]
TEST RDI,RDI
JZ 0x00142a4b
MOV RSI,qword ptr [RBX + 0xe8]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a4b:
MOV RDI,qword ptr [RBX + 0xc0]
TEST RDI,RDI
JZ 0x00142a66
MOV RSI,qword ptr [RBX + 0xd0]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a66:
MOV RDI,qword ptr [RBX + 0xa8]
TEST RDI,RDI
JZ 0x00142a81
MOV RSI,qword ptr [RBX + 0xb8]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a81:
MOV RDI,qword ptr [RBX + 0x90]
TEST RDI,RDI
JZ 0x00142a9c
MOV RSI,qword ptr [RBX + 0xa0]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142a9c:
MOV RDI,qword ptr [RBX + 0x78]
TEST RDI,RDI
JZ 0x00142ab4
MOV RSI,qword ptr [RBX + 0x88]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142ab4:
MOV RDI,qword ptr [RBX + 0x60]
TEST RDI,RDI
JZ 0x00142ac9
MOV RSI,qword ptr [RBX + 0x70]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142ac9:
MOV RDI,qword ptr [RBX + 0x48]
TEST RDI,RDI
JZ 0x00142ade
MOV RSI,qword ptr [RBX + 0x58]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142ade:
MOV RDI,qword ptr [RBX + 0x30]
TEST RDI,RDI
JZ 0x00142af3
MOV RSI,qword ptr [RBX + 0x40]
SUB RSI,RDI
CALL 0x0013a2b0
LAB_00142af3:
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x00142b0d
MOV RSI,qword ptr [RBX + 0x28]
SUB RSI,RDI
POP RBX
POP R14
POP R15
JMP 0x0013a2b0
LAB_00142b0d:
POP RBX
POP R14
POP R15
RET
|
/* OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level() */
void __thiscall OpenSubdiv::v3_6_0::Vtr::internal::Level::~Level(Level *this)
{
FVarLevel *this_00;
void *pvVar1;
long lVar2;
pvVar1 = *(void **)(this + 0x1c8);
if (0 < (int)((ulong)(*(long *)(this + 0x1d0) - (long)pvVar1) >> 3)) {
lVar2 = 0;
do {
this_00 = *(FVarLevel **)((long)pvVar1 + lVar2 * 8);
if (this_00 != (FVarLevel *)0x0) {
FVarLevel::~FVarLevel(this_00);
}
operator_delete(this_00,0xd8);
lVar2 = lVar2 + 1;
pvVar1 = *(void **)(this + 0x1c8);
} while (lVar2 < (int)((ulong)(*(long *)(this + 0x1d0) - (long)pvVar1) >> 3));
}
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x1d8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x1b0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x1c0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x198);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x1a8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x180);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 400) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x168);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x178) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x150);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x160) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x138);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x148) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x120);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x130) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x108);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x118) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xf0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x100) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xd8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xe8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xc0);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xd0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0xa8);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xb8) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x90);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0xa0) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x78);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x88) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x60);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x70) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x48);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x58) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x30);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x40) - (long)pvVar1);
}
pvVar1 = *(void **)(this + 0x18);
if (pvVar1 != (void *)0x0) {
operator_delete(pvVar1,*(long *)(this + 0x28) - (long)pvVar1);
return;
}
return;
}
| |
22,225 | exchange_int64s | bluesky950520[P]quickjs/cutils.c | static void exchange_int64s(void *a, void *b, size_t size) {
uint64_t *ap = (uint64_t *)a;
uint64_t *bp = (uint64_t *)b;
for (size /= sizeof(uint64_t); size-- != 0;) {
uint64_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O1 | c | exchange_int64s:
cmpq $0x8, %rdx
jb 0x1c90a
shrq $0x3, %rdx
xorl %eax, %eax
movq (%rdi,%rax,8), %rcx
movq (%rsi,%rax,8), %r8
movq %r8, (%rdi,%rax,8)
movq %rcx, (%rsi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x1c8f2
retq
| exchange_int64s:
cmp rdx, 8
jb short locret_1C90A
shr rdx, 3
xor eax, eax
loc_1C8F2:
mov rcx, [rdi+rax*8]
mov r8, [rsi+rax*8]
mov [rdi+rax*8], r8
mov [rsi+rax*8], rcx
inc rax
cmp rdx, rax
jnz short loc_1C8F2
locret_1C90A:
retn
| void exchange_int64s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
long long v5; // rcx
if ( a3 >= 8 )
{
v3 = a3 >> 3;
v4 = 0LL;
do
{
v5 = *(_QWORD *)(a1 + 8 * v4);
*(_QWORD *)(a1 + 8 * v4) = *(_QWORD *)(a2 + 8 * v4);
*(_QWORD *)(a2 + 8 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| exchange_int64s:
CMP RDX,0x8
JC 0x0011c90a
SHR RDX,0x3
XOR EAX,EAX
LAB_0011c8f2:
MOV RCX,qword ptr [RDI + RAX*0x8]
MOV R8,qword ptr [RSI + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],R8
MOV qword ptr [RSI + RAX*0x8],RCX
INC RAX
CMP RDX,RAX
JNZ 0x0011c8f2
LAB_0011c90a:
RET
|
void exchange_int64s(long param_1,long param_2,ulong param_3)
{
int8 uVar1;
ulong uVar2;
if (7 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int8 *)(param_1 + uVar2 * 8);
*(int8 *)(param_1 + uVar2 * 8) = *(int8 *)(param_2 + uVar2 * 8);
*(int8 *)(param_2 + uVar2 * 8) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 3 != uVar2);
}
return;
}
| |
22,226 | exchange_int64s | bluesky950520[P]quickjs/cutils.c | static void exchange_int64s(void *a, void *b, size_t size) {
uint64_t *ap = (uint64_t *)a;
uint64_t *bp = (uint64_t *)b;
for (size /= sizeof(uint64_t); size-- != 0;) {
uint64_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O2 | c | exchange_int64s:
shrq $0x3, %rdx
xorl %eax, %eax
cmpq %rax, %rdx
je 0x16f16
movq (%rdi,%rax,8), %rcx
movq (%rsi,%rax,8), %r8
movq %r8, (%rdi,%rax,8)
movq %rcx, (%rsi,%rax,8)
incq %rax
jmp 0x16efc
retq
| exchange_int64s:
shr rdx, 3
xor eax, eax
loc_16EFC:
cmp rdx, rax
jz short locret_16F16
mov rcx, [rdi+rax*8]
mov r8, [rsi+rax*8]
mov [rdi+rax*8], r8
mov [rsi+rax*8], rcx
inc rax
jmp short loc_16EFC
locret_16F16:
retn
| long long exchange_int64s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long result; // rax
long long v5; // rcx
v3 = a3 >> 3;
for ( result = 0LL; v3 != result; ++result )
{
v5 = *(_QWORD *)(a1 + 8 * result);
*(_QWORD *)(a1 + 8 * result) = *(_QWORD *)(a2 + 8 * result);
*(_QWORD *)(a2 + 8 * result) = v5;
}
return result;
}
| exchange_int64s:
SHR RDX,0x3
XOR EAX,EAX
LAB_00116efc:
CMP RDX,RAX
JZ 0x00116f16
MOV RCX,qword ptr [RDI + RAX*0x8]
MOV R8,qword ptr [RSI + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],R8
MOV qword ptr [RSI + RAX*0x8],RCX
INC RAX
JMP 0x00116efc
LAB_00116f16:
RET
|
void exchange_int64s(long param_1,long param_2,ulong param_3)
{
int8 uVar1;
ulong uVar2;
for (uVar2 = 0; param_3 >> 3 != uVar2; uVar2 = uVar2 + 1) {
uVar1 = *(int8 *)(param_1 + uVar2 * 8);
*(int8 *)(param_1 + uVar2 * 8) = *(int8 *)(param_2 + uVar2 * 8);
*(int8 *)(param_2 + uVar2 * 8) = uVar1;
}
return;
}
| |
22,227 | exchange_int64s | bluesky950520[P]quickjs/cutils.c | static void exchange_int64s(void *a, void *b, size_t size) {
uint64_t *ap = (uint64_t *)a;
uint64_t *bp = (uint64_t *)b;
for (size /= sizeof(uint64_t); size-- != 0;) {
uint64_t t = *ap;
*ap++ = *bp;
*bp++ = t;
}
} | O3 | c | exchange_int64s:
cmpq $0x8, %rdx
jb 0x1d208
shrq $0x3, %rdx
xorl %eax, %eax
movq (%rdi,%rax,8), %rcx
movq (%rsi,%rax,8), %r8
movq %r8, (%rdi,%rax,8)
movq %rcx, (%rsi,%rax,8)
incq %rax
cmpq %rax, %rdx
jne 0x1d1f0
retq
| exchange_int64s:
cmp rdx, 8
jb short locret_1D208
shr rdx, 3
xor eax, eax
loc_1D1F0:
mov rcx, [rdi+rax*8]
mov r8, [rsi+rax*8]
mov [rdi+rax*8], r8
mov [rsi+rax*8], rcx
inc rax
cmp rdx, rax
jnz short loc_1D1F0
locret_1D208:
retn
| void exchange_int64s(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rdx
long long v4; // rax
long long v5; // rcx
if ( a3 >= 8 )
{
v3 = a3 >> 3;
v4 = 0LL;
do
{
v5 = *(_QWORD *)(a1 + 8 * v4);
*(_QWORD *)(a1 + 8 * v4) = *(_QWORD *)(a2 + 8 * v4);
*(_QWORD *)(a2 + 8 * v4++) = v5;
}
while ( v3 != v4 );
}
}
| exchange_int64s:
CMP RDX,0x8
JC 0x0011d208
SHR RDX,0x3
XOR EAX,EAX
LAB_0011d1f0:
MOV RCX,qword ptr [RDI + RAX*0x8]
MOV R8,qword ptr [RSI + RAX*0x8]
MOV qword ptr [RDI + RAX*0x8],R8
MOV qword ptr [RSI + RAX*0x8],RCX
INC RAX
CMP RDX,RAX
JNZ 0x0011d1f0
LAB_0011d208:
RET
|
void exchange_int64s(long param_1,long param_2,ulong param_3)
{
int8 uVar1;
ulong uVar2;
if (7 < param_3) {
uVar2 = 0;
do {
uVar1 = *(int8 *)(param_1 + uVar2 * 8);
*(int8 *)(param_1 + uVar2 * 8) = *(int8 *)(param_2 + uVar2 * 8);
*(int8 *)(param_2 + uVar2 * 8) = uVar1;
uVar2 = uVar2 + 1;
} while (param_3 >> 3 != uVar2);
}
return;
}
| |
22,228 | GL_Program::add_uniform(char const*) | untodesu[P]voxelius/game/client/program.cc | std::size_t GL_Program::add_uniform(const char *name)
{
for(std::size_t i = 0; i < uniforms.size(); ++i) {
if(uniforms[i].name.compare(name))
continue;
return i;
}
const std::size_t index = uniforms.size();
uniforms.push_back(GL_Uniform());
uniforms[index].location = -1;
uniforms[index].name = name;
return index;
} | O2 | cpp | GL_Program::add_uniform(char const*):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r12
leaq 0xa0(%rdi), %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0xa0(%r12), %rdi
movq 0xa8(%r12), %r13
subq %rdi, %r13
movq %r13, %rax
cqto
pushq $0x28
popq %rcx
idivq %rcx
cmpq %rax, %r15
jae 0x59aed
addq %r14, %rdi
movq %rbx, %rsi
callq 0x26210
testl %eax, %eax
je 0x59b3d
incq %r15
addq $0x28, %r14
jmp 0x59ab2
movq %rax, %rbp
leaq 0x20(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5a82a
leaq 0x10(%rsp), %rdi
callq 0x272a8
movq (%r14), %rax
leaq (%rax,%r13), %rdi
orl $-0x1, 0x20(%rax,%r13)
movq %rbx, %rsi
callq 0x271c0
movq %rbp, %r15
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x272a8
movq %rbx, %rdi
callq 0x27040
| _ZN10GL_Program11add_uniformEPKc:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 38h
mov rbx, rsi
mov r12, rdi
lea rax, [rdi+0A0h]
mov [rsp+68h+var_60], rax
xor r14d, r14d
xor r15d, r15d
loc_59AB2:
mov rdi, [r12+0A0h]
mov r13, [r12+0A8h]
sub r13, rdi
mov rax, r13
cqo
push 28h ; '('
pop rcx
idiv rcx
cmp r15, rax
jnb short loc_59AED
add rdi, r14
mov rsi, rbx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_59B3D
inc r15
add r14, 28h ; '('
jmp short loc_59AB2
loc_59AED:
mov rbp, rax
lea rax, [rsp+68h+var_48]
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
and qword ptr [rax+10h], 0
mov [rax-10h], rax
and qword ptr [rax-8], 0
lea rsi, [rsp+68h+var_58]
mov r14, [rsp+68h+var_60]
mov rdi, r14
call _ZNSt6vectorI10GL_UniformSaIS0_EE12emplace_backIJS0_EEERS0_DpOT_; std::vector<GL_Uniform>::emplace_back<GL_Uniform>(GL_Uniform &&)
lea rdi, [rsp+68h+var_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, [r14]
lea rdi, [rax+r13]
or dword ptr [rax+r13+20h], 0FFFFFFFFh
mov rsi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6assignEPKc; std::string::assign(char const*)
mov r15, rbp
loc_59B3D:
mov rax, r15
add rsp, 38h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
| unsigned long long GL_Program::add_uniform(GL_Program *this, const char *a2)
{
long long v3; // r14
unsigned long long i; // r15
long long v5; // rdi
long long v6; // r13
long long v7; // rdx
long long v8; // rbp
long long v9; // rdi
long long v10; // rdx
long long v11; // rcx
long long v12; // r8
long long v13; // r9
_QWORD *v15; // [rsp+8h] [rbp-60h]
_QWORD v16[2]; // [rsp+10h] [rbp-58h] BYREF
__int128 v17; // [rsp+20h] [rbp-48h] BYREF
long long v18; // [rsp+30h] [rbp-38h]
v15 = (_QWORD *)((char *)this + 160);
v3 = 0LL;
for ( i = 0LL; ; ++i )
{
v5 = *((_QWORD *)this + 20);
v6 = *((_QWORD *)this + 21) - v5;
v7 = v6 % 40;
if ( i >= v6 / 40 )
break;
if ( !(unsigned int)std::string::compare(v3 + v5, a2, v7) )
return i;
v3 += 40LL;
}
v8 = (*((_QWORD *)this + 21) - v5) / 40;
v17 = 0LL;
v18 = 0LL;
v16[0] = &v17;
v16[1] = 0LL;
std::vector<GL_Uniform>::emplace_back<GL_Uniform>(v15, v16, v7);
std::string::~string(v16);
v9 = *v15 + v6;
*(_DWORD *)(v9 + 32) = -1;
std::string::assign(v9, a2, v10, v11, v12, v13);
return v8;
}
| add_uniform:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x38
MOV RBX,RSI
MOV R12,RDI
LEA RAX,[RDI + 0xa0]
MOV qword ptr [RSP + 0x8],RAX
XOR R14D,R14D
XOR R15D,R15D
LAB_00159ab2:
MOV RDI,qword ptr [R12 + 0xa0]
MOV R13,qword ptr [R12 + 0xa8]
SUB R13,RDI
MOV RAX,R13
CQO
PUSH 0x28
POP RCX
IDIV RCX
CMP R15,RAX
JNC 0x00159aed
ADD RDI,R14
MOV RSI,RBX
CALL 0x00126210
TEST EAX,EAX
JZ 0x00159b3d
INC R15
ADD R14,0x28
JMP 0x00159ab2
LAB_00159aed:
MOV RBP,RAX
LEA RAX,[RSP + 0x20]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
AND qword ptr [RAX + 0x10],0x0
MOV qword ptr [RAX + -0x10],RAX
AND qword ptr [RAX + -0x8],0x0
LAB_00159b09:
LEA RSI,[RSP + 0x10]
MOV R14,qword ptr [RSP + 0x8]
MOV RDI,R14
CALL 0x0015a82a
LAB_00159b1b:
LEA RDI,[RSP + 0x10]
CALL 0x001272a8
MOV RAX,qword ptr [R14]
LEA RDI,[RAX + R13*0x1]
OR dword ptr [RAX + R13*0x1 + 0x20],0xffffffff
MOV RSI,RBX
CALL 0x001271c0
MOV R15,RBP
LAB_00159b3d:
MOV RAX,R15
ADD RSP,0x38
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* GL_Program::add_uniform(char const*) */
ulong GL_Program::add_uniform(char *param_1)
{
int iVar1;
long lVar2;
long lVar3;
ulong uVar4;
int8 *local_58;
int8 local_50;
int8 local_48;
int8 uStack_40;
int8 local_38;
lVar3 = 0;
uVar4 = 0;
while( true ) {
lVar2 = *(long *)(param_1 + 0xa8) - *(long *)(param_1 + 0xa0);
if ((ulong)(lVar2 / 0x28) <= uVar4) {
local_58 = &local_48;
local_48 = 0;
uStack_40 = 0;
local_38 = 0;
local_50 = 0;
/* try { // try from 00159b09 to 00159b1a has its CatchHandler @ 00159b4f */
std::vector<GL_Uniform,std::allocator<GL_Uniform>>::emplace_back<GL_Uniform>
((vector<GL_Uniform,std::allocator<GL_Uniform>> *)(param_1 + 0xa0),
(GL_Uniform *)&local_58);
std::__cxx11::string::~string((string *)&local_58);
lVar3 = *(long *)(param_1 + 0xa0);
*(int4 *)(lVar3 + 0x20 + lVar2) = 0xffffffff;
std::__cxx11::string::assign((char *)(lVar3 + lVar2));
return lVar2 / 0x28;
}
iVar1 = std::__cxx11::string::compare((char *)(*(long *)(param_1 + 0xa0) + lVar3));
if (iVar1 == 0) break;
uVar4 = uVar4 + 1;
lVar3 = lVar3 + 0x28;
}
return uVar4;
}
| |
22,229 | mysql_real_query@libmariadbclient_18 | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int STDCALL
mysql_real_query(MYSQL *mysql, const char *query, unsigned long length)
{
my_bool skip_result= OPT_EXT_VAL(mysql, multi_command);
if (length == (unsigned long)-1)
length= (unsigned long)strlen(query);
free_old_query(mysql);
if (ma_simple_command(mysql, COM_QUERY,query,length,1,0))
return(-1);
if (!skip_result && !mysql->options.extension->skip_read_response)
return(mysql->methods->db_read_query_result(mysql));
return(0);
} | O0 | c | mysql_real_query@libmariadbclient_18:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x27bd0
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movsbl 0xa8(%rax), %eax
cmpl $0x0, %eax
je 0x27bd0
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
movsbl 0xa8(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x27bd7
xorl %eax, %eax
movl %eax, -0x28(%rbp)
jmp 0x27bd7
movl -0x28(%rbp), %eax
movb %al, -0x21(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0x27bf1
movq -0x18(%rbp), %rdi
callq 0x17250
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28d00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x3, %esi
movl $0x1, %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x219b0
cmpl $0x0, %eax
je 0x27c29
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27c64
cmpb $0x0, -0x21(%rbp)
jne 0x27c5d
movq -0x10(%rbp), %rax
movq 0x480(%rax), %rax
cmpb $0x0, 0x148(%rax)
jne 0x27c5d
movq -0x10(%rbp), %rax
movq 0x4d0(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x27c64
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| mysql_real_query@libmariadbclient_18:
push rbp; Alternative name is 'mysql_real_query'
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_27BD0
mov rax, [rbp+var_10]
mov rax, [rax+480h]
movsx eax, byte ptr [rax+0A8h]
cmp eax, 0
jz short loc_27BD0
mov rax, [rbp+var_10]
mov rax, [rax+480h]
movsx eax, byte ptr [rax+0A8h]
mov [rbp+var_28], eax
jmp short loc_27BD7
loc_27BD0:
xor eax, eax
mov [rbp+var_28], eax
jmp short $+2
loc_27BD7:
mov eax, [rbp+var_28]
mov [rbp+var_21], al
cmp [rbp+var_20], 0FFFFFFFFFFFFFFFFh
jnz short loc_27BF1
mov rdi, [rbp+var_18]
call _strlen
mov [rbp+var_20], rax
loc_27BF1:
mov rdi, [rbp+var_10]
call free_old_query
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov esi, 3
mov r8d, 1
xor eax, eax
mov r9d, eax
call ma_simple_command
cmp eax, 0
jz short loc_27C29
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_27C64
loc_27C29:
cmp [rbp+var_21], 0
jnz short loc_27C5D
mov rax, [rbp+var_10]
mov rax, [rax+480h]
cmp byte ptr [rax+148h], 0
jnz short loc_27C5D
mov rax, [rbp+var_10]
mov rax, [rax+4D0h]
mov rax, [rax+20h]
mov rdi, [rbp+var_10]
call rax
mov [rbp+var_4], eax
jmp short loc_27C64
loc_27C5D:
mov [rbp+var_4], 0
loc_27C64:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long mysql_real_query_libmariadbclient_18(long long a1, long long a2, long long a3)
{
char v4; // [rsp+8h] [rbp-28h]
long long v5; // [rsp+10h] [rbp-20h]
v5 = a3;
if ( *(_QWORD *)(a1 + 1152) && *(_BYTE *)(*(_QWORD *)(a1 + 1152) + 168LL) )
v4 = *(_BYTE *)(*(_QWORD *)(a1 + 1152) + 168LL);
else
v4 = 0;
if ( a3 == -1 )
v5 = strlen(a2);
free_old_query(a1);
if ( (unsigned int)ma_simple_command(a1, 3u, a2, v5, 1, 0LL) )
{
return (unsigned int)-1;
}
else if ( v4 || *(_BYTE *)(*(_QWORD *)(a1 + 1152) + 328LL) )
{
return 0;
}
else
{
return (unsigned int)(*(long long ( **)(long long))(*(_QWORD *)(a1 + 1232) + 32LL))(a1);
}
}
| mysql_real_query:
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 RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x00127bd0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOVSX EAX,byte ptr [RAX + 0xa8]
CMP EAX,0x0
JZ 0x00127bd0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
MOVSX EAX,byte ptr [RAX + 0xa8]
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00127bd7
LAB_00127bd0:
XOR EAX,EAX
MOV dword ptr [RBP + -0x28],EAX
JMP 0x00127bd7
LAB_00127bd7:
MOV EAX,dword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0x21],AL
CMP qword ptr [RBP + -0x20],-0x1
JNZ 0x00127bf1
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00117250
MOV qword ptr [RBP + -0x20],RAX
LAB_00127bf1:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00128d00
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV ESI,0x3
MOV R8D,0x1
XOR EAX,EAX
MOV R9D,EAX
CALL 0x001219b0
CMP EAX,0x0
JZ 0x00127c29
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x00127c64
LAB_00127c29:
CMP byte ptr [RBP + -0x21],0x0
JNZ 0x00127c5d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x480]
CMP byte ptr [RAX + 0x148],0x0
JNZ 0x00127c5d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00127c64
LAB_00127c5d:
MOV dword ptr [RBP + -0x4],0x0
LAB_00127c64:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 mysql_real_query(long param_1,char *param_2,size_t param_3)
{
char cVar1;
int iVar2;
int8 local_28;
int4 local_c;
if ((*(long *)(param_1 + 0x480) == 0) || (*(char *)(*(long *)(param_1 + 0x480) + 0xa8) == '\0')) {
cVar1 = '\0';
}
else {
cVar1 = *(char *)(*(long *)(param_1 + 0x480) + 0xa8);
}
local_28 = param_3;
if (param_3 == 0xffffffffffffffff) {
local_28 = strlen(param_2);
}
free_old_query(param_1);
iVar2 = ma_simple_command(param_1,3,param_2,local_28,1,0);
if (iVar2 == 0) {
if ((cVar1 == '\0') && (*(char *)(*(long *)(param_1 + 0x480) + 0x148) == '\0')) {
local_c = (**(code **)(*(long *)(param_1 + 0x4d0) + 0x20))(param_1);
}
else {
local_c = 0;
}
}
else {
local_c = 0xffffffff;
}
return local_c;
}
| |
22,230 | common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&) | monkey531[P]llama/common/chat.cpp | static common_chat_params common_chat_params_init_deepseek_r1(const common_chat_template & tmpl, const struct common_chat_inputs & inputs) {
common_chat_params data;
data.grammar_lazy = inputs.tool_choice != "required";
data.grammar = build_grammar([&](const common_grammar_builder & builder) {
std::vector<std::string> tool_rules;
foreach_function(inputs.tools, [&](const json & tool) {
const auto & function = tool["function"];
std::string name = function["name"];
auto parameters = function["parameters"];
auto args_rule = builder.add_schema(name + "-args", parameters);
tool_rules.push_back(builder.add_rule(name + "-call",
"\"<｜tool▁call▁begin｜>function<｜tool▁sep｜>" + name + "\\n```json\\n\" " + args_rule + " \"```<｜tool▁call▁end｜>\""));
});
data.grammar_triggers.push_back({"<｜tool▁calls▁begin｜>", /* .at_start = */ false});
data.preserved_tokens = {
"<｜tool▁sep｜>",
"<｜tool▁call▁end｜>",
};
builder.add_rule("root", "\"<｜tool▁calls▁begin｜>\" (" + string_join(tool_rules, " | ") + ")" + (inputs.parallel_tool_calls ? "*" : "") + " space");
}, grammar_options);
data.prompt = tmpl.apply(inputs.messages, inputs.tools.empty() ? json() : inputs.tools, inputs.add_generation_prompt);
data.format = COMMON_CHAT_FORMAT_DEEPSEEK_R1;
return data;
} | O1 | cpp | common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorl %eax, %eax
movb %al, 0x8(%rdi)
movq %rax, 0x10(%rdi)
leaq 0x28(%rdi), %rcx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movb %al, 0x28(%rdi)
movb %al, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movq %rax, 0x80(%rdi)
leaq 0x20(%rdx), %rdi
leaq 0x1f444(%rip), %rsi # 0xf2902
callq 0xa6ec1
movb %al, 0x38(%rbx)
leaq 0x10(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0xd447(%rip), %rax # 0xe092a
movq %rax, 0x18(%rsi)
leaq 0xdad8(%rip), %rax # 0xe0fc6
movq %rax, 0x10(%rsi)
leaq 0x2534f(%rip), %rdx # 0xf8848
leaq 0x38(%rsp), %rdi
callq 0xbd146
leaq 0x18(%rbx), %rdi
leaq 0x38(%rsp), %r12
movq %r12, %rsi
callq 0x1bab0
movq (%r12), %rdi
leaq 0x48(%rsp), %r12
cmpq %r12, %rdi
je 0xd352f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8e0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd3548
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movzbl 0x10(%r14), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0xd3572
movq 0x18(%r14), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0xd3576
leaq 0x10(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0x5e6fe
jmp 0xd3584
testl %eax, %eax
jne 0xd3562
movb $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movzbl 0x68(%r14), %r8d
leaq 0x58(%rsp), %r9
movb $0x0, (%r9)
movq $0x0, 0x8(%r9)
movl $0x1, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rcx
movq %r15, %rsi
movq %r14, %rdx
callq 0xa3580
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x812a8
movb 0x8(%rbx), %al
leaq 0x68(%rsp), %rdi
movb (%rdi), %cl
movb %cl, 0x8(%rbx)
movb %al, (%rdi)
movq 0x10(%rbx), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rbx)
movq %rax, 0x8(%rdi)
callq 0x5ec5e
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xd3600
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8e0
leaq 0x58(%rsp), %rdi
callq 0x5ec5e
leaq 0x10(%rsp), %rdi
callq 0x5ec5e
movl $0x5, (%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0xd3681
jmp 0xd3691
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xd364f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x1b8e0
jmp 0xd364f
movq %rax, %r14
leaq 0x58(%rsp), %rdi
callq 0x5ec5e
leaq 0x10(%rsp), %rdi
callq 0x5ec5e
jmp 0xd3681
movq %rax, %r14
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xd3681
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x7fd42
movq %r14, %rdi
callq 0x1bf90
movq %rax, %rdi
callq 0x231d1
| _ZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputs:
push r15
push r14
push r12
push rbx
sub rsp, 78h
mov r14, rdx
mov r15, rsi
mov rbx, rdi
mov dword ptr [rdi], 0
xor eax, eax
mov [rdi+8], al
mov [rdi+10h], rax
lea rcx, [rdi+28h]
mov [rdi+18h], rcx
mov [rdi+20h], rax
mov [rdi+28h], al
mov [rdi+38h], al
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+60h], xmm0
movups xmmword ptr [rdi+70h], xmm0
mov [rdi+80h], rax
lea rdi, [rdx+20h]
lea rsi, aRequired; "required"
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
mov [rbx+38h], al
lea rsi, [rsp+98h+var_88]
xorps xmm0, xmm0
movaps xmmword ptr [rsi], xmm0
movaps xmmword ptr [rsi+10h], xmm0
mov [rsi], r14
mov [rsi+8], rbx
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rsi+18h], rax
lea rax, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZL35common_chat_params_init_deepseek_r1RKN5minja13chat_templateERK18common_chat_inputsE3$_0E10_M_managerERSt9_Any_dataRKSD_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsi+10h], rax
lea rdx, _ZL15grammar_options; grammar_options
lea rdi, [rsp+98h+var_60]
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
lea rdi, [rbx+18h]
lea r12, [rsp+98h+var_60]
mov rsi, r12
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEOS4_; std::string::operator=(std::string&&)
mov rdi, [r12]; void *
lea r12, [rsp+98h+var_50]
cmp rdi, r12
jz short loc_D352F
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D352F:
mov rax, [rsp+98h+var_78]
test rax, rax
jz short loc_D3548
lea rdi, [rsp+98h+var_88]
mov rsi, rdi
mov edx, 3
call rax
loc_D3548:
movzx eax, byte ptr [r14+10h]
lea ecx, [rax-1]
cmp ecx, 2
jnb short loc_D3572
mov rax, [r14+18h]
mov rcx, [rax]
cmp rcx, [rax+8]
jz short loc_D3576
loc_D3562:
lea rsi, [r14+10h]
lea rdi, [rsp+98h+var_88]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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> const&)
jmp short loc_D3584
loc_D3572:
test eax, eax
jnz short loc_D3562
loc_D3576:
mov [rsp+98h+var_88], 0
mov [rsp+98h+var_80], 0
loc_D3584:
movzx r8d, byte ptr [r14+68h]
lea r9, [rsp+98h+var_40]
mov byte ptr [r9], 0
mov qword ptr [r9+8], 0
mov [rsp+98h+var_98], 1
lea rdi, [rsp+98h+var_60]
lea rcx, [rsp+98h+var_88]
mov rsi, r15
mov rdx, r14
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)
lea rdi, [rsp+98h+var_30]
lea rsi, [rsp+98h+var_60]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
mov al, [rbx+8]
lea rdi, [rsp+98h+var_30]
mov cl, [rdi]
mov [rbx+8], cl
mov [rdi], al
mov rax, [rbx+10h]
mov rcx, [rdi+8]
mov [rbx+10h], rcx
mov [rdi+8], rax
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rsp+98h+var_60]; void *
cmp rdi, r12
jz short loc_D3600
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_D3600:
lea rdi, [rsp+98h+var_40]
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()
lea rdi, [rsp+98h+var_88]
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 dword ptr [rbx], 5
mov rax, rbx
add rsp, 78h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
jmp short loc_D3681
jmp short loc_D3691
mov r14, rax
mov rdi, [rsp+98h+var_60]; void *
cmp rdi, r12
jz short loc_D364F
mov rsi, [rsp+98h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D364F
mov r14, rax
loc_D364F:
lea rdi, [rsp+98h+var_40]
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()
lea rdi, [rsp+98h+var_88]
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_D3681
mov r14, rax
mov rax, [rsp+98h+var_78]
test rax, rax
jz short loc_D3681
lea rdi, [rsp+98h+var_88]
mov rsi, rdi
mov edx, 3
call rax
loc_D3681:
mov rdi, rbx; this
call _ZN18common_chat_paramsD2Ev; common_chat_params::~common_chat_params()
mov rdi, r14
call __Unwind_Resume
loc_D3691:
mov rdi, rax
call __clang_call_terminate
| const minja::chat_template * common_chat_params_init_deepseek_r1(
const minja::chat_template *a1,
const common_chat_inputs *a2,
long long a3)
{
long long v4; // rcx
int v5; // r8d
int v6; // r9d
int v7; // r8d
char v8; // al
long long v9; // rax
long long v11; // [rsp+10h] [rbp-88h] BYREF
const minja::chat_template *v12; // [rsp+18h] [rbp-80h]
long long ( *v13)(); // [rsp+20h] [rbp-78h]
long long ( *v14)(); // [rsp+28h] [rbp-70h]
void *v15[2]; // [rsp+38h] [rbp-60h] BYREF
_QWORD v16[2]; // [rsp+48h] [rbp-50h] BYREF
unsigned __int8 v17[8]; // [rsp+58h] [rbp-40h] BYREF
long long v18; // [rsp+60h] [rbp-38h]
char v19[8]; // [rsp+68h] [rbp-30h] BYREF
long long v20; // [rsp+70h] [rbp-28h]
*(_DWORD *)a1 = 0;
*((_BYTE *)a1 + 8) = 0;
*((_QWORD *)a1 + 2) = 0LL;
*((_QWORD *)a1 + 3) = (char *)a1 + 40;
*((_QWORD *)a1 + 4) = 0LL;
*((_BYTE *)a1 + 40) = 0;
*((_BYTE *)a1 + 56) = 0;
*((_OWORD *)a1 + 4) = 0LL;
*((_OWORD *)a1 + 5) = 0LL;
*((_OWORD *)a1 + 6) = 0LL;
*((_OWORD *)a1 + 7) = 0LL;
*((_QWORD *)a1 + 16) = 0LL;
*((_BYTE *)a1 + 56) = ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
a3 + 32,
(long long)"required");
v11 = a3;
v12 = a1;
v14 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_invoke;
v13 = std::_Function_handler<void ()(common_grammar_builder const&),common_chat_params_init_deepseek_r1(minja::chat_template const&,common_chat_inputs const&)::$_0>::_M_manager;
build_grammar[abi:cxx11]((long long)v15, (long long)&v11, grammar_options, v4, v5, v6);
std::string::operator=((char *)a1 + 24, v15);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
if ( v13 )
((void ( *)(long long *, long long *, long long))v13)(&v11, &v11, 3LL);
if ( (unsigned int)*(unsigned __int8 *)(a3 + 16) - 1 >= 2 )
{
if ( *(_BYTE *)(a3 + 16) )
goto LABEL_7;
}
else if ( **(_QWORD **)(a3 + 24) != *(_QWORD *)(*(_QWORD *)(a3 + 24) + 8LL) )
{
LABEL_7:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
(unsigned __int8 *)&v11,
(unsigned __int8 *)(a3 + 16));
goto LABEL_10;
}
LOBYTE(v11) = 0;
v12 = 0LL;
LABEL_10:
v7 = *(unsigned __int8 *)(a3 + 104);
v17[0] = 0;
v18 = 0LL;
minja::chat_template::apply((long long)v15, a2, (unsigned __int8 *)a3, (unsigned __int8 *)&v11, v7, v17, 1);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_(v19);
v8 = *((_BYTE *)a1 + 8);
*((_BYTE *)a1 + 8) = v19[0];
v19[0] = v8;
v9 = *((_QWORD *)a1 + 2);
*((_QWORD *)a1 + 2) = v20;
v20 = 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>::data::~data(v19);
if ( v15[0] != v16 )
operator delete(v15[0], v16[0] + 1LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(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>::data::~data(&v11);
*(_DWORD *)a1 = 5;
return a1;
}
| common_chat_params_init_deepseek_r1:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
MOV dword ptr [RDI],0x0
XOR EAX,EAX
MOV byte ptr [RDI + 0x8],AL
MOV qword ptr [RDI + 0x10],RAX
LEA RCX,[RDI + 0x28]
MOV qword ptr [RDI + 0x18],RCX
MOV qword ptr [RDI + 0x20],RAX
MOV byte ptr [RDI + 0x28],AL
MOV byte ptr [RDI + 0x38],AL
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x60],XMM0
MOVUPS xmmword ptr [RDI + 0x70],XMM0
MOV qword ptr [RDI + 0x80],RAX
LEA RDI,[RDX + 0x20]
LEA RSI,[0x1f2902]
CALL 0x001a6ec1
MOV byte ptr [RBX + 0x38],AL
LEA RSI,[RSP + 0x10]
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSI],XMM0
MOVAPS xmmword ptr [RSI + 0x10],XMM0
MOV qword ptr [RSI],R14
MOV qword ptr [RSI + 0x8],RBX
LEA RAX,[0x1e092a]
MOV qword ptr [RSI + 0x18],RAX
LEA RAX,[0x1e0fc6]
MOV qword ptr [RSI + 0x10],RAX
LAB_001d34f2:
LEA RDX,[0x1f8848]
LEA RDI,[RSP + 0x38]
CALL 0x001bd146
LEA RDI,[RBX + 0x18]
LEA R12,[RSP + 0x38]
MOV RSI,R12
CALL 0x0011bab0
MOV RDI,qword ptr [R12]
LEA R12,[RSP + 0x48]
CMP RDI,R12
JZ 0x001d352f
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b8e0
LAB_001d352f:
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x001d3548
LAB_001d3539:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001d3548:
MOVZX EAX,byte ptr [R14 + 0x10]
LEA ECX,[RAX + -0x1]
CMP ECX,0x2
JNC 0x001d3572
MOV RAX,qword ptr [R14 + 0x18]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
JZ 0x001d3576
LAB_001d3562:
LEA RSI,[R14 + 0x10]
LEA RDI,[RSP + 0x10]
CALL 0x0015e6fe
JMP 0x001d3584
LAB_001d3572:
TEST EAX,EAX
JNZ 0x001d3562
LAB_001d3576:
MOV byte ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
LAB_001d3584:
MOVZX R8D,byte ptr [R14 + 0x68]
LEA R9,[RSP + 0x58]
MOV byte ptr [R9],0x0
MOV qword ptr [R9 + 0x8],0x0
LAB_001d359a:
MOV dword ptr [RSP],0x1
LEA RDI,[RSP + 0x38]
LEA RCX,[RSP + 0x10]
MOV RSI,R15
MOV RDX,R14
CALL 0x001a3580
LAB_001d35b6:
LEA RDI,[RSP + 0x68]
LEA RSI,[RSP + 0x38]
CALL 0x001812a8
MOV AL,byte ptr [RBX + 0x8]
LEA RDI,[RSP + 0x68]
MOV CL,byte ptr [RDI]
MOV byte ptr [RBX + 0x8],CL
MOV byte ptr [RDI],AL
MOV RAX,qword ptr [RBX + 0x10]
MOV RCX,qword ptr [RDI + 0x8]
MOV qword ptr [RBX + 0x10],RCX
MOV qword ptr [RDI + 0x8],RAX
CALL 0x0015ec5e
MOV RDI,qword ptr [RSP + 0x38]
CMP RDI,R12
JZ 0x001d3600
MOV RSI,qword ptr [RSP + 0x48]
INC RSI
CALL 0x0011b8e0
LAB_001d3600:
LEA RDI,[RSP + 0x58]
CALL 0x0015ec5e
LEA RDI,[RSP + 0x10]
CALL 0x0015ec5e
MOV dword ptr [RBX],0x5
MOV RAX,RBX
ADD RSP,0x78
POP RBX
POP R12
POP R14
POP R15
RET
|
/* common_chat_params_init_deepseek_r1(minja::chat_template const&, common_chat_inputs const&) */
chat_template *
common_chat_params_init_deepseek_r1(chat_template *param_1,common_chat_inputs *param_2)
{
int8 uVar1;
chat_template cVar2;
ulong in_RDX;
ulong local_88;
chat_template *pcStack_80;
code *local_78;
code *pcStack_70;
long *local_60 [2];
long local_50 [2];
data local_40 [8];
int8 local_38;
chat_template local_30 [8];
int8 local_28;
*(int4 *)param_1 = 0;
param_1[8] = (chat_template)0x0;
*(int8 *)(param_1 + 0x10) = 0;
*(chat_template **)(param_1 + 0x18) = param_1 + 0x28;
*(int8 *)(param_1 + 0x20) = 0;
param_1[0x28] = (chat_template)0x0;
param_1[0x38] = (chat_template)0x0;
*(int8 *)(param_1 + 0x40) = 0;
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)(param_1 + 0x50) = 0;
*(int8 *)(param_1 + 0x58) = 0;
*(int8 *)(param_1 + 0x60) = 0;
*(int8 *)(param_1 + 0x68) = 0;
*(int8 *)(param_1 + 0x70) = 0;
*(int8 *)(param_1 + 0x78) = 0;
*(int8 *)(param_1 + 0x80) = 0;
cVar2 = (chat_template)
_ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(in_RDX + 0x20,"required");
param_1[0x38] = cVar2;
pcStack_70 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_invoke;
local_78 = std::
_Function_handler<void(common_grammar_builder_const&),common_chat_params_init_deepseek_r1(minja::chat_template_const&,common_chat_inputs_const&)::$_0>
::_M_manager;
/* try { // try from 001d34f2 to 001d3502 has its CatchHandler @ 001d3665 */
local_88 = in_RDX;
pcStack_80 = param_1;
build_grammar_abi_cxx11_((function *)local_60,(common_grammar_options *)&local_88);
std::__cxx11::string::operator=((string *)(param_1 + 0x18),(string *)local_60);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
if (local_78 != (code *)0x0) {
/* try { // try from 001d3539 to 001d3547 has its CatchHandler @ 001d362e */
(*local_78)(&local_88,&local_88,3);
}
if (*(byte *)(in_RDX + 0x10) - 1 < 2) {
if (**(long **)(in_RDX + 0x18) == (*(long **)(in_RDX + 0x18))[1]) {
LAB_001d3576:
local_88 = local_88 & 0xffffffffffffff00;
pcStack_80 = (chat_template *)0x0;
goto LAB_001d3584;
}
}
else if (*(byte *)(in_RDX + 0x10) == 0) goto LAB_001d3576;
/* try { // try from 001d3562 to 001d356f has its CatchHandler @ 001d3629 */
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_88,(basic_json *)(in_RDX + 0x10));
LAB_001d3584:
local_40[0] = (data)0x0;
local_38 = 0;
/* try { // try from 001d359a to 001d35b5 has its CatchHandler @ 001d364c */
minja::chat_template::apply
((basic_json *)local_60,(basic_json *)param_2,SUB81(in_RDX,0),(basic_json *)&local_88,
*(bool *)(in_RDX + 0x68));
/* try { // try from 001d35b6 to 001d35c4 has its CatchHandler @ 001d3630 */
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SG_EE5valueEiE4typeELi0EEEOT_
(local_30,local_60);
cVar2 = param_1[8];
param_1[8] = local_30[0];
uVar1 = *(int8 *)(param_1 + 0x10);
*(int8 *)(param_1 + 0x10) = local_28;
local_30[0] = cVar2;
local_28 = uVar1;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_30);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_40);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_88);
*(int4 *)param_1 = 5;
return param_1;
}
| |
22,231 | LefDefParser::lefiPin::addAntennaMetalArea(double, char const*) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiPin::addAntennaMetalArea(double val,
const char *layer)
{
int len;
if (numAntennaMetalArea_ == antennaMetalAreaAllocated_) {
int i;
int max;
int lim = numAntennaMetalArea_;
double *nd;
char **nl;
if (antennaMetalAreaAllocated_ == 0)
max = antennaMetalAreaAllocated_ = 2;
else
max = antennaMetalAreaAllocated_ *= 2;
nd = (double*) lefMalloc(sizeof(double) * max);
nl = (char**) lefMalloc(sizeof(double) * max);
for (i = 0; i < lim; i++) {
nl[i] = antennaMetalAreaLayer_[i];
nd[i] = antennaMetalArea_[i];
}
lefFree((char*) (antennaMetalAreaLayer_));
lefFree((char*) (antennaMetalArea_));
antennaMetalAreaLayer_ = nl;
antennaMetalArea_ = nd;
}
antennaMetalArea_[numAntennaMetalArea_] = val;
if (layer) { // layer can be null, since it is optional
len = strlen(layer) + 1;
antennaMetalAreaLayer_[numAntennaMetalArea_] =
(char*) lefMalloc(len);
strcpy(antennaMetalAreaLayer_[numAntennaMetalArea_],
layer);
} else
antennaMetalAreaLayer_[numAntennaMetalArea_] = NULL;
numAntennaMetalArea_ += 1;
} | O3 | cpp | LefDefParser::lefiPin::addAntennaMetalArea(double, char const*):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x198(%rdi), %r13d
cmpl 0x19c(%rdi), %r13d
jne 0x2a518
movsd %xmm0, 0x8(%rsp)
leal (,%r13,2), %eax
testl %r13d, %r13d
movl $0x2, %ecx
cmovnel %eax, %ecx
movl %ecx, 0x19c(%rbx)
movslq %ecx, %r12
shlq $0x3, %r12
movq %r12, %rdi
callq 0x24985
movq %rax, %r15
movq %r12, %rdi
callq 0x24985
movq %rax, %r12
testl %r13d, %r13d
jle 0x2a4e3
xorl %eax, %eax
movq 0x1a8(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, (%r12,%rax,8)
movq 0x1a0(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x2a4ba
movq 0x1a8(%rbx), %rdi
callq 0x26040
movq 0x1a0(%rbx), %rdi
callq 0x26040
movq %r12, 0x1a8(%rbx)
movq %r15, 0x1a0(%rbx)
movl 0x198(%rbx), %r13d
movsd 0x8(%rsp), %xmm0
jmp 0x2a51f
movq 0x1a0(%rbx), %r15
movslq %r13d, %rax
movsd %xmm0, (%r15,%rax,8)
testq %r14, %r14
je 0x2a56d
movq %r14, %rdi
callq 0x20d0
incl %eax
movslq %eax, %rdi
callq 0x24985
movq 0x1a8(%rbx), %rcx
movslq 0x198(%rbx), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1a8(%rbx), %rax
movq (%rax,%rdx,8), %rdi
movq %r14, %rsi
callq 0x21b0
movl 0x198(%rbx), %r13d
jmp 0x2a57c
movq 0x1a8(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incl %r13d
movl %r13d, 0x198(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| _ZN12LefDefParser7lefiPin19addAntennaMetalAreaEdPKc:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r14, rsi
mov rbx, rdi
mov r13d, [rdi+198h]
cmp r13d, [rdi+19Ch]
jnz loc_2A518
movsd [rsp+38h+var_30], xmm0
lea eax, ds:0[r13*2]
test r13d, r13d
mov ecx, 2
cmovnz ecx, eax
mov [rbx+19Ch], ecx
movsxd r12, ecx
shl r12, 3
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r15, rax
mov rdi, r12; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov r12, rax
test r13d, r13d
jle short loc_2A4E3
xor eax, eax
loc_2A4BA:
mov rcx, [rbx+1A8h]
mov rcx, [rcx+rax*8]
mov [r12+rax*8], rcx
mov rcx, [rbx+1A0h]
movsd xmm0, qword ptr [rcx+rax*8]
movsd qword ptr [r15+rax*8], xmm0
inc rax
cmp r13, rax
jnz short loc_2A4BA
loc_2A4E3:
mov rdi, [rbx+1A8h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rdi, [rbx+1A0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov [rbx+1A8h], r12
mov [rbx+1A0h], r15
mov r13d, [rbx+198h]
movsd xmm0, [rsp+38h+var_30]
jmp short loc_2A51F
loc_2A518:
mov r15, [rbx+1A0h]
loc_2A51F:
movsxd rax, r13d
movsd qword ptr [r15+rax*8], xmm0
test r14, r14
jz short loc_2A56D
mov rdi, r14
call _strlen
inc eax
movsxd rdi, eax; this
call _ZN12LefDefParser9lefMallocEm; LefDefParser::lefMalloc(ulong)
mov rcx, [rbx+1A8h]
movsxd rdx, dword ptr [rbx+198h]
mov [rcx+rdx*8], rax
mov rax, [rbx+1A8h]
mov rdi, [rax+rdx*8]
mov rsi, r14
call _strcpy
mov r13d, [rbx+198h]
jmp short loc_2A57C
loc_2A56D:
mov rcx, [rbx+1A8h]
mov qword ptr [rcx+rax*8], 0
loc_2A57C:
inc r13d
mov [rbx+198h], r13d
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
| long long LefDefParser::lefiPin::addAntennaMetalArea(LefDefParser::lefiPin *this, double a2, char *a3)
{
long long v3; // r13
int v4; // ecx
LefDefParser *v5; // r12
long long v6; // r15
long long v7; // r12
long long i; // rax
long long result; // rax
int v10; // eax
long long v11; // rax
long long v12; // rdx
v3 = *((unsigned int *)this + 102);
if ( (_DWORD)v3 == *((_DWORD *)this + 103) )
{
v4 = 2;
if ( (_DWORD)v3 )
v4 = 2 * v3;
*((_DWORD *)this + 103) = v4;
v5 = (LefDefParser *)(8LL * v4);
v6 = LefDefParser::lefMalloc(v5);
v7 = LefDefParser::lefMalloc(v5);
if ( (int)v3 > 0 )
{
for ( i = 0LL; i != v3; ++i )
{
*(_QWORD *)(v7 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 53) + 8 * i);
*(_QWORD *)(v6 + 8 * i) = *(_QWORD *)(*((_QWORD *)this + 52) + 8 * i);
}
}
LefDefParser::lefFree(*((LefDefParser **)this + 53), a3);
LefDefParser::lefFree(*((LefDefParser **)this + 52), a3);
*((_QWORD *)this + 53) = v7;
*((_QWORD *)this + 52) = v6;
LODWORD(v3) = *((_DWORD *)this + 102);
}
else
{
v6 = *((_QWORD *)this + 52);
}
result = (int)v3;
*(double *)(v6 + 8LL * (int)v3) = a2;
if ( a3 )
{
v10 = strlen(a3);
v11 = LefDefParser::lefMalloc((LefDefParser *)(v10 + 1));
v12 = *((int *)this + 102);
*(_QWORD *)(*((_QWORD *)this + 53) + 8 * v12) = v11;
result = strcpy(*(_QWORD *)(*((_QWORD *)this + 53) + 8 * v12), a3);
LODWORD(v3) = *((_DWORD *)this + 102);
}
else
{
*(_QWORD *)(*((_QWORD *)this + 53) + 8LL * (int)v3) = 0LL;
}
*((_DWORD *)this + 102) = v3 + 1;
return result;
}
| addAntennaMetalArea:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14,RSI
MOV RBX,RDI
MOV R13D,dword ptr [RDI + 0x198]
CMP R13D,dword ptr [RDI + 0x19c]
JNZ 0x0012a518
MOVSD qword ptr [RSP + 0x8],XMM0
LEA EAX,[R13*0x2]
TEST R13D,R13D
MOV ECX,0x2
CMOVNZ ECX,EAX
MOV dword ptr [RBX + 0x19c],ECX
MOVSXD R12,ECX
SHL R12,0x3
MOV RDI,R12
CALL 0x00124985
MOV R15,RAX
MOV RDI,R12
CALL 0x00124985
MOV R12,RAX
TEST R13D,R13D
JLE 0x0012a4e3
XOR EAX,EAX
LAB_0012a4ba:
MOV RCX,qword ptr [RBX + 0x1a8]
MOV RCX,qword ptr [RCX + RAX*0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
MOV RCX,qword ptr [RBX + 0x1a0]
MOVSD XMM0,qword ptr [RCX + RAX*0x8]
MOVSD qword ptr [R15 + RAX*0x8],XMM0
INC RAX
CMP R13,RAX
JNZ 0x0012a4ba
LAB_0012a4e3:
MOV RDI,qword ptr [RBX + 0x1a8]
CALL 0x00126040
MOV RDI,qword ptr [RBX + 0x1a0]
CALL 0x00126040
MOV qword ptr [RBX + 0x1a8],R12
MOV qword ptr [RBX + 0x1a0],R15
MOV R13D,dword ptr [RBX + 0x198]
MOVSD XMM0,qword ptr [RSP + 0x8]
JMP 0x0012a51f
LAB_0012a518:
MOV R15,qword ptr [RBX + 0x1a0]
LAB_0012a51f:
MOVSXD RAX,R13D
MOVSD qword ptr [R15 + RAX*0x8],XMM0
TEST R14,R14
JZ 0x0012a56d
MOV RDI,R14
CALL 0x001020d0
INC EAX
MOVSXD RDI,EAX
CALL 0x00124985
MOV RCX,qword ptr [RBX + 0x1a8]
MOVSXD RDX,dword ptr [RBX + 0x198]
MOV qword ptr [RCX + RDX*0x8],RAX
MOV RAX,qword ptr [RBX + 0x1a8]
MOV RDI,qword ptr [RAX + RDX*0x8]
MOV RSI,R14
CALL 0x001021b0
MOV R13D,dword ptr [RBX + 0x198]
JMP 0x0012a57c
LAB_0012a56d:
MOV RCX,qword ptr [RBX + 0x1a8]
MOV qword ptr [RCX + RAX*0x8],0x0
LAB_0012a57c:
INC R13D
MOV dword ptr [RBX + 0x198],R13D
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* LefDefParser::lefiPin::addAntennaMetalArea(double, char const*) */
void __thiscall
LefDefParser::lefiPin::addAntennaMetalArea(lefiPin *this,double param_1,char *param_2)
{
long lVar1;
long lVar2;
ulong uVar3;
size_t sVar4;
int8 uVar5;
int iVar6;
char *pcVar7;
uint uVar8;
uVar8 = *(uint *)(this + 0x198);
pcVar7 = param_2;
if (uVar8 == *(uint *)(this + 0x19c)) {
iVar6 = 2;
if (uVar8 != 0) {
iVar6 = uVar8 * 2;
}
*(int *)(this + 0x19c) = iVar6;
lVar1 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)param_2);
lVar2 = lefMalloc((LefDefParser *)((long)iVar6 << 3),(ulong)pcVar7);
if (0 < (int)uVar8) {
uVar3 = 0;
do {
*(int8 *)(lVar2 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1a8) + uVar3 * 8);
*(int8 *)(lVar1 + uVar3 * 8) = *(int8 *)(*(long *)(this + 0x1a0) + uVar3 * 8);
uVar3 = uVar3 + 1;
} while (uVar8 != uVar3);
}
lefFree(*(void **)(this + 0x1a8));
lefFree(*(void **)(this + 0x1a0));
*(long *)(this + 0x1a8) = lVar2;
*(long *)(this + 0x1a0) = lVar1;
uVar8 = *(uint *)(this + 0x198);
}
else {
lVar1 = *(long *)(this + 0x1a0);
}
*(double *)(lVar1 + (long)(int)uVar8 * 8) = param_1;
if (param_2 == (char *)0x0) {
*(int8 *)(*(long *)(this + 0x1a8) + (long)(int)uVar8 * 8) = 0;
}
else {
sVar4 = strlen(param_2);
uVar5 = lefMalloc((LefDefParser *)(long)((int)sVar4 + 1),(ulong)pcVar7);
iVar6 = *(int *)(this + 0x198);
*(int8 *)(*(long *)(this + 0x1a8) + (long)iVar6 * 8) = uVar5;
strcpy(*(char **)(*(long *)(this + 0x1a8) + (long)iVar6 * 8),param_2);
uVar8 = *(uint *)(this + 0x198);
}
*(uint *)(this + 0x198) = uVar8 + 1;
return;
}
| |
22,232 | LefDefParser::lefiNonDefault::layerResistance(int) const | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiNonDefault.cpp | double
lefiNonDefault::layerResistance(int index) const
{
char msg[160];
if (index < 0 || index >= numLayers_) {
sprintf(msg, "ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d", index, numLayers_);
lefiError(0, 1402, msg);
return 0.0;
}
return resistance_[index];
} | O0 | cpp | LefDefParser::lefiNonDefault::layerResistance(int) const:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movl %esi, 0xb4(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0xb4(%rsp)
jl 0x470fe
movq 0x8(%rsp), %rcx
movl 0xb4(%rsp), %eax
cmpl 0x10(%rcx), %eax
jl 0x4713f
movq 0x8(%rsp), %rax
leaq 0x10(%rsp), %rdi
movl 0xb4(%rsp), %edx
movl 0x10(%rax), %ecx
leaq 0x4f561(%rip), %rsi # 0x9667a
movb $0x0, %al
callq 0x2050
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movl $0x57a, %esi # imm = 0x57A
callq 0x59060
xorps %xmm0, %xmm0
movsd %xmm0, 0xc0(%rsp)
jmp 0x4715e
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0xb4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nop
| _ZNK12LefDefParser14lefiNonDefault15layerResistanceEi:
sub rsp, 0C8h
mov [rsp+0C8h+var_10], rdi
mov [rsp+0C8h+var_14], esi
mov rax, [rsp+0C8h+var_10]
mov [rsp+0C8h+var_C0], rax
cmp [rsp+0C8h+var_14], 0
jl short loc_470FE
mov rcx, [rsp+0C8h+var_C0]
mov eax, [rsp+0C8h+var_14]
cmp eax, [rcx+10h]
jl short loc_4713F
loc_470FE:
mov rax, [rsp+0C8h+var_C0]
lea rdi, [rsp+0C8h+var_B8]
mov edx, [rsp+0C8h+var_14]
mov ecx, [rax+10h]
lea rsi, aErrorLefpars14_3; "ERROR (LEFPARS-1402): The index number "...
mov al, 0
call _sprintf
lea rdx, [rsp+0C8h+var_B8]; int
xor edi, edi; this
mov esi, 57Ah; int
call _ZN12LefDefParser9lefiErrorEiiPKc; LefDefParser::lefiError(int,int,char const*)
xorps xmm0, xmm0
movsd [rsp+0C8h+var_8], xmm0
jmp short loc_4715E
loc_4713F:
mov rax, [rsp+0C8h+var_C0]
mov rax, [rax+50h]
movsxd rcx, [rsp+0C8h+var_14]
movsd xmm0, qword ptr [rax+rcx*8]
movsd [rsp+0C8h+var_8], xmm0
loc_4715E:
movsd xmm0, [rsp+0C8h+var_8]
add rsp, 0C8h
retn
| double LefDefParser::lefiNonDefault::layerResistance(LefDefParser::lefiNonDefault *this, int a2)
{
const char *v2; // rcx
int v4[41]; // [rsp+10h] [rbp-B8h] BYREF
int v5; // [rsp+B4h] [rbp-14h]
LefDefParser::lefiNonDefault *v6; // [rsp+B8h] [rbp-10h]
v6 = this;
v5 = a2;
if ( a2 >= 0 && v5 < *((_DWORD *)this + 4) )
return *(double *)(*((_QWORD *)this + 10) + 8LL * v5);
sprintf(
v4,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d",
v5,
*((_DWORD *)this + 4));
LefDefParser::lefiError(0LL, 1402, (int)v4, v2);
return 0.0;
}
| layerResistance:
SUB RSP,0xc8
MOV qword ptr [RSP + 0xb8],RDI
MOV dword ptr [RSP + 0xb4],ESI
MOV RAX,qword ptr [RSP + 0xb8]
MOV qword ptr [RSP + 0x8],RAX
CMP dword ptr [RSP + 0xb4],0x0
JL 0x001470fe
MOV RCX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RSP + 0xb4]
CMP EAX,dword ptr [RCX + 0x10]
JL 0x0014713f
LAB_001470fe:
MOV RAX,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xb4]
MOV ECX,dword ptr [RAX + 0x10]
LEA RSI,[0x19667a]
MOV AL,0x0
CALL 0x00102050
LEA RDX,[RSP + 0x10]
XOR EDI,EDI
MOV ESI,0x57a
CALL 0x00159060
XORPS XMM0,XMM0
MOVSD qword ptr [RSP + 0xc0],XMM0
JMP 0x0014715e
LAB_0014713f:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x50]
MOVSXD RCX,dword ptr [RSP + 0xb4]
MOVSD XMM0,qword ptr [RAX + RCX*0x8]
MOVSD qword ptr [RSP + 0xc0],XMM0
LAB_0014715e:
MOVSD XMM0,qword ptr [RSP + 0xc0]
ADD RSP,0xc8
RET
|
/* LefDefParser::lefiNonDefault::layerResistance(int) const */
int8 __thiscall
LefDefParser::lefiNonDefault::layerResistance(lefiNonDefault *this,int param_1)
{
char local_b8 [164];
int local_14;
lefiNonDefault *local_10;
int8 local_8;
if ((param_1 < 0) || (*(int *)(this + 0x10) <= param_1)) {
local_14 = param_1;
local_10 = this;
sprintf(local_b8,
"ERROR (LEFPARS-1402): The index number %d given for the NONDEFAULT LAYER is invalid.\nValid index is from 0 to %d"
,(ulong)(uint)param_1,(ulong)*(uint *)(this + 0x10));
lefiError(0,0x57a,local_b8);
local_8 = 0;
}
else {
local_8 = *(int8 *)(*(long *)(this + 0x50) + (long)param_1 * 8);
}
return local_8;
}
| |
22,233 | init_tree | eloqsql/mysys/tree.c | void init_tree(TREE *tree, size_t default_alloc_size, size_t memory_limit,
int size, qsort_cmp2 compare,
tree_element_free free_element, void *custom_arg,
myf my_flags)
{
DBUG_ENTER("init_tree");
DBUG_PRINT("enter",("tree: %p size: %d", tree, size));
if (default_alloc_size < DEFAULT_ALLOC_SIZE)
default_alloc_size= DEFAULT_ALLOC_SIZE;
default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
tree->root= &null_element;
tree->compare=compare;
tree->size_of_element= size > 0 ? (uint) size : 0;
tree->memory_limit=memory_limit;
tree->free=free_element;
tree->allocated=0;
tree->elements_in_tree=0;
tree->custom_arg = custom_arg;
tree->my_flags= my_flags;
tree->flag= 0;
if (!free_element && size >= 0 &&
((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
{
/*
We know that the data doesn't have to be aligned (like if the key
contains a double), so we can store the data combined with the
TREE_ELEMENT.
*/
tree->offset_to_key=sizeof(TREE_ELEMENT); /* Put key after element */
/* Fix allocation size so that we don't lose any memory */
default_alloc_size/=(sizeof(TREE_ELEMENT)+size);
if (!default_alloc_size)
default_alloc_size=1;
default_alloc_size*=(sizeof(TREE_ELEMENT)+size);
}
else
{
tree->offset_to_key=0; /* use key through pointer */
tree->size_of_element+=sizeof(void*);
}
if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE)))
{
init_alloc_root(key_memory_TREE, &tree->mem_root, default_alloc_size, 0,
MYF(my_flags));
tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element;
}
DBUG_VOID_RETURN;
} | O0 | c | init_tree:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0xf9919
cmpq $0x2000, -0x10(%rbp) # imm = 0x2000
jae 0xf992b
movq $0x2000, -0x10(%rbp) # imm = 0x2000
movq -0x10(%rbp), %rax
addq $0x2000, %rax # imm = 0x2000
subq $0x1, %rax
andq $-0x2000, %rax # imm = 0xE000
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1c52f2(%rip), %rcx # 0x2bec40
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x228(%rax)
cmpl $0x0, -0x1c(%rbp)
jle 0xf996e
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0xf9975
xorl %eax, %eax
movl %eax, -0x34(%rbp)
jmp 0xf9975
movl -0x34(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x210(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x218(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x280(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x220(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20c(%rax)
movq 0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x230(%rax)
movq 0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x288(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x290(%rax)
cmpq $0x0, -0x30(%rbp)
jne 0xf9a51
cmpl $0x0, -0x1c(%rbp)
jl 0xf9a51
movl -0x1c(%rbp), %eax
cmpq $0x8, %rax
jbe 0xf9a0c
movl -0x1c(%rbp), %eax
andq $0x7, %rax
cmpq $0x0, %rax
je 0xf9a51
movq -0x8(%rbp), %rax
movl $0x18, 0x208(%rax)
movslq -0x1c(%rbp), %rcx
addq $0x18, %rcx
movq -0x10(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf9a3e
movq $0x1, -0x10(%rbp)
movslq -0x1c(%rbp), %rax
addq $0x18, %rax
imulq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xf9a73
movq -0x8(%rbp), %rax
movl $0x0, 0x208(%rax)
movq -0x8(%rbp), %rax
movl 0x210(%rax), %ecx
addq $0x8, %rcx
movl %ecx, 0x210(%rax)
movq 0x18(%rbp), %rdx
andq $0x40000, %rdx # imm = 0x40000
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movq -0x8(%rbp), %rcx
movb %al, 0x278(%rcx)
cmpb $0x0, %al
jne 0xf9ada
leaq 0xb881cb(%rip), %rax # 0xc81c6c
movl (%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x238, %rsi # imm = 0x238
movq -0x10(%rbp), %rdx
movq 0x18(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0xec770
movq -0x8(%rbp), %rax
movl 0x210(%rax), %eax
movl %eax, %ecx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x250(%rax)
jmp 0xf9adc
jmp 0xf9ade
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| init_tree:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_1C], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
jmp short $+2
loc_F9919:
cmp [rbp+var_10], 2000h
jnb short loc_F992B
mov [rbp+var_10], 2000h
loc_F992B:
mov rax, [rbp+var_10]
add rax, 2000h
sub rax, 1
and rax, 0FFFFFFFFFFFFE000h
mov [rbp+var_10], rax
mov rax, [rbp+var_8]
lea rcx, null_element
mov [rax], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+var_8]
mov [rax+228h], rcx
cmp [rbp+var_1C], 0
jle short loc_F996E
mov eax, [rbp+var_1C]
mov [rbp+var_34], eax
jmp short loc_F9975
loc_F996E:
xor eax, eax
mov [rbp+var_34], eax
jmp short $+2
loc_F9975:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_8]
mov [rax+210h], ecx
mov rcx, [rbp+var_18]
mov rax, [rbp+var_8]
mov [rax+218h], rcx
mov rcx, [rbp+var_30]
mov rax, [rbp+var_8]
mov [rax+280h], rcx
mov rax, [rbp+var_8]
mov qword ptr [rax+220h], 0
mov rax, [rbp+var_8]
mov dword ptr [rax+20Ch], 0
mov rcx, [rbp+arg_0]
mov rax, [rbp+var_8]
mov [rax+230h], rcx
mov rcx, [rbp+arg_8]
mov rax, [rbp+var_8]
mov [rax+288h], rcx
mov rax, [rbp+var_8]
mov dword ptr [rax+290h], 0
cmp [rbp+var_30], 0
jnz short loc_F9A51
cmp [rbp+var_1C], 0
jl short loc_F9A51
mov eax, [rbp+var_1C]
cmp rax, 8
jbe short loc_F9A0C
mov eax, [rbp+var_1C]
and rax, 7
cmp rax, 0
jz short loc_F9A51
loc_F9A0C:
mov rax, [rbp+var_8]
mov dword ptr [rax+208h], 18h
movsxd rcx, [rbp+var_1C]
add rcx, 18h
mov rax, [rbp+var_10]
xor edx, edx
div rcx
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
jnz short loc_F9A3E
mov [rbp+var_10], 1
loc_F9A3E:
movsxd rax, [rbp+var_1C]
add rax, 18h
imul rax, [rbp+var_10]
mov [rbp+var_10], rax
jmp short loc_F9A73
loc_F9A51:
mov rax, [rbp+var_8]
mov dword ptr [rax+208h], 0
mov rax, [rbp+var_8]
mov ecx, [rax+210h]
add rcx, 8
mov [rax+210h], ecx
loc_F9A73:
mov rdx, [rbp+arg_8]
and rdx, 40000h
xor eax, eax
mov ecx, 1
cmp rdx, 0
cmovnz eax, ecx
mov rcx, [rbp+var_8]
mov [rcx+278h], al
cmp al, 0
jnz short loc_F9ADA
lea rax, key_memory_TREE
mov edi, [rax]
mov rsi, [rbp+var_8]
add rsi, 238h
mov rdx, [rbp+var_10]
mov r8, [rbp+arg_8]
xor eax, eax
mov ecx, eax
call init_alloc_root
mov rax, [rbp+var_8]
mov eax, [rax+210h]
mov ecx, eax
add rcx, 18h
mov rax, [rbp+var_8]
mov [rax+250h], rcx
loc_F9ADA:
jmp short $+2
loc_F9ADC:
jmp short $+2
loc_F9ADE:
add rsp, 40h
pop rbp
retn
| _BOOL8 init_tree(
long long a1,
unsigned long long a2,
long long a3,
int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
_BOOL8 result; // rax
int v9; // [rsp+Ch] [rbp-34h]
long long v10; // [rsp+30h] [rbp-10h]
unsigned long long v11; // [rsp+30h] [rbp-10h]
unsigned long long v12; // [rsp+30h] [rbp-10h]
v10 = a2;
if ( a2 < 0x2000 )
v10 = 0x2000LL;
v11 = (v10 + 0x1FFF) & 0xFFFFFFFFFFFFE000LL;
*(_QWORD *)a1 = &null_element;
*(_QWORD *)(a1 + 552) = a5;
if ( a4 <= 0 )
v9 = 0;
else
v9 = a4;
*(_DWORD *)(a1 + 528) = v9;
*(_QWORD *)(a1 + 536) = a3;
*(_QWORD *)(a1 + 640) = a6;
*(_QWORD *)(a1 + 544) = 0LL;
*(_DWORD *)(a1 + 524) = 0;
*(_QWORD *)(a1 + 560) = a7;
*(_QWORD *)(a1 + 648) = a8;
*(_DWORD *)(a1 + 656) = 0;
if ( a6 || a4 < 0 || (unsigned int)a4 > 8uLL && (a4 & 7) == 0 )
{
*(_DWORD *)(a1 + 520) = 0;
*(_DWORD *)(a1 + 528) += 8;
}
else
{
*(_DWORD *)(a1 + 520) = 24;
v12 = v11 / (a4 + 24LL);
if ( !v12 )
v12 = 1LL;
v11 = v12 * (a4 + 24LL);
}
result = (a8 & 0x40000) != 0;
*(_BYTE *)(a1 + 632) = result;
if ( (a8 & 0x40000) == 0 )
{
init_alloc_root(key_memory_TREE, (long long *)(a1 + 568), v11, 0LL, a8);
result = a1;
*(_QWORD *)(a1 + 592) = *(unsigned int *)(a1 + 528) + 24LL;
}
return result;
}
| init_tree:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
JMP 0x001f9919
LAB_001f9919:
CMP qword ptr [RBP + -0x10],0x2000
JNC 0x001f992b
MOV qword ptr [RBP + -0x10],0x2000
LAB_001f992b:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x2000
SUB RAX,0x1
AND RAX,-0x2000
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x3bec40]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x228],RCX
CMP dword ptr [RBP + -0x1c],0x0
JLE 0x001f996e
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001f9975
LAB_001f996e:
XOR EAX,EAX
MOV dword ptr [RBP + -0x34],EAX
JMP 0x001f9975
LAB_001f9975:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x210],ECX
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x218],RCX
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x280],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x220],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x20c],0x0
MOV RCX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x230],RCX
MOV RCX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x288],RCX
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x290],0x0
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001f9a51
CMP dword ptr [RBP + -0x1c],0x0
JL 0x001f9a51
MOV EAX,dword ptr [RBP + -0x1c]
CMP RAX,0x8
JBE 0x001f9a0c
MOV EAX,dword ptr [RBP + -0x1c]
AND RAX,0x7
CMP RAX,0x0
JZ 0x001f9a51
LAB_001f9a0c:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x208],0x18
MOVSXD RCX,dword ptr [RBP + -0x1c]
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x10]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
JNZ 0x001f9a3e
MOV qword ptr [RBP + -0x10],0x1
LAB_001f9a3e:
MOVSXD RAX,dword ptr [RBP + -0x1c]
ADD RAX,0x18
IMUL RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f9a73
LAB_001f9a51:
MOV RAX,qword ptr [RBP + -0x8]
MOV dword ptr [RAX + 0x208],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x210]
ADD RCX,0x8
MOV dword ptr [RAX + 0x210],ECX
LAB_001f9a73:
MOV RDX,qword ptr [RBP + 0x18]
AND RDX,0x40000
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,0x0
CMOVNZ EAX,ECX
MOV RCX,qword ptr [RBP + -0x8]
MOV byte ptr [RCX + 0x278],AL
CMP AL,0x0
JNZ 0x001f9ada
LEA RAX,[0xd81c6c]
MOV EDI,dword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x8]
ADD RSI,0x238
MOV RDX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RBP + 0x18]
XOR EAX,EAX
MOV ECX,EAX
CALL 0x001ec770
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX + 0x210]
MOV ECX,EAX
ADD RCX,0x18
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x250],RCX
LAB_001f9ada:
JMP 0x001f9adc
LAB_001f9adc:
JMP 0x001f9ade
LAB_001f9ade:
ADD RSP,0x40
POP RBP
RET
|
void init_tree(int8 *param_1,ulong param_2,int8 param_3,uint param_4,int8 param_5,
long param_6,int8 param_7,ulong param_8)
{
bool bVar1;
uint local_3c;
ulong local_18;
local_18 = param_2;
if (param_2 < 0x2000) {
local_18 = 0x2000;
}
local_18 = local_18 + 0x1fff & 0xffffffffffffe000;
*param_1 = null_element;
param_1[0x45] = param_5;
local_3c = param_4;
if ((int)param_4 < 1) {
local_3c = 0;
}
*(uint *)(param_1 + 0x42) = local_3c;
param_1[0x43] = param_3;
param_1[0x50] = param_6;
param_1[0x44] = 0;
*(int4 *)((long)param_1 + 0x20c) = 0;
param_1[0x46] = param_7;
param_1[0x51] = param_8;
*(int4 *)(param_1 + 0x52) = 0;
if (((param_6 == 0) && (-1 < (int)param_4)) && ((param_4 < 9 || ((param_4 & 7) != 0)))) {
*(int4 *)(param_1 + 0x41) = 0x18;
local_18 = local_18 / ((long)(int)param_4 + 0x18U);
if (local_18 == 0) {
local_18 = 1;
}
local_18 = ((long)(int)param_4 + 0x18) * local_18;
}
else {
*(int4 *)(param_1 + 0x41) = 0;
*(int *)(param_1 + 0x42) = *(int *)(param_1 + 0x42) + 8;
}
bVar1 = (param_8 & 0x40000) != 0;
*(bool *)(param_1 + 0x4f) = bVar1;
if (!bVar1) {
init_alloc_root(key_memory_TREE,param_1 + 0x47,local_18,0,param_8);
param_1[0x4a] = (ulong)*(uint *)(param_1 + 0x42) + 0x18;
}
return;
}
| |
22,234 | init_tree | eloqsql/mysys/tree.c | void init_tree(TREE *tree, size_t default_alloc_size, size_t memory_limit,
int size, qsort_cmp2 compare,
tree_element_free free_element, void *custom_arg,
myf my_flags)
{
DBUG_ENTER("init_tree");
DBUG_PRINT("enter",("tree: %p size: %d", tree, size));
if (default_alloc_size < DEFAULT_ALLOC_SIZE)
default_alloc_size= DEFAULT_ALLOC_SIZE;
default_alloc_size= MY_ALIGN(default_alloc_size, DEFAULT_ALIGN_SIZE);
tree->root= &null_element;
tree->compare=compare;
tree->size_of_element= size > 0 ? (uint) size : 0;
tree->memory_limit=memory_limit;
tree->free=free_element;
tree->allocated=0;
tree->elements_in_tree=0;
tree->custom_arg = custom_arg;
tree->my_flags= my_flags;
tree->flag= 0;
if (!free_element && size >= 0 &&
((uint) size <= sizeof(void*) || ((uint) size & (sizeof(void*)-1))))
{
/*
We know that the data doesn't have to be aligned (like if the key
contains a double), so we can store the data combined with the
TREE_ELEMENT.
*/
tree->offset_to_key=sizeof(TREE_ELEMENT); /* Put key after element */
/* Fix allocation size so that we don't lose any memory */
default_alloc_size/=(sizeof(TREE_ELEMENT)+size);
if (!default_alloc_size)
default_alloc_size=1;
default_alloc_size*=(sizeof(TREE_ELEMENT)+size);
}
else
{
tree->offset_to_key=0; /* use key through pointer */
tree->size_of_element+=sizeof(void*);
}
if (!(tree->with_delete= MY_TEST(my_flags & MY_TREE_WITH_DELETE)))
{
init_alloc_root(key_memory_TREE, &tree->mem_root, default_alloc_size, 0,
MYF(my_flags));
tree->mem_root.min_malloc= sizeof(TREE_ELEMENT)+tree->size_of_element;
}
DBUG_VOID_RETURN;
} | O3 | c | init_tree:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rdi, %rbx
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %rdi
cmpq $0x2001, %rsi # imm = 0x2001
movl $0x2000, %r10d # imm = 0x2000
cmovaeq %rsi, %r10
addq $0x1fff, %r10 # imm = 0x1FFF
andq $-0x2000, %r10 # imm = 0xE000
leaq 0x2e0c82(%rip), %rsi # 0x384bc0
movq %rsi, (%rbx)
movq %rax, 0x228(%rbx)
testq %r9, %r9
setne %sil
xorl %r11d, %r11d
testl %ecx, %ecx
movl $0x0, %eax
cmovgl %ecx, %eax
movl %eax, 0x210(%rbx)
movq %rdx, 0x218(%rbx)
movq %r9, 0x280(%rbx)
movq $0x0, 0x220(%rbx)
movl %r11d, 0x20c(%rbx)
movq %rdi, 0x230(%rbx)
movq %r8, 0x288(%rbx)
movl %r11d, 0x290(%rbx)
sets %dl
orb %sil, %dl
jne 0xa3fb1
cmpl $0x9, %ecx
setae %dl
testb $0x7, %cl
sete %sil
testb %sil, %dl
je 0xa3fc6
movl $0x0, 0x208(%rbx)
addl $0x8, %eax
movl %eax, 0x210(%rbx)
jmp 0xa3fec
movl $0x18, 0x208(%rbx)
addl $0x18, %ecx
movq %r10, %rax
xorl %edx, %edx
divq %rcx
cmpq %rcx, %r10
movl $0x1, %r10d
cmovaeq %rax, %r10
imulq %rcx, %r10
movl %r8d, %eax
shrl $0x12, %eax
andb $0x1, %al
movb %al, 0x278(%rbx)
jne 0xa4027
leaq 0xb63089(%rip), %rax # 0xc0708c
movl (%rax), %edi
leaq 0x238(%rbx), %rsi
movq %r10, %rdx
xorl %ecx, %ecx
callq 0x9c474
movl 0x210(%rbx), %eax
addq $0x18, %rax
movq %rax, 0x250(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| init_tree:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, r8
mov rbx, rdi
mov r8, [rbp+arg_8]
mov rdi, [rbp+arg_0]
cmp rsi, 2001h
mov r10d, 2000h
cmovnb r10, rsi
add r10, 1FFFh
and r10, 0FFFFFFFFFFFFE000h
lea rsi, null_element
mov [rbx], rsi
mov [rbx+228h], rax
test r9, r9
setnz sil
xor r11d, r11d
test ecx, ecx
mov eax, 0
cmovg eax, ecx
mov [rbx+210h], eax
mov [rbx+218h], rdx
mov [rbx+280h], r9
mov qword ptr [rbx+220h], 0
mov [rbx+20Ch], r11d
mov [rbx+230h], rdi
mov [rbx+288h], r8
mov [rbx+290h], r11d
sets dl
or dl, sil
jnz short loc_A3FB1
cmp ecx, 9
setnb dl
test cl, 7
setz sil
test dl, sil
jz short loc_A3FC6
loc_A3FB1:
mov dword ptr [rbx+208h], 0
add eax, 8
mov [rbx+210h], eax
jmp short loc_A3FEC
loc_A3FC6:
mov dword ptr [rbx+208h], 18h
add ecx, 18h
mov rax, r10
xor edx, edx
div rcx
cmp r10, rcx
mov r10d, 1
cmovnb r10, rax
imul r10, rcx
loc_A3FEC:
mov eax, r8d
shr eax, 12h
and al, 1
mov [rbx+278h], al
jnz short loc_A4027
lea rax, key_memory_TREE
mov edi, [rax]
lea rsi, [rbx+238h]
mov rdx, r10
xor ecx, ecx
call init_alloc_root
mov eax, [rbx+210h]
add rax, 18h
mov [rbx+250h], rax
loc_A4027:
add rsp, 8
pop rbx
pop rbp
retn
| char init_tree(
long long a1,
unsigned long long a2,
long long a3,
int a4,
long long a5,
long long a6,
long long a7,
long long a8)
{
long long v8; // r10
unsigned long long v9; // r10
int v10; // eax
unsigned long long v11; // rcx
unsigned long long v12; // rax
bool v13; // cf
long long v14; // r10
long long v15; // rax
v8 = 0x2000LL;
if ( a2 >= 0x2001 )
v8 = a2;
v9 = (v8 + 0x1FFF) & 0xFFFFFFFFFFFFE000LL;
*(_QWORD *)a1 = &null_element;
*(_QWORD *)(a1 + 552) = a5;
v10 = 0;
if ( a4 > 0 )
v10 = a4;
*(_DWORD *)(a1 + 528) = v10;
*(_QWORD *)(a1 + 536) = a3;
*(_QWORD *)(a1 + 640) = a6;
*(_QWORD *)(a1 + 544) = 0LL;
*(_DWORD *)(a1 + 524) = 0;
*(_QWORD *)(a1 + 560) = a7;
*(_QWORD *)(a1 + 648) = a8;
*(_DWORD *)(a1 + 656) = 0;
if ( a6 != 0 || a4 < 0 || (a4 & 7) == 0 && (unsigned int)a4 >= 9 )
{
*(_DWORD *)(a1 + 520) = 0;
*(_DWORD *)(a1 + 528) = v10 + 8;
}
else
{
*(_DWORD *)(a1 + 520) = 24;
v11 = (unsigned int)(a4 + 24);
v12 = v9 / v11;
v13 = v9 < v11;
v14 = 1LL;
if ( !v13 )
v14 = v12;
v9 = v11 * v14;
}
LOBYTE(v15) = (a8 & 0x40000) != 0;
*(_BYTE *)(a1 + 632) = v15;
if ( (a8 & 0x40000) == 0 )
{
init_alloc_root(key_memory_TREE, (long long *)(a1 + 568), v9, 0LL, a8);
v15 = *(unsigned int *)(a1 + 528) + 24LL;
*(_QWORD *)(a1 + 592) = v15;
}
return v15;
}
| init_tree:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,R8
MOV RBX,RDI
MOV R8,qword ptr [RBP + 0x18]
MOV RDI,qword ptr [RBP + 0x10]
CMP RSI,0x2001
MOV R10D,0x2000
CMOVNC R10,RSI
ADD R10,0x1fff
AND R10,-0x2000
LEA RSI,[0x484bc0]
MOV qword ptr [RBX],RSI
MOV qword ptr [RBX + 0x228],RAX
TEST R9,R9
SETNZ SIL
XOR R11D,R11D
TEST ECX,ECX
MOV EAX,0x0
CMOVG EAX,ECX
MOV dword ptr [RBX + 0x210],EAX
MOV qword ptr [RBX + 0x218],RDX
MOV qword ptr [RBX + 0x280],R9
MOV qword ptr [RBX + 0x220],0x0
MOV dword ptr [RBX + 0x20c],R11D
MOV qword ptr [RBX + 0x230],RDI
MOV qword ptr [RBX + 0x288],R8
MOV dword ptr [RBX + 0x290],R11D
SETS DL
OR DL,SIL
JNZ 0x001a3fb1
CMP ECX,0x9
SETNC DL
TEST CL,0x7
SETZ SIL
TEST DL,SIL
JZ 0x001a3fc6
LAB_001a3fb1:
MOV dword ptr [RBX + 0x208],0x0
ADD EAX,0x8
MOV dword ptr [RBX + 0x210],EAX
JMP 0x001a3fec
LAB_001a3fc6:
MOV dword ptr [RBX + 0x208],0x18
ADD ECX,0x18
MOV RAX,R10
XOR EDX,EDX
DIV RCX
CMP R10,RCX
MOV R10D,0x1
CMOVNC R10,RAX
IMUL R10,RCX
LAB_001a3fec:
MOV EAX,R8D
SHR EAX,0x12
AND AL,0x1
MOV byte ptr [RBX + 0x278],AL
JNZ 0x001a4027
LEA RAX,[0xd0708c]
MOV EDI,dword ptr [RAX]
LEA RSI,[RBX + 0x238]
MOV RDX,R10
XOR ECX,ECX
CALL 0x0019c474
MOV EAX,dword ptr [RBX + 0x210]
ADD RAX,0x18
MOV qword ptr [RBX + 0x250],RAX
LAB_001a4027:
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void init_tree(int8 *param_1,ulong param_2,int8 param_3,uint param_4,int8 param_5,
long param_6,int8 param_7,ulong param_8)
{
uint uVar1;
ulong uVar2;
ulong uVar3;
ulong uVar4;
uVar3 = 0x2000;
if (0x2000 < param_2) {
uVar3 = param_2;
}
uVar3 = uVar3 + 0x1fff & 0xffffffffffffe000;
*param_1 = null_element;
param_1[0x45] = param_5;
uVar1 = 0;
if (0 < (int)param_4) {
uVar1 = param_4;
}
*(uint *)(param_1 + 0x42) = uVar1;
param_1[0x43] = param_3;
param_1[0x50] = param_6;
param_1[0x44] = 0;
*(int4 *)((long)param_1 + 0x20c) = 0;
param_1[0x46] = param_7;
param_1[0x51] = param_8;
*(int4 *)(param_1 + 0x52) = 0;
if (((int)param_4 < 0 || param_6 != 0) || (8 < param_4 && (param_4 & 7) == 0)) {
*(int4 *)(param_1 + 0x41) = 0;
*(uint *)(param_1 + 0x42) = uVar1 + 8;
}
else {
*(int4 *)(param_1 + 0x41) = 0x18;
uVar2 = (ulong)(param_4 + 0x18);
uVar4 = 1;
if (uVar2 <= uVar3) {
uVar4 = uVar3 / uVar2;
}
uVar3 = uVar4 * uVar2;
}
*(byte *)(param_1 + 0x4f) = (byte)(param_8 >> 0x12) & 1;
if ((param_8 >> 0x12 & 1) == 0) {
init_alloc_root(key_memory_TREE,param_1 + 0x47,uVar3,0);
param_1[0x4a] = (ulong)*(uint *)(param_1 + 0x42) + 0x18;
}
return;
}
| |
22,235 | 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>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>) | monkey531[P]llama/common/json.hpp | void push_back(initializer_list_t init)
{
if (is_object() && init.size() == 2 && (*init.begin())->is_string())
{
basic_json&& key = init.begin()->moved_or_copied();
push_back(typename object_t::value_type(
std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
}
else
{
push_back(basic_json(init));
}
} | 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>::push_back(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rdi)
sete %al
cmpq $0x2, %rdx
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x5e097
movq 0x10(%r14), %rax
testq %rax, %rax
cmoveq %r14, %rax
cmpb $0x3, (%rax)
jne 0x5e097
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7ef9e
movq %r15, %rdi
callq 0x93606
movq %rax, %r15
addq $0x18, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7ef9e
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x93246
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93152
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31156
movq %rbx, %rdi
callq 0x364a4
movq -0x20(%rbx), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x5e07b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x196d0
movq %rsp, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31156
movq %rbx, %rdi
callq 0x364a4
leaq 0x10(%rsp), %rbx
jmp 0x5e0c2
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movl $0x2, %r8d
callq 0x5e57c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x932bc
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x31156
movq %rbx, %rdi
callq 0x364a4
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x66518
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x31156
movq %r14, %rdi
callq 0x364a4
jmp 0x5e107
jmp 0x5e104
movq %rax, %rbx
leaq 0x10(%rsp), %r14
jmp 0x5e116
movq %rax, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x31156
movq %r14, %rdi
callq 0x364a4
movq %rbx, %rdi
callq 0x19c00
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backESt16initializer_listINS0_6detail8json_refISD_EEE:
push r15
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
cmp byte ptr [rdi], 1
setz al
cmp rdx, 2
setz cl
and cl, al
cmp cl, 1
jnz loc_5E097
mov rax, [r14+10h]
test rax, rax
cmovz rax, r14
cmp byte ptr [rax], 3
jnz loc_5E097
lea r15, [rsp+68h+var_58]
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12get_ref_implIRS9_SD_EET_RT0_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::get_ref_impl<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>>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)
mov r15, rax
add r14, 18h
mov rdi, rsp
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
lea r14, [rsp+68h+var_48]
mov rdx, rsp
mov rdi, r14
mov rsi, r15
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backERKSt4pairIKS9_SD_E; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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(std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
lea rbx, [rsp+68h+var_28]
mov rdi, rbx
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, [rbx-20h]; void *
lea rax, [rsp+68h+var_38]
cmp rdi, rax
jz short loc_5E07B
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_5E07B:
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()
lea rbx, [rsp+68h+var_58]
jmp short loc_5E0C2
loc_5E097:
lea r15, [rsp+68h+var_48]
mov rdi, r15
mov rsi, r14
mov ecx, 1
mov r8d, 2
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9push_backEOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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>&&)
lea rbx, [rsp+68h+var_48]
loc_5E0C2:
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()
add rsp, 50h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEED2Ev; std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~pair()
mov 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()
jmp short loc_5E107
jmp short $+2
loc_5E104:
mov rbx, rax
loc_5E107:
lea r14, [rsp+arg_8]
jmp short loc_5E116
mov rbx, rax
lea r14, [rsp+arg_18]
loc_5E116:
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::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
_BYTE *a1,
long long a2,
long long a3)
{
_BYTE *v3; // rax
long long v4; // r15
char *v5; // rbx
char v7[16]; // [rsp+0h] [rbp-68h] BYREF
_BYTE v8[16]; // [rsp+10h] [rbp-58h] BYREF
void *v9[2]; // [rsp+20h] [rbp-48h] BYREF
long long v10; // [rsp+30h] [rbp-38h] BYREF
char v11[40]; // [rsp+40h] [rbp-28h] BYREF
if ( *a1 != 1 || a3 != 2 )
goto LABEL_8;
v3 = *(_BYTE **)(a2 + 16);
if ( !v3 )
v3 = (_BYTE *)a2;
if ( *v3 == 3 )
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v8,
a2);
v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::get_ref_impl<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>>(v8);
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
v7,
a2 + 24);
ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_(
v9,
v4,
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>::push_back(
a1,
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>::assert_invariant(v11);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v11);
if ( v9[0] != &v10 )
operator delete(v9[0], v10 + 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>::assert_invariant(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>::data::~data(v7);
v5 = v8;
}
else
{
LABEL_8:
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(
v9,
a2,
a3,
1LL,
2LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::push_back(
a1,
v9);
v5 = (char *)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>::assert_invariant(v5);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v5);
}
| push_back:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
CMP byte ptr [RDI],0x1
SETZ AL
CMP RDX,0x2
SETZ CL
AND CL,AL
CMP CL,0x1
JNZ 0x0015e097
MOV RAX,qword ptr [R14 + 0x10]
TEST RAX,RAX
CMOVZ RAX,R14
CMP byte ptr [RAX],0x3
JNZ 0x0015e097
LEA R15,[RSP + 0x10]
MOV RDI,R15
MOV RSI,R14
CALL 0x0017ef9e
LAB_0015e011:
MOV RDI,R15
CALL 0x00193606
MOV R15,RAX
ADD R14,0x18
LAB_0015e020:
MOV RDI,RSP
MOV RSI,R14
CALL 0x0017ef9e
LEA R14,[RSP + 0x20]
MOV RDX,RSP
MOV RDI,R14
MOV RSI,R15
CALL 0x00193246
LAB_0015e03e:
MOV RDI,RBX
MOV RSI,R14
CALL 0x00193152
LAB_0015e049:
LEA RBX,[RSP + 0x40]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00131156
MOV RDI,RBX
CALL 0x001364a4
MOV RDI,qword ptr [RBX + -0x20]
LEA RAX,[RSP + 0x30]
CMP RDI,RAX
JZ 0x0015e07b
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001196d0
LAB_0015e07b:
MOV RBX,RSP
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00131156
MOV RDI,RBX
CALL 0x001364a4
LEA RBX,[RSP + 0x10]
JMP 0x0015e0c2
LAB_0015e097:
LEA R15,[RSP + 0x20]
MOV RDI,R15
MOV RSI,R14
MOV ECX,0x1
MOV R8D,0x2
CALL 0x0015e57c
LAB_0015e0b2:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001932bc
LAB_0015e0bd:
LEA RBX,[RSP + 0x20]
LAB_0015e0c2:
MOV RDI,RBX
XOR ESI,ESI
CALL 0x00131156
MOV RDI,RBX
CALL 0x001364a4
ADD RSP,0x50
POP RBX
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, 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(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >) */
void nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::push_back(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2,long param_3)
{
char *pcVar1;
string *psVar2;
data *this;
data adStack_68 [16];
basic_json local_58 [16];
long *local_48 [2];
long local_38 [2];
data local_28 [16];
if (param_3 == 2 &&
*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>
)0x1) {
pcVar1 = *(char **)(param_2 + 0x10);
if (*(char **)(param_2 + 0x10) == (char *)0x0) {
pcVar1 = param_2;
}
if (*pcVar1 == '\x03') {
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 0015e011 to 0015e018 has its CatchHandler @ 0015e104 */
psVar2 = get_ref_impl<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>>
(local_58);
/* try { // try from 0015e020 to 0015e02a has its CatchHandler @ 0015e102 */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
_ZNSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS5_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEEEC2IS5_SF_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairISJ_SK_EEEbE4typeELb1EEEOSJ_OSK_
((pair *)local_48,psVar2,adStack_68);
/* try { // try from 0015e03e to 0015e048 has its CatchHandler @ 0015e0de */
push_back(param_1,(pair *)local_48);
assert_invariant(SUB81(local_28,0));
data::~data(local_28);
if (local_48[0] != local_38) {
operator_delete(local_48[0],local_38[0] + 1);
}
assert_invariant(SUB81(adStack_68,0));
data::~data(adStack_68);
this = (data *)local_58;
goto LAB_0015e0c2;
}
}
basic_json((basic_json *)local_48,param_2,param_3,1,2);
/* try { // try from 0015e0b2 to 0015e0bc has its CatchHandler @ 0015e10e */
push_back(param_1,(basic_json *)local_48);
this = (data *)local_48;
LAB_0015e0c2:
assert_invariant(SUB81(this,0));
data::~data(this);
return;
}
| |
22,236 | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | giladroyz[P]FindPeaks/build_O3/_deps/googletest-src/googletest/src/gtest-matchers.cc | Matcher<const std::string&>::Matcher(const std::string& s) { *this = Eq(s); } | O3 | cpp | testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x42de2(%rip), %r14 # 0x588b8
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x391b4
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x391b4
leaq 0x42f31(%rip), %rax # 0x58a50
movq %rax, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x430ec(%rip), %rax # 0x58c20
movq %rax, 0x48(%rsp)
movl $0x28, %edi
callq 0x84b0
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rdx
cmpq %r12, %rdx
je 0x15b6c
movq %rdx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
jmp 0x15b74
movups (%r12), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %r12, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x10(%rsi)
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x35e28
leaq 0x40(%rsp), %rdi
callq 0x31d96
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x15bc3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x15bda
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x31d96
jmp 0x15bf8
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x15c13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x15c13
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x15c2f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x84e0
jmp 0x15c2f
movq %rax, %r14
movq %rbx, %rdi
callq 0x31d96
movq %r14, %rdi
callq 0x8990
nop
| _ZN7testing7MatcherIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2ES8_:
push r15; Alternative name is 'testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)'
push r14
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
lea r14, off_588B8
mov [rdi], r14
lea r15, [rsp+78h+var_48]
mov [r15-10h], r15
mov rax, [rsi]
mov rdx, [rsi+8]
add rdx, rax
lea rdi, [rsp+78h+var_58]
mov rsi, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea r12, [rsp+78h+var_68]
mov [r12-10h], r12
mov rsi, [rsp+78h+var_58]
mov rdx, [rsp+78h+var_50]
add rdx, rsi
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
lea rax, off_58A50
mov [rsp+78h+var_38], rax
mov [rsp+78h+var_28], 0
lea rax, _ZZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEE9GetVTableINSA_11ValuePolicyINS0_9EqMatcherIS7_EELb0EEEEEPKNSA_6VTableEvE7kVTableB5cxx11; testing::internal::MatcherBase<std::string const&>::GetVTable<testing::internal::MatcherBase<std::string const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable
mov [rsp+78h+var_30], rax
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov dword ptr [rax], 1
mov rcx, rax
add rcx, 18h
mov [rax+8], rcx
mov rdx, [rsp+78h+var_78]
cmp rdx, r12
jz short loc_15B6C
mov [rax+8], rdx
mov rcx, [rsp+78h+var_68]
mov [rax+18h], rcx
jmp short loc_15B74
loc_15B6C:
movups xmm0, xmmword ptr [r12]
movups xmmword ptr [rcx], xmm0
loc_15B74:
mov rcx, [rsp+78h+var_70]
mov [rax+10h], rcx
mov [rsp+78h+var_78], r12
mov [rsp+78h+var_70], 0
mov byte ptr [rsp+78h+var_68], 0
lea rsi, [rsp+78h+var_38]
mov [rsi+10h], rax
mov [rsi], r14
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEaSEOSA_; testing::internal::MatcherBase<std::string const&>::operator=(testing::internal::MatcherBase<std::string const&>&&)
lea rdi, [rsp+78h+var_38]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
mov rdi, [rsp+78h+var_78]; void *
cmp rdi, r12
jz short loc_15BC3
mov rsi, [rsp+78h+var_68]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_15BC3:
mov rdi, [rsp+78h+var_58]; void *
cmp rdi, r15
jz short loc_15BDA
mov rsi, [rsp+78h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_15BDA:
add rsp, 58h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
lea rdi, [rsp+arg_38]
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
jmp short loc_15BF8
mov r14, rax
loc_15BF8:
mov rdi, [rsp+0]; void *
cmp rdi, r12
jz short loc_15C13
mov rsi, [rsp+arg_8]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_15C13
mov r14, rax
loc_15C13:
mov rdi, [rsp+arg_18]; void *
cmp rdi, r15
jz short loc_15C2F
mov rsi, [rsp+arg_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_15C2F
mov r14, rax
loc_15C2F:
mov rdi, rbx
call _ZN7testing8internal11MatcherBaseIRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; testing::internal::MatcherBase<std::string const&>::~MatcherBase()
mov rdi, r14
call __Unwind_Resume
| void testing::Matcher<std::string const&>::Matcher(long long a1, _QWORD *a2)
{
long long v2; // rax
void *v3; // [rsp+0h] [rbp-78h] BYREF
long long v4; // [rsp+8h] [rbp-70h]
__int128 v5; // [rsp+10h] [rbp-68h] BYREF
void *v6[2]; // [rsp+20h] [rbp-58h] BYREF
_QWORD v7[2]; // [rsp+30h] [rbp-48h] BYREF
_QWORD v8[2]; // [rsp+40h] [rbp-38h] BYREF
long long v9; // [rsp+50h] [rbp-28h]
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)a1 = &off_588B8;
v6[0] = v7;
std::string::_M_construct<char *>(v6, *a2, *a2 + a2[1]);
v3 = &v5;
std::string::_M_construct<char *>(&v3, v6[0], (char *)v6[0] + (unsigned long long)v6[1]);
v8[0] = &off_58A50;
v9 = 0LL;
v8[1] = testing::internal::MatcherBase<std::string const&>::GetVTable<testing::internal::MatcherBase<std::string const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(void)::kVTable[abi:cxx11];
v2 = operator new(0x28uLL);
*(_DWORD *)v2 = 1;
*(_QWORD *)(v2 + 8) = v2 + 24;
if ( v3 == &v5 )
{
*(_OWORD *)(v2 + 24) = v5;
}
else
{
*(_QWORD *)(v2 + 8) = v3;
*(_QWORD *)(v2 + 24) = v5;
}
*(_QWORD *)(v2 + 16) = v4;
v3 = &v5;
v4 = 0LL;
LOBYTE(v5) = 0;
v9 = v2;
v8[0] = &off_588B8;
testing::internal::MatcherBase<std::string const&>::operator=(a1);
testing::internal::MatcherBase<std::string const&>::~MatcherBase(v8);
if ( v3 != &v5 )
operator delete(v3, v5 + 1);
if ( v6[0] != v7 )
operator delete(v6[0], v7[0] + 1LL);
}
| Matcher:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
LEA R14,[0x1588b8]
MOV qword ptr [RDI],R14
LEA R15,[RSP + 0x30]
MOV qword ptr [R15 + -0x10],R15
MOV RAX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
ADD RDX,RAX
LAB_00115aec:
LEA RDI,[RSP + 0x20]
MOV RSI,RAX
CALL 0x001391b4
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RSI,qword ptr [RSP + 0x20]
MOV RDX,qword ptr [RSP + 0x28]
ADD RDX,RSI
LAB_00115b10:
MOV RDI,RSP
CALL 0x001391b4
LEA RAX,[0x158a50]
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x50],0x0
LEA RAX,[0x158c20]
MOV qword ptr [RSP + 0x48],RAX
LAB_00115b39:
MOV EDI,0x28
CALL 0x001084b0
MOV dword ptr [RAX],0x1
MOV RCX,RAX
ADD RCX,0x18
MOV qword ptr [RAX + 0x8],RCX
MOV RDX,qword ptr [RSP]
CMP RDX,R12
JZ 0x00115b6c
MOV qword ptr [RAX + 0x8],RDX
MOV RCX,qword ptr [RSP + 0x10]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x00115b74
LAB_00115b6c:
MOVUPS XMM0,xmmword ptr [R12]
MOVUPS xmmword ptr [RCX],XMM0
LAB_00115b74:
MOV RCX,qword ptr [RSP + 0x8]
MOV qword ptr [RAX + 0x10],RCX
MOV qword ptr [RSP],R12
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI + 0x10],RAX
MOV qword ptr [RSI],R14
LAB_00115b9b:
MOV RDI,RBX
CALL 0x00135e28
LAB_00115ba3:
LEA RDI,[RSP + 0x40]
CALL 0x00131d96
MOV RDI,qword ptr [RSP]
CMP RDI,R12
JZ 0x00115bc3
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x001084e0
LAB_00115bc3:
MOV RDI,qword ptr [RSP + 0x20]
CMP RDI,R15
JZ 0x00115bda
MOV RSI,qword ptr [RSP + 0x30]
INC RSI
CALL 0x001084e0
LAB_00115bda:
ADD RSP,0x58
POP RBX
POP R12
POP R14
POP R15
RET
|
/* testing::Matcher<std::__cxx11::string const&>::Matcher(std::__cxx11::string const&) */
void __thiscall
testing::Matcher<std::__cxx11::string_const&>::Matcher
(Matcher<std::__cxx11::string_const&> *this,string *param_1)
{
int1 *local_78;
int8 local_70;
int1 local_68;
int7 uStack_67;
int8 uStack_60;
long *local_58;
long local_50;
long local_48 [2];
int **local_38;
int1 *local_30;
int4 *local_28;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int ***)this = &PTR__MatcherBase_001588b8;
/* try { // try from 00115aec to 00115af8 has its CatchHandler @ 00115c2c */
local_58 = local_48;
std::__cxx11::string::_M_construct<char*>
(&local_58,*(long *)param_1,*(long *)(param_1 + 8) + *(long *)param_1);
local_78 = &local_68;
/* try { // try from 00115b10 to 00115b17 has its CatchHandler @ 00115c10 */
std::__cxx11::string::_M_construct<char*>(&local_78,local_58,local_50 + (long)local_58);
local_38 = &PTR__MatcherBase_00158a50;
local_28 = (int4 *)0x0;
local_30 = internal::MatcherBase<std::__cxx11::string_const&>::
GetVTable<testing::internal::MatcherBase<std::__cxx11::string_const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>()
::kVTable_abi_cxx11_;
/* try { // try from 00115b39 to 00115b42 has its CatchHandler @ 00115bf5 */
local_28 = (int4 *)operator_new(0x28);
*local_28 = 1;
*(int4 **)(local_28 + 2) = local_28 + 6;
if (local_78 == &local_68) {
*(ulong *)(local_28 + 6) = CONCAT71(uStack_67,local_68);
*(int8 *)(local_28 + 8) = uStack_60;
}
else {
*(int1 **)(local_28 + 2) = local_78;
*(ulong *)(local_28 + 6) = CONCAT71(uStack_67,local_68);
}
*(int8 *)(local_28 + 4) = local_70;
local_70 = 0;
local_68 = 0;
local_38 = &PTR__MatcherBase_001588b8;
local_78 = &local_68;
/* try { // try from 00115b9b to 00115ba2 has its CatchHandler @ 00115be6 */
internal::MatcherBase<std::__cxx11::string_const&>::operator=
((MatcherBase<std::__cxx11::string_const&> *)this,(MatcherBase *)&local_38);
internal::MatcherBase<std::__cxx11::string_const&>::~MatcherBase
((MatcherBase<std::__cxx11::string_const&> *)&local_38);
if (local_78 != &local_68) {
operator_delete(local_78,CONCAT71(uStack_67,local_68) + 1);
}
if (local_58 != local_48) {
operator_delete(local_58,local_48[0] + 1);
}
return;
}
| |
22,237 | js_string_delete_property | bluesky950520[P]quickjs/quickjs.c | static int js_string_delete_property(JSContext *ctx,
JSValue obj, JSAtom prop)
{
uint32_t idx;
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx < js_string_obj_get_length(ctx, obj)) {
return FALSE;
}
}
return TRUE;
} | O2 | c | js_string_delete_property:
testl %ecx, %ecx
jns 0x3dbd5
cmpl $-0x7, 0x38(%rsi)
jne 0x3dbd5
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl %edx, %ecx
movq 0x30(%rsi), %rax
andl 0x4(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
jb 0x3dbd8
pushq $0x1
popq %rax
retq
| js_string_delete_property:
test ecx, ecx
jns short loc_3DBD5
cmp dword ptr [rsi+38h], 0FFFFFFF9h
jnz short loc_3DBD5
mov edx, 7FFFFFFFh
and ecx, edx
mov rax, [rsi+30h]
and edx, [rax+4]
xor eax, eax
cmp ecx, edx
jb short locret_3DBD8
loc_3DBD5:
push 1
pop rax
locret_3DBD8:
retn
| long long js_string_delete_property(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
if ( a4 >= 0 )
return 1LL;
if ( *(_DWORD *)(a2 + 56) != -7 )
return 1LL;
result = 0LL;
if ( (a4 & 0x7FFFFFFFu) >= (*(_DWORD *)(*(_QWORD *)(a2 + 48) + 4LL) & 0x7FFFFFFFu) )
return 1LL;
return result;
}
| js_string_delete_property:
TEST ECX,ECX
JNS 0x0013dbd5
CMP dword ptr [RSI + 0x38],-0x7
JNZ 0x0013dbd5
MOV EDX,0x7fffffff
AND ECX,EDX
MOV RAX,qword ptr [RSI + 0x30]
AND EDX,dword ptr [RAX + 0x4]
XOR EAX,EAX
CMP ECX,EDX
JC 0x0013dbd8
LAB_0013dbd5:
PUSH 0x1
POP RAX
LAB_0013dbd8:
RET
|
int8
js_string_delete_property(int8 param_1,long param_2,int8 param_3,uint param_4)
{
int8 uVar1;
if (((-1 < (int)param_4) || (*(int *)(param_2 + 0x38) != -7)) ||
(uVar1 = 0, (*(uint *)(*(long *)(param_2 + 0x30) + 4) & 0x7fffffff) <= (param_4 & 0x7fffffff)))
{
uVar1 = 1;
}
return uVar1;
}
| |
22,238 | js_string_delete_property | bluesky950520[P]quickjs/quickjs.c | static int js_string_delete_property(JSContext *ctx,
JSValue obj, JSAtom prop)
{
uint32_t idx;
if (__JS_AtomIsTaggedInt(prop)) {
idx = __JS_AtomToUInt32(prop);
if (idx < js_string_obj_get_length(ctx, obj)) {
return FALSE;
}
}
return TRUE;
} | O3 | c | js_string_delete_property:
testl %ecx, %ecx
jns 0x49382
cmpl $-0x7, 0x38(%rsi)
jne 0x49382
movl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl %edx, %ecx
movq 0x30(%rsi), %rax
andl 0x4(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
jb 0x49387
movl $0x1, %eax
retq
| js_string_delete_property:
test ecx, ecx
jns short loc_49382
cmp dword ptr [rsi+38h], 0FFFFFFF9h
jnz short loc_49382
mov edx, 7FFFFFFFh
and ecx, edx
mov rax, [rsi+30h]
and edx, [rax+4]
xor eax, eax
cmp ecx, edx
jb short locret_49387
loc_49382:
mov eax, 1
locret_49387:
retn
| long long js_string_delete_property(long long a1, long long a2, long long a3, int a4)
{
long long result; // rax
if ( a4 >= 0 )
return 1LL;
if ( *(_DWORD *)(a2 + 56) != -7 )
return 1LL;
result = 0LL;
if ( (a4 & 0x7FFFFFFFu) >= (*(_DWORD *)(*(_QWORD *)(a2 + 48) + 4LL) & 0x7FFFFFFFu) )
return 1LL;
return result;
}
| js_string_delete_property:
TEST ECX,ECX
JNS 0x00149382
CMP dword ptr [RSI + 0x38],-0x7
JNZ 0x00149382
MOV EDX,0x7fffffff
AND ECX,EDX
MOV RAX,qword ptr [RSI + 0x30]
AND EDX,dword ptr [RAX + 0x4]
XOR EAX,EAX
CMP ECX,EDX
JC 0x00149387
LAB_00149382:
MOV EAX,0x1
LAB_00149387:
RET
|
int8
js_string_delete_property(int8 param_1,long param_2,int8 param_3,uint param_4)
{
int8 uVar1;
if (((-1 < (int)param_4) || (*(int *)(param_2 + 0x38) != -7)) ||
(uVar1 = 0, (*(uint *)(*(long *)(param_2 + 0x30) + 4) & 0x7fffffff) <= (param_4 & 0x7fffffff)))
{
uVar1 = 1;
}
return uVar1;
}
| |
22,239 | mysql_stat_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_stat_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stat,
(parms->mysql),
parms->mysql,
const char *,
r_const_ptr)
} | O3 | c | mysql_stat_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
movq 0x480(%rdi), %rax
movq 0x28(%rax), %rbx
callq 0x1f5d7
movq %rax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| mysql_stat_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rdi, [rdi]
mov rax, [rdi+480h]
mov rbx, [rax+28h]
call mysql_stat
mov [rbx+8], rax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
| _BYTE * mysql_stat_start_internal(long long *a1)
{
long long v1; // rdi
long long v2; // rbx
_BYTE *result; // rax
v1 = *a1;
v2 = *(_QWORD *)(*(_QWORD *)(v1 + 1152) + 40LL);
result = mysql_stat(v1);
*(_QWORD *)(v2 + 8) = result;
*(_DWORD *)v2 = 0;
return result;
}
| mysql_stat_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RDI,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x480]
MOV RBX,qword ptr [RAX + 0x28]
CALL 0x0011f5d7
MOV qword ptr [RBX + 0x8],RAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stat_start_internal(long *param_1)
{
int4 *puVar1;
int8 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_stat();
*(int8 *)(puVar1 + 2) = uVar2;
*puVar1 = 0;
return;
}
| |
22,240 | my_mb_wc_euc_jp | eloqsql/strings/ctype-ujis.c | static int
my_mb_wc_euc_jp(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) /* ASCII code set: [00..7F] -> [U+0000..U+007F] */
{
*pwc= hi;
return 1;
}
if (hi >= 0xA1 && hi <= 0xFE) /* JIS-X-0208 code set: [A1..FE][A1..FE] */
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
return (*pwc= jisx0208_eucjp_to_unicode[(hi << 8) + s[1]]) ? 2 :
(s[1] < 0xA1 || s[1] > 0xFE) ? MY_CS_ILSEQ : -2;
}
/* JIS-X-0201 HALF WIDTH KATAKANA: [8E][A1..DF] -> [U+FF61..U+FF9F] */
if (hi == 0x8E)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
if (s[1] < 0xA1 || s[1] > 0xDF)
return MY_CS_ILSEQ;
*pwc= 0xFEC0 + s[1]; /* 0xFFC0 = 0xFF61 - 0xA1 */
return 2;
}
if (hi == 0x8F) /* JIS X 0212 code set: [8F][A1..FE][A1..FE] */
{
if (s + 3 > e)
return MY_CS_TOOSMALL3;
return (*pwc= jisx0212_eucjp_to_unicode[(((int) s[1]) << 8) + s[2]]) ?
3 :
(s[1] < 0xA1 || s[1] > 0xFE || s[2] < 0xA1 || s[2] > 0xFE) ?
MY_CS_ILSEQ : -3;
}
return MY_CS_ILSEQ;
} | O3 | c | my_mb_wc_euc_jp:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x4c9c7
movzbl (%rdx), %edi
testb %dil, %dil
js 0x4c9c9
movq %rdi, (%rsi)
movl $0x1, %eax
popq %rbp
retq
leal 0x5f(%rdi), %eax
cmpb $0x5d, %al
ja 0x4ca15
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x4c9c7
movzbl 0x1(%rdx), %eax
shll $0x9, %edi
leal (%rdi,%rax,2), %eax
leaq 0x206531(%rip), %rcx # 0x252f20
movzwl (%rax,%rcx), %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testq %rcx, %rcx
jne 0x4c9c7
movb 0x1(%rdx), %al
incb %al
xorl %ecx, %ecx
cmpb $-0x5e, %al
setb %cl
leal -0x2(,%rcx,2), %eax
jmp 0x4c9c7
cmpq $0x8f, %rdi
je 0x4ca59
cmpl $0x8e, %edi
jne 0x4ca9b
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x4c9c7
movzbl 0x1(%rdx), %ecx
leal 0x20(%rcx), %edx
movl $0x0, %eax
cmpb $-0x3f, %dl
jb 0x4c9c7
addq $0xfec0, %rcx # imm = 0xFEC0
movq %rcx, (%rsi)
movl $0x2, %eax
jmp 0x4c9c7
leaq 0x3(%rdx), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rcx, %rdi
ja 0x4c9c7
movzwl 0x1(%rdx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0x2264a3(%rip), %rcx # 0x272f20
movzwl (%rcx,%rax,2), %ecx
movq %rcx, (%rsi)
movl $0x3, %eax
testq %rcx, %rcx
jne 0x4c9c7
movb 0x1(%rdx), %al
incb %al
cmpb $-0x5e, %al
jae 0x4caa2
xorl %eax, %eax
jmp 0x4c9c7
movb 0x2(%rdx), %cl
movl $0x0, %eax
cmpb $-0x5f, %cl
jb 0x4c9c7
xorl %eax, %eax
cmpb $-0x1, %cl
sete %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
jmp 0x4c9c7
| my_mb_wc_euc_jp:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short loc_4C9C7
movzx edi, byte ptr [rdx]
test dil, dil
js short loc_4C9C9
mov [rsi], rdi
mov eax, 1
loc_4C9C7:
pop rbp
retn
loc_4C9C9:
lea eax, [rdi+5Fh]
cmp al, 5Dh ; ']'
ja short loc_4CA15
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short loc_4C9C7
movzx eax, byte ptr [rdx+1]
shl edi, 9
lea eax, [rdi+rax*2]
lea rcx, jisx0208_eucjp_to_unicode
movzx ecx, word ptr [rax+rcx]
mov [rsi], rcx
mov eax, 2
test rcx, rcx
jnz short loc_4C9C7
mov al, [rdx+1]
inc al
xor ecx, ecx
cmp al, 0A2h
setb cl
lea eax, ds:0FFFFFFFFFFFFFFFEh[rcx*2]
jmp short loc_4C9C7
loc_4CA15:
cmp rdi, 8Fh
jz short loc_4CA59
cmp edi, 8Eh
jnz short loc_4CA9B
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_4C9C7
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx+20h]
mov eax, 0
cmp dl, 0C1h
jb short loc_4C9C7
add rcx, 0FEC0h
mov [rsi], rcx
mov eax, 2
jmp loc_4C9C7
loc_4CA59:
lea rdi, [rdx+3]
mov eax, 0FFFFFF99h
cmp rdi, rcx
ja loc_4C9C7
movzx eax, word ptr [rdx+1]
rol ax, 8
movzx eax, ax
lea rcx, jisx0212_eucjp_to_unicode
movzx ecx, word ptr [rcx+rax*2]
mov [rsi], rcx
mov eax, 3
test rcx, rcx
jnz loc_4C9C7
mov al, [rdx+1]
inc al
cmp al, 0A2h
jnb short loc_4CAA2
loc_4CA9B:
xor eax, eax
jmp loc_4C9C7
loc_4CAA2:
mov cl, [rdx+2]
mov eax, 0
cmp cl, 0A1h
jb loc_4C9C7
xor eax, eax
cmp cl, 0FFh
setz al
lea eax, [rax+rax*2]
add eax, 0FFFFFFFDh
jmp loc_4C9C7
| long long my_mb_wc_euc_jp(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
long long v6; // rcx
long long v7; // rcx
long long v8; // rcx
unsigned __int8 v9; // cl
result = 4294967195LL;
if ( (unsigned long long)a3 >= a4 )
return result;
v5 = *a3;
if ( (v5 & 0x80u) == 0LL )
{
*a2 = v5;
return 1LL;
}
if ( (unsigned __int8)(v5 + 95) <= 0x5Du )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = jisx0208_eucjp_to_unicode[256 * (_DWORD)v5 + a3[1]];
*a2 = v6;
result = 2LL;
if ( !v6 )
return 2 * (unsigned int)((unsigned __int8)(a3[1] + 1) < 0xA2u) - 2;
}
return result;
}
if ( v5 != 143 )
{
if ( (_DWORD)v5 == 142 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v7 = a3[1];
result = 0LL;
if ( (unsigned __int8)(v7 + 32) >= 0xC1u )
{
*a2 = v7 + 65216;
return 2LL;
}
}
return result;
}
return 0LL;
}
result = 4294967193LL;
if ( (unsigned long long)(a3 + 3) > a4 )
return result;
v8 = jisx0212_eucjp_to_unicode[(unsigned __int16)__ROL2__(*(_WORD *)(a3 + 1), 8)];
*a2 = v8;
result = 3LL;
if ( v8 )
return result;
if ( (unsigned __int8)(a3[1] + 1) < 0xA2u )
return 0LL;
v9 = a3[2];
result = 0LL;
if ( v9 >= 0xA1u )
return 3 * (unsigned int)(v9 == 0xFF) - 3;
return result;
}
| my_mb_wc_euc_jp:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x0014c9c7
MOVZX EDI,byte ptr [RDX]
TEST DIL,DIL
JS 0x0014c9c9
MOV qword ptr [RSI],RDI
MOV EAX,0x1
LAB_0014c9c7:
POP RBP
RET
LAB_0014c9c9:
LEA EAX,[RDI + 0x5f]
CMP AL,0x5d
JA 0x0014ca15
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x0014c9c7
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EDI,0x9
LEA EAX,[RDI + RAX*0x2]
LEA RCX,[0x352f20]
MOVZX ECX,word ptr [RAX + RCX*0x1]
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST RCX,RCX
JNZ 0x0014c9c7
MOV AL,byte ptr [RDX + 0x1]
INC AL
XOR ECX,ECX
CMP AL,0xa2
SETC CL
LEA EAX,[-0x2 + RCX*0x2]
JMP 0x0014c9c7
LAB_0014ca15:
CMP RDI,0x8f
JZ 0x0014ca59
CMP EDI,0x8e
JNZ 0x0014ca9b
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x0014c9c7
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + 0x20]
MOV EAX,0x0
CMP DL,0xc1
JC 0x0014c9c7
ADD RCX,0xfec0
MOV qword ptr [RSI],RCX
MOV EAX,0x2
JMP 0x0014c9c7
LAB_0014ca59:
LEA RDI,[RDX + 0x3]
MOV EAX,0xffffff99
CMP RDI,RCX
JA 0x0014c9c7
MOVZX EAX,word ptr [RDX + 0x1]
ROL AX,0x8
MOVZX EAX,AX
LEA RCX,[0x372f20]
MOVZX ECX,word ptr [RCX + RAX*0x2]
MOV qword ptr [RSI],RCX
MOV EAX,0x3
TEST RCX,RCX
JNZ 0x0014c9c7
MOV AL,byte ptr [RDX + 0x1]
INC AL
CMP AL,0xa2
JNC 0x0014caa2
LAB_0014ca9b:
XOR EAX,EAX
JMP 0x0014c9c7
LAB_0014caa2:
MOV CL,byte ptr [RDX + 0x2]
MOV EAX,0x0
CMP CL,0xa1
JC 0x0014c9c7
XOR EAX,EAX
CMP CL,0xff
SETZ AL
LEA EAX,[RAX + RAX*0x2]
ADD EAX,-0x3
JMP 0x0014c9c7
|
int my_mb_wc_euc_jp(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
ushort uVar2;
int iVar3;
iVar3 = -0x65;
if (param_3 < param_4) {
bVar1 = *param_3;
if ((char)bVar1 < '\0') {
if ((byte)(bVar1 + 0x5f) < 0x5e) {
iVar3 = -0x66;
if (param_3 + 2 <= param_4) {
uVar2 = *(ushort *)
(jisx0208_eucjp_to_unicode + ((uint)bVar1 * 0x200 + (uint)param_3[1] * 2));
*param_2 = (ulong)uVar2;
iVar3 = 2;
if ((ulong)uVar2 == 0) {
iVar3 = (uint)((byte)(param_3[1] + 1) < 0xa2) * 2 + -2;
}
}
}
else {
if ((ulong)bVar1 == 0x8f) {
if (param_4 < param_3 + 3) {
return -0x67;
}
uVar2 = *(ushort *)
(&jisx0212_eucjp_to_unicode +
(ulong)(ushort)(*(ushort *)(param_3 + 1) << 8 | *(ushort *)(param_3 + 1) >> 8) *
2);
*param_2 = (ulong)uVar2;
if ((ulong)uVar2 != 0) {
return 3;
}
if (0xa1 < (byte)(param_3[1] + 1)) {
if (param_3[2] < 0xa1) {
return 0;
}
return (uint)(param_3[2] == 0xff) * 3 + -3;
}
}
else if (bVar1 == 0x8e) {
if (param_4 < param_3 + 2) {
return -0x66;
}
if ((byte)(param_3[1] + 0x20) < 0xc1) {
return 0;
}
*param_2 = (ulong)param_3[1] + 0xfec0;
return 2;
}
iVar3 = 0;
}
}
else {
*param_2 = (ulong)bVar1;
iVar3 = 1;
}
}
return iVar3;
}
| |
22,241 | ma_get_host_list | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void ma_get_host_list(char *host_list, struct st_host *host_info, int default_port)
{
char *token, *start, *save;
int host_nr= 0;
start= host_list;
while ((token= strtok_r(start, ",", &save)))
{
char *p;
/* ipv6 hostname */
if ((p= strchr(token, ']')))
{
host_info[host_nr].host= token + 1;
*p++= 0;
token= p;
}
else
host_info[host_nr].host= token;
/* check if port was specified */
if ((p= strchr(token, ':')))
{
*p++= 0;
host_info[host_nr].port= atoi(p);
}
else
host_info[host_nr].port= default_port;
host_nr++;
start= NULL;
}
return;
} | O0 | c | ma_get_host_list:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2f16d(%rip), %rsi # 0x4bcea
leaq -0x30(%rbp), %rdx
callq 0x13780
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1cc6c
movq -0x20(%rbp), %rdi
movl $0x5d, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1cbe2
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1cbf8
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
movl $0x3a, %esi
callq 0x13170
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1cc41
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x40(%rbp)
movb $0x0, (%rax)
movq -0x40(%rbp), %rdi
callq 0x136b0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
jmp 0x1cc56
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x28(%rbp)
jmp 0x1cb72
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| ma_get_host_list:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_34], 0
mov rax, [rbp+var_8]
mov [rbp+var_28], rax
loc_1CB72:
mov rdi, [rbp+var_28]
lea rsi, asc_4BCEA; ","
lea rdx, [rbp+var_30]
call _strtok_r
mov [rbp+var_20], rax
cmp rax, 0
jz loc_1CC6C
mov rdi, [rbp+var_20]
mov esi, 5Dh ; ']'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_1CBE2
mov rcx, [rbp+var_20]
add rcx, 1
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rax, [rbp+var_40]
mov [rbp+var_20], rax
jmp short loc_1CBF8
loc_1CBE2:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax], rcx
loc_1CBF8:
mov rdi, [rbp+var_20]
mov esi, 3Ah ; ':'
call _strchr
mov [rbp+var_40], rax
cmp rax, 0
jz short loc_1CC41
mov rax, [rbp+var_40]
mov rcx, rax
add rcx, 1
mov [rbp+var_40], rcx
mov byte ptr [rax], 0
mov rdi, [rbp+var_40]
call _atoi
mov ecx, eax
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
jmp short loc_1CC56
loc_1CC41:
mov ecx, [rbp+var_14]
mov rax, [rbp+var_10]
movsxd rdx, [rbp+var_34]
shl rdx, 4
add rax, rdx
mov [rax+8], ecx
loc_1CC56:
mov eax, [rbp+var_34]
add eax, 1
mov [rbp+var_34], eax
mov [rbp+var_28], 0
jmp loc_1CB72
loc_1CC6C:
add rsp, 40h
pop rbp
retn
| long long ma_get_host_list(long long a1, long long a2, int a3)
{
long long result; // rax
int v4; // eax
_BYTE *v5; // [rsp+0h] [rbp-40h]
_BYTE *v6; // [rsp+0h] [rbp-40h]
int v7; // [rsp+Ch] [rbp-34h]
_BYTE v8[8]; // [rsp+10h] [rbp-30h] BYREF
long long i; // [rsp+18h] [rbp-28h]
_BYTE *v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+2Ch] [rbp-14h]
long long v12; // [rsp+30h] [rbp-10h]
long long v13; // [rsp+38h] [rbp-8h]
v13 = a1;
v12 = a2;
v11 = a3;
v7 = 0;
for ( i = a1; ; i = 0LL )
{
result = strtok_r(i, ",", v8);
v10 = (_BYTE *)result;
if ( !result )
break;
v5 = (_BYTE *)strchr(v10, 93LL);
if ( v5 )
{
*(_QWORD *)(16LL * v7 + v12) = v10 + 1;
*v5 = 0;
v10 = v5 + 1;
}
else
{
*(_QWORD *)(16LL * v7 + v12) = v10;
}
v6 = (_BYTE *)strchr(v10, 58LL);
if ( v6 )
{
*v6 = 0;
v4 = atoi(v6 + 1);
*(_DWORD *)(16LL * v7 + v12 + 8) = v4;
}
else
{
*(_DWORD *)(16LL * v7 + v12 + 8) = v11;
}
++v7;
}
return result;
}
| ma_get_host_list:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
MOV dword ptr [RBP + -0x34],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x28],RAX
LAB_0011cb72:
MOV RDI,qword ptr [RBP + -0x28]
LEA RSI,[0x14bcea]
LEA RDX,[RBP + -0x30]
CALL 0x00113780
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JZ 0x0011cc6c
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x5d
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x0011cbe2
MOV RCX,qword ptr [RBP + -0x20]
ADD RCX,0x1
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0011cbf8
LAB_0011cbe2:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV qword ptr [RAX],RCX
LAB_0011cbf8:
MOV RDI,qword ptr [RBP + -0x20]
MOV ESI,0x3a
CALL 0x00113170
MOV qword ptr [RBP + -0x40],RAX
CMP RAX,0x0
JZ 0x0011cc41
MOV RAX,qword ptr [RBP + -0x40]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x40],RCX
MOV byte ptr [RAX],0x0
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001136b0
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
JMP 0x0011cc56
LAB_0011cc41:
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RDX,dword ptr [RBP + -0x34]
SHL RDX,0x4
ADD RAX,RDX
MOV dword ptr [RAX + 0x8],ECX
LAB_0011cc56:
MOV EAX,dword ptr [RBP + -0x34]
ADD EAX,0x1
MOV dword ptr [RBP + -0x34],EAX
MOV qword ptr [RBP + -0x28],0x0
JMP 0x0011cb72
LAB_0011cc6c:
ADD RSP,0x40
POP RBP
RET
|
void ma_get_host_list(char *param_1,long param_2,int4 param_3)
{
int iVar1;
char *pcVar2;
int local_3c;
char *local_38;
char *local_30;
char *local_28;
int4 local_1c;
long local_18;
char *local_10;
local_3c = 0;
local_30 = param_1;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
local_28 = strtok_r(local_30,",",&local_38);
if (local_28 == (char *)0x0) break;
pcVar2 = strchr(local_28,0x5d);
if (pcVar2 == (char *)0x0) {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28;
}
else {
*(char **)(local_18 + (long)local_3c * 0x10) = local_28 + 1;
local_28 = pcVar2 + 1;
*pcVar2 = '\0';
}
pcVar2 = strchr(local_28,0x3a);
if (pcVar2 == (char *)0x0) {
*(int4 *)(local_18 + (long)local_3c * 0x10 + 8) = local_1c;
}
else {
*pcVar2 = '\0';
iVar1 = atoi(pcVar2 + 1);
*(int *)(local_18 + (long)local_3c * 0x10 + 8) = iVar1;
}
local_3c = local_3c + 1;
local_30 = (char *)0x0;
}
return;
}
| |
22,242 | testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.empty()) {
GTEST_LOG_(FATAL) << "XML output file may not be null";
}
} | O1 | cpp | testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*):
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30de8(%rip), %rax # 0x58f88
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x3(%rsp), %rdx
callq 0x3518c
cmpq $0x0, 0x10(%rbx)
jne 0x281f5
leaq 0x1a83c(%rip), %rdx # 0x429fb
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0xf92, %ecx # imm = 0xF92
callq 0x1b13e
movq 0x31e0e(%rip), %rdi # 0x59fe8
leaq 0x1b4d8(%rip), %rsi # 0x436b9
movl $0x1f, %edx
callq 0x95a0
leaq 0x4(%rsp), %rdi
callq 0x1b280
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x4(%rsp), %rdi
callq 0x1b280
jmp 0x2820f
movq %rax, %r14
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x28227
movq (%rbx), %rsi
incq %rsi
callq 0x94c0
movq %r14, %rdi
callq 0x99a0
nop
| _ZN7testing8internal24XmlUnitTestResultPrinterC2EPKc:
push r14
push rbx
push rax
mov rbx, rdi
lea rax, off_58F88
mov [rdi], rax
add rdi, 8
lea rdx, [rsp+18h+var_15]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
cmp qword ptr [rbx+10h], 0
jnz short loc_281F5
lea rdx, aWorkspaceLlm4b_3; "/workspace/llm4binary/github/2025_star3"...
lea rdi, [rsp+18h+var_14]
mov esi, 3
mov ecx, 0F92h
call _ZN7testing8internal8GTestLogC2ENS0_16GTestLogSeverityEPKci; testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity,char const*,int)
mov rdi, cs:_ZSt4cerr_ptr
lea rsi, aXmlOutputFileM; "XML output file may not be null"
mov edx, 1Fh
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+18h+var_14]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
loc_281F5:
add rsp, 8
pop rbx
pop r14
retn
mov r14, rax
lea rdi, [rsp+4]; this
call _ZN7testing8internal8GTestLogD2Ev; testing::internal::GTestLog::~GTestLog()
jmp short loc_2820F
mov r14, rax
loc_2820F:
mov rdi, [rbx+8]; void *
add rbx, 18h
cmp rdi, rbx
jz short loc_28227
mov rsi, [rbx]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_28227:
mov rdi, r14
call __Unwind_Resume
| void testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(
testing::internal::XmlUnitTestResultPrinter *this,
const char *a2)
{
long long v2; // rax
_QWORD v3[3]; // [rsp-2h] [rbp-18h] BYREF
v3[0] = v2;
*(_QWORD *)this = off_58F88;
std::string::basic_string<std::allocator<char>>((char *)this + 8, a2, (char *)v3 + 3);
if ( !*((_QWORD *)this + 2) )
{
testing::internal::GTestLog::GTestLog(
(_DWORD *)v3 + 1,
3,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc",
3986);
std::__ostream_insert<char,std::char_traits<char>>(&std::cerr, "XML output file may not be null", 31LL);
testing::internal::GTestLog::~GTestLog((testing::internal::GTestLog *)((char *)v3 + 4));
}
}
| XmlUnitTestResultPrinter:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
LEA RAX,[0x158f88]
MOV qword ptr [RDI],RAX
ADD RDI,0x8
LEA RDX,[RSP + 0x3]
CALL 0x0013518c
CMP qword ptr [RBX + 0x10],0x0
JNZ 0x001281f5
LAB_001281b8:
LEA RDX,[0x1429fb]
LEA RDI,[RSP + 0x4]
MOV ESI,0x3
MOV ECX,0xf92
CALL 0x0011b13e
LAB_001281d3:
MOV RDI,qword ptr [0x00159fe8]
LEA RSI,[0x1436b9]
MOV EDX,0x1f
CALL 0x001095a0
LAB_001281eb:
LEA RDI,[RSP + 0x4]
CALL 0x0011b280
LAB_001281f5:
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) */
void __thiscall
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter
(XmlUnitTestResultPrinter *this,char *param_1)
{
allocator local_15;
GTestLog local_14 [4];
*(int ***)this = &PTR__XmlUnitTestResultPrinter_00158f88;
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 8),param_1,&local_15);
if (*(long *)(this + 0x10) == 0) {
/* try { // try from 001281b8 to 001281d2 has its CatchHandler @ 0012820c */
GTestLog::GTestLog(local_14,3,
"/workspace/llm4binary/github/2025_star3/seiftnesse[P]memoryallocator/build_O1/_deps/googletest-src/googletest/src/gtest.cc"
,0xf92);
/* try { // try from 001281d3 to 001281ea has its CatchHandler @ 001281fd */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)PTR_cerr_00159fe8,"XML output file may not be null",0x1f);
GTestLog::~GTestLog(local_14);
}
return;
}
| |
22,243 | facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody() | yoga-mod/tests/EventsTest.cpp | TEST_F(EventTest, baseline_functions_get_wrapped) {
auto root = YGNodeNew();
auto child = YGNodeNew();
YGNodeInsertChild(root, child, 0);
YGNodeSetBaselineFunc(
child, [](YGNodeConstRef, float, float) { return 0.0f; });
YGNodeStyleSetFlexDirection(root, YGFlexDirectionRow);
YGNodeStyleSetAlignItems(root, YGAlignBaseline);
YGNodeCalculateLayout(root, YGUndefined, YGUndefined, YGDirectionLTR);
ASSERT_EQ(events[5].node, child);
ASSERT_EQ(events[5].type, Event::NodeBaselineStart);
ASSERT_EQ(events[events.size() - 1].node, root);
ASSERT_EQ(events[events.size() - 1].type, Event::LayoutPassEnd);
} | O3 | cpp | facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody():
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
callq 0x366b25
movq %rax, %r14
movq %rax, -0x40(%rbp)
callq 0x366b25
movq %rax, %r15
leaq -0x48(%rbp), %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36703b
leaq 0x1818(%rip), %rsi # 0x70838
movq %r15, %rdi
callq 0x367827
movq %r14, %rdi
movl $0x2, %esi
callq 0x367b49
movq %r14, %rdi
movl $0x5, %esi
callq 0x367bf4
movss 0x329fbe(%rip), %xmm0 # 0x399008
movq %r14, %rdi
movaps %xmm0, %xmm1
movl $0x1, %esi
callq 0x366ffd
movl $0x1e0, %ecx # imm = 0x1E0
addq 0x3e94a2(%rip), %rcx # 0x458508
leaq 0x32a1da(%rip), %rsi # 0x399247
leaq 0x331f47(%rip), %rdx # 0x3a0fbb
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %r8
callq 0x7089d
cmpb $0x0, (%r14)
je 0x6f17e
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6f09f
leaq -0x30(%rbp), %rdi
callq 0x6fd1c
movl $0x1e8, %ecx # imm = 0x1E8
addq 0x3e945d(%rip), %rcx # 0x458508
leaq -0x20(%rbp), %r8
movl $0x7, (%r8)
leaq 0x32a199(%rip), %rsi # 0x399256
leaq 0x32a406(%rip), %rdx # 0x3994ca
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x70b26
cmpb $0x0, (%rbx)
je 0x6f195
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6f0eb
leaq -0x30(%rbp), %rdi
callq 0x6fd1c
movq 0x3e941e(%rip), %rcx # 0x458510
addq $-0x60, %rcx
leaq 0x32a370(%rip), %rsi # 0x39946d
leaq 0x3385f6(%rip), %rdx # 0x3a76fa
leaq -0x40(%rbp), %r8
movq %rbx, %rdi
callq 0x7089d
cmpb $0x0, (%rbx)
je 0x6f1df
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6f12b
leaq -0x30(%rbp), %rdi
callq 0x6fd1c
movq 0x3e93de(%rip), %rcx # 0x458510
addq $-0x58, %rcx
leaq -0x20(%rbp), %r8
movl $0x4, (%r8)
leaq 0x32a344(%rip), %rsi # 0x39948c
leaq 0x32a152(%rip), %rdx # 0x3992a1
movq %rbx, %rdi
callq 0x70b26
cmpb $0x0, (%rbx)
jne 0x6f29c
leaq -0x20(%rbp), %rdi
callq 0x37f68a
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x6f256
movq (%rax), %r8
jmp 0x6f25d
leaq -0x20(%rbp), %rdi
callq 0x37f68a
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x6f1ac
movq (%rax), %r8
jmp 0x6f1b3
leaq -0x20(%rbp), %rdi
callq 0x37f68a
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x6f1f6
movq (%rax), %r8
jmp 0x6f1fd
leaq 0x33a1f7(%rip), %r8 # 0x3a93aa
leaq 0x329ec7(%rip), %rdx # 0x399081
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x119, %ecx # imm = 0x119
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37bc92
jmp 0x6f284
leaq -0x20(%rbp), %rdi
callq 0x37f68a
movq -0x30(%rbp), %rax
testq %rax, %rax
je 0x6f226
movq (%rax), %r8
jmp 0x6f22d
leaq 0x33a1ad(%rip), %r8 # 0x3a93aa
leaq 0x329e7d(%rip), %rdx # 0x399081
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x11a, %ecx # imm = 0x11A
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37bc92
jmp 0x6f284
leaq 0x33a17d(%rip), %r8 # 0x3a93aa
leaq 0x329e4d(%rip), %rdx # 0x399081
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x11c, %ecx # imm = 0x11C
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37bc92
jmp 0x6f284
leaq 0x33a14d(%rip), %r8 # 0x3a93aa
leaq 0x329e1d(%rip), %rdx # 0x399081
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x11d, %ecx # imm = 0x11D
callq 0x37cfa4
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x37bc92
leaq -0x28(%rbp), %rdi
callq 0x37d01c
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x6f29c
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6f2ae
leaq -0x30(%rbp), %rdi
callq 0x6fd1c
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6f2cb
jmp 0x6f2d9
jmp 0x6f2ed
jmp 0x6f2cb
jmp 0x6f2d9
jmp 0x6f2ed
jmp 0x6f2cb
jmp 0x6f2d9
jmp 0x6f2ed
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x37d01c
jmp 0x6f2dc
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x6f2f0
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x6f2f0
movq %rax, %rbx
movq -0x30(%rbp), %rsi
testq %rsi, %rsi
je 0x6f302
leaq -0x30(%rbp), %rdi
callq 0x6fd1c
movq %rbx, %rdi
callq 0x32840
| _ZN8facebook4yoga4test45EventTest_baseline_functions_get_wrapped_Test8TestBodyEv:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 38h
call YGNodeNew
mov r14, rax
mov [rbp+var_40], rax
call YGNodeNew
mov r15, rax
lea rbx, [rbp+var_48]
mov [rbx], rax
mov rdi, r14; this
mov rsi, rax; facebook::yoga::Node *
xor edx, edx; unsigned __int64
call YGNodeInsertChild
lea rsi, _ZZN8facebook4yoga4test45EventTest_baseline_functions_get_wrapped_Test8TestBodyEvEN3$_08__invokeEPK6YGNodeff; facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody(void)::$_0::__invoke(YGNode const*,float,float)
mov rdi, r15
call YGNodeSetBaselineFunc
mov rdi, r14
mov esi, 2
call YGNodeStyleSetFlexDirection
mov rdi, r14
mov esi, 5
call YGNodeStyleSetAlignItems
movss xmm0, cs:dword_399008
mov rdi, r14
movaps xmm1, xmm0
mov esi, 1
call YGNodeCalculateLayout
mov ecx, 1E0h
add rcx, qword ptr cs:_ZN8facebook4yoga4test9EventTest6eventsE; facebook::yoga::test::EventTest::events
lea rsi, aEvents5Node; "events[5].node"
lea rdx, aAlignBaselineD+1Dh; "child"
lea r14, [rbp+var_38]
mov rdi, r14; this
mov r8, rbx
call _ZN7testing8internal11CmpHelperEQIPK6YGNodePS2_EENS_15AssertionResultEPKcS8_RKT_RKT0_; testing::internal::CmpHelperEQ<YGNode const*,YGNode*>(char const*,char const*,YGNode const* const&,YGNode* const&)
cmp byte ptr [r14], 0
jz loc_6F17E
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_6F09F
lea rdi, [rbp+var_30]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_6F09F:
mov ecx, 1E8h
add rcx, qword ptr cs:_ZN8facebook4yoga4test9EventTest6eventsE; facebook::yoga::test::EventTest::events
lea r8, [rbp+var_20]
mov dword ptr [r8], 7
lea rsi, aEvents5Type; "events[5].type"
lea rdx, aEventNodebasel; "Event::NodeBaselineStart"
lea rbx, [rbp+var_38]
mov rdi, rbx; this
call _ZN7testing8internal11CmpHelperEQIN8facebook4yoga5Event4TypeES5_EENS_15AssertionResultEPKcS8_RKT_RKT0_; testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>(char const*,char const*,facebook::yoga::Event::Type const&,facebook::yoga::Event::Type const&)
cmp byte ptr [rbx], 0
jz loc_6F195
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_6F0EB
lea rdi, [rbp+var_30]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_6F0EB:
mov rcx, qword ptr cs:_ZN8facebook4yoga4test9EventTest6eventsE+8; facebook::yoga::test::EventTest::events
add rcx, 0FFFFFFFFFFFFFFA0h
lea rsi, aEventsEventsSi; "events[events.size() - 1].node"
lea rdx, aStaticPosition_53+17h; "root"
lea r8, [rbp+var_40]
mov rdi, rbx; this
call _ZN7testing8internal11CmpHelperEQIPK6YGNodePS2_EENS_15AssertionResultEPKcS8_RKT_RKT0_; testing::internal::CmpHelperEQ<YGNode const*,YGNode*>(char const*,char const*,YGNode const* const&,YGNode* const&)
cmp byte ptr [rbx], 0
jz loc_6F1DF
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_6F12B
lea rdi, [rbp+var_30]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_6F12B:
mov rcx, qword ptr cs:_ZN8facebook4yoga4test9EventTest6eventsE+8; facebook::yoga::test::EventTest::events
add rcx, 0FFFFFFFFFFFFFFA8h
lea r8, [rbp+var_20]
mov dword ptr [r8], 4
lea rsi, aEventsEventsSi_0; "events[events.size() - 1].type"
lea rdx, aEventLayoutpas_0; "Event::LayoutPassEnd"
mov rdi, rbx; this
call _ZN7testing8internal11CmpHelperEQIN8facebook4yoga5Event4TypeES5_EENS_15AssertionResultEPKcS8_RKT_RKT0_; testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>(char const*,char const*,facebook::yoga::Event::Type const&,facebook::yoga::Event::Type const&)
cmp byte ptr [rbx], 0
jnz loc_6F29C
lea rdi, [rbp+var_20]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_30]
test rax, rax
jz loc_6F256
mov r8, [rax]
jmp loc_6F25D
loc_6F17E:
lea rdi, [rbp+var_20]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_30]
test rax, rax
jz short loc_6F1AC
mov r8, [rax]
jmp short loc_6F1B3
loc_6F195:
lea rdi, [rbp+var_20]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_30]
test rax, rax
jz short loc_6F1F6
mov r8, [rax]
jmp short loc_6F1FD
loc_6F1AC:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_6F1B3:
lea rdx, xmmword_399081
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 119h
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_20]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp loc_6F284
loc_6F1DF:
lea rdi, [rbp+var_20]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rax, [rbp+var_30]
test rax, rax
jz short loc_6F226
mov r8, [rax]
jmp short loc_6F22D
loc_6F1F6:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_6F1FD:
lea rdx, xmmword_399081
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 11Ah
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_20]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short loc_6F284
loc_6F226:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_6F22D:
lea rdx, xmmword_399081
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 11Ch
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_20]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
jmp short loc_6F284
loc_6F256:
lea r8, aSFromSSMsTotal+1Ah; ""
loc_6F25D:
lea rdx, xmmword_399081
lea rdi, [rbp+var_28]
mov esi, 2
mov ecx, 11Dh
call _ZN7testing8internal12AssertHelperC2ENS_14TestPartResult4TypeEPKciS5_; testing::internal::AssertHelper::AssertHelper(testing::TestPartResult::Type,char const*,int,char const*)
lea rdi, [rbp+var_28]
lea rsi, [rbp+var_20]
call _ZNK7testing8internal12AssertHelperaSERKNS_7MessageE; testing::internal::AssertHelper::operator=(testing::Message const&)
loc_6F284:
lea rdi, [rbp+var_28]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
mov rdi, [rbp+var_20]
test rdi, rdi
jz short loc_6F29C
mov rax, [rdi]
call qword ptr [rax+8]
loc_6F29C:
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_6F2AE
lea rdi, [rbp+var_30]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_6F2AE:
add rsp, 38h
pop rbx
pop r14
pop r15
pop rbp
retn
jmp short loc_6F2CB
jmp short loc_6F2D9
jmp short loc_6F2ED
jmp short loc_6F2CB
jmp short loc_6F2D9
jmp short loc_6F2ED
jmp short loc_6F2CB
jmp short loc_6F2D9
jmp short loc_6F2ED
loc_6F2CB:
mov rbx, rax
lea rdi, [rbp+var_28]; this
call _ZN7testing8internal12AssertHelperD2Ev; testing::internal::AssertHelper::~AssertHelper()
jmp short loc_6F2DC
loc_6F2D9:
mov rbx, rax
loc_6F2DC:
mov rdi, [rbp+var_20]
test rdi, rdi
jz short loc_6F2F0
mov rax, [rdi]
call qword ptr [rax+8]
jmp short loc_6F2F0
loc_6F2ED:
mov rbx, rax
loc_6F2F0:
mov rsi, [rbp+var_30]
test rsi, rsi
jz short loc_6F302
lea rdi, [rbp+var_30]
call _ZNKSt14default_deleteINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEclEPS5_; std::default_delete<std::string>::operator()(std::string*)
loc_6F302:
mov rdi, rbx
call __Unwind_Resume
| void facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody(
facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test *this)
{
char *v1; // r8
char *v2; // r8
char *v3; // r8
char *v4; // r8
facebook::yoga::Node *v5; // [rsp+8h] [rbp-48h]
facebook::yoga::Node *v6; // [rsp+10h] [rbp-40h]
_BYTE v7[8]; // [rsp+18h] [rbp-38h] BYREF
char **v8; // [rsp+20h] [rbp-30h] BYREF
_BYTE v9[8]; // [rsp+28h] [rbp-28h] BYREF
_QWORD v10[4]; // [rsp+30h] [rbp-20h] BYREF
v6 = (facebook::yoga::Node *)YGNodeNew(this);
v5 = (facebook::yoga::Node *)YGNodeNew(this);
YGNodeInsertChild(v6, v5, 0LL);
YGNodeSetBaselineFunc(
v5,
facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody(void)::$_0::__invoke);
YGNodeStyleSetFlexDirection(v6, 2LL);
YGNodeStyleSetAlignItems(v6, 5LL);
YGNodeCalculateLayout(v6, 1LL, NAN, NAN);
testing::internal::CmpHelperEQ<YGNode const*,YGNode*>((testing *)v7);
if ( !v7[0] )
{
testing::Message::Message((testing::Message *)v10);
if ( v8 )
v2 = *v8;
else
v2 = "";
testing::internal::AssertHelper::AssertHelper(v9, 2LL, &xmmword_399081, 281LL, v2);
testing::internal::AssertHelper::operator=(v9, v10);
LABEL_27:
testing::internal::AssertHelper::~AssertHelper((testing::internal::AssertHelper *)v9);
if ( v10[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v10[0] + 8LL))(v10[0]);
goto LABEL_29;
}
if ( v8 )
std::default_delete<std::string>::operator()(&v8);
LODWORD(v10[0]) = 7;
testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>((testing *)v7);
if ( !v7[0] )
{
testing::Message::Message((testing::Message *)v10);
if ( v8 )
v3 = *v8;
else
v3 = "";
testing::internal::AssertHelper::AssertHelper(v9, 2LL, &xmmword_399081, 282LL, v3);
testing::internal::AssertHelper::operator=(v9, v10);
goto LABEL_27;
}
if ( v8 )
std::default_delete<std::string>::operator()(&v8);
testing::internal::CmpHelperEQ<YGNode const*,YGNode*>((testing *)v7);
if ( !v7[0] )
{
testing::Message::Message((testing::Message *)v10);
if ( v8 )
v4 = *v8;
else
v4 = "";
testing::internal::AssertHelper::AssertHelper(v9, 2LL, &xmmword_399081, 284LL, v4);
testing::internal::AssertHelper::operator=(v9, v10);
goto LABEL_27;
}
if ( v8 )
std::default_delete<std::string>::operator()(&v8);
LODWORD(v10[0]) = 4;
testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>((testing *)v7);
if ( !v7[0] )
{
testing::Message::Message((testing::Message *)v10);
if ( v8 )
v1 = *v8;
else
v1 = "";
testing::internal::AssertHelper::AssertHelper(v9, 2LL, &xmmword_399081, 285LL, v1);
testing::internal::AssertHelper::operator=(v9, v10);
goto LABEL_27;
}
LABEL_29:
if ( v8 )
std::default_delete<std::string>::operator()(&v8);
}
| TestBody:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x38
CALL 0x00466b25
MOV R14,RAX
MOV qword ptr [RBP + -0x40],RAX
CALL 0x00466b25
MOV R15,RAX
LEA RBX,[RBP + -0x48]
MOV qword ptr [RBX],RAX
MOV RDI,R14
MOV RSI,RAX
XOR EDX,EDX
CALL 0x0046703b
LEA RSI,[0x170838]
MOV RDI,R15
CALL 0x00467827
MOV RDI,R14
MOV ESI,0x2
CALL 0x00467b49
MOV RDI,R14
MOV ESI,0x5
CALL 0x00467bf4
MOVSS XMM0,dword ptr [0x00499008]
MOV RDI,R14
MOVAPS XMM1,XMM0
MOV ESI,0x1
CALL 0x00466ffd
MOV ECX,0x1e0
ADD RCX,qword ptr [0x00558508]
LEA RSI,[0x499247]
LEA RDX,[0x4a0fbb]
LEA R14,[RBP + -0x38]
MOV RDI,R14
MOV R8,RBX
CALL 0x0017089d
CMP byte ptr [R14],0x0
JZ 0x0016f17e
MOV RSI,qword ptr [RBP + -0x30]
TEST RSI,RSI
JZ 0x0016f09f
LEA RDI,[RBP + -0x30]
CALL 0x0016fd1c
LAB_0016f09f:
MOV ECX,0x1e8
ADD RCX,qword ptr [0x00558508]
LEA R8,[RBP + -0x20]
MOV dword ptr [R8],0x7
LEA RSI,[0x499256]
LEA RDX,[0x4994ca]
LEA RBX,[RBP + -0x38]
MOV RDI,RBX
CALL 0x00170b26
CMP byte ptr [RBX],0x0
JZ 0x0016f195
MOV RSI,qword ptr [RBP + -0x30]
TEST RSI,RSI
JZ 0x0016f0eb
LEA RDI,[RBP + -0x30]
CALL 0x0016fd1c
LAB_0016f0eb:
MOV RCX,qword ptr [0x00558510]
ADD RCX,-0x60
LEA RSI,[0x49946d]
LEA RDX,[0x4a76fa]
LEA R8,[RBP + -0x40]
MOV RDI,RBX
CALL 0x0017089d
CMP byte ptr [RBX],0x0
JZ 0x0016f1df
MOV RSI,qword ptr [RBP + -0x30]
TEST RSI,RSI
JZ 0x0016f12b
LEA RDI,[RBP + -0x30]
CALL 0x0016fd1c
LAB_0016f12b:
MOV RCX,qword ptr [0x00558510]
ADD RCX,-0x58
LEA R8,[RBP + -0x20]
MOV dword ptr [R8],0x4
LEA RSI,[0x49948c]
LEA RDX,[0x4992a1]
MOV RDI,RBX
CALL 0x00170b26
CMP byte ptr [RBX],0x0
JNZ 0x0016f29c
LAB_0016f160:
LEA RDI,[RBP + -0x20]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x30]
TEST RAX,RAX
JZ 0x0016f256
MOV R8,qword ptr [RAX]
JMP 0x0016f25d
LAB_0016f17e:
LEA RDI,[RBP + -0x20]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x30]
TEST RAX,RAX
JZ 0x0016f1ac
MOV R8,qword ptr [RAX]
JMP 0x0016f1b3
LAB_0016f195:
LEA RDI,[RBP + -0x20]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x30]
TEST RAX,RAX
JZ 0x0016f1f6
MOV R8,qword ptr [RAX]
JMP 0x0016f1fd
LAB_0016f1ac:
LEA R8,[0x4a93aa]
LAB_0016f1b3:
LEA RDX,[0x499081]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x119
CALL 0x0047cfa4
LAB_0016f1cd:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x20]
CALL 0x0047bc92
JMP 0x0016f284
LAB_0016f1df:
LEA RDI,[RBP + -0x20]
CALL 0x0047f68a
MOV RAX,qword ptr [RBP + -0x30]
TEST RAX,RAX
JZ 0x0016f226
MOV R8,qword ptr [RAX]
JMP 0x0016f22d
LAB_0016f1f6:
LEA R8,[0x4a93aa]
LAB_0016f1fd:
LEA RDX,[0x499081]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x11a
CALL 0x0047cfa4
LAB_0016f217:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x20]
CALL 0x0047bc92
JMP 0x0016f284
LAB_0016f226:
LEA R8,[0x4a93aa]
LAB_0016f22d:
LEA RDX,[0x499081]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x11c
CALL 0x0047cfa4
LAB_0016f247:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x20]
CALL 0x0047bc92
JMP 0x0016f284
LAB_0016f256:
LEA R8,[0x4a93aa]
LAB_0016f25d:
LEA RDX,[0x499081]
LEA RDI,[RBP + -0x28]
MOV ESI,0x2
MOV ECX,0x11d
CALL 0x0047cfa4
LAB_0016f277:
LEA RDI,[RBP + -0x28]
LEA RSI,[RBP + -0x20]
CALL 0x0047bc92
LAB_0016f284:
LEA RDI,[RBP + -0x28]
CALL 0x0047d01c
MOV RDI,qword ptr [RBP + -0x20]
TEST RDI,RDI
JZ 0x0016f29c
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0016f29c:
MOV RSI,qword ptr [RBP + -0x30]
TEST RSI,RSI
JZ 0x0016f2ae
LEA RDI,[RBP + -0x30]
CALL 0x0016fd1c
LAB_0016f2ae:
ADD RSP,0x38
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody() */
void facebook::yoga::test::EventTest_baseline_functions_get_wrapped_Test::TestBody(void)
{
YGNode *pYVar1;
YGNode *pYVar2;
char *pcVar3;
YGNode *local_50;
YGNode *local_48;
internal local_40 [8];
string *local_38;
AssertHelper local_30 [8];
int4 local_28;
int4 uStack_24;
pYVar1 = (YGNode *)YGNodeNew();
local_48 = pYVar1;
pYVar2 = (YGNode *)YGNodeNew();
local_50 = pYVar2;
YGNodeInsertChild(pYVar1,pYVar2,0);
YGNodeSetBaselineFunc(pYVar2,TestBody()::$_0::__invoke);
YGNodeStyleSetFlexDirection(pYVar1,2);
YGNodeStyleSetAlignItems(pYVar1,5);
YGNodeCalculateLayout(DAT_00499008,DAT_00499008,pYVar1,1);
testing::internal::CmpHelperEQ<YGNode_const*,YGNode*>
(local_40,"events[5].node","child",(YGNode **)(EventTest::events + 0x1e0),&local_50);
if (local_40[0] == (internal)0x0) {
/* try { // try from 0016f17e to 0016f186 has its CatchHandler @ 0016f2ed */
testing::Message::Message((Message *)&local_28);
if (local_38 == (string *)0x0) {
pcVar3 = "";
}
else {
pcVar3 = *(char **)local_38;
}
/* try { // try from 0016f1b3 to 0016f1cc has its CatchHandler @ 0016f2d9 */
testing::internal::AssertHelper::AssertHelper
(local_30,2,"/workspace/llm4binary/github2025/yoga-mod/tests/EventsTest.cpp",0x119,
pcVar3);
/* try { // try from 0016f1cd to 0016f1d9 has its CatchHandler @ 0016f2cb */
testing::internal::AssertHelper::operator=(local_30,(Message *)&local_28);
}
else {
if (local_38 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_38,local_38);
}
local_28 = 7;
testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>
(local_40,"events[5].type","Event::NodeBaselineStart",
(Type *)(EventTest::events + 0x1e8),(Type *)&local_28);
if (local_40[0] == (internal)0x0) {
/* try { // try from 0016f195 to 0016f19d has its CatchHandler @ 0016f2c9 */
testing::Message::Message((Message *)&local_28);
if (local_38 == (string *)0x0) {
pcVar3 = "";
}
else {
pcVar3 = *(char **)local_38;
}
/* try { // try from 0016f1fd to 0016f216 has its CatchHandler @ 0016f2c7 */
testing::internal::AssertHelper::AssertHelper
(local_30,2,"/workspace/llm4binary/github2025/yoga-mod/tests/EventsTest.cpp",0x11a,
pcVar3);
/* try { // try from 0016f217 to 0016f223 has its CatchHandler @ 0016f2c5 */
testing::internal::AssertHelper::operator=(local_30,(Message *)&local_28);
}
else {
if (local_38 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_38,local_38);
}
testing::internal::CmpHelperEQ<YGNode_const*,YGNode*>
(local_40,"events[events.size() - 1].node","root",(YGNode **)(DAT_00558510 + -0x60),
&local_48);
if (local_40[0] == (internal)0x0) {
/* try { // try from 0016f1df to 0016f1e7 has its CatchHandler @ 0016f2c3 */
testing::Message::Message((Message *)&local_28);
if (local_38 == (string *)0x0) {
pcVar3 = "";
}
else {
pcVar3 = *(char **)local_38;
}
/* try { // try from 0016f22d to 0016f246 has its CatchHandler @ 0016f2c1 */
testing::internal::AssertHelper::AssertHelper
(local_30,2,"/workspace/llm4binary/github2025/yoga-mod/tests/EventsTest.cpp",0x11c
,pcVar3);
/* try { // try from 0016f247 to 0016f253 has its CatchHandler @ 0016f2bf */
testing::internal::AssertHelper::operator=(local_30,(Message *)&local_28);
}
else {
if (local_38 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_38,local_38);
}
local_28 = 4;
testing::internal::CmpHelperEQ<facebook::yoga::Event::Type,facebook::yoga::Event::Type>
(local_40,"events[events.size() - 1].type","Event::LayoutPassEnd",
(Type *)(DAT_00558510 + -0x58),(Type *)&local_28);
if (local_40[0] != (internal)0x0) goto LAB_0016f29c;
/* try { // try from 0016f160 to 0016f168 has its CatchHandler @ 0016f2bd */
testing::Message::Message((Message *)&local_28);
if (local_38 == (string *)0x0) {
pcVar3 = "";
}
else {
pcVar3 = *(char **)local_38;
}
/* try { // try from 0016f25d to 0016f276 has its CatchHandler @ 0016f2bb */
testing::internal::AssertHelper::AssertHelper
(local_30,2,"/workspace/llm4binary/github2025/yoga-mod/tests/EventsTest.cpp",0x11d
,pcVar3);
/* try { // try from 0016f277 to 0016f283 has its CatchHandler @ 0016f2b9 */
testing::internal::AssertHelper::operator=(local_30,(Message *)&local_28);
}
}
}
testing::internal::AssertHelper::~AssertHelper(local_30);
if ((long *)CONCAT44(uStack_24,local_28) != (long *)0x0) {
(**(code **)(*(long *)CONCAT44(uStack_24,local_28) + 8))();
}
LAB_0016f29c:
if (local_38 != (string *)0x0) {
std::default_delete<std::__cxx11::string>::operator()
((default_delete<std::__cxx11::string> *)&local_38,local_38);
}
return;
}
| |
22,244 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O0 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0xffffff, -0x28(%rbp) # imm = 0xFFFFFF
jb 0x46e90
movq $0xffffff, -0x30(%rbp) # imm = 0xFFFFFF
movb $-0x1, -0xc(%rbp)
movb $-0x1, -0xb(%rbp)
movb $-0x1, -0xa(%rbp)
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rcx)
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x46f30
cmpl $0x0, %eax
jne 0x46e63
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0xffffff, %edx # imm = 0xFFFFFF
callq 0x46f30
cmpl $0x0, %eax
je 0x46e6f
movl $0x1, -0x10(%rbp)
jmp 0x46efe
movq -0x20(%rbp), %rax
addq $0xffffff, %rax # imm = 0xFFFFFF
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
subq $0xffffff, %rax # imm = 0xFFFFFF
movq %rax, -0x28(%rbp)
jmp 0x46e01
jmp 0x46e92
movq -0x28(%rbp), %rax
movb %al, -0xc(%rbp)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movb %al, -0xb(%rbp)
movq -0x28(%rbp), %rax
shrq $0x10, %rax
movb %al, -0xa(%rbp)
movq -0x18(%rbp), %rcx
movl 0x60(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x60(%rcx)
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x46f30
cmpl $0x0, %eax
jne 0x46eee
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x46f30
cmpl $0x0, %eax
je 0x46ef7
movl $0x1, -0x10(%rbp)
jmp 0x46efe
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x46f1f
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x134b0
nopw %cs:(%rax,%rax)
| ma_net_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
loc_46E01:
cmp [rbp+var_28], 0FFFFFFh
jb loc_46E90
mov [rbp+var_30], 0FFFFFFh
mov [rbp+var_C], 0FFh
mov [rbp+var_B], 0FFh
mov [rbp+var_A], 0FFh
mov rcx, [rbp+var_18]
mov eax, [rcx+60h]
mov edx, eax
add edx, 1
mov [rcx+60h], edx
mov [rbp+var_9], al
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_C]
mov edx, 4
call ma_net_write_buff
cmp eax, 0
jnz short loc_46E63
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov edx, 0FFFFFFh
call ma_net_write_buff
cmp eax, 0
jz short loc_46E6F
loc_46E63:
mov [rbp+var_10], 1
jmp loc_46EFE
loc_46E6F:
mov rax, [rbp+var_20]
add rax, 0FFFFFFh
mov [rbp+var_20], rax
mov rax, [rbp+var_28]
sub rax, 0FFFFFFh
mov [rbp+var_28], rax
jmp loc_46E01
loc_46E90:
jmp short $+2
loc_46E92:
mov rax, [rbp+var_28]
mov [rbp+var_C], al
mov rax, [rbp+var_28]
shr rax, 8
mov [rbp+var_B], al
mov rax, [rbp+var_28]
shr rax, 10h
mov [rbp+var_A], al
mov rcx, [rbp+var_18]
mov eax, [rcx+60h]
mov edx, eax
add edx, 1
mov [rcx+60h], edx
mov [rbp+var_9], al
mov rdi, [rbp+var_18]
lea rsi, [rbp+var_C]
mov edx, 4
call ma_net_write_buff
cmp eax, 0
jnz short loc_46EEE
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_28]
call ma_net_write_buff
cmp eax, 0
jz short loc_46EF7
loc_46EEE:
mov [rbp+var_10], 1
jmp short loc_46EFE
loc_46EF7:
mov [rbp+var_10], 0
loc_46EFE:
mov eax, [rbp+var_10]
mov [rbp+var_34], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_46F1F
mov eax, [rbp+var_34]
add rsp, 40h
pop rbp
retn
loc_46F1F:
call ___stack_chk_fail
| _BOOL8 ma_net_write(long long a1, long long a2, unsigned long long a3)
{
int v3; // eax
int v4; // eax
__int16 v9; // [rsp+34h] [rbp-Ch] BYREF
char v10; // [rsp+36h] [rbp-Ah]
char v11; // [rsp+37h] [rbp-9h]
unsigned long long v12; // [rsp+38h] [rbp-8h]
v12 = __readfsqword(0x28u);
while ( a3 >= 0xFFFFFF )
{
v9 = -1;
v10 = -1;
v3 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v3 + 1;
v11 = v3;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
return 1;
a2 += 0xFFFFFFLL;
a3 -= 0xFFFFFFLL;
}
v9 = a3;
v10 = BYTE2(a3);
v4 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v4 + 1;
v11 = v4;
return (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, a3);
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
LAB_00146e01:
CMP qword ptr [RBP + -0x28],0xffffff
JC 0x00146e90
MOV qword ptr [RBP + -0x30],0xffffff
MOV byte ptr [RBP + -0xc],0xff
MOV byte ptr [RBP + -0xb],0xff
MOV byte ptr [RBP + -0xa],0xff
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x60]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x60],EDX
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0xc]
MOV EDX,0x4
CALL 0x00146f30
CMP EAX,0x0
JNZ 0x00146e63
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV EDX,0xffffff
CALL 0x00146f30
CMP EAX,0x0
JZ 0x00146e6f
LAB_00146e63:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00146efe
LAB_00146e6f:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0xffffff
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x28]
SUB RAX,0xffffff
MOV qword ptr [RBP + -0x28],RAX
JMP 0x00146e01
LAB_00146e90:
JMP 0x00146e92
LAB_00146e92:
MOV RAX,qword ptr [RBP + -0x28]
MOV byte ptr [RBP + -0xc],AL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x8
MOV byte ptr [RBP + -0xb],AL
MOV RAX,qword ptr [RBP + -0x28]
SHR RAX,0x10
MOV byte ptr [RBP + -0xa],AL
MOV RCX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RCX + 0x60]
MOV EDX,EAX
ADD EDX,0x1
MOV dword ptr [RCX + 0x60],EDX
MOV byte ptr [RBP + -0x9],AL
MOV RDI,qword ptr [RBP + -0x18]
LEA RSI,[RBP + -0xc]
MOV EDX,0x4
CALL 0x00146f30
CMP EAX,0x0
JNZ 0x00146eee
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x28]
CALL 0x00146f30
CMP EAX,0x0
JZ 0x00146ef7
LAB_00146eee:
MOV dword ptr [RBP + -0x10],0x1
JMP 0x00146efe
LAB_00146ef7:
MOV dword ptr [RBP + -0x10],0x0
LAB_00146efe:
MOV EAX,dword ptr [RBP + -0x10]
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00146f1f
MOV EAX,dword ptr [RBP + -0x34]
ADD RSP,0x40
POP RBP
RET
LAB_00146f1f:
CALL 0x001134b0
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
long in_FS_OFFSET;
ulong local_30;
long local_28;
int4 local_18;
int1 local_14;
int1 local_13;
int1 local_12;
int1 local_11;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_28 = param_2;
for (local_30 = param_3; 0xfffffe < local_30; local_30 = local_30 - 0xffffff) {
local_14 = 0xff;
local_13 = 0xff;
local_12 = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_11 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_14,4);
if (iVar1 != 0) {
LAB_00146e63:
local_18 = 1;
goto LAB_00146efe;
}
iVar1 = ma_net_write_buff(param_1,local_28,0xffffff);
if (iVar1 != 0) goto LAB_00146e63;
local_28 = local_28 + 0xffffff;
}
local_14 = (int1)local_30;
local_13 = (int1)(local_30 >> 8);
local_12 = (int1)(local_30 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_11 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_14,4);
if (iVar1 == 0) {
iVar1 = ma_net_write_buff(param_1,local_28,local_30);
if (iVar1 == 0) {
local_18 = 0;
goto LAB_00146efe;
}
}
local_18 = 1;
LAB_00146efe:
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_18;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,245 | ma_net_write | eloqsql/libmariadb/libmariadb/ma_net.c | int ma_net_write(NET *net, const uchar *packet, size_t len)
{
uchar buff[NET_HEADER_SIZE];
while (len >= MAX_PACKET_LENGTH)
{
const ulong max_len= MAX_PACKET_LENGTH;
int3store(buff,max_len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, max_len))
return 1;
packet+= max_len;
len-= max_len;
}
/* write last remaining packet, size can be zero */
int3store(buff, len);
buff[3]= (uchar)net->pkt_nr++;
if (ma_net_write_buff(net,(char*) buff,NET_HEADER_SIZE) ||
ma_net_write_buff(net, (char *)packet, len))
return 1;
return 0;
} | O3 | c | ma_net_write:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpq $0xffffff, %rdx # imm = 0xFFFFFF
jb 0x31e60
leaq -0x34(%rbp), %r12
movl $0x1, %r13d
movw $0xffff, -0x34(%rbp) # imm = 0xFFFF
movb $-0x1, -0x32(%rbp)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, -0x31(%rbp)
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x31ecd
testl %eax, %eax
jne 0x31ea7
movl $0xffffff, %edx # imm = 0xFFFFFF
movq %r15, %rdi
movq %r14, %rsi
callq 0x31ecd
testl %eax, %eax
jne 0x31ea7
addq $0xffffff, %r14 # imm = 0xFFFFFF
addq $-0xffffff, %rbx # imm = 0xFF000001
cmpq $0xfffffe, %rbx # imm = 0xFFFFFE
ja 0x31e09
leaq -0x34(%rbp), %rsi
movb %bl, (%rsi)
movb %bh, -0x33(%rbp)
movl %ebx, %eax
shrl $0x10, %eax
movb %al, 0x2(%rsi)
movl 0x60(%r15), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x60(%r15)
movb %al, 0x3(%rsi)
movl $0x4, %edx
movq %r15, %rdi
callq 0x31ecd
movl $0x1, %r13d
testl %eax, %eax
jne 0x31ea7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x31ecd
movl %eax, %r13d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x31ec8
movl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13500
| ma_net_write:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp rdx, 0FFFFFFh
jb short loc_31E60
lea r12, [rbp+var_34]
mov r13d, 1
loc_31E09:
mov [rbp+var_34], 0FFFFh
mov [rbp+var_32], 0FFh
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rbp+var_31], al
mov edx, 4
mov rdi, r15
mov rsi, r12
call ma_net_write_buff
test eax, eax
jnz short loc_31EA7
mov edx, 0FFFFFFh
mov rdi, r15
mov rsi, r14
call ma_net_write_buff
test eax, eax
jnz short loc_31EA7
add r14, 0FFFFFFh
add rbx, 0FFFFFFFFFF000001h
cmp rbx, 0FFFFFEh
ja short loc_31E09
loc_31E60:
lea rsi, [rbp+var_34]
mov [rsi], bl
mov byte ptr [rbp+var_34+1], bh
mov eax, ebx
shr eax, 10h
mov [rsi+2], al
mov eax, [r15+60h]
lea ecx, [rax+1]
mov [r15+60h], ecx
mov [rsi+3], al
mov edx, 4
mov rdi, r15
call ma_net_write_buff
mov r13d, 1
test eax, eax
jnz short loc_31EA7
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call ma_net_write_buff
mov r13d, eax
loc_31EA7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_31EC8
mov eax, r13d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_31EC8:
call ___stack_chk_fail
| long long ma_net_write(long long a1, long long a2, unsigned long long a3)
{
unsigned long long v3; // rbx
unsigned int v5; // r13d
int v6; // eax
int v7; // eax
__int16 v9; // [rsp+Ch] [rbp-34h] BYREF
char v10; // [rsp+Eh] [rbp-32h]
char v11; // [rsp+Fh] [rbp-31h]
unsigned long long v12; // [rsp+10h] [rbp-30h]
v3 = a3;
v12 = __readfsqword(0x28u);
if ( a3 < 0xFFFFFF )
{
LABEL_6:
v9 = v3;
v10 = BYTE2(v3);
v7 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v7 + 1;
v11 = v7;
v5 = 1;
if ( !(unsigned int)ma_net_write_buff(a1, &v9, 4LL) )
return (unsigned int)ma_net_write_buff(a1, a2, v3);
}
else
{
v5 = 1;
while ( 1 )
{
v9 = -1;
v10 = -1;
v6 = *(_DWORD *)(a1 + 96);
*(_DWORD *)(a1 + 96) = v6 + 1;
v11 = v6;
if ( (unsigned int)ma_net_write_buff(a1, &v9, 4LL) || (unsigned int)ma_net_write_buff(a1, a2, 0xFFFFFFLL) )
break;
a2 += 0xFFFFFFLL;
v3 -= 0xFFFFFFLL;
if ( v3 <= 0xFFFFFE )
goto LABEL_6;
}
}
return v5;
}
| ma_net_write:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP RDX,0xffffff
JC 0x00131e60
LEA R12,[RBP + -0x34]
MOV R13D,0x1
LAB_00131e09:
MOV word ptr [RBP + -0x34],0xffff
MOV byte ptr [RBP + -0x32],0xff
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RBP + -0x31],AL
MOV EDX,0x4
MOV RDI,R15
MOV RSI,R12
CALL 0x00131ecd
TEST EAX,EAX
JNZ 0x00131ea7
MOV EDX,0xffffff
MOV RDI,R15
MOV RSI,R14
CALL 0x00131ecd
TEST EAX,EAX
JNZ 0x00131ea7
ADD R14,0xffffff
ADD RBX,-0xffffff
CMP RBX,0xfffffe
JA 0x00131e09
LAB_00131e60:
LEA RSI,[RBP + -0x34]
MOV byte ptr [RSI],BL
MOV byte ptr [RBP + -0x33],BH
MOV EAX,EBX
SHR EAX,0x10
MOV byte ptr [RSI + 0x2],AL
MOV EAX,dword ptr [R15 + 0x60]
LEA ECX,[RAX + 0x1]
MOV dword ptr [R15 + 0x60],ECX
MOV byte ptr [RSI + 0x3],AL
MOV EDX,0x4
MOV RDI,R15
CALL 0x00131ecd
MOV R13D,0x1
TEST EAX,EAX
JNZ 0x00131ea7
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x00131ecd
MOV R13D,EAX
LAB_00131ea7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00131ec8
MOV EAX,R13D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00131ec8:
CALL 0x00113500
|
int4 ma_net_write(long param_1,long param_2,ulong param_3)
{
int iVar1;
int4 uVar2;
long in_FS_OFFSET;
int2 local_3c;
int1 local_3a;
int1 local_39;
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (0xfffffe < param_3) {
uVar2 = 1;
do {
local_3c = 0xffff;
local_3a = 0xff;
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
if (iVar1 != 0) goto LAB_00131ea7;
iVar1 = ma_net_write_buff(param_1,param_2,0xffffff);
if (iVar1 != 0) goto LAB_00131ea7;
param_2 = param_2 + 0xffffff;
param_3 = param_3 - 0xffffff;
} while (0xfffffe < param_3);
}
local_3c = (int2)param_3;
local_3a = (int1)(param_3 >> 0x10);
iVar1 = *(int *)(param_1 + 0x60);
*(int *)(param_1 + 0x60) = iVar1 + 1;
local_39 = (int1)iVar1;
iVar1 = ma_net_write_buff(param_1,&local_3c,4);
uVar2 = 1;
if (iVar1 == 0) {
uVar2 = ma_net_write_buff(param_1,param_2,param_3);
}
LAB_00131ea7:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,246 | Geometry::append_points(String*, unsigned int, char const*, unsigned int) const | eloqsql/sql/spatial.cc | const char *Geometry::append_points(String *txt, uint32 n_points,
const char *data, uint32 offset) const
{
while (n_points--)
{
double x,y;
data+= offset;
get_point(&x, &y, data);
data+= POINT_DATA_SIZE;
txt->qs_append(x);
txt->qs_append(' ');
txt->qs_append(y);
txt->qs_append(',');
}
return data;
} | O0 | cpp | Geometry::append_points(String*, unsigned int, char const*, unsigned int) const:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0xa6fff5
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xa70000
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movsd -0x30(%rbp), %xmm0
callq 0x492160
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x20, %esi
callq 0x4b41f0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movsd -0x38(%rbp), %xmm0
callq 0x492160
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x2c, %esi
callq 0x4b41f0
jmp 0xa6ff6b
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
| _ZNK8Geometry13append_pointsEP6StringjPKcj:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
mov [rbp+var_20], rcx
mov [rbp+var_24], r8d
loc_A6FF6B:
mov eax, [rbp+var_14]
mov ecx, eax
add ecx, 0FFFFFFFFh
mov [rbp+var_14], ecx
cmp eax, 0
jz short loc_A6FFF5
mov ecx, [rbp+var_24]
mov rax, [rbp+var_20]
mov ecx, ecx
add rax, rcx
mov [rbp+var_20], rax
mov rdx, [rbp+var_20]; char *
lea rdi, [rbp+var_30]; double *
lea rsi, [rbp+var_38]; double *
call _ZL9get_pointPdS_PKc; get_point(double *,double *,char const*)
mov rax, [rbp+var_20]
add rax, 10h
mov [rbp+var_20], rax
mov rdi, [rbp+var_10]
add rdi, 8; this
movsd xmm0, [rbp+var_30]; double
call _ZN13Binary_string9qs_appendEd; Binary_string::qs_append(double)
mov rdi, [rbp+var_10]
add rdi, 8; this
mov esi, 20h ; ' '; char
call _ZN13Binary_string9qs_appendEc; Binary_string::qs_append(char)
mov rdi, [rbp+var_10]
add rdi, 8; this
movsd xmm0, [rbp+var_38]; double
call _ZN13Binary_string9qs_appendEd; Binary_string::qs_append(double)
mov rdi, [rbp+var_10]
add rdi, 8; this
mov esi, 2Ch ; ','; char
call _ZN13Binary_string9qs_appendEc; Binary_string::qs_append(char)
jmp loc_A6FF6B
loc_A6FFF5:
mov rax, [rbp+var_20]
add rsp, 40h
pop rbp
retn
| char * Geometry::append_points(Geometry *this, String *a2, int a3, char *a4, unsigned int a5)
{
double v7; // [rsp+8h] [rbp-38h] BYREF
double v8; // [rsp+10h] [rbp-30h] BYREF
unsigned int v9; // [rsp+1Ch] [rbp-24h]
char *v10; // [rsp+20h] [rbp-20h]
int v11; // [rsp+2Ch] [rbp-14h]
String *v12; // [rsp+30h] [rbp-10h]
Geometry *v13; // [rsp+38h] [rbp-8h]
v13 = this;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a5;
while ( v11-- )
{
v10 += v9;
get_point(&v8, &v7, v10);
v10 += 16;
Binary_string::qs_append((String *)((char *)v12 + 8), v8);
Binary_string::qs_append((String *)((char *)v12 + 8), 32);
Binary_string::qs_append((String *)((char *)v12 + 8), v7);
Binary_string::qs_append((String *)((char *)v12 + 8), 44);
}
return v10;
}
| ~Item_func_is_used_lock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RDI
CALL 0x00a6ff10
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0xc8
CALL 0x005b7780
ADD RSP,0x10
POP RBP
RET
|
/* Item_func_is_used_lock::~Item_func_is_used_lock() */
void __thiscall Item_func_is_used_lock::~Item_func_is_used_lock(Item_func_is_used_lock *this)
{
~Item_func_is_used_lock(this);
Item::operator_delete(this,200);
return;
}
| |
22,247 | MY_RELAX_CPU() | eloqsql/include/my_cpu.h | static inline void MY_RELAX_CPU(void)
{
#ifdef _WIN32
/*
In the Win32 API, the x86 PAUSE instruction is executed by calling
the YieldProcessor macro defined in WinNT.h. It is a CPU architecture-
independent way by using YieldProcessor.
*/
YieldProcessor();
#elif defined HAVE_PAUSE_INSTRUCTION
/*
According to the gcc info page, asm volatile means that the
instruction has important side-effects and must not be removed.
Also asm volatile may trigger a memory barrier (spilling all registers
to memory).
*/
#ifdef __SUNPRO_CC
asm ("pause" );
#else
__asm__ __volatile__ ("pause");
#endif
#elif defined(_ARCH_PWR8)
__ppc_get_timebase();
#elif defined __GNUC__ && (defined __arm__ || defined __aarch64__)
/* Mainly, prevent the compiler from optimizing away delay loops */
__asm__ __volatile__ ("":::"memory");
#else
int32 var, oldval = 0;
my_atomic_cas32_strong_explicit(&var, &oldval, 1, MY_MEMORY_ORDER_RELAXED,
MY_MEMORY_ORDER_RELAXED);
#endif
} | O0 | c | MY_RELAX_CPU():
pushq %rbp
movq %rsp, %rbp
pause
popq %rbp
retq
nopl (%rax,%rax)
| _ZL12MY_RELAX_CPUv:
push rbp
mov rbp, rsp
pause
pop rbp
retn
| void MY_RELAX_CPU(void)
{
_mm_pause();
}
| MY_RELAX_CPU:
PUSH RBP
MOV RBP,RSP
PAUSE
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* MY_RELAX_CPU() */
void MY_RELAX_CPU(void)
{
return;
}
| |
22,248 | ftxui::text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Andrewchistyakov[P]flashcards_lyc/build_O2/_deps/ftxui-src/src/ftxui/dom/text.cpp | Element text(std::string text) {
return std::make_shared<Text>(std::move(text));
} | O2 | cpp | ftxui::text(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x1ffbf
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x13452
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _ZN5ftxui4textENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
push rbx
sub rsp, 10h
mov rbx, rdi
mov rdi, rsp
call _ZSt11make_sharedIN5ftxui12_GLOBAL__N_14TextEJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESt10shared_ptrIT_EDpOT0_; std::make_shared<ftxui::`anonymous namespace'::Text,std::string>(std::string &&)
lea rdi, [rsp+18h+var_10]
movaps xmm0, xmmword ptr [rdi-8]
and qword ptr [rdi], 0
movups xmmword ptr [rbx], xmm0
and qword ptr [rdi-8], 0
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _OWORD * ftxui::text(_OWORD *a1, int a2, int a3, int a4, int a5, int a6)
{
__int128 v6; // xmm0
__int128 v8; // [rsp+0h] [rbp-18h] BYREF
char v9; // [rsp+10h] [rbp-8h]
std::make_shared<ftxui::`anonymous namespace'::Text,std::string>(
(unsigned int)&v8,
a2,
a3,
a4,
a5,
a6,
v8,
DWORD2(v8),
v9);
v6 = v8;
*((_QWORD *)&v8 + 1) = 0LL;
*a1 = v6;
*(_QWORD *)&v8 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count((_QWORD *)&v8 + 1);
return a1;
}
| text:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RDI,RSP
CALL 0x0011ffbf
LEA RDI,[RSP + 0x8]
MOVAPS XMM0,xmmword ptr [RDI + -0x8]
AND qword ptr [RDI],0x0
MOVUPS xmmword ptr [RBX],XMM0
AND qword ptr [RDI + -0x8],0x0
CALL 0x00113452
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* ftxui::text(std::__cxx11::string) */
int8 * ftxui::text(int8 *param_1)
{
int8 uVar1;
int8 local_18;
int8 uStack_10;
std::make_shared<ftxui::(anonymous_namespace)::Text,std::__cxx11::string>((string *)&local_18);
uVar1 = uStack_10;
uStack_10 = 0;
*param_1 = local_18;
param_1[1] = uVar1;
local_18 = 0;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_10);
return param_1;
}
| |
22,249 | mysql_select_db_start_internal | eloqsql/libmariadb/libmariadb/mariadb_async.c | static void
mysql_select_db_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_select_db,
(parms->mysql, parms->db),
parms->mysql,
int,
r_int)
} | O0 | c | mysql_select_db_start_internal:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x480(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x42270
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| mysql_select_db_start_internal:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+480h]
mov rax, [rax+28h]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rdi, [rax]
mov rax, [rbp+var_10]
mov rsi, [rax+8]
call mysql_select_db
mov [rbp+var_14], eax
mov ecx, [rbp+var_14]
mov rax, [rbp+var_20]
mov [rax+8], ecx
mov rax, [rbp+var_20]
mov dword ptr [rax], 0
add rsp, 20h
pop rbp
retn
| _DWORD * mysql_select_db_start_internal(long long *a1)
{
_DWORD *result; // rax
_DWORD *v2; // [rsp+0h] [rbp-20h]
v2 = *(_DWORD **)(*(_QWORD *)(*a1 + 1152) + 40LL);
v2[2] = mysql_select_db(*a1, a1[1]);
result = v2;
*v2 = 0;
return result;
}
| mysql_select_db_start_internal:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x480]
MOV RAX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RAX + 0x8]
CALL 0x00142270
MOV dword ptr [RBP + -0x14],EAX
MOV ECX,dword ptr [RBP + -0x14]
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x8],ECX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX],0x0
ADD RSP,0x20
POP RBP
RET
|
void mysql_select_db_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*param_1 + 0x480) + 0x28);
uVar2 = mysql_select_db(*param_1,param_1[1]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
| |
22,250 | decimal_operation_results(int, char const*, char const*) | eloqsql/sql/my_decimal.cc | int decimal_operation_results(int result, const char *value, const char *type)
{
/* Avoid calling current_thd on default path */
if (likely(result == E_DEC_OK))
return(result);
THD *thd= current_thd;
switch (result) {
case E_DEC_TRUNCATED:
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_DATA_TRUNCATED, ER_THD(thd, ER_DATA_TRUNCATED),
value, type);
break;
case E_DEC_OVERFLOW:
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_DATA_OVERFLOW, ER_THD(thd, ER_DATA_OVERFLOW),
value, type);
break;
case E_DEC_DIV_ZERO:
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_DIVISION_BY_ZERO, ER_THD(thd, ER_DIVISION_BY_ZERO));
break;
case E_DEC_BAD_NUM:
push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
ER_BAD_DATA, ER_THD(thd, ER_BAD_DATA),
value, type);
break;
case E_DEC_OOM:
my_error(ER_OUT_OF_RESOURCES, MYF(0));
break;
default:
DBUG_ASSERT(0);
}
return result;
} | O0 | cpp | decimal_operation_results(int, char const*, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xd7538f
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd754a9
callq 0x7cc1e0
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0xf, %eax
ja 0xd7549d
movq -0x28(%rbp), %rax
leaq 0x7e0dc5(%rip), %rcx # 0x155617c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xb90(%rax), %rax
movq (%rax), %rax
movq 0x1ca8(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl $0x1, %esi
movl $0x77d, %edx # imm = 0x77D
movb $0x0, %al
callq 0x8ab3d0
jmp 0xd754a3
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xb90(%rax), %rax
movq (%rax), %rax
movq 0x1ca0(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl $0x1, %esi
movl $0x77c, %edx # imm = 0x77C
movb $0x0, %al
callq 0x8ab3d0
jmp 0xd754a3
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xb90(%rax), %rax
movq (%rax), %rax
movq 0xb68(%rax), %rcx
movl $0x1, %esi
movl $0x555, %edx # imm = 0x555
movb $0x0, %al
callq 0x8ab3d0
jmp 0xd754a3
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0xb90(%rax), %rax
movq (%rax), %rax
movq 0x1cb0(%rax), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl $0x1, %esi
movl $0x77e, %edx # imm = 0x77E
movb $0x0, %al
callq 0x8ab3d0
jmp 0xd754a3
movl $0x411, %edi # imm = 0x411
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x12bf0d0
jmp 0xd754a3
jmp 0xd7549f
jmp 0xd754a1
jmp 0xd754a3
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _Z25decimal_operation_resultsiPKcS0_:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
cmp [rbp+var_8], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_D7538F
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
jmp loc_D754A9
loc_D7538F:
call _current_thd
mov [rbp+var_20], rax
mov eax, [rbp+var_8]
dec eax; switch 16 cases
mov ecx, eax
mov [rbp+var_28], rcx
sub eax, 0Fh
ja def_D753BE; jumptable 0000000000D753BE default case, cases 3,5-7,9-15
mov rax, [rbp+var_28]
lea rcx, jpt_D753BE
movsxd rax, ds:(jpt_D753BE - 155617Ch)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_D753C0:
mov rdi, [rbp+var_20]; jumptable 0000000000D753BE case 1
mov rax, [rbp+var_20]
mov rax, [rax+0B90h]
mov rax, [rax]
mov rcx, [rax+1CA8h]
mov r8, [rbp+var_10]
mov r9, [rbp+var_18]
mov esi, 1
mov edx, 77Dh
mov al, 0
call _Z19push_warning_printfP3THDN21Sql_state_errno_level18enum_warning_levelEjPKcz; push_warning_printf(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*,...)
jmp loc_D754A3
loc_D753F7:
mov rdi, [rbp+var_20]; jumptable 0000000000D753BE case 2
mov rax, [rbp+var_20]
mov rax, [rax+0B90h]
mov rax, [rax]
mov rcx, [rax+1CA0h]
mov r8, [rbp+var_10]
mov r9, [rbp+var_18]
mov esi, 1
mov edx, 77Ch
mov al, 0
call _Z19push_warning_printfP3THDN21Sql_state_errno_level18enum_warning_levelEjPKcz; push_warning_printf(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*,...)
jmp short loc_D754A3
loc_D7542B:
mov rdi, [rbp+var_20]; jumptable 0000000000D753BE case 4
mov rax, [rbp+var_20]
mov rax, [rax+0B90h]
mov rax, [rax]
mov rcx, [rax+0B68h]
mov esi, 1
mov edx, 555h
mov al, 0
call _Z19push_warning_printfP3THDN21Sql_state_errno_level18enum_warning_levelEjPKcz; push_warning_printf(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*,...)
jmp short loc_D754A3
loc_D75457:
mov rdi, [rbp+var_20]; jumptable 0000000000D753BE case 8
mov rax, [rbp+var_20]
mov rax, [rax+0B90h]
mov rax, [rax]
mov rcx, [rax+1CB0h]
mov r8, [rbp+var_10]
mov r9, [rbp+var_18]
mov esi, 1
mov edx, 77Eh
mov al, 0
call _Z19push_warning_printfP3THDN21Sql_state_errno_level18enum_warning_levelEjPKcz; push_warning_printf(THD *,Sql_state_errno_level::enum_warning_level,uint,char const*,...)
jmp short loc_D754A3
loc_D7548B:
mov edi, 411h; jumptable 0000000000D753BE case 16
xor eax, eax
mov esi, eax
mov al, 0
call my_error
jmp short loc_D754A3
def_D753BE:
jmp short $+2; jumptable 0000000000D753BE default case, cases 3,5-7,9-15
loc_D7549F:
jmp short $+2
loc_D754A1:
jmp short $+2
loc_D754A3:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_D754A9:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long decimal_operation_results(long long a1, const char *a2, const char *a3)
{
int v3; // edx
int v4; // r8d
int v5; // r9d
THD *v7; // [rsp+10h] [rbp-20h]
if ( (_DWORD)a1 )
{
v7 = (THD *)current_thd(a1, a2, a3);
switch ( (int)a1 )
{
case 1:
push_warning_printf(v7, 1u, 0x77Du, *(_QWORD *)(**((_QWORD **)v7 + 370) + 7336LL), a2, a3);
break;
case 2:
push_warning_printf(v7, 1u, 0x77Cu, *(_QWORD *)(**((_QWORD **)v7 + 370) + 7328LL), a2, a3);
break;
case 4:
push_warning_printf(v7, 1u, 0x555u, *(_QWORD *)(**((_QWORD **)v7 + 370) + 2920LL));
break;
case 8:
push_warning_printf(v7, 1u, 0x77Eu, *(_QWORD *)(**((_QWORD **)v7 + 370) + 7344LL), a2, a3);
break;
case 16:
my_error(1041, 0, v3, a1 - 1, v4, v5);
break;
default:
break;
}
return (unsigned int)a1;
}
else
{
return 0;
}
}
| Item_func_decode_oracle:
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 0x00d75230
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x1b0d528]
ADD RCX,0x10
MOV qword ptr [RAX],RCX
ADD RSP,0x20
POP RBP
RET
|
/* Item_func_decode_oracle::Item_func_decode_oracle(Item_func_decode_oracle const&) */
void __thiscall
Item_func_decode_oracle::Item_func_decode_oracle
(Item_func_decode_oracle *this,Item_func_decode_oracle *param_1)
{
Item_func_case_simple::Item_func_case_simple
((Item_func_case_simple *)this,(Item_func_case_simple *)param_1);
*(int ***)this = &PTR__Item_func_decode_oracle_01b0d538;
return;
}
| |
22,251 | JS_DupAtom | bluesky950520[P]quickjs/quickjs.c | JSAtom JS_DupAtom(JSContext *ctx, JSAtom v)
{
JSRuntime *rt;
JSAtomStruct *p;
if (!__JS_AtomIsConst(v)) {
rt = ctx->rt;
p = rt->atom_array[v];
p->header.ref_count++;
}
return v;
} | O1 | c | JS_DupAtom:
movl %esi, %eax
cmpl $0xe0, %esi
jl 0x1f1ab
movq 0x18(%rdi), %rcx
movq 0x68(%rcx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
retq
| JS_DupAtom:
mov eax, esi
cmp esi, 0E0h
jl short locret_1F1AB
mov rcx, [rdi+18h]
mov rcx, [rcx+68h]
mov edx, eax
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
locret_1F1AB:
retn
| long long JS_DupAtom(long long a1, int a2)
{
long long result; // rax
_DWORD *v3; // rcx
result = (unsigned int)a2;
if ( a2 >= 224 )
{
v3 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a2);
++*v3;
}
return result;
}
| JS_DupAtom:
MOV EAX,ESI
CMP ESI,0xe0
JL 0x0011f1ab
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EAX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_0011f1ab:
RET
|
void JS_DupAtom(long param_1,uint param_2)
{
int *piVar1;
if (0xdf < (int)param_2) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_2 * 8);
*piVar1 = *piVar1 + 1;
}
return;
}
| |
22,252 | JS_DupAtom | bluesky950520[P]quickjs/quickjs.c | JSAtom JS_DupAtom(JSContext *ctx, JSAtom v)
{
JSRuntime *rt;
JSAtomStruct *p;
if (!__JS_AtomIsConst(v)) {
rt = ctx->rt;
p = rt->atom_array[v];
p->header.ref_count++;
}
return v;
} | O3 | c | JS_DupAtom:
movl %esi, %eax
cmpl $0xe0, %esi
jl 0x1f8ee
movq 0x18(%rdi), %rcx
movq 0x68(%rcx), %rcx
movl %eax, %edx
movq (%rcx,%rdx,8), %rcx
incl (%rcx)
retq
| JS_DupAtom:
mov eax, esi
cmp esi, 0E0h
jl short locret_1F8EE
mov rcx, [rdi+18h]
mov rcx, [rcx+68h]
mov edx, eax
mov rcx, [rcx+rdx*8]
inc dword ptr [rcx]
locret_1F8EE:
retn
| long long JS_DupAtom(long long a1, int a2)
{
long long result; // rax
_DWORD *v3; // rcx
result = (unsigned int)a2;
if ( a2 >= 224 )
{
v3 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 104LL) + 8LL * (unsigned int)a2);
++*v3;
}
return result;
}
| JS_DupAtom:
MOV EAX,ESI
CMP ESI,0xe0
JL 0x0011f8ee
MOV RCX,qword ptr [RDI + 0x18]
MOV RCX,qword ptr [RCX + 0x68]
MOV EDX,EAX
MOV RCX,qword ptr [RCX + RDX*0x8]
INC dword ptr [RCX]
LAB_0011f8ee:
RET
|
void JS_DupAtom(long param_1,uint param_2)
{
int *piVar1;
if (0xdf < (int)param_2) {
piVar1 = *(int **)(*(long *)(*(long *)(param_1 + 0x18) + 0x68) + (ulong)param_2 * 8);
*piVar1 = *piVar1 + 1;
}
return;
}
| |
22,253 | my_error_unregister | eloqsql/mysys/my_error.c | my_bool my_error_unregister(uint first, uint last)
{
struct my_err_head *meh_p;
struct my_err_head **search_meh_pp;
/* Search for the registration in the list. */
for (search_meh_pp= &my_errmsgs_list;
*search_meh_pp;
search_meh_pp= &(*search_meh_pp)->meh_next)
{
if (((*search_meh_pp)->meh_first == first) &&
((*search_meh_pp)->meh_last == last))
break;
}
if (! *search_meh_pp)
return TRUE;
/* Remove header from the chain. */
meh_p= *search_meh_pp;
*search_meh_pp= meh_p->meh_next;
my_free(meh_p);
return FALSE;
} | O3 | c | my_error_unregister:
movq 0x34c049(%rip), %r8 # 0x3e5220
movb $0x1, %al
testq %r8, %r8
je 0x99215
pushq %rbp
movq %rsp, %rbp
leaq 0x34c037(%rip), %rdx # 0x3e5220
movq %r8, %rcx
cmpl %edi, 0x10(%r8)
jne 0x991f7
cmpl %esi, 0x14(%rcx)
je 0x99204
movq (%rcx), %r8
movq %rcx, %rdx
testq %r8, %r8
jne 0x991e9
jmp 0x99214
movq (%rcx), %rax
movq %rax, (%rdx)
movq %rcx, %rdi
callq 0x9c92a
xorl %eax, %eax
popq %rbp
retq
| my_error_unregister:
mov r8, cs:my_errmsgs_list
mov al, 1
test r8, r8
jz short locret_99215
push rbp
mov rbp, rsp
lea rdx, my_errmsgs_list
loc_991E9:
mov rcx, r8
cmp [r8+10h], edi
jnz short loc_991F7
cmp [rcx+14h], esi
jz short loc_99204
loc_991F7:
mov r8, [rcx]
mov rdx, rcx
test r8, r8
jnz short loc_991E9
jmp short loc_99214
loc_99204:
mov rax, [rcx]
mov [rdx], rax
mov rdi, rcx
call my_free
xor eax, eax
loc_99214:
pop rbp
locret_99215:
retn
| char my_error_unregister(int a1, int a2)
{
long long *v2; // r8
char result; // al
long long **v4; // rdx
long long *v5; // rcx
v2 = my_errmsgs_list;
result = 1;
if ( my_errmsgs_list )
{
v4 = &my_errmsgs_list;
while ( 1 )
{
v5 = v2;
if ( *((_DWORD *)v2 + 4) == a1 && *((_DWORD *)v2 + 5) == a2 )
break;
v2 = (long long *)*v2;
v4 = (long long **)v5;
if ( !*v5 )
return result;
}
*v4 = (long long *)*v2;
my_free(v2);
return 0;
}
return result;
}
| my_error_unregister:
MOV R8,qword ptr [0x004e5220]
MOV AL,0x1
TEST R8,R8
JZ 0x00199215
PUSH RBP
MOV RBP,RSP
LEA RDX,[0x4e5220]
LAB_001991e9:
MOV RCX,R8
CMP dword ptr [R8 + 0x10],EDI
JNZ 0x001991f7
CMP dword ptr [RCX + 0x14],ESI
JZ 0x00199204
LAB_001991f7:
MOV R8,qword ptr [RCX]
MOV RDX,RCX
TEST R8,R8
JNZ 0x001991e9
JMP 0x00199214
LAB_00199204:
MOV RAX,qword ptr [RCX]
MOV qword ptr [RDX],RAX
MOV RDI,RCX
CALL 0x0019c92a
XOR EAX,EAX
LAB_00199214:
POP RBP
LAB_00199215:
RET
|
int8 my_error_unregister(int param_1,int param_2)
{
int **ppuVar1;
int **ppuVar2;
int **ppuVar3;
if (my_errmsgs_list != (int *)0x0) {
ppuVar2 = &my_errmsgs_list;
ppuVar3 = (int **)my_errmsgs_list;
do {
if ((*(int *)(ppuVar3 + 2) == param_1) && (*(int *)((long)ppuVar3 + 0x14) == param_2)) {
*ppuVar2 = *ppuVar3;
my_free(ppuVar3);
return 0;
}
ppuVar1 = (int **)*ppuVar3;
ppuVar2 = ppuVar3;
ppuVar3 = ppuVar1;
} while (ppuVar1 != (int **)0x0);
}
return 1;
}
| |
22,254 | SchemaConverter::_not_strings(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&) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string _not_strings(const std::vector<std::string> & strings) {
struct TrieNode {
std::map<char, TrieNode> children;
bool is_end_of_string;
TrieNode() : is_end_of_string(false) {}
void insert(const std::string & string) {
auto node = this;
for (char c : string) {
node = &node->children[c];
}
node->is_end_of_string = true;
}
};
TrieNode trie;
for (const auto & s : strings) {
trie.insert(s);
}
std::string char_rule = _add_primitive("char", PRIMITIVE_RULES.at("char"));
std::ostringstream out;
out << "[\"] ( ";
std::function<void(const TrieNode &)> visit = [&](const TrieNode & node) {
std::ostringstream rejects;
auto first = true;
for (const auto & kv : node.children) {
rejects << kv.first;
if (first) {
first = false;
} else {
out << " | ";
}
out << "[" << kv.first << "]";
if (!kv.second.children.empty()) {
out << " (";
visit(kv.second);
out << ")";
} else if (kv.second.is_end_of_string) {
out << " " << char_rule << "+";
}
}
if (!node.children.empty()) {
if (!first) {
out << " | ";
}
out << "[^\"" << rejects.str() << "] " << char_rule << "*";
}
};
visit(trie);
out << " )";
if (!trie.is_end_of_string) {
out << "?";
}
out << " [\"] space";
return out.str();
} | O2 | cpp | SchemaConverter::_not_strings(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&):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rdx), %r15
movq 0x8(%rdx), %r13
leaq 0x28(%rsp), %r12
cmpq %r13, %r15
je 0x932c6
movq %r12, %rdi
movq %r15, %rsi
callq 0x93976
addq $0x20, %r15
jmp 0x932b0
leaq 0x271eb(%rip), %rsi # 0xba4b8
leaq 0x98(%rsp), %rdi
leaq 0x80(%rsp), %rdx
callq 0x27fde
leaq 0x271cf(%rip), %rsi # 0xba4b8
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x27fde
leaq 0x6ef91(%rip), %rdi # 0x102290
leaq 0x8(%rsp), %rsi
callq 0x9654c
leaq 0x60(%rsp), %r15
leaq 0x98(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x9226e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x251d8
leaq 0x98(%rsp), %rdi
callq 0x251d8
leaq 0x98(%rsp), %rdi
callq 0x24b90
leaq 0x27508(%rip), %rsi # 0xba85a
leaq 0x98(%rsp), %r12
movq %r12, %rdi
callq 0x24890
leaq 0x80(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movq %r14, %rdi
callq 0x939ba
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x93a02
leaq 0x271da(%rip), %rsi # 0xba56d
leaq 0x98(%rsp), %rdi
callq 0x24890
cmpb $0x0, 0x58(%rsp)
jne 0x933bb
leaq 0x272f0(%rip), %rsi # 0xba69e
leaq 0x98(%rsp), %rdi
callq 0x24890
leaq 0x2749f(%rip), %rsi # 0xba861
leaq 0x98(%rsp), %rdi
callq 0x24890
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0x24da0
leaq 0x8(%rsp), %rdi
callq 0x48930
leaq 0x98(%rsp), %rdi
callq 0x241f0
leaq 0x60(%rsp), %rdi
callq 0x251d8
leaq 0x28(%rsp), %rdi
callq 0x93fae
movq %rbx, %rax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x93420
movq %rax, %rbx
jmp 0x93455
movq %rax, %rbx
jmp 0x93462
movq %rax, %rbx
jmp 0x9343e
jmp 0x9346e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x251d8
leaq 0x98(%rsp), %rdi
jmp 0x93467
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x48930
leaq 0x98(%rsp), %rdi
callq 0x241f0
leaq 0x60(%rsp), %rdi
callq 0x251d8
jmp 0x93471
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x93fae
movq %rbx, %rdi
callq 0x24f80
nop
| _ZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 210h
mov r14, rsi
mov rbx, rdi
lea rax, [rsp+238h+var_208]
and dword ptr [rax], 0
and qword ptr [rax+8], 0
mov [rax+10h], rax
mov [rax+18h], rax
and qword ptr [rax+20h], 0
mov byte ptr [rax+28h], 0
mov r15, [rdx]
mov r13, [rdx+8]
lea r12, [rsp+238h+var_210]
loc_932B0:
cmp r15, r13
jz short loc_932C6
mov rdi, r12
mov rsi, r15
call _ZZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS6_EEEN8TrieNode6insertERKS6_; SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(std::string const&)
add r15, 20h ; ' '
jmp short loc_932B0
loc_932C6:
lea rsi, aChar; "char"
lea rdi, [rsp+238h+var_1A0]
lea rdx, [rsp+238h+var_1B8]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aChar; "char"
lea rdi, [rsp+238h+var_230]
lea rdx, [rsp+238h+var_231]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, _Z15PRIMITIVE_RULESB5cxx11; PRIMITIVE_RULES
lea rsi, [rsp+238h+var_230]
call _ZNSt8__detail9_Map_baseINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4pairIKS6_11BuiltinRuleESaISA_ENS_10_Select1stESt8equal_toIS6_ESt4hashIS6_ENS_18_Mod_range_hashingENS_20_Default_ranged_hashENS_20_Prime_rehash_policyENS_17_Hashtable_traitsILb1ELb0ELb1EEELb1EE2atERS8_; std::__detail::_Map_base<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>::at(std::string const&)
lea r15, [rsp+238h+var_1D8]
lea rdx, [rsp+238h+var_1A0]
mov rdi, r15
mov rsi, r14
mov rcx, rax
call _ZN15SchemaConverter14_add_primitiveERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERK11BuiltinRule; SchemaConverter::_add_primitive(std::string const&,BuiltinRule const&)
lea r14, [rsp+238h+var_230]
mov rdi, r14; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_1A0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_1A0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
lea rsi, asc_BA85A; "[\"] ( "
lea r12, [rsp+238h+var_1A0]
mov rdi, r12
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, [rsp+238h+var_1B8]
mov [rsi], r12
mov [rsi+8], r14
mov [rsi+10h], r15
mov rdi, r14
call _ZNSt8functionIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEEC2IZNS0_12_not_stringsESB_EUlSE_E_vEEOT_; std::function<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)>::function<SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1},void>(SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1} &&)
lea rdi, [rsp+238h+var_230]
lea rsi, [rsp+238h+var_210]
call _ZNKSt8functionIFvRKZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEE8TrieNodeEEclESE_; std::function<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)>::operator()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)
lea rsi, a09401910201912+50h; " )"
lea rdi, [rsp+238h+var_1A0]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
cmp [rsp+238h+var_1E0], 0
jnz short loc_933BB
lea rsi, asc_BA69B+3; "?"
lea rdi, [rsp+238h+var_1A0]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
loc_933BB:
lea rsi, aSpace_5; " [\"] space"
lea rdi, [rsp+238h+var_1A0]
call __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc; std::operator<<<std::char_traits<char>>(std::ostream &,char const*)
lea rsi, [rsp+238h+var_198]
mov rdi, rbx
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
lea rdi, [rsp+238h+var_230]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rdi, [rsp+238h+var_1A0]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+238h+var_1D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+238h+var_210]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rax, rbx
add rsp, 210h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
jmp short $+2
loc_93420:
mov rbx, rax
jmp short loc_93455
mov rbx, rax
jmp short loc_93462
mov rbx, rax
jmp short loc_9343E
jmp short loc_9346E
mov rbx, rax
lea rdi, [rsp+arg_0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_9343E:
lea rdi, [rsp+arg_90]
jmp short loc_93467
mov rbx, rax
lea rdi, [rsp+arg_0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
loc_93455:
lea rdi, [rsp+arg_90]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED1Ev; std::ostringstream::~ostringstream()
loc_93462:
lea rdi, [rsp+arg_58]; void *
loc_93467:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_93471
loc_9346E:
mov rbx, rax
loc_93471:
lea rdi, [rsp+arg_20]
call _ZNSt8_Rb_treeIcSt4pairIKcZN15SchemaConverter12_not_stringsERKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS9_EEE8TrieNodeESt10_Select1stISF_ESt4lessIcESaISF_EED2Ev; std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree()
mov rdi, rbx
call __Unwind_Resume
| long long SchemaConverter::_not_strings(long long a1, long long a2, long long *a3)
{
long long v3; // r15
long long v4; // r13
_QWORD *v5; // rax
_QWORD v7[4]; // [rsp+8h] [rbp-230h] BYREF
_BYTE v8[8]; // [rsp+28h] [rbp-210h] BYREF
int v9; // [rsp+30h] [rbp-208h] BYREF
long long v10; // [rsp+38h] [rbp-200h]
int *v11; // [rsp+40h] [rbp-1F8h]
int *v12; // [rsp+48h] [rbp-1F0h]
long long v13; // [rsp+50h] [rbp-1E8h]
char v14; // [rsp+58h] [rbp-1E0h]
_BYTE v15[32]; // [rsp+60h] [rbp-1D8h] BYREF
long long *v16; // [rsp+80h] [rbp-1B8h]
_QWORD *v17; // [rsp+88h] [rbp-1B0h]
_BYTE *v18; // [rsp+90h] [rbp-1A8h]
long long v19; // [rsp+98h] [rbp-1A0h] BYREF
_BYTE v20[408]; // [rsp+A0h] [rbp-198h] BYREF
v9 = 0;
v10 = 0LL;
v11 = &v9;
v12 = &v9;
v13 = 0LL;
v14 = 0;
v3 = *a3;
v4 = a3[1];
while ( v3 != v4 )
{
SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode::insert(v8, v3);
v3 += 32LL;
}
std::string::basic_string<std::allocator<char>>(&v19, (long long)"char");
std::string::basic_string<std::allocator<char>>(v7, (long long)"char");
v5 = (_QWORD *)std::__detail::_Map_base<std::string,std::pair<std::string const,BuiltinRule>,std::allocator<std::pair<std::string const,BuiltinRule>>,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>::at(
&PRIMITIVE_RULES[abi:cxx11],
v7);
SchemaConverter::_add_primitive((long long)v15, a2, &v19, v5);
std::string::~string(v7);
std::string::~string(&v19);
std::ostringstream::basic_ostringstream(&v19);
std::operator<<<std::char_traits<char>>(&v19, "[\"] ( ");
v16 = &v19;
v17 = v7;
v18 = v15;
std::function<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)>::function<SchemaConverter::_not_strings(std::vector<std::string> const&)::{lambda(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)#1},void>(v7);
std::function<void ()(SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode const&)>::operator()(
v7,
v8);
std::operator<<<std::char_traits<char>>(&v19, " )");
if ( !v14 )
std::operator<<<std::char_traits<char>>(&v19, "?");
std::operator<<<std::char_traits<char>>(&v19, " [\"] space");
std::stringbuf::str(a1, v20);
std::_Function_base::~_Function_base((std::_Function_base *)v7);
std::ostringstream::~ostringstream(&v19);
std::string::~string(v15);
std::_Rb_tree<char,std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>,std::_Select1st<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char const,SchemaConverter::_not_strings(std::vector<std::string> const&)::TrieNode>>>::~_Rb_tree(v8);
return a1;
}
| _not_strings:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x210
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RSP + 0x30]
AND dword ptr [RAX],0x0
AND qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX + 0x10],RAX
MOV qword ptr [RAX + 0x18],RAX
AND qword ptr [RAX + 0x20],0x0
MOV byte ptr [RAX + 0x28],0x0
MOV R15,qword ptr [RDX]
MOV R13,qword ptr [RDX + 0x8]
LEA R12,[RSP + 0x28]
LAB_001932b0:
CMP R15,R13
JZ 0x001932c6
LAB_001932b5:
MOV RDI,R12
MOV RSI,R15
CALL 0x00193976
ADD R15,0x20
JMP 0x001932b0
LAB_001932c6:
LEA RSI,[0x1ba4b8]
LEA RDI,[RSP + 0x98]
LEA RDX,[RSP + 0x80]
CALL 0x00127fde
LAB_001932e2:
LEA RSI,[0x1ba4b8]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x7]
CALL 0x00127fde
LAB_001932f8:
LEA RDI,[0x202290]
LEA RSI,[RSP + 0x8]
CALL 0x0019654c
LEA R15,[RSP + 0x60]
LEA RDX,[RSP + 0x98]
MOV RDI,R15
MOV RSI,R14
MOV RCX,RAX
CALL 0x0019226e
LEA R14,[RSP + 0x8]
MOV RDI,R14
CALL 0x001251d8
LEA RDI,[RSP + 0x98]
CALL 0x001251d8
LAB_0019333e:
LEA RDI,[RSP + 0x98]
CALL 0x00124b90
LAB_0019334b:
LEA RSI,[0x1ba85a]
LEA R12,[RSP + 0x98]
MOV RDI,R12
CALL 0x00124890
LEA RSI,[RSP + 0x80]
MOV qword ptr [RSI],R12
MOV qword ptr [RSI + 0x8],R14
MOV qword ptr [RSI + 0x10],R15
LAB_00193375:
MOV RDI,R14
CALL 0x001939ba
LAB_0019337d:
LEA RDI,[RSP + 0x8]
LEA RSI,[RSP + 0x28]
CALL 0x00193a02
LEA RSI,[0x1ba56d]
LEA RDI,[RSP + 0x98]
CALL 0x00124890
CMP byte ptr [RSP + 0x58],0x0
JNZ 0x001933bb
LEA RSI,[0x1ba69e]
LEA RDI,[RSP + 0x98]
CALL 0x00124890
LAB_001933bb:
LEA RSI,[0x1ba861]
LEA RDI,[RSP + 0x98]
CALL 0x00124890
LEA RSI,[RSP + 0xa0]
MOV RDI,RBX
CALL 0x00124da0
LAB_001933df:
LEA RDI,[RSP + 0x8]
CALL 0x00148930
LEA RDI,[RSP + 0x98]
CALL 0x001241f0
LEA RDI,[RSP + 0x60]
CALL 0x001251d8
LEA RDI,[RSP + 0x28]
CALL 0x00193fae
MOV RAX,RBX
ADD RSP,0x210
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* SchemaConverter::_not_strings(std::vector<std::__cxx11::string,
std::allocator<std::__cxx11::string > > const&) */
vector * SchemaConverter::_not_strings(vector *param_1)
{
long lVar1;
long *in_RDX;
BuiltinRule *in_RSI;
long lVar2;
allocator local_231;
string local_230 [32];
TrieNode local_210 [8];
int4 local_208 [2];
int8 local_200;
int4 *local_1f8;
int4 *local_1f0;
int8 local_1e8;
char local_1e0;
string local_1d8 [32];
ostream *local_1b8;
string *local_1b0;
string *local_1a8;
string local_1a0 [376];
local_1f8 = local_208;
local_208[0] = 0;
local_200 = 0;
local_1e8 = 0;
local_1e0 = '\0';
lVar1 = in_RDX[1];
local_1f0 = local_1f8;
for (lVar2 = *in_RDX; lVar2 != lVar1; lVar2 = lVar2 + 0x20) {
/* try { // try from 001932b5 to 001932bf has its CatchHandler @ 0019346e */
_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::
TrieNode::insert(std::__cxx11::string_const__(local_210,lVar2);
}
/* try { // try from 001932c6 to 001932e1 has its CatchHandler @ 0019342f */
std::__cxx11::string::string<std::allocator<char>>(local_1a0,"char",(allocator *)&local_1b8);
/* try { // try from 001932e2 to 001932f7 has its CatchHandler @ 0019342a */
std::__cxx11::string::string<std::allocator<char>>(local_230,"char",&local_231);
/* try { // try from 001932f8 to 00193323 has its CatchHandler @ 00193431 */
std::__detail::
_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>
::at((_Map_base<std::__cxx11::string,std::pair<std::__cxx11::string_const,BuiltinRule>,std::allocator<std::pair<std::__cxx11::string_const,BuiltinRule>>,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>
*)PRIMITIVE_RULES_abi_cxx11_,local_230);
_add_primitive(local_1d8,in_RSI);
std::__cxx11::string::~string(local_230);
std::__cxx11::string::~string(local_1a0);
/* try { // try from 0019333e to 0019334a has its CatchHandler @ 00193425 */
std::__cxx11::ostringstream::ostringstream((ostringstream *)local_1a0);
/* try { // try from 0019334b to 00193361 has its CatchHandler @ 00193420 */
std::operator<<((ostream *)local_1a0,"[\"] ( ");
local_1b8 = (ostream *)local_1a0;
local_1b0 = local_230;
local_1a8 = local_1d8;
/* try { // try from 00193375 to 0019337c has its CatchHandler @ 0019341e */
std::
function<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)>
::
function<SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::_lambda(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)_1_,void>
((_lambda_SchemaConverter___not_strings_std__vector<std::__cxx11::string,std::allocator<std::__cxx11::string_>_>_const____TrieNode_const___1_
*)local_230);
/* try { // try from 0019337d to 001933de has its CatchHandler @ 00193448 */
std::
function<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)>
::operator()((function<void(SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode_const&)>
*)local_230,local_210);
std::operator<<((ostream *)local_1a0," )");
if (local_1e0 == '\0') {
std::operator<<((ostream *)local_1a0,"?");
}
std::operator<<((ostream *)local_1a0," [\"] space");
std::__cxx11::stringbuf::str();
std::_Function_base::~_Function_base((_Function_base *)local_230);
std::__cxx11::ostringstream::~ostringstream((ostringstream *)local_1a0);
std::__cxx11::string::~string(local_1d8);
std::
_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
::~_Rb_tree((_Rb_tree<char,std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>,std::_Select1st<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>,std::less<char>,std::allocator<std::pair<char_const,SchemaConverter::_not_strings(std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>const&)::TrieNode>>>
*)local_210);
return param_1;
}
| |
22,255 | alaya::Graph<unsigned int, unsigned int, alaya::SequentialStorage<unsigned int, unsigned int>>::Graph(unsigned int, unsigned int) | AlayaLite/include/executor/jobs/../../index/graph/graph.hpp | Graph(NodeIDType max_nodes, EdgeIDType max_nbrs) : max_nodes_(max_nodes), max_nbrs_(max_nbrs) {
uint32_t item_size = max_nbrs * sizeof(NodeIDType);
data_storage_.init(item_size, max_nodes, -1);
} | O3 | cpp | alaya::Graph<unsigned int, unsigned int, alaya::SequentialStorage<unsigned int, unsigned int>>::Graph(unsigned int, unsigned int):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x8(%rdi), %rbx
leal (,%rdx,4), %eax
movl %esi, %edx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq $0x0, 0x58(%rdi)
movl $0x40, %r8d
movq %rbx, %rdi
movq %rax, %rsi
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x1b374
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x48(%r14), %rdi
testq %rdi, %rdi
je 0x1716d
movq 0x58(%r14), %rsi
subq %rdi, %rsi
callq 0x11120
addq $0x40, %r14
movq %r14, %rdi
callq 0x191c8
movq %rbx, %rdi
callq 0x191fc
movq %r15, %rdi
callq 0x11760
nop
| _ZN5alaya5GraphIjjNS_17SequentialStorageIjjEEEC2Ejj:
push r15
push r14
push rbx
mov r14, rdi
mov [rdi], esi
mov [rdi+4], edx
lea rbx, [rdi+8]
lea eax, ds:0[rdx*4]
mov edx, esi
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
movups xmmword ptr [rdi+18h], xmm0
movups xmmword ptr [rdi+28h], xmm0
movups xmmword ptr [rdi+38h], xmm0
movups xmmword ptr [rdi+48h], xmm0
mov qword ptr [rdi+58h], 0
mov r8d, 40h ; '@'
mov rdi, rbx
mov rsi, rax
mov ecx, 0FFFFFFFFh
call _ZN5alaya17SequentialStorageIjjE4initEmmcm; alaya::SequentialStorage<uint,uint>::init(ulong,ulong,char,ulong)
pop rbx
pop r14
pop r15
retn
mov r15, rax
mov rdi, [r14+48h]; void *
test rdi, rdi
jz short loc_1716D
mov rsi, [r14+58h]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1716D:
add r14, 40h ; '@'
mov rdi, r14
call _ZNSt10unique_ptrIN5alaya12OverlayGraphIjjEESt14default_deleteIS2_EED2Ev; std::unique_ptr<alaya::OverlayGraph<uint,uint>>::~unique_ptr()
mov rdi, rbx
call _ZN5alaya17SequentialStorageIjjED2Ev; alaya::SequentialStorage<uint,uint>::~SequentialStorage()
mov rdi, r15
call __Unwind_Resume
| long long alaya::Graph<unsigned int,unsigned int,alaya::SequentialStorage<unsigned int,unsigned int>>::Graph(
long long a1,
unsigned int a2,
int a3)
{
*(_DWORD *)a1 = a2;
*(_DWORD *)(a1 + 4) = a3;
*(_OWORD *)(a1 + 8) = 0LL;
*(_OWORD *)(a1 + 24) = 0LL;
*(_OWORD *)(a1 + 40) = 0LL;
*(_OWORD *)(a1 + 56) = 0LL;
*(_OWORD *)(a1 + 72) = 0LL;
*(_QWORD *)(a1 + 88) = 0LL;
return alaya::SequentialStorage<unsigned int,unsigned int>::init(
a1 + 8,
(unsigned int)(4 * a3),
a2,
0xFFFFFFFFLL,
64LL);
}
| Graph:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDI
MOV dword ptr [RDI],ESI
MOV dword ptr [RDI + 0x4],EDX
LEA RBX,[RDI + 0x8]
LEA EAX,[RDX*0x4]
MOV EDX,ESI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOVUPS xmmword ptr [RDI + 0x18],XMM0
MOVUPS xmmword ptr [RDI + 0x28],XMM0
MOVUPS xmmword ptr [RDI + 0x38],XMM0
MOVUPS xmmword ptr [RDI + 0x48],XMM0
MOV qword ptr [RDI + 0x58],0x0
LAB_00117139:
MOV R8D,0x40
MOV RDI,RBX
MOV RSI,RAX
MOV ECX,0xffffffff
CALL 0x0011b374
LAB_0011714f:
POP RBX
POP R14
POP R15
RET
|
/* alaya::Graph<unsigned int, unsigned int, alaya::SequentialStorage<unsigned int, unsigned int>
>::Graph(unsigned int, unsigned int) */
void __thiscall
alaya::Graph<unsigned_int,unsigned_int,alaya::SequentialStorage<unsigned_int,unsigned_int>>::Graph
(Graph<unsigned_int,unsigned_int,alaya::SequentialStorage<unsigned_int,unsigned_int>>
*this,uint param_1,uint param_2)
{
*(uint *)this = param_1;
*(uint *)(this + 4) = param_2;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x50) = 0;
*(int8 *)(this + 0x58) = 0;
/* try { // try from 00117139 to 0011714e has its CatchHandler @ 00117155 */
SequentialStorage<unsigned_int,unsigned_int>::init
((SequentialStorage<unsigned_int,unsigned_int> *)(this + 8),(ulong)(param_2 * 4),
(ulong)param_1,-1,0x40);
return;
}
| |
22,256 | minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const | llama.cpp/common/minja/minja.hpp | void do_render(std::ostringstream & out, const std::shared_ptr<Context> & context) const override {
// https://jinja.palletsprojects.com/en/3.0.x/templates/#for
if (!iterable) throw std::runtime_error("ForNode.iterable is null");
if (!body) throw std::runtime_error("ForNode.body is null");
auto iterable_value = iterable->evaluate(context);
Value::CallableType loop_function;
std::function<void(Value&)> visit = [&](Value& iter) {
auto filtered_items = Value::array();
if (!iter.is_null()) {
if (!iterable_value.is_iterable()) {
throw std::runtime_error("For loop iterable must be iterable: " + iterable_value.dump());
}
iterable_value.for_each([&](Value & item) {
destructuring_assign(var_names, context, item);
if (!condition || condition->evaluate(context).to_bool()) {
filtered_items.push_back(item);
}
});
}
if (filtered_items.empty()) {
if (else_body) {
else_body->render(out, context);
}
} else {
auto loop = recursive ? Value::callable(loop_function) : Value::object();
loop.set("length", (int64_t) filtered_items.size());
size_t cycle_index = 0;
loop.set("cycle", Value::callable([&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.empty() || !args.kwargs.empty()) {
throw std::runtime_error("cycle() expects at least 1 positional argument and no named arg");
}
auto item = args.args[cycle_index];
cycle_index = (cycle_index + 1) % args.args.size();
return item;
}));
auto loop_context = Context::make(Value::object(), context);
loop_context->set("loop", loop);
for (size_t i = 0, n = filtered_items.size(); i < n; ++i) {
auto & item = filtered_items.at(i);
destructuring_assign(var_names, loop_context, item);
loop.set("index", (int64_t) i + 1);
loop.set("index0", (int64_t) i);
loop.set("revindex", (int64_t) (n - i));
loop.set("revindex0", (int64_t) (n - i - 1));
loop.set("length", (int64_t) n);
loop.set("first", i == 0);
loop.set("last", i == (n - 1));
loop.set("previtem", i > 0 ? filtered_items.at(i - 1) : Value());
loop.set("nextitem", i < n - 1 ? filtered_items.at(i + 1) : Value());
try {
body->render(out, loop_context);
} catch (const LoopControlException & e) {
if (e.control_type == LoopControlType::Break) break;
if (e.control_type == LoopControlType::Continue) continue;
}
}
}
};
if (recursive) {
loop_function = [&](const std::shared_ptr<Context> &, ArgumentsValue & args) {
if (args.args.size() != 1 || !args.kwargs.empty() || !args.args[0].is_array()) {
throw std::runtime_error("loop() expects exactly 1 positional iterable argument");
}
auto & items = args.args[0];
visit(items);
return Value();
};
}
visit(iterable_value);
} | O3 | cpp | minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq 0x38(%rdi), %rsi
testq %rsi, %rsi
je 0xf0ca3
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0xf0cc1
movq %rdx, %r15
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0xe1958
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x28, %edi
callq 0x20200
movq %r12, (%rax)
movq %rbx, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x20(%rsp), %rcx
movq %rcx, 0x20(%rax)
movq %rax, (%rsp)
leaq 0x2e9(%rip), %rax # 0xf0e94
movq %rax, 0x18(%rsp)
leaq 0x2e5(%rip), %rcx # 0xf0e9c
movq %rcx, 0x10(%rsp)
cmpb $0x0, 0x68(%rbx)
je 0xf0be7
movq %rsp, %rbx
leaq 0x40(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0xf0e1e
cmpq $0x0, 0x10(%rbx)
je 0xf0cf3
movq 0x18(%rsp), %rax
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf0c08
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xf0c21
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x858ca
movq %rbx, %rdi
callq 0x89fe4
leaq 0x80(%rsp), %rdi
callq 0x71092
leaq 0x70(%rsp), %rdi
callq 0x71092
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x71092
movq -0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xf0c94
movq 0x71329(%rip), %rax # 0x161f98
cmpb $0x0, (%rax)
je 0xf0c7f
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0xf0c89
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0xf0c94
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x20620
movq %rax, %r14
leaq 0x313a1(%rip), %rsi # 0x122058
movq %rax, %rdi
callq 0x20400
jmp 0xf0cdd
movl $0x10, %edi
callq 0x20620
movq %rax, %r14
leaq 0x3139c(%rip), %rsi # 0x122071
movq %rax, %rdi
callq 0x20400
movq 0x712dc(%rip), %rsi # 0x161fc0
movq 0x71295(%rip), %rdx # 0x161f80
movq %r14, %rdi
callq 0x20a30
callq 0x21240
jmp 0xf0cfa
movq %rax, %rbx
movq %r14, %rdi
callq 0x20eb0
jmp 0xf0d4d
jmp 0xf0d57
jmp 0xf0d57
movq %rax, %rbx
jmp 0xf0d2a
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf0d2a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xf0d43
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rsp), %rdi
callq 0xb6738
movq %rbx, %rdi
callq 0x20ad0
jmp 0xf0d57
movq %rax, %rdi
callq 0x27b48
nop
| _ZNK5minja7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS_7ContextEE:
push r15
push r14
push r12
push rbx
sub rsp, 98h
mov r14, rsi
mov rsi, [rdi+38h]
test rsi, rsi
jz loc_F0CA3
mov rbx, rdi
cmp qword ptr [rdi+58h], 0
jz loc_F0CC1
mov r15, rdx
lea r12, [rsp+0B8h+var_70]
mov rdi, r12
call _ZNK5minja10Expression8evaluateERKSt10shared_ptrINS_7ContextEE; minja::Expression::evaluate(std::shared_ptr<minja::Context> const&)
xorps xmm0, xmm0
movaps [rsp+0B8h+var_88], xmm0
movaps [rsp+0B8h+var_98], xmm0
mov [rsp+0B8h+var_B0], 0
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov [rax], r12
mov [rax+8], rbx
mov [rax+10h], r15
mov [rax+18h], r14
lea rcx, [rsp+0B8h+var_98]
mov [rax+20h], rcx
mov [rsp+0B8h+var_B8], rax
lea rax, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS0_7ContextEEEUlS2_E_E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke(std::_Any_data const&,minja::Value &)
mov [rsp+0B8h+var_A0], rax
lea rcx, _ZNSt17_Function_handlerIFvRN5minja5ValueEEZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEERKSt10shared_ptrINS0_7ContextEEEUlS2_E_E10_M_managerERSt9_Any_dataRKSJ_St18_Manager_operation; std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rsp+0B8h+var_A8], rcx
cmp byte ptr [rbx+68h], 0
jz short loc_F0BE7
mov rbx, rsp
lea rsi, [rsp+0B8h+var_78]
mov [rsi], rbx
lea rdi, [rsp+0B8h+var_98]
call _ZNSt8functionIFN5minja5ValueERKSt10shared_ptrINS0_7ContextEERNS0_14ArgumentsValueEEEaSIZNKS0_7ForNode9do_renderERNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEES6_EUlS6_S8_E_EENSt9enable_ifIXsrNSA_9_CallableIT_NSL_IXntsr7is_sameINSt9remove_cvINSt16remove_referenceISN_E4typeEE4typeESA_EE5valueESt5decayISN_EE4type4typeESt15__invoke_resultIRSY_JS6_S8_EEEE5valueERSA_E4typeEOSN_
cmp qword ptr [rbx+10h], 0
jz loc_F0CF3
mov rax, [rsp+0B8h+var_A0]
loc_F0BE7:
mov rdi, rsp
lea rsi, [rsp+0B8h+var_70]
call rax ; std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke(std::_Any_data const&,minja::Value &); std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke(std::_Any_data const&,minja::Value &)
mov rax, [rsp+0B8h+var_A8]
test rax, rax
jz short loc_F0C08
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_F0C08:
mov rax, qword ptr [rsp+0B8h+var_88]
test rax, rax
jz short loc_F0C21
lea rdi, [rsp+0B8h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_F0C21:
lea rbx, [rsp+0B8h+var_30]
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()
lea rdi, [rsp+0B8h+var_38]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rdi, [rsp+0B8h+var_48]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
lea rbx, [rsp+0B8h+var_58]
mov rdi, rbx
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, [rbx-10h]
test rdi, rdi
jz short loc_F0C94
mov rax, cs:_ZTISt19_Sp_make_shared_tag; `typeinfo for'std::_Sp_make_shared_tag
cmp byte ptr [rax], 0
jz short loc_F0C7F
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_F0C89
loc_F0C7F:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_F0C89:
cmp eax, 1
jnz short loc_F0C94
mov rax, [rdi]
call qword ptr [rax+18h]
loc_F0C94:
add rsp, 98h
pop rbx
pop r12
pop r14
pop r15
retn
loc_F0CA3:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeIterabl; "ForNode.iterable is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short loc_F0CDD
loc_F0CC1:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aFornodeBodyIsN; "ForNode.body is null"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
loc_F0CDD:
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_F0CF3:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short $+2
loc_F0CFA:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_F0D4D
jmp short loc_F0D57
jmp short loc_F0D57
mov rbx, rax
jmp short loc_F0D2A
mov rbx, rax
mov rax, [rsp+0B8h+var_A8]
test rax, rax
jz short loc_F0D2A
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_F0D2A:
mov rax, qword ptr [rsp+0B8h+var_88]
test rax, rax
jz short loc_F0D43
lea rdi, [rsp+0B8h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_F0D43:
lea rdi, [rsp+0B8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_F0D4D:
mov rdi, rbx
call __Unwind_Resume
jmp short $+2
loc_F0D57:
mov rdi, rax
call __clang_call_terminate
| void minja::ForNode::do_render(long long a1, long long a2, long long a3)
{
void (***v4)(void); // rsi
_QWORD *v6; // rax
void ( *v7)(_QWORD *, _BYTE *); // rax
long long v8; // rdi
signed __int32 v9; // eax
std::runtime_error *exception; // r14
_QWORD v11[2]; // [rsp+0h] [rbp-B8h] BYREF
long long ( *v12)(); // [rsp+10h] [rbp-A8h]
void ( *v13)(_QWORD *, _BYTE *); // [rsp+18h] [rbp-A0h]
__int128 v14; // [rsp+20h] [rbp-98h] BYREF
__int128 v15; // [rsp+30h] [rbp-88h]
_QWORD *v16; // [rsp+40h] [rbp-78h]
_BYTE v17[8]; // [rsp+48h] [rbp-70h] BYREF
long long v18; // [rsp+50h] [rbp-68h]
volatile signed __int32 *v19; // [rsp+60h] [rbp-58h] BYREF
volatile signed __int32 *v20; // [rsp+70h] [rbp-48h] BYREF
volatile signed __int32 *v21; // [rsp+80h] [rbp-38h] BYREF
char v22[48]; // [rsp+88h] [rbp-30h] BYREF
v4 = *(void (****)(void))(a1 + 56);
if ( !v4 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.iterable is null");
goto LABEL_19;
}
if ( !*(_QWORD *)(a1 + 88) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.body is null");
LABEL_19:
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
minja::Expression::evaluate((long long)v17, v4);
v15 = 0LL;
v14 = 0LL;
v11[1] = 0LL;
v6 = (_QWORD *)operator new(0x28uLL);
*v6 = v17;
v6[1] = a1;
v6[2] = a3;
v6[3] = a2;
v6[4] = &v14;
v11[0] = v6;
v7 = (void ( *)(_QWORD *, _BYTE *))std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke;
v13 = (void ( *)(_QWORD *, _BYTE *))std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_invoke;
v12 = std::_Function_handler<void ()(minja::Value &),minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(minja::Value &)#1}>::_M_manager;
if ( *(_BYTE *)(a1 + 104) )
{
v16 = v11;
std::function<minja::Value ()(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)>::operator=<minja::ForNode::do_render(std::ostringstream &,std::shared_ptr<minja::Context> const&)::{lambda(std::shared_ptr<minja::Context> const&,minja::ArgumentsValue &)#1}>(&v14);
if ( !v12 )
std::__throw_bad_function_call();
v7 = v13;
}
v7(v11, v17);
if ( v12 )
((void ( *)(_QWORD *, _QWORD *, long long))v12)(v11, v11, 3LL);
if ( (_QWORD)v15 )
((void ( *)(__int128 *, __int128 *, long long))v15)(&v14, &v14, 3LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(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(v22);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v21);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v20);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(&v19);
v8 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
v9 = *(_DWORD *)(v18 + 12);
*(_DWORD *)(v18 + 12) = v9 - 1;
}
else
{
v9 = _InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( v9 == 1 )
(*(void ( **)(long long, _QWORD))(*(_QWORD *)v8 + 24LL))(v8, 0LL);
}
}
| do_render:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV R14,RSI
MOV RSI,qword ptr [RDI + 0x38]
TEST RSI,RSI
JZ 0x001f0ca3
MOV RBX,RDI
CMP qword ptr [RDI + 0x58],0x0
JZ 0x001f0cc1
MOV R15,RDX
LEA R12,[RSP + 0x48]
MOV RDI,R12
CALL 0x001e1958
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x8],0x0
LAB_001f0b7e:
MOV EDI,0x28
CALL 0x00120200
MOV qword ptr [RAX],R12
MOV qword ptr [RAX + 0x8],RBX
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x18],R14
LEA RCX,[RSP + 0x20]
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RSP],RAX
LEA RAX,[0x1f0e94]
MOV qword ptr [RSP + 0x18],RAX
LEA RCX,[0x1f0e9c]
MOV qword ptr [RSP + 0x10],RCX
CMP byte ptr [RBX + 0x68],0x0
JZ 0x001f0be7
MOV RBX,RSP
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],RBX
LEA RDI,[RSP + 0x20]
CALL 0x001f0e1e
CMP qword ptr [RBX + 0x10],0x0
JZ 0x001f0cf3
MOV RAX,qword ptr [RSP + 0x18]
LAB_001f0be7:
MOV RDI,RSP
LEA RSI,[RSP + 0x48]
CALL RAX
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x001f0c08
LAB_001f0bfb:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001f0c08:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x001f0c21
LAB_001f0c12:
LEA RDI,[RSP + 0x20]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001f0c21:
LEA RBX,[RSP + 0x88]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001858ca
MOV RDI,RBX
CALL 0x00189fe4
LEA RDI,[RSP + 0x80]
CALL 0x00171092
LEA RDI,[RSP + 0x70]
CALL 0x00171092
LEA RBX,[RSP + 0x60]
MOV RDI,RBX
CALL 0x00171092
MOV RDI,qword ptr [RBX + -0x10]
TEST RDI,RDI
JZ 0x001f0c94
MOV RAX,qword ptr [0x00261f98]
CMP byte ptr [RAX],0x0
JZ 0x001f0c7f
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x001f0c89
LAB_001f0c7f:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_001f0c89:
CMP EAX,0x1
JNZ 0x001f0c94
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_001f0c94:
ADD RSP,0x98
POP RBX
POP R12
POP R14
POP R15
RET
LAB_001f0ca3:
MOV EDI,0x10
CALL 0x00120620
MOV R14,RAX
LAB_001f0cb0:
LEA RSI,[0x222058]
MOV RDI,RAX
CALL 0x00120400
LAB_001f0cbf:
JMP 0x001f0cdd
LAB_001f0cc1:
MOV EDI,0x10
CALL 0x00120620
MOV R14,RAX
LAB_001f0cce:
LEA RSI,[0x222071]
MOV RDI,RAX
CALL 0x00120400
LAB_001f0cdd:
MOV RSI,qword ptr [0x00261fc0]
MOV RDX,qword ptr [0x00261f80]
MOV RDI,R14
CALL 0x00120a30
LAB_001f0cf3:
CALL 0x00121240
|
/* minja::ForNode::do_render(std::__cxx11::ostringstream&, std::shared_ptr<minja::Context> const&)
const */
void __thiscall minja::ForNode::do_render(ForNode *this,ostringstream *param_1,shared_ptr *param_2)
{
int *piVar1;
int iVar2;
runtime_error *this_00;
int8 *local_b8;
int8 local_b0;
code *local_a8;
code *local_a0;
int8 local_98;
int8 uStack_90;
code *local_88;
int8 uStack_80;
int1 *local_78;
Expression local_70 [8];
long *local_68;
__shared_count<(__gnu_cxx::_Lock_policy)2> local_58 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_48 [16];
__shared_count<(__gnu_cxx::_Lock_policy)2> local_38 [8];
data local_30 [16];
if (*(shared_ptr **)(this + 0x38) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f0cb0 to 001f0cbe has its CatchHandler @ 001f0cfa */
std::runtime_error::runtime_error(this_00,"ForNode.iterable is null");
}
else {
if (*(long *)(this + 0x58) != 0) {
Expression::evaluate(local_70,*(shared_ptr **)(this + 0x38));
local_88 = (code *)0x0;
uStack_80 = 0;
local_98 = 0;
uStack_90 = 0;
local_b0 = 0;
/* try { // try from 001f0b7e to 001f0b87 has its CatchHandler @ 001f0d0b */
local_b8 = (int8 *)operator_new(0x28);
*local_b8 = local_70;
local_b8[1] = this;
local_b8[2] = param_2;
local_b8[3] = param_1;
local_b8[4] = &local_98;
local_a0 = std::
_Function_handler<void(minja::Value&),minja::ForNode::do_render(std::__cxx11::ostringstream&,std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value&)#1}>
::_M_invoke;
local_a8 = std::
_Function_handler<void(minja::Value&),minja::ForNode::do_render(std::__cxx11::ostringstream&,std::shared_ptr<minja::Context>const&)const::{lambda(minja::Value&)#1}>
::_M_manager;
if ((this[0x68] != (ForNode)0x0) &&
(local_78 = (int1 *)&local_b8,
std::function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>::
operator=((function<minja::Value(std::shared_ptr<minja::Context>const&,minja::ArgumentsValue&)>
*)&local_98,
(_lambda_std__shared_ptr<minja::Context>_const__minja__ArgumentsValue___1_ *)
&local_78), local_a8 == (code *)0x0)) {
/* WARNING: Subroutine does not return */
/* try { // try from 001f0cf3 to 001f0cf7 has its CatchHandler @ 001f0d10 */
std::__throw_bad_function_call();
}
/* try { // try from 001f0be7 to 001f0bf0 has its CatchHandler @ 001f0d10 */
(*local_a0)(&local_b8,local_70);
if (local_a8 != (code *)0x0) {
/* try { // try from 001f0bfb to 001f0c07 has its CatchHandler @ 001f0d09 */
(*local_a8)(&local_b8,&local_b8,3);
}
if (local_88 != (code *)0x0) {
/* try { // try from 001f0c12 to 001f0c20 has its CatchHandler @ 001f0d07 */
(*local_88)(&local_98,&local_98,3);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(local_30,0));
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::data::~data(local_30);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_38);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_48);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(local_58);
if (local_68 != (long *)0x0) {
if (*PTR___libc_single_threaded_00261f98 == '\0') {
LOCK();
piVar1 = (int *)((long)local_68 + 0xc);
iVar2 = *piVar1;
*piVar1 = *piVar1 + -1;
UNLOCK();
}
else {
iVar2 = *(int *)((long)local_68 + 0xc);
*(int *)((long)local_68 + 0xc) = iVar2 + -1;
}
if (iVar2 == 1) {
(**(code **)(*local_68 + 0x18))();
}
}
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001f0cce to 001f0cdc has its CatchHandler @ 001f0cf8 */
std::runtime_error::runtime_error(this_00,"ForNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00261fc0,PTR__runtime_error_00261f80);
}
| |
22,257 | safe_lexcstrdup_root | eloqsql/mysys/my_alloc.c | LEX_CSTRING safe_lexcstrdup_root(MEM_ROOT *root, const LEX_CSTRING str)
{
LEX_CSTRING res;
if (str.length)
res.str= strmake_root(root, str.str, str.length);
else
res.str= (const char *)"";
res.length= str.length;
return res;
} | O0 | c | safe_lexcstrdup_root:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %rdi, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x34be2
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x34b00
movq %rax, -0x10(%rbp)
jmp 0x34bed
leaq 0x49121(%rip), %rax # 0x7dd0a
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| safe_lexcstrdup_root:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_20], rsi
mov [rbp+var_18], rdx
mov [rbp+var_28], rdi
cmp [rbp+var_18], 0
jz short loc_34BE2
mov rdi, [rbp+var_28]
mov rsi, [rbp+var_20]
mov rdx, [rbp+var_18]
call strmake_root
mov [rbp+var_10], rax
jmp short loc_34BED
loc_34BE2:
lea rax, asc_7DD06+4; ""
mov [rbp+var_10], rax
loc_34BED:
mov rax, [rbp+var_18]
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 30h
pop rbp
retn
| char * safe_lexcstrdup_root(_QWORD **a1, long long a2, long long a3)
{
if ( a3 )
return strmake_root(a1, a2, a3);
else
return "";
}
| safe_lexcstrdup_root:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x28],RDI
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00134be2
MOV RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x20]
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x00134b00
MOV qword ptr [RBP + -0x10],RAX
JMP 0x00134bed
LAB_00134be2:
LEA RAX,[0x17dd0a]
MOV qword ptr [RBP + -0x10],RAX
LAB_00134bed:
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x30
POP RBP
RET
|
int1 [16] safe_lexcstrdup_root(int8 param_1,int8 param_2,long param_3)
{
int1 auVar1 [16];
int *local_18;
if (param_3 == 0) {
local_18 = &DAT_0017dd0a;
}
else {
local_18 = (int *)strmake_root(param_1,param_2,param_3);
}
auVar1._8_8_ = param_3;
auVar1._0_8_ = local_18;
return auVar1;
}
| |
22,258 | rtree_get_first | eloqsql/storage/myisam/rt_index.c | int rtree_get_first(MI_INFO *info, uint keynr, uint key_length)
{
my_off_t root;
MI_KEYDEF *keyinfo = info->s->keyinfo + keynr;
if ((root = info->s->state.key_root[keynr]) == HA_OFFSET_ERROR)
{
my_errno= HA_ERR_END_OF_FILE;
return -1;
}
info->rtree_recursion_depth = -1;
info->buff_used = 1;
return rtree_get_req(info, keyinfo, key_length, root, 0);
} | O3 | c | rtree_get_first:
movq (%rdi), %rax
movl %esi, %ecx
movq 0x98(%rax), %rdx
movq (%rdx,%rcx,8), %rdx
cmpq $-0x1, %rdx
je 0xa4dd9
imulq $0x70, %rcx, %rsi
addq 0x218(%rax), %rsi
movl $0xffffffff, 0x3c0(%rdi) # imm = 0xFFFFFFFF
movb $0x1, 0x33d(%rdi)
xorl %ecx, %ecx
jmp 0xa4def
pushq %rbp
movq %rsp, %rbp
callq 0xc14ee
movl $0x89, (%rax)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
popq %rbp
retq
| rtree_get_first:
mov rax, [rdi]
mov ecx, esi
mov rdx, [rax+98h]
mov rdx, [rdx+rcx*8]
cmp rdx, 0FFFFFFFFFFFFFFFFh
jz short loc_A4DD9
imul rsi, rcx, 70h ; 'p'
add rsi, [rax+218h]
mov dword ptr [rdi+3C0h], 0FFFFFFFFh
mov byte ptr [rdi+33Dh], 1
xor ecx, ecx
jmp short rtree_get_req
loc_A4DD9:
push rbp
mov rbp, rsp
call _my_thread_var
mov dword ptr [rax], 89h
mov eax, 0FFFFFFFFh
pop rbp
retn
| long long rtree_get_first(long long a1, unsigned int a2)
{
long long v2; // rdx
long long v3; // rsi
v2 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)a1 + 152LL) + 8LL * a2);
if ( v2 == -1 )
{
*(_DWORD *)my_thread_var(a1) = 137;
return 0xFFFFFFFFLL;
}
else
{
v3 = *(_QWORD *)(*(_QWORD *)a1 + 536LL) + 112LL * a2;
*(_DWORD *)(a1 + 960) = -1;
*(_BYTE *)(a1 + 829) = 1;
return rtree_get_req(a1, v3, v2, 0LL);
}
}
| rtree_get_first:
MOV RAX,qword ptr [RDI]
MOV ECX,ESI
MOV RDX,qword ptr [RAX + 0x98]
MOV RDX,qword ptr [RDX + RCX*0x8]
CMP RDX,-0x1
JZ 0x001a4dd9
IMUL RSI,RCX,0x70
ADD RSI,qword ptr [RAX + 0x218]
MOV dword ptr [RDI + 0x3c0],0xffffffff
MOV byte ptr [RDI + 0x33d],0x1
XOR ECX,ECX
JMP 0x001a4def
LAB_001a4dd9:
PUSH RBP
MOV RBP,RSP
CALL 0x001c14ee
MOV dword ptr [RAX],0x89
MOV EAX,0xffffffff
POP RBP
RET
|
int8 rtree_get_first(long *param_1,ulong param_2)
{
long lVar1;
long lVar2;
int8 uVar3;
int4 *puVar4;
lVar1 = *(long *)(*(long *)(*param_1 + 0x98) + (param_2 & 0xffffffff) * 8);
if (lVar1 != -1) {
lVar2 = *(long *)(*param_1 + 0x218);
*(int4 *)(param_1 + 0x78) = 0xffffffff;
*(int1 *)((long)param_1 + 0x33d) = 1;
uVar3 = rtree_get_req(param_1,(param_2 & 0xffffffff) * 0x70 + lVar2,lVar1,0);
return uVar3;
}
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0x89;
return 0xffffffff;
}
| |
22,259 | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) | ng-log[P]ng-log/src/vlog_is_on.cc | NGLOG_NO_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len,
const char* str, size_t str_len) {
size_t p = 0;
size_t s = 0;
while (true) {
if (p == patt_len && s == str_len) return true;
if (p == patt_len) return false;
if (s == str_len) return p + 1 == patt_len && pattern[p] == '*';
if (pattern[p] == str[s] || pattern[p] == '?') {
p += 1;
s += 1;
continue;
}
if (pattern[p] == '*') {
if (p + 1 == patt_len) return true;
do {
if (SafeFNMatch_(pattern + (p + 1), patt_len - (p + 1), str + s,
str_len - s)) {
return true;
}
s += 1;
} while (s != str_len);
return false;
}
return false;
}
} | O1 | cpp | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rcx, %rcx
sete %al
testq %rsi, %rsi
sete %r8b
je 0x2344b
movq %rcx, %r14
movq %rdx, %rbx
leaq -0x1(%rsi), %rcx
leaq -0x1(%r14), %rdx
xorl %r15d, %r15d
testb $0x1, %al
jne 0x23450
movb (%rdi,%r15), %al
cmpb $0x3f, %al
je 0x23432
cmpb (%rbx,%r15), %al
jne 0x2345f
cmpq %r15, %rcx
sete %r8b
cmpq %r15, %rdx
leaq 0x1(%r15), %r9
sete %al
movq %r9, %r15
cmpq %r9, %rsi
jne 0x23420
andb %r8b, %al
jmp 0x234a6
cmpq %r15, %rcx
jne 0x234a4
cmpb $0x2a, (%rdi,%r15)
sete %al
jmp 0x234a6
cmpb $0x2a, %al
jne 0x234a4
movb $0x1, %al
cmpq %r15, %rcx
je 0x234a6
addq %r15, %rbx
subq %r15, %r14
leaq (%rdi,%r15), %r12
incq %r12
notq %r15
addq %rsi, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x233f8
testb %al, %al
jne 0x234a6
leaq -0x1(%r14), %rcx
incq %rbx
cmpq $0x1, %r14
movq %rcx, %r14
jne 0x2347d
jmp 0x234a6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m:
push r15
push r14
push r12
push rbx
push rax
test rcx, rcx
setz al
test rsi, rsi
setz r8b; unsigned __int64
jz short loc_2344B
mov r14, rcx
mov rbx, rdx
lea rcx, [rsi-1]
lea rdx, [r14-1]
xor r15d, r15d
loc_23420:
test al, 1
jnz short loc_23450
mov al, [rdi+r15]
cmp al, 3Fh ; '?'
jz short loc_23432
cmp al, [rbx+r15]
jnz short loc_2345F
loc_23432:
cmp rcx, r15
setz r8b
cmp rdx, r15
lea r9, [r15+1]
setz al
mov r15, r9
cmp rsi, r9
jnz short loc_23420
loc_2344B:
and al, r8b
jmp short loc_234A6
loc_23450:
cmp rcx, r15
jnz short loc_234A4
cmp byte ptr [rdi+r15], 2Ah ; '*'
setz al
jmp short loc_234A6
loc_2345F:
cmp al, 2Ah ; '*'
jnz short loc_234A4
mov al, 1
cmp rcx, r15
jz short loc_234A6
add rbx, r15
sub r14, r15
lea r12, [rdi+r15]
inc r12
not r15
add r15, rsi
loc_2347D:
mov rdi, r12; this
mov rsi, r15; char *
mov rdx, rbx; unsigned __int64
mov rcx, r14; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jnz short loc_234A6
lea rcx, [r14-1]
inc rbx
cmp r14, 1
mov r14, rcx
jnz short loc_2347D
jmp short loc_234A6
loc_234A4:
xor eax, eax
loc_234A6:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| char nglog::tools::SafeFNMatch_(
nglog::tools *this,
const char *a2,
long long a3,
const char *a4,
unsigned long long a5)
{
bool v5; // al
const char *v7; // rcx
const char *v8; // r15
char v9; // al
char result; // al
unsigned long long v11; // rbx
const char *v12; // r14
nglog::tools *v13; // r12
const char *v14; // r15
v5 = a4 == 0LL;
LOBYTE(a5) = a2 == 0LL;
if ( !a2 )
return a5 & v5;
v7 = a2 - 1;
v8 = 0LL;
while ( 1 )
{
if ( v5 )
{
if ( v7 == v8 )
return v8[(_QWORD)this] == 42;
return 0;
}
v9 = v8[(_QWORD)this];
if ( v9 != 63 && v9 != v8[a3] )
break;
LOBYTE(a5) = v7 == v8;
v5 = a4 - 1 == v8++;
if ( a2 == v8 )
return a5 & v5;
}
if ( v9 != 42 )
return 0;
result = 1;
if ( v7 != v8 )
{
v11 = (unsigned long long)&v8[a3];
v12 = (const char *)(a4 - v8);
v13 = (nglog::tools *)&v8[(_QWORD)this + 1];
v14 = &a2[~(unsigned long long)v8];
do
{
result = nglog::tools::SafeFNMatch_(v13, v14, v11, v12, a5);
if ( result )
break;
++v11;
--v12;
}
while ( v12 );
}
return result;
}
| SafeFNMatch_:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
TEST RCX,RCX
SETZ AL
TEST RSI,RSI
SETZ R8B
JZ 0x0012344b
MOV R14,RCX
MOV RBX,RDX
LEA RCX,[RSI + -0x1]
LEA RDX,[R14 + -0x1]
XOR R15D,R15D
LAB_00123420:
TEST AL,0x1
JNZ 0x00123450
MOV AL,byte ptr [RDI + R15*0x1]
CMP AL,0x3f
JZ 0x00123432
CMP AL,byte ptr [RBX + R15*0x1]
JNZ 0x0012345f
LAB_00123432:
CMP RCX,R15
SETZ R8B
CMP RDX,R15
LEA R9,[R15 + 0x1]
SETZ AL
MOV R15,R9
CMP RSI,R9
JNZ 0x00123420
LAB_0012344b:
AND AL,R8B
JMP 0x001234a6
LAB_00123450:
CMP RCX,R15
JNZ 0x001234a4
CMP byte ptr [RDI + R15*0x1],0x2a
SETZ AL
JMP 0x001234a6
LAB_0012345f:
CMP AL,0x2a
JNZ 0x001234a4
MOV AL,0x1
CMP RCX,R15
JZ 0x001234a6
ADD RBX,R15
SUB R14,R15
LEA R12,[RDI + R15*0x1]
INC R12
NOT R15
ADD R15,RSI
LAB_0012347d:
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
MOV RCX,R14
CALL 0x001233f8
TEST AL,AL
JNZ 0x001234a6
LEA RCX,[R14 + -0x1]
INC RBX
CMP R14,0x1
MOV R14,RCX
JNZ 0x0012347d
JMP 0x001234a6
LAB_001234a4:
XOR EAX,EAX
LAB_001234a6:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) */
bool nglog::tools::SafeFNMatch_(char *param_1,ulong param_2,char *param_3,ulong param_4)
{
char cVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bool bVar6;
bVar5 = param_4 == 0;
bVar6 = param_2 == 0;
if (!bVar6) {
uVar3 = param_2 - 1;
uVar4 = 0;
do {
if (bVar5) {
if (uVar3 != uVar4) {
return false;
}
return param_1[uVar4] == '*';
}
cVar1 = param_1[uVar4];
if ((cVar1 != '?') && (cVar1 != param_3[uVar4])) {
if (cVar1 != '*') {
return false;
}
if (uVar3 != uVar4) {
pcVar2 = param_3 + uVar4;
uVar3 = param_4 - uVar4;
do {
cVar1 = SafeFNMatch_(param_1 + uVar4 + 1,~uVar4 + param_2,pcVar2,uVar3);
if (cVar1 != '\0') {
return (bool)cVar1;
}
pcVar2 = pcVar2 + 1;
bVar5 = uVar3 != 1;
uVar3 = uVar3 - 1;
} while (bVar5);
return false;
}
return true;
}
bVar6 = uVar3 == uVar4;
bVar5 = param_4 - 1 == uVar4;
uVar4 = uVar4 + 1;
} while (param_2 != uVar4);
}
return (bool)(bVar5 & bVar6);
}
| |
22,260 | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) | ng-log[P]ng-log/src/vlog_is_on.cc | NGLOG_NO_EXPORT bool SafeFNMatch_(const char* pattern, size_t patt_len,
const char* str, size_t str_len) {
size_t p = 0;
size_t s = 0;
while (true) {
if (p == patt_len && s == str_len) return true;
if (p == patt_len) return false;
if (s == str_len) return p + 1 == patt_len && pattern[p] == '*';
if (pattern[p] == str[s] || pattern[p] == '?') {
p += 1;
s += 1;
continue;
}
if (pattern[p] == '*') {
if (p + 1 == patt_len) return true;
do {
if (SafeFNMatch_(pattern + (p + 1), patt_len - (p + 1), str + s,
str_len - s)) {
return true;
}
s += 1;
} while (s != str_len);
return false;
}
return false;
}
} | O3 | cpp | nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long):
testq %rcx, %rcx
sete %al
testq %rsi, %rsi
je 0x23011
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
decq %rcx
xorl %r15d, %r15d
testb $0x1, %al
jne 0x22fa9
movb (%rdi,%r15), %al
cmpb $0x3f, %al
je 0x22f95
cmpb (%rbx,%r15), %al
jne 0x22fbb
cmpq %r15, %rcx
leaq 0x1(%r15), %rdx
sete %al
movq %rdx, %r15
cmpq %rdx, %rsi
jne 0x22f83
jmp 0x23006
decq %rsi
cmpq %r15, %rsi
jne 0x23004
cmpb $0x2a, (%rdi,%r15)
sete %al
jmp 0x23006
cmpb $0x2a, %al
jne 0x23004
leaq -0x1(%rsi), %rcx
movb $0x1, %al
cmpq %r15, %rcx
je 0x23006
addq %r15, %rbx
subq %r15, %r14
leaq (%rdi,%r15), %r12
incq %r12
notq %r15
addq %rsi, %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x22f60
testb %al, %al
jne 0x23006
leaq -0x1(%r14), %rcx
incq %rbx
cmpq $0x1, %r14
movq %rcx, %r14
jne 0x22fdd
jmp 0x23006
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m:
test rcx, rcx
setz al
test rsi, rsi
jz locret_23011
push r15
push r14
push r12
push rbx
push rax
mov r14, rcx
mov rbx, rdx
dec rcx
xor r15d, r15d
loc_22F83:
test al, 1
jnz short loc_22FA9
mov al, [rdi+r15]
cmp al, 3Fh ; '?'
jz short loc_22F95
cmp al, [rbx+r15]
jnz short loc_22FBB
loc_22F95:
cmp rcx, r15
lea rdx, [r15+1]
setz al
mov r15, rdx
cmp rsi, rdx
jnz short loc_22F83
jmp short loc_23006
loc_22FA9:
dec rsi
cmp rsi, r15
jnz short loc_23004
cmp byte ptr [rdi+r15], 2Ah ; '*'
setz al
jmp short loc_23006
loc_22FBB:
cmp al, 2Ah ; '*'
jnz short loc_23004
lea rcx, [rsi-1]
mov al, 1
cmp rcx, r15
jz short loc_23006
add rbx, r15
sub r14, r15
lea r12, [rdi+r15]
inc r12
not r15
add r15, rsi
loc_22FDD:
mov rdi, r12; this
mov rsi, r15; char *
mov rdx, rbx; unsigned __int64
mov rcx, r14; char *
call _ZN5nglog5tools12SafeFNMatch_EPKcmS2_m; nglog::tools::SafeFNMatch_(char const*,ulong,char const*,ulong)
test al, al
jnz short loc_23006
lea rcx, [r14-1]
inc rbx
cmp r14, 1
mov r14, rcx
jnz short loc_22FDD
jmp short loc_23006
loc_23004:
xor eax, eax
loc_23006:
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
locret_23011:
retn
| char nglog::tools::SafeFNMatch_(
nglog::tools *this,
const char *a2,
long long a3,
const char *a4,
unsigned long long a5)
{
char result; // al
const char *v7; // rcx
const char *v8; // r15
char v9; // al
unsigned long long v10; // rbx
const char *v11; // r14
nglog::tools *v12; // r12
const char *v13; // r15
result = a4 == 0LL;
if ( !a2 )
return result;
v7 = a4 - 1;
v8 = 0LL;
while ( 1 )
{
if ( (result & 1) != 0 )
{
if ( a2 - 1 == v8 )
return v8[(_QWORD)this] == 42;
return 0;
}
v9 = v8[(_QWORD)this];
if ( v9 != 63 && v9 != v8[a3] )
break;
result = v7 == v8++;
if ( a2 == v8 )
return result;
}
if ( v9 != 42 )
return 0;
result = 1;
if ( a2 - 1 != v8 )
{
v10 = (unsigned long long)&v8[a3];
v11 = (const char *)(a4 - v8);
v12 = (nglog::tools *)&v8[(_QWORD)this + 1];
v13 = &a2[~(unsigned long long)v8];
do
{
result = nglog::tools::SafeFNMatch_(v12, v13, v10, v11, a5);
if ( result )
break;
++v10;
--v11;
}
while ( v11 );
}
return result;
}
| SafeFNMatch_:
TEST RCX,RCX
SETZ AL
TEST RSI,RSI
JZ 0x00123011
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RCX
MOV RBX,RDX
DEC RCX
XOR R15D,R15D
LAB_00122f83:
TEST AL,0x1
JNZ 0x00122fa9
MOV AL,byte ptr [RDI + R15*0x1]
CMP AL,0x3f
JZ 0x00122f95
CMP AL,byte ptr [RBX + R15*0x1]
JNZ 0x00122fbb
LAB_00122f95:
CMP RCX,R15
LEA RDX,[R15 + 0x1]
SETZ AL
MOV R15,RDX
CMP RSI,RDX
JNZ 0x00122f83
JMP 0x00123006
LAB_00122fa9:
DEC RSI
CMP RSI,R15
JNZ 0x00123004
CMP byte ptr [RDI + R15*0x1],0x2a
SETZ AL
JMP 0x00123006
LAB_00122fbb:
CMP AL,0x2a
JNZ 0x00123004
LEA RCX,[RSI + -0x1]
MOV AL,0x1
CMP RCX,R15
JZ 0x00123006
ADD RBX,R15
SUB R14,R15
LEA R12,[RDI + R15*0x1]
INC R12
NOT R15
ADD R15,RSI
LAB_00122fdd:
MOV RDI,R12
MOV RSI,R15
MOV RDX,RBX
MOV RCX,R14
CALL 0x00122f60
TEST AL,AL
JNZ 0x00123006
LEA RCX,[R14 + -0x1]
INC RBX
CMP R14,0x1
MOV R14,RCX
JNZ 0x00122fdd
JMP 0x00123006
LAB_00123004:
XOR EAX,EAX
LAB_00123006:
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
LAB_00123011:
RET
|
/* nglog::tools::SafeFNMatch_(char const*, unsigned long, char const*, unsigned long) */
bool nglog::tools::SafeFNMatch_(char *param_1,ulong param_2,char *param_3,ulong param_4)
{
char cVar1;
char *pcVar2;
ulong uVar3;
ulong uVar4;
bool bVar5;
bVar5 = param_4 == 0;
if (param_2 == 0) {
return bVar5;
}
uVar4 = 0;
while( true ) {
if (bVar5) {
if (param_2 - 1 != uVar4) {
return false;
}
return param_1[uVar4] == '*';
}
cVar1 = param_1[uVar4];
if ((cVar1 != '?') && (cVar1 != param_3[uVar4])) break;
bVar5 = param_4 - 1 == uVar4;
uVar4 = uVar4 + 1;
if (param_2 == uVar4) {
return bVar5;
}
}
if (cVar1 != '*') {
return false;
}
if (param_2 - 1 != uVar4) {
pcVar2 = param_3 + uVar4;
uVar3 = param_4 - uVar4;
do {
cVar1 = SafeFNMatch_(param_1 + uVar4 + 1,~uVar4 + param_2,pcVar2,uVar3);
if (cVar1 != '\0') {
return (bool)cVar1;
}
pcVar2 = pcVar2 + 1;
bVar5 = uVar3 != 1;
uVar3 = uVar3 - 1;
} while (bVar5);
return false;
}
return true;
}
| |
22,261 | CLI::IncorrectConstruction::IncorrectConstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::ExitCodes) | MikePodsytnik[P]TCRtrie/build_O1/_deps/cli11-src/include/CLI/Error.hpp | static IncorrectConstruction PositionalFlag(std::string name) {
return IncorrectConstruction(name + ": Flags cannot be positional");
} | O1 | cpp | CLI::IncorrectConstruction::IncorrectConstruction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, CLI::ExitCodes):
pushq %rbx
movq %rdi, %rbx
leaq 0x2b93f(%rip), %rax # 0x491f0
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x1d8cc
movq (%rax), %rsi
incq %rsi
callq 0x7430
movq %rbx, %rdi
callq 0x7490
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7430
| _ZN3CLI21IncorrectConstructionD0Ev:
push rbx
mov rbx, rdi
lea rax, off_491F0
mov [rdi], rax
mov rdi, [rdi+18h]; void *
lea rax, [rbx+28h]
cmp rdi, rax
jz short loc_1D8CC
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_1D8CC:
mov rdi, rbx; this
call __ZNSt13runtime_errorD2Ev; std::runtime_error::~runtime_error()
mov esi, 38h ; '8'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void CLI::IncorrectConstruction::~IncorrectConstruction(CLI::IncorrectConstruction *this)
{
char *v2; // rdi
*(_QWORD *)this = off_491F0;
v2 = (char *)*((_QWORD *)this + 3);
if ( v2 != (char *)this + 40 )
operator delete(v2, *((_QWORD *)this + 5) + 1LL);
std::runtime_error::~runtime_error(this);
operator delete(this, 0x38uLL);
}
| ~IncorrectConstruction:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1491f0]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x18]
LEA RAX,[RBX + 0x28]
CMP RDI,RAX
JZ 0x0011d8cc
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x00107430
LAB_0011d8cc:
MOV RDI,RBX
CALL 0x00107490
MOV ESI,0x38
MOV RDI,RBX
POP RBX
JMP 0x00107430
|
/* CLI::IncorrectConstruction::~IncorrectConstruction() */
void __thiscall CLI::IncorrectConstruction::~IncorrectConstruction(IncorrectConstruction *this)
{
*(int ***)this = &PTR__Error_001491f0;
if (*(IncorrectConstruction **)(this + 0x18) != this + 0x28) {
operator_delete(*(IncorrectConstruction **)(this + 0x18),*(long *)(this + 0x28) + 1);
}
std::runtime_error::~runtime_error((runtime_error *)this);
operator_delete(this,0x38);
return;
}
| |
22,262 | my_caseup_8bit | eloqsql/strings/ctype-simple.c | size_t my_caseup_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_upper;
DBUG_ASSERT(srclen <= dstlen);
for ( ; src != end ; src++)
*dst++= (char) map[(uchar) *src];
return srclen;
} | O3 | c | my_caseup_8bit:
movq %rdx, %rax
testq %rdx, %rdx
je 0xbfd67
pushq %rbp
movq %rsp, %rbp
movq 0x50(%rdi), %rdx
xorl %edi, %edi
movzbl (%rsi,%rdi), %r8d
movb (%rdx,%r8), %r8b
movb %r8b, (%rcx,%rdi)
incq %rdi
cmpq %rdi, %rax
jne 0xbfd51
popq %rbp
retq
| my_caseup_8bit:
mov rax, rdx
test rdx, rdx
jz short locret_BFD67
push rbp
mov rbp, rsp
mov rdx, [rdi+50h]
xor edi, edi
loc_BFD51:
movzx r8d, byte ptr [rsi+rdi]
mov r8b, [rdx+r8]
mov [rcx+rdi], r8b
inc rdi
cmp rax, rdi
jnz short loc_BFD51
pop rbp
locret_BFD67:
retn
| long long my_caseup_8bit(long long a1, long long a2, long long a3, long long a4)
{
long long result; // rax
long long v5; // rdx
long long v6; // rdi
result = a3;
if ( a3 )
{
v5 = *(_QWORD *)(a1 + 80);
v6 = 0LL;
do
{
*(_BYTE *)(a4 + v6) = *(_BYTE *)(v5 + *(unsigned __int8 *)(a2 + v6));
++v6;
}
while ( result != v6 );
}
return result;
}
| my_caseup_8bit:
MOV RAX,RDX
TEST RDX,RDX
JZ 0x001bfd67
PUSH RBP
MOV RBP,RSP
MOV RDX,qword ptr [RDI + 0x50]
XOR EDI,EDI
LAB_001bfd51:
MOVZX R8D,byte ptr [RSI + RDI*0x1]
MOV R8B,byte ptr [RDX + R8*0x1]
MOV byte ptr [RCX + RDI*0x1],R8B
INC RDI
CMP RAX,RDI
JNZ 0x001bfd51
POP RBP
LAB_001bfd67:
RET
|
void my_caseup_8bit(long param_1,long param_2,long param_3,long param_4)
{
long lVar1;
long lVar2;
if (param_3 != 0) {
lVar1 = *(long *)(param_1 + 0x50);
lVar2 = 0;
do {
*(int1 *)(param_4 + lVar2) = *(int1 *)(lVar1 + (ulong)*(byte *)(param_2 + lVar2));
lVar2 = lVar2 + 1;
} while (param_3 != lVar2);
}
return;
}
| |
22,263 | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool) | monkey531[P]llama/common/common.cpp | std::string common_detokenize(const struct llama_vocab * vocab, const std::vector<llama_token> & tokens, bool special) {
std::string text;
text.resize(std::max(text.capacity(), tokens.size()));
int32_t n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
if (n_chars < 0) {
text.resize(-n_chars);
n_chars = llama_detokenize(vocab, tokens.data(), (int32_t)tokens.size(), &text[0], (int32_t)text.size(), false, special);
GGML_ASSERT(n_chars <= (int32_t)text.size()); // whitespace trimming is performed after per-token detokenization
}
text.resize(n_chars);
// NOTE: the original tokenizer decodes bytes after collecting the pieces.
return text;
} | O3 | cpp | common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int>> const&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
subq (%rdx), %rax
sarq $0x2, %rax
cmpq $0x10, %rax
movl $0xf, %esi
cmovaeq %rax, %rsi
xorl %edx, %edx
callq 0x1a240
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movzbl %bpl, %ebp
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x1a0d0
testl %eax, %eax
jns 0x763d4
negl %eax
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x1a240
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
shrq $0x2, %rdx
movq (%rbx), %rcx
movl 0x8(%rbx), %r8d
movl %ebp, (%rsp)
movq %r14, %rdi
xorl %r9d, %r9d
callq 0x1a0d0
cmpl 0x8(%rbx), %eax
jg 0x763f1
movslq %eax, %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1a240
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x786f9(%rip), %rdi # 0xeeaf1
leaq 0x758f4(%rip), %rdx # 0xebcf3
leaq 0x78d90(%rip), %rcx # 0xef196
movl $0x6e2, %esi # imm = 0x6E2
xorl %eax, %eax
callq 0x1aeb0
jmp 0x76414
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x7642b
movq (%r12), %rsi
incq %rsi
callq 0x1a8e0
movq %r14, %rdi
callq 0x1afb0
| _Z17common_detokenizeB5cxx11PK11llama_vocabRKSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebp, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rax, [rdx+8]
sub rax, [rdx]
sar rax, 2
cmp rax, 10h
mov esi, 0Fh
cmovnb rsi, rax
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
movzx ebp, bpl
mov [rsp+38h+var_38], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
test eax, eax
jns short loc_763D4
neg eax
mov rdi, rbx
mov rsi, rax
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rsi, [r15]
mov rdx, [r15+8]
sub rdx, rsi
shr rdx, 2
mov rcx, [rbx]
mov r8d, [rbx+8]
mov [rsp+38h+var_38], ebp
mov rdi, r14
xor r9d, r9d
call _llama_detokenize
cmp eax, [rbx+8]
jg short loc_763F1
loc_763D4:
movsxd rsi, eax
mov rdi, rbx
xor edx, edx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6resizeEmc; std::string::resize(ulong,char)
mov rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_763F1:
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aNCharsInt32TTe; "n_chars <= (int32_t)text.size()"
mov esi, 6E2h
xor eax, eax
call _ggml_abort
jmp short $+2
loc_76414:
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_7642B
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7642B:
mov rdi, r14
call __Unwind_Resume
| _QWORD * common_detokenize[abi:cxx11](_QWORD *a1, long long a2, _QWORD *a3, long long a4)
{
unsigned __int8 v4; // bp
_QWORD *v7; // r12
long long v8; // rsi
int v9; // eax
long long v10; // rcx
long long v12; // r14
v4 = a4;
v7 = a1 + 2;
*a1 = a1 + 2;
a1[1] = 0LL;
*((_BYTE *)a1 + 16) = 0;
v8 = 15LL;
if ( (unsigned long long)((long long)(a3[1] - *a3) >> 2) >= 0x10 )
v8 = (long long)(a3[1] - *a3) >> 2;
std::string::resize(a1, v8, 0LL, a4);
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v4);
if ( v9 < 0 )
{
std::string::resize(a1, (unsigned int)-v9, 0LL, v10);
v9 = llama_detokenize(a2, *a3, (a3[1] - *a3) >> 2, *a1, *((unsigned int *)a1 + 2), 0LL, v4);
if ( v9 > *((_DWORD *)a1 + 2) )
{
v12 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1762LL,
"GGML_ASSERT(%s) failed",
"n_chars <= (int32_t)text.size()");
if ( (_QWORD *)*a1 != v7 )
operator delete((void *)*a1, *v7 + 1LL);
_Unwind_Resume(v12);
}
}
std::string::resize(a1, v9, 0LL, v10);
return a1;
}
| common_detokenize[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBP,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RDX + 0x8]
SUB RAX,qword ptr [RDX]
SAR RAX,0x2
CMP RAX,0x10
MOV ESI,0xf
CMOVNC RSI,RAX
LAB_0017636b:
XOR EDX,EDX
CALL 0x0011a240
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
LAB_00176387:
MOVZX EBP,BPL
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x0011a0d0
TEST EAX,EAX
JNS 0x001763d4
NEG EAX
MOV RDI,RBX
MOV RSI,RAX
XOR EDX,EDX
CALL 0x0011a240
MOV RSI,qword ptr [R15]
MOV RDX,qword ptr [R15 + 0x8]
SUB RDX,RSI
SHR RDX,0x2
MOV RCX,qword ptr [RBX]
MOV R8D,dword ptr [RBX + 0x8]
MOV dword ptr [RSP],EBP
MOV RDI,R14
XOR R9D,R9D
CALL 0x0011a0d0
CMP EAX,dword ptr [RBX + 0x8]
JG 0x001763f1
LAB_001763d4:
MOVSXD RSI,EAX
MOV RDI,RBX
XOR EDX,EDX
CALL 0x0011a240
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001763f1:
LEA RDI,[0x1eeaf1]
LEA RDX,[0x1ebcf3]
LEA RCX,[0x1ef196]
MOV ESI,0x6e2
XOR EAX,EAX
CALL 0x0011aeb0
|
/* common_detokenize[abi:cxx11](llama_vocab const*, std::vector<int, std::allocator<int> > const&,
bool) */
llama_vocab * common_detokenize_abi_cxx11_(llama_vocab *param_1,vector *param_2,bool param_3)
{
int iVar1;
ulong uVar2;
int1 in_CL;
int7 in_register_00000011;
long *plVar3;
ulong uVar4;
plVar3 = (long *)CONCAT71(in_register_00000011,param_3);
*(llama_vocab **)param_1 = param_1 + 0x10;
*(int8 *)(param_1 + 8) = 0;
param_1[0x10] = (llama_vocab)0x0;
uVar2 = plVar3[1] - *plVar3 >> 2;
uVar4 = 0xf;
if (0xf < uVar2) {
uVar4 = uVar2;
}
/* try { // try from 0017636b to 00176371 has its CatchHandler @ 00176412 */
std::__cxx11::string::resize((ulong)param_1,(char)uVar4);
/* try { // try from 00176387 to 00176411 has its CatchHandler @ 00176414 */
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,*(int8 *)param_1,
*(int4 *)(param_1 + 8),0,in_CL);
if (iVar1 < 0) {
std::__cxx11::string::resize((ulong)param_1,-(char)iVar1);
iVar1 = llama_detokenize(param_2,*plVar3,(ulong)(plVar3[1] - *plVar3) >> 2,
*(int8 *)param_1,*(int4 *)(param_1 + 8),0,in_CL);
if (*(int *)(param_1 + 8) < iVar1) {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",0x6e2
,"GGML_ASSERT(%s) failed","n_chars <= (int32_t)text.size()");
}
}
std::__cxx11::string::resize((ulong)param_1,(char)iVar1);
return param_1;
}
| |
22,264 | google::protobuf::io::CodedInputStream::ReadTagFallback(unsigned int) | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/coded_stream.h | inline int CodedInputStream::BufferSize() const {
return static_cast<int>(buffer_end_ - buffer_);
} | O3 | c | google::protobuf::io::CodedInputStream::ReadTagFallback(unsigned int):
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movl %eax, %edx
subl %ecx, %edx
cmpl $0x9, %edx
jg 0x158dc
testl %edx, %edx
jle 0x1591e
cmpb $0x0, -0x1(%rax)
js 0x15854
testl %esi, %esi
je 0x158fb
movzbl 0x1(%rcx), %eax
movl %eax, %edx
shll $0x7, %edx
addl %esi, %edx
addl $-0x80, %edx
testb %al, %al
js 0x15903
addq $0x2, %rcx
jmp 0x1597d
incq %rcx
movq %rcx, (%rdi)
jmp 0x15946
movzbl 0x2(%rcx), %eax
movl %eax, %esi
shll $0xe, %esi
addl %esi, %edx
addl $0xffffc000, %edx # imm = 0xFFFFC000
testb %al, %al
js 0x15949
addq $0x3, %rcx
jmp 0x1597d
jne 0x15854
movl 0x2c(%rdi), %eax
movl 0x18(%rdi), %ecx
testl %eax, %eax
jg 0x15937
cmpl 0x28(%rdi), %ecx
jne 0x15854
subl %eax, %ecx
cmpl 0x30(%rdi), %ecx
jge 0x15854
movb $0x1, 0x24(%rdi)
xorl %eax, %eax
retq
movzbl 0x3(%rcx), %eax
movl %eax, %esi
shll $0x15, %esi
addl %esi, %edx
addl $0xffe00000, %edx # imm = 0xFFE00000
testb %al, %al
js 0x15964
addq $0x4, %rcx
jmp 0x1597d
movzbl 0x4(%rcx), %eax
movl %eax, %esi
shll $0x1c, %esi
addl %esi, %edx
addl $0xf0000000, %edx # imm = 0xF0000000
testb %al, %al
js 0x15983
addq $0x5, %rcx
movq %rcx, (%rdi)
movl %edx, %eax
retq
addq $0x6, %rcx
movl $0x5, %esi
xorl %eax, %eax
cmpb $0x0, -0x1(%rcx)
jns 0x1597d
incq %rcx
decl %esi
jne 0x1598e
jmp 0x15948
nop
| _ZN6google8protobuf2io16CodedInputStream15ReadTagFallbackEj:
mov rcx, [rdi]
mov rax, [rdi+8]
mov edx, eax
sub edx, ecx
cmp edx, 9
jg short loc_158DC
test edx, edx
jle short loc_1591E
cmp byte ptr [rax-1], 0
js _ZN6google8protobuf2io16CodedInputStream11ReadTagSlowEv; google::protobuf::io::CodedInputStream::ReadTagSlow(void)
loc_158DC:
test esi, esi
jz short loc_158FB
movzx eax, byte ptr [rcx+1]
mov edx, eax
shl edx, 7
add edx, esi
add edx, 0FFFFFF80h
test al, al
js short loc_15903
add rcx, 2
jmp loc_1597D
loc_158FB:
inc rcx
mov [rdi], rcx
jmp short loc_15946
loc_15903:
movzx eax, byte ptr [rcx+2]
mov esi, eax
shl esi, 0Eh
add edx, esi
add edx, 0FFFFC000h
test al, al
js short loc_15949
add rcx, 3
jmp short loc_1597D
loc_1591E:
jnz _ZN6google8protobuf2io16CodedInputStream11ReadTagSlowEv; google::protobuf::io::CodedInputStream::ReadTagSlow(void)
mov eax, [rdi+2Ch]
mov ecx, [rdi+18h]
test eax, eax
jg short loc_15937
cmp ecx, [rdi+28h]
jnz _ZN6google8protobuf2io16CodedInputStream11ReadTagSlowEv; google::protobuf::io::CodedInputStream::ReadTagSlow(void)
loc_15937:
sub ecx, eax
cmp ecx, [rdi+30h]
jge _ZN6google8protobuf2io16CodedInputStream11ReadTagSlowEv; google::protobuf::io::CodedInputStream::ReadTagSlow(void)
mov byte ptr [rdi+24h], 1
loc_15946:
xor eax, eax
locret_15948:
retn
loc_15949:
movzx eax, byte ptr [rcx+3]
mov esi, eax
shl esi, 15h
add edx, esi
add edx, 0FFE00000h
test al, al
js short loc_15964
add rcx, 4
jmp short loc_1597D
loc_15964:
movzx eax, byte ptr [rcx+4]
mov esi, eax
shl esi, 1Ch
add edx, esi
add edx, 0F0000000h
test al, al
js short loc_15983
add rcx, 5
loc_1597D:
mov [rdi], rcx
mov eax, edx
retn
loc_15983:
add rcx, 6
mov esi, 5
xor eax, eax
loc_1598E:
cmp byte ptr [rcx-1], 0
jns short loc_1597D
inc rcx
dec esi
jnz short loc_1598E
jmp short locret_15948
| long long google::protobuf::io::CodedInputStream::ReadTagFallback(
google::protobuf::io::CodedInputStream *this,
int a2)
{
unsigned __int8 *v2; // rcx
int v3; // edx
unsigned int v4; // edx
unsigned __int8 *v5; // rcx
int v6; // eax
int v7; // ecx
long long result; // rax
int v9; // esi
v2 = *(unsigned __int8 **)this;
v3 = *((_QWORD *)this + 1) - *(_QWORD *)this;
if ( v3 <= 9 )
{
if ( v3 <= 0 )
{
if ( !v3 )
{
v6 = *((_DWORD *)this + 11);
v7 = *((_DWORD *)this + 6);
if ( (v6 > 0 || v7 == *((_DWORD *)this + 10)) && v7 - v6 < *((_DWORD *)this + 12) )
{
*((_BYTE *)this + 36) = 1;
return 0LL;
}
}
}
else if ( *(char *)(*((_QWORD *)this + 1) - 1LL) >= 0 )
{
goto LABEL_4;
}
return google::protobuf::io::CodedInputStream::ReadTagSlow(this);
}
LABEL_4:
if ( !a2 )
{
*(_QWORD *)this = v2 + 1;
return 0LL;
}
v4 = a2 + (v2[1] << 7) - 128;
if ( (v2[1] & 0x80u) != 0 )
{
v4 = (v2[2] << 14) + v4 - 0x4000;
if ( (v2[2] & 0x80u) != 0 )
{
v4 = (v2[3] << 21) + v4 - 0x200000;
if ( (v2[3] & 0x80u) != 0 )
{
v4 = (v2[4] << 28) + v4 - 0x10000000;
if ( (v2[4] & 0x80u) != 0 )
{
v5 = v2 + 6;
v9 = 5;
result = 0LL;
while ( (*(v5 - 1) & 0x80u) != 0 )
{
++v5;
if ( !--v9 )
return result;
}
}
else
{
v5 = v2 + 5;
}
}
else
{
v5 = v2 + 4;
}
}
else
{
v5 = v2 + 3;
}
}
else
{
v5 = v2 + 2;
}
*(_QWORD *)this = v5;
return v4;
}
| ReadTagFallback:
MOV RCX,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
MOV EDX,EAX
SUB EDX,ECX
CMP EDX,0x9
JG 0x001158dc
TEST EDX,EDX
JLE 0x0011591e
CMP byte ptr [RAX + -0x1],0x0
JS 0x00115854
LAB_001158dc:
TEST ESI,ESI
JZ 0x001158fb
MOVZX EAX,byte ptr [RCX + 0x1]
MOV EDX,EAX
SHL EDX,0x7
ADD EDX,ESI
ADD EDX,-0x80
TEST AL,AL
JS 0x00115903
ADD RCX,0x2
JMP 0x0011597d
LAB_001158fb:
INC RCX
MOV qword ptr [RDI],RCX
JMP 0x00115946
LAB_00115903:
MOVZX EAX,byte ptr [RCX + 0x2]
MOV ESI,EAX
SHL ESI,0xe
ADD EDX,ESI
ADD EDX,0xffffc000
TEST AL,AL
JS 0x00115949
ADD RCX,0x3
JMP 0x0011597d
LAB_0011591e:
JNZ 0x00115854
MOV EAX,dword ptr [RDI + 0x2c]
MOV ECX,dword ptr [RDI + 0x18]
TEST EAX,EAX
JG 0x00115937
CMP ECX,dword ptr [RDI + 0x28]
JNZ 0x00115854
LAB_00115937:
SUB ECX,EAX
CMP ECX,dword ptr [RDI + 0x30]
JGE 0x00115854
MOV byte ptr [RDI + 0x24],0x1
LAB_00115946:
XOR EAX,EAX
LAB_00115948:
RET
LAB_00115949:
MOVZX EAX,byte ptr [RCX + 0x3]
MOV ESI,EAX
SHL ESI,0x15
ADD EDX,ESI
ADD EDX,0xffe00000
TEST AL,AL
JS 0x00115964
ADD RCX,0x4
JMP 0x0011597d
LAB_00115964:
MOVZX EAX,byte ptr [RCX + 0x4]
MOV ESI,EAX
SHL ESI,0x1c
ADD EDX,ESI
ADD EDX,0xf0000000
TEST AL,AL
JS 0x00115983
ADD RCX,0x5
LAB_0011597d:
MOV qword ptr [RDI],RCX
MOV EAX,EDX
RET
LAB_00115983:
ADD RCX,0x6
MOV ESI,0x5
XOR EAX,EAX
LAB_0011598e:
CMP byte ptr [RCX + -0x1],0x0
JNS 0x0011597d
INC RCX
DEC ESI
JNZ 0x0011598e
JMP 0x00115948
|
/* google::protobuf::io::CodedInputStream::ReadTagFallback(unsigned int) */
int __thiscall
google::protobuf::io::CodedInputStream::ReadTagFallback(CodedInputStream *this,uint param_1)
{
char cVar1;
char *pcVar2;
char *pcVar3;
long lVar4;
int iVar5;
ulong extraout_RDX;
int iVar6;
lVar4 = *(long *)this;
iVar6 = (int)*(long *)(this + 8);
iVar5 = iVar6 - (int)lVar4;
if (iVar5 < 10) {
if (iVar5 < 1) {
if (iVar6 == (int)lVar4) {
if (((0 < *(int *)(this + 0x2c)) || (*(int *)(this + 0x18) == *(int *)(this + 0x28))) &&
(*(int *)(this + 0x18) - *(int *)(this + 0x2c) < *(int *)(this + 0x30))) {
this[0x24] = (CodedInputStream)0x1;
return 0;
}
}
}
else if (-1 < *(char *)(*(long *)(this + 8) + -1)) goto LAB_001158dc;
pcVar3 = *(char **)this;
pcVar2 = *(char **)(this + 8);
if (pcVar3 == pcVar2) {
cVar1 = Refresh(this);
if (cVar1 == '\0') {
if (*(int *)(this + 0x18) - *(int *)(this + 0x2c) < *(int *)(this + 0x30)) {
this[0x24] = (CodedInputStream)0x1;
}
else {
this[0x24] = (CodedInputStream)(*(int *)(this + 0x28) == *(int *)(this + 0x30));
}
return 0;
}
pcVar3 = *(char **)this;
pcVar2 = *(char **)(this + 8);
}
if ((pcVar3 < pcVar2) && (cVar1 = *pcVar3, -1 < cVar1)) {
*(char **)this = pcVar3 + 1;
iVar5 = (int)cVar1;
}
else {
iVar6 = ReadVarint64Fallback(this);
iVar5 = 0;
if ((extraout_RDX & 1) != 0) {
iVar5 = iVar6;
}
}
return iVar5;
}
LAB_001158dc:
if (param_1 == 0) {
*(long *)this = lVar4 + 1;
return 0;
}
iVar5 = (uint)*(byte *)(lVar4 + 1) * 0x80 + param_1 + -0x80;
if ((char)*(byte *)(lVar4 + 1) < '\0') {
iVar5 = iVar5 + (uint)*(byte *)(lVar4 + 2) * 0x4000 + -0x4000;
if ((char)*(byte *)(lVar4 + 2) < '\0') {
iVar5 = iVar5 + (uint)*(byte *)(lVar4 + 3) * 0x200000 + -0x200000;
if ((char)*(byte *)(lVar4 + 3) < '\0') {
iVar5 = iVar5 + (uint)*(byte *)(lVar4 + 4) * 0x10000000 + -0x10000000;
if ((char)*(byte *)(lVar4 + 4) < '\0') {
lVar4 = lVar4 + 6;
iVar6 = 5;
while (*(char *)(lVar4 + -1) < '\0') {
lVar4 = lVar4 + 1;
iVar6 = iVar6 + -1;
if (iVar6 == 0) {
return 0;
}
}
}
else {
lVar4 = lVar4 + 5;
}
}
else {
lVar4 = lVar4 + 4;
}
}
else {
lVar4 = lVar4 + 3;
}
}
else {
lVar4 = lVar4 + 2;
}
*(long *)this = lVar4;
return iVar5;
}
| |
22,265 | testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*) | seiftnesse[P]memoryallocator/build_O0/_deps/googletest-src/googletest/src/gtest.cc | AssertionResult CmpHelperSTRCASEEQ(const char* lhs_expression,
const char* rhs_expression, const char* lhs,
const char* rhs) {
if (String::CaseInsensitiveCStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailure(lhs_expression, rhs_expression, PrintToString(lhs),
PrintToString(rhs), true);
} | O0 | cpp | testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*):
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x301f0
testb $0x1, %al
jne 0x30120
jmp 0x30131
movq -0x88(%rbp), %rdi
callq 0x1f090
jmp 0x301cf
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4eda0
leaq -0x68(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4eda0
jmp 0x30163
movq -0x90(%rbp), %rdx
movq -0x98(%rbp), %rsi
movq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rcx
leaq -0x68(%rbp), %r8
movl $0x1, %r9d
callq 0x2f3c0
jmp 0x3018d
leaq -0x68(%rbp), %rdi
callq 0xbe58
leaq -0x48(%rbp), %rdi
callq 0xbe58
jmp 0x301cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x301c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xbe58
leaq -0x48(%rbp), %rdi
callq 0xbe58
jmp 0x301dc
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xbcd0
nopw %cs:(%rax,%rax)
| _ZN7testing8internal18CmpHelperSTRCASEEQEPKcS2_S2_S2_:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov [rbp+var_88], rdi
mov rax, rdi
mov [rbp+var_80], rax
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 rdi, [rbp+var_20]; this
mov rsi, [rbp+var_28]; char *
call _ZN7testing8internal6String28CaseInsensitiveCStringEqualsEPKcS3_; testing::internal::String::CaseInsensitiveCStringEquals(char const*,char const*)
test al, 1
jnz short loc_30120
jmp short loc_30131
loc_30120:
mov rdi, [rbp+var_88]; this
call _ZN7testing16AssertionSuccessEv; testing::AssertionSuccess(void)
jmp loc_301CF
loc_30131:
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
mov rax, [rbp+var_18]
mov [rbp+var_90], rax
lea rdi, [rbp+var_48]
lea rsi, [rbp+var_20]
call _ZN7testing13PrintToStringIPKcEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<char const*>(char const* const&)
lea rdi, [rbp+var_68]
lea rsi, [rbp+var_28]
call _ZN7testing13PrintToStringIPKcEENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKT_; testing::PrintToString<char const*>(char const* const&)
jmp short $+2
loc_30163:
mov rdx, [rbp+var_90]
mov rsi, [rbp+var_98]
mov rdi, [rbp+var_88]
lea rcx, [rbp+var_48]
lea r8, [rbp+var_68]
mov r9d, 1
call _ZN7testing8internal9EqFailureEPKcS2_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESA_b; testing::internal::EqFailure(char const*,char const*,std::string const&,std::string const&,bool)
jmp short $+2
loc_3018D:
lea rdi, [rbp+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
lea rdi, [rbp+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_301CF
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
jmp short loc_301C4
mov rcx, rax
mov eax, edx
mov [rbp+var_70], rcx
mov [rbp+var_74], eax
lea rdi, [rbp+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_301C4:
lea rdi, [rbp+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
jmp short loc_301DC
loc_301CF:
mov rax, [rbp+var_80]
add rsp, 0A0h
pop rbp
retn
loc_301DC:
mov rdi, [rbp+var_70]
call __Unwind_Resume
| testing::internal * testing::internal::CmpHelperSTRCASEEQ(
testing::internal *this,
const char *a2,
const char *a3,
testing::internal::String *a4,
char *a5)
{
long long v6; // [rsp+8h] [rbp-98h]
long long v7; // [rsp+10h] [rbp-90h]
_BYTE v8[32]; // [rsp+38h] [rbp-68h] BYREF
_BYTE v9[32]; // [rsp+58h] [rbp-48h] BYREF
char *v10; // [rsp+78h] [rbp-28h] BYREF
testing::internal::String *v11; // [rsp+80h] [rbp-20h] BYREF
const char *v12; // [rsp+88h] [rbp-18h]
const char *v13; // [rsp+90h] [rbp-10h]
testing::internal *v14; // [rsp+98h] [rbp-8h]
v14 = this;
v13 = a2;
v12 = a3;
v11 = a4;
v10 = a5;
if ( (testing::internal::String::CaseInsensitiveCStringEquals(a4, a5, a3) & 1) != 0 )
{
testing::AssertionSuccess(this);
}
else
{
v6 = (long long)v13;
v7 = (long long)v12;
testing::PrintToString<char const*>(v9, &v11);
testing::PrintToString<char const*>(v8, &v10);
testing::internal::EqFailure(this, v6, v7, (long long)v9, (long long)v8, 1);
std::string::~string(v8);
std::string::~string(v9);
}
return this;
}
| CmpHelperSTRCASEEQ:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,RDI
MOV qword ptr [RBP + -0x80],RAX
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 RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x001301f0
TEST AL,0x1
JNZ 0x00130120
JMP 0x00130131
LAB_00130120:
MOV RDI,qword ptr [RBP + -0x88]
CALL 0x0011f090
JMP 0x001301cf
LAB_00130131:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x90],RAX
LEA RDI,[RBP + -0x48]
LEA RSI,[RBP + -0x20]
CALL 0x0014eda0
LAB_00130154:
LEA RDI,[RBP + -0x68]
LEA RSI,[RBP + -0x28]
CALL 0x0014eda0
JMP 0x00130163
LAB_00130163:
MOV RDX,qword ptr [RBP + -0x90]
MOV RSI,qword ptr [RBP + -0x98]
MOV RDI,qword ptr [RBP + -0x88]
LEA RCX,[RBP + -0x48]
LEA R8,[RBP + -0x68]
MOV R9D,0x1
CALL 0x0012f3c0
LAB_0013018b:
JMP 0x0013018d
LAB_0013018d:
LEA RDI,[RBP + -0x68]
CALL 0x0010be58
LEA RDI,[RBP + -0x48]
CALL 0x0010be58
JMP 0x001301cf
LAB_001301cf:
MOV RAX,qword ptr [RBP + -0x80]
ADD RSP,0xa0
POP RBP
RET
|
/* testing::internal::CmpHelperSTRCASEEQ(char const*, char const*, char const*, char const*) */
internal * __thiscall
testing::internal::CmpHelperSTRCASEEQ
(internal *this,char *param_1,char *param_2,char *param_3,char *param_4)
{
char *pcVar1;
char *pcVar2;
ulong uVar3;
testing local_70 [32];
testing local_50 [32];
char *local_30;
char *local_28;
char *local_20;
char *local_18;
internal *local_10;
local_30 = param_4;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_10 = this;
uVar3 = String::CaseInsensitiveCStringEquals(param_3,param_4);
pcVar2 = local_18;
pcVar1 = local_20;
if ((uVar3 & 1) == 0) {
PrintToString<char_const*>(local_50,&local_28);
/* try { // try from 00130154 to 00130160 has its CatchHandler @ 001301a1 */
PrintToString<char_const*>(local_70,&local_30);
/* try { // try from 00130163 to 0013018a has its CatchHandler @ 001301af */
EqFailure(this,pcVar2,pcVar1,(string *)local_50,(string *)local_70,true);
std::__cxx11::string::~string((string *)local_70);
std::__cxx11::string::~string((string *)local_50);
}
else {
AssertionSuccess((testing *)this);
}
return this;
}
| |
22,266 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>) | monkey531[P]llama/common/./json.hpp | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x817b4
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, %rsi
callq 0x7b2f4
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x81725
cmpq $0x0, 0x18(%r15)
jne 0x81817
cmpl $0x8, %eax
je 0x81746
cmpl $0x3, %eax
jne 0x8177c
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rax
movq (%rax), %rdi
addq $0x10, %rax
movl $0x20, %r15d
cmpq %rax, %rdi
je 0x81768
movq (%rax), %rsi
incq %rsi
jmp 0x81763
cmpl $0x1, %eax
je 0x8179d
cmpl $0x2, %eax
jne 0x81877
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x81d2e
movq %rax, 0x10(%rbx)
jmp 0x8178d
leaq 0x8(%r14), %r12
movq 0x8(%r14), %rax
movq (%rax), %rdi
movl $0x28, %r15d
testq %rdi, %rdi
je 0x81768
movq 0x10(%rax), %rsi
subq %rdi, %rsi
callq 0x1fae0
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1fae0
movq $0x0, (%r12)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x449aa
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
leaq 0x30(%rsi), %rdx
callq 0x819ae
movq %rax, 0x8(%rbx)
jmp 0x8178d
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcdca0(%rip), %rsi # 0x14f471
leaq 0xcdcbc(%rip), %rdx # 0x14f494
leaq 0x8(%rsp), %rdi
callq 0x4c588
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x7b4b8
xorl %ebp, %ebp
leaq 0x1275d5(%rip), %rsi # 0x1a8dd8
leaq -0x2776(%rip), %rdx # 0x7f094
movq %rbx, %rdi
callq 0x202e0
jmp 0x818d5
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcdc61(%rip), %rsi # 0x14f495
leaq 0xcdc6f(%rip), %rdx # 0x14f4aa
leaq 0x8(%rsp), %rdi
callq 0x4c588
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x7b4b8
xorl %ebp, %ebp
leaq 0x127572(%rip), %rsi # 0x1a8dd8
leaq -0x27d9(%rip), %rdx # 0x7f094
movq %rbx, %rdi
callq 0x202e0
jmp 0x818d5
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
movq %r14, %rdi
callq 0x578fc
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xcdc10(%rip), %rsi # 0x14f4ab
leaq 0x8(%rsp), %rdi
callq 0x81925
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x5ec72
xorl %ebp, %ebp
leaq 0x12708a(%rip), %rsi # 0x1a8950
leaq -0x2839(%rip), %rdx # 0x7f094
movq %rbx, %rdi
callq 0x202e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x818fb
jmp 0x81910
jmp 0x8190a
jmp 0x818ee
jmp 0x8190a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x81910
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1fae0
jmp 0x81910
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8191d
movq %rbx, %rdi
callq 0x1f7e0
movq %r14, %rdi
callq 0x20380
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; int
push r15; int
push r14; char
push r12; int
push rbx; __int64
sub rsp, 30h
mov r14, rsi
cmp [rdx], rsi
jnz loc_817B4
mov r15, rdx
mov rbx, rdi
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_81725
cmp qword ptr [r15+18h], 0
jnz loc_81817
cmp eax, 8
jz short loc_81746
cmp eax, 3
jnz short loc_8177C
lea r12, [r14+8]
mov rax, [r14+8]
mov rdi, [rax]
add rax, 10h
mov r15d, 20h ; ' '
cmp rdi, rax
jz short loc_81768
mov rsi, [rax]
inc rsi
jmp short loc_81763
loc_81725:
cmp eax, 1
jz short loc_8179D
cmp eax, 2
jnz loc_81877
mov rdi, [r14+8]
mov rsi, [r15+10h]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; 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>>::_M_erase(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_8178D
loc_81746:
lea r12, [r14+8]
mov rax, [r14+8]
mov rdi, [rax]; void *
mov r15d, 28h ; '('
test rdi, rdi
jz short loc_81768
mov rsi, [rax+10h]
sub rsi, rdi; unsigned __int64
loc_81763:
call __ZdlPvm; operator delete(void *,ulong)
loc_81768:
mov rdi, [r12]; void *
mov rsi, r15; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r12], 0
loc_8177C:
mov byte ptr [r14], 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)
loc_8178D:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_8179D:
mov rdi, [r14+8]
mov rsi, [r15+8]
lea rdx, [rsi+30h]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEESP_; 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>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>)
mov [rbx+8], rax
jmp short loc_8178D
loc_817B4:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_818D5
loc_81817:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_818D5
loc_81877:
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+58h+var_30]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 133h; 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
loc_818D5:
mov r14, rax
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_818FB
jmp short loc_81910
jmp short loc_8190A
jmp short loc_818EE
jmp short loc_8190A
loc_818EE:
mov r14, rax
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r15
jz short loc_81910
loc_818FB:
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_81910
loc_8190A:
mov r14, rax
mov bpl, 1
loc_81910:
test bpl, bpl
jz short loc_8191D
mov rdi, rbx; void *
call ___cxa_free_exception
loc_8191D:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_(
long long a1,
unsigned __int8 *a2,
unsigned __int8 **a3)
{
int v6; // eax
void **v7; // r12
void **v8; // rax
_QWORD *v9; // rdi
_QWORD *v10; // rax
unsigned long long v11; // r15
unsigned long long v12; // rsi
long long v13; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v16; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v17; // rbx
void *v18[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v19[8]; // [rsp+18h] [rbp-40h] BYREF
if ( *a3 != a2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v18[0] = v19;
std::string::_M_construct<char const*>(v18, "iterator does not fit current value", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
202,
v18);
__cxa_throw(
exception,
(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);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::end(
a1,
a2);
v6 = *a2;
if ( (unsigned int)(v6 - 3) < 6 )
{
if ( a3[3] )
{
v16 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v18[0] = v19;
std::string::_M_construct<char const*>(v18, "iterator out of range", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v16,
205,
v18);
__cxa_throw(
v16,
(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 ( v6 == 8 )
{
v7 = (void **)(a2 + 8);
v13 = *((_QWORD *)a2 + 1);
v9 = *(_QWORD **)v13;
v11 = 40LL;
if ( *(_QWORD *)v13 )
{
v12 = *(_QWORD *)(v13 + 16) - (_QWORD)v9;
goto LABEL_13;
}
}
else
{
if ( v6 != 3 )
{
LABEL_15:
*a2 = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a2);
return a1;
}
v7 = (void **)(a2 + 8);
v8 = (void **)*((_QWORD *)a2 + 1);
v9 = *v8;
v10 = v8 + 2;
v11 = 32LL;
if ( v9 != v10 )
{
v12 = *v10 + 1LL;
LABEL_13:
operator delete(v9, v12);
}
}
operator delete(*v7, v11);
*v7 = 0LL;
goto LABEL_15;
}
if ( v6 == 1 )
{
*(_QWORD *)(a1 + 8) = 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>>>>::erase(
*((_QWORD *)a2 + 1),
a3[1],
a3[1] + 48);
}
else
{
if ( v6 != 2 )
{
v17 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v19[2] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(
v18,
"cannot use erase() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v17,
307,
v18);
__cxa_throw(
v17,
(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);
}
*(_QWORD *)(a1 + 16) = 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>>::_M_erase(
*((_QWORD *)a2 + 1),
a3[2]);
}
return a1;
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x001817b4
MOV R15,RDX
MOV RBX,RDI
MOV RSI,R14
CALL 0x0017b2f4
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x00181725
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x00181817
CMP EAX,0x8
JZ 0x00181746
CMP EAX,0x3
JNZ 0x0018177c
LEA R12,[R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RAX]
ADD RAX,0x10
MOV R15D,0x20
CMP RDI,RAX
JZ 0x00181768
MOV RSI,qword ptr [RAX]
INC RSI
JMP 0x00181763
LAB_00181725:
CMP EAX,0x1
JZ 0x0018179d
CMP EAX,0x2
JNZ 0x00181877
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x00181d2e
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0018178d
LAB_00181746:
LEA R12,[R14 + 0x8]
MOV RAX,qword ptr [R14 + 0x8]
MOV RDI,qword ptr [RAX]
MOV R15D,0x28
TEST RDI,RDI
JZ 0x00181768
MOV RSI,qword ptr [RAX + 0x10]
SUB RSI,RDI
LAB_00181763:
CALL 0x0011fae0
LAB_00181768:
MOV RDI,qword ptr [R12]
MOV RSI,R15
CALL 0x0011fae0
MOV qword ptr [R12],0x0
LAB_0018177c:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001449aa
LAB_0018178d:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0018179d:
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x8]
LEA RDX,[RSI + 0x30]
CALL 0x001819ae
MOV qword ptr [RBX + 0x8],RAX
JMP 0x0018178d
LAB_001817b4:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_001817ca:
LEA RSI,[0x24f471]
LEA RDX,[0x24f494]
LEA RDI,[RSP + 0x8]
CALL 0x0014c588
MOV BPL,0x1
LAB_001817e5:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x0017b4b8
XOR EBP,EBP
LEA RSI,[0x2a8dd8]
LEA RDX,[0x17f094]
MOV RDI,RBX
CALL 0x001202e0
LAB_00181817:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0018182d:
LEA RSI,[0x24f495]
LEA RDX,[0x24f4aa]
LEA RDI,[RSP + 0x8]
CALL 0x0014c588
MOV BPL,0x1
LAB_00181848:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x0017b4b8
XOR EBP,EBP
LEA RSI,[0x2a8dd8]
LEA RDX,[0x17f094]
MOV RDI,RBX
CALL 0x001202e0
LAB_00181877:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
MOV RDI,R14
CALL 0x001578fc
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_00181894:
LEA RSI,[0x24f4ab]
LEA RDI,[RSP + 0x8]
CALL 0x00181925
MOV BPL,0x1
LAB_001818a8:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x0015ec72
XOR EBP,EBP
LEA RSI,[0x2a8950]
LEA RDX,[0x17f094]
MOV RDI,RBX
CALL 0x001202e0
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(long 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>
*param_2,long *param_3)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
long *plVar2;
int8 uVar3;
ulong uVar4;
long *plVar5;
ulong uVar6;
int1 *local_50 [2];
int1 local_40 [16];
char *local_30;
if ((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3 != param_2) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 001817ca to 001817e1 has its CatchHandler @ 0018190a */
std::__cxx11::string::_M_construct<char_const*>
(local_50,"iterator does not fit current value","");
/* try { // try from 001817e5 to 00181811 has its CatchHandler @ 001818ee */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xca,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end();
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
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) {
uVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::erase(*(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>>>>
**)(param_2 + 8),param_3[1],param_3[1] + 0x30);
*(int8 *)(param_1 + 8) = uVar3;
return param_1;
}
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>
)0x2) {
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>>>
::_M_erase(*(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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar3;
return param_1;
}
uVar3 = __cxa_allocate_exception(0x20);
local_30 = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_2);
/* try { // try from 00181894 to 001818a4 has its CatchHandler @ 001818e8 */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_50,"cannot use erase() with ",&local_30);
/* try { // try from 001818a8 to 001818d4 has its CatchHandler @ 001818d5 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0x133,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (param_3[3] != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 0018182d to 00181844 has its CatchHandler @ 001818ec */
std::__cxx11::string::_M_construct<char_const*>(local_50,"iterator out of range","");
/* try { // try from 00181848 to 00181874 has its CatchHandler @ 001818ea */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xcd,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
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>
)0x8) {
plVar5 = (long *)**(long **)(param_2 + 8);
uVar6 = 0x28;
if (plVar5 != (long *)0x0) {
uVar4 = (*(long **)(param_2 + 8))[2] - (long)plVar5;
LAB_00181763:
operator_delete(plVar5,uVar4);
}
}
else {
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>
)0x3) goto LAB_0018177c;
plVar5 = (long *)**(long **)(param_2 + 8);
plVar2 = *(long **)(param_2 + 8) + 2;
uVar6 = 0x20;
if (plVar5 != plVar2) {
uVar4 = *plVar2 + 1;
goto LAB_00181763;
}
}
operator_delete(*(void **)(param_2 + 8),uVar6);
*(int8 *)(param_2 + 8) = 0;
LAB_0018177c:
*param_2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| |
22,267 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>) | monkey531[P]llama/common/./json.hpp | IteratorType erase(IteratorType pos)
{
// make sure iterator fits the current value
if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
{
JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value", this));
}
IteratorType result = end();
switch (m_data.m_type)
{
case value_t::boolean:
case value_t::number_float:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::string:
case value_t::binary:
{
if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
{
JSON_THROW(invalid_iterator::create(205, "iterator out of range", this));
}
if (is_string())
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.string, 1);
m_data.m_value.string = nullptr;
}
else if (is_binary())
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, m_data.m_value.binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_data.m_value.binary, 1);
m_data.m_value.binary = nullptr;
}
m_data.m_type = value_t::null;
assert_invariant();
break;
}
case value_t::object:
{
result.m_it.object_iterator = m_data.m_value.object->erase(pos.m_it.object_iterator);
break;
}
case value_t::array:
{
result.m_it.array_iterator = m_data.m_value.array->erase(pos.m_it.array_iterator);
break;
}
case value_t::null:
case value_t::discarded:
default:
JSON_THROW(type_error::create(307, detail::concat("cannot use erase() with ", type_name()), this));
}
return result;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>> nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::erase<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, 0>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
cmpq %rsi, (%rdx)
jne 0x7f68b
movq %rdx, %r15
movq %rdi, %rbx
movq %r14, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x18(%rdi)
callq 0x7950e
movzbl (%r14), %eax
leal -0x3(%rax), %ecx
cmpl $0x6, %ecx
jae 0x7f5f8
cmpq $0x0, 0x18(%r15)
jne 0x7f6ee
cmpl $0x8, %eax
je 0x7f619
cmpl $0x3, %eax
jne 0x7f64c
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x7f5f1
movq (%rcx), %rsi
incq %rsi
movq %rax, %rdi
callq 0x1fae0
movq (%r15), %rdi
movl $0x20, %esi
jmp 0x7f640
cmpl $0x1, %eax
je 0x7f66d
cmpl $0x2, %eax
jne 0x7f74e
movq 0x8(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x7fc14
movq %rax, 0x10(%rbx)
jmp 0x7f65d
leaq 0x8(%r14), %r15
movq 0x8(%r14), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x7f63b
movq 0x10(%rdi), %rsi
subq %rax, %rsi
movq %rax, %rdi
callq 0x1fae0
movq (%r15), %rdi
movl $0x28, %esi
callq 0x1fae0
movq $0x0, (%r15)
movb $0x0, (%r14)
movq %r14, %rdi
movl $0x1, %esi
callq 0x438fc
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r12
addq $0x8, %r12
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
leaq 0x30(%rsi), %rdx
callq 0x7f882
movq %rax, (%r12)
jmp 0x7f65d
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc9d1e(%rip), %rsi # 0x1493c6
leaq 0xc9d3a(%rip), %rdx # 0x1493e9
leaq 0x8(%rsp), %rdi
callq 0x4b514
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xca, %esi
movq %r14, %rcx
callq 0x7967c
xorl %ebp, %ebp
leaq 0x12373e(%rip), %rsi # 0x1a2e18
leaq -0x2723(%rip), %rdx # 0x7cfbe
movq %rbx, %rdi
callq 0x202e0
jmp 0x7f7ac
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xc9cdf(%rip), %rsi # 0x1493ea
leaq 0xc9ced(%rip), %rdx # 0x1493ff
leaq 0x8(%rsp), %rdi
callq 0x4b514
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0xcd, %esi
movq %r14, %rcx
callq 0x7967c
xorl %ebp, %ebp
leaq 0x1236db(%rip), %rsi # 0x1a2e18
leaq -0x2786(%rip), %rdx # 0x7cfbe
movq %rbx, %rdi
callq 0x202e0
jmp 0x7f7ac
movl $0x20, %edi
callq 0x1f550
movq %rax, %rbx
movq %r14, %rdi
callq 0x568fa
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xc9c8e(%rip), %rsi # 0x149400
leaq 0x8(%rsp), %rdi
callq 0x7f7f9
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x133, %esi # imm = 0x133
movq %r14, %rcx
callq 0x5d8b8
xorl %ebp, %ebp
leaq 0x123213(%rip), %rsi # 0x1a29b0
leaq -0x27e6(%rip), %rdx # 0x7cfbe
movq %rbx, %rdi
callq 0x202e0
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x7f7d2
jmp 0x7f7df
jmp 0x7f7e6
jmp 0x7f7c5
jmp 0x7f7e6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f7df
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1fae0
testb %bpl, %bpl
jne 0x7f7e9
jmp 0x7f7f1
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f7e0
movq %r14, %rdi
callq 0x20380
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
push rbp; int
push r15; int
push r14; char
push r12; int
push rbx; __int64
sub rsp, 30h
mov r14, rsi
cmp [rdx], rsi
jnz loc_7F68B
mov r15, rdx
mov rbx, rdi
mov [rdi], r14
xorps xmm0, xmm0
movups xmmword ptr [rdi+8], xmm0
mov rax, 8000000000000000h
mov [rdi+18h], rax
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE7set_endEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::set_end(void)
movzx eax, byte ptr [r14]
lea ecx, [rax-3]
cmp ecx, 6
jnb short loc_7F5F8
cmp qword ptr [r15+18h], 0
jnz loc_7F6EE
cmp eax, 8
jz short loc_7F619
cmp eax, 3
jnz loc_7F64C
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
lea rcx, [rdi+10h]
cmp rax, rcx
jz short loc_7F5F1
mov rsi, [rcx]
inc rsi; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]
loc_7F5F1:
mov esi, 20h ; ' '
jmp short loc_7F640
loc_7F5F8:
cmp eax, 1
jz short loc_7F66D
cmp eax, 2
jnz loc_7F74E
mov rdi, [r14+8]
mov rsi, [r15+10h]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE8_M_eraseEN9__gnu_cxx17__normal_iteratorIPSD_SF_EE; 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>>::_M_erase(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>)
mov [rbx+10h], rax
jmp short loc_7F65D
loc_7F619:
lea r15, [r14+8]
mov rdi, [r14+8]
mov rax, [rdi]
test rax, rax
jz short loc_7F63B
mov rsi, [rdi+10h]
sub rsi, rax; unsigned __int64
mov rdi, rax; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, [r15]; void *
loc_7F63B:
mov esi, 28h ; '('; unsigned __int64
loc_7F640:
call __ZdlPvm; operator delete(void *,ulong)
mov qword ptr [r15], 0
loc_7F64C:
mov byte ptr [r14], 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)
loc_7F65D:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_7F66D:
mov r12, rbx
add r12, 8
mov rdi, [r14+8]
mov rsi, [r15+8]
lea rdx, [rsi+30h]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE5eraseEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEESP_; 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>>>>::erase(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>)
mov [r12], rax
jmp short loc_7F65D
loc_7F68B:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorDoesNo; "iterator does not fit current value"
lea rdx, aIteratorDoesNo+23h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CAh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp loc_7F7AC
loc_7F6EE:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r15, [rsp+58h+var_40]
mov [r15-10h], r15
lea rsi, aIteratorOutOfR; "iterator out of range"
lea rdx, aIteratorOutOfR+15h; ""
lea rdi, [rsp+58h+var_50]
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
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 0CDh; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail16invalid_iteratorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_7F7AC
loc_7F74E:
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+58h+var_30]
mov [rdx], rax
lea rsi, aCannotUseErase; "cannot use erase() with "
lea rdi, [rsp+58h+var_50]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA25_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(char const(&)[25],char const* &&)
mov bpl, 1
lea rdx, [rsp+58h+var_50]
mov rdi, rbx; this
mov esi, 133h; 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
loc_7F7AC:
mov r14, rax
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]
cmp rdi, rax
jnz short loc_7F7D2
jmp short loc_7F7DF
jmp short loc_7F7E6
jmp short loc_7F7C5
jmp short loc_7F7E6
loc_7F7C5:
mov r14, rax
mov rdi, [rsp+58h+var_50]; void *
cmp rdi, r15
jz short loc_7F7DF
loc_7F7D2:
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7F7DF:
test bpl, bpl
jnz short loc_7F7E9
jmp short loc_7F7F1
loc_7F7E6:
mov r14, rax
loc_7F7E9:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7F7F1:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_(
long long a1,
unsigned __int8 *a2,
unsigned __int8 **a3)
{
int v6; // eax
long long *v7; // r15
long long v8; // rdi
unsigned long long v9; // rsi
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v12; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v13; // rbx
void *v14[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v15[8]; // [rsp+18h] [rbp-40h] BYREF
if ( *a3 != a2 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v14[0] = v15;
std::string::_M_construct<char const*>((long long)v14, "iterator does not fit current value", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
202,
v14);
__cxa_throw(
exception,
(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);
}
*(_QWORD *)a1 = a2;
*(_OWORD *)(a1 + 8) = 0LL;
*(_QWORD *)(a1 + 24) = 0x8000000000000000LL;
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::set_end((unsigned __int8 **)a1);
v6 = *a2;
if ( (unsigned int)(v6 - 3) < 6 )
{
if ( a3[3] )
{
v12 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v14[0] = v15;
std::string::_M_construct<char const*>((long long)v14, "iterator out of range", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v12,
205,
v14);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::invalid_iterator,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if ( v6 == 8 )
{
v7 = (long long *)(a2 + 8);
v8 = *((_QWORD *)a2 + 1);
if ( *(_QWORD *)v8 )
{
operator delete(*(void **)v8, *(_QWORD *)(v8 + 16) - *(_QWORD *)v8);
v8 = *v7;
}
v9 = 40LL;
}
else
{
if ( v6 != 3 )
{
LABEL_16:
*a2 = 0;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant((char *)a2);
return a1;
}
v7 = (long long *)(a2 + 8);
v8 = *((_QWORD *)a2 + 1);
if ( *(_QWORD *)v8 != v8 + 16 )
{
operator delete(*(void **)v8, *(_QWORD *)(v8 + 16) + 1LL);
v8 = *v7;
}
v9 = 32LL;
}
operator delete((void *)v8, v9);
*v7 = 0LL;
goto LABEL_16;
}
if ( v6 == 1 )
{
*(_QWORD *)(a1 + 8) = 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>>>>::erase(
*((_QWORD *)a2 + 1),
a3[1],
a3[1] + 48);
}
else
{
if ( v6 != 2 )
{
v13 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v15[2] = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name(a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[25],char const*>(
v14,
"cannot use erase() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v13,
307,
v14);
__cxa_throw(
v13,
(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);
}
*(_QWORD *)(a1 + 16) = 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>>::_M_erase(
*((_QWORD *)a2 + 1),
a3[2]);
}
return a1;
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
CMP qword ptr [RDX],RSI
JNZ 0x0017f68b
MOV R15,RDX
MOV RBX,RDI
MOV qword ptr [RDI],R14
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x8],XMM0
MOV RAX,-0x8000000000000000
MOV qword ptr [RDI + 0x18],RAX
CALL 0x0017950e
MOVZX EAX,byte ptr [R14]
LEA ECX,[RAX + -0x3]
CMP ECX,0x6
JNC 0x0017f5f8
CMP qword ptr [R15 + 0x18],0x0
JNZ 0x0017f6ee
CMP EAX,0x8
JZ 0x0017f619
CMP EAX,0x3
JNZ 0x0017f64c
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
LEA RCX,[RDI + 0x10]
CMP RAX,RCX
JZ 0x0017f5f1
MOV RSI,qword ptr [RCX]
INC RSI
MOV RDI,RAX
CALL 0x0011fae0
MOV RDI,qword ptr [R15]
LAB_0017f5f1:
MOV ESI,0x20
JMP 0x0017f640
LAB_0017f5f8:
CMP EAX,0x1
JZ 0x0017f66d
CMP EAX,0x2
JNZ 0x0017f74e
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x10]
CALL 0x0017fc14
MOV qword ptr [RBX + 0x10],RAX
JMP 0x0017f65d
LAB_0017f619:
LEA R15,[R14 + 0x8]
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0017f63b
MOV RSI,qword ptr [RDI + 0x10]
SUB RSI,RAX
MOV RDI,RAX
CALL 0x0011fae0
MOV RDI,qword ptr [R15]
LAB_0017f63b:
MOV ESI,0x28
LAB_0017f640:
CALL 0x0011fae0
MOV qword ptr [R15],0x0
LAB_0017f64c:
MOV byte ptr [R14],0x0
MOV RDI,R14
MOV ESI,0x1
CALL 0x001438fc
LAB_0017f65d:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_0017f66d:
MOV R12,RBX
ADD R12,0x8
MOV RDI,qword ptr [R14 + 0x8]
MOV RSI,qword ptr [R15 + 0x8]
LEA RDX,[RSI + 0x30]
CALL 0x0017f882
MOV qword ptr [R12],RAX
JMP 0x0017f65d
LAB_0017f68b:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0017f6a1:
LEA RSI,[0x2493c6]
LEA RDX,[0x2493e9]
LEA RDI,[RSP + 0x8]
CALL 0x0014b514
MOV BPL,0x1
LAB_0017f6bc:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xca
MOV RCX,R14
CALL 0x0017967c
XOR EBP,EBP
LEA RSI,[0x2a2e18]
LEA RDX,[0x17cfbe]
MOV RDI,RBX
CALL 0x001202e0
LAB_0017f6ee:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
LEA R15,[RSP + 0x18]
MOV qword ptr [R15 + -0x10],R15
LAB_0017f704:
LEA RSI,[0x2493ea]
LEA RDX,[0x2493ff]
LEA RDI,[RSP + 0x8]
CALL 0x0014b514
MOV BPL,0x1
LAB_0017f71f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0xcd
MOV RCX,R14
CALL 0x0017967c
XOR EBP,EBP
LEA RSI,[0x2a2e18]
LEA RDX,[0x17cfbe]
MOV RDI,RBX
CALL 0x001202e0
LAB_0017f74e:
MOV EDI,0x20
CALL 0x0011f550
MOV RBX,RAX
MOV RDI,R14
CALL 0x001568fa
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0017f76b:
LEA RSI,[0x249400]
LEA RDI,[RSP + 0x8]
CALL 0x0017f7f9
MOV BPL,0x1
LAB_0017f77f:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x133
MOV RCX,R14
CALL 0x0015d8b8
XOR EBP,EBP
LEA RSI,[0x2a29b0]
LEA RDX,[0x17cfbe]
MOV RDI,RBX
CALL 0x001202e0
|
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*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>
*param_2,long *param_3)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
void *pvVar2;
int8 uVar3;
ulong uVar4;
int8 *puVar5;
int1 *local_50 [2];
int1 local_40 [16];
char *local_30;
if ((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*param_3 != param_2) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 0017f6a1 to 0017f6b8 has its CatchHandler @ 0017f7e6 */
std::__cxx11::string::_M_construct<char_const*>
(local_50,"iterator does not fit current value","");
/* try { // try from 0017f6bc to 0017f6e8 has its CatchHandler @ 0017f7c5 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xca,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
*(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
**)param_1 = param_2;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0x8000000000000000;
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::set_end(param_1);
bVar1 = *param_2;
if (5 < (byte)bVar1 - 3) {
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) {
uVar3 = nlohmann::json_abi_v3_11_3::
ordered_map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::erase(*(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>>>>
**)(param_2 + 8),param_3[1],param_3[1] + 0x30);
*(int8 *)(param_1 + 8) = uVar3;
return param_1;
}
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>
)0x2) {
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>>>
::_M_erase(*(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>>>
**)(param_2 + 8),param_3[2]);
*(int8 *)(param_1 + 0x10) = uVar3;
return param_1;
}
uVar3 = __cxa_allocate_exception(0x20);
local_30 = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_2);
/* try { // try from 0017f76b to 0017f77b has its CatchHandler @ 0017f7bf */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[25],char_const*>
((detail *)local_50,"cannot use erase() with ",&local_30);
/* try { // try from 0017f77f to 0017f7ab has its CatchHandler @ 0017f7ac */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0x133,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
if (param_3[3] != 0) {
uVar3 = __cxa_allocate_exception(0x20);
local_50[0] = local_40;
/* try { // try from 0017f704 to 0017f71b has its CatchHandler @ 0017f7c3 */
std::__cxx11::string::_M_construct<char_const*>(local_50,"iterator out of range","");
/* try { // try from 0017f71f to 0017f74b has its CatchHandler @ 0017f7c1 */
_ZN8nlohmann16json_abi_v3_11_36detail16invalid_iterator6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar3,0xcd,local_50,param_2);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar3,&nlohmann::json_abi_v3_11_3::detail::invalid_iterator::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
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>
)0x8) {
puVar5 = *(int8 **)(param_2 + 8);
pvVar2 = (void *)*puVar5;
if (pvVar2 != (void *)0x0) {
operator_delete(pvVar2,puVar5[2] - (long)pvVar2);
puVar5 = *(int8 **)(param_2 + 8);
}
uVar4 = 0x28;
}
else {
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>
)0x3) goto LAB_0017f64c;
puVar5 = *(int8 **)(param_2 + 8);
if ((long *)*puVar5 != puVar5 + 2) {
operator_delete((long *)*puVar5,puVar5[2] + 1);
puVar5 = *(int8 **)(param_2 + 8);
}
uVar4 = 0x20;
}
operator_delete(puVar5,uVar4);
*(int8 *)(param_2 + 8) = 0;
LAB_0017f64c:
*param_2 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_2,0));
return param_1;
}
| |
22,268 | js_json_check | bluesky950520[P]quickjs/quickjs.c | static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
JSValue holder, JSValue val, JSValue key)
{
JSValue v;
JSValue args[2];
if (JS_IsObject(val) || JS_IsBigInt(ctx, val)) {
JSValue f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
if (JS_IsException(f))
goto exception;
if (JS_IsFunction(ctx, f)) {
v = JS_CallFree(ctx, f, val, 1, &key);
JS_FreeValue(ctx, val);
val = v;
if (JS_IsException(val))
goto exception;
} else {
JS_FreeValue(ctx, f);
}
}
if (!JS_IsUndefined(jsc->replacer_func)) {
args[0] = key;
args[1] = val;
v = JS_Call(ctx, jsc->replacer_func, holder, 2, args);
JS_FreeValue(ctx, val);
val = v;
if (JS_IsException(val))
goto exception;
}
switch (JS_VALUE_GET_NORM_TAG(val)) {
case JS_TAG_OBJECT:
if (JS_IsFunction(ctx, val))
break;
case JS_TAG_STRING:
case JS_TAG_INT:
case JS_TAG_FLOAT64:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_BIG_INT:
case JS_TAG_EXCEPTION:
return val;
default:
break;
}
JS_FreeValue(ctx, val);
return JS_UNDEFINED;
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O1 | c | js_json_check:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rbp
movq %rdi, %r15
movl %ebx, %eax
orl $0x8, %eax
cmpl $-0x1, %eax
jne 0x33db3
movq %rcx, 0x20(%rsp)
movq %r8, 0x28(%rsp)
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x91, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x2238f
movq %rdx, %r12
cmpl $0x6, %r12d
jne 0x33d31
xorl %eax, %eax
jmp 0x33da1
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x221aa
testl %eax, %eax
je 0x33d90
leaq 0xa0(%rsp), %rax
movq %rax, (%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl $0x1, %r9d
callq 0x22089
movq %rax, %r12
movq %rdx, %r13
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
cmpl $0x6, %r13d
setne %al
movq %r12, %r14
movq %r13, %rbx
jmp 0x33da1
movq 0x18(%r15), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1ccb2
movb $0x1, %al
testb %al, %al
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %rcx
je 0x33e35
movq 0x8(%rbp), %rdx
cmpl $0x3, %edx
je 0x33e4f
leaq 0xa0(%rsp), %rax
movups (%rax), %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq (%rbp), %rsi
movl $0x0, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %r15, %rdi
movl $0x2, %r9d
callq 0x278b6
movq %rax, %r12
movq %rdx, %r13
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movq %r12, %r14
movq %r13, %rbx
cmpl $0x6, %r13d
jne 0x33e4f
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movl $0x6, %ebx
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x33e71
leal 0x9(%rbx), %eax
cmpl $0x10, %eax
ja 0x33e9d
movl $0x18e05, %ecx # imm = 0x18E05
btl %eax, %ecx
jae 0x33e86
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %r14, %rcx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x8, %eax
jne 0x33e9d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x221aa
testl %eax, %eax
je 0x33e61
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ccb2
movl $0x3, %ebx
jmp 0x33e49
| js_json_check:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov rbx, r9
mov r14, r8
mov r8, rcx
mov rcx, rdx
mov rbp, rsi
mov r15, rdi
mov eax, ebx
or eax, 8
cmp eax, 0FFFFFFFFh
jnz loc_33DB3
mov [rsp+98h+var_78], rcx
mov [rsp+98h+var_70], r8
mov dword ptr [rsp+98h+var_98+8], 0
mov qword ptr [rsp+98h+var_98], 0
mov rdi, r15
mov rsi, r14
mov rdx, rbx
mov ecx, 91h
mov r8, r14
mov r9, rbx
call JS_GetPropertyInternal2
mov r12, rdx
cmp r12d, 6
jnz short loc_33D31
xor eax, eax
jmp short loc_33DA1
loc_33D31:
mov r13, rax
mov rdi, r15
mov rsi, rax
mov rdx, r12
call JS_IsFunction
test eax, eax
jz short loc_33D90
lea rax, [rsp+98h+arg_0]
mov qword ptr [rsp+98h+var_98], rax
mov rdi, r15
mov rsi, r13
mov rdx, r12
mov rcx, r14
mov r8, rbx
mov r9d, 1
call JS_CallFree
mov r12, rax
mov r13, rdx
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
cmp r13d, 6
setnz al
mov r14, r12
mov rbx, r13
jmp short loc_33DA1
loc_33D90:
mov rdi, [r15+18h]
mov rsi, r13
mov rdx, r12
call JS_FreeValueRT
mov al, 1
loc_33DA1:
test al, al
mov r8, [rsp+98h+var_70]
mov rcx, [rsp+98h+var_78]
jz loc_33E35
loc_33DB3:
mov rdx, [rbp+8]
cmp edx, 3
jz loc_33E4F
lea rax, [rsp+98h+arg_0]
movups xmm0, xmmword ptr [rax]
lea rax, [rsp+98h+var_58]
movaps xmmword ptr [rax], xmm0
mov [rax+10h], r14
mov [rax+18h], rbx
mov rsi, [rbp+0]
mov dword ptr [rsp+98h+var_68], 0
mov qword ptr [rsp+98h+var_68+8], 3
movups xmm0, [rsp+98h+var_68]
movups [rsp+98h+var_98], xmm0
mov [rsp+98h+var_88], rax
mov [rsp+98h+var_80], 2
mov rdi, r15
mov r9d, 2
call JS_CallInternal
mov r12, rax
mov r13, rdx
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov r14, r12
mov rbx, r13
cmp r13d, 6
jnz short loc_33E4F
loc_33E35:
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 6
loc_33E49:
xor eax, eax
xor ecx, ecx
jmp short loc_33E71
loc_33E4F:
lea eax, [rbx+9]
cmp eax, 10h
ja short loc_33E9D
mov ecx, 18E05h
bt ecx, eax
jnb short loc_33E86
loc_33E61:
mov rcx, 0FFFFFFFF00000000h
and rcx, r14
mov eax, r14d
loc_33E71:
or rax, rcx
mov rdx, rbx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_33E86:
cmp eax, 8
jnz short loc_33E9D
mov rdi, r15
mov rsi, r14
mov rdx, rbx
call JS_IsFunction
test eax, eax
jz short loc_33E61
loc_33E9D:
mov rdi, [r15+18h]
mov rsi, r14
mov rdx, rbx
call JS_FreeValueRT
mov ebx, 3
jmp short loc_33E49
| unsigned long long js_json_check(
long long a1,
long long *a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
__int128 a15)
{
long long v15; // rbx
long long v18; // rcx
unsigned long long PropertyInternal2; // rax
long long v20; // rdx
long long v21; // r12
bool v22; // al
_DWORD *v23; // r13
long long v24; // r12
long long v25; // rdx
long long v26; // r13
long long v27; // rdx
unsigned long long v28; // r12
long long v29; // rdx
long long v30; // r13
long long v31; // rax
unsigned long long v32; // rcx
int v33; // ecx
long long v36; // [rsp+28h] [rbp-70h]
__m128 v37; // [rsp+30h] [rbp-68h]
__int128 v38; // [rsp+40h] [rbp-58h] BYREF
long long v39; // [rsp+50h] [rbp-48h]
long long v40; // [rsp+58h] [rbp-40h]
v15 = a6;
v18 = a3;
if ( ((unsigned int)a6 | 8) == 0xFFFFFFFF )
{
v36 = a4;
PropertyInternal2 = JS_GetPropertyInternal2(a1, a5, a6, 0x91u, a5, a6, 0LL, 0);
v21 = v20;
if ( (_DWORD)v20 == 6 )
{
v22 = 0;
}
else
{
v23 = (_DWORD *)PropertyInternal2;
if ( (unsigned int)JS_IsFunction(a1, PropertyInternal2, v20) )
{
v24 = JS_CallFree(a1, v23, v21, a5, v15, 1, (long long)&a15);
v26 = v25;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)a5, v15);
v22 = (_DWORD)v26 != 6;
a5 = v24;
v15 = v26;
}
else
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v23, v21);
v22 = 1;
}
}
a4 = v36;
v18 = a3;
if ( !v22 )
goto LABEL_10;
}
v27 = a2[1];
if ( (_DWORD)v27 != 3 )
{
v38 = a15;
v39 = a5;
v40 = v15;
v37.m128_i32[0] = 0;
v37.m128_u64[1] = 3LL;
v28 = JS_CallInternal(
a1,
*a2,
v27,
v18,
a4,
2LL,
v37,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v37.m128_i8[0],
3,
(long long)&v38,
2u);
v30 = v29;
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)a5, v15);
a5 = v28;
v15 = v30;
if ( (_DWORD)v30 == 6 )
goto LABEL_10;
}
if ( (unsigned int)(v15 + 9) <= 0x10
&& ((v33 = 101893, _bittest(&v33, v15 + 9)) || (_DWORD)v15 == -1 && !(unsigned int)JS_IsFunction(a1, a5, -1)) )
{
v32 = a5 & 0xFFFFFFFF00000000LL;
v31 = (unsigned int)a5;
}
else
{
LABEL_10:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), (_DWORD *)a5, v15);
v31 = 0LL;
v32 = 0LL;
}
return v32 | v31;
}
| js_json_check:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV RBX,R9
MOV R14,R8
MOV R8,RCX
MOV RCX,RDX
MOV RBP,RSI
MOV R15,RDI
MOV EAX,EBX
OR EAX,0x8
CMP EAX,-0x1
JNZ 0x00133db3
MOV qword ptr [RSP + 0x20],RCX
MOV qword ptr [RSP + 0x28],R8
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
MOV ECX,0x91
MOV R8,R14
MOV R9,RBX
CALL 0x0012238f
MOV R12,RDX
CMP R12D,0x6
JNZ 0x00133d31
XOR EAX,EAX
JMP 0x00133da1
LAB_00133d31:
MOV R13,RAX
MOV RDI,R15
MOV RSI,RAX
MOV RDX,R12
CALL 0x001221aa
TEST EAX,EAX
JZ 0x00133d90
LEA RAX,[RSP + 0xa0]
MOV qword ptr [RSP],RAX
MOV RDI,R15
MOV RSI,R13
MOV RDX,R12
MOV RCX,R14
MOV R8,RBX
MOV R9D,0x1
CALL 0x00122089
MOV R12,RAX
MOV R13,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
CMP R13D,0x6
SETNZ AL
MOV R14,R12
MOV RBX,R13
JMP 0x00133da1
LAB_00133d90:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R13
MOV RDX,R12
CALL 0x0011ccb2
MOV AL,0x1
LAB_00133da1:
TEST AL,AL
MOV R8,qword ptr [RSP + 0x28]
MOV RCX,qword ptr [RSP + 0x20]
JZ 0x00133e35
LAB_00133db3:
MOV RDX,qword ptr [RBP + 0x8]
CMP EDX,0x3
JZ 0x00133e4f
LEA RAX,[RSP + 0xa0]
MOVUPS XMM0,xmmword ptr [RAX]
LEA RAX,[RSP + 0x40]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],R14
MOV qword ptr [RAX + 0x18],RBX
MOV RSI,qword ptr [RBP]
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,R15
MOV R9D,0x2
CALL 0x001278b6
MOV R12,RAX
MOV R13,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
MOV R14,R12
MOV RBX,R13
CMP R13D,0x6
JNZ 0x00133e4f
LAB_00133e35:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
MOV EBX,0x6
LAB_00133e49:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00133e71
LAB_00133e4f:
LEA EAX,[RBX + 0x9]
CMP EAX,0x10
JA 0x00133e9d
MOV ECX,0x18e05
BT ECX,EAX
JNC 0x00133e86
LAB_00133e61:
MOV RCX,-0x100000000
AND RCX,R14
MOV EAX,R14D
LAB_00133e71:
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00133e86:
CMP EAX,0x8
JNZ 0x00133e9d
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
CALL 0x001221aa
TEST EAX,EAX
JZ 0x00133e61
LAB_00133e9d:
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,R14
MOV RDX,RBX
CALL 0x0011ccb2
MOV EBX,0x3
JMP 0x00133e49
|
int1 [16]
js_json_check(long param_1,int8 *param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8)
{
int1 auVar1 [16];
uint uVar2;
int iVar3;
ulong uVar4;
ulong uVar5;
int8 uVar6;
int8 uVar7;
bool bVar8;
int1 auVar9 [16];
int1 auVar10 [16];
uint uStack_64;
int8 local_58;
int8 uStack_50;
int1 local_48 [16];
auVar10._8_8_ = param_6;
auVar10._0_8_ = param_5;
auVar1._8_8_ = param_6;
auVar1._0_8_ = param_5;
if (((uint)param_6 | 8) == 0xffffffff) {
auVar9 = JS_GetPropertyInternal2(param_1,param_5,param_6,0x91,param_5,param_6,0,0);
uVar7 = auVar9._8_8_;
uVar6 = auVar9._0_8_;
if (auVar9._8_4_ == 6) {
bVar8 = false;
auVar10 = auVar1;
}
else {
iVar3 = JS_IsFunction(param_1,uVar6,uVar7);
if (iVar3 == 0) {
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar6,uVar7);
bVar8 = true;
}
else {
auVar10 = JS_CallFree(param_1,uVar6,uVar7,param_5,param_6,1,¶m_7);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),param_5,param_6);
bVar8 = auVar10._8_4_ != 6;
}
}
if (bVar8) goto LAB_00133db3;
LAB_00133e35:
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),auVar10._0_8_,auVar10._8_8_);
uVar6 = 6;
}
else {
LAB_00133db3:
uVar6 = auVar10._8_8_;
uVar7 = auVar10._0_8_;
if ((int)param_2[1] != 3) {
local_58 = param_7;
uStack_50 = param_8;
local_48 = auVar10;
auVar10 = JS_CallInternal(param_1,*param_2,param_2[1],param_3,param_4,2,
(ulong)uStack_64 << 0x20,3,&local_58,2);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar7,uVar6);
if (auVar10._8_4_ == 6) goto LAB_00133e35;
}
uVar6 = auVar10._8_8_;
uVar4 = auVar10._0_8_;
uVar2 = auVar10._8_4_ + 9;
if (uVar2 < 0x11) {
if ((0x18e05U >> (uVar2 & 0x1f) & 1) != 0) {
LAB_00133e61:
uVar5 = uVar4 & 0xffffffff00000000;
uVar4 = uVar4 & 0xffffffff;
goto LAB_00133e71;
}
if (uVar2 == 8) {
iVar3 = JS_IsFunction(param_1,uVar4,uVar6);
if (iVar3 == 0) goto LAB_00133e61;
}
}
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar4,uVar6);
uVar6 = 3;
}
uVar4 = 0;
uVar5 = 0;
LAB_00133e71:
auVar9._0_8_ = uVar4 | uVar5;
auVar9._8_8_ = uVar6;
return auVar9;
}
| |
22,269 | js_json_check | bluesky950520[P]quickjs/quickjs.c | static JSValue js_json_check(JSContext *ctx, JSONStringifyContext *jsc,
JSValue holder, JSValue val, JSValue key)
{
JSValue v;
JSValue args[2];
if (JS_IsObject(val) || JS_IsBigInt(ctx, val)) {
JSValue f = JS_GetProperty(ctx, val, JS_ATOM_toJSON);
if (JS_IsException(f))
goto exception;
if (JS_IsFunction(ctx, f)) {
v = JS_CallFree(ctx, f, val, 1, &key);
JS_FreeValue(ctx, val);
val = v;
if (JS_IsException(val))
goto exception;
} else {
JS_FreeValue(ctx, f);
}
}
if (!JS_IsUndefined(jsc->replacer_func)) {
args[0] = key;
args[1] = val;
v = JS_Call(ctx, jsc->replacer_func, holder, 2, args);
JS_FreeValue(ctx, val);
val = v;
if (JS_IsException(val))
goto exception;
}
switch (JS_VALUE_GET_NORM_TAG(val)) {
case JS_TAG_OBJECT:
if (JS_IsFunction(ctx, val))
break;
case JS_TAG_STRING:
case JS_TAG_INT:
case JS_TAG_FLOAT64:
case JS_TAG_BOOL:
case JS_TAG_NULL:
case JS_TAG_BIG_INT:
case JS_TAG_EXCEPTION:
return val;
default:
break;
}
JS_FreeValue(ctx, val);
return JS_UNDEFINED;
exception:
JS_FreeValue(ctx, val);
return JS_EXCEPTION;
} | O3 | c | js_json_check:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r15
leaq 0xa0(%rsp), %rcx
movl %r14d, %eax
orl $0x8, %eax
cmpl $-0x1, %eax
jne 0x34b6d
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0x91, %ecx
movq %rbx, %r8
movq %r14, %r9
callq 0x22c0f
movl %edx, %ecx
cmpq $0x6, %rcx
je 0x34cb9
cmpl $-0x1, %ecx
movq %r12, 0x20(%rsp)
jne 0x34bfc
movzwl 0x6(%rax), %ecx
cmpl $0xd, %ecx
je 0x34b98
cmpl $0x30, %ecx
jne 0x34b7a
movq 0x30(%rax), %rcx
movzbl 0x20(%rcx), %ecx
jmp 0x34b94
movq %r12, 0x20(%rsp)
movq %r14, %r12
jmp 0x34c24
movq 0x18(%r15), %rsi
movq 0x80(%rsi), %rsi
leaq (%rcx,%rcx,4), %rdi
xorl %ecx, %ecx
cmpq $0x0, 0x18(%rsi,%rdi,8)
setne %cl
testl %ecx, %ecx
je 0x34bfc
leaq 0xa0(%rsp), %rcx
movq %rcx, (%rsp)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
movq %r14, %r8
movl $0x1, %r9d
callq 0x228ab
movq %rdx, %r12
movq 0x18(%r15), %rdi
movl (%rbx), %edx
leal -0x1(%rdx), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %edx
jg 0x34be3
movq %rax, 0x28(%rsp)
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
movq 0x28(%rsp), %rax
movq %rax, %rbx
movq %r12, %r14
cmpl $0x6, %r12d
leaq 0xa0(%rsp), %rcx
jne 0x34c24
jmp 0x34cb9
cmpl $-0x9, %edx
jb 0x34c19
movq 0x18(%r15), %rdi
movl (%rax), %ecx
leal -0x1(%rcx), %esi
movl %esi, (%rax)
cmpl $0x1, %ecx
jg 0x34c19
movq %rax, %rsi
callq 0x20d90
movq %r14, %r12
leaq 0xa0(%rsp), %rcx
movq 0x8(%rbp), %rdx
cmpl $0x3, %edx
jne 0x34c35
movq %r12, %r14
jmp 0x34ce6
movups (%rcx), %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq %r12, 0x18(%rax)
movq (%rbp), %rsi
movl $0x0, 0x30(%rsp)
movq $0x3, 0x38(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rax, 0x10(%rsp)
movl $0x2, 0x18(%rsp)
movq %r15, %rdi
movq 0x20(%rsp), %rcx
movq %r13, %r8
movl $0x2, %r9d
callq 0x27eca
movq %rax, %r13
movq %rdx, %r14
cmpl $-0x9, %r12d
jb 0x34cb0
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x34cb0
movq %rbx, %rsi
movq %r12, %rdx
callq 0x20d90
movq %r13, %rbx
cmpl $0x6, %r14d
jne 0x34ce6
cmpl $-0x9, %r14d
jb 0x34cda
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x34cda
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
xorl %eax, %eax
xorl %ecx, %ecx
movl $0x6, %r14d
jmp 0x34d08
leal 0x9(%r14), %eax
cmpl $0x10, %eax
ja 0x34d40
movl $0x18e05, %ecx # imm = 0x18E05
btl %eax, %ecx
jae 0x34d1d
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rbx, %rcx
movl %ebx, %eax
orq %rcx, %rax
movq %r14, %rdx
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x8, %eax
jne 0x34d40
cmpl $-0x1, %r14d
jne 0x34cf9
movzwl 0x6(%rbx), %eax
cmpl $0xd, %eax
je 0x34d70
cmpl $0x30, %eax
jne 0x34d52
movq 0x30(%rbx), %rax
movzbl 0x20(%rax), %eax
jmp 0x34d6c
cmpl $-0x9, %r14d
jae 0x34d70
movl $0x3, %r14d
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x34d08
movq 0x18(%r15), %rcx
movq 0x80(%rcx), %rcx
leaq (%rax,%rax,4), %rdx
xorl %eax, %eax
cmpq $0x0, 0x18(%rcx,%rdx,8)
setne %al
testl %eax, %eax
je 0x34cf9
movq 0x18(%r15), %rdi
movl (%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x1, %eax
jg 0x34d8b
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20d90
xorl %eax, %eax
xorl %ecx, %ecx
movl $0x3, %r14d
jmp 0x34d08
| js_json_check:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov r14, r9
mov rbx, r8
mov r13, rcx
mov r12, rdx
mov rbp, rsi
mov r15, rdi
lea rcx, [rsp+98h+arg_0]
mov eax, r14d
or eax, 8
cmp eax, 0FFFFFFFFh
jnz short loc_34B6D
mov dword ptr [rsp+98h+var_98+8], 0
mov qword ptr [rsp+98h+var_98], 0
mov rdi, r15
mov rsi, rbx
mov rdx, r14
mov ecx, 91h
mov r8, rbx
mov r9, r14
call JS_GetPropertyInternal2
mov ecx, edx
cmp rcx, 6
jz loc_34CB9
cmp ecx, 0FFFFFFFFh
mov [rsp+98h+var_78], r12
jnz loc_34BFC
movzx ecx, word ptr [rax+6]
cmp ecx, 0Dh
jz short loc_34B98
cmp ecx, 30h ; '0'
jnz short loc_34B7A
mov rcx, [rax+30h]
movzx ecx, byte ptr [rcx+20h]
jmp short loc_34B94
loc_34B6D:
mov [rsp+98h+var_78], r12
mov r12, r14
jmp loc_34C24
loc_34B7A:
mov rsi, [r15+18h]
mov rsi, [rsi+80h]
lea rdi, [rcx+rcx*4]
xor ecx, ecx
cmp qword ptr [rsi+rdi*8+18h], 0
setnz cl
loc_34B94:
test ecx, ecx
jz short loc_34BFC
loc_34B98:
lea rcx, [rsp+98h+arg_0]
mov qword ptr [rsp+98h+var_98], rcx
mov rdi, r15
mov rsi, rax
mov rcx, rbx
mov r8, r14
mov r9d, 1
call JS_CallFree
mov r12, rdx
mov rdi, [r15+18h]
mov edx, [rbx]
lea ecx, [rdx-1]
mov [rbx], ecx
cmp edx, 1
jg short loc_34BE3
mov [rsp+98h+var_70], rax
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
mov rax, [rsp+98h+var_70]
loc_34BE3:
mov rbx, rax
mov r14, r12
cmp r12d, 6
lea rcx, [rsp+98h+arg_0]
jnz short loc_34C24
jmp loc_34CB9
loc_34BFC:
cmp edx, 0FFFFFFF7h
jb short loc_34C19
mov rdi, [r15+18h]
mov ecx, [rax]
lea esi, [rcx-1]
mov [rax], esi
cmp ecx, 1
jg short loc_34C19
mov rsi, rax
call js_free_value_rt
loc_34C19:
mov r12, r14
lea rcx, [rsp+98h+arg_0]
loc_34C24:
mov rdx, [rbp+8]
cmp edx, 3
jnz short loc_34C35
mov r14, r12
jmp loc_34CE6
loc_34C35:
movups xmm0, xmmword ptr [rcx]
lea rax, [rsp+98h+var_58]
movaps xmmword ptr [rax], xmm0
mov [rax+10h], rbx
mov [rax+18h], r12
mov rsi, [rbp+0]
mov dword ptr [rsp+98h+var_68], 0
mov qword ptr [rsp+98h+var_68+8], 3
movups xmm0, [rsp+98h+var_68]
movups [rsp+98h+var_98], xmm0
mov [rsp+98h+var_88], rax
mov [rsp+98h+var_80], 2
mov rdi, r15
mov rcx, [rsp+98h+var_78]
mov r8, r13
mov r9d, 2
call JS_CallInternal
mov r13, rax
mov r14, rdx
cmp r12d, 0FFFFFFF7h
jb short loc_34CB0
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_34CB0
mov rsi, rbx
mov rdx, r12
call js_free_value_rt
loc_34CB0:
mov rbx, r13
cmp r14d, 6
jnz short loc_34CE6
loc_34CB9:
cmp r14d, 0FFFFFFF7h
jb short loc_34CDA
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_34CDA
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_34CDA:
xor eax, eax
xor ecx, ecx
mov r14d, 6
jmp short loc_34D08
loc_34CE6:
lea eax, [r14+9]
cmp eax, 10h
ja short loc_34D40
mov ecx, 18E05h
bt ecx, eax
jnb short loc_34D1D
loc_34CF9:
mov rcx, 0FFFFFFFF00000000h
and rcx, rbx
mov eax, ebx
loc_34D08:
or rax, rcx
mov rdx, r14
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_34D1D:
cmp eax, 8
jnz short loc_34D40
cmp r14d, 0FFFFFFFFh
jnz short loc_34CF9
movzx eax, word ptr [rbx+6]
cmp eax, 0Dh
jz short loc_34D70
cmp eax, 30h ; '0'
jnz short loc_34D52
mov rax, [rbx+30h]
movzx eax, byte ptr [rax+20h]
jmp short loc_34D6C
loc_34D40:
cmp r14d, 0FFFFFFF7h
jnb short loc_34D70
mov r14d, 3
xor eax, eax
xor ecx, ecx
jmp short loc_34D08
loc_34D52:
mov rcx, [r15+18h]
mov rcx, [rcx+80h]
lea rdx, [rax+rax*4]
xor eax, eax
cmp qword ptr [rcx+rdx*8+18h], 0
setnz al
loc_34D6C:
test eax, eax
jz short loc_34CF9
loc_34D70:
mov rdi, [r15+18h]
mov eax, [rbx]
lea ecx, [rax-1]
mov [rbx], ecx
cmp eax, 1
jg short loc_34D8B
mov rsi, rbx
mov rdx, r14
call js_free_value_rt
loc_34D8B:
xor eax, eax
xor ecx, ecx
mov r14d, 3
jmp loc_34D08
| unsigned long long js_json_check(
long long a1,
long long *a2,
long long a3,
long long a4,
long long a5,
long long a6,
double a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
__int128 a15)
{
long long v15; // r14
unsigned long long v16; // rbx
unsigned int *PropertyInternal2; // rax
long long v21; // rdx
long long v22; // rcx
int v23; // ecx
long long v24; // r12
long long v25; // rax
long long v26; // rdx
long long v27; // rdi
long long v28; // rcx
long long v29; // rdi
long long v30; // rcx
long long v31; // rdx
unsigned long long v32; // r13
long long v33; // rdx
long long v34; // rdi
int v35; // eax
long long v36; // rcx
long long v37; // rdi
int v38; // eax
long long v39; // rcx
long long v40; // rax
unsigned long long v41; // rcx
int v42; // ecx
long long v44; // rax
long long v46; // rdi
int v47; // eax
long long v48; // rcx
long long v49; // [rsp+20h] [rbp-78h]
long long v50; // [rsp+28h] [rbp-70h]
__m128i v51; // [rsp+30h] [rbp-68h]
__int128 v52; // [rsp+40h] [rbp-58h] BYREF
unsigned long long v53; // [rsp+50h] [rbp-48h]
long long v54; // [rsp+58h] [rbp-40h]
v15 = a6;
v16 = a5;
if ( ((unsigned int)a6 | 8) == 0xFFFFFFFF )
{
PropertyInternal2 = (unsigned int *)JS_GetPropertyInternal2(a1, a5, a6, 0x91u, a5, a6, 0LL, 0);
if ( (unsigned int)v21 == 6LL )
goto LABEL_24;
v49 = a3;
if ( (_DWORD)v21 == -1
&& ((v22 = *((unsigned __int16 *)PropertyInternal2 + 3), (_DWORD)v22 == 13)
|| ((_DWORD)v22 != 48
? (v23 = *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v22 + 24) != 0LL)
: (v23 = *(unsigned __int8 *)(*((_QWORD *)PropertyInternal2 + 6) + 32LL)),
v23)) )
{
v25 = JS_CallFree(a1, PropertyInternal2, v21, v16, v15, 1, (long long)&a15);
v24 = v26;
v27 = *(_QWORD *)(a1 + 24);
LODWORD(v26) = *(_DWORD *)v16;
v28 = (unsigned int)(*(_DWORD *)v16 - 1);
*(_DWORD *)v16 = v28;
if ( (int)v26 <= 1 )
{
v50 = v25;
js_free_value_rt(v27, (_QWORD *)v16, v15, v28, a5, a6);
v25 = v50;
}
v16 = v25;
v15 = v24;
if ( (_DWORD)v24 == 6 )
goto LABEL_24;
}
else
{
if ( (unsigned int)v21 >= 0xFFFFFFF7 )
{
v29 = *(_QWORD *)(a1 + 24);
v30 = *PropertyInternal2;
*PropertyInternal2 = v30 - 1;
if ( (int)v30 <= 1 )
js_free_value_rt(v29, PropertyInternal2, v21, v30, a5, a6);
}
v24 = v15;
}
}
else
{
v49 = a3;
v24 = a6;
}
v31 = a2[1];
if ( (_DWORD)v31 != 3 )
{
v52 = a15;
v53 = v16;
v54 = v24;
v51.m128i_i32[0] = 0;
v51.m128i_i64[1] = 3LL;
v32 = JS_CallInternal(
a1,
*a2,
v31,
v49,
a4,
2LL,
v51,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v51.m128i_i8[0],
3,
(long long)&v52,
2u);
v15 = v33;
if ( (unsigned int)v24 >= 0xFFFFFFF7 )
{
v34 = *(_QWORD *)(a1 + 24);
v35 = *(_DWORD *)v16;
v36 = (unsigned int)(*(_DWORD *)v16 - 1);
*(_DWORD *)v16 = v36;
if ( v35 <= 1 )
js_free_value_rt(v34, (_QWORD *)v16, v24, v36, a5, a6);
}
v16 = v32;
if ( (_DWORD)v15 != 6 )
goto LABEL_28;
LABEL_24:
if ( (unsigned int)v15 >= 0xFFFFFFF7 )
{
v37 = *(_QWORD *)(a1 + 24);
v38 = *(_DWORD *)v16;
v39 = (unsigned int)(*(_DWORD *)v16 - 1);
*(_DWORD *)v16 = v39;
if ( v38 <= 1 )
js_free_value_rt(v37, (_QWORD *)v16, v15, v39, a5, a6);
}
v40 = 0LL;
v41 = 0LL;
return v41 | v40;
}
v15 = v24;
if ( (unsigned int)(v15 + 9) > 0x10 )
goto LABEL_36;
LABEL_28:
v42 = 101893;
if ( _bittest(&v42, v15 + 9) )
{
LABEL_30:
v41 = v16 & 0xFFFFFFFF00000000LL;
v40 = (unsigned int)v16;
return v41 | v40;
}
if ( (_DWORD)v15 == -1 )
{
v44 = *(unsigned __int16 *)(v16 + 6);
if ( (_DWORD)v44 != 13
&& !((_DWORD)v44 == 48
? *(unsigned __int8 *)(*(_QWORD *)(v16 + 48) + 32LL)
: *(_QWORD *)(*(_QWORD *)(*(_QWORD *)(a1 + 24) + 128LL) + 40 * v44 + 24) != 0LL) )
{
goto LABEL_30;
}
}
else
{
LABEL_36:
if ( (unsigned int)v15 < 0xFFFFFFF7 )
{
v40 = 0LL;
v41 = 0LL;
return v41 | v40;
}
}
v46 = *(_QWORD *)(a1 + 24);
v47 = *(_DWORD *)v16;
v48 = (unsigned int)(*(_DWORD *)v16 - 1);
*(_DWORD *)v16 = v48;
if ( v47 <= 1 )
js_free_value_rt(v46, (_QWORD *)v16, v15, v48, a5, a6);
v40 = 0LL;
v41 = 0LL;
return v41 | v40;
}
| js_json_check:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV R14,R9
MOV RBX,R8
MOV R13,RCX
MOV R12,RDX
MOV RBP,RSI
MOV R15,RDI
LEA RCX,[RSP + 0xa0]
MOV EAX,R14D
OR EAX,0x8
CMP EAX,-0x1
JNZ 0x00134b6d
MOV dword ptr [RSP + 0x8],0x0
MOV qword ptr [RSP],0x0
MOV RDI,R15
MOV RSI,RBX
MOV RDX,R14
MOV ECX,0x91
MOV R8,RBX
MOV R9,R14
CALL 0x00122c0f
MOV ECX,EDX
CMP RCX,0x6
JZ 0x00134cb9
CMP ECX,-0x1
MOV qword ptr [RSP + 0x20],R12
JNZ 0x00134bfc
MOVZX ECX,word ptr [RAX + 0x6]
CMP ECX,0xd
JZ 0x00134b98
CMP ECX,0x30
JNZ 0x00134b7a
MOV RCX,qword ptr [RAX + 0x30]
MOVZX ECX,byte ptr [RCX + 0x20]
JMP 0x00134b94
LAB_00134b6d:
MOV qword ptr [RSP + 0x20],R12
MOV R12,R14
JMP 0x00134c24
LAB_00134b7a:
MOV RSI,qword ptr [R15 + 0x18]
MOV RSI,qword ptr [RSI + 0x80]
LEA RDI,[RCX + RCX*0x4]
XOR ECX,ECX
CMP qword ptr [RSI + RDI*0x8 + 0x18],0x0
SETNZ CL
LAB_00134b94:
TEST ECX,ECX
JZ 0x00134bfc
LAB_00134b98:
LEA RCX,[RSP + 0xa0]
MOV qword ptr [RSP],RCX
MOV RDI,R15
MOV RSI,RAX
MOV RCX,RBX
MOV R8,R14
MOV R9D,0x1
CALL 0x001228ab
MOV R12,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV EDX,dword ptr [RBX]
LEA ECX,[RDX + -0x1]
MOV dword ptr [RBX],ECX
CMP EDX,0x1
JG 0x00134be3
MOV qword ptr [RSP + 0x28],RAX
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
MOV RAX,qword ptr [RSP + 0x28]
LAB_00134be3:
MOV RBX,RAX
MOV R14,R12
CMP R12D,0x6
LEA RCX,[RSP + 0xa0]
JNZ 0x00134c24
JMP 0x00134cb9
LAB_00134bfc:
CMP EDX,-0x9
JC 0x00134c19
MOV RDI,qword ptr [R15 + 0x18]
MOV ECX,dword ptr [RAX]
LEA ESI,[RCX + -0x1]
MOV dword ptr [RAX],ESI
CMP ECX,0x1
JG 0x00134c19
MOV RSI,RAX
CALL 0x00120d90
LAB_00134c19:
MOV R12,R14
LEA RCX,[RSP + 0xa0]
LAB_00134c24:
MOV RDX,qword ptr [RBP + 0x8]
CMP EDX,0x3
JNZ 0x00134c35
MOV R14,R12
JMP 0x00134ce6
LAB_00134c35:
MOVUPS XMM0,xmmword ptr [RCX]
LEA RAX,[RSP + 0x40]
MOVAPS xmmword ptr [RAX],XMM0
MOV qword ptr [RAX + 0x10],RBX
MOV qword ptr [RAX + 0x18],R12
MOV RSI,qword ptr [RBP]
MOV dword ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + 0x38],0x3
MOVUPS XMM0,xmmword ptr [RSP + 0x30]
MOVUPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],RAX
MOV dword ptr [RSP + 0x18],0x2
MOV RDI,R15
MOV RCX,qword ptr [RSP + 0x20]
MOV R8,R13
MOV R9D,0x2
CALL 0x00127eca
MOV R13,RAX
MOV R14,RDX
CMP R12D,-0x9
JC 0x00134cb0
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00134cb0
MOV RSI,RBX
MOV RDX,R12
CALL 0x00120d90
LAB_00134cb0:
MOV RBX,R13
CMP R14D,0x6
JNZ 0x00134ce6
LAB_00134cb9:
CMP R14D,-0x9
JC 0x00134cda
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00134cda
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
LAB_00134cda:
XOR EAX,EAX
XOR ECX,ECX
MOV R14D,0x6
JMP 0x00134d08
LAB_00134ce6:
LEA EAX,[R14 + 0x9]
CMP EAX,0x10
JA 0x00134d40
MOV ECX,0x18e05
BT ECX,EAX
JNC 0x00134d1d
LAB_00134cf9:
MOV RCX,-0x100000000
AND RCX,RBX
MOV EAX,EBX
LAB_00134d08:
OR RAX,RCX
MOV RDX,R14
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00134d1d:
CMP EAX,0x8
JNZ 0x00134d40
CMP R14D,-0x1
JNZ 0x00134cf9
MOVZX EAX,word ptr [RBX + 0x6]
CMP EAX,0xd
JZ 0x00134d70
CMP EAX,0x30
JNZ 0x00134d52
MOV RAX,qword ptr [RBX + 0x30]
MOVZX EAX,byte ptr [RAX + 0x20]
JMP 0x00134d6c
LAB_00134d40:
CMP R14D,-0x9
JNC 0x00134d70
MOV R14D,0x3
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00134d08
LAB_00134d52:
MOV RCX,qword ptr [R15 + 0x18]
MOV RCX,qword ptr [RCX + 0x80]
LEA RDX,[RAX + RAX*0x4]
XOR EAX,EAX
CMP qword ptr [RCX + RDX*0x8 + 0x18],0x0
SETNZ AL
LAB_00134d6c:
TEST EAX,EAX
JZ 0x00134cf9
LAB_00134d70:
MOV RDI,qword ptr [R15 + 0x18]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RBX],ECX
CMP EAX,0x1
JG 0x00134d8b
MOV RSI,RBX
MOV RDX,R14
CALL 0x00120d90
LAB_00134d8b:
XOR EAX,EAX
XOR ECX,ECX
MOV R14D,0x3
JMP 0x00134d08
|
int1 [16]
js_json_check(long param_1,int8 *param_2,int8 param_3,int8 param_4,int *param_5,
int8 param_6,int8 param_7,int8 param_8)
{
ushort uVar1;
int iVar2;
int8 uVar3;
uint uVar4;
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
uint uVar8;
ulong uVar9;
ulong uVar10;
int *piVar11;
int8 uVar12;
char cVar13;
int1 auVar14 [16];
int1 auVar15 [16];
uint uStack_64;
int8 local_58;
int8 uStack_50;
int1 local_48 [16];
auVar15._8_8_ = param_6;
auVar15._0_8_ = param_5;
auVar7._8_8_ = param_6;
auVar7._0_8_ = param_5;
auVar6._8_8_ = param_6;
auVar6._0_8_ = param_5;
auVar5._8_8_ = param_6;
auVar5._0_8_ = param_5;
if (((uint)param_6 | 8) == 0xffffffff) {
auVar14 = JS_GetPropertyInternal2(param_1,param_5,param_6,0x91,param_5,param_6,0,0);
piVar11 = auVar14._0_8_;
if ((auVar14._8_8_ & 0xffffffff) != 6) {
if (auVar14._8_4_ == 0xffffffff) {
uVar1 = *(ushort *)((long)piVar11 + 6);
if (uVar1 != 0xd) {
if (uVar1 == 0x30) {
cVar13 = *(char *)(*(long *)(piVar11 + 0xc) + 0x20);
}
else {
cVar13 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x18 +
(ulong)uVar1 * 0x28) != 0;
}
if (cVar13 == '\0') goto LAB_00134bfc;
}
auVar15 = JS_CallFree(param_1,piVar11,auVar14._8_8_,param_5,param_6,1,¶m_7);
uVar12 = *(int8 *)(param_1 + 0x18);
iVar2 = *param_5;
*param_5 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar12,param_5,param_6);
}
auVar5 = auVar15;
if (auVar15._8_4_ == 6) goto LAB_00134cb9;
}
else {
LAB_00134bfc:
auVar5 = auVar6;
if (0xfffffff6 < auVar14._8_4_) {
uVar12 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar11;
*piVar11 = iVar2 + -1;
auVar5 = auVar7;
if (iVar2 < 2) {
js_free_value_rt(uVar12,piVar11);
auVar5 = auVar15;
}
}
}
goto LAB_00134c24;
}
LAB_00134cb9:
piVar11 = auVar15._0_8_;
if (0xfffffff6 < auVar15._8_4_) {
uVar12 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar11;
*piVar11 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar12,piVar11,auVar15._8_8_);
}
}
uVar9 = 0;
uVar10 = 0;
uVar12 = 6;
goto LAB_00134d08;
}
LAB_00134c24:
piVar11 = auVar5._0_8_;
if ((int)param_2[1] != 3) {
local_58 = param_7;
uStack_50 = param_8;
local_48 = auVar5;
auVar15 = JS_CallInternal(param_1,*param_2,param_2[1],param_3,param_4,2,(ulong)uStack_64 << 0x20
,3,&local_58,2);
if (0xfffffff6 < auVar5._8_4_) {
uVar12 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar11;
*piVar11 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar12,piVar11,auVar5._8_8_);
}
}
auVar5 = auVar15;
if (auVar15._8_4_ == 6) goto LAB_00134cb9;
}
uVar12 = auVar5._8_8_;
piVar11 = auVar5._0_8_;
uVar4 = auVar5._8_4_;
uVar8 = uVar4 + 9;
if (uVar8 < 0x11) {
if ((0x18e05U >> (uVar8 & 0x1f) & 1) != 0) {
LAB_00134cf9:
uVar10 = (ulong)piVar11 & 0xffffffff00000000;
uVar9 = (ulong)piVar11 & 0xffffffff;
goto LAB_00134d08;
}
if (uVar8 != 8) goto LAB_00134d40;
if (uVar4 != 0xffffffff) goto LAB_00134cf9;
uVar1 = *(ushort *)((long)piVar11 + 6);
if (uVar1 != 0xd) {
if (uVar1 == 0x30) {
cVar13 = *(char *)(*(long *)(piVar11 + 0xc) + 0x20);
}
else {
cVar13 = *(long *)(*(long *)(*(long *)(param_1 + 0x18) + 0x80) + 0x18 + (ulong)uVar1 * 0x28)
!= 0;
}
if (cVar13 == '\0') goto LAB_00134cf9;
}
}
else {
LAB_00134d40:
if (uVar4 < 0xfffffff7) {
uVar12 = 3;
uVar9 = 0;
uVar10 = 0;
goto LAB_00134d08;
}
}
uVar3 = *(int8 *)(param_1 + 0x18);
iVar2 = *piVar11;
*piVar11 = iVar2 + -1;
if (iVar2 < 2) {
js_free_value_rt(uVar3,piVar11,uVar12);
}
uVar9 = 0;
uVar10 = 0;
uVar12 = 3;
LAB_00134d08:
auVar14._0_8_ = uVar9 | uVar10;
auVar14._8_8_ = uVar12;
return auVar14;
}
| |
22,270 | minja::FilterTemplateToken::~FilterTemplateToken() | monkey531[P]llama/common/minja.hpp | FilterTemplateToken(const Location & location, SpaceHandling pre, SpaceHandling post, std::shared_ptr<Expression> && filter)
: TemplateToken(Type::Filter, location, pre, post), filter(std::move(filter)) {} | O3 | cpp | minja::FilterTemplateToken::~FilterTemplateToken():
pushq %rbx
movq %rdi, %rbx
leaq 0x916a1(%rip), %rax # 0x12fe48
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x9e7bc
callq 0x33c02
leaq 0x90b25(%rip), %rax # 0x12f2e8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x9e7d8
callq 0x33c02
movl $0x40, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1b910
| _ZN5minja19FilterTemplateTokenD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja19FilterTemplateTokenE; `vtable for'minja::FilterTemplateToken
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+38h]
test rdi, rdi
jz short loc_9E7BC
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E7BC:
lea rax, _ZTVN5minja13TemplateTokenE; `vtable for'minja::TemplateToken
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+18h]
test rdi, rdi
jz short loc_9E7D8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9E7D8:
mov esi, 40h ; '@'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::FilterTemplateToken::~FilterTemplateToken(minja::FilterTemplateToken *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::FilterTemplateToken + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 7);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateToken + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 3);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x40uLL);
}
| ~FilterTemplateToken:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22fe48]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x38]
TEST RDI,RDI
JZ 0x0019e7bc
CALL 0x00133c02
LAB_0019e7bc:
LEA RAX,[0x22f2e8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x18]
TEST RDI,RDI
JZ 0x0019e7d8
CALL 0x00133c02
LAB_0019e7d8:
MOV ESI,0x40
MOV RDI,RBX
POP RBX
JMP 0x0011b910
|
/* minja::FilterTemplateToken::~FilterTemplateToken() */
void __thiscall minja::FilterTemplateToken::~FilterTemplateToken(FilterTemplateToken *this)
{
*(int ***)this = &PTR__FilterTemplateToken_0022fe58;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x38) !=
(_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 + 0x38));
}
*(int ***)this = &PTR__TemplateToken_0022f2f8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x18));
}
operator_delete(this,0x40);
return;
}
| |
22,271 | find_hashed_shape_proto | bluesky950520[P]quickjs/quickjs.c | static JSShape *find_hashed_shape_proto(JSRuntime *rt, JSObject *proto)
{
JSShape *sh1;
uint32_t h, h1;
h = shape_initial_hash(proto);
h1 = get_shape_hash(h, rt->shape_hash_bits);
for(sh1 = rt->shape_hash[h1]; sh1 != NULL; sh1 = sh1->shape_hash_next) {
if (sh1->hash == h &&
sh1->proto == proto &&
sh1->prop_count == 0) {
return sh1;
}
}
return NULL;
} | O0 | c | find_hashed_shape_proto:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5d8c0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x18(%rsp), %rax
movl 0x184(%rax), %esi
callq 0x5d890
movl %eax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x190(%rax), %rax
movl (%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2a03a
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %eax
cmpl 0x4(%rsp), %eax
jne 0x2a028
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0x2a028
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x2a028
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2a043
jmp 0x2a02a
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x29feb
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
| find_hashed_shape_proto:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rdi, [rsp+28h+var_18]
call shape_initial_hash
mov [rsp+28h+var_24], eax
mov edi, [rsp+28h+var_24]
mov rax, [rsp+28h+var_10]
mov esi, [rax+184h]
call get_shape_hash
mov [rsp+28h+var_28], eax
mov rax, [rsp+28h+var_10]
mov rax, [rax+190h]
mov ecx, [rsp+28h+var_28]
mov rax, [rax+rcx*8]
mov [rsp+28h+var_20], rax
loc_29FEB:
cmp [rsp+28h+var_20], 0
jz short loc_2A03A
mov rax, [rsp+28h+var_20]
mov eax, [rax+1Ch]
cmp eax, [rsp+28h+var_24]
jnz short loc_2A028
mov rax, [rsp+28h+var_20]
mov rax, [rax+38h]
cmp rax, [rsp+28h+var_18]
jnz short loc_2A028
mov rax, [rsp+28h+var_20]
cmp dword ptr [rax+28h], 0
jnz short loc_2A028
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_8], rax
jmp short loc_2A043
loc_2A028:
jmp short $+2
loc_2A02A:
mov rax, [rsp+28h+var_20]
mov rax, [rax+30h]
mov [rsp+28h+var_20], rax
jmp short loc_29FEB
loc_2A03A:
mov [rsp+28h+var_8], 0
loc_2A043:
mov rax, [rsp+28h+var_8]
add rsp, 28h
retn
| long long find_hashed_shape_proto(long long a1, long long a2)
{
unsigned int v3; // [rsp+4h] [rbp-24h]
long long i; // [rsp+8h] [rbp-20h]
v3 = shape_initial_hash(a2);
for ( i = *(_QWORD *)(*(_QWORD *)(a1 + 400) + 8LL * (unsigned int)get_shape_hash(v3, *(unsigned int *)(a1 + 388)));
i;
i = *(_QWORD *)(i + 48) )
{
if ( *(_DWORD *)(i + 28) == v3 && *(_QWORD *)(i + 56) == a2 && !*(_DWORD *)(i + 40) )
return i;
}
return 0LL;
}
| find_hashed_shape_proto:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0015d8c0
MOV dword ptr [RSP + 0x4],EAX
MOV EDI,dword ptr [RSP + 0x4]
MOV RAX,qword ptr [RSP + 0x18]
MOV ESI,dword ptr [RAX + 0x184]
CALL 0x0015d890
MOV dword ptr [RSP],EAX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x190]
MOV ECX,dword ptr [RSP]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x8],RAX
LAB_00129feb:
CMP qword ptr [RSP + 0x8],0x0
JZ 0x0012a03a
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x1c]
CMP EAX,dword ptr [RSP + 0x4]
JNZ 0x0012a028
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x38]
CMP RAX,qword ptr [RSP + 0x10]
JNZ 0x0012a028
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RAX + 0x28],0x0
JNZ 0x0012a028
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x20],RAX
JMP 0x0012a043
LAB_0012a028:
JMP 0x0012a02a
LAB_0012a02a:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x00129feb
LAB_0012a03a:
MOV qword ptr [RSP + 0x20],0x0
LAB_0012a043:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
long find_hashed_shape_proto(long param_1,long param_2)
{
int iVar1;
uint uVar2;
long local_20;
iVar1 = shape_initial_hash(param_2);
uVar2 = get_shape_hash(iVar1,*(int4 *)(param_1 + 0x184));
local_20 = *(long *)(*(long *)(param_1 + 400) + (ulong)uVar2 * 8);
while( true ) {
if (local_20 == 0) {
return 0;
}
if (((*(int *)(local_20 + 0x1c) == iVar1) && (*(long *)(local_20 + 0x38) == param_2)) &&
(*(int *)(local_20 + 0x28) == 0)) break;
local_20 = *(long *)(local_20 + 0x30);
}
return local_20;
}
| |
22,272 | clip_model_loader::get_arr_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, bool) | llama.cpp/examples/llava/clip.cpp | void get_arr_int(const std::string & key, std::vector<int> & output, bool required = true) {
const int i = gguf_find_key(ctx_gguf.get(), key.c_str());
if (i < 0) {
if (required) throw std::runtime_error("Key not found: " + key);
return;
}
int n = gguf_get_arr_n(ctx_gguf.get(), i);
output.resize(n);
const int32_t * values = (const int32_t *)gguf_get_arr_data(ctx_gguf.get(), i);
for (int i = 0; i < n; ++i) {
output[i] = values[i];
}
} | O3 | cpp | clip_model_loader::get_arr_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<int, std::allocator<int>>&, bool):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rsi), %rsi
callq 0x23840
movq %rax, %r12
testl %r12d, %r12d
js 0x4c686
movq 0x8(%r15), %rdi
andl $0x7fffffff, %r12d # imm = 0x7FFFFFFF
movq %r12, %rsi
callq 0x24180
movq %rax, %r14
movslq %r14d, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2cfe8
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x24930
testl %r13d, %r13d
jle 0x4c68b
movq (%rbx), %rcx
andl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
incq %rdx
cmpq %rdx, %r14
jne 0x4c676
jmp 0x4c68b
testb %bpl, %bpl
jne 0x4c69a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x23850
movq %rax, %rbx
leaq 0xecabc(%rip), %rsi # 0x13916a
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x2cedf
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x23590
xorl %ebp, %ebp
movq 0x1428ec(%rip), %rsi # 0x18efc0
movq 0x1428a5(%rip), %rdx # 0x18ef80
movq %rbx, %rdi
callq 0x23e00
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c701
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x231f0
testb %bpl, %bpl
jne 0x4c70b
jmp 0x4c713
movq %rax, %r14
movq %rbx, %rdi
callq 0x24440
movq %r14, %rdi
callq 0x23ee0
nop
| _ZN17clip_model_loader11get_arr_intERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERSt6vectorIiSaIiEEb:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, ecx
mov rbx, rdx
mov r14, rsi
mov r15, rdi
mov rdi, [rdi+8]
mov rsi, [rsi]
call _gguf_find_key
mov r12, rax
test r12d, r12d
js short loc_4C686
mov rdi, [r15+8]
and r12d, 7FFFFFFFh
mov rsi, r12
call _gguf_get_arr_n
mov r14, rax
movsxd r13, r14d
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorIiSaIiEE6resizeEm; std::vector<int>::resize(ulong)
mov rdi, [r15+8]
mov rsi, r12
call _gguf_get_arr_data
test r13d, r13d
jle short loc_4C68B
mov rcx, [rbx]
and r14d, 7FFFFFFFh
xor edx, edx
loc_4C676:
mov esi, [rax+rdx*4]
mov [rcx+rdx*4], esi
inc rdx
cmp r14, rdx
jnz short loc_4C676
jmp short loc_4C68B
loc_4C686:
test bpl, bpl
jnz short loc_4C69A
loc_4C68B:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4C69A:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aKeyNotFound; "Key not found: "
lea rdi, [rsp+58h+var_50]
mov rdx, r14
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
mov bpl, 1
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_4C701
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_4C701:
test bpl, bpl
jnz short loc_4C70B
jmp short loc_4C713
mov r14, rax
loc_4C70B:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_4C713:
mov rdi, r14
call __Unwind_Resume
| long long clip_model_loader::get_arr_int(long long a1, _QWORD *a2, long long *a3, char a4)
{
long long result; // rax
unsigned int v7; // r12d
int arr_n; // r14d
long long v9; // rcx
long long v10; // r14
long long v11; // rdx
void *exception; // rbx
_BYTE v13[16]; // [rsp+8h] [rbp-50h] BYREF
result = gguf_find_key(*(_QWORD *)(a1 + 8), *a2);
if ( (int)result < 0 )
{
if ( a4 )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Key not found: ", a2);
std::runtime_error::runtime_error(exception, v13);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v7 = result & 0x7FFFFFFF;
arr_n = gguf_get_arr_n(*(_QWORD *)(a1 + 8), result & 0x7FFFFFFF);
std::vector<int>::resize(a3, arr_n);
result = gguf_get_arr_data(*(_QWORD *)(a1 + 8), v7);
if ( arr_n > 0 )
{
v9 = *a3;
v10 = arr_n & 0x7FFFFFFF;
v11 = 0LL;
do
{
*(_DWORD *)(v9 + 4 * v11) = *(_DWORD *)(result + 4 * v11);
++v11;
}
while ( v10 != v11 );
}
}
return result;
}
| get_arr_int:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,ECX
MOV RBX,RDX
MOV R14,RSI
MOV R15,RDI
MOV RDI,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RSI]
CALL 0x00123840
MOV R12,RAX
TEST R12D,R12D
JS 0x0014c686
MOV RDI,qword ptr [R15 + 0x8]
AND R12D,0x7fffffff
MOV RSI,R12
CALL 0x00124180
MOV R14,RAX
MOVSXD R13,R14D
MOV RDI,RBX
MOV RSI,R13
CALL 0x0012cfe8
MOV RDI,qword ptr [R15 + 0x8]
MOV RSI,R12
CALL 0x00124930
TEST R13D,R13D
JLE 0x0014c68b
MOV RCX,qword ptr [RBX]
AND R14D,0x7fffffff
XOR EDX,EDX
LAB_0014c676:
MOV ESI,dword ptr [RAX + RDX*0x4]
MOV dword ptr [RCX + RDX*0x4],ESI
INC RDX
CMP R14,RDX
JNZ 0x0014c676
JMP 0x0014c68b
LAB_0014c686:
TEST BPL,BPL
JNZ 0x0014c69a
LAB_0014c68b:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014c69a:
MOV EDI,0x10
CALL 0x00123850
MOV RBX,RAX
LAB_0014c6a7:
LEA RSI,[0x23916a]
LEA RDI,[RSP + 0x8]
MOV RDX,R14
CALL 0x0012cedf
MOV BPL,0x1
LAB_0014c6be:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00123590
XOR EBP,EBP
MOV RSI,qword ptr [0x0028efc0]
MOV RDX,qword ptr [0x0028ef80]
MOV RDI,RBX
CALL 0x00123e00
|
/* clip_model_loader::get_arr_int(std::__cxx11::string const&, std::vector<int, std::allocator<int>
>&, bool) */
void __thiscall
clip_model_loader::get_arr_int(clip_model_loader *this,string *param_1,vector *param_2,bool param_3)
{
long lVar1;
uint uVar2;
uint uVar3;
long lVar4;
runtime_error *this_00;
ulong uVar5;
string local_50 [32];
uVar2 = gguf_find_key(*(int8 *)(this + 8),*(int8 *)param_1);
if ((int)uVar2 < 0) {
if (param_3) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0014c6a7 to 0014c6ba has its CatchHandler @ 0014c708 */
std::operator+((char *)local_50,(string *)"Key not found: ");
/* try { // try from 0014c6be to 0014c6e2 has its CatchHandler @ 0014c6e3 */
std::runtime_error::runtime_error(this_00,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0028efc0,PTR__runtime_error_0028ef80);
}
}
else {
uVar3 = gguf_get_arr_n(*(int8 *)(this + 8),uVar2 & 0x7fffffff);
std::vector<int,std::allocator<int>>::resize
((vector<int,std::allocator<int>> *)param_2,(long)(int)uVar3);
lVar4 = gguf_get_arr_data(*(int8 *)(this + 8),uVar2 & 0x7fffffff);
if (0 < (int)uVar3) {
lVar1 = *(long *)param_2;
uVar5 = 0;
do {
*(int4 *)(lVar1 + uVar5 * 4) = *(int4 *)(lVar4 + uVar5 * 4);
uVar5 = uVar5 + 1;
} while ((uVar3 & 0x7fffffff) != uVar5);
}
}
return;
}
| |
22,273 | ImPlot3D::RenderTickLabels(ImDrawList*, ImPlot3DPlot const&, ImPlot3DPoint const*, ImVec2 const*, int const (*) [2]) | zkingston[P]unknot/build_O1/_deps/implot3d-src/implot3d.cpp | void RenderTickLabels(ImDrawList* draw_list, const ImPlot3DPlot& plot, const ImPlot3DPoint* corners, const ImVec2* corners_pix, const int axis_corners[3][2]) {
ImU32 col_tick_txt = GetStyleColorU32(ImPlot3DCol_AxisText);
for (int a = 0; a < 3; a++) {
const ImPlot3DAxis& axis = plot.Axes[a];
if (ImPlot3D::ImHasFlag(axis.Flags, ImPlot3DAxisFlags_NoTickLabels))
continue;
// Corner indices for this axis
int idx0 = axis_corners[a][0];
int idx1 = axis_corners[a][1];
// If normal to the 2D plot, ignore the ticks
if (idx0 == idx1)
continue;
// Start and end points of the axis in plot space
ImPlot3DPoint axis_start = corners[idx0];
ImPlot3DPoint axis_end = corners[idx1];
// Direction vector along the axis
ImPlot3DPoint axis_dir = axis_end - axis_start;
// Convert axis start and end to screen space
ImVec2 axis_start_pix = corners_pix[idx0];
ImVec2 axis_end_pix = corners_pix[idx1];
// Screen space axis direction
ImVec2 axis_screen_dir = axis_end_pix - axis_start_pix;
float axis_length = ImSqrt(ImLengthSqr(axis_screen_dir));
if (axis_length != 0.0f)
axis_screen_dir /= axis_length;
else
axis_screen_dir = ImVec2(1.0f, 0.0f); // Default direction if length is zero
// Perpendicular direction in screen space
ImVec2 offset_dir_pix = ImVec2(-axis_screen_dir.y, axis_screen_dir.x);
// Make sure direction points away from cube center
ImVec2 box_center_pix = PlotToPixels(plot.RangeCenter());
ImVec2 axis_center_pix = (axis_start_pix + axis_end_pix) * 0.5f;
ImVec2 center_to_axis_pix = axis_center_pix - box_center_pix;
center_to_axis_pix /= ImSqrt(ImLengthSqr(center_to_axis_pix));
if (ImDot(offset_dir_pix, center_to_axis_pix) < 0.0f)
offset_dir_pix = -offset_dir_pix;
// Adjust the offset magnitude
float offset_magnitude = 20.0f; // TODO Calculate based on label size
ImVec2 offset_pix = offset_dir_pix * offset_magnitude;
// Compute angle perpendicular to axis in screen space
float angle = atan2f(-axis_screen_dir.y, axis_screen_dir.x) + IM_PI * 0.5f;
// Normalize angle to be between -π and π
if (angle > IM_PI)
angle -= 2 * IM_PI;
if (angle < -IM_PI)
angle += 2 * IM_PI;
// Adjust angle to keep labels upright
if (angle > IM_PI * 0.5f)
angle -= IM_PI;
if (angle < -IM_PI * 0.5f)
angle += IM_PI;
// Loop over ticks
for (int t = 0; t < axis.Ticker.TickCount(); ++t) {
const ImPlot3DTick& tick = axis.Ticker.Ticks[t];
if (!tick.ShowLabel)
continue;
// Compute position along the axis
float t_axis = (tick.PlotPos - axis.Range.Min) / (axis.Range.Max - axis.Range.Min);
// Skip ticks that are out of range
if (t_axis < 0.0f || t_axis > 1.0f)
continue;
ImPlot3DPoint tick_pos = axis_start + axis_dir * t_axis;
// Convert to pixel coordinates
ImVec2 tick_pos_pix = PlotToPixels(tick_pos);
// Get the tick label text
const char* label = axis.Ticker.GetText(tick);
// Adjust label position by offset
ImVec2 label_pos_pix = tick_pos_pix + offset_pix;
// Render the tick label
AddTextRotated(draw_list, label_pos_pix, angle, col_tick_txt, label);
}
}
} | O1 | cpp | ImPlot3D::RenderTickLabels(ImDrawList*, ImPlot3DPlot const&, ImPlot3DPoint const*, ImVec2 const*, int const (*) [2]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rsi, %r12
movq %rdi, 0x88(%rsp)
movq 0x2e97f7(%rip), %rcx # 0x336c98
movss 0x1ac(%rcx), %xmm0
ucomiss 0x241b54(%rip), %xmm0 # 0x28f004
jne 0x4d4c4
jp 0x4d4c4
xorl %edi, %edi
callq 0x215eee
movq %rax, %rcx
addq $0x8, %rcx
jmp 0x4d4d2
leaq 0x1a0(%rcx), %rax
addq $0x1a8, %rcx # imm = 0x1A8
movsd (%rax), %xmm0
movhps (%rcx), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
leaq 0x10(%rsp), %rdi
movups %xmm0, (%rdi)
callq 0x213cfe
movl %eax, 0xc(%rsp)
leaq 0x78(%r12), %rax
movq %rax, 0x48(%rsp)
xorl %ebx, %ebx
imulq $0x70, %rbx, %r15
movq 0x48(%rsp), %rax
testb $0x8, (%rax,%r15)
jne 0x4d887
movq 0x80(%rsp), %rcx
movslq (%rcx,%rbx,8), %rax
movslq 0x4(%rcx,%rbx,8), %rcx
cmpl %ecx, %eax
je 0x4d887
leaq (%rax,%rax,2), %rdx
movq 0x70(%rsp), %rdi
movss 0x8(%rdi,%rdx,4), %xmm0
movss %xmm0, 0x8(%rsp)
leaq (%rcx,%rcx,2), %rsi
movsd (%rdi,%rdx,4), %xmm0
movaps %xmm0, 0x90(%rsp)
movsd (%rdi,%rsi,4), %xmm0
movaps %xmm0, 0x60(%rsp)
movss 0x8(%rdi,%rsi,4), %xmm0
movss %xmm0, 0x4(%rsp)
movq 0x78(%rsp), %rdx
movsd (%rdx,%rax,8), %xmm3
movsd (%rdx,%rcx,8), %xmm4
movaps %xmm4, %xmm2
subps %xmm3, %xmm2
movaps %xmm2, %xmm1
mulps %xmm2, %xmm1
shufps $0x55, %xmm1, %xmm1 # xmm1 = xmm1[1,1,1,1]
movaps %xmm2, %xmm0
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
ucomiss 0x241ac4(%rip), %xmm0 # 0x28f054
movaps %xmm3, 0x30(%rsp)
movaps %xmm4, 0x50(%rsp)
jb 0x4d5a2
sqrtss %xmm0, %xmm0
jmp 0x4d5b1
movaps %xmm2, 0x20(%rsp)
callq 0x10240
movaps 0x20(%rsp), %xmm2
ucomiss 0x241a9c(%rip), %xmm0 # 0x28f054
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
divps %xmm0, %xmm2
jne 0x4d5cb
jp 0x4d5cb
movss 0x241a3d(%rip), %xmm2 # 0x28f008
movaps %xmm2, 0x20(%rsp)
movups 0x80(%r12), %xmm0
movups 0x84(%r12), %xmm1
movss 0xf0(%r12), %xmm2
unpcklps %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movss 0xf4(%r12), %xmm2
unpcklps %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
addps %xmm0, %xmm1
movss 0x160(%r12), %xmm0
addss 0x164(%r12), %xmm0
mulps 0x246dd6(%rip), %xmm1 # 0x2943f0
movss 0x2419fe(%rip), %xmm2 # 0x28f020
mulss %xmm2, %xmm0
movlps %xmm1, 0x10(%rsp)
movss %xmm0, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4cd88
movaps 0x30(%rsp), %xmm5
addps 0x50(%rsp), %xmm5
movaps %xmm5, %xmm6
shufps $0x55, %xmm5, %xmm6 # xmm6 = xmm6[1,1],xmm5[1,1]
movss 0x2419cc(%rip), %xmm1 # 0x28f020
mulss %xmm1, %xmm5
mulss %xmm1, %xmm6
subss %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm0 # xmm0 = xmm0[1,1,1,1]
subss %xmm0, %xmm6
movaps %xmm6, %xmm1
mulss %xmm6, %xmm1
movaps %xmm5, %xmm0
mulss %xmm5, %xmm0
addss %xmm1, %xmm0
ucomiss 0x2419d3(%rip), %xmm0 # 0x28f054
jb 0x4d68c
xorps %xmm1, %xmm1
sqrtss %xmm0, %xmm1
jmp 0x4d6a8
movaps %xmm5, 0x30(%rsp)
movaps %xmm6, 0x50(%rsp)
callq 0x10240
movaps 0x50(%rsp), %xmm6
movaps 0x30(%rsp), %xmm5
movaps %xmm0, %xmm1
movaps 0x245f61(%rip), %xmm2 # 0x293610
movaps 0x20(%rsp), %xmm4
movaps %xmm4, %xmm3
shufps $0x55, %xmm4, %xmm3 # xmm3 = xmm3[1,1],xmm4[1,1]
movaps %xmm3, %xmm0
xorps %xmm2, %xmm0
divss %xmm1, %xmm5
divss %xmm1, %xmm6
mulss %xmm4, %xmm6
mulss %xmm0, %xmm5
addss %xmm6, %xmm5
xorps %xmm1, %xmm1
ucomiss %xmm5, %xmm1
ja 0x4d6e5
movaps %xmm0, %xmm3
unpcklps %xmm4, %xmm3 # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
jmp 0x4d6ee
movaps %xmm4, %xmm1
xorps %xmm2, %xmm1
unpcklps %xmm1, %xmm3 # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
addq 0x48(%rsp), %r15
mulps 0x246d66(%rip), %xmm3 # 0x294460
movaps %xmm3, 0x30(%rsp)
movaps %xmm4, %xmm1
callq 0xfda0
movss 0x246c7d(%rip), %xmm3 # 0x29438c
addss %xmm3, %xmm0
movaps %xmm0, %xmm1
addss 0x246c72(%rip), %xmm1 # 0x294390
movss 0x246c6e(%rip), %xmm2 # 0x294394
cmpltss %xmm0, %xmm2
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
movaps %xmm2, %xmm0
addss 0x246c59(%rip), %xmm0 # 0x294398
movaps %xmm2, %xmm1
movss 0x246c52(%rip), %xmm4 # 0x29439c
cmpltss %xmm4, %xmm1
andps %xmm1, %xmm0
andnps %xmm2, %xmm1
orps %xmm0, %xmm1
movaps %xmm3, %xmm0
cmpltss %xmm1, %xmm0
movaps %xmm1, %xmm2
addss %xmm4, %xmm2
andps %xmm0, %xmm2
andnps %xmm1, %xmm0
orps %xmm2, %xmm0
movaps %xmm0, %xmm1
cmpltss 0x246c24(%rip), %xmm1 # 0x2943a0
cmpl $0x0, 0x28(%r15)
jle 0x4d887
movaps %xmm1, %xmm2
movaps 0x60(%rsp), %xmm1
subps 0x90(%rsp), %xmm1
movaps %xmm1, 0x60(%rsp)
movss 0x4(%rsp), %xmm1
subss 0x8(%rsp), %xmm1
movss %xmm1, 0x4(%rsp)
movaps %xmm0, %xmm1
addss 0x246bdb(%rip), %xmm1 # 0x294394
andps %xmm2, %xmm1
andnps %xmm0, %xmm2
orps %xmm1, %xmm2
movaps %xmm2, 0x20(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x30(%r15), %r14
cmpb $0x1, 0x5(%r14,%r13)
jne 0x4d873
movss (%r14,%r13), %xmm0
movss 0x8(%r15), %xmm1
movss 0xc(%r15), %xmm2
subss %xmm1, %xmm0
subss %xmm1, %xmm2
divss %xmm2, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x4d873
ucomiss 0x2417ff(%rip), %xmm0 # 0x28f008
ja 0x4d873
movss 0x4(%rsp), %xmm1
mulss %xmm0, %xmm1
unpcklps %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1]
mulps 0x60(%rsp), %xmm0
addps 0x90(%rsp), %xmm0
addss 0x8(%rsp), %xmm1
movlps %xmm0, 0x10(%rsp)
movss %xmm1, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4cd88
movslq 0x14(%r14,%r13), %rax
movq 0x30(%r15), %rcx
leaq (%rax,%rax,2), %rax
movslq 0x10(%rcx,%rax,8), %rdx
addq 0x40(%r15), %rdx
addps 0x30(%rsp), %xmm0
movq 0x88(%rsp), %rdi
movaps 0x20(%rsp), %xmm1
movl 0xc(%rsp), %esi
xorl %ecx, %ecx
callq 0x4b11a
incq %rbp
movslq 0x28(%r15), %rax
addq $0x18, %r13
cmpq %rax, %rbp
jl 0x4d7cc
incq %rbx
cmpq $0x3, %rbx
jne 0x4d4f6
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ZN8ImPlot3D16RenderTickLabelsEP10ImDrawListRK12ImPlot3DPlotPK13ImPlot3DPointPK6ImVec2PA2_Ki:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0A8h
mov [rsp+0D8h+var_58], r8
mov [rsp+0D8h+var_60], rcx
mov [rsp+0D8h+var_68], rdx
mov r12, rsi
mov [rsp+0D8h+var_50], rdi
mov rcx, cs:_ZN8ImPlot3D9GImPlot3DE; ImPlot3D::GImPlot3D
movss xmm0, dword ptr [rcx+1ACh]
ucomiss xmm0, cs:flt_28F004
jnz short loc_4D4C4
jp short loc_4D4C4
xor edi, edi; this
call _ZN5ImGui17GetStyleColorVec4Ei; ImGui::GetStyleColorVec4(int)
mov rcx, rax
add rcx, 8
jmp short loc_4D4D2
loc_4D4C4:
lea rax, [rcx+1A0h]
add rcx, 1A8h
loc_4D4D2:
movsd xmm0, qword ptr [rax]
movhps xmm0, qword ptr [rcx]
lea rdi, [rsp+0D8h+var_C8]
movups xmmword ptr [rdi], xmm0
call _ZN5ImGui23ColorConvertFloat4ToU32ERK6ImVec4; ImGui::ColorConvertFloat4ToU32(ImVec4 const&)
mov [rsp+0D8h+var_CC], eax
lea rax, [r12+78h]
mov [rsp+0D8h+var_90], rax
xor ebx, ebx
loc_4D4F6:
imul r15, rbx, 70h ; 'p'
mov rax, [rsp+0D8h+var_90]
test byte ptr [rax+r15], 8
jnz loc_4D887
mov rcx, [rsp+0D8h+var_58]
movsxd rax, dword ptr [rcx+rbx*8]
movsxd rcx, dword ptr [rcx+rbx*8+4]
cmp eax, ecx
jz loc_4D887
lea rdx, [rax+rax*2]
mov rdi, [rsp+0D8h+var_68]
movss xmm0, dword ptr [rdi+rdx*4+8]
movss [rsp+0D8h+var_D0], xmm0
lea rsi, [rcx+rcx*2]; ImPlot3DPoint *
movsd xmm0, qword ptr [rdi+rdx*4]
movaps [rsp+0D8h+var_48], xmm0
movsd xmm0, qword ptr [rdi+rsi*4]
movaps [rsp+0D8h+var_78], xmm0
movss xmm0, dword ptr [rdi+rsi*4+8]
movss [rsp+0D8h+var_D4], xmm0
mov rdx, [rsp+0D8h+var_60]
movsd xmm3, qword ptr [rdx+rax*8]
movsd xmm4, qword ptr [rdx+rcx*8]
movaps xmm2, xmm4
subps xmm2, xmm3
movaps xmm1, xmm2
mulps xmm1, xmm2
shufps xmm1, xmm1, 55h ; 'U'
movaps xmm0, xmm2
mulss xmm0, xmm2
addss xmm0, xmm1
ucomiss xmm0, cs:dword_28F054
movaps [rsp+0D8h+var_A8], xmm3
movaps [rsp+0D8h+var_88], xmm4
jb short loc_4D5A2
sqrtss xmm0, xmm0
jmp short loc_4D5B1
loc_4D5A2:
movaps [rsp+0D8h+var_B8], xmm2
call _sqrtf
movaps xmm2, [rsp+0D8h+var_B8]
loc_4D5B1:
ucomiss xmm0, cs:dword_28F054
shufps xmm0, xmm0, 0
divps xmm2, xmm0
jnz short loc_4D5CB
jp short loc_4D5CB
movss xmm2, cs:flt_28F008
loc_4D5CB:
movaps [rsp+0D8h+var_B8], xmm2
movups xmm0, xmmword ptr [r12+80h]
movups xmm1, xmmword ptr [r12+84h]
movss xmm2, dword ptr [r12+0F0h]
unpcklps xmm0, xmm2
movss xmm2, dword ptr [r12+0F4h]
unpcklps xmm1, xmm2
addps xmm1, xmm0
movss xmm0, dword ptr [r12+160h]
addss xmm0, dword ptr [r12+164h]
mulps xmm1, cs:xmmword_2943F0
movss xmm2, dword ptr cs:xmmword_28F020
mulss xmm0, xmm2
movlps [rsp+0D8h+var_C8], xmm1
movss [rsp+0D8h+var_C0], xmm0
lea rdi, [rsp+0D8h+var_C8]; this
call _ZN8ImPlot3D12PlotToPixelsERK13ImPlot3DPoint; ImPlot3D::PlotToPixels(ImPlot3DPoint const&)
movaps xmm5, [rsp+0D8h+var_A8]
addps xmm5, [rsp+0D8h+var_88]
movaps xmm6, xmm5
shufps xmm6, xmm5, 55h ; 'U'
movss xmm1, dword ptr cs:xmmword_28F020
mulss xmm5, xmm1
mulss xmm6, xmm1
subss xmm5, xmm0
shufps xmm0, xmm0, 55h ; 'U'
subss xmm6, xmm0
movaps xmm1, xmm6
mulss xmm1, xmm6
movaps xmm0, xmm5
mulss xmm0, xmm5
addss xmm0, xmm1
ucomiss xmm0, cs:dword_28F054
jb short loc_4D68C
xorps xmm1, xmm1
sqrtss xmm1, xmm0
jmp short loc_4D6A8
loc_4D68C:
movaps [rsp+0D8h+var_A8], xmm5
movaps [rsp+0D8h+var_88], xmm6
call _sqrtf
movaps xmm6, [rsp+0D8h+var_88]
movaps xmm5, [rsp+0D8h+var_A8]
movaps xmm1, xmm0
loc_4D6A8:
movaps xmm2, cs:xmmword_293610
movaps xmm4, [rsp+0D8h+var_B8]
movaps xmm3, xmm4
shufps xmm3, xmm4, 55h ; 'U'
movaps xmm0, xmm3
xorps xmm0, xmm2
divss xmm5, xmm1
divss xmm6, xmm1
mulss xmm6, xmm4
mulss xmm5, xmm0
addss xmm5, xmm6
xorps xmm1, xmm1
ucomiss xmm1, xmm5
ja short loc_4D6E5
movaps xmm3, xmm0
unpcklps xmm3, xmm4
jmp short loc_4D6EE
loc_4D6E5:
movaps xmm1, xmm4
xorps xmm1, xmm2
unpcklps xmm3, xmm1
loc_4D6EE:
add r15, [rsp+0D8h+var_90]
mulps xmm3, cs:xmmword_294460
movaps [rsp+0D8h+var_A8], xmm3
movaps xmm1, xmm4
call _atan2f
movss xmm3, cs:dword_29438C
addss xmm0, xmm3
movaps xmm1, xmm0
addss xmm1, cs:dword_294390
movss xmm2, cs:dword_294394
cmpltss xmm2, xmm0
andps xmm1, xmm2
andnps xmm2, xmm0
orps xmm2, xmm1
movaps xmm0, xmm2
addss xmm0, cs:dword_294398
movaps xmm1, xmm2
movss xmm4, cs:dword_29439C
cmpltss xmm1, xmm4
andps xmm0, xmm1
andnps xmm1, xmm2
orps xmm1, xmm0
movaps xmm0, xmm3
cmpltss xmm0, xmm1
movaps xmm2, xmm1
addss xmm2, xmm4
andps xmm2, xmm0
andnps xmm0, xmm1
orps xmm0, xmm2
movaps xmm1, xmm0
cmpltss xmm1, cs:dword_2943A0
cmp dword ptr [r15+28h], 0
jle loc_4D887
movaps xmm2, xmm1
movaps xmm1, [rsp+0D8h+var_78]
subps xmm1, [rsp+0D8h+var_48]
movaps [rsp+0D8h+var_78], xmm1
movss xmm1, [rsp+0D8h+var_D4]
subss xmm1, [rsp+0D8h+var_D0]
movss [rsp+0D8h+var_D4], xmm1
movaps xmm1, xmm0
addss xmm1, cs:dword_294394
andps xmm1, xmm2
andnps xmm2, xmm0
orps xmm2, xmm1
movaps [rsp+0D8h+var_B8], xmm2
xor r13d, r13d
xor ebp, ebp
loc_4D7CC:
mov r14, [r15+30h]
cmp byte ptr [r14+r13+5], 1
jnz loc_4D873
movss xmm0, dword ptr [r14+r13]
movss xmm1, dword ptr [r15+8]
movss xmm2, dword ptr [r15+0Ch]
subss xmm0, xmm1
subss xmm2, xmm1
divss xmm0, xmm2
xorps xmm1, xmm1
ucomiss xmm1, xmm0
ja short loc_4D873
ucomiss xmm0, cs:flt_28F008
ja short loc_4D873
movss xmm1, [rsp+0D8h+var_D4]
mulss xmm1, xmm0
unpcklps xmm0, xmm0
mulps xmm0, [rsp+0D8h+var_78]
addps xmm0, [rsp+0D8h+var_48]
addss xmm1, [rsp+0D8h+var_D0]
movlps [rsp+0D8h+var_C8], xmm0
movss [rsp+0D8h+var_C0], xmm1
lea rdi, [rsp+0D8h+var_C8]; this
call _ZN8ImPlot3D12PlotToPixelsERK13ImPlot3DPoint; ImPlot3D::PlotToPixels(ImPlot3DPoint const&)
movsxd rax, dword ptr [r14+r13+14h]
mov rcx, [r15+30h]
lea rax, [rax+rax*2]
movsxd rdx, dword ptr [rcx+rax*8+10h]
add rdx, [r15+40h]
addps xmm0, [rsp+0D8h+var_A8]
mov rdi, [rsp+0D8h+var_50]
movaps xmm1, [rsp+0D8h+var_B8]
mov esi, [rsp+0D8h+var_CC]
xor ecx, ecx
call _ZN8ImPlot3D14AddTextRotatedEP10ImDrawList6ImVec2fjPKcS4_; ImPlot3D::AddTextRotated(ImDrawList *,ImVec2,float,uint,char const*,char const*)
loc_4D873:
inc rbp
movsxd rax, dword ptr [r15+28h]
add r13, 18h
cmp rbp, rax
jl loc_4D7CC
loc_4D887:
inc rbx
cmp rbx, 3
jnz loc_4D4F6
add rsp, 0A8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| void ImPlot3D::RenderTickLabels(ImDrawList *a1, long long a2, long long a3, long long a4, long long a5)
{
const double *v6; // rcx
long long i; // rbx
long long v8; // rax
long long v9; // rcx
long long v10; // rsi
__m128 v11; // xmm4
__m128 v12; // xmm2
__m128 v13; // xmm1
__m128 v14; // xmm0
__m128 v15; // xmm2
__m128 v16; // xmm0
__m128 v17; // xmm1
__m128 v18; // xmm5
__m128 v19; // xmm6
float v20; // xmm0_4
float v21; // xmm1_4
double v22; // xmm0_8
__m128 v23; // xmm3
__m128 v24; // xmm0
__m128 v25; // xmm3
long long v26; // r15
__m128 v27; // xmm1
__m128 v28; // xmm2
__m128 v29; // xmm2
__m128 v30; // xmm0
__m128 v31; // xmm1
__m128 v32; // xmm1
__m128 v33; // xmm0
__m128 v34; // xmm2
__m128 v35; // xmm0
__m128 v36; // rt1
__m128 v37; // xmm1
__m128 v38; // xmm2
__m128 v39; // xmm1
long long v40; // r13
long long v41; // rbp
long long v42; // r14
__m128 v43; // xmm0
float v44; // xmm1_4
__m128 v45; // xmm0
float v46; // [rsp+4h] [rbp-D4h]
float v47; // [rsp+4h] [rbp-D4h]
float v48; // [rsp+8h] [rbp-D0h]
unsigned int v49; // [rsp+Ch] [rbp-CCh]
__m128 v50; // [rsp+10h] [rbp-C8h] BYREF
__m128 v51; // [rsp+20h] [rbp-B8h]
__m128 v52; // [rsp+30h] [rbp-A8h]
long long v53; // [rsp+48h] [rbp-90h]
__m128 v54; // [rsp+50h] [rbp-88h]
__m128 v55; // [rsp+60h] [rbp-78h]
long long v56; // [rsp+70h] [rbp-68h]
long long v57; // [rsp+78h] [rbp-60h]
long long v58; // [rsp+80h] [rbp-58h]
ImDrawList *v59; // [rsp+88h] [rbp-50h]
__m128 v60; // [rsp+90h] [rbp-48h]
v58 = a5;
v57 = a4;
v56 = a3;
v59 = a1;
if ( *((float *)ImPlot3D::GImPlot3D + 107) == -1.0 )
v6 = (const double *)(ImGui::GetStyleColorVec4(0LL, a2) + 8);
else
v6 = (const double *)((char *)ImPlot3D::GImPlot3D + 424);
v50 = _mm_loadh_ps(v6);
v49 = ImGui::ColorConvertFloat4ToU32(&v50);
v53 = a2 + 120;
for ( i = 0LL; i != 3; ++i )
{
if ( (*(_BYTE *)(v53 + 112 * i) & 8) == 0 )
{
v8 = *(int *)(v58 + 8 * i);
v9 = *(int *)(v58 + 8 * i + 4);
if ( (_DWORD)v8 != (_DWORD)v9 )
{
v48 = *(float *)(v56 + 12 * v8 + 8);
v10 = 3 * v9;
v60 = (__m128)*(unsigned long long *)(v56 + 12 * v8);
v55 = (__m128)*(unsigned long long *)(v56 + 12 * v9);
v46 = *(float *)(v56 + 12 * v9 + 8);
v11 = (__m128)*(unsigned long long *)(v57 + 8 * v9);
v12 = _mm_sub_ps(v11, (__m128)*(unsigned long long *)(v57 + 8 * v8));
v13 = _mm_mul_ps(v12, v12);
v14 = v12;
v14.m128_f32[0] = (float)(v12.m128_f32[0] * v12.m128_f32[0]) + _mm_shuffle_ps(v13, v13, 85).m128_f32[0];
v52 = (__m128)*(unsigned long long *)(v57 + 8 * v8);
v54 = v11;
if ( v14.m128_f32[0] < 0.0 )
{
v51 = v12;
*(double *)v14.m128_u64 = sqrtf(v56, v10);
v12 = v51;
}
else
{
v14.m128_f32[0] = fsqrt(v14.m128_f32[0]);
}
v15 = _mm_div_ps(v12, _mm_shuffle_ps(v14, v14, 0));
if ( v14.m128_f32[0] == 0.0 )
v15 = (__m128)0x3F800000u;
v51 = v15;
v16 = (__m128)*(unsigned int *)(a2 + 352);
v17 = _mm_mul_ps(
_mm_add_ps(
_mm_unpacklo_ps(*(__m128 *)(a2 + 132), (__m128)*(unsigned int *)(a2 + 244)),
_mm_unpacklo_ps(*(__m128 *)(a2 + 128), (__m128)*(unsigned int *)(a2 + 240))),
(__m128)xmmword_2943F0);
v16.m128_f32[0] = (float)(v16.m128_f32[0] + *(float *)(a2 + 356)) * 0.5;
_mm_storel_ps((double *)v50.m128_u64, v17);
v50.m128_i32[2] = v16.m128_i32[0];
ImPlot3D::PlotToPixels((ImPlot3D *)&v50, (const ImPlot3DPoint *)v10, v16, v17.m128_f32[0]);
v18 = _mm_add_ps(v52, v54);
v19 = _mm_shuffle_ps(v18, v18, 85);
v18.m128_f32[0] = (float)(v18.m128_f32[0] * 0.5) - v16.m128_f32[0];
v19.m128_f32[0] = (float)(v19.m128_f32[0] * 0.5) - _mm_shuffle_ps(v16, v16, 85).m128_f32[0];
v20 = (float)(v18.m128_f32[0] * v18.m128_f32[0]) + (float)(v19.m128_f32[0] * v19.m128_f32[0]);
if ( v20 < 0.0 )
{
v52 = v18;
v54 = v19;
v22 = sqrtf(&v50, v10);
v19.m128_i32[0] = v54.m128_i32[0];
v18.m128_i32[0] = v52.m128_i32[0];
v21 = *(float *)&v22;
}
else
{
v21 = fsqrt(v20);
}
v23 = _mm_shuffle_ps(v51, v51, 85);
v24 = _mm_xor_ps(v23, (__m128)xmmword_293610);
if ( (float)((float)((float)(v18.m128_f32[0] / v21) * v24.m128_f32[0])
+ (float)((float)(v19.m128_f32[0] / v21) * v51.m128_f32[0])) < 0.0 )
v25 = _mm_unpacklo_ps(v23, _mm_xor_ps(v51, (__m128)xmmword_293610));
else
v25 = _mm_unpacklo_ps(v24, v51);
v26 = v53 + 112 * i;
v52 = _mm_mul_ps(v25, (__m128)xmmword_294460);
*(double *)v24.m128_u64 = atan2f(*(double *)v24.m128_u64, *(double *)v51.m128_u64);
v24.m128_f32[0] = v24.m128_f32[0] + 1.5707964;
v27 = v24;
v27.m128_f32[0] = v24.m128_f32[0] + -6.2831855;
v28 = _mm_cmplt_ss((__m128)0x40490FDBu, v24);
v29 = _mm_or_ps(_mm_andnot_ps(v28, v24), _mm_and_ps(v27, v28));
v30 = v29;
v30.m128_f32[0] = v29.m128_f32[0] + 6.2831855;
v31 = _mm_cmplt_ss(v29, (__m128)0xC0490FDB);
v32 = _mm_or_ps(_mm_andnot_ps(v31, v29), _mm_and_ps(v30, v31));
v33 = _mm_cmplt_ss((__m128)0x3FC90FDBu, v32);
v34 = v32;
v34.m128_f32[0] = v32.m128_f32[0] + -3.1415927;
v35 = _mm_or_ps(_mm_andnot_ps(v33, v32), _mm_and_ps(v34, v33));
v36.m128_i32[0] = -1077342245;
v37 = _mm_cmplt_ss(v35, v36);
if ( *(int *)(v26 + 40) > 0 )
{
v38 = v37;
v55 = _mm_sub_ps(v55, v60);
v47 = v46 - v48;
v39 = v35;
v39.m128_f32[0] = v35.m128_f32[0] + 3.1415927;
v51 = _mm_or_ps(_mm_andnot_ps(v38, v35), _mm_and_ps(v39, v38));
v40 = 0LL;
v41 = 0LL;
do
{
v42 = *(_QWORD *)(v26 + 48);
if ( *(_BYTE *)(v42 + v40 + 5) == 1 )
{
v43 = (__m128)*(unsigned int *)(v42 + v40);
v43.m128_f32[0] = (float)(v43.m128_f32[0] - *(float *)(v26 + 8))
/ (float)(*(float *)(v26 + 12) - *(float *)(v26 + 8));
if ( v43.m128_f32[0] >= 0.0 && v43.m128_f32[0] <= 1.0 )
{
v44 = v47 * v43.m128_f32[0];
v45 = _mm_add_ps(_mm_mul_ps(_mm_unpacklo_ps(v43, v43), v55), v60);
_mm_storel_ps((double *)v50.m128_u64, v45);
v50.m128_f32[2] = v44 + v48;
ImPlot3D::PlotToPixels((ImPlot3D *)&v50, (const ImPlot3DPoint *)v10, v45, v44 + v48);
v10 = v49;
ImPlot3D::AddTextRotated(
v59,
v49,
(const char *)(*(_QWORD *)(v26 + 64)
+ *(int *)(*(_QWORD *)(v26 + 48) + 24LL * *(int *)(v42 + v40 + 20) + 16)),
0LL,
_mm_add_ps(v45, v52),
v51);
}
}
++v41;
v40 += 24LL;
}
while ( v41 < *(int *)(v26 + 40) );
}
}
}
}
}
| RenderTickLabels:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xa8
MOV qword ptr [RSP + 0x80],R8
MOV qword ptr [RSP + 0x78],RCX
MOV qword ptr [RSP + 0x70],RDX
MOV R12,RSI
MOV qword ptr [RSP + 0x88],RDI
MOV RCX,qword ptr [0x00436c98]
MOVSS XMM0,dword ptr [RCX + 0x1ac]
UCOMISS XMM0,dword ptr [0x0038f004]
JNZ 0x0014d4c4
JP 0x0014d4c4
XOR EDI,EDI
CALL 0x00315eee
MOV RCX,RAX
ADD RCX,0x8
JMP 0x0014d4d2
LAB_0014d4c4:
LEA RAX,[RCX + 0x1a0]
ADD RCX,0x1a8
LAB_0014d4d2:
MOVSD XMM0,qword ptr [RAX]
MOVHPS XMM0,qword ptr [RCX]
LEA RDI,[RSP + 0x10]
MOVUPS xmmword ptr [RDI],XMM0
CALL 0x00313cfe
MOV dword ptr [RSP + 0xc],EAX
LEA RAX,[R12 + 0x78]
MOV qword ptr [RSP + 0x48],RAX
XOR EBX,EBX
LAB_0014d4f6:
IMUL R15,RBX,0x70
MOV RAX,qword ptr [RSP + 0x48]
TEST byte ptr [RAX + R15*0x1],0x8
JNZ 0x0014d887
MOV RCX,qword ptr [RSP + 0x80]
MOVSXD RAX,dword ptr [RCX + RBX*0x8]
MOVSXD RCX,dword ptr [RCX + RBX*0x8 + 0x4]
CMP EAX,ECX
JZ 0x0014d887
LEA RDX,[RAX + RAX*0x2]
MOV RDI,qword ptr [RSP + 0x70]
MOVSS XMM0,dword ptr [RDI + RDX*0x4 + 0x8]
MOVSS dword ptr [RSP + 0x8],XMM0
LEA RSI,[RCX + RCX*0x2]
MOVSD XMM0,qword ptr [RDI + RDX*0x4]
MOVAPS xmmword ptr [RSP + 0x90],XMM0
MOVSD XMM0,qword ptr [RDI + RSI*0x4]
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVSS XMM0,dword ptr [RDI + RSI*0x4 + 0x8]
MOVSS dword ptr [RSP + 0x4],XMM0
MOV RDX,qword ptr [RSP + 0x78]
MOVSD XMM3,qword ptr [RDX + RAX*0x8]
MOVSD XMM4,qword ptr [RDX + RCX*0x8]
MOVAPS XMM2,XMM4
SUBPS XMM2,XMM3
MOVAPS XMM1,XMM2
MULPS XMM1,XMM2
SHUFPS XMM1,XMM1,0x55
MOVAPS XMM0,XMM2
MULSS XMM0,XMM2
ADDSS XMM0,XMM1
UCOMISS XMM0,dword ptr [0x0038f054]
MOVAPS xmmword ptr [RSP + 0x30],XMM3
MOVAPS xmmword ptr [RSP + 0x50],XMM4
JC 0x0014d5a2
SQRTSS XMM0,XMM0
JMP 0x0014d5b1
LAB_0014d5a2:
MOVAPS xmmword ptr [RSP + 0x20],XMM2
CALL 0x00110240
MOVAPS XMM2,xmmword ptr [RSP + 0x20]
LAB_0014d5b1:
UCOMISS XMM0,dword ptr [0x0038f054]
SHUFPS XMM0,XMM0,0x0
DIVPS XMM2,XMM0
JNZ 0x0014d5cb
JP 0x0014d5cb
MOVSS XMM2,dword ptr [0x0038f008]
LAB_0014d5cb:
MOVAPS xmmword ptr [RSP + 0x20],XMM2
MOVUPS XMM0,xmmword ptr [R12 + 0x80]
MOVUPS XMM1,xmmword ptr [R12 + 0x84]
MOVSS XMM2,dword ptr [R12 + 0xf0]
UNPCKLPS XMM0,XMM2
MOVSS XMM2,dword ptr [R12 + 0xf4]
UNPCKLPS XMM1,XMM2
ADDPS XMM1,XMM0
MOVSS XMM0,dword ptr [R12 + 0x160]
ADDSS XMM0,dword ptr [R12 + 0x164]
MULPS XMM1,xmmword ptr [0x003943f0]
MOVSS XMM2,dword ptr [0x0038f020]
MULSS XMM0,XMM2
MOVLPS qword ptr [RSP + 0x10],XMM1
MOVSS dword ptr [RSP + 0x18],XMM0
LEA RDI,[RSP + 0x10]
CALL 0x0014cd88
MOVAPS XMM5,xmmword ptr [RSP + 0x30]
ADDPS XMM5,xmmword ptr [RSP + 0x50]
MOVAPS XMM6,XMM5
SHUFPS XMM6,XMM5,0x55
MOVSS XMM1,dword ptr [0x0038f020]
MULSS XMM5,XMM1
MULSS XMM6,XMM1
SUBSS XMM5,XMM0
SHUFPS XMM0,XMM0,0x55
SUBSS XMM6,XMM0
MOVAPS XMM1,XMM6
MULSS XMM1,XMM6
MOVAPS XMM0,XMM5
MULSS XMM0,XMM5
ADDSS XMM0,XMM1
UCOMISS XMM0,dword ptr [0x0038f054]
JC 0x0014d68c
XORPS XMM1,XMM1
SQRTSS XMM1,XMM0
JMP 0x0014d6a8
LAB_0014d68c:
MOVAPS xmmword ptr [RSP + 0x30],XMM5
MOVAPS xmmword ptr [RSP + 0x50],XMM6
CALL 0x00110240
MOVAPS XMM6,xmmword ptr [RSP + 0x50]
MOVAPS XMM5,xmmword ptr [RSP + 0x30]
MOVAPS XMM1,XMM0
LAB_0014d6a8:
MOVAPS XMM2,xmmword ptr [0x00393610]
MOVAPS XMM4,xmmword ptr [RSP + 0x20]
MOVAPS XMM3,XMM4
SHUFPS XMM3,XMM4,0x55
MOVAPS XMM0,XMM3
XORPS XMM0,XMM2
DIVSS XMM5,XMM1
DIVSS XMM6,XMM1
MULSS XMM6,XMM4
MULSS XMM5,XMM0
ADDSS XMM5,XMM6
XORPS XMM1,XMM1
UCOMISS XMM1,XMM5
JA 0x0014d6e5
MOVAPS XMM3,XMM0
UNPCKLPS XMM3,XMM4
JMP 0x0014d6ee
LAB_0014d6e5:
MOVAPS XMM1,XMM4
XORPS XMM1,XMM2
UNPCKLPS XMM3,XMM1
LAB_0014d6ee:
ADD R15,qword ptr [RSP + 0x48]
MULPS XMM3,xmmword ptr [0x00394460]
MOVAPS xmmword ptr [RSP + 0x30],XMM3
MOVAPS XMM1,XMM4
CALL 0x0010fda0
MOVSS XMM3,dword ptr [0x0039438c]
ADDSS XMM0,XMM3
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [0x00394390]
MOVSS XMM2,dword ptr [0x00394394]
CMPLTSS XMM2,XMM0
ANDPS XMM1,XMM2
ANDNPS XMM2,XMM0
ORPS XMM2,XMM1
MOVAPS XMM0,XMM2
ADDSS XMM0,dword ptr [0x00394398]
MOVAPS XMM1,XMM2
MOVSS XMM4,dword ptr [0x0039439c]
CMPLTSS XMM1,XMM4
ANDPS XMM0,XMM1
ANDNPS XMM1,XMM2
ORPS XMM1,XMM0
MOVAPS XMM0,XMM3
CMPLTSS XMM0,XMM1
MOVAPS XMM2,XMM1
ADDSS XMM2,XMM4
ANDPS XMM2,XMM0
ANDNPS XMM0,XMM1
ORPS XMM0,XMM2
MOVAPS XMM1,XMM0
CMPLTSS XMM1,dword ptr [0x003943a0]
CMP dword ptr [R15 + 0x28],0x0
JLE 0x0014d887
MOVAPS XMM2,XMM1
MOVAPS XMM1,xmmword ptr [RSP + 0x60]
SUBPS XMM1,xmmword ptr [RSP + 0x90]
MOVAPS xmmword ptr [RSP + 0x60],XMM1
MOVSS XMM1,dword ptr [RSP + 0x4]
SUBSS XMM1,dword ptr [RSP + 0x8]
MOVSS dword ptr [RSP + 0x4],XMM1
MOVAPS XMM1,XMM0
ADDSS XMM1,dword ptr [0x00394394]
ANDPS XMM1,XMM2
ANDNPS XMM2,XMM0
ORPS XMM2,XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM2
XOR R13D,R13D
XOR EBP,EBP
LAB_0014d7cc:
MOV R14,qword ptr [R15 + 0x30]
CMP byte ptr [R14 + R13*0x1 + 0x5],0x1
JNZ 0x0014d873
MOVSS XMM0,dword ptr [R14 + R13*0x1]
MOVSS XMM1,dword ptr [R15 + 0x8]
MOVSS XMM2,dword ptr [R15 + 0xc]
SUBSS XMM0,XMM1
SUBSS XMM2,XMM1
DIVSS XMM0,XMM2
XORPS XMM1,XMM1
UCOMISS XMM1,XMM0
JA 0x0014d873
UCOMISS XMM0,dword ptr [0x0038f008]
JA 0x0014d873
MOVSS XMM1,dword ptr [RSP + 0x4]
MULSS XMM1,XMM0
UNPCKLPS XMM0,XMM0
MULPS XMM0,xmmword ptr [RSP + 0x60]
ADDPS XMM0,xmmword ptr [RSP + 0x90]
ADDSS XMM1,dword ptr [RSP + 0x8]
MOVLPS qword ptr [RSP + 0x10],XMM0
MOVSS dword ptr [RSP + 0x18],XMM1
LEA RDI,[RSP + 0x10]
CALL 0x0014cd88
MOVSXD RAX,dword ptr [R14 + R13*0x1 + 0x14]
MOV RCX,qword ptr [R15 + 0x30]
LEA RAX,[RAX + RAX*0x2]
MOVSXD RDX,dword ptr [RCX + RAX*0x8 + 0x10]
ADD RDX,qword ptr [R15 + 0x40]
ADDPS XMM0,xmmword ptr [RSP + 0x30]
MOV RDI,qword ptr [RSP + 0x88]
MOVAPS XMM1,xmmword ptr [RSP + 0x20]
MOV ESI,dword ptr [RSP + 0xc]
XOR ECX,ECX
CALL 0x0014b11a
LAB_0014d873:
INC RBP
MOVSXD RAX,dword ptr [R15 + 0x28]
ADD R13,0x18
CMP RBP,RAX
JL 0x0014d7cc
LAB_0014d887:
INC RBX
CMP RBX,0x3
JNZ 0x0014d4f6
ADD RSP,0xa8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* ImPlot3D::RenderTickLabels(ImDrawList*, ImPlot3DPlot const&, ImPlot3DPoint const*, ImVec2 const*,
int const (*) [2]) */
void ImPlot3D::RenderTickLabels
(ImDrawList *param_1,ImPlot3DPlot *param_2,ImPlot3DPoint *param_3,ImVec2 *param_4,
int *param_5)
{
float fVar1;
float fVar2;
long lVar3;
ImPlot3DPlot *pIVar4;
int4 uVar5;
int8 *puVar6;
long lVar7;
int8 *puVar8;
long lVar9;
long lVar10;
long lVar11;
float fVar12;
float fVar13;
float __y;
int8 uVar14;
float fVar16;
int1 auVar15 [16];
int1 extraout_var [12];
float fVar17;
float fVar18;
float fVar19;
int8 local_c8;
int8 uStack_c0;
int1 local_b8 [8];
int4 uStack_b0;
int4 uStack_ac;
int8 local_a8;
int8 uStack_a0;
ImPlot3DPlot *local_90;
int8 local_88;
int8 uStack_80;
int8 local_78;
int8 uStack_70;
ImPlot3DPoint *local_68;
ImVec2 *local_60;
int *local_58;
ImDrawList *local_50;
int8 local_48;
int8 uStack_40;
local_68 = param_3;
local_60 = param_4;
local_58 = param_5;
local_50 = param_1;
if ((*(float *)(GImPlot3D + 0x1ac) != DAT_0038f004) ||
(NAN(*(float *)(GImPlot3D + 0x1ac)) || NAN(DAT_0038f004))) {
puVar6 = (int8 *)(GImPlot3D + 0x1a0);
puVar8 = (int8 *)(GImPlot3D + 0x1a8);
}
else {
puVar6 = (int8 *)ImGui::GetStyleColorVec4(0);
puVar8 = puVar6 + 1;
}
local_c8 = *puVar6;
uStack_c0 = *puVar8;
uVar5 = ImGui::ColorConvertFloat4ToU32((ImVec4 *)&local_c8);
local_90 = param_2 + 0x78;
lVar10 = 0;
do {
lVar11 = lVar10 * 0x70;
if (((byte)local_90[lVar11] & 8) == 0) {
lVar7 = (long)local_58[lVar10 * 2];
lVar9 = (long)local_58[lVar10 * 2 + 1];
if (local_58[lVar10 * 2] != local_58[lVar10 * 2 + 1]) {
fVar1 = *(float *)(local_68 + lVar7 * 0xc + 8);
local_48 = *(int8 *)(local_68 + lVar7 * 0xc);
uStack_40 = 0;
local_78 = *(int8 *)(local_68 + lVar9 * 0xc);
uStack_70 = 0;
fVar2 = *(float *)(local_68 + lVar9 * 0xc + 8);
local_a8 = *(int8 *)(local_60 + lVar7 * 8);
local_88 = *(int8 *)(local_60 + lVar9 * 8);
local_b8._0_4_ = (float)local_88 - (float)local_a8;
local_b8._4_4_ = (float)((ulong)local_88 >> 0x20) - (float)((ulong)local_a8 >> 0x20);
register0x00001288 = 0;
fVar12 = (float)local_b8._0_4_ * (float)local_b8._0_4_ +
(float)local_b8._4_4_ * (float)local_b8._4_4_;
uStack_a0 = 0;
uStack_80 = 0;
if (fVar12 < DAT_0038f054) {
fVar12 = sqrtf(fVar12);
}
else {
fVar12 = SQRT(fVar12);
}
auVar15._4_4_ = fVar12;
auVar15._0_4_ = fVar12;
auVar15._8_4_ = fVar12;
auVar15._12_4_ = fVar12;
_local_b8 = divps(_local_b8,auVar15);
if ((fVar12 == DAT_0038f054) && (!NAN(fVar12) && !NAN(DAT_0038f054))) {
_local_b8 = ZEXT416((uint)DAT_0038f008);
}
local_c8 = CONCAT44((*(float *)(param_2 + 0xf4) + *(float *)(param_2 + 0xf0)) *
DAT_003943f0._4_4_,
(*(float *)(param_2 + 0x84) + *(float *)(param_2 + 0x80)) *
(float)DAT_003943f0);
uStack_c0 = CONCAT44(uStack_c0._4_4_,
(*(float *)(param_2 + 0x160) + *(float *)(param_2 + 0x164)) *
DAT_0038f020);
uVar14 = PlotToPixels((ImPlot3DPoint *)&local_c8);
local_a8._4_4_ = local_a8._4_4_ + local_88._4_4_;
local_a8._0_4_ = ((float)local_a8 + (float)local_88) * DAT_0038f020 - (float)uVar14;
fVar12 = local_a8._4_4_ * DAT_0038f020 - (float)((ulong)uVar14 >> 0x20);
fVar13 = (float)local_a8 * (float)local_a8 + fVar12 * fVar12;
if (fVar13 < DAT_0038f054) {
uStack_a0 = CONCAT44(uStack_a0._4_4_ + uStack_80._4_4_,(float)uStack_a0 + (float)uStack_80
);
local_88 = CONCAT44(local_a8._4_4_,fVar12);
uStack_80 = CONCAT44(local_a8._4_4_,local_a8._4_4_);
fVar13 = sqrtf(fVar13);
fVar12 = (float)local_88;
}
else {
fVar13 = SQRT(fVar13);
}
pIVar4 = local_90;
__y = (float)(local_b8._4_4_ ^ _DAT_00393610);
fVar16 = (float)(local_b8._4_4_ ^ _UNK_00393614);
fVar17 = __y;
fVar18 = (float)local_b8._0_4_;
fVar19 = (float)local_b8._4_4_;
if (((float)local_a8 / fVar13) * __y + (fVar12 / fVar13) * (float)local_b8._0_4_ < 0.0) {
fVar17 = (float)local_b8._4_4_;
fVar18 = (float)(local_b8._0_4_ ^ _DAT_00393610);
fVar16 = (float)local_b8._4_4_;
fVar19 = (float)(local_b8._4_4_ ^ _UNK_00393614);
}
local_a8 = CONCAT44(fVar18 * _UNK_00394464,fVar17 * _DAT_00394460);
uStack_a0 = CONCAT44(fVar19 * _UNK_0039446c,fVar16 * _UNK_00394468);
fVar12 = atan2f(__y,(float)local_b8._0_4_);
fVar12 = fVar12 + DAT_0039438c;
fVar12 = (float)(~-(uint)(DAT_00394394 < fVar12) & (uint)fVar12 |
(uint)(fVar12 + _DAT_00394390) & -(uint)(DAT_00394394 < fVar12));
fVar12 = (float)(~-(uint)(fVar12 < DAT_0039439c) & (uint)fVar12 |
(uint)(fVar12 + DAT_00394398) & -(uint)(fVar12 < DAT_0039439c));
fVar12 = (float)(~-(uint)(DAT_0039438c < fVar12) & (uint)fVar12 |
(uint)(fVar12 + DAT_0039439c) & -(uint)(DAT_0039438c < fVar12));
if (0 < *(int *)(pIVar4 + lVar11 + 0x28)) {
local_78._0_4_ = (float)local_78 - (float)local_48;
local_78._4_4_ = local_78._4_4_ - local_48._4_4_;
uStack_70 = CONCAT44(uStack_70._4_4_ - uStack_40._4_4_,(float)uStack_70 - (float)uStack_40
);
local_b8._4_4_ = extraout_var._0_4_;
local_b8._0_4_ =
~-(uint)(fVar12 < DAT_003943a0) & (uint)fVar12 |
(uint)(fVar12 + DAT_00394394) & -(uint)(fVar12 < DAT_003943a0);
uStack_b0 = extraout_var._4_4_;
uStack_ac = extraout_var._8_4_;
lVar9 = 0;
lVar7 = 0;
do {
lVar3 = *(long *)(pIVar4 + lVar11 + 0x30);
if (((*(char *)(lVar3 + 5 + lVar9) == '\x01') &&
(fVar12 = (*(float *)(lVar3 + lVar9) - *(float *)(pIVar4 + lVar11 + 8)) /
(*(float *)(pIVar4 + lVar11 + 0xc) - *(float *)(pIVar4 + lVar11 + 8)),
0.0 <= fVar12)) && (fVar12 <= DAT_0038f008)) {
local_c8 = CONCAT44(fVar12 * local_78._4_4_ + local_48._4_4_,
fVar12 * (float)local_78 + (float)local_48);
uStack_c0 = CONCAT44(uStack_c0._4_4_,(fVar2 - fVar1) * fVar12 + fVar1);
PlotToPixels((ImPlot3DPoint *)&local_c8);
AddTextRotated(local_50,uVar5,
(long)*(int *)(*(long *)(pIVar4 + lVar11 + 0x30) + 0x10 +
(long)*(int *)(lVar3 + 0x14 + lVar9) * 0x18) +
*(long *)(pIVar4 + lVar11 + 0x40),0);
}
lVar7 = lVar7 + 1;
lVar9 = lVar9 + 0x18;
} while (lVar7 < *(int *)(pIVar4 + lVar11 + 0x28));
}
}
}
lVar10 = lVar10 + 1;
} while (lVar10 != 3);
return;
}
| |
22,274 | 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>>::end_object() | monkey531[P]llama/common/json.hpp | bool end_object()
{
if (ref_stack.back())
{
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
else
{
ref_stack.back()->set_parents();
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
{
// remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
{
if (it->is_discarded())
{
ref_stack.back()->erase(it);
break;
}
}
}
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>>::end_object():
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x8, %rdi
callq 0xf4080
cmpq $0x0, (%rax)
je 0xf2db8
movq 0x18(%rsp), %rdi
movq %rdi, %rax
addq $0x80, %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0xf3a90
movq 0x18(%rsp), %rdi
subl $0x1, %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0xf4080
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movq (%rax), %rcx
movl $0x1, %edx
callq 0xf3a30
testb $0x1, %al
jne 0xf2da0
movq 0x18(%rsp), %rsi
addq $0xa8, %rsi
leaq 0xa0(%rsp), %rdi
callq 0xcb4a0
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xcafc0
leaq 0xa0(%rsp), %rdi
callq 0xcb040
jmp 0xf2db6
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rdi
callq 0xdc930
jmp 0xf2db8
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf43d0
testb $0x1, %al
jne 0xf2dcc
jmp 0xf2ded
leaq 0xf4a13(%rip), %rdi # 0x1e77e6
movl $0x1bbd, %esi # imm = 0x1BBD
leaq 0xf0854(%rip), %rdx # 0x1e3633
leaq 0xf5eed(%rip), %rcx # 0x1e8cd3
movb $0x0, %al
callq 0x56d30
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x6a880
testb $0x1, %al
jne 0xf2e01
jmp 0xf2e22
leaq 0xf49de(%rip), %rdi # 0x1e77e6
movl $0x1bbe, %esi # imm = 0x1BBE
leaq 0xf081f(%rip), %rdx # 0x1e3633
leaq 0xf5e32(%rip), %rcx # 0x1e8c4d
movb $0x0, %al
callq 0x56d30
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4eb0
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0xf3a10
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf43d0
testb $0x1, %al
jne 0xf2f49
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
cmpq $0x0, (%rax)
je 0xf2f49
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rdi
callq 0xf4ed0
testb $0x1, %al
jne 0xf2e8b
jmp 0xf2f49
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rsi
leaq 0x80(%rsp), %rdi
callq 0xf4f10
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rsi
leaq 0x60(%rsp), %rdi
callq 0xf4f80
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xf4f50
testb $0x1, %al
jne 0xf2edc
jmp 0xf2f47
leaq 0x80(%rsp), %rdi
callq 0xf4fc0
movq %rax, %rdi
callq 0xf06a0
testb $0x1, %al
jne 0xf2ef7
jmp 0xf2f33
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xf4080
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xf5780
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xf5230
jmp 0xf2f47
jmp 0xf2f35
leaq 0x80(%rsp), %rdi
callq 0xf57c0
jmp 0xf2ea9
jmp 0xf2f49
movb $0x1, %al
andb $0x1, %al
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10end_objectEv:
sub rsp, 0B8h
mov qword ptr [rsp+0B8h+var_8], rdi; int
mov rdi, qword ptr [rsp+0B8h+var_8]
mov qword ptr [rsp+0B8h+var_A0], rdi; 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)
cmp qword ptr [rax], 0
jz loc_F2DB8
mov rdi, qword ptr [rsp+0B8h+var_A0]
mov rax, rdi
add rax, 80h
mov [rsp+0B8h+var_B0], 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, qword ptr [rsp+0B8h+var_A0]
sub eax, 1
mov [rsp+0B8h+var_A4], eax
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+0B8h+var_B0]
mov esi, [rsp+0B8h+var_A4]
mov rcx, [rax]
mov edx, 1
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, 1
jnz short loc_F2DA0
mov rsi, qword ptr [rsp+0B8h+var_A0]
add rsi, 0A8h
lea rdi, [rsp+0B8h+var_18]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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> const&)
mov rdi, qword ptr [rsp+0B8h+var_A0]
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]
lea rsi, [rsp+0B8h+var_18]
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>)
lea rdi, [rsp+0B8h+var_18]
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 short loc_F2DB6
loc_F2DA0:
mov rdi, qword ptr [rsp+0B8h+var_A0]
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 _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE11set_parentsEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parents(void)
loc_F2DB6:
jmp short $+2
loc_F2DB8:
mov rdi, qword ptr [rsp+0B8h+var_A0]
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_F2DCC
jmp short loc_F2DED
loc_F2DCC:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1BBDh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov al, 0
call _ggml_abort
loc_F2DED:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 20h ; ' '
call _ZNKSt6vectorIbSaIbEE5emptyEv; std::vector<bool>::empty(void)
test al, 1
jnz short loc_F2E01
jmp short loc_F2E22
loc_F2E01:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 1BBEh
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov al, 0
call _ggml_abort
loc_F2E22:
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 8
call _ZNSt6vectorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISE_EE8pop_backEv; 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> *>>::pop_back(void)
mov rdi, qword ptr [rsp+0B8h+var_A0]
add rdi, 20h ; ' '
call _ZNSt6vectorIbSaIbEE8pop_backEv; std::vector<bool>::pop_back(void)
mov rdi, qword ptr [rsp+0B8h+var_A0]
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 loc_F2F49
mov rdi, qword ptr [rsp+0B8h+var_A0]
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_F2F49
mov rdi, qword ptr [rsp+0B8h+var_A0]
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_IhSaIhEEvE13is_structuredEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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_structured(void)
test al, 1
jnz short loc_F2E8B
jmp loc_F2F49
loc_F2E8B:
mov rdi, qword ptr [rsp+0B8h+var_A0]
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 rsi, [rax]
lea rdi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5beginEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::begin(void)
loc_F2EA9:
mov rdi, qword ptr [rsp+0B8h+var_A0]
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 rsi, [rax]
lea rdi, [rsp+0B8h+var_58]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
lea rdi, [rsp+0B8h+var_38]; int
lea rsi, [rsp+0B8h+var_58]; void *
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
test al, 1
jnz short loc_F2EDC
jmp short loc_F2F47
loc_F2EDC:
lea rdi, [rsp+0B8h+var_38]; int
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator->(void)
mov rdi, rax
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE12is_discardedEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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_discarded(void)
test al, 1
jnz short loc_F2EF7
jmp short loc_F2F33
loc_F2EF7:
mov rdi, qword ptr [rsp+0B8h+var_A0]
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 [rsp+0B8h+var_B8], rax; void *
lea rdi, [rsp+0B8h+var_78]
lea rsi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERKSG_; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::iter_impl(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)
mov rsi, [rsp+0B8h+var_B8]
lea rdi, [rsp+0B8h+var_98]; int
lea rdx, [rsp+0B8h+var_78]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
jmp short loc_F2F47
loc_F2F33:
jmp short $+2
loc_F2F35:
lea rdi, [rsp+0B8h+var_38]
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator++(void)
jmp loc_F2EA9
loc_F2F47:
jmp short $+2
loc_F2F49:
mov al, 1
and al, 1
add rsp, 0B8h
retn
| end_object:
SUB RSP,0xb8
MOV qword ptr [RSP + 0xb0],RDI
MOV RDI,qword ptr [RSP + 0xb0]
MOV qword ptr [RSP + 0x18],RDI
ADD RDI,0x8
CALL 0x001f4080
CMP qword ptr [RAX],0x0
JZ 0x001f2db8
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,RDI
ADD RAX,0x80
MOV qword ptr [RSP + 0x8],RAX
ADD RDI,0x8
CALL 0x001f3a90
MOV RDI,qword ptr [RSP + 0x18]
SUB EAX,0x1
MOV dword ptr [RSP + 0x14],EAX
ADD RDI,0x8
CALL 0x001f4080
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RSP + 0x14]
MOV RCX,qword ptr [RAX]
MOV EDX,0x1
CALL 0x001f3a30
TEST AL,0x1
JNZ 0x001f2da0
MOV RSI,qword ptr [RSP + 0x18]
ADD RSI,0xa8
LEA RDI,[RSP + 0xa0]
CALL 0x001cb4a0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RDI,qword ptr [RAX]
LEA RSI,[RSP + 0xa0]
CALL 0x001cafc0
LEA RDI,[RSP + 0xa0]
CALL 0x001cb040
JMP 0x001f2db6
LAB_001f2da0:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RDI,qword ptr [RAX]
CALL 0x001dc930
LAB_001f2db6:
JMP 0x001f2db8
LAB_001f2db8:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f43d0
TEST AL,0x1
JNZ 0x001f2dcc
JMP 0x001f2ded
LAB_001f2dcc:
LEA RDI,[0x2e77e6]
MOV ESI,0x1bbd
LEA RDX,[0x2e3633]
LEA RCX,[0x2e8cd3]
MOV AL,0x0
CALL 0x00156d30
LAB_001f2ded:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x20
CALL 0x0016a880
TEST AL,0x1
JNZ 0x001f2e01
JMP 0x001f2e22
LAB_001f2e01:
LEA RDI,[0x2e77e6]
MOV ESI,0x1bbe
LEA RDX,[0x2e3633]
LEA RCX,[0x2e8c4d]
MOV AL,0x0
CALL 0x00156d30
LAB_001f2e22:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4eb0
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x20
CALL 0x001f3a10
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f43d0
TEST AL,0x1
JNZ 0x001f2f49
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
CMP qword ptr [RAX],0x0
JZ 0x001f2f49
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RDI,qword ptr [RAX]
CALL 0x001f4ed0
TEST AL,0x1
JNZ 0x001f2e8b
JMP 0x001f2f49
LAB_001f2e8b:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RSI,qword ptr [RAX]
LEA RDI,[RSP + 0x80]
CALL 0x001f4f10
LAB_001f2ea9:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RSI,qword ptr [RAX]
LEA RDI,[RSP + 0x60]
CALL 0x001f4f80
LEA RDI,[RSP + 0x80]
LEA RSI,[RSP + 0x60]
CALL 0x001f4f50
TEST AL,0x1
JNZ 0x001f2edc
JMP 0x001f2f47
LAB_001f2edc:
LEA RDI,[RSP + 0x80]
CALL 0x001f4fc0
MOV RDI,RAX
CALL 0x001f06a0
TEST AL,0x1
JNZ 0x001f2ef7
JMP 0x001f2f33
LAB_001f2ef7:
MOV RDI,qword ptr [RSP + 0x18]
ADD RDI,0x8
CALL 0x001f4080
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x40]
LEA RSI,[RSP + 0x80]
CALL 0x001f5780
MOV RSI,qword ptr [RSP]
LEA RDI,[RSP + 0x20]
LEA RDX,[RSP + 0x40]
CALL 0x001f5230
JMP 0x001f2f47
LAB_001f2f33:
JMP 0x001f2f35
LAB_001f2f35:
LEA RDI,[RSP + 0x80]
CALL 0x001f57c0
JMP 0x001f2ea9
LAB_001f2f47:
JMP 0x001f2f49
LAB_001f2f49:
MOV AL,0x1
AND AL,0x1
ADD RSP,0xb8
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> >::end_object() */
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>>
::end_object(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)
{
int8 uVar1;
int iVar2;
long *plVar3;
int8 *puVar4;
ulong uVar5;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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;
int1 local_98 [32];
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
local_78 [32];
int1 local_58 [32];
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
local_38 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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 [16];
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_8 = this;
plVar3 = (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 (*plVar3 != 0) {
iVar2 = 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));
puVar4 = (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));
uVar5 = 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),iVar2 + -1,1,*puVar4);
if ((uVar5 & 1) == 0) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_18,this + 0xa8);
puVar4 = (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));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
*)*puVar4,local_18);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_18);
}
else {
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));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::set_parents();
}
}
uVar5 = 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 ((uVar5 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1bbd,
"GGML_ASSERT(%s) failed","!ref_stack.empty()");
}
uVar5 = std::vector<bool,std::allocator<bool>>::empty
((vector<bool,std::allocator<bool>> *)(this + 0x20));
if ((uVar5 & 1) != 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",0x1bbe,
"GGML_ASSERT(%s) failed","!keep_stack.empty()");
}
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>*>>
::pop_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<bool,std::allocator<bool>>::pop_back
((vector<bool,std::allocator<bool>> *)(this + 0x20));
uVar5 = 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 (((uVar5 & 1) == 0) &&
(plVar3 = (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)), *plVar3 != 0)) {
puVar4 = (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));
uVar5 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_structured((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)*puVar4);
if ((uVar5 & 1) != 0) {
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));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::begin();
while( true ) {
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));
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end();
uVar5 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(local_38,local_58);
if ((uVar5 & 1) == 0) break;
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>
*)iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->(local_38);
uVar5 = basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_discarded(this_00);
if ((uVar5 & 1) != 0) {
puVar4 = (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));
uVar1 = *puVar4;
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::iter_impl(local_78,(iter_impl *)local_38);
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(local_98,uVar1,local_78);
return 1;
}
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(local_38);
}
}
}
return 1;
}
| ||
22,275 | 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>>::end_object() | monkey531[P]llama/common/json.hpp | bool end_object()
{
if (ref_stack.back())
{
if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
{
// discard object
*ref_stack.back() = discarded;
}
else
{
ref_stack.back()->set_parents();
}
}
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(!keep_stack.empty());
ref_stack.pop_back();
keep_stack.pop_back();
if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
{
// remove discarded value
for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
{
if (it->is_discarded())
{
ref_stack.back()->erase(it);
break;
}
}
}
return true;
} | O2 | 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>>::end_object():
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq -0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x55c0e
leaq 0x80(%rbx), %rdi
subq 0x8(%rbx), %rsi
shrq $0x3, %rsi
decl %esi
pushq $0x1
popq %rdx
callq 0x56262
testb %al, %al
jne 0x55c0e
leaq 0xa8(%rbx), %rsi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x46ea2
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rdi
movq %r14, %rsi
callq 0x46ca4
movq %r14, %rdi
callq 0x46ce8
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x55ce2
movq 0x20(%rbx), %rcx
cmpq 0x30(%rbx), %rcx
jne 0x55c30
cmpl $0x0, 0x38(%rbx)
je 0x55cfe
leaq 0x30(%rbx), %rdi
addq $-0x8, %rax
movq %rax, 0x10(%rbx)
callq 0x55a32
movq 0x10(%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x55cd6
movq -0x8(%rax), %rsi
testq %rsi, %rsi
je 0x55cd6
movb (%rsi), %al
decb %al
cmpb $0x1, %al
ja 0x55cd6
movq %rsp, %r14
movq %r14, %rdi
callq 0x56800
leaq 0x20(%rsp), %r15
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rsi
movq %r15, %rdi
callq 0x56830
movq %r14, %rdi
movq %r15, %rsi
callq 0x56826
testb %al, %al
je 0x55cd6
movq %r14, %rdi
callq 0x56856
cmpb $0x9, (%rax)
je 0x55ca6
movq %r14, %rdi
callq 0x56b76
jmp 0x55c70
movq 0x10(%rbx), %rax
movq -0x8(%rax), %rsi
movq (%rsp), %rax
leaq 0x50(%rsp), %rdx
movq %rax, (%rdx)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rdx)
movq 0x18(%rsp), %rax
movq %rax, 0x18(%rdx)
leaq 0x20(%rsp), %rdi
callq 0x56984
movb $0x1, %al
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x47fe2(%rip), %rdi # 0x9dccb
leaq 0x44899(%rip), %rdx # 0x9a589
leaq 0x494c3(%rip), %rcx # 0x9f1ba
movl $0x1bbd, %esi # imm = 0x1BBD
jmp 0x55d18
leaq 0x47fc6(%rip), %rdi # 0x9dccb
leaq 0x4487d(%rip), %rdx # 0x9a589
leaq 0x49421(%rip), %rcx # 0x9f134
movl $0x1bbe, %esi # imm = 0x1BBE
xorl %eax, %eax
callq 0x22ce0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE10end_objectEv:
push r15
push r14
push rbx
sub rsp, 70h
mov rbx, rdi
mov rsi, [rdi+10h]
mov rcx, [rsi-8]
test rcx, rcx
jz short loc_55C0E
lea rdi, [rbx+80h]
sub rsi, [rbx+8]
shr rsi, 3
dec esi
push 1
pop rdx
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
jnz short loc_55C0E
lea rsi, [rbx+0A8h]
lea r14, [rsp+88h+var_48]
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ERKSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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> const&)
mov rax, [rbx+10h]
mov rdi, [rax-8]
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()
loc_55C0E:
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz loc_55CE2
mov rcx, [rbx+20h]
cmp rcx, [rbx+30h]
jnz short loc_55C30
cmp dword ptr [rbx+38h], 0
jz loc_55CFE
loc_55C30:
lea rdi, [rbx+30h]; this
add rax, 0FFFFFFFFFFFFFFF8h
mov [rbx+10h], rax
call _ZNSt18_Bit_iterator_base12_M_bump_downEv; std::_Bit_iterator_base::_M_bump_down(void)
mov rax, [rbx+10h]
cmp [rbx+8], rax
jz loc_55CD6
mov rsi, [rax-8]
test rsi, rsi
jz short loc_55CD6
mov al, [rsi]
dec al
cmp al, 1
ja short loc_55CD6
mov r14, rsp
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5beginEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::begin(void)
lea r15, [rsp+88h+var_68]
loc_55C70:
mov rax, [rbx+10h]
mov rsi, [rax-8]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE3endEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::end(void)
mov rdi, r14
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
test al, al
jz short loc_55CD6
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEptEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator->(void)
cmp byte ptr [rax], 9
jz short loc_55CA6
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv; nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::operator++(void)
jmp short loc_55C70
loc_55CA6:
mov rax, [rbx+10h]
mov rsi, [rax-8]
mov rax, [rsp+88h+var_88]
lea rdx, [rsp+88h+var_38]
mov [rdx], rax
movups xmm0, [rsp+88h+var_80]
movups xmmword ptr [rdx+8], xmm0
mov rax, [rsp+88h+var_70]
mov [rdx+18h], rax
lea rdi, [rsp+88h+var_68]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
loc_55CD6:
mov al, 1
add rsp, 70h
pop rbx
pop r14
pop r15
retn
loc_55CE2:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aRefStackEmpty; "!ref_stack.empty()"
mov esi, 1BBDh
jmp short loc_55D18
loc_55CFE:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aKeepStackEmpty; "!keep_stack.empty()"
mov esi, 1BBEh
loc_55D18:
xor eax, eax
call _ggml_abort
nop
| 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>>::end_object(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
char a7,
int a8,
char a9)
{
long long v9; // rsi
long long v10; // rcx
long long v11; // rax
long long v12; // rax
_BYTE *v13; // rsi
long long v14; // rsi
int v16; // esi
int v17; // edx
int v18; // ecx
int v19; // r8d
int v20; // r9d
long long v21; // [rsp+0h] [rbp-88h] BYREF
__int128 v22; // [rsp+8h] [rbp-80h]
long long v23; // [rsp+18h] [rbp-70h]
_BYTE v24[32]; // [rsp+20h] [rbp-68h] BYREF
char v25[16]; // [rsp+40h] [rbp-48h] BYREF
long long v26; // [rsp+50h] [rbp-38h]
__int128 v27; // [rsp+58h] [rbp-30h]
long long v28; // [rsp+68h] [rbp-20h]
v9 = *(_QWORD *)(a1 + 16);
v10 = *(_QWORD *)(v9 - 8);
if ( v10
&& !(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,
(unsigned int)((unsigned long long)(v9 - *(_QWORD *)(a1 + 8)) >> 3) - 1,
1LL,
v10) )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v25,
a1 + 168);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
*(char **)(*(_QWORD *)(a1 + 16) - 8LL),
v25);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v25);
}
v11 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) == v11 )
{
v16 = 7101;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7101LL,
"GGML_ASSERT(%s) failed",
"!ref_stack.empty()");
return 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>>::key(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
v17,
v18,
v19,
v20,
a7,
a8,
a9);
}
if ( *(_QWORD *)(a1 + 32) == *(_QWORD *)(a1 + 48) && !*(_DWORD *)(a1 + 56) )
{
v16 = 7102;
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
7102LL,
"GGML_ASSERT(%s) failed",
"!keep_stack.empty()");
return 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>>::key(
(unsigned int)"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",
v16,
v17,
v18,
v19,
v20,
a7,
a8,
a9);
}
*(_QWORD *)(a1 + 16) = v11 - 8;
std::_Bit_iterator_base::_M_bump_down((std::_Bit_iterator_base *)(a1 + 48));
v12 = *(_QWORD *)(a1 + 16);
if ( *(_QWORD *)(a1 + 8) != v12 )
{
v13 = *(_BYTE **)(v12 - 8);
if ( v13 )
{
if ( (unsigned __int8)(*v13 - 1) <= 1u )
{
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::begin(&v21);
while ( 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>::end(
v24,
*(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL));
if ( !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_(
&v21,
v24) )
break;
if ( *(_BYTE *)nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator->(&v21) == 9 )
{
v14 = *(_QWORD *)(*(_QWORD *)(a1 + 16) - 8LL);
v26 = v21;
v27 = v22;
v28 = v23;
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_(
v24,
v14);
return 1;
}
nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(&v21);
}
}
}
}
return 1;
}
| end_object:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x10]
MOV RCX,qword ptr [RSI + -0x8]
TEST RCX,RCX
JZ 0x00155c0e
LEA RDI,[RBX + 0x80]
SUB RSI,qword ptr [RBX + 0x8]
SHR RSI,0x3
DEC ESI
PUSH 0x1
POP RDX
CALL 0x00156262
TEST AL,AL
JNZ 0x00155c0e
LEA RSI,[RBX + 0xa8]
LEA R14,[RSP + 0x40]
MOV RDI,R14
CALL 0x00146ea2
MOV RAX,qword ptr [RBX + 0x10]
MOV RDI,qword ptr [RAX + -0x8]
MOV RSI,R14
CALL 0x00146ca4
MOV RDI,R14
CALL 0x00146ce8
LAB_00155c0e:
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x00155ce2
MOV RCX,qword ptr [RBX + 0x20]
CMP RCX,qword ptr [RBX + 0x30]
JNZ 0x00155c30
CMP dword ptr [RBX + 0x38],0x0
JZ 0x00155cfe
LAB_00155c30:
LEA RDI,[RBX + 0x30]
ADD RAX,-0x8
MOV qword ptr [RBX + 0x10],RAX
CALL 0x00155a32
MOV RAX,qword ptr [RBX + 0x10]
CMP qword ptr [RBX + 0x8],RAX
JZ 0x00155cd6
MOV RSI,qword ptr [RAX + -0x8]
TEST RSI,RSI
JZ 0x00155cd6
MOV AL,byte ptr [RSI]
DEC AL
CMP AL,0x1
JA 0x00155cd6
MOV R14,RSP
MOV RDI,R14
CALL 0x00156800
LEA R15,[RSP + 0x20]
LAB_00155c70:
MOV RAX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RAX + -0x8]
MOV RDI,R15
CALL 0x00156830
MOV RDI,R14
MOV RSI,R15
CALL 0x00156826
TEST AL,AL
JZ 0x00155cd6
MOV RDI,R14
CALL 0x00156856
CMP byte ptr [RAX],0x9
JZ 0x00155ca6
MOV RDI,R14
CALL 0x00156b76
JMP 0x00155c70
LAB_00155ca6:
MOV RAX,qword ptr [RBX + 0x10]
MOV RSI,qword ptr [RAX + -0x8]
MOV RAX,qword ptr [RSP]
LEA RDX,[RSP + 0x50]
MOV qword ptr [RDX],RAX
MOVUPS XMM0,xmmword ptr [RSP + 0x8]
MOVUPS xmmword ptr [RDX + 0x8],XMM0
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RDX + 0x18],RAX
LEA RDI,[RSP + 0x20]
CALL 0x00156984
LAB_00155cd6:
MOV AL,0x1
ADD RSP,0x70
POP RBX
POP R14
POP R15
RET
LAB_00155ce2:
LEA RDI,[0x19dccb]
LEA RDX,[0x19a589]
LEA RCX,[0x19f1ba]
MOV ESI,0x1bbd
JMP 0x00155d18
LAB_00155cfe:
LEA RDI,[0x19dccb]
LEA RDX,[0x19a589]
LEA RCX,[0x19f134]
MOV ESI,0x1bbe
LAB_00155d18:
XOR EAX,EAX
CALL 0x00122ce0
|
/* 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> >::end_object() */
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>>
::end_object(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)
{
char cVar1;
char *pcVar2;
int8 uVar3;
int8 local_88;
int4 local_80;
int4 uStack_7c;
int4 uStack_78;
int4 uStack_74;
int8 local_70;
int1 local_68 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_48 [16];
int8 local_38;
int4 local_30;
int4 uStack_2c;
int4 uStack_28;
int4 uStack_24;
int8 local_20;
if ((*(long *)(*(long *)(this + 0x10) + -8) != 0) &&
(cVar1 = std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::operator()(this + 0x80,
(int)((ulong)(*(long *)(this + 0x10) - *(long *)(this + 8)) >> 3) + -1,1)
, cVar1 == '\0')) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_48,this + 0xa8);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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>
**)(*(long *)(this + 0x10) + -8),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>
::~basic_json(local_48);
}
if (*(long *)(this + 8) == *(long *)(this + 0x10)) {
pcVar2 = "!ref_stack.empty()";
uVar3 = 0x1bbd;
}
else {
if ((*(long *)(this + 0x20) != *(long *)(this + 0x30)) || (*(int *)(this + 0x38) != 0)) {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + -8;
std::_Bit_iterator_base::_M_bump_down((_Bit_iterator_base *)(this + 0x30));
if ((*(long *)(this + 8) != *(long *)(this + 0x10)) &&
((pcVar2 = *(char **)(*(long *)(this + 0x10) + -8), pcVar2 != (char *)0x0 &&
((byte)(*pcVar2 - 1U) < 2)))) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::begin();
while( true ) {
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::end();
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEneISG_TnNSt9enable_ifIXoosr3std7is_sameIT_SG_EE5valuesr3std7is_sameISJ_NS2_IKSF_EEEE5valueEDnE4typeELDn0EEEbRKSJ_
(&local_88,local_68);
if (cVar1 == '\0') break;
pcVar2 = (char *)iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator->((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_88);
if (*pcVar2 == '\t') {
local_38 = local_88;
local_30 = local_80;
uStack_2c = uStack_7c;
uStack_28 = uStack_78;
uStack_24 = uStack_74;
local_20 = local_70;
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5eraseINS0_6detail9iter_implISD_EETnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISJ_NSG_IKSD_EEEE5valueEiE4typeELi0EEESJ_SJ_
(local_68,*(int8 *)(*(long *)(this + 0x10) + -8));
return 1;
}
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++((iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_88);
}
}
return 1;
}
pcVar2 = "!keep_stack.empty()";
uVar3 = 0x1bbe;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/json.hpp",uVar3,
"GGML_ASSERT(%s) failed",pcVar2);
}
| |
22,276 | r3d_light_init | r3d/src/details/r3d_light.c | void r3d_light_init(r3d_light_t* light)
{
light->shadow = (r3d_shadow_t){ 0 };
light->color = (Vector3){ 1, 1, 1 };
light->position = (Vector3){ 0 };
light->direction = (Vector3){ 0, 0, -1 };
light->specular = 0.5f;
light->energy = 1.0f;
light->range = 100.0f;
light->size = 0.001f;
light->near = 0.05f;
light->attenuation = 1.0f;
light->innerCutOff = -1.0f;
light->outerCutOff = -1.0f;
light->type = R3D_LIGHT_DIR;
light->enabled = false;
} | O3 | c | r3d_light_init:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x60(%rdi)
movabsq $0x3f8000003f800000, %rax # imm = 0x3F8000003F800000
movq %rax, 0x68(%rdi)
movl $0x3f800000, 0x70(%rdi) # imm = 0x3F800000
movups %xmm0, 0x74(%rdi)
movl $0x0, 0x84(%rdi)
movaps 0x1ba4(%rip), %xmm0 # 0xe39f0
movups %xmm0, 0x88(%rdi)
movabsq $0x3d4ccccd3a83126f, %rax # imm = 0x3D4CCCCD3A83126F
movq %rax, 0x98(%rdi)
movaps 0x1b95(%rip), %xmm0 # 0xe3a00
movups %xmm0, 0xa4(%rdi)
movb $0x0, 0xb4(%rdi)
popq %rbp
retq
| r3d_light_init:
push rbp
mov rbp, rsp
xorps xmm0, xmm0
movups xmmword ptr [rdi+50h], xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+60h], 0
mov rax, 3F8000003F800000h
mov [rdi+68h], rax
mov dword ptr [rdi+70h], 3F800000h
movups xmmword ptr [rdi+74h], xmm0
mov dword ptr [rdi+84h], 0
movaps xmm0, cs:xmmword_E39F0
movups xmmword ptr [rdi+88h], xmm0
mov rax, 3D4CCCCD3A83126Fh
mov [rdi+98h], rax
movaps xmm0, cs:xmmword_E3A00
movups xmmword ptr [rdi+0A4h], xmm0
mov byte ptr [rdi+0B4h], 0
pop rbp
retn
| long long r3d_light_init(long long a1)
{
long long result; // rax
*(_OWORD *)(a1 + 80) = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 96) = 0LL;
*(_QWORD *)(a1 + 104) = 0x3F8000003F800000LL;
*(_DWORD *)(a1 + 112) = 1065353216;
*(_OWORD *)(a1 + 116) = 0LL;
*(_DWORD *)(a1 + 132) = 0;
*(_OWORD *)(a1 + 136) = xmmword_E39F0;
result = 0x3D4CCCCD3A83126FLL;
*(_QWORD *)(a1 + 152) = 0x3D4CCCCD3A83126FLL;
*(_OWORD *)(a1 + 164) = xmmword_E3A00;
*(_BYTE *)(a1 + 180) = 0;
return result;
}
| r3d_light_init:
PUSH RBP
MOV RBP,RSP
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x50],XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x60],0x0
MOV RAX,0x3f8000003f800000
MOV qword ptr [RDI + 0x68],RAX
MOV dword ptr [RDI + 0x70],0x3f800000
MOVUPS xmmword ptr [RDI + 0x74],XMM0
MOV dword ptr [RDI + 0x84],0x0
MOVAPS XMM0,xmmword ptr [0x001e39f0]
MOVUPS xmmword ptr [RDI + 0x88],XMM0
MOV RAX,0x3d4ccccd3a83126f
MOV qword ptr [RDI + 0x98],RAX
MOVAPS XMM0,xmmword ptr [0x001e3a00]
MOVUPS xmmword ptr [RDI + 0xa4],XMM0
MOV byte ptr [RDI + 0xb4],0x0
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
void r3d_light_init(int8 *param_1)
{
int8 uVar1;
param_1[10] = 0;
param_1[0xb] = 0;
param_1[8] = 0;
param_1[9] = 0;
param_1[6] = 0;
param_1[7] = 0;
param_1[4] = 0;
param_1[5] = 0;
param_1[2] = 0;
param_1[3] = 0;
*param_1 = 0;
param_1[1] = 0;
param_1[0xc] = 0;
param_1[0xd] = 0x3f8000003f800000;
*(int4 *)(param_1 + 0xe) = 0x3f800000;
*(int8 *)((long)param_1 + 0x74) = 0;
*(int8 *)((long)param_1 + 0x7c) = 0;
*(int4 *)((long)param_1 + 0x84) = 0;
uVar1 = _UNK_001e39f8;
param_1[0x11] = _DAT_001e39f0;
param_1[0x12] = uVar1;
param_1[0x13] = 0x3d4ccccd3a83126f;
uVar1 = _UNK_001e3a08;
*(int8 *)((long)param_1 + 0xa4) = _DAT_001e3a00;
*(int8 *)((long)param_1 + 0xac) = uVar1;
*(int1 *)((long)param_1 + 0xb4) = 0;
return;
}
| |
22,277 | my_charset_loader_init_mysys | eloqsql/mysys/charset.c | void
my_charset_loader_init_mysys(MY_CHARSET_LOADER *loader)
{
loader->error[0]= '\0';
loader->once_alloc= my_once_alloc_c;
loader->malloc= my_malloc_c;
loader->realloc= my_realloc_c;
loader->free= my_free;
loader->reporter= my_charset_error_reporter;
loader->add_collation= add_collation;
} | O0 | c | my_charset_loader_init_mysys:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
leaq 0x66(%rip), %rcx # 0xdc350
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rax
leaq 0x74(%rip), %rcx # 0xdc370
movq %rcx, 0x88(%rax)
movq -0x8(%rbp), %rax
leaq 0x92(%rip), %rcx # 0xdc3a0
movq %rcx, 0x90(%rax)
movq -0x8(%rbp), %rax
leaq 0x1c3b0(%rip), %rcx # 0xf86d0
movq %rcx, 0x98(%rax)
leaq 0x1ee592(%rip), %rax # 0x2ca8c0
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x8(%rbp), %rax
leaq 0x99(%rip), %rcx # 0xdc3e0
movq %rcx, 0xa8(%rax)
popq %rbp
retq
| my_charset_loader_init_mysys:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov byte ptr [rax], 0
mov rax, [rbp+var_8]
lea rcx, my_once_alloc_c
mov [rax+80h], rcx
mov rax, [rbp+var_8]
lea rcx, my_malloc_c
mov [rax+88h], rcx
mov rax, [rbp+var_8]
lea rcx, my_realloc_c
mov [rax+90h], rcx
mov rax, [rbp+var_8]
lea rcx, my_free
mov [rax+98h], rcx
lea rax, my_charset_error_reporter
mov rcx, [rax]
mov rax, [rbp+var_8]
mov [rax+0A0h], rcx
mov rax, [rbp+var_8]
lea rcx, add_collation
mov [rax+0A8h], rcx
pop rbp
retn
| long long my_charset_loader_init_mysys(long long a1)
{
long long result; // rax
*(_BYTE *)a1 = 0;
*(_QWORD *)(a1 + 128) = my_once_alloc_c;
*(_QWORD *)(a1 + 136) = my_malloc_c;
*(_QWORD *)(a1 + 144) = my_realloc_c;
*(_QWORD *)(a1 + 152) = my_free;
*(_QWORD *)(a1 + 160) = my_charset_error_reporter;
result = a1;
*(_QWORD *)(a1 + 168) = add_collation;
return result;
}
| my_charset_loader_init_mysys:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1dc350]
MOV qword ptr [RAX + 0x80],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1dc370]
MOV qword ptr [RAX + 0x88],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1dc3a0]
MOV qword ptr [RAX + 0x90],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1f86d0]
MOV qword ptr [RAX + 0x98],RCX
LEA RAX,[0x3ca8c0]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0xa0],RCX
MOV RAX,qword ptr [RBP + -0x8]
LEA RCX,[0x1dc3e0]
MOV qword ptr [RAX + 0xa8],RCX
POP RBP
RET
|
void my_charset_loader_init_mysys(int1 *param_1)
{
*param_1 = 0;
*(code **)(param_1 + 0x80) = my_once_alloc_c;
*(code **)(param_1 + 0x88) = my_malloc_c;
*(code **)(param_1 + 0x90) = my_realloc_c;
*(code **)(param_1 + 0x98) = my_free;
*(int **)(param_1 + 0xa0) = my_charset_error_reporter;
*(code **)(param_1 + 0xa8) = add_collation;
return;
}
| |
22,278 | resize_properties | bluesky950520[P]quickjs/quickjs.c | static no_inline int resize_properties(JSContext *ctx, JSShape **psh,
JSObject *p, uint32_t count)
{
JSShape *sh;
uint32_t new_size, new_hash_size, new_hash_mask, i;
JSShapeProperty *pr;
void *sh_alloc;
intptr_t h;
sh = *psh;
new_size = max_int(count, sh->prop_size * 3 / 2);
/* Reallocate prop array first to avoid crash or size inconsistency
in case of memory allocation failure */
if (p) {
JSProperty *new_prop;
new_prop = js_realloc(ctx, p->prop, sizeof(new_prop[0]) * new_size);
if (unlikely(!new_prop))
return -1;
p->prop = new_prop;
}
new_hash_size = sh->prop_hash_mask + 1;
while (new_hash_size < new_size)
new_hash_size = 2 * new_hash_size;
if (new_hash_size != (sh->prop_hash_mask + 1)) {
JSShape *old_sh;
/* resize the hash table and the properties */
old_sh = sh;
sh_alloc = js_malloc(ctx, get_shape_size(new_hash_size, new_size));
if (!sh_alloc)
return -1;
sh = get_shape_from_alloc(sh_alloc, new_hash_size);
list_del(&old_sh->header.link);
/* copy all the fields and the properties */
memcpy(sh, old_sh,
sizeof(JSShape) + sizeof(sh->prop[0]) * old_sh->prop_count);
list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
new_hash_mask = new_hash_size - 1;
sh->prop_hash_mask = new_hash_mask;
memset(prop_hash_end(sh) - new_hash_size, 0,
sizeof(prop_hash_end(sh)[0]) * new_hash_size);
for(i = 0, pr = sh->prop; i < sh->prop_count; i++, pr++) {
if (pr->atom != JS_ATOM_NULL) {
h = ((uintptr_t)pr->atom & new_hash_mask);
pr->hash_next = prop_hash_end(sh)[-h - 1];
prop_hash_end(sh)[-h - 1] = i + 1;
}
}
js_free(ctx, get_alloc_from_shape(old_sh));
} else {
/* only resize the properties */
list_del(&sh->header.link);
sh_alloc = js_realloc(ctx, get_alloc_from_shape(sh),
get_shape_size(new_hash_size, new_size));
if (unlikely(!sh_alloc)) {
/* insert again in the GC list */
list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
return -1;
}
sh = get_shape_from_alloc(sh_alloc, new_hash_size);
list_add_tail(&sh->header.link, &ctx->rt->gc_obj_list);
}
*psh = sh;
sh->prop_size = new_size;
return 0;
} | O1 | c | resize_properties:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
movq %rsi, 0x20(%rsp)
movq (%rsi), %r14
movl 0x24(%r14), %eax
leal (%rax,%rax,2), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
cmpl %ebp, %ecx
cmovgl %ecx, %ebp
movl %ebp, %ebx
testq %rdx, %rdx
je 0x3b704
movq %rdx, %r12
movq 0x20(%rdx), %rsi
movq %rbx, %rdx
shlq $0x4, %rdx
movq %r15, %rdi
callq 0x1bfc4
testq %rax, %rax
je 0x3b8ff
movq %rax, 0x20(%r12)
movl 0x20(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, %edx
movl %edx, %r13d
leal (,%r13,2), %edx
cmpl %ebp, %r13d
jb 0x3b70d
cmpl %ecx, %r13d
jne 0x3b7b9
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
movq %rdx, 0x8(%rcx)
movq %rcx, (%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
notq %rax
leaq (%r14,%rax,4), %rsi
movl %r13d, %r13d
leaq (,%r13,4), %rax
leaq (%rax,%rbx,8), %rdx
addq $0x40, %rdx
movq %r15, %rdi
callq 0x1bfc4
testq %rax, %rax
je 0x3b909
leaq (%rax,%r13,4), %r12
leaq (%rax,%r13,4), %rcx
addq $0x8, %rcx
movq 0x18(%r15), %rdx
leaq 0x98(%rdx), %rsi
movq 0x98(%rdx), %rdi
movq %rcx, 0x8(%rdi)
movq %rdi, 0x8(%rax,%r13,4)
movq %rsi, 0x10(%rax,%r13,4)
movq %rcx, 0x98(%rdx)
movq 0x20(%rsp), %rax
movq %r12, (%rax)
movl %ebp, 0x24(%r12)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r13d, %r12d
leaq (,%r12,4), %rax
movq %rax, 0x18(%rsp)
leaq (%rax,%rbx,8), %rsi
addq $0x40, %rsi
movq %r15, %rdi
callq 0xed5d
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x3b8f0
movq %r12, 0x8(%rsp)
movq 0x10(%rsp), %rbx
leaq (%rbx,%r12,4), %r12
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movslq 0x28(%r14), %rax
leaq 0x40(,%rax,8), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0xe5a0
movq 0x8(%rsp), %rdi
leaq (%rbx,%rdi,4), %rax
addq $0x8, %rax
movq 0x18(%r15), %rcx
leaq 0x98(%rcx), %rdx
movq 0x98(%rcx), %rsi
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%rbx,%rdi,4)
movq %rdx, 0x10(%rbx,%rdi,4)
movq %rax, 0x98(%rcx)
decl %r13d
movl %r13d, 0x20(%rbx,%rdi,4)
movq %rbx, %rdi
xorl %esi, %esi
movq 0x18(%rsp), %rdx
callq 0xe340
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rbx,%rax,4)
je 0x3b8bc
xorl %eax, %eax
movl $0x3ffffff, %ecx # imm = 0x3FFFFFF
movl $0xfc000000, %edx # imm = 0xFC000000
movl 0x44(%r12,%rax,8), %esi
testl %esi, %esi
je 0x3b8b2
andl %r13d, %esi
notq %rsi
movl (%r12,%rsi,4), %edi
andl %ecx, %edi
movl 0x40(%r12,%rax,8), %r8d
andl %edx, %r8d
orl %edi, %r8d
movl %r8d, 0x40(%r12,%rax,8)
leal 0x1(%rax), %edi
movl %edi, (%r12,%rsi,4)
incq %rax
cmpl 0x28(%r12), %eax
jb 0x3b886
movl 0x20(%r14), %eax
notq %rax
leaq (%r14,%rax,4), %r14
movq 0x18(%r15), %rbx
decq 0x28(%rbx)
movq %r14, %rdi
callq *0x20(%rbx)
movq 0x30(%rbx), %rcx
movq 0x40(%rbx), %rdi
subq %rax, %rcx
addq $-0x8, %rcx
movq %rcx, 0x30(%rbx)
movq %r14, %rsi
callq *0x10(%rbx)
jmp 0x3b8f3
movq %r14, %r12
cmpq $0x0, 0x10(%rsp)
jne 0x3b79b
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x3b7aa
leaq 0x8(%r14), %rax
movq 0x18(%r15), %rcx
leaq 0x98(%rcx), %rdx
movq 0x98(%rcx), %rsi
movq %rax, 0x8(%rsi)
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rax, 0x98(%rcx)
jmp 0x3b8ff
| resize_properties:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdi
mov [rsp+58h+var_38], rsi
mov r14, [rsi]
mov eax, [r14+24h]
lea eax, [rax+rax*2]
mov ebp, eax
shr ebp, 1Fh
add ebp, eax
sar ebp, 1
cmp ecx, ebp
cmovg ebp, ecx
mov ebx, ebp
test rdx, rdx
jz short loc_3B704
mov r12, rdx
mov rsi, [rdx+20h]
mov rdx, rbx
shl rdx, 4
mov rdi, r15
call js_realloc
test rax, rax
jz loc_3B8FF
mov [r12+20h], rax
loc_3B704:
mov eax, [r14+20h]
lea ecx, [rax+1]
mov edx, ecx
loc_3B70D:
mov r13d, edx
lea edx, ds:0[r13*2]
cmp r13d, ebp
jb short loc_3B70D
cmp r13d, ecx
jnz loc_3B7B9
mov rcx, [r14+8]
mov rdx, [r14+10h]
mov [rcx+8], rdx
mov [rdx], rcx
xorps xmm0, xmm0
movups xmmword ptr [r14+8], xmm0
not rax
lea rsi, [r14+rax*4]
mov r13d, r13d
lea rax, ds:0[r13*4]
lea rdx, [rax+rbx*8]
add rdx, 40h ; '@'
mov rdi, r15
call js_realloc
test rax, rax
jz loc_3B909
lea r12, [rax+r13*4]
lea rcx, [rax+r13*4]
add rcx, 8
mov rdx, [r15+18h]
lea rsi, [rdx+98h]
mov rdi, [rdx+98h]
mov [rdi+8], rcx
mov [rax+r13*4+8], rdi
mov [rax+r13*4+10h], rsi
mov [rdx+98h], rcx
loc_3B79B:
mov rax, [rsp+58h+var_38]
mov [rax], r12
mov [r12+24h], ebp
xor eax, eax
loc_3B7AA:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_3B7B9:
mov r12d, r13d
lea rax, ds:0[r12*4]
mov [rsp+58h+var_40], rax
lea rsi, [rax+rbx*8]
add rsi, 40h ; '@'
mov rdi, r15
call js_malloc
mov [rsp+58h+var_48], rax
test rax, rax
jz loc_3B8F0
mov [rsp+58h+var_50], r12
mov rbx, [rsp+58h+var_48]
lea r12, [rbx+r12*4]
mov rax, [r14+8]
mov rcx, [r14+10h]
mov [rax+8], rcx
mov [rcx], rax
xorps xmm0, xmm0
movups xmmword ptr [r14+8], xmm0
movsxd rax, dword ptr [r14+28h]
lea rdx, ds:40h[rax*8]
mov rdi, r12
mov rsi, r14
call _memcpy
mov rdi, [rsp+58h+var_50]
lea rax, [rbx+rdi*4]
add rax, 8
mov rcx, [r15+18h]
lea rdx, [rcx+98h]
mov rsi, [rcx+98h]
mov [rsi+8], rax
mov [rbx+rdi*4+8], rsi
mov [rbx+rdi*4+10h], rdx
mov [rcx+98h], rax
dec r13d
mov [rbx+rdi*4+20h], r13d
mov rdi, rbx
xor esi, esi
mov rdx, [rsp+58h+var_40]
call _memset
mov rax, [rsp+58h+var_50]
cmp dword ptr [rbx+rax*4+28h], 0
jz short loc_3B8BC
xor eax, eax
mov ecx, 3FFFFFFh
mov edx, 0FC000000h
loc_3B886:
mov esi, [r12+rax*8+44h]
test esi, esi
jz short loc_3B8B2
and esi, r13d
not rsi
mov edi, [r12+rsi*4]
and edi, ecx
mov r8d, [r12+rax*8+40h]
and r8d, edx
or r8d, edi
mov [r12+rax*8+40h], r8d
lea edi, [rax+1]
mov [r12+rsi*4], edi
loc_3B8B2:
inc rax
cmp eax, [r12+28h]
jb short loc_3B886
loc_3B8BC:
mov eax, [r14+20h]
not rax
lea r14, [r14+rax*4]
mov rbx, [r15+18h]
dec qword ptr [rbx+28h]
mov rdi, r14
call qword ptr [rbx+20h]
mov rcx, [rbx+30h]
mov rdi, [rbx+40h]
sub rcx, rax
add rcx, 0FFFFFFFFFFFFFFF8h
mov [rbx+30h], rcx
mov rsi, r14
call qword ptr [rbx+10h]
jmp short loc_3B8F3
loc_3B8F0:
mov r12, r14
loc_3B8F3:
cmp [rsp+58h+var_48], 0
jnz loc_3B79B
loc_3B8FF:
mov eax, 0FFFFFFFFh
jmp loc_3B7AA
loc_3B909:
lea rax, [r14+8]
mov rcx, [r15+18h]
lea rdx, [rcx+98h]
mov rsi, [rcx+98h]
mov [rsi+8], rax
mov [r14+8], rsi
mov [r14+10h], rdx
mov [rcx+98h], rax
jmp short loc_3B8FF
| long long resize_properties(long long a1, long long *a2, long long a3, signed int a4)
{
long long v4; // r14
unsigned int v5; // ebp
long long v7; // rax
long long v8; // rax
unsigned int v9; // edx
unsigned int v10; // r13d
long long v11; // rcx
_QWORD *v12; // rdx
long long v13; // rax
long long v14; // r12
long long *v15; // rsi
long long v16; // rdi
long long v18; // rax
_QWORD *v19; // rcx
long long v20; // rcx
long long v21; // rsi
unsigned int v22; // r13d
long long v23; // rax
int v24; // esi
unsigned long long v25; // rsi
unsigned long long v26; // r14
long long v27; // rbx
long long v28; // rax
long long v29; // rdi
long long *v30; // rdx
long long v31; // rsi
long long v32; // [rsp+8h] [rbp-50h]
long long v33; // [rsp+10h] [rbp-48h]
long long v34; // [rsp+18h] [rbp-40h]
v4 = *a2;
v5 = 3 * *(_DWORD *)(*a2 + 36) / 2;
if ( a4 > (int)v5 )
v5 = a4;
if ( a3 )
{
v7 = js_realloc(a1, *(_QWORD *)(a3 + 32), 16LL * v5);
if ( !v7 )
return 0xFFFFFFFFLL;
*(_QWORD *)(a3 + 32) = v7;
}
v8 = *(unsigned int *)(v4 + 32);
v9 = v8 + 1;
do
{
v10 = v9;
v9 *= 2;
}
while ( v10 < v5 );
if ( v10 == (_DWORD)v8 + 1 )
{
v11 = *(_QWORD *)(v4 + 8);
v12 = *(_QWORD **)(v4 + 16);
*(_QWORD *)(v11 + 8) = v12;
*v12 = v11;
*(_OWORD *)(v4 + 8) = 0LL;
v13 = js_realloc(a1, v4 + 4 * ~v8, 4LL * v10 + 8LL * v5 + 64);
if ( v13 )
{
v14 = v13 + 4LL * v10;
v15 = (long long *)(*(_QWORD *)(a1 + 24) + 152LL);
v16 = *v15;
*(_QWORD *)(v16 + 8) = v14 + 8;
*(_QWORD *)(v14 + 8) = v16;
*(_QWORD *)(v14 + 16) = v15;
*v15 = v14 + 8;
LABEL_11:
*a2 = v14;
*(_DWORD *)(v14 + 36) = v5;
return 0LL;
}
v30 = (long long *)(*(_QWORD *)(a1 + 24) + 152LL);
v31 = *v30;
*(_QWORD *)(v31 + 8) = v4 + 8;
*(_QWORD *)(v4 + 8) = v31;
*(_QWORD *)(v4 + 16) = v30;
*v30 = v4 + 8;
}
else
{
v34 = 4LL * v10;
v33 = js_malloc(a1, v34 + 8LL * v5 + 64);
if ( v33 )
{
v32 = v10;
v14 = v33 + 4LL * v10;
v18 = *(_QWORD *)(v4 + 8);
v19 = *(_QWORD **)(v4 + 16);
*(_QWORD *)(v18 + 8) = v19;
*v19 = v18;
*(_OWORD *)(v4 + 8) = 0LL;
memcpy(v14, v4, 8LL * *(int *)(v4 + 40) + 64);
v20 = *(_QWORD *)(a1 + 24);
v21 = *(_QWORD *)(v20 + 152);
*(_QWORD *)(v21 + 8) = v14 + 8;
*(_QWORD *)(v14 + 8) = v21;
*(_QWORD *)(v14 + 16) = v20 + 152;
*(_QWORD *)(v20 + 152) = v14 + 8;
v22 = v10 - 1;
*(_DWORD *)(v33 + 4 * v32 + 32) = v22;
memset(v33, 0LL, v34);
if ( *(_DWORD *)(v33 + 4 * v32 + 40) )
{
v23 = 0LL;
do
{
v24 = *(_DWORD *)(v14 + 8 * v23 + 68);
if ( v24 )
{
v25 = ~(unsigned long long)(v22 & v24);
*(_DWORD *)(v14 + 8 * v23 + 64) = *(_DWORD *)(v14 + 4 * v25) & 0x3FFFFFF | *(_DWORD *)(v14 + 8 * v23 + 64) & 0xFC000000;
*(_DWORD *)(v14 + 4 * v25) = v23 + 1;
}
++v23;
}
while ( (unsigned int)v23 < *(_DWORD *)(v14 + 40) );
}
v26 = v4 + 4 * ~(unsigned long long)*(unsigned int *)(v4 + 32);
v27 = *(_QWORD *)(a1 + 24);
--*(_QWORD *)(v27 + 40);
v28 = (*(long long ( **)(unsigned long long))(v27 + 32))(v26);
v29 = *(_QWORD *)(v27 + 64);
*(_QWORD *)(v27 + 48) = *(_QWORD *)(v27 + 48) - v28 - 8;
(*(void ( **)(long long, unsigned long long))(v27 + 16))(v29, v26);
}
else
{
v14 = v4;
}
if ( v33 )
goto LABEL_11;
}
return 0xFFFFFFFFLL;
}
| resize_properties:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDI
MOV qword ptr [RSP + 0x20],RSI
MOV R14,qword ptr [RSI]
MOV EAX,dword ptr [R14 + 0x24]
LEA EAX,[RAX + RAX*0x2]
MOV EBP,EAX
SHR EBP,0x1f
ADD EBP,EAX
SAR EBP,0x1
CMP ECX,EBP
CMOVG EBP,ECX
MOV EBX,EBP
TEST RDX,RDX
JZ 0x0013b704
MOV R12,RDX
MOV RSI,qword ptr [RDX + 0x20]
MOV RDX,RBX
SHL RDX,0x4
MOV RDI,R15
CALL 0x0011bfc4
TEST RAX,RAX
JZ 0x0013b8ff
MOV qword ptr [R12 + 0x20],RAX
LAB_0013b704:
MOV EAX,dword ptr [R14 + 0x20]
LEA ECX,[RAX + 0x1]
MOV EDX,ECX
LAB_0013b70d:
MOV R13D,EDX
LEA EDX,[R13*0x2]
CMP R13D,EBP
JC 0x0013b70d
CMP R13D,ECX
JNZ 0x0013b7b9
MOV RCX,qword ptr [R14 + 0x8]
MOV RDX,qword ptr [R14 + 0x10]
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RDX],RCX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x8],XMM0
NOT RAX
LEA RSI,[R14 + RAX*0x4]
MOV R13D,R13D
LEA RAX,[R13*0x4]
LEA RDX,[RAX + RBX*0x8]
ADD RDX,0x40
MOV RDI,R15
CALL 0x0011bfc4
TEST RAX,RAX
JZ 0x0013b909
LEA R12,[RAX + R13*0x4]
LEA RCX,[RAX + R13*0x4]
ADD RCX,0x8
MOV RDX,qword ptr [R15 + 0x18]
LEA RSI,[RDX + 0x98]
MOV RDI,qword ptr [RDX + 0x98]
MOV qword ptr [RDI + 0x8],RCX
MOV qword ptr [RAX + R13*0x4 + 0x8],RDI
MOV qword ptr [RAX + R13*0x4 + 0x10],RSI
MOV qword ptr [RDX + 0x98],RCX
LAB_0013b79b:
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RAX],R12
MOV dword ptr [R12 + 0x24],EBP
XOR EAX,EAX
LAB_0013b7aa:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0013b7b9:
MOV R12D,R13D
LEA RAX,[R12*0x4]
MOV qword ptr [RSP + 0x18],RAX
LEA RSI,[RAX + RBX*0x8]
ADD RSI,0x40
MOV RDI,R15
CALL 0x0010ed5d
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x0013b8f0
MOV qword ptr [RSP + 0x8],R12
MOV RBX,qword ptr [RSP + 0x10]
LEA R12,[RBX + R12*0x4]
MOV RAX,qword ptr [R14 + 0x8]
MOV RCX,qword ptr [R14 + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RCX],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x8],XMM0
MOVSXD RAX,dword ptr [R14 + 0x28]
LEA RDX,[0x40 + RAX*0x8]
MOV RDI,R12
MOV RSI,R14
CALL 0x0010e5a0
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RBX + RDI*0x4]
ADD RAX,0x8
MOV RCX,qword ptr [R15 + 0x18]
LEA RDX,[RCX + 0x98]
MOV RSI,qword ptr [RCX + 0x98]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [RBX + RDI*0x4 + 0x8],RSI
MOV qword ptr [RBX + RDI*0x4 + 0x10],RDX
MOV qword ptr [RCX + 0x98],RAX
DEC R13D
MOV dword ptr [RBX + RDI*0x4 + 0x20],R13D
MOV RDI,RBX
XOR ESI,ESI
MOV RDX,qword ptr [RSP + 0x18]
CALL 0x0010e340
MOV RAX,qword ptr [RSP + 0x8]
CMP dword ptr [RBX + RAX*0x4 + 0x28],0x0
JZ 0x0013b8bc
XOR EAX,EAX
MOV ECX,0x3ffffff
MOV EDX,0xfc000000
LAB_0013b886:
MOV ESI,dword ptr [R12 + RAX*0x8 + 0x44]
TEST ESI,ESI
JZ 0x0013b8b2
AND ESI,R13D
NOT RSI
MOV EDI,dword ptr [R12 + RSI*0x4]
AND EDI,ECX
MOV R8D,dword ptr [R12 + RAX*0x8 + 0x40]
AND R8D,EDX
OR R8D,EDI
MOV dword ptr [R12 + RAX*0x8 + 0x40],R8D
LEA EDI,[RAX + 0x1]
MOV dword ptr [R12 + RSI*0x4],EDI
LAB_0013b8b2:
INC RAX
CMP EAX,dword ptr [R12 + 0x28]
JC 0x0013b886
LAB_0013b8bc:
MOV EAX,dword ptr [R14 + 0x20]
NOT RAX
LEA R14,[R14 + RAX*0x4]
MOV RBX,qword ptr [R15 + 0x18]
DEC qword ptr [RBX + 0x28]
MOV RDI,R14
CALL qword ptr [RBX + 0x20]
MOV RCX,qword ptr [RBX + 0x30]
MOV RDI,qword ptr [RBX + 0x40]
SUB RCX,RAX
ADD RCX,-0x8
MOV qword ptr [RBX + 0x30],RCX
MOV RSI,R14
CALL qword ptr [RBX + 0x10]
JMP 0x0013b8f3
LAB_0013b8f0:
MOV R12,R14
LAB_0013b8f3:
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x0013b79b
LAB_0013b8ff:
MOV EAX,0xffffffff
JMP 0x0013b7aa
LAB_0013b909:
LEA RAX,[R14 + 0x8]
MOV RCX,qword ptr [R15 + 0x18]
LEA RDX,[RCX + 0x98]
MOV RSI,qword ptr [RCX + 0x98]
MOV qword ptr [RSI + 0x8],RAX
MOV qword ptr [R14 + 0x8],RSI
MOV qword ptr [R14 + 0x10],RDX
MOV qword ptr [RCX + 0x98],RAX
JMP 0x0013b8ff
|
int8 resize_properties(long param_1,int8 *param_2,long param_3,uint param_4)
{
void *__dest;
long *plVar1;
uint uVar2;
uint uVar3;
long lVar4;
void *__s;
long lVar5;
long lVar6;
uint uVar7;
long lVar8;
uint uVar9;
ulong uVar10;
ulong uVar11;
void *pvVar12;
pvVar12 = (void *)*param_2;
uVar9 = (*(int *)((long)pvVar12 + 0x24) * 3) / 2;
uVar10 = (ulong)uVar9;
if ((int)uVar9 < (int)param_4) {
uVar10 = (ulong)param_4;
}
if (param_3 != 0) {
lVar4 = js_realloc(param_1,*(int8 *)(param_3 + 0x20),uVar10 << 4);
if (lVar4 == 0) {
return 0xffffffff;
}
*(long *)(param_3 + 0x20) = lVar4;
}
uVar9 = *(uint *)((long)pvVar12 + 0x20);
uVar7 = uVar9 + 1;
uVar3 = uVar7;
do {
uVar2 = uVar3;
uVar11 = (ulong)uVar2;
uVar3 = uVar2 * 2;
} while (uVar2 < (uint)uVar10);
if (uVar2 == uVar7) {
lVar4 = *(long *)((long)pvVar12 + 8);
plVar1 = *(long **)((long)pvVar12 + 0x10);
*(long **)(lVar4 + 8) = plVar1;
*plVar1 = lVar4;
*(int8 *)((long)pvVar12 + 8) = 0;
*(int8 *)((long)pvVar12 + 0x10) = 0;
lVar4 = js_realloc(param_1,(void *)((long)pvVar12 + ~(ulong)uVar9 * 4),
uVar11 * 4 + uVar10 * 8 + 0x40);
if (lVar4 != 0) {
pvVar12 = (void *)(lVar4 + uVar11 * 4);
lVar8 = lVar4 + uVar11 * 4 + 8;
lVar6 = *(long *)(param_1 + 0x18);
lVar5 = *(long *)(lVar6 + 0x98);
*(long *)(lVar5 + 8) = lVar8;
*(long *)(lVar4 + 8 + uVar11 * 4) = lVar5;
*(long *)(lVar4 + 0x10 + uVar11 * 4) = lVar6 + 0x98;
*(long *)(lVar6 + 0x98) = lVar8;
LAB_0013b79b:
*param_2 = pvVar12;
*(uint *)((long)pvVar12 + 0x24) = (uint)uVar10;
return 0;
}
lVar4 = *(long *)(param_1 + 0x18);
lVar6 = *(long *)(lVar4 + 0x98);
*(long *)(lVar6 + 8) = (long)pvVar12 + 8;
*(long *)((long)pvVar12 + 8) = lVar6;
*(long *)((long)pvVar12 + 0x10) = lVar4 + 0x98;
*(long *)(lVar4 + 0x98) = (long)pvVar12 + 8;
}
else {
__s = (void *)js_malloc(param_1,uVar11 * 4 + uVar10 * 8 + 0x40);
if (__s != (void *)0x0) {
__dest = (void *)((long)__s + uVar11 * 4);
lVar4 = *(long *)((long)pvVar12 + 8);
plVar1 = *(long **)((long)pvVar12 + 0x10);
*(long **)(lVar4 + 8) = plVar1;
*plVar1 = lVar4;
*(int8 *)((long)pvVar12 + 8) = 0;
*(int8 *)((long)pvVar12 + 0x10) = 0;
memcpy(__dest,pvVar12,(long)*(int *)((long)pvVar12 + 0x28) * 8 + 0x40);
lVar5 = (long)__s + uVar11 * 4 + 8;
lVar4 = *(long *)(param_1 + 0x18);
lVar6 = *(long *)(lVar4 + 0x98);
*(long *)(lVar6 + 8) = lVar5;
*(long *)((long)__s + uVar11 * 4 + 8) = lVar6;
*(long *)((long)__s + uVar11 * 4 + 0x10) = lVar4 + 0x98;
*(long *)(lVar4 + 0x98) = lVar5;
*(uint *)((long)__s + uVar11 * 4 + 0x20) = uVar2 - 1;
memset(__s,0,uVar11 * 4);
if (*(int *)((long)__s + uVar11 * 4 + 0x28) != 0) {
lVar4 = 0;
do {
uVar9 = *(uint *)((long)__dest + lVar4 * 8 + 0x44);
if (uVar9 != 0) {
uVar11 = ~(ulong)(uVar9 & uVar2 - 1);
*(uint *)((long)__dest + lVar4 * 8 + 0x40) =
*(uint *)((long)__dest + lVar4 * 8 + 0x40) & 0xfc000000 |
*(uint *)((long)__dest + uVar11 * 4) & 0x3ffffff;
*(int *)((long)__dest + uVar11 * 4) = (int)lVar4 + 1;
}
lVar4 = lVar4 + 1;
} while ((uint)lVar4 < *(uint *)((long)__dest + 0x28));
}
pvVar12 = (void *)((long)pvVar12 + ~(ulong)*(uint *)((long)pvVar12 + 0x20) * 4);
lVar4 = *(long *)(param_1 + 0x18);
*(long *)(lVar4 + 0x28) = *(long *)(lVar4 + 0x28) + -1;
lVar6 = (**(code **)(lVar4 + 0x20))(pvVar12);
*(long *)(lVar4 + 0x30) = (*(long *)(lVar4 + 0x30) - lVar6) + -8;
(**(code **)(lVar4 + 0x10))(*(int8 *)(lVar4 + 0x40),pvVar12);
pvVar12 = __dest;
}
if (__s != (void *)0x0) goto LAB_0013b79b;
}
return 0xffffffff;
}
| |
22,279 | CacheHierarchy::processMemoryAccess(char, unsigned int) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MainMulCache.cpp | void processMemoryAccess(char op, uint32_t addr) {
if (!memory->isPageExist(addr)) {
memory->addPage(addr);
}
switch (op) {
case 'r':
l1cache->read(addr);
break;
case 'w':
l1cache->write(addr, 0);
break;
default:
throw std::runtime_error("Illegal memory access operation");
}
} | O0 | cpp | CacheHierarchy::processMemoryAccess(char, unsigned int):
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
movl 0x28(%rsp), %esi
callq 0x3410
testb $0x1, %al
jne 0x2a9f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movl 0x28(%rsp), %esi
callq 0x32d0
movsbl 0x2f(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x72, %eax
je 0x2aba
jmp 0x2aaf
movl 0xc(%rsp), %eax
subl $0x77, %eax
je 0x2ace
jmp 0x2ae5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x28(%rsp), %esi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2b37
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x28(%rsp), %esi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x8(%rax)
jmp 0x2b37
movl $0x10, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x5544(%rip), %rsi # 0x8044
callq 0x20b0
jmp 0x2b07
movq (%rsp), %rdi
movq 0x94de(%rip), %rsi # 0xbff0
movq 0x94a7(%rip), %rdx # 0xbfc0
callq 0x22e0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x2140
jmp 0x2b3c
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
| _ZN14CacheHierarchy19processMemoryAccessEcj:
sub rsp, 38h
mov al, sil
mov [rsp+38h+var_8], rdi
mov [rsp+38h+var_9], al
mov [rsp+38h+var_10], edx
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_28], rax
mov rdi, [rax]; this
mov esi, [rsp+38h+var_10]; unsigned int
call _ZN13MemoryManager11isPageExistEj; MemoryManager::isPageExist(uint)
test al, 1
jnz short loc_2A9F
mov rax, [rsp+38h+var_28]
mov rdi, [rax]; this
mov esi, [rsp+38h+var_10]; unsigned int
call _ZN13MemoryManager7addPageEj; MemoryManager::addPage(uint)
loc_2A9F:
movsx eax, [rsp+38h+var_9]
mov [rsp+38h+var_2C], eax
sub eax, 72h ; 'r'
jz short loc_2ABA
jmp short $+2
loc_2AAF:
mov eax, [rsp+38h+var_2C]
sub eax, 77h ; 'w'
jz short loc_2ACE
jmp short loc_2AE5
loc_2ABA:
mov rax, [rsp+38h+var_28]
mov rdi, [rax+8]
mov esi, [rsp+38h+var_10]
mov rax, [rdi]
call qword ptr [rax]
jmp short loc_2B37
loc_2ACE:
mov rax, [rsp+38h+var_28]
mov rdi, [rax+8]
mov esi, [rsp+38h+var_10]
mov rax, [rdi]
xor edx, edx
call qword ptr [rax+8]
jmp short loc_2B37
loc_2AE5:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+38h+var_38], rax
lea rsi, aIllegalMemoryA; "Illegal memory access operation"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_2B07:
mov rdi, [rsp+38h+var_38]; void *
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+38h+var_38]; void *
mov rcx, rax
mov eax, edx
mov [rsp+38h+var_18], rcx
mov [rsp+38h+var_1C], eax
call ___cxa_free_exception
jmp short loc_2B3C
loc_2B37:
add rsp, 38h
retn
loc_2B3C:
mov rdi, [rsp+38h+var_18]
call __Unwind_Resume
| long long CacheHierarchy::processMemoryAccess(MemoryManager **this, char a2, unsigned int a3)
{
std::runtime_error *exception; // [rsp+0h] [rbp-38h]
if ( (MemoryManager::isPageExist(*this, a3) & 1) == 0 )
MemoryManager::addPage(*this, a3);
if ( a2 == 114 )
return (**(long long ( ***)(MemoryManager *, _QWORD))this[1])(this[1], a3);
if ( a2 != 119 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Illegal memory access operation");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return (*(long long ( **)(MemoryManager *, _QWORD, _QWORD))(*(_QWORD *)this[1] + 8LL))(this[1], a3, 0LL);
}
| processMemoryAccess:
SUB RSP,0x38
MOV AL,SIL
MOV qword ptr [RSP + 0x30],RDI
MOV byte ptr [RSP + 0x2f],AL
MOV dword ptr [RSP + 0x28],EDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RSP + 0x28]
CALL 0x00103410
TEST AL,0x1
JNZ 0x00102a9f
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX]
MOV ESI,dword ptr [RSP + 0x28]
CALL 0x001032d0
LAB_00102a9f:
MOVSX EAX,byte ptr [RSP + 0x2f]
MOV dword ptr [RSP + 0xc],EAX
SUB EAX,0x72
JZ 0x00102aba
JMP 0x00102aaf
LAB_00102aaf:
MOV EAX,dword ptr [RSP + 0xc]
SUB EAX,0x77
JZ 0x00102ace
JMP 0x00102ae5
LAB_00102aba:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX]
JMP 0x00102b37
LAB_00102ace:
MOV RAX,qword ptr [RSP + 0x10]
MOV RDI,qword ptr [RAX + 0x8]
MOV ESI,dword ptr [RSP + 0x28]
MOV RAX,qword ptr [RDI]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
JMP 0x00102b37
LAB_00102ae5:
MOV EDI,0x10
CALL 0x001020f0
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP],RAX
LAB_00102af9:
LEA RSI,[0x108044]
CALL 0x001020b0
LAB_00102b05:
JMP 0x00102b07
LAB_00102b07:
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [0x0010bff0]
MOV RDX,qword ptr [0x0010bfc0]
CALL 0x001022e0
LAB_00102b37:
ADD RSP,0x38
RET
|
/* CacheHierarchy::processMemoryAccess(char, unsigned int) */
void __thiscall CacheHierarchy::processMemoryAccess(CacheHierarchy *this,char param_1,uint param_2)
{
ulong uVar1;
runtime_error *this_00;
uVar1 = MemoryManager::isPageExist(*(MemoryManager **)this,param_2);
if ((uVar1 & 1) == 0) {
MemoryManager::addPage(*(MemoryManager **)this,param_2);
}
if (param_1 == 'r') {
(**(code **)**(int8 **)(this + 8))(*(int8 **)(this + 8),param_2);
}
else {
if (param_1 != 'w') {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00102af9 to 00102b04 has its CatchHandler @ 00102b1e */
std::runtime_error::runtime_error(this_00,"Illegal memory access operation");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_0010bff0,PTR__runtime_error_0010bfc0);
}
(**(code **)(**(long **)(this + 8) + 8))(*(long **)(this + 8),param_2,0);
}
return;
}
| |
22,280 | CacheHierarchy::processMemoryAccess(char, unsigned int) | DanielDanyang[P]CSC3050-2025-Spring-Project-4/src/MainMulCache.cpp | void processMemoryAccess(char op, uint32_t addr) {
if (!memory->isPageExist(addr)) {
memory->addPage(addr);
}
switch (op) {
case 'r':
l1cache->read(addr);
break;
case 'w':
l1cache->write(addr, 0);
break;
default:
throw std::runtime_error("Illegal memory access operation");
}
} | O2 | cpp | CacheHierarchy::processMemoryAccess(char, unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movq (%rdi), %rdi
movl %edx, %esi
callq 0x2b7e
testb %al, %al
jne 0x276d
movq (%r14), %rdi
movl %ebx, %esi
callq 0x2ac4
movsbl %bpl, %eax
cmpl $0x77, %eax
je 0x278d
cmpl $0x72, %eax
jne 0x27a2
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movl %ebx, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
pushq $0x10
popq %rdi
callq 0x2100
movq %rax, %rbx
leaq 0x28b0(%rip), %rsi # 0x5064
movq %rax, %rdi
callq 0x20a0
movq 0x582d(%rip), %rsi # 0x7ff0
movq 0x57f6(%rip), %rdx # 0x7fc0
movq %rbx, %rdi
callq 0x2270
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x2290
nop
| _ZN14CacheHierarchy19processMemoryAccessEcj:
push rbp
push r14
push rbx
mov ebx, edx
mov ebp, esi
mov r14, rdi
mov rdi, [rdi]; this
mov esi, edx; unsigned int
call _ZN13MemoryManager11isPageExistEj; MemoryManager::isPageExist(uint)
test al, al
jnz short loc_276D
mov rdi, [r14]; this
mov esi, ebx; unsigned int
call _ZN13MemoryManager7addPageEj; MemoryManager::addPage(uint)
loc_276D:
movsx eax, bpl
cmp eax, 77h ; 'w'
jz short loc_278D
cmp eax, 72h ; 'r'
jnz short loc_27A2
mov rdi, [r14+8]
mov rax, [rdi]
mov rax, [rax]
mov esi, ebx
pop rbx
pop r14
pop rbp
jmp rax
loc_278D:
mov rdi, [r14+8]
mov rax, [rdi]
mov rax, [rax+8]
mov esi, ebx
xor edx, edx
pop rbx
pop r14
pop rbp
jmp rax
loc_27A2:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aIllegalMemoryA; "Illegal memory access operation"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
mov rdi, rbx; void *
call ___cxa_free_exception
mov rdi, r14
call __Unwind_Resume
| long long CacheHierarchy::processMemoryAccess(MemoryManager **this, char a2, unsigned int a3)
{
std::runtime_error *exception; // rbx
if ( !(unsigned __int8)MemoryManager::isPageExist(*this, a3) )
MemoryManager::addPage(*this, a3);
if ( a2 == 119 )
return (*(long long ( **)(MemoryManager *, _QWORD, _QWORD))(*(_QWORD *)this[1] + 8LL))(this[1], a3, 0LL);
if ( a2 != 114 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Illegal memory access operation");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return (**(long long ( ***)(MemoryManager *, _QWORD))this[1])(this[1], a3);
}
| processMemoryAccess:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV EBP,ESI
MOV R14,RDI
MOV RDI,qword ptr [RDI]
MOV ESI,EDX
CALL 0x00102b7e
TEST AL,AL
JNZ 0x0010276d
MOV RDI,qword ptr [R14]
MOV ESI,EBX
CALL 0x00102ac4
LAB_0010276d:
MOVSX EAX,BPL
CMP EAX,0x77
JZ 0x0010278d
CMP EAX,0x72
JNZ 0x001027a2
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX]
MOV ESI,EBX
POP RBX
POP R14
POP RBP
JMP RAX
LAB_0010278d:
MOV RDI,qword ptr [R14 + 0x8]
MOV RAX,qword ptr [RDI]
MOV RAX,qword ptr [RAX + 0x8]
MOV ESI,EBX
XOR EDX,EDX
POP RBX
POP R14
POP RBP
JMP RAX
LAB_001027a2:
PUSH 0x10
POP RDI
CALL 0x00102100
MOV RBX,RAX
LAB_001027ad:
LEA RSI,[0x105064]
MOV RDI,RAX
CALL 0x001020a0
LAB_001027bc:
MOV RSI,qword ptr [0x00107ff0]
MOV RDX,qword ptr [0x00107fc0]
MOV RDI,RBX
CALL 0x00102270
|
/* CacheHierarchy::processMemoryAccess(char, unsigned int) */
void __thiscall CacheHierarchy::processMemoryAccess(CacheHierarchy *this,char param_1,uint param_2)
{
char cVar1;
runtime_error *this_00;
cVar1 = MemoryManager::isPageExist(*(MemoryManager **)this,param_2);
if (cVar1 == '\0') {
MemoryManager::addPage(*(MemoryManager **)this,param_2);
}
if (param_1 != 'w') {
if (param_1 == 'r') {
/* WARNING: Could not recover jumptable at 0x0010278b. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)**(int8 **)(this + 8))(*(int8 **)(this + 8),param_2);
return;
}
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001027ad to 001027bb has its CatchHandler @ 001027d2 */
std::runtime_error::runtime_error(this_00,"Illegal memory access operation");
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_00107ff0,PTR__runtime_error_00107fc0);
}
/* WARNING: Could not recover jumptable at 0x001027a0. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(**(long **)(this + 8) + 8))(*(long **)(this + 8),param_2,0);
return;
}
| |
22,281 | minja::Value::at(unsigned long) | monkey531[P]llama/common/minja.hpp | Value& at(size_t index) {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_array()) return array_->at(index);
if (is_object()) return object_->at(index);
throw std::runtime_error("Value is not an array or object: " + dump());
} | O3 | cpp | minja::Value::at(unsigned long):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq 0x10(%rdi), %rcx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x9e10e
testq %rcx, %rcx
jne 0x9e10e
cmpb $0x0, 0x40(%r14)
jne 0x9e10e
cmpq $0x0, 0x30(%r14)
je 0x9e159
testq %rcx, %rcx
je 0x9e141
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x9e18b
leaq (%rsi,%rsi,4), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
jmp 0x9e150
testq %rdi, %rdi
je 0x9e199
leaq 0x8(%rsp), %rsi
callq 0x9e4aa
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x1b450
movq %rax, %rbx
leaq 0x5fcd1(%rip), %rsi # 0xfde3e
movq %rax, %rdi
callq 0x1b330
movq 0x9ce6c(%rip), %rsi # 0x13afe8
movq 0x9cdd5(%rip), %rdx # 0x13af58
movq %rbx, %rdi
callq 0x1bf90
leaq 0x6041c(%rip), %rdi # 0xfe5ae
xorl %eax, %eax
callq 0x1bd60
movl $0x10, %edi
callq 0x1b450
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x941f8
leaq 0x603cb(%rip), %rsi # 0xfe58c
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x86aa5
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x1be80
xorl %ebp, %ebp
movq 0x9cdff(%rip), %rsi # 0x13afe8
movq 0x9cd68(%rip), %rdx # 0x13af58
movq %rbx, %rdi
callq 0x1bf90
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e216
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1b8f0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e231
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8f0
testb %bpl, %bpl
jne 0x9e25d
jmp 0x9e265
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e25d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b8f0
jmp 0x9e25d
jmp 0x9e25a
movq %rax, %r14
movq %rbx, %rdi
callq 0x1b680
movq %r14, %rdi
callq 0x1c020
nop
| _ZN5minja5Value2atEm:
push rbp
push r14
push rbx
sub rsp, 50h
mov r14, rdi
mov [rsp+68h+var_60], rsi
mov rcx, [rdi+10h]
mov rdi, [rdi+20h]
test rdi, rdi
jnz short loc_9E10E
test rcx, rcx
jnz short loc_9E10E
cmp byte ptr [r14+40h], 0
jnz short loc_9E10E
cmp qword ptr [r14+30h], 0
jz short loc_9E159
loc_9E10E:
test rcx, rcx
jz short loc_9E141
mov rax, [rcx]
mov rcx, [rcx+8]
sub rcx, rax
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cmp rdx, rsi
jbe short loc_9E18B
lea rcx, [rsi+rsi*4]
shl rcx, 4
add rax, rcx
jmp short loc_9E150
loc_9E141:
test rdi, rdi
jz short loc_9E199
lea rsi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
loc_9E150:
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_9E159:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rsi, aUndefinedValue; "Undefined value or reference"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_9E18B:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_9E199:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_58]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aValueIsNotAnAr_0; "Value is not an array or object: "
lea rdi, [rsp+68h+var_38]
lea rdx, [rsp+68h+var_58]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+68h+var_38]
mov rdi, rbx
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+68h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9E216
mov rsi, [rsp+68h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9E216:
lea rax, [rsp+68h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9E231
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_9E231:
test bpl, bpl
jnz short loc_9E25D
jmp short loc_9E265
mov r14, rax
lea rax, [rsp+68h+var_48]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_9E25D
mov rsi, [rsp+68h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_9E25D
jmp short $+2
loc_9E25A:
mov r14, rax
loc_9E25D:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_9E265:
mov rdi, r14
call __Unwind_Resume
| unsigned long long minja::Value::at(minja::Value *this, unsigned long long a2)
{
_QWORD *v3; // rcx
long long v4; // rdi
unsigned long long v5; // rdx
std::runtime_error *exception; // rbx
void *v8; // rbx
unsigned long long v9; // [rsp+8h] [rbp-60h] BYREF
_BYTE v10[16]; // [rsp+10h] [rbp-58h] BYREF
_BYTE v11[16]; // [rsp+30h] [rbp-38h] BYREF
v9 = a2;
v3 = (_QWORD *)*((_QWORD *)this + 2);
v4 = *((_QWORD *)this + 4);
if ( !v4 && !v3 && !*((_BYTE *)this + 64) && !*((_QWORD *)this + 6) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Undefined value or reference");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( v3 )
{
v5 = 0xCCCCCCCCCCCCCCCDLL * ((long long)(v3[1] - *v3) >> 4);
if ( v5 <= a2 )
std::__throw_out_of_range_fmt("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)", a2, v5);
return 80 * a2 + *v3;
}
else
{
if ( !v4 )
{
v8 = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v10, (long long)this, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v11, (long long)"Value is not an array or object: ", (long long)v10);
std::runtime_error::runtime_error(v8, v11);
__cxa_throw(
v8,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_(
v4,
&v9);
}
}
| at:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RCX,qword ptr [RDI + 0x10]
MOV RDI,qword ptr [RDI + 0x20]
TEST RDI,RDI
JNZ 0x0019e10e
TEST RCX,RCX
JNZ 0x0019e10e
CMP byte ptr [R14 + 0x40],0x0
JNZ 0x0019e10e
CMP qword ptr [R14 + 0x30],0x0
JZ 0x0019e159
LAB_0019e10e:
TEST RCX,RCX
JZ 0x0019e141
MOV RAX,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RAX
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CMP RDX,RSI
JBE 0x0019e18b
LEA RCX,[RSI + RSI*0x4]
SHL RCX,0x4
ADD RAX,RCX
JMP 0x0019e150
LAB_0019e141:
TEST RDI,RDI
JZ 0x0019e199
LEA RSI,[RSP + 0x8]
CALL 0x0019e4aa
LAB_0019e150:
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0019e159:
MOV EDI,0x10
CALL 0x0011b450
MOV RBX,RAX
LAB_0019e166:
LEA RSI,[0x1fde3e]
MOV RDI,RAX
CALL 0x0011b330
LAB_0019e175:
MOV RSI,qword ptr [0x0023afe8]
MOV RDX,qword ptr [0x0023af58]
MOV RDI,RBX
CALL 0x0011bf90
LAB_0019e18b:
LEA RDI,[0x1fe5ae]
XOR EAX,EAX
CALL 0x0011bd60
LAB_0019e199:
MOV EDI,0x10
CALL 0x0011b450
MOV RBX,RAX
LAB_0019e1a6:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x001941f8
LAB_0019e1ba:
LEA RSI,[0x1fe58c]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0x10]
CALL 0x00186aa5
MOV BPL,0x1
LAB_0019e1d3:
LEA RSI,[RSP + 0x30]
MOV RDI,RBX
CALL 0x0011be80
XOR EBP,EBP
MOV RSI,qword ptr [0x0023afe8]
MOV RDX,qword ptr [0x0023af58]
MOV RDI,RBX
CALL 0x0011bf90
|
/* minja::Value::at(unsigned long) */
long __thiscall minja::Value::at(Value *this,ulong param_1)
{
long *plVar1;
long lVar2;
runtime_error *prVar3;
ulong uVar4;
ulong local_60;
int1 local_58 [32];
string local_38 [32];
plVar1 = *(long **)(this + 0x10);
lVar2 = *(long *)(this + 0x20);
local_60 = param_1;
if ((((lVar2 == 0) && (plVar1 == (long *)0x0)) && (this[0x40] == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019e166 to 0019e174 has its CatchHandler @ 0019e25a */
std::runtime_error::runtime_error(prVar3,"Undefined value or reference");
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0023afe8,PTR__runtime_error_0023af58);
}
if (plVar1 == (long *)0x0) {
if (lVar2 == 0) goto LAB_0019e199;
lVar2 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE2atIRmTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvESD_T_EE5valueEiE4typeELi0EEERSF_OSS_
(lVar2,&local_60);
}
else {
uVar4 = (plVar1[1] - *plVar1 >> 4) * -0x3333333333333333;
if (uVar4 < param_1 || uVar4 - param_1 == 0) {
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)");
LAB_0019e199:
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0019e1a6 to 0019e1b9 has its CatchHandler @ 0019e258 */
dump_abi_cxx11_((int)local_58,SUB81(this,0));
/* try { // try from 0019e1ba to 0019e1cf has its CatchHandler @ 0019e238 */
std::operator+((char *)local_38,(string *)"Value is not an array or object: ");
/* try { // try from 0019e1d3 to 0019e1f7 has its CatchHandler @ 0019e1f8 */
std::runtime_error::runtime_error(prVar3,local_38);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_0023afe8,PTR__runtime_error_0023af58);
}
lVar2 = *plVar1 + param_1 * 0x50;
}
return lVar2;
}
| |
22,282 | get_charset | eloqsql/mysys/charset.c | CHARSET_INFO *get_charset(uint cs_number, myf flags)
{
CHARSET_INFO *cs= NULL;
if (cs_number == default_charset_info->number)
return default_charset_info;
my_pthread_once(&charsets_initialized, init_available_charsets);
if (cs_number < array_elements(all_charsets))
{
MY_CHARSET_LOADER loader;
my_charset_loader_init_mysys(&loader);
cs= get_internal_charset(&loader, cs_number, flags);
}
if (!cs && (flags & MY_WME))
{
char index_file[FN_REFLEN + sizeof(MY_CHARSET_INDEX)], cs_string[23];
strmov(get_charsets_dir(index_file),MY_CHARSET_INDEX);
cs_string[0]='#';
int10_to_str(cs_number, cs_string+1, 10);
my_error(EE_UNKNOWN_CHARSET, MYF(ME_BELL), cs_string, index_file);
}
return cs;
} | O3 | c | get_charset:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %fs:0x28, %rax
movq %rax, -0x20(%rbp)
leaq 0x2f2c4a(%rip), %rax # 0x3856f8
movq (%rax), %r15
cmpl %edi, (%r15)
je 0x92bb5
movq %rsi, %r14
movl %edi, %ebx
leaq 0xb7506a(%rip), %rdi # 0xc07b30
leaq -0x382(%rip), %rsi # 0x9274b
callq 0x29240
cmpl $0x7ff, %ebx # imm = 0x7FF
ja 0x92b4a
leaq -0x230(%rbp), %rdi
movb $0x0, (%rdi)
leaq -0xb6d(%rip), %rax # 0x91f7e
movq %rax, 0x80(%rdi)
leaq -0xb6c(%rip), %rax # 0x91f8d
movq %rax, 0x88(%rdi)
leaq -0xb5f(%rip), %rax # 0x91fa8
movq %rax, 0x90(%rdi)
leaq 0xd4c9(%rip), %rax # 0x9ffde
movq %rax, 0x98(%rdi)
leaq 0x2f2bcd(%rip), %rax # 0x3856f0
movq (%rax), %rax
movq %rax, 0xa0(%rdi)
leaq -0xb6e(%rip), %rax # 0x91fc6
movq %rax, 0xa8(%rdi)
movl %ebx, %esi
movq %r14, %rdx
callq 0x92bda
movq %rax, %r15
jmp 0x92b4d
xorl %r15d, %r15d
testq %r15, %r15
setne %al
testb $0x10, %r14b
sete %cl
orb %al, %cl
jne 0x92bb5
leaq -0x230(%rbp), %r14
movq %r14, %rdi
callq 0x9250b
movabsq $0x6d782e7865646e49, %rcx # imm = 0x6D782E7865646E49
movq %rcx, (%rax)
movw $0x6c, 0x8(%rax)
leaq -0x24f(%rbp), %rsi
movb $0x23, -0x1(%rsi)
movl %ebx, %edi
movl $0xa, %edx
callq 0xd5802
xorl %r15d, %r15d
leaq -0x250(%rbp), %rdx
movl $0x4, %esi
movl $0x16, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x9e1d7
movq %fs:0x28, %rax
cmpq -0x20(%rbp), %rax
jne 0x92bd5
movq %r15, %rax
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
| get_charset:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
sub rsp, 238h
mov rax, fs:28h
mov [rbp+var_20], rax
lea rax, default_charset_info
mov r15, [rax]
cmp [r15], edi
jz loc_92BB5
mov r14, rsi
mov ebx, edi
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
cmp ebx, 7FFh
ja short loc_92B4A
lea rdi, [rbp+var_230]
mov byte ptr [rdi], 0
lea rax, my_once_alloc_c
mov [rdi+80h], rax
lea rax, my_malloc_c
mov [rdi+88h], rax
lea rax, my_realloc_c
mov [rdi+90h], rax
lea rax, my_free
mov [rdi+98h], rax
lea rax, my_charset_error_reporter
mov rax, [rax]
mov [rdi+0A0h], rax
lea rax, add_collation
mov [rdi+0A8h], rax
mov esi, ebx
mov rdx, r14
call get_internal_charset
mov r15, rax
jmp short loc_92B4D
loc_92B4A:
xor r15d, r15d
loc_92B4D:
test r15, r15
setnz al
test r14b, 10h
setz cl
or cl, al
jnz short loc_92BB5
lea r14, [rbp+var_230]
mov rdi, r14
call get_charsets_dir
mov rcx, 6D782E7865646E49h
mov [rax], rcx
mov word ptr [rax+8], 6Ch ; 'l'
lea rsi, [rbp+var_24F]
mov byte ptr [rsi-1], 23h ; '#'
mov edi, ebx
mov edx, 0Ah
call int10_to_str
xor r15d, r15d
lea rdx, [rbp+var_250]
mov esi, 4
mov edi, 16h
mov rcx, r14
xor eax, eax
call my_error
loc_92BB5:
mov rax, fs:28h
cmp rax, [rbp+var_20]
jnz short loc_92BD5
mov rax, r15
add rsp, 238h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_92BD5:
call ___stack_chk_fail
| void * get_charset(unsigned int a1, long long a2)
{
void *internal_charset; // r15
int v3; // r8d
int v4; // r9d
char v6; // [rsp+0h] [rbp-250h] BYREF
_BYTE v7[31]; // [rsp+1h] [rbp-24Fh] BYREF
_BYTE v8[128]; // [rsp+20h] [rbp-230h] BYREF
long long ( *v9)(long long); // [rsp+A0h] [rbp-1B0h]
long long ( *v10)(long long); // [rsp+A8h] [rbp-1A8h]
long long ( *v11)(long long, long long, long long, long long, long long, long long); // [rsp+B0h] [rbp-1A0h]
long long ( *v12)(_QWORD); // [rsp+B8h] [rbp-198h]
long long ( *v13)(); // [rsp+C0h] [rbp-190h]
long long ( *v14)(unsigned int *); // [rsp+C8h] [rbp-188h]
unsigned long long v15; // [rsp+230h] [rbp-20h]
v15 = __readfsqword(0x28u);
internal_charset = default_charset_info;
if ( *(_DWORD *)default_charset_info != a1 )
{
pthread_once(&charsets_initialized, init_available_charsets);
if ( a1 > 0x7FF )
{
internal_charset = 0LL;
}
else
{
v8[0] = 0;
v9 = my_once_alloc_c;
v10 = my_malloc_c;
v11 = my_realloc_c;
v12 = my_free;
v13 = my_charset_error_reporter;
v14 = add_collation;
internal_charset = (void *)get_internal_charset(v8, a1, a2);
}
if ( internal_charset == 0LL && (a2 & 0x10) != 0 )
{
strcpy((char *)get_charsets_dir((long long)v8), "Index.xml");
v6 = 35;
int10_to_str(a1, v7, 10LL);
internal_charset = 0LL;
my_error(22, 4, (unsigned int)&v6, (unsigned int)v8, v3, v4);
}
}
return internal_charset;
}
| get_charset:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x238
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x4856f8]
MOV R15,qword ptr [RAX]
CMP dword ptr [R15],EDI
JZ 0x00192bb5
MOV R14,RSI
MOV EBX,EDI
LEA RDI,[0xd07b30]
LEA RSI,[0x19274b]
CALL 0x00129240
CMP EBX,0x7ff
JA 0x00192b4a
LEA RDI,[RBP + -0x230]
MOV byte ptr [RDI],0x0
LEA RAX,[0x191f7e]
MOV qword ptr [RDI + 0x80],RAX
LEA RAX,[0x191f8d]
MOV qword ptr [RDI + 0x88],RAX
LEA RAX,[0x191fa8]
MOV qword ptr [RDI + 0x90],RAX
LEA RAX,[0x19ffde]
MOV qword ptr [RDI + 0x98],RAX
LEA RAX,[0x4856f0]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RDI + 0xa0],RAX
LEA RAX,[0x191fc6]
MOV qword ptr [RDI + 0xa8],RAX
MOV ESI,EBX
MOV RDX,R14
CALL 0x00192bda
MOV R15,RAX
JMP 0x00192b4d
LAB_00192b4a:
XOR R15D,R15D
LAB_00192b4d:
TEST R15,R15
SETNZ AL
TEST R14B,0x10
SETZ CL
OR CL,AL
JNZ 0x00192bb5
LEA R14,[RBP + -0x230]
MOV RDI,R14
CALL 0x0019250b
MOV RCX,0x6d782e7865646e49
MOV qword ptr [RAX],RCX
MOV word ptr [RAX + 0x8],0x6c
LEA RSI,[RBP + -0x24f]
MOV byte ptr [RSI + -0x1],0x23
MOV EDI,EBX
MOV EDX,0xa
CALL 0x001d5802
XOR R15D,R15D
LEA RDX,[RBP + -0x250]
MOV ESI,0x4
MOV EDI,0x16
MOV RCX,R14
XOR EAX,EAX
CALL 0x0019e1d7
LAB_00192bb5:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x20]
JNZ 0x00192bd5
MOV RAX,R15
ADD RSP,0x238
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_00192bd5:
CALL 0x00129270
|
int * get_charset(uint param_1,ulong param_2)
{
int *puVar1;
int8 *puVar2;
long in_FS_OFFSET;
int1 local_258;
int1 local_257 [31];
int1 local_238 [128];
code *local_1b8;
code *local_1b0;
code *local_1a8;
code *local_1a0;
int *local_198;
code *local_190;
long local_28;
local_28 = *(long *)(in_FS_OFFSET + 0x28);
puVar1 = default_charset_info;
if (*(uint *)default_charset_info != param_1) {
pthread_once(&charsets_initialized,init_available_charsets);
if (param_1 < 0x800) {
local_238[0] = 0;
local_1b8 = my_once_alloc_c;
local_1b0 = my_malloc_c;
local_1a8 = my_realloc_c;
local_1a0 = my_free;
local_198 = my_charset_error_reporter;
local_190 = add_collation;
puVar1 = (int *)get_internal_charset(local_238,param_1,param_2);
}
else {
puVar1 = (int *)0x0;
}
if ((param_2 & 0x10) != 0 && puVar1 == (int *)0x0) {
puVar2 = (int8 *)get_charsets_dir(local_238);
*puVar2 = 0x6d782e7865646e49;
*(int2 *)(puVar2 + 1) = 0x6c;
local_258 = 0x23;
int10_to_str(param_1,local_257,10);
puVar1 = (int *)0x0;
my_error(0x16,4,&local_258,local_238);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_28) {
return puVar1;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
22,283 | testing::internal::posix::GetEnv(char const*) | AlayaLite/build_O0/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h | inline const char* GetEnv(const char* name) {
#if defined(GTEST_OS_WINDOWS_MOBILE) || defined(GTEST_OS_WINDOWS_PHONE) || \
defined(GTEST_OS_ESP8266) || defined(GTEST_OS_XTENSA) || \
defined(GTEST_OS_QURT)
// We are on an embedded platform, which has no environment variables.
static_cast<void>(name); // To prevent 'unused argument' warning.
return nullptr;
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
// Environment variables which we programmatically clear will be set to the
// empty string rather than unset (NULL). Handle that case.
const char* const env = getenv(name);
return (env != nullptr && env[0] != '\0') ? env : nullptr;
#else
return getenv(name);
#endif
} | O0 | c | testing::internal::posix::GetEnv(char const*):
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x15930
popq %rcx
retq
| _ZN7testing8internal5posix6GetEnvEPKc:
push rax
mov [rsp+8+var_8], rdi
mov rdi, [rsp+8+var_8]
call _getenv
pop rcx
retn
| long long testing::internal::posix::GetEnv(testing::internal::posix *this, const char *a2)
{
return getenv(this);
}
| _S_check_init_len:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV qword ptr [RSP + 0x18],RSI
MOV RAX,qword ptr [RSP + 0x20]
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RSP + 0x18]
LEA RDI,[RSP + 0x17]
CALL 0x00125250
LEA RDI,[RSP + 0x17]
CALL 0x001251f0
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0x17]
CALL 0x001231f0
MOV RCX,qword ptr [RSP]
MOV RAX,qword ptr [RSP + 0x8]
CMP RAX,RCX
JBE 0x00125129
LEA RDI,[0x24d75a]
CALL 0x001153e0
LAB_00125129:
MOV RAX,qword ptr [RSP + 0x20]
ADD RSP,0x28
RET
|
/* std::vector<float, std::allocator<float> >::_S_check_init_len(unsigned long,
std::allocator<float> const&) */
ulong std::vector<float,std::allocator<float>>::_S_check_init_len(ulong param_1,allocator *param_2)
{
ulong uVar1;
allocator local_11;
allocator *local_10;
ulong local_8;
local_10 = param_2;
local_8 = param_1;
allocator<float>::allocator(&local_11);
uVar1 = _S_max_size(&local_11);
allocator<float>::~allocator((allocator<float> *)&local_11);
if (uVar1 < param_1) {
std::__throw_length_error("cannot create std::vector larger than max_size()");
}
return local_8;
}
| |
22,284 | my_caseup_utf8mb4 | eloqsql/strings/ctype-utf8.c | static size_t
my_caseup_utf8mb4(CHARSET_INFO *cs, const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
} | O0 | c | my_caseup_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x75efa
jmp 0x75efc
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x75f2c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x75b60
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x75f35
jmp 0x75f88
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x79e10
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x75b90
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0x75f61
jmp 0x75f88
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x75efc
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| my_caseup_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_75EFA:
jmp short $+2
loc_75EFC:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_75F2C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_mb_wc_utf8mb4
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_75F2C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_75F35
jmp short loc_75F88
loc_75F35:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_toupper_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_wc_mb_utf8mb4
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_75F61
jmp short loc_75F88
loc_75F61:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
mov ecx, [rbp+var_38]
mov rax, [rbp+var_20]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_20], rax
jmp loc_75EFC
loc_75F88:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
| _BYTE * my_caseup_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_mb_wc_utf8mb4(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_toupper_utf8mb4(v8, v14);
v12 = my_wc_mb_utf8mb4(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
| my_caseup_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00175efa
LAB_00175efa:
JMP 0x00175efc
LAB_00175efc:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x00175f2c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00175b60
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_00175f2c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x00175f35
JMP 0x00175f88
LAB_00175f35:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x00179e10
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x48]
CALL 0x00175b90
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x00175f61
JMP 0x00175f88
LAB_00175f61:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
MOV ECX,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x20]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
JMP 0x00175efc
LAB_00175f88:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf8mb4(uVar1,&local_38);
iVar3 = my_wc_mb_utf8mb4(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
| |
22,285 | check_longlong | eloqsql/strings/my_vsnprintf.c | static const char *check_longlong(const char *fmt, uint *have_longlong)
{
*have_longlong= 0;
if (*fmt == 'l')
{
fmt++;
if (*fmt != 'l')
*have_longlong= (sizeof(long) == sizeof(longlong));
else
{
fmt++;
*have_longlong= 1;
}
}
else if (*fmt == 'z')
{
fmt++;
*have_longlong= (sizeof(size_t) == sizeof(longlong));
}
else if (*fmt == 'p')
*have_longlong= (sizeof(void *) == sizeof(longlong));
return fmt;
} | O0 | c | check_longlong:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0xc953e
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0xc9526
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0xc953c
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0xc957c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7a, %eax
jne 0xc9562
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0xc957a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0xc9578
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
jmp 0xc957a
jmp 0xc957c
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| check_longlong:
push rbp
mov rbp, rsp
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov dword ptr [rax], 0
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jnz short loc_C953E
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_C9526
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_C953C
loc_C9526:
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
loc_C953C:
jmp short loc_C957C
loc_C953E:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 7Ah ; 'z'
jnz short loc_C9562
mov rax, [rbp+var_8]
add rax, 1
mov [rbp+var_8], rax
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
jmp short loc_C957A
loc_C9562:
mov rax, [rbp+var_8]
movsx eax, byte ptr [rax]
cmp eax, 70h ; 'p'
jnz short loc_C9578
mov rax, [rbp+var_10]
mov dword ptr [rax], 1
loc_C9578:
jmp short $+2
loc_C957A:
jmp short $+2
loc_C957C:
mov rax, [rbp+var_8]
pop rbp
retn
| _BYTE * check_longlong(_BYTE *a1, _DWORD *a2)
{
_BYTE *v3; // [rsp+8h] [rbp-8h]
v3 = a1;
*a2 = 0;
switch ( *a1 )
{
case 'l':
v3 = a1 + 1;
if ( a1[1] == 108 )
v3 = a1 + 2;
*a2 = 1;
break;
case 'z':
v3 = a1 + 1;
*a2 = 1;
break;
case 'p':
*a2 = 1;
break;
}
return v3;
}
| check_longlong:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JNZ 0x001c953e
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x001c9526
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x001c953c
LAB_001c9526:
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
LAB_001c953c:
JMP 0x001c957c
LAB_001c953e:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x7a
JNZ 0x001c9562
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,0x1
MOV qword ptr [RBP + -0x8],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
JMP 0x001c957a
LAB_001c9562:
MOV RAX,qword ptr [RBP + -0x8]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x70
JNZ 0x001c9578
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX],0x1
LAB_001c9578:
JMP 0x001c957a
LAB_001c957a:
JMP 0x001c957c
LAB_001c957c:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
char * check_longlong(char *param_1,int4 *param_2)
{
char *local_10;
*param_2 = 0;
if (*param_1 == 'l') {
local_10 = param_1 + 1;
if (*local_10 == 'l') {
local_10 = param_1 + 2;
*param_2 = 1;
}
else {
*param_2 = 1;
}
}
else if (*param_1 == 'z') {
local_10 = param_1 + 1;
*param_2 = 1;
}
else {
local_10 = param_1;
if (*param_1 == 'p') {
*param_2 = 1;
}
}
return local_10;
}
| |
22,286 | check_mb_utf8_valid | eloqsql/libmariadb/libmariadb/ma_charset.c | static unsigned int check_mb_utf8_valid(const char *start, const char *end)
{
unsigned int len = check_mb_utf8_sequence(start, end);
return (len > 1)? len:0;
} | O3 | c | check_mb_utf8_valid:
pushq %rbp
movq %rsp, %rbp
cmpq %rsi, %rdi
jae 0x17a4b
movb (%rdi), %al
cmpb $-0x3e, %al
jae 0x17a4f
xorl %eax, %eax
popq %rbp
retq
cmpb $-0x21, %al
ja 0x17a69
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
ja 0x17a4b
movl $0x2, %eax
cmpb $-0x40, 0x1(%rdi)
jge 0x17a4b
jmp 0x17a4d
cmpb $-0x11, %al
ja 0x17a9a
leaq 0x3(%rdi), %rcx
cmpq %rsi, %rcx
ja 0x17a4b
movb 0x1(%rdi), %cl
cmpb $-0x41, %cl
jg 0x17a4b
cmpb $-0x41, 0x2(%rdi)
jg 0x17a4b
cmpb $-0x20, %al
setne %al
cmpb $-0x60, %cl
setae %cl
orb %al, %cl
movl $0x3, %eax
je 0x17a4b
jmp 0x17a4d
cmpb $-0xb, %al
setae %cl
leaq 0x4(%rdi), %rdx
cmpq %rsi, %rdx
seta %dl
orb %cl, %dl
jne 0x17a4b
movb 0x1(%rdi), %cl
cmpb $-0x41, %cl
jg 0x17a4b
cmpb $-0x41, 0x2(%rdi)
jg 0x17a4b
cmpb $-0x41, 0x3(%rdi)
jg 0x17a4b
cmpb $-0x10, %al
sete %dl
cmpb $-0x70, %cl
setb %sil
testb %sil, %dl
jne 0x17a4b
cmpb $-0xc, %al
setne %al
cmpb $-0x70, %cl
setb %cl
orb %al, %cl
movl $0x4, %eax
je 0x17a4b
jmp 0x17a4d
| check_mb_utf8_valid:
push rbp
mov rbp, rsp
cmp rdi, rsi
jnb short loc_17A4B
mov al, [rdi]
cmp al, 0C2h
jnb short loc_17A4F
loc_17A4B:
xor eax, eax
loc_17A4D:
pop rbp
retn
loc_17A4F:
cmp al, 0DFh
ja short loc_17A69
lea rax, [rdi+2]
cmp rax, rsi
ja short loc_17A4B
mov eax, 2
cmp byte ptr [rdi+1], 0C0h
jge short loc_17A4B
jmp short loc_17A4D
loc_17A69:
cmp al, 0EFh
ja short loc_17A9A
lea rcx, [rdi+3]
cmp rcx, rsi
ja short loc_17A4B
mov cl, [rdi+1]
cmp cl, 0BFh
jg short loc_17A4B
cmp byte ptr [rdi+2], 0BFh
jg short loc_17A4B
cmp al, 0E0h
setnz al
cmp cl, 0A0h
setnb cl
or cl, al
mov eax, 3
jz short loc_17A4B
jmp short loc_17A4D
loc_17A9A:
cmp al, 0F5h
setnb cl
lea rdx, [rdi+4]
cmp rdx, rsi
setnbe dl
or dl, cl
jnz short loc_17A4B
mov cl, [rdi+1]
cmp cl, 0BFh
jg short loc_17A4B
cmp byte ptr [rdi+2], 0BFh
jg short loc_17A4B
cmp byte ptr [rdi+3], 0BFh
jg short loc_17A4B
cmp al, 0F0h
setz dl
cmp cl, 90h
setb sil
test dl, sil
jnz loc_17A4B
cmp al, 0F4h
setnz al
cmp cl, 90h
setb cl
or cl, al
mov eax, 4
jz loc_17A4B
jmp loc_17A4D
| long long check_mb_utf8_valid(unsigned __int8 *a1, unsigned long long a2)
{
unsigned __int8 v2; // al
long long result; // rax
char v4; // cl
bool v5; // cl
char v6; // cl
bool v7; // cl
if ( (unsigned long long)a1 >= a2 )
return 0LL;
v2 = *a1;
if ( *a1 < 0xC2u )
return 0LL;
if ( v2 <= 0xDFu )
{
if ( (unsigned long long)(a1 + 2) <= a2 )
{
result = 2LL;
if ( (char)a1[1] < -64 )
return result;
}
return 0LL;
}
if ( v2 > 0xEFu )
{
if ( v2 >= 0xF5u || (unsigned long long)(a1 + 4) > a2 )
return 0LL;
v6 = a1[1];
if ( v6 > -65 )
return 0LL;
if ( (char)a1[2] > -65 )
return 0LL;
if ( (char)a1[3] > -65 )
return 0LL;
if ( (unsigned __int8)v6 < 0x90u && v2 == 0xF0 )
return 0LL;
v7 = v2 != 0xF4 || (unsigned __int8)v6 < 0x90u;
result = 4LL;
if ( !v7 )
return 0LL;
}
else
{
if ( (unsigned long long)(a1 + 3) > a2 )
return 0LL;
v4 = a1[1];
if ( v4 > -65 )
return 0LL;
if ( (char)a1[2] > -65 )
return 0LL;
v5 = v2 != 0xE0 || (unsigned __int8)v4 >= 0xA0u;
result = 3LL;
if ( !v5 )
return 0LL;
}
return result;
}
| check_mb_utf8_valid:
PUSH RBP
MOV RBP,RSP
CMP RDI,RSI
JNC 0x00117a4b
MOV AL,byte ptr [RDI]
CMP AL,0xc2
JNC 0x00117a4f
LAB_00117a4b:
XOR EAX,EAX
LAB_00117a4d:
POP RBP
RET
LAB_00117a4f:
CMP AL,0xdf
JA 0x00117a69
LEA RAX,[RDI + 0x2]
CMP RAX,RSI
JA 0x00117a4b
MOV EAX,0x2
CMP byte ptr [RDI + 0x1],0xc0
JGE 0x00117a4b
JMP 0x00117a4d
LAB_00117a69:
CMP AL,0xef
JA 0x00117a9a
LEA RCX,[RDI + 0x3]
CMP RCX,RSI
JA 0x00117a4b
MOV CL,byte ptr [RDI + 0x1]
CMP CL,0xbf
JG 0x00117a4b
CMP byte ptr [RDI + 0x2],0xbf
JG 0x00117a4b
CMP AL,0xe0
SETNZ AL
CMP CL,0xa0
SETNC CL
OR CL,AL
MOV EAX,0x3
JZ 0x00117a4b
JMP 0x00117a4d
LAB_00117a9a:
CMP AL,0xf5
SETNC CL
LEA RDX,[RDI + 0x4]
CMP RDX,RSI
SETA DL
OR DL,CL
JNZ 0x00117a4b
MOV CL,byte ptr [RDI + 0x1]
CMP CL,0xbf
JG 0x00117a4b
CMP byte ptr [RDI + 0x2],0xbf
JG 0x00117a4b
CMP byte ptr [RDI + 0x3],0xbf
JG 0x00117a4b
CMP AL,0xf0
SETZ DL
CMP CL,0x90
SETC SIL
TEST DL,SIL
JNZ 0x00117a4b
CMP AL,0xf4
SETNZ AL
CMP CL,0x90
SETC CL
OR CL,AL
MOV EAX,0x4
JZ 0x00117a4b
JMP 0x00117a4d
|
int8 check_mb_utf8_valid(byte *param_1,byte *param_2)
{
byte bVar1;
byte bVar2;
if ((param_1 < param_2) && (bVar1 = *param_1, 0xc1 < bVar1)) {
if (bVar1 < 0xe0) {
if ((param_1 + 2 <= param_2) && ((char)param_1[1] < -0x40)) {
return 2;
}
}
else if (bVar1 < 0xf0) {
if (((param_1 + 3 <= param_2) && ((char)param_1[1] < -0x40)) &&
(((char)param_1[2] < -0x40 && (0x9f < param_1[1] || bVar1 != 0xe0)))) {
return 3;
}
}
else if (((((param_1 + 4 <= param_2 && bVar1 < 0xf5) &&
(bVar2 = param_1[1], (char)bVar2 < -0x40)) && ((char)param_1[2] < -0x40)) &&
(((char)param_1[3] < -0x40 && (bVar1 != 0xf0 || 0x8f < bVar2)))) &&
(bVar2 < 0x90 || bVar1 != 0xf4)) {
return 4;
}
}
return 0;
}
| |
22,287 | dbuf_put_self | bluesky950520[P]quickjs/cutils.c | int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
} | O0 | c | dbuf_put_self:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
seta %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1e677
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
addq 0x8(%rsp), %rsi
callq 0x1e3f0
cmpl $0x0, %eax
je 0x1e675
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1e6b9
jmp 0x1e677
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xe5b0
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| dbuf_put_self:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov [rsp+28h+var_20], rdx
mov rax, [rsp+28h+var_10]
mov rax, [rax+8]
add rax, [rsp+28h+var_20]
mov rcx, [rsp+28h+var_10]
cmp rax, [rcx+10h]
setnbe al
xor al, 0FFh
xor al, 0FFh
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_1E677
mov rdi, [rsp+28h+var_10]
mov rax, [rsp+28h+var_10]
mov rsi, [rax+8]
add rsi, [rsp+28h+var_20]
call dbuf_realloc
cmp eax, 0
jz short loc_1E675
mov [rsp+28h+var_4], 0FFFFFFFFh
jmp short loc_1E6B9
loc_1E675:
jmp short $+2
loc_1E677:
mov rax, [rsp+28h+var_10]
mov rdi, [rax]
mov rax, [rsp+28h+var_10]
add rdi, [rax+8]
mov rax, [rsp+28h+var_10]
mov rsi, [rax]
add rsi, [rsp+28h+var_18]
mov rdx, [rsp+28h+var_20]
call _memcpy
mov rcx, [rsp+28h+var_20]
mov rax, [rsp+28h+var_10]
add rcx, [rax+8]
mov [rax+8], rcx
mov [rsp+28h+var_4], 0
loc_1E6B9:
mov eax, [rsp+28h+var_4]
add rsp, 28h
retn
| long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
if ( (unsigned long long)(a3 + a1[1]) > a1[2] && (unsigned int)dbuf_realloc((long long)a1, a3 + a1[1]) )
{
return (unsigned int)-1;
}
else
{
memcpy(a1[1] + *a1, a2 + *a1, a3);
a1[1] += a3;
return 0;
}
}
| dbuf_put_self:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV qword ptr [RSP + 0x8],RDX
MOV RAX,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RAX + 0x8]
ADD RAX,qword ptr [RSP + 0x8]
MOV RCX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RCX + 0x10]
SETA AL
XOR AL,0xff
XOR AL,0xff
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x0011e677
MOV RDI,qword ptr [RSP + 0x18]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX + 0x8]
ADD RSI,qword ptr [RSP + 0x8]
CALL 0x0011e3f0
CMP EAX,0x0
JZ 0x0011e675
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x0011e6b9
LAB_0011e675:
JMP 0x0011e677
LAB_0011e677:
MOV RAX,qword ptr [RSP + 0x18]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0x18]
ADD RDI,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
ADD RSI,qword ptr [RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x0010e5b0
MOV RCX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RSP + 0x18]
ADD RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RSP + 0x24],0x0
LAB_0011e6b9:
MOV EAX,dword ptr [RSP + 0x24]
ADD RSP,0x28
RET
|
int4 dbuf_put_self(long *param_1,long param_2,size_t param_3)
{
int iVar1;
int4 local_4;
if (((ulong)param_1[2] < param_1[1] + param_3) &&
(iVar1 = dbuf_realloc(param_1,param_1[1] + param_3), iVar1 != 0)) {
local_4 = 0xffffffff;
}
else {
memcpy((void *)(*param_1 + param_1[1]),(void *)(*param_1 + param_2),param_3);
param_1[1] = param_3 + param_1[1];
local_4 = 0;
}
return local_4;
}
| |
22,288 | dbuf_put_self | bluesky950520[P]quickjs/cutils.c | int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
} | O1 | c | dbuf_put_self:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rsi
addq %rdx, %rsi
cmpq 0x10(%rdi), %rsi
ja 0x1b4bb
movq (%r14), %rax
movq 0x8(%r14), %rdi
addq %rax, %rdi
addq %rax, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe5b0
addq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1b375
movl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1b4b5
jmp 0x1b497
| dbuf_put_self:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rsi, [rdi+8]
add rsi, rdx
cmp rsi, [rdi+10h]
ja short loc_1B4BB
loc_1B497:
mov rax, [r14]
mov rdi, [r14+8]
add rdi, rax
add r15, rax
mov rsi, r15
mov rdx, rbx
call _memcpy
add [r14+8], rbx
xor eax, eax
loc_1B4B5:
pop rbx
pop r14
pop r15
retn
loc_1B4BB:
mov rdi, r14
call dbuf_realloc
mov ecx, eax
mov eax, 0FFFFFFFFh
test ecx, ecx
jnz short loc_1B4B5
jmp short loc_1B497
| long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
unsigned long long v5; // rsi
long long result; // rax
int v7; // ecx
v5 = a3 + a1[1];
if ( v5 <= a1[2] || (v7 = dbuf_realloc((long long)a1, v5), result = 0xFFFFFFFFLL, !v7) )
{
memcpy(*a1 + a1[1], *a1 + a2, a3);
a1[1] += a3;
return 0LL;
}
return result;
}
| |||
22,289 | dbuf_put_self | bluesky950520[P]quickjs/cutils.c | int dbuf_put_self(DynBuf *s, size_t offset, size_t len)
{
if (unlikely((s->size + len) > s->allocated_size)) {
if (dbuf_realloc(s, s->size + len))
return -1;
}
memcpy(s->buf + s->size, s->buf + offset, len);
s->size += len;
return 0;
} | O2 | c | dbuf_put_self:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rdx), %rsi
cmpq 0x10(%r14), %rsi
ja 0x15d1c
movq (%r14), %rax
addq %rax, %rdi
addq %rax, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0xe5c0
addq %rbx, 0x8(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x15bdf
testl %eax, %eax
je 0x15d2d
pushq $-0x1
popq %rax
jmp 0x15d16
movq 0x8(%r14), %rdi
jmp 0x15cfc
| dbuf_put_self:
push r15
push r14
push rbx
mov rbx, rdx
mov r15, rsi
mov r14, rdi
mov rdi, [rdi+8]
lea rsi, [rdi+rdx]
cmp rsi, [r14+10h]
ja short loc_15D1C
loc_15CFC:
mov rax, [r14]
add rdi, rax
add r15, rax
mov rsi, r15
mov rdx, rbx
call _memcpy
add [r14+8], rbx
xor eax, eax
loc_15D16:
pop rbx
pop r14
pop r15
retn
loc_15D1C:
mov rdi, r14
call dbuf_realloc
test eax, eax
jz short loc_15D2D
push 0FFFFFFFFFFFFFFFFh
pop rax
jmp short loc_15D16
loc_15D2D:
mov rdi, [r14+8]
jmp short loc_15CFC
| long long dbuf_put_self(_QWORD *a1, long long a2, long long a3)
{
long long v5; // rdi
v5 = a1[1];
if ( (unsigned long long)(v5 + a3) <= a1[2] )
goto LABEL_2;
if ( !(unsigned int)dbuf_realloc((long long)a1, v5 + a3) )
{
v5 = a1[1];
LABEL_2:
memcpy(*a1 + v5, *a1 + a2, a3);
a1[1] += a3;
return 0LL;
}
return -1LL;
}
| dbuf_put_self:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDX
MOV R15,RSI
MOV R14,RDI
MOV RDI,qword ptr [RDI + 0x8]
LEA RSI,[RDI + RDX*0x1]
CMP RSI,qword ptr [R14 + 0x10]
JA 0x00115d1c
LAB_00115cfc:
MOV RAX,qword ptr [R14]
ADD RDI,RAX
ADD R15,RAX
MOV RSI,R15
MOV RDX,RBX
CALL 0x0010e5c0
ADD qword ptr [R14 + 0x8],RBX
XOR EAX,EAX
LAB_00115d16:
POP RBX
POP R14
POP R15
RET
LAB_00115d1c:
MOV RDI,R14
CALL 0x00115bdf
TEST EAX,EAX
JZ 0x00115d2d
PUSH -0x1
POP RAX
JMP 0x00115d16
LAB_00115d2d:
MOV RDI,qword ptr [R14 + 0x8]
JMP 0x00115cfc
|
int8 dbuf_put_self(long *param_1,long param_2,size_t param_3)
{
int iVar1;
long lVar2;
lVar2 = param_1[1];
if ((ulong)param_1[2] < lVar2 + param_3) {
iVar1 = dbuf_realloc(param_1);
if (iVar1 != 0) {
return 0xffffffffffffffff;
}
lVar2 = param_1[1];
}
memcpy((void *)(lVar2 + *param_1),(void *)(param_2 + *param_1),param_3);
param_1[1] = param_1[1] + param_3;
return 0;
}
| |
22,290 | match_pins | eloqsql/mysys/lf_alloc-pin.c | static int match_pins(LF_PINS *el, void *addr)
{
int i;
LF_PINS *el_end= el+LF_DYNARRAY_LEVEL_LENGTH;
for (; el < el_end; el++)
for (i= 0; i < LF_PINBOX_PINS; i++)
if (el->pin[i] == addr)
return 1;
return 0;
} | O0 | c | match_pins:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x7800, %rax # imm = 0x7800
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x5bfe9
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x5bfd9
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x5bfcc
movl $0x1, -0x4(%rbp)
jmp 0x5bff0
jmp 0x5bfce
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5bfab
jmp 0x5bfdb
movq -0x10(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x10(%rbp)
jmp 0x5bf9a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| match_pins:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
add rax, 7800h
mov [rbp+var_28], rax
loc_5BF9A:
mov rax, [rbp+var_10]
cmp rax, [rbp+var_28]
jnb short loc_5BFE9
mov [rbp+var_1C], 0
loc_5BFAB:
cmp [rbp+var_1C], 4
jge short loc_5BFD9
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_1C]
mov rax, [rax+rcx*8]
cmp rax, [rbp+var_18]
jnz short loc_5BFCC
mov [rbp+var_4], 1
jmp short loc_5BFF0
loc_5BFCC:
jmp short $+2
loc_5BFCE:
mov eax, [rbp+var_1C]
add eax, 1
mov [rbp+var_1C], eax
jmp short loc_5BFAB
loc_5BFD9:
jmp short $+2
loc_5BFDB:
mov rax, [rbp+var_10]
add rax, 78h ; 'x'
mov [rbp+var_10], rax
jmp short loc_5BF9A
loc_5BFE9:
mov [rbp+var_4], 0
loc_5BFF0:
mov eax, [rbp+var_4]
pop rbp
retn
| long long match_pins(unsigned long long a1, long long a2)
{
int j; // [rsp+Ch] [rbp-1Ch]
unsigned long long i; // [rsp+18h] [rbp-10h]
for ( i = a1; i < a1 + 30720; i += 120LL )
{
for ( j = 0; j < 4; ++j )
{
if ( *(_QWORD *)(i + 8LL * j) == a2 )
return 1;
}
}
return 0;
}
| match_pins:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x7800
MOV qword ptr [RBP + -0x28],RAX
LAB_0015bf9a:
MOV RAX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RBP + -0x28]
JNC 0x0015bfe9
MOV dword ptr [RBP + -0x1c],0x0
LAB_0015bfab:
CMP dword ptr [RBP + -0x1c],0x4
JGE 0x0015bfd9
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x1c]
MOV RAX,qword ptr [RAX + RCX*0x8]
CMP RAX,qword ptr [RBP + -0x18]
JNZ 0x0015bfcc
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0015bff0
LAB_0015bfcc:
JMP 0x0015bfce
LAB_0015bfce:
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,0x1
MOV dword ptr [RBP + -0x1c],EAX
JMP 0x0015bfab
LAB_0015bfd9:
JMP 0x0015bfdb
LAB_0015bfdb:
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x78
MOV qword ptr [RBP + -0x10],RAX
JMP 0x0015bf9a
LAB_0015bfe9:
MOV dword ptr [RBP + -0x4],0x0
LAB_0015bff0:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 match_pins(ulong param_1,long param_2)
{
int local_24;
ulong local_18;
local_18 = param_1;
do {
if (param_1 + 0x7800 <= local_18) {
return 0;
}
for (local_24 = 0; local_24 < 4; local_24 = local_24 + 1) {
if (*(long *)(local_18 + (long)local_24 * 8) == param_2) {
return 1;
}
}
local_18 = local_18 + 0x78;
} while( true );
}
| |
22,291 | my_hash_sort_latin1_de | eloqsql/strings/ctype-latin1.c | void my_hash_sort_latin1_de(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end;
register ulong m1= *nr1, m2= *nr2;
/*
Remove end space. We have to do this to be able to compare
'AE' and 'Ä' as identical
*/
end= skip_trailing_space(key, len);
for (; key < end ; key++)
{
uint X= (uint) combo1map[(uint) *key];
MY_HASH_ADD(m1, m2, X);
if ((X= combo2map[*key]))
{
MY_HASH_ADD(m1, m2, X);
}
}
*nr1= m1;
*nr2= m2;
} | O3 | c | my_hash_sort_latin1_de:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
leaq (%rsi,%rdx), %r9
cmpq $0x15, %rdx
jb 0x3991f
movq %r9, %rdx
andq $-0x4, %rdx
cmpq %rsi, %rdx
jbe 0x3991f
leaq 0x3(%rsi), %rax
andq $-0x4, %rax
movq %r9, %rdi
movb -0x1(%r9), %r10b
cmpq %rdx, %r9
jbe 0x399c8
leaq -0x1(%rdi), %r9
cmpb $0x20, %r10b
je 0x39903
jmp 0x39922
movq %r9, %rdi
movq (%rcx), %r11
movq (%r8), %rax
cmpq %rsi, %rdi
jbe 0x399b5
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
movq %rdx, %rdi
je 0x39928
incq %rdx
leaq 0x16c0a8(%rip), %r9 # 0x1a59f0
leaq 0x16c1a1(%rip), %r10 # 0x1a5af0
movq %r11, %rdi
movzbl (%rsi), %r14d
movzbl (%r14,%r9), %ebx
movl %r11d, %r15d
andl $0x3f, %r15d
addq %rax, %r15
imulq %rbx, %r15
shlq $0x8, %rdi
addq %r15, %rdi
xorq %r11, %rdi
leaq 0x3(%rax), %rbx
movzbl (%r14,%r10), %r11d
testq %r11, %r11
je 0x399a5
movl %edi, %r14d
andl $0x3f, %r14d
addq %rbx, %r14
imulq %r11, %r14
movq %rdi, %r11
shlq $0x8, %r11
addq %r14, %r11
xorq %r11, %rdi
addq $0x6, %rax
movq %rax, %rbx
jmp 0x399a8
movq %rbx, %rax
incq %rsi
movq %rdi, %r11
cmpq %rdx, %rsi
jb 0x39952
jmp 0x399bb
movq %r11, %rdi
movq %rax, %rbx
movq %rdi, (%rcx)
movq %rbx, (%r8)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x20, %r10b
setne %r9b
cmpq %rdx, %rax
setae %dl
orb %r9b, %dl
jne 0x39922
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rax, %rdx
jbe 0x39922
leaq -0x4(%rdi), %rdx
cmpl $0x20202020, -0x4(%rdi) # imm = 0x20202020
je 0x399e2
jmp 0x39922
| my_hash_sort_latin1_de:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
lea r9, [rsi+rdx]
cmp rdx, 15h
jb short loc_3991F
mov rdx, r9
and rdx, 0FFFFFFFFFFFFFFFCh
cmp rdx, rsi
jbe short loc_3991F
lea rax, [rsi+3]
and rax, 0FFFFFFFFFFFFFFFCh
loc_39903:
mov rdi, r9
mov r10b, [r9-1]
cmp r9, rdx
jbe loc_399C8
lea r9, [rdi-1]
cmp r10b, 20h ; ' '
jz short loc_39903
jmp short loc_39922
loc_3991F:
mov rdi, r9
loc_39922:
mov r11, [rcx]
mov rax, [r8]
loc_39928:
cmp rdi, rsi
jbe loc_399B5
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
mov rdi, rdx
jz short loc_39928
inc rdx
lea r9, combo1map
lea r10, combo2map
mov rdi, r11
loc_39952:
movzx r14d, byte ptr [rsi]
movzx ebx, byte ptr [r14+r9]
mov r15d, r11d
and r15d, 3Fh
add r15, rax
imul r15, rbx
shl rdi, 8
add rdi, r15
xor rdi, r11
lea rbx, [rax+3]
movzx r11d, byte ptr [r14+r10]
test r11, r11
jz short loc_399A5
mov r14d, edi
and r14d, 3Fh
add r14, rbx
imul r14, r11
mov r11, rdi
shl r11, 8
add r11, r14
xor rdi, r11
add rax, 6
mov rbx, rax
jmp short loc_399A8
loc_399A5:
mov rax, rbx
loc_399A8:
inc rsi
mov r11, rdi
cmp rsi, rdx
jb short loc_39952
jmp short loc_399BB
loc_399B5:
mov rdi, r11
mov rbx, rax
loc_399BB:
mov [rcx], rdi
mov [r8], rbx
pop rbx
pop r14
pop r15
pop rbp
retn
loc_399C8:
cmp r10b, 20h ; ' '
setnz r9b
cmp rax, rdx
setnb dl
or dl, r9b
jnz loc_39922
mov rdx, rdi
loc_399E2:
mov rdi, rdx
cmp rdx, rax
jbe loc_39922
lea rdx, [rdi-4]
cmp dword ptr [rdi-4], 20202020h
jz short loc_399E2
jmp loc_39922
| long long my_hash_sort_latin1_de(
long long a1,
unsigned __int8 *a2,
unsigned long long a3,
long long *a4,
long long *a5)
{
unsigned long long v5; // r9
unsigned long long v6; // rdx
unsigned long long v7; // rax
unsigned long long v8; // rdi
char v9; // r10
long long v10; // r11
long long result; // rax
unsigned long long v12; // rdx
unsigned long long v14; // rdx
long long v15; // rdi
long long v16; // r14
long long v17; // rbx
unsigned long long v18; // rdx
v5 = (unsigned long long)&a2[a3];
if ( a3 < 0x15 || (v6 = v5 & 0xFFFFFFFFFFFFFFFCLL, (v5 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v8 = v5;
}
else
{
v7 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v8 = v5;
v9 = *(_BYTE *)(v5 - 1);
if ( v5 <= v6 )
break;
--v5;
if ( v9 != 32 )
goto LABEL_8;
}
if ( v9 == 32 && v7 < v6 )
{
v18 = v5;
do
{
v8 = v18;
if ( v18 <= v7 )
break;
v18 -= 4LL;
}
while ( *(_DWORD *)(v8 - 4) == 538976288 );
}
}
LABEL_8:
v10 = *a4;
result = *a5;
do
{
if ( v8 <= (unsigned long long)a2 )
{
v15 = *a4;
v17 = *a5;
goto LABEL_18;
}
v12 = v8 - 1;
}
while ( *(_BYTE *)--v8 == 32 );
v14 = v12 + 1;
v15 = *a4;
do
{
v16 = *a2;
v15 = v10 ^ (combo1map[v16] * (result + (v10 & 0x3F)) + (v15 << 8));
v17 = result + 3;
if ( combo2map[v16] )
{
v15 ^= combo2map[v16] * (v17 + (v15 & 0x3F)) + (v15 << 8);
result += 6LL;
v17 = result;
}
else
{
result += 3LL;
}
++a2;
v10 = v15;
}
while ( (unsigned long long)a2 < v14 );
LABEL_18:
*a4 = v15;
*a5 = v17;
return result;
}
| my_hash_sort_latin1_de:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
LEA R9,[RSI + RDX*0x1]
CMP RDX,0x15
JC 0x0013991f
MOV RDX,R9
AND RDX,-0x4
CMP RDX,RSI
JBE 0x0013991f
LEA RAX,[RSI + 0x3]
AND RAX,-0x4
LAB_00139903:
MOV RDI,R9
MOV R10B,byte ptr [R9 + -0x1]
CMP R9,RDX
JBE 0x001399c8
LEA R9,[RDI + -0x1]
CMP R10B,0x20
JZ 0x00139903
JMP 0x00139922
LAB_0013991f:
MOV RDI,R9
LAB_00139922:
MOV R11,qword ptr [RCX]
MOV RAX,qword ptr [R8]
LAB_00139928:
CMP RDI,RSI
JBE 0x001399b5
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
MOV RDI,RDX
JZ 0x00139928
INC RDX
LEA R9,[0x2a59f0]
LEA R10,[0x2a5af0]
MOV RDI,R11
LAB_00139952:
MOVZX R14D,byte ptr [RSI]
MOVZX EBX,byte ptr [R14 + R9*0x1]
MOV R15D,R11D
AND R15D,0x3f
ADD R15,RAX
IMUL R15,RBX
SHL RDI,0x8
ADD RDI,R15
XOR RDI,R11
LEA RBX,[RAX + 0x3]
MOVZX R11D,byte ptr [R14 + R10*0x1]
TEST R11,R11
JZ 0x001399a5
MOV R14D,EDI
AND R14D,0x3f
ADD R14,RBX
IMUL R14,R11
MOV R11,RDI
SHL R11,0x8
ADD R11,R14
XOR RDI,R11
ADD RAX,0x6
MOV RBX,RAX
JMP 0x001399a8
LAB_001399a5:
MOV RAX,RBX
LAB_001399a8:
INC RSI
MOV R11,RDI
CMP RSI,RDX
JC 0x00139952
JMP 0x001399bb
LAB_001399b5:
MOV RDI,R11
MOV RBX,RAX
LAB_001399bb:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],RBX
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001399c8:
CMP R10B,0x20
SETNZ R9B
CMP RAX,RDX
SETNC DL
OR DL,R9B
JNZ 0x00139922
MOV RDX,RDI
LAB_001399e2:
MOV RDI,RDX
CMP RDX,RAX
JBE 0x00139922
LEA RDX,[RDI + -0x4]
CMP dword ptr [RDI + -0x4],0x20202020
JZ 0x001399e2
JMP 0x00139922
|
void my_hash_sort_latin1_de
(int8 param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
long lVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
pbVar5 = param_2 + param_3;
if ((0x14 < param_3) && (pbVar4 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar4))
{
pbVar1 = pbVar5;
do {
pbVar5 = pbVar1;
if (pbVar5 <= pbVar4) {
pbVar1 = pbVar5;
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar4 && pbVar5[-1] == 0x20)
goto LAB_001399e2;
break;
}
pbVar1 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
}
goto LAB_00139922;
while (pbVar1 = pbVar5 + -4, *(int *)(pbVar5 + -4) == 0x20202020) {
LAB_001399e2:
pbVar5 = pbVar1;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_00139922:
uVar6 = *param_4;
lVar2 = *param_5;
do {
pbVar4 = pbVar5;
lVar3 = lVar2;
if (pbVar4 <= param_2) goto LAB_001399bb;
pbVar5 = pbVar4 + -1;
} while (pbVar4[-1] == 0x20);
do {
uVar6 = uVar6 * 0x100 + ((ulong)((uint)uVar6 & 0x3f) + lVar2) * (ulong)(byte)combo1map[*param_2]
^ uVar6;
lVar3 = lVar2 + 3;
if ((ulong)(byte)combo2map[*param_2] != 0) {
uVar6 = uVar6 ^ uVar6 * 0x100 +
((ulong)((uint)uVar6 & 0x3f) + lVar3) * (ulong)(byte)combo2map[*param_2];
lVar3 = lVar2 + 6;
}
param_2 = param_2 + 1;
lVar2 = lVar3;
} while (param_2 < pbVar4);
LAB_001399bb:
*param_4 = uVar6;
*param_5 = lVar3;
return;
}
| |
22,292 | mbr_join | eloqsql/storage/maria/ma_rt_split.c | static void mbr_join(double *a, const double *b, int n_dim)
{
double *end= a + n_dim * 2;
do
{
if (a[0] > b[0])
a[0]= b[0];
if (a[1] < b[1])
a[1]= b[1];
a+= 2;
b+= 2;
} while (a != end);
} | O0 | c | mbr_join:
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)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
ucomisd (%rax), %xmm0
jbe 0x8aa98
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x8aac2
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
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 0x8aa76
popq %rbp
retq
nopw %cs:(%rax,%rax)
| mbr_join:
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
loc_8AA76:
mov rax, [rbp+var_8]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_10]
ucomisd xmm0, qword ptr [rax]
jbe short loc_8AA98
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax]
mov rax, [rbp+var_8]
movsd qword ptr [rax], xmm0
loc_8AA98:
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_8AAC2
mov rax, [rbp+var_10]
movsd xmm0, qword ptr [rax+8]
mov rax, [rbp+var_8]
movsd qword ptr [rax+8], xmm0
loc_8AAC2:
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 short loc_8AA76
pop rbp
retn
| double * mbr_join(double *a1, double *a2, int a3)
{
double *result; // rax
double *v5; // [rsp+18h] [rbp-8h]
v5 = a1;
do
{
if ( *v5 > *a2 )
*v5 = *a2;
if ( a2[1] > v5[1] )
v5[1] = a2[1];
v5 += 2;
a2 += 2;
result = v5;
}
while ( v5 != &a1[2 * a3] );
return result;
}
| mbr_join:
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
LAB_0018aa76:
MOV RAX,qword ptr [RBP + -0x8]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
UCOMISD XMM0,qword ptr [RAX]
JBE 0x0018aa98
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX],XMM0
LAB_0018aa98:
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 0x0018aac2
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x8]
MOVSD qword ptr [RAX + 0x8],XMM0
LAB_0018aac2:
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 0x0018aa76
POP RBP
RET
|
void mbr_join(double *param_1,double *param_2,int param_3)
{
double *local_18;
double *local_10;
local_18 = param_2;
local_10 = param_1;
do {
if (*local_18 <= *local_10 && *local_10 != *local_18) {
*local_10 = *local_18;
}
if (local_10[1] < local_18[1]) {
local_10[1] = local_18[1];
}
local_10 = local_10 + 2;
local_18 = local_18 + 2;
} while (local_10 != param_1 + (param_3 << 1));
return;
}
| |
22,293 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
} | O0 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& 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>::at<char const (&) [8], 0>(char const (&) [8]):
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xadf70
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x161b78
jmp 0x161c54
movb $0x1, 0x83(%rsp)
movl $0x20, %edi
callq 0x5a680
movq 0x20(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xb4d40
movq %rax, 0x90(%rsp)
leaq 0xafe71(%rip), %rsi # 0x211a19
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x169c80
jmp 0x161bbf
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdi
movl $0x130, %esi # imm = 0x130
leaq 0x98(%rsp), %rdx
callq 0xb4ae0
jmp 0x161bdd
movq 0x18(%rsp), %rdi
movb $0x0, 0x83(%rsp)
leaq 0x13e197(%rip), %rsi # 0x29fd88
leaq -0xace08(%rip), %rdx # 0xb4df0
callq 0x5aae0
jmp 0x161de5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x161c39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5b528
testb $0x1, 0x83(%rsp)
jne 0x161c45
jmp 0x161c4f
movq 0x18(%rsp), %rdi
callq 0x5af50
jmp 0x161dd8
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xb8(%rsp), %rsi
callq 0x16add0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x78(%rsp)
movq 0x8(%rax), %rdi
callq 0xb3770
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xb4710
testb $0x1, %al
jne 0x161c9d
jmp 0x161dae
movb $0x1, 0x2e(%rsp)
movl $0x20, %edi
callq 0x5a680
movq %rax, (%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x5b0b0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x629a0
jmp 0x161ce2
leaq 0xafd60(%rip), %rsi # 0x211a49
leaq 0xafd5f(%rip), %rcx # 0x211a4f
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x16aea0
jmp 0x161d01
movq 0x20(%rsp), %rcx
movq (%rsp), %rdi
movl $0x193, %esi # imm = 0x193
leaq 0x50(%rsp), %rdx
callq 0xadac0
jmp 0x161d1b
movq (%rsp), %rdi
movb $0x0, 0x2e(%rsp)
leaq 0x13dfdd(%rip), %rsi # 0x29fd08
leaq -0xb4c62(%rip), %rdx # 0xad0d0
callq 0x5aae0
jmp 0x161de5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x161d90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x161d86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5b528
leaq 0x30(%rsp), %rdi
callq 0x5b528
leaq 0x2f(%rsp), %rdi
callq 0x5b500
testb $0x1, 0x2e(%rsp)
jne 0x161da3
jmp 0x161dac
movq (%rsp), %rdi
callq 0x5af50
jmp 0x161dd8
leaq 0x78(%rsp), %rdi
callq 0xb4910
movq 0x20(%rsp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
movq $-0x1, %rdx
callq 0x169b60
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x5aba0
nopw %cs:(%rax,%rax)
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
sub rsp, 0C8h
mov [rsp+0C8h+var_8], rdi
mov qword ptr [rsp+0C8h+var_10], rsi
mov rdi, [rsp+0C8h+var_8]
mov [rsp+0C8h+var_A8], rdi; int
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)
xor al, 0FFh
xor al, 0FFh
xor al, 0FFh
test al, 1
jnz short loc_161B78
jmp loc_161C54
loc_161B78:
mov [rsp+0C8h+var_45], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rdi, [rsp+0C8h+var_A8]
mov [rsp+0C8h+var_B0], rax; char
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
mov qword ptr [rsp+0C8h+var_38], rax; char
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+0C8h+var_30]; int
lea rdx, [rsp+0C8h+var_38]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
jmp short $+2
loc_161BBF:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_B0]; int
mov esi, 130h
lea rdx, [rsp+0C8h+var_30]
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
jmp short $+2
loc_161BDD:
mov rdi, [rsp+0C8h+var_B0]; void *
mov [rsp+0C8h+var_45], 0
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail10type_errorD2Ev; void (*)(void *)
call ___cxa_throw
jmp loc_161DE5
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_161C39
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_161C39:
test [rsp+arg_7B], 1
jnz short loc_161C45
jmp short loc_161C4F
loc_161C45:
mov rdi, [rsp+arg_10]; void *
call ___cxa_free_exception
loc_161C4F:
jmp loc_161DD8
loc_161C54:
mov rax, [rsp+0C8h+var_A8]
mov rdi, [rax+8]
mov rsi, qword ptr [rsp+0C8h+var_10]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, rax
mov rax, [rsp+0C8h+var_A8]
mov qword ptr [rsp+0C8h+var_50], rcx; int
mov rdi, [rax+8]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov qword ptr [rsp+0C8h+var_58], rax; char
lea rdi, [rsp+0C8h+var_50]
lea rsi, [rsp+0C8h+var_58]
call _ZN9__gnu_cxxeqIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator==<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_161C9D
jmp loc_161DAE
loc_161C9D:
mov [rsp+0C8h+var_9A], 1
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov [rsp+0C8h+var_C8], rax; int
mov rax, qword ptr [rsp+0C8h+var_10]
mov qword ptr [rsp+0C8h+var_C0], rax; int
lea rdi, [rsp+0C8h+var_99]
mov qword ptr [rsp+0C8h+var_B8], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, qword ptr [rsp+0C8h+var_C0]
mov rdx, qword ptr [rsp+0C8h+var_B8]
lea rdi, [rsp+0C8h+var_99+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_161CE2:
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+0C8h+var_78]; int
lea rdx, [rsp+0C8h+var_99+1]; int
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
jmp short $+2
loc_161D01:
mov rcx, [rsp+0C8h+var_A8]
mov rdi, [rsp+0C8h+var_C8]; int
mov esi, 193h
lea rdx, [rsp+0C8h+var_78]
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_161D1B:
mov rdi, [rsp+0C8h+var_C8]; void *
mov [rsp+0C8h+var_9A], 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 loc_161DE5
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_161D90
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
jmp short loc_161D86
mov rcx, rax
mov eax, edx
mov [rsp+arg_80], rcx
mov [rsp+arg_7C], eax
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_161D86:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
loc_161D90:
lea rdi, [rsp+arg_27]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
test [rsp+arg_26], 1
jnz short loc_161DA3
jmp short loc_161DAC
loc_161DA3:
mov rdi, [rsp+0]; void *
call ___cxa_free_exception
loc_161DAC:
jmp short loc_161DD8
loc_161DAE:
lea rdi, [rsp+0C8h+var_50]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEptEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator->(void)
mov rdi, [rsp+0C8h+var_A8]
mov rsi, rax
add rsi, 20h ; ' '
mov rdx, 0FFFFFFFFFFFFFFFFh
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10set_parentERSD_m; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::set_parent(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&,ulong)
add rsp, 0C8h
retn
loc_161DD8:
mov rdi, [rsp+arg_80]
call __Unwind_Resume
loc_161DE5:
nop word ptr [rax+rax+00000000h]
nop
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA8_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
long long a2)
{
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // r8d
int v6; // r9d
long long v7; // rax
int v9; // [rsp+0h] [rbp-C8h]
void *v10; // [rsp+0h] [rbp-C8h]
nlohmann::json_abi_v3_11_3::detail::out_of_range *v11; // [rsp+0h] [rbp-C8h]
void *v12; // [rsp+8h] [rbp-C0h]
long long v13; // [rsp+8h] [rbp-C0h]
int v14; // [rsp+10h] [rbp-B8h]
int v15; // [rsp+18h] [rbp-B0h]
void *exception; // [rsp+18h] [rbp-B0h]
nlohmann::json_abi_v3_11_3::detail::type_error *v17; // [rsp+18h] [rbp-B0h]
long long v18; // [rsp+20h] [rbp-A8h]
char v19; // [rsp+2Fh] [rbp-99h] BYREF
_BYTE v20[32]; // [rsp+30h] [rbp-98h] BYREF
int v21[8]; // [rsp+50h] [rbp-78h] BYREF
char v22[8]; // [rsp+70h] [rbp-58h] BYREF
int v23[2]; // [rsp+78h] [rbp-50h] BYREF
char v24; // [rsp+83h] [rbp-45h]
char v25[8]; // [rsp+90h] [rbp-38h] BYREF
int v26[8]; // [rsp+98h] [rbp-30h] BYREF
int v27[2]; // [rsp+B8h] [rbp-10h]
long long v28; // [rsp+C0h] [rbp-8h]
v28 = a1;
*(_QWORD *)v27 = a2;
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((_BYTE *)a1) )
{
exception = __cxa_allocate_exception(0x20uLL);
*(_QWORD *)v25 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::type_name((_BYTE *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(
(int)v26,
(int)"cannot use at() with ",
(int)v25,
v2,
v3,
v4,
v9,
v12,
v14,
(long long)exception);
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v17,
304,
(long long)v26,
a1);
v24 = 0;
__cxa_throw(
v17,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::type_error::~type_error);
}
*(_QWORD *)v23 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
*(_QWORD *)(a1 + 8),
*(_QWORD *)v27);
*(_QWORD *)v22 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::end(*(_QWORD *)(a1 + 8));
if ( __gnu_cxx::operator==<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>(
(long long)v23,
(long long)v22) )
{
v10 = __cxa_allocate_exception(0x20uLL);
v13 = *(_QWORD *)v27;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v20, v13, (long long)&v19);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
(int)v21,
(int)"key '",
(int)v20,
(int)"' not found",
v5,
v6,
v10,
v13,
(int)&v19,
v15,
a1);
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v11,
403,
(long long)v21,
v18);
__cxa_throw(
v11,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::out_of_range::~out_of_range);
}
v7 = __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>>::operator->((long long)v23);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::set_parent(
a1,
v7 + 32,
-1LL);
}
| begin:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
CALL 0x00165f60
MOV RAX,qword ptr [RSP + 0x10]
ADD RSP,0x18
RET
|
/* std::vector<int, std::allocator<int> >::begin() */
int8 __thiscall
std::vector<int,std::allocator<int>>::begin(vector<int,std::allocator<int>> *this)
{
int8 local_8;
__gnu_cxx::__normal_iterator<int*,std::vector<int,std::allocator<int>>>::__normal_iterator
((__normal_iterator<int*,std::vector<int,std::allocator<int>>> *)&local_8,(int **)this);
return local_8;
}
| |
22,294 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
} | O2 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [8], 0>(char const (&) [8]):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x7a3c5
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x7e16c
movq 0x8(%r14), %rcx
cmpq 0x8(%rcx), %rax
je 0x7a423
addq $0x20, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
movq %r14, %rdi
callq 0x42dc8
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x39c3b(%rip), %rsi # 0xb4022
leaq 0x8(%rsp), %rdi
callq 0x7d791
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x42c7c
xorl %ebp, %ebp
leaq 0x80b36(%rip), %rsi # 0xfaf48
leaq -0x3aac1(%rip), %rdx # 0x3f958
movq %rbx, %rdi
callq 0x23ee0
jmp 0x7a48d
pushq $0x20
popq %rdi
callq 0x23450
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x27370
leaq 0x39c0b(%rip), %rsi # 0xb4052
leaq 0x39c0a(%rip), %rcx # 0xb4058
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x7dd9b
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x41528
xorl %ebp, %ebp
leaq 0x80a4a(%rip), %rsi # 0xfaec8
leaq -0x3ab2d(%rip), %rdx # 0x3f958
movq %rbx, %rdi
callq 0x23ee0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x241a8
jmp 0x7a4a2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
jmp 0x7a4b3
jmp 0x7a4bf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x241a8
testb %bpl, %bpl
jne 0x7a4c2
jmp 0x7a4ca
movq %rax, %r14
movq %rbx, %rdi
callq 0x23680
movq %r14, %rdi
callq 0x23f70
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push rbx; int
sub rsp, 48h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_7A3C5
mov r15, rsi
mov rdi, [r14+8]
call _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
mov rcx, [r14+8]
cmp rax, [rcx+8]
jz short loc_7A423
add rax, 20h ; ' '
add rsp, 48h
pop rbx
pop r14
pop r15
pop rbp
retn
loc_7A3C5:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
mov rdi, r14
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9type_nameEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::type_name(void)
lea rdx, [rsp+68h+var_40]
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_60]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_7A48D
loc_7A423:
push 20h ; ' '
pop rdi; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+68h+var_40]
lea rdx, [rsp+68h+var_61]
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_60]
lea rdx, [rsp+68h+var_40]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_60]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
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_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_7A48D:
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7A4A2
mov r14, rax
mov bpl, 1
loc_7A4A2:
lea rdi, [rsp+68h+var_40]
jmp short loc_7A4B3
jmp short loc_7A4BF
mov r14, rax
lea rdi, [rsp+68h+var_60]; void *
loc_7A4B3:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7A4C2
jmp short loc_7A4CA
loc_7A4BF:
mov r14, rax
loc_7A4C2:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_7A4CA:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
long long a2)
{
long long v2; // rax
nlohmann::json_abi_v3_11_3::detail::type_error *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::out_of_range *v5; // rbx
_BYTE v6[32]; // [rsp+8h] [rbp-60h] BYREF
_QWORD v7[8]; // [rsp+28h] [rbp-40h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::type_error *)__cxa_allocate_exception(0x20uLL);
v7[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>::type_name((unsigned __int8 *)a1);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(v6, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
(long long)v6);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v2 = ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(*(_QWORD *)(a1 + 8));
if ( v2 == *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL) )
{
v5 = (nlohmann::json_abi_v3_11_3::detail::out_of_range *)__cxa_allocate_exception(0x20uLL);
std::string::basic_string<std::allocator<char>>(v7, a2);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v6,
"key '",
v7,
"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v5,
403,
(long long)v6,
a1);
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v2 + 32;
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x0017a3c5
MOV R15,RSI
MOV RDI,qword ptr [R14 + 0x8]
CALL 0x0017e16c
MOV RCX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
JZ 0x0017a423
ADD RAX,0x20
ADD RSP,0x48
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_0017a3c5:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
MOV RDI,R14
CALL 0x00142dc8
LEA RDX,[RSP + 0x28]
MOV qword ptr [RDX],RAX
LAB_0017a3e0:
LEA RSI,[0x1b4022]
LEA RDI,[RSP + 0x8]
CALL 0x0017d791
MOV BPL,0x1
LAB_0017a3f4:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x00142c7c
XOR EBP,EBP
LEA RSI,[0x1faf48]
LEA RDX,[0x13f958]
MOV RDI,RBX
CALL 0x00123ee0
LAB_0017a423:
PUSH 0x20
POP RDI
CALL 0x00123450
MOV RBX,RAX
LAB_0017a42e:
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x7]
MOV RSI,R15
CALL 0x00127370
LAB_0017a440:
LEA RSI,[0x1b4052]
LEA RCX,[0x1b4058]
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x28]
CALL 0x0017dd9b
MOV BPL,0x1
LAB_0017a460:
LEA RDX,[RSP + 0x8]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x00141528
XOR EBP,EBP
LEA RSI,[0x1faec8]
LEA RDX,[0x13f958]
MOV RDI,RBX
CALL 0x00123ee0
|
long _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long lVar1;
int8 uVar2;
allocator local_61;
detail local_60 [32];
char *local_40 [4];
if (*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>
)0x1) {
uVar2 = __cxa_allocate_exception(0x20);
local_40[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 0017a3e0 to 0017a3f0 has its CatchHandler @ 0017a4bf */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_60,"cannot use at() with ",local_40);
/* try { // try from 0017a3f4 to 0017a420 has its CatchHandler @ 0017a4ab */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x130,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
lVar1 = _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA9_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(*(int8 *)(param_1 + 8));
if (lVar1 != *(long *)(*(long *)(param_1 + 8) + 8)) {
return lVar1 + 0x20;
}
uVar2 = __cxa_allocate_exception(0x20);
/* try { // try from 0017a42e to 0017a43f has its CatchHandler @ 0017a4a9 */
std::__cxx11::string::string<std::allocator<char>>((string *)local_40,param_2,&local_61);
/* try { // try from 0017a440 to 0017a45c has its CatchHandler @ 0017a49c */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_60,"key \'",(string *)local_40,"\' not found");
/* try { // try from 0017a460 to 0017a48c has its CatchHandler @ 0017a48d */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar2,0x193,local_60,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar2,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
| |
22,295 | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(key));
if (it == m_data.m_value.object->end())
{
JSON_THROW(out_of_range::create(403, detail::concat("key '", string_t(std::forward<KeyType>(key)), "' not found"), this));
}
return set_parent(it->second);
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::at<char const (&) [8], 0>(char const (&) [8]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0xa3fb7
movq %rsi, %r15
movq 0x8(%r14), %r12
movq (%r12), %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
je 0xa3fa1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a210
testl %eax, %eax
je 0xa3f96
addq $0x30, %rbx
movq 0x8(%r12), %rax
cmpq %rax, %rbx
jne 0xa3f77
jmp 0xa3f99
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
cmpq %rbx, %rax
je 0xa4015
addq $0x20, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
movq %r14, %rdi
callq 0x5e834
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0x4c069(%rip), %rsi # 0xf0042
leaq 0x20(%rsp), %rdi
callq 0xaa8ab
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x130, %esi # imm = 0x130
movq %r14, %rcx
callq 0x5e5dc
xorl %ebp, %ebp
leaq 0x84f54(%rip), %rsi # 0x128f58
leaq -0x495a1(%rip), %rdx # 0x5aa6a
movq %rbx, %rdi
callq 0x1aee0
jmp 0xa408e
movl $0x20, %edi
callq 0x1a430
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x1a3d0
leaq (%rax,%r15), %rdx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x21b46
leaq 0x4c028(%rip), %rsi # 0xf0072
leaq 0x4c027(%rip), %rcx # 0xf0078
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xaae88
movb $0x1, %bpl
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movl $0x193, %esi # imm = 0x193
movq %r14, %rcx
callq 0x5cbcc
xorl %ebp, %ebp
leaq 0x84e59(%rip), %rsi # 0x128ed8
leaq -0x4961c(%rip), %rdx # 0x5aa6a
movq %rbx, %rdi
callq 0x1aee0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa40ac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8b0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa40f7
movq 0x10(%rsp), %rsi
jmp 0xa40ef
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xa4101
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1a8b0
jmp 0xa4101
jmp 0xa40fe
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa40f7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1a8b0
testb %bpl, %bpl
jne 0xa4101
jmp 0xa4109
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a660
movq %r14, %rdi
callq 0x1af70
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
push rbp; char
push r15; int
push r14; int
push r12; int
push rbx; char
sub rsp, 40h
mov r14, rdi
cmp byte ptr [rdi], 1
jnz short loc_A3FB7
mov r15, rsi
mov r12, [r14+8]
mov rbx, [r12]
mov rax, [r12+8]
cmp rbx, rax
jz short loc_A3FA1
loc_A3F77:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A3F96
add rbx, 30h ; '0'
mov rax, [r12+8]
cmp rbx, rax
jnz short loc_A3F77
jmp short loc_A3F99
loc_A3F96:
mov rax, rbx
loc_A3F99:
mov rcx, [r14+8]
mov rbx, [rcx+8]
loc_A3FA1:
cmp rax, rbx
jz short loc_A4015
add rax, 20h ; ' '
add rsp, 40h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_A3FB7:
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)
mov rdx, rsp
mov [rdx], rax
lea rsi, aCannotUseAtWit; "cannot use at() with "
lea rdi, [rsp+68h+var_48]
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA22_KcPS9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[22],char const*>(char const(&)[22],char const* &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 130h; int
mov rcx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
jmp short loc_A408E
loc_A4015:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea r12, [rsp+68h+var_58]
mov [r12-10h], r12
mov rdi, r15
call _strlen
lea rdx, [rax+r15]
mov rdi, rsp
mov rsi, r15
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
lea rsi, aKey; "key '"
lea rcx, aNotFound; "' not found"
lea rdi, [rsp+68h+var_48]
mov rdx, rsp
call _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA6_KcS8_RA12_S9_EEET_DpOT0_; nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(char const(&)[6],std::string,char const(&)[12] &&)
mov bpl, 1
lea rdx, [rsp+68h+var_48]
mov rdi, rbx; this
mov esi, 193h; int
mov rcx, r14
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_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail12out_of_rangeE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
loc_A408E:
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A40AC
mov rsi, [rsp+68h+var_38]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A40AC:
mov rdi, [rsp+68h+var_68]
cmp rdi, r12
jz short loc_A40F7
mov rsi, [rsp+68h+var_58]
jmp short loc_A40EF
mov r14, rax
mov rdi, [rsp+68h+var_68]; void *
cmp rdi, r12
jz short loc_A4101
mov rsi, [rsp+68h+var_58]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_A4101
jmp short loc_A40FE
mov r14, rax
lea rax, [rsp+68h+var_38]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A40F7
mov rsi, [rsp+68h+var_38]
loc_A40EF:
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A40F7:
test bpl, bpl
jnz short loc_A4101
jmp short loc_A4109
loc_A40FE:
mov r14, rax
loc_A4101:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_A4109:
mov rdi, r14
call __Unwind_Resume
| long long ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_(
long long a1,
_BYTE *a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
nlohmann::json_abi_v3_11_3::detail::exception *exception; // rbx
nlohmann::json_abi_v3_11_3::detail::exception *v7; // rbx
long long v8; // rax
void *v9[2]; // [rsp+0h] [rbp-68h] BYREF
long long v10; // [rsp+10h] [rbp-58h] BYREF
_QWORD v11[2]; // [rsp+20h] [rbp-48h] BYREF
if ( *(_BYTE *)a1 != 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = (void *)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(&)[22],char const*>(v11, "cannot use at() with ");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
exception,
304,
v11);
__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);
}
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
goto LABEL_7;
}
v4 = v3;
LABEL_7:
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
if ( v4 == v3 )
{
v7 = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v9[0] = &v10;
v8 = strlen(a2);
std::string::_M_construct<char const*>((long long)v9, a2, (long long)&a2[v8]);
nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[6],std::string,char const(&)[12]>(
v11,
"key '",
v9,
"' not found");
ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_(
v7,
403,
v11);
__cxa_throw(
v7,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::out_of_range,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return v4 + 32;
}
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV R14,RDI
CMP byte ptr [RDI],0x1
JNZ 0x001a3fb7
MOV R15,RSI
MOV R12,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JZ 0x001a3fa1
LAB_001a3f77:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a210
TEST EAX,EAX
JZ 0x001a3f96
ADD RBX,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP RBX,RAX
JNZ 0x001a3f77
JMP 0x001a3f99
LAB_001a3f96:
MOV RAX,RBX
LAB_001a3f99:
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
LAB_001a3fa1:
CMP RAX,RBX
JZ 0x001a4015
ADD RAX,0x20
ADD RSP,0x40
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001a3fb7:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
MOV RDI,R14
CALL 0x0015e834
MOV RDX,RSP
MOV qword ptr [RDX],RAX
LAB_001a3fd2:
LEA RSI,[0x1f0042]
LEA RDI,[RSP + 0x20]
CALL 0x001aa8ab
MOV BPL,0x1
LAB_001a3fe6:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x130
MOV RCX,R14
CALL 0x0015e5dc
XOR EBP,EBP
LEA RSI,[0x228f58]
LEA RDX,[0x15aa6a]
MOV RDI,RBX
CALL 0x0011aee0
LAB_001a4015:
MOV EDI,0x20
CALL 0x0011a430
MOV RBX,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
MOV RDI,R15
CALL 0x0011a3d0
LEA RDX,[RAX + R15*0x1]
LAB_001a4038:
MOV RDI,RSP
MOV RSI,R15
CALL 0x00121b46
LAB_001a4043:
LEA RSI,[0x1f0072]
LEA RCX,[0x1f0078]
LEA RDI,[RSP + 0x20]
MOV RDX,RSP
CALL 0x001aae88
MOV BPL,0x1
LAB_001a4061:
LEA RDX,[RSP + 0x20]
MOV RDI,RBX
MOV ESI,0x193
MOV RCX,R14
CALL 0x0015cbcc
XOR EBP,EBP
LEA RSI,[0x228ed8]
LEA RDX,[0x15aa6a]
MOV RDI,RBX
CALL 0x0011aee0
|
char * _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERSD_OSJ_
(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*param_1,char *param_2)
{
long *plVar1;
int iVar2;
char *pcVar3;
int8 uVar4;
size_t sVar5;
char *pcVar6;
char *local_68 [2];
char local_58 [16];
detail local_48 [32];
if (*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>
)0x1) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = (char *)nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::type_name(param_1);
/* try { // try from 001a3fd2 to 001a3fe2 has its CatchHandler @ 001a40fe */
nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string,char_const(&)[22],char_const*>
(local_48,"cannot use at() with ",local_68);
/* try { // try from 001a3fe6 to 001a4012 has its CatchHandler @ 001a40d9 */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x130,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::type_error::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
plVar1 = *(long **)(param_1 + 8);
pcVar6 = (char *)*plVar1;
pcVar3 = (char *)plVar1[1];
if (pcVar6 != pcVar3) {
do {
pcVar3 = pcVar6;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar6 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar6 != pcVar3);
pcVar6 = *(char **)(*(long *)(param_1 + 8) + 8);
}
if (pcVar3 == pcVar6) {
uVar4 = __cxa_allocate_exception(0x20);
local_68[0] = local_58;
sVar5 = strlen(param_2);
/* try { // try from 001a4038 to 001a4042 has its CatchHandler @ 001a40d7 */
std::__cxx11::string::_M_construct<char_const*>(local_68,param_2,param_2 + sVar5);
/* try { // try from 001a4043 to 001a405d has its CatchHandler @ 001a40bc */
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[6],std::__cxx11::string,char_const(&)[12]>
(local_48,"key \'",(string *)local_68,"\' not found");
/* try { // try from 001a4061 to 001a408d has its CatchHandler @ 001a408e */
_ZN8nlohmann16json_abi_v3_11_36detail12out_of_range6createIPNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEETnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKSC_SJ_
(uVar4,0x193,local_48,param_1);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar4,&nlohmann::json_abi_v3_11_3::detail::out_of_range::typeinfo,
nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
return pcVar3 + 0x20;
}
| |
22,296 | command_failure::~command_failure() | msxemulator/build_O3/_deps/picotool-src/errors/errors.h | command_failure(int code, std::string s) : c(code), s(std::move(s)) {} | O3 | c | command_failure::~command_failure():
pushq %rbx
movq %rdi, %rbx
leaq 0x66891(%rip), %rax # 0xe1e50
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x7b5da
movq (%rax), %rsi
incq %rsi
callq 0xf470
movq %rbx, %rdi
callq 0xf888
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xf470
| _ZN15command_failureD0Ev:
push rbx
mov rbx, rdi
lea rax, off_E1E50
mov [rdi], rax
mov rdi, [rdi+10h]; void *
lea rax, [rbx+20h]
cmp rdi, rax
jz short loc_7B5DA
mov rsi, [rax]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_7B5DA:
mov rdi, rbx; this
call _ZNSt9exceptionD2Ev; std::exception::~exception()
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void command_failure::~command_failure(command_failure *this)
{
char *v2; // rdi
*(_QWORD *)this = off_E1E50;
v2 = (char *)*((_QWORD *)this + 2);
if ( v2 != (char *)this + 32 )
operator delete(v2, *((_QWORD *)this + 4) + 1LL);
std::exception::~exception(this);
operator delete(this, 0x30uLL);
}
| ~command_failure:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x1e1e50]
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x10]
LEA RAX,[RBX + 0x20]
CMP RDI,RAX
JZ 0x0017b5da
MOV RSI,qword ptr [RAX]
INC RSI
CALL 0x0010f470
LAB_0017b5da:
MOV RDI,RBX
CALL 0x0010f888
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x0010f470
|
/* command_failure::~command_failure() */
void __thiscall command_failure::~command_failure(command_failure *this)
{
*(int ***)this = &PTR__command_failure_001e1e50;
if (*(command_failure **)(this + 0x10) != this + 0x20) {
operator_delete(*(command_failure **)(this + 0x10),*(long *)(this + 0x20) + 1);
}
std::exception::~exception((exception *)this);
operator_delete(this,0x30);
return;
}
| |
22,297 | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) | llama.cpp/common/json.hpp | serializer(output_adapter_t<char> s, const char ichar,
error_handler_t error_handler_ = error_handler_t::strict)
: o(std::move(s))
, loc(std::localeconv())
, thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
, decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
, indent_char(ichar)
, indent_string(512, indent_char)
, error_handler(error_handler_)
{} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
movq %r15, 0x8(%rdi)
movups (%rsi), %xmm0
movq %r15, 0x8(%rsi)
movups %xmm0, (%rdi)
movq %r15, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
callq 0x210f0
movq %rax, 0x50(%r14)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x7d97a
movb (%rcx), %r15b
movb %r15b, 0x58(%r14)
movq (%rax), %rax
testq %rax, %rax
je 0x7d98a
movb (%rax), %al
jmp 0x7d98c
xorl %eax, %eax
leaq 0x8(%r14), %r15
movb %al, 0x59(%r14)
leaq 0x5a(%r14), %rdi
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x214e0
movb %bpl, 0x25a(%r14)
leaq 0x260(%r14), %rdi
leaq 0x270(%r14), %rax
movq %rax, 0x260(%r14)
movsbl %bpl, %edx
movl $0x200, %esi # imm = 0x200
callq 0x219d0
movl %ebx, 0x280(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x70882
movq %rbx, %rdi
callq 0x21af0
nop
| _ZN8nlohmann16json_abi_v3_11_36detail10serializerINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ESt10shared_ptrINS1_23output_adapter_protocolIcEEEcNS1_15error_handler_tE:
push rbp
push r15
push r14
push rbx
push rax
mov ebx, ecx
mov ebp, edx
mov r14, rdi
xor r15d, r15d
mov [rdi+8], r15
movups xmm0, xmmword ptr [rsi]
mov [rsi+8], r15
movups xmmword ptr [rdi], xmm0
mov [rsi], r15
xorps xmm0, xmm0
movups xmmword ptr [rdi+40h], xmm0
movups xmmword ptr [rdi+30h], xmm0
movups xmmword ptr [rdi+20h], xmm0
movups xmmword ptr [rdi+10h], xmm0
call _localeconv
mov [r14+50h], rax
mov rcx, [rax+8]
test rcx, rcx
jz short loc_7D97A
mov r15b, [rcx]
loc_7D97A:
mov [r14+58h], r15b
mov rax, [rax]
test rax, rax
jz short loc_7D98A
mov al, [rax]
jmp short loc_7D98C
loc_7D98A:
xor eax, eax
loc_7D98C:
lea r15, [r14+8]
mov [r14+59h], al
lea rdi, [r14+5Ah]
mov edx, 200h
xor esi, esi
call _memset
mov [r14+25Ah], bpl
lea rdi, [r14+260h]
lea rax, [r14+270h]
mov [r14+260h], rax
movsx edx, bpl
mov esi, 200h
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructEmc; std::string::_M_construct(ulong,char)
mov [r14+280h], ebx
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
mov rdi, r15
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EED2Ev; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count()
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::serializer<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>>::serializer(
long long a1,
__int128 *a2,
char a3,
int a4)
{
char v6; // r15
__int128 v7; // xmm0
long long v8; // rax
char *v9; // rcx
char *v10; // rax
char v11; // al
long long result; // rax
v6 = 0;
*(_QWORD *)(a1 + 8) = 0LL;
v7 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)a1 = v7;
*(_QWORD *)a2 = 0LL;
*(_OWORD *)(a1 + 64) = 0LL;
*(_OWORD *)(a1 + 48) = 0LL;
*(_OWORD *)(a1 + 32) = 0LL;
*(_OWORD *)(a1 + 16) = 0LL;
v8 = localeconv(a1);
*(_QWORD *)(a1 + 80) = v8;
v9 = *(char **)(v8 + 8);
if ( v9 )
v6 = *v9;
*(_BYTE *)(a1 + 88) = v6;
v10 = *(char **)v8;
if ( v10 )
v11 = *v10;
else
v11 = 0;
*(_BYTE *)(a1 + 89) = v11;
memset(a1 + 90, 0LL, 512LL);
*(_BYTE *)(a1 + 602) = a3;
*(_QWORD *)(a1 + 608) = a1 + 624;
result = std::string::_M_construct(a1 + 608, 512LL, (unsigned int)a3);
*(_DWORD *)(a1 + 640) = a4;
return result;
}
| serializer:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV EBX,ECX
MOV EBP,EDX
MOV R14,RDI
XOR R15D,R15D
MOV qword ptr [RDI + 0x8],R15
MOVUPS XMM0,xmmword ptr [RSI]
MOV qword ptr [RSI + 0x8],R15
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RSI],R15
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI + 0x40],XMM0
MOVUPS xmmword ptr [RDI + 0x30],XMM0
MOVUPS xmmword ptr [RDI + 0x20],XMM0
MOVUPS xmmword ptr [RDI + 0x10],XMM0
CALL 0x001210f0
MOV qword ptr [R14 + 0x50],RAX
MOV RCX,qword ptr [RAX + 0x8]
TEST RCX,RCX
JZ 0x0017d97a
MOV R15B,byte ptr [RCX]
LAB_0017d97a:
MOV byte ptr [R14 + 0x58],R15B
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0017d98a
MOV AL,byte ptr [RAX]
JMP 0x0017d98c
LAB_0017d98a:
XOR EAX,EAX
LAB_0017d98c:
LEA R15,[R14 + 0x8]
MOV byte ptr [R14 + 0x59],AL
LEA RDI,[R14 + 0x5a]
MOV EDX,0x200
XOR ESI,ESI
CALL 0x001214e0
MOV byte ptr [R14 + 0x25a],BPL
LEA RDI,[R14 + 0x260]
LEA RAX,[R14 + 0x270]
MOV qword ptr [R14 + 0x260],RAX
LAB_0017d9c0:
MOVSX EDX,BPL
MOV ESI,0x200
CALL 0x001219d0
LAB_0017d9ce:
MOV dword ptr [R14 + 0x280],EBX
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::serializer<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>
>::serializer(std::shared_ptr<nlohmann::json_abi_v3_11_3::detail::output_adapter_protocol<char>
>, char, nlohmann::json_abi_v3_11_3::detail::error_handler_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
serializer<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>>
::serializer(serializer<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,int8 *param_2,
serializer<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>>
param_3,int4 param_4)
{
int8 uVar1;
serializer<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>>
sVar2;
lconv *plVar3;
sVar2 = (serializer<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>>
)0x0;
*(int8 *)(this + 8) = 0;
uVar1 = param_2[1];
param_2[1] = 0;
*(int8 *)this = *param_2;
*(int8 *)(this + 8) = uVar1;
*param_2 = 0;
*(int8 *)(this + 0x40) = 0;
*(int8 *)(this + 0x48) = 0;
*(int8 *)(this + 0x30) = 0;
*(int8 *)(this + 0x38) = 0;
*(int8 *)(this + 0x20) = 0;
*(int8 *)(this + 0x28) = 0;
*(int8 *)(this + 0x10) = 0;
*(int8 *)(this + 0x18) = 0;
plVar3 = localeconv();
*(lconv **)(this + 0x50) = plVar3;
if ((serializer<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>>
*)plVar3->thousands_sep !=
(serializer<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>>
*)0x0) {
sVar2 = *(serializer<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>>
*)plVar3->thousands_sep;
}
this[0x58] = sVar2;
if ((serializer<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>>
*)plVar3->decimal_point ==
(serializer<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>>
*)0x0) {
sVar2 = (serializer<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>>
)0x0;
}
else {
sVar2 = *(serializer<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>>
*)plVar3->decimal_point;
}
this[0x59] = sVar2;
memset(this + 0x5a,0,0x200);
this[0x25a] = param_3;
*(serializer<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 + 0x260) = this + 0x270;
/* try { // try from 0017d9c0 to 0017d9cd has its CatchHandler @ 0017d9e0 */
std::__cxx11::string::_M_construct((ulong)(this + 0x260),'\0');
*(int4 *)(this + 0x280) = param_4;
return;
}
| |
22,298 | evmone::check_memory(long&, evmone::Memory&, intx::uint<256u> const&, unsigned long) | corpus-core[P]colibri-stateless/build_O2/_deps/evmone_external-src/lib/evmone/instructions.hpp | inline bool check_memory(
int64_t& gas_left, Memory& memory, const uint256& offset, uint64_t size) noexcept
{
// TODO: This should be done in intx.
// There is "branchless" variant of this using | instead of ||, but benchmarks difference
// is within noise. This should be decided when moving the implementation to intx.
if (((offset[3] | offset[2] | offset[1]) != 0) || (offset[0] > max_buffer_size))
return false;
const auto new_size = static_cast<uint64_t>(offset) + size;
if (new_size > memory.size())
gas_left = grow_memory(gas_left, memory, new_size);
return gas_left >= 0; // Always true for no-grow case.
} | O2 | cpp | evmone::check_memory(long&, evmone::Memory&, intx::uint<256u> const&, unsigned long):
movq 0x10(%rdx), %rax
orq 0x18(%rdx), %rax
orq 0x8(%rdx), %rax
jne 0x3b2d2
movq (%rdx), %rdx
movq %rdx, %rax
shrq $0x20, %rax
je 0x3b2d5
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
addq %rcx, %rdx
movq (%rdi), %rax
cmpq 0x8(%rsi), %rdx
jbe 0x3b2f0
movq %rax, %rdi
callq 0x3b2f8
movq %rax, (%rbx)
testq %rax, %rax
setns %al
popq %rbx
retq
| _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEEm:
mov rax, [rdx+10h]
or rax, [rdx+18h]
or rax, [rdx+8]
jnz short loc_3B2D2
mov rdx, [rdx]
mov rax, rdx
shr rax, 20h
jz short loc_3B2D5
loc_3B2D2:
xor eax, eax
retn
loc_3B2D5:
push rbx
mov rbx, rdi
add rdx, rcx; evmone::Memory *
mov rax, [rdi]
cmp rdx, [rsi+8]
jbe short loc_3B2F0
mov rdi, rax; this
call _ZN6evmone11grow_memoryElRNS_6MemoryEm; evmone::grow_memory(long,evmone::Memory &,ulong)
mov [rbx], rax
loc_3B2F0:
test rax, rax
setns al
pop rbx
retn
| bool evmone::check_memory(evmone **a1, long long a2, unsigned long long *a3, unsigned long long a4)
{
unsigned long long v4; // rdx
evmone::Memory *v6; // rdx
evmone *v7; // rax
if ( a3[1] | a3[3] | a3[2] )
return 0;
v4 = *a3;
if ( HIDWORD(v4) )
return 0;
v6 = (evmone::Memory *)(a4 + v4);
v7 = *a1;
if ( (unsigned long long)v6 > *(_QWORD *)(a2 + 8) )
{
v7 = (evmone *)evmone::grow_memory(*a1, a2, v6, a4);
*a1 = v7;
}
return (long long)v7 >= 0;
}
| check_memory:
MOV RAX,qword ptr [RDX + 0x10]
OR RAX,qword ptr [RDX + 0x18]
OR RAX,qword ptr [RDX + 0x8]
JNZ 0x0013b2d2
MOV RDX,qword ptr [RDX]
MOV RAX,RDX
SHR RAX,0x20
JZ 0x0013b2d5
LAB_0013b2d2:
XOR EAX,EAX
RET
LAB_0013b2d5:
PUSH RBX
MOV RBX,RDI
ADD RDX,RCX
MOV RAX,qword ptr [RDI]
CMP RDX,qword ptr [RSI + 0x8]
JBE 0x0013b2f0
MOV RDI,RAX
CALL 0x0013b2f8
MOV qword ptr [RBX],RAX
LAB_0013b2f0:
TEST RAX,RAX
SETNS AL
POP RBX
RET
|
/* evmone::check_memory(long&, evmone::Memory&, intx::uint<256u> const&, unsigned long) */
bool evmone::check_memory(long *param_1,Memory *param_2,uint *param_3,ulong param_4)
{
long lVar1;
ulong uVar2;
if (((*(long *)(param_3 + 0x10) == 0 && *(long *)(param_3 + 0x18) == 0) &&
*(long *)(param_3 + 8) == 0) && (*(ulong *)param_3 >> 0x20 == 0)) {
uVar2 = *(ulong *)param_3 + param_4;
lVar1 = *param_1;
if (*(ulong *)(param_2 + 8) < uVar2) {
lVar1 = grow_memory(lVar1,param_2,uVar2);
*param_1 = lVar1;
}
return -1 < lVar1;
}
return false;
}
| |
22,299 | mi_calc_bin_pack_key_length | eloqsql/storage/myisam/mi_search.c | int
_mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,uchar *next_key,
uchar *org_key, uchar *prev_key, uchar *key,
MI_KEY_PARAM *s_temp)
{
uint length,key_length,ref_length;
s_temp->totlength=key_length=_mi_keylength(keyinfo,key)+nod_flag;
#ifdef HAVE_valgrind
s_temp->n_length= s_temp->n_ref_length=0; /* For valgrind */
#endif
s_temp->key=key;
s_temp->prev_key=org_key;
if (prev_key) /* If not first key in block */
{
/* pack key against previous key */
/*
As keys may be identical when running a sort in myisamchk, we
have to guard against the case where keys may be identical
*/
uchar *end;
end=key+key_length;
for ( ; *key == *prev_key && key < end; key++,prev_key++) ;
s_temp->ref_length= ref_length=(uint) (key-s_temp->key);
length=key_length - ref_length + get_pack_length(ref_length);
}
else
{
/* No previous key */
s_temp->ref_length=ref_length=0;
length=key_length+1;
}
if ((s_temp->next_key_pos=next_key)) /* If another key after */
{
/* pack key against next key */
uint next_length,next_length_pack;
get_key_pack_length(next_length,next_length_pack,next_key);
/* If first key and next key is packed (only on delete) */
if (!prev_key && org_key && next_length)
{
uchar *end;
for (key= s_temp->key, end=key+next_length ;
*key == *org_key && key < end;
key++,org_key++) ;
ref_length= (uint) (key - s_temp->key);
}
if (next_length > ref_length)
{
/* We put a key with different case between two keys with the same prefix
Extend next key to have same prefix as
this key */
s_temp->n_ref_length= ref_length;
s_temp->prev_length= next_length-ref_length;
s_temp->prev_key+= ref_length;
return (int) (length+ s_temp->prev_length - next_length_pack +
get_pack_length(ref_length));
}
/* Check how many characters are identical to next key */
key= s_temp->key+next_length;
s_temp->prev_length= 0;
while (*key++ == *next_key++) ;
if ((ref_length= (uint) (key - s_temp->key)-1) == next_length)
{
s_temp->next_key_pos=0;
return length; /* can't pack next key */
}
s_temp->n_ref_length=ref_length;
return (int) (length-(ref_length - next_length) - next_length_pack +
get_pack_length(ref_length));
}
return (int) length;
} | O0 | c | mi_calc_bin_pack_key_length:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4b450
movl %eax, %ecx
addl -0x14(%rbp), %ecx
movl %ecx, -0x40(%rbp)
movq 0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x30(%rbp)
je 0x4ccd7
movq -0x38(%rbp), %rax
movl -0x40(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
movq -0x30(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x61(%rbp)
jne 0x4cc75
movq -0x38(%rbp), %rax
cmpq -0x50(%rbp), %rax
setb %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4cc7e
jmp 0x4cc9a
jmp 0x4cc80
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4cc50
movq -0x38(%rbp), %rax
movq 0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x40(%rbp), %eax
subl -0x44(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4ccf1
movl $0x0, -0x44(%rbp)
movq 0x10(%rbp), %rax
movl $0x0, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rbp), %rcx
movq %rax, 0x30(%rcx)
cmpq $0x0, %rax
je 0x4ceff
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
je 0x4cd33
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x54(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x4cd67
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
movzwl %ax, %eax
movq -0x20(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x54(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x20(%rbp)
movl $0x3, -0x58(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4cdf5
cmpq $0x0, -0x28(%rbp)
je 0x4cdf5
cmpl $0x0, -0x54(%rbp)
je 0x4cdf5
movq 0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x38(%rbp), %rax
movzbl (%rax), %ecx
movq -0x28(%rbp), %rax
movzbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x62(%rbp)
jne 0x4cdbe
movq -0x38(%rbp), %rax
cmpq -0x60(%rbp), %rax
setb %al
movb %al, -0x62(%rbp)
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x4cdc7
jmp 0x4cde3
jmp 0x4cdc9
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x4cd99
movq -0x38(%rbp), %rax
movq 0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x44(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x44(%rbp), %eax
jbe 0x4ce55
movl -0x44(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x54(%rbp), %ecx
subl -0x44(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x44(%rbp), %edx
movq 0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x28(%rax)
movl -0x3c(%rbp), %eax
movq 0x10(%rbp), %rcx
addl 0x18(%rcx), %eax
subl -0x58(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4cf05
movq 0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x54(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq 0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x38(%rbp)
movzbl (%rax), %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4ce9c
jmp 0x4ce72
movq -0x38(%rbp), %rax
movq 0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl -0x54(%rbp), %eax
jne 0x4ceca
movq 0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4cf05
movl -0x44(%rbp), %ecx
movq 0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x3c(%rbp), %eax
movl -0x44(%rbp), %ecx
subl -0x54(%rbp), %ecx
subl %ecx, %eax
subl -0x58(%rbp), %eax
movl -0x44(%rbp), %esi
movl $0x1, %ecx
movl $0x3, %edx
cmpl $0xff, %esi
cmovael %edx, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4cf05
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
| _mi_calc_bin_pack_key_length:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
call _mi_keylength
mov ecx, eax
add ecx, [rbp+var_14]
mov [rbp+var_40], ecx
mov rax, [rbp+arg_0]
mov [rax+10h], ecx
mov rcx, [rbp+var_38]
mov rax, [rbp+arg_0]
mov [rax+20h], rcx
mov rcx, [rbp+var_28]
mov rax, [rbp+arg_0]
mov [rax+28h], rcx
cmp [rbp+var_30], 0
jz loc_4CCD7
mov rax, [rbp+var_38]
mov ecx, [rbp+var_40]
add rax, rcx
mov [rbp+var_50], rax
loc_4CC50:
mov rax, [rbp+var_38]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_30]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_61], al
jnz short loc_4CC75
mov rax, [rbp+var_38]
cmp rax, [rbp+var_50]
setb al
mov [rbp+var_61], al
loc_4CC75:
mov al, [rbp+var_61]
test al, 1
jnz short loc_4CC7E
jmp short loc_4CC9A
loc_4CC7E:
jmp short $+2
loc_4CC80:
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_4CC50
loc_4CC9A:
mov rax, [rbp+var_38]
mov rcx, [rbp+arg_0]
mov rcx, [rcx+20h]
sub rax, rcx
mov ecx, eax
mov [rbp+var_44], ecx
mov rax, [rbp+arg_0]
mov [rax], ecx
mov eax, [rbp+var_40]
sub eax, [rbp+var_44]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov [rbp+var_3C], eax
jmp short loc_4CCF1
loc_4CCD7:
mov [rbp+var_44], 0
mov rax, [rbp+arg_0]
mov dword ptr [rax], 0
mov eax, [rbp+var_40]
add eax, 1
mov [rbp+var_3C], eax
loc_4CCF1:
mov rax, [rbp+var_20]
mov rcx, [rbp+arg_0]
mov [rcx+30h], rax
cmp rax, 0
jz loc_4CEFF
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax]
cmp eax, 0FFh
jz short loc_4CD33
mov rax, [rbp+var_20]
mov rcx, rax
add rcx, 1
mov [rbp+var_20], rcx
movzx eax, byte ptr [rax]
mov [rbp+var_54], eax
mov [rbp+var_58], 1
jmp short loc_4CD67
loc_4CD33:
mov rax, [rbp+var_20]
movzx eax, byte ptr [rax+2]
movzx eax, ax
mov rcx, [rbp+var_20]
movzx ecx, byte ptr [rcx+1]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_54], eax
mov rax, [rbp+var_20]
add rax, 3
mov [rbp+var_20], rax
mov [rbp+var_58], 3
loc_4CD67:
cmp [rbp+var_30], 0
jnz loc_4CDF5
cmp [rbp+var_28], 0
jz short loc_4CDF5
cmp [rbp+var_54], 0
jz short loc_4CDF5
mov rax, [rbp+arg_0]
mov rax, [rax+20h]
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov ecx, [rbp+var_54]
add rax, rcx
mov [rbp+var_60], rax
loc_4CD99:
mov rax, [rbp+var_38]
movzx ecx, byte ptr [rax]
mov rax, [rbp+var_28]
movzx edx, byte ptr [rax]
xor eax, eax
cmp ecx, edx
mov [rbp+var_62], al
jnz short loc_4CDBE
mov rax, [rbp+var_38]
cmp rax, [rbp+var_60]
setb al
mov [rbp+var_62], al
loc_4CDBE:
mov al, [rbp+var_62]
test al, 1
jnz short loc_4CDC7
jmp short loc_4CDE3
loc_4CDC7:
jmp short $+2
loc_4CDC9:
mov rax, [rbp+var_38]
add rax, 1
mov [rbp+var_38], rax
mov rax, [rbp+var_28]
add rax, 1
mov [rbp+var_28], rax
jmp short loc_4CD99
loc_4CDE3:
mov rax, [rbp+var_38]
mov rcx, [rbp+arg_0]
mov rcx, [rcx+20h]
sub rax, rcx
mov [rbp+var_44], eax
loc_4CDF5:
mov eax, [rbp+var_54]
cmp eax, [rbp+var_44]
jbe short loc_4CE55
mov ecx, [rbp+var_44]
mov rax, [rbp+arg_0]
mov [rax+8], ecx
mov ecx, [rbp+var_54]
sub ecx, [rbp+var_44]
mov rax, [rbp+arg_0]
mov [rax+18h], ecx
mov edx, [rbp+var_44]
mov rax, [rbp+arg_0]
mov rcx, [rax+28h]
mov edx, edx
add rcx, rdx
mov [rax+28h], rcx
mov eax, [rbp+var_3C]
mov rcx, [rbp+arg_0]
add eax, [rcx+18h]
sub eax, [rbp+var_58]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov [rbp+var_4], eax
jmp loc_4CF05
loc_4CE55:
mov rax, [rbp+arg_0]
mov rax, [rax+20h]
mov ecx, [rbp+var_54]
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+arg_0]
mov dword ptr [rax+18h], 0
loc_4CE72:
mov rax, [rbp+var_38]
mov rcx, rax
add rcx, 1
mov [rbp+var_38], rcx
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_20]
mov rdx, rcx
add rdx, 1
mov [rbp+var_20], rdx
movzx ecx, byte ptr [rcx]
cmp eax, ecx
jnz short loc_4CE9C
jmp short loc_4CE72
loc_4CE9C:
mov rax, [rbp+var_38]
mov rcx, [rbp+arg_0]
mov rcx, [rcx+20h]
sub rax, rcx
sub eax, 1
mov [rbp+var_44], eax
cmp eax, [rbp+var_54]
jnz short loc_4CECA
mov rax, [rbp+arg_0]
mov qword ptr [rax+30h], 0
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
jmp short loc_4CF05
loc_4CECA:
mov ecx, [rbp+var_44]
mov rax, [rbp+arg_0]
mov [rax+8], ecx
mov eax, [rbp+var_3C]
mov ecx, [rbp+var_44]
sub ecx, [rbp+var_54]
sub eax, ecx
sub eax, [rbp+var_58]
mov esi, [rbp+var_44]
mov ecx, 1
mov edx, 3
cmp esi, 0FFh
cmovnb ecx, edx
add eax, ecx
mov [rbp+var_4], eax
jmp short loc_4CF05
loc_4CEFF:
mov eax, [rbp+var_3C]
mov [rbp+var_4], eax
loc_4CF05:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
| long long mi_calc_bin_pack_key_length(
long long a1,
int a2,
unsigned __int8 *a3,
unsigned __int8 *a4,
unsigned __int8 *a5,
unsigned __int8 *a6,
long long a7)
{
int v7; // ecx
unsigned __int8 *v8; // rax
int v9; // ecx
unsigned __int8 *v10; // rax
unsigned __int8 *v11; // rcx
int v12; // ecx
bool v14; // [rsp+Eh] [rbp-62h]
bool v15; // [rsp+Fh] [rbp-61h]
unsigned __int8 *v16; // [rsp+10h] [rbp-60h]
int v17; // [rsp+18h] [rbp-58h]
unsigned int v18; // [rsp+1Ch] [rbp-54h]
unsigned __int8 *v19; // [rsp+20h] [rbp-50h]
unsigned int v20; // [rsp+2Ch] [rbp-44h]
unsigned int v21; // [rsp+2Ch] [rbp-44h]
int v22; // [rsp+30h] [rbp-40h]
unsigned int v23; // [rsp+34h] [rbp-3Ch]
unsigned __int8 *v24; // [rsp+38h] [rbp-38h]
unsigned __int8 *v25; // [rsp+38h] [rbp-38h]
unsigned __int8 *v26; // [rsp+38h] [rbp-38h]
unsigned __int8 *v30; // [rsp+50h] [rbp-20h]
v24 = a6;
v22 = a2 + mi_keylength(a1, a6);
*(_DWORD *)(a7 + 16) = v22;
*(_QWORD *)(a7 + 32) = v24;
*(_QWORD *)(a7 + 40) = a4;
if ( a5 )
{
v19 = &v24[v22];
while ( 1 )
{
v15 = 0;
if ( *v24 == *a5 )
v15 = v24 < v19;
if ( !v15 )
break;
++v24;
++a5;
}
v20 = (_DWORD)v24 - *(_QWORD *)(a7 + 32);
*(_DWORD *)a7 = v20;
v7 = 1;
if ( v20 >= 0xFF )
v7 = 3;
v23 = v7 + v22 - v20;
}
else
{
v20 = 0;
*(_DWORD *)a7 = 0;
v23 = v22 + 1;
}
*(_QWORD *)(a7 + 48) = a3;
if ( a3 )
{
if ( *a3 == 255 )
{
v18 = _byteswap_ushort(*(_WORD *)(a3 + 1));
v30 = a3 + 3;
v17 = 3;
}
else
{
v8 = a3;
v30 = a3 + 1;
v18 = *v8;
v17 = 1;
}
if ( !a5 && a4 && v18 )
{
v25 = *(unsigned __int8 **)(a7 + 32);
v16 = &v25[v18];
while ( 1 )
{
v14 = 0;
if ( *v25 == *a4 )
v14 = v25 < v16;
if ( !v14 )
break;
++v25;
++a4;
}
v20 = (_DWORD)v25 - *(_QWORD *)(a7 + 32);
}
if ( v18 <= v20 )
{
v26 = (unsigned __int8 *)(v18 + *(_QWORD *)(a7 + 32));
*(_DWORD *)(a7 + 24) = 0;
do
{
v10 = v26++;
v11 = v30++;
}
while ( *v10 == *v11 );
v21 = (_DWORD)v26 - *(_QWORD *)(a7 + 32) - 1;
if ( v21 == v18 )
{
*(_QWORD *)(a7 + 48) = 0LL;
return v23;
}
else
{
*(_DWORD *)(a7 + 8) = v21;
v12 = 1;
if ( v21 >= 0xFF )
v12 = 3;
return v12 + v23 - (v21 - v18) - v17;
}
}
else
{
*(_DWORD *)(a7 + 8) = v20;
*(_DWORD *)(a7 + 24) = v18 - v20;
*(_QWORD *)(a7 + 40) += v20;
v9 = 1;
if ( v20 >= 0xFF )
v9 = 3;
return v9 + *(_DWORD *)(a7 + 24) + v23 - v17;
}
}
else
{
return v23;
}
}
| _mi_calc_bin_pack_key_length:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x0014b450
MOV ECX,EAX
ADD ECX,dword ptr [RBP + -0x14]
MOV dword ptr [RBP + -0x40],ECX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX + 0x10],ECX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x20],RCX
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x28],RCX
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0014ccd7
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x40]
ADD RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_0014cc50:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x61],AL
JNZ 0x0014cc75
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x50]
SETC AL
MOV byte ptr [RBP + -0x61],AL
LAB_0014cc75:
MOV AL,byte ptr [RBP + -0x61]
TEST AL,0x1
JNZ 0x0014cc7e
JMP 0x0014cc9a
LAB_0014cc7e:
JMP 0x0014cc80
LAB_0014cc80:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x0014cc50
LAB_0014cc9a:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV ECX,EAX
MOV dword ptr [RBP + -0x44],ECX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,dword ptr [RBP + -0x44]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV dword ptr [RBP + -0x3c],EAX
JMP 0x0014ccf1
LAB_0014ccd7:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],0x0
MOV EAX,dword ptr [RBP + -0x40]
ADD EAX,0x1
MOV dword ptr [RBP + -0x3c],EAX
LAB_0014ccf1:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + 0x10]
MOV qword ptr [RCX + 0x30],RAX
CMP RAX,0x0
JZ 0x0014ceff
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX]
CMP EAX,0xff
JZ 0x0014cd33
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x20],RCX
MOVZX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x54],EAX
MOV dword ptr [RBP + -0x58],0x1
JMP 0x0014cd67
LAB_0014cd33:
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,byte ptr [RAX + 0x2]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x20]
MOVZX ECX,byte ptr [RCX + 0x1]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x54],EAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x3
MOV qword ptr [RBP + -0x20],RAX
MOV dword ptr [RBP + -0x58],0x3
LAB_0014cd67:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x0014cdf5
CMP qword ptr [RBP + -0x28],0x0
JZ 0x0014cdf5
CMP dword ptr [RBP + -0x54],0x0
JZ 0x0014cdf5
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
LAB_0014cd99:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EDX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,EDX
MOV byte ptr [RBP + -0x62],AL
JNZ 0x0014cdbe
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x60]
SETC AL
MOV byte ptr [RBP + -0x62],AL
LAB_0014cdbe:
MOV AL,byte ptr [RBP + -0x62]
TEST AL,0x1
JNZ 0x0014cdc7
JMP 0x0014cde3
LAB_0014cdc7:
JMP 0x0014cdc9
LAB_0014cdc9:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x1
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x28]
ADD RAX,0x1
MOV qword ptr [RBP + -0x28],RAX
JMP 0x0014cd99
LAB_0014cde3:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
LAB_0014cdf5:
MOV EAX,dword ptr [RBP + -0x54]
CMP EAX,dword ptr [RBP + -0x44]
JBE 0x0014ce55
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX + 0x8],ECX
MOV ECX,dword ptr [RBP + -0x54]
SUB ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX + 0x18],ECX
MOV EDX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RAX + 0x28]
MOV EDX,EDX
ADD RCX,RDX
MOV qword ptr [RAX + 0x28],RCX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + 0x10]
ADD EAX,dword ptr [RCX + 0x18]
SUB EAX,dword ptr [RBP + -0x58]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014cf05
LAB_0014ce55:
MOV RAX,qword ptr [RBP + 0x10]
MOV RAX,qword ptr [RAX + 0x20]
MOV ECX,dword ptr [RBP + -0x54]
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX + 0x18],0x0
LAB_0014ce72:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x38],RCX
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x20]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x20],RDX
MOVZX ECX,byte ptr [RCX]
CMP EAX,ECX
JNZ 0x0014ce9c
JMP 0x0014ce72
LAB_0014ce9c:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + 0x10]
MOV RCX,qword ptr [RCX + 0x20]
SUB RAX,RCX
SUB EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
CMP EAX,dword ptr [RBP + -0x54]
JNZ 0x0014ceca
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RAX + 0x30],0x0
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014cf05
LAB_0014ceca:
MOV ECX,dword ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX + 0x8],ECX
MOV EAX,dword ptr [RBP + -0x3c]
MOV ECX,dword ptr [RBP + -0x44]
SUB ECX,dword ptr [RBP + -0x54]
SUB EAX,ECX
SUB EAX,dword ptr [RBP + -0x58]
MOV ESI,dword ptr [RBP + -0x44]
MOV ECX,0x1
MOV EDX,0x3
CMP ESI,0xff
CMOVNC ECX,EDX
ADD EAX,ECX
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0014cf05
LAB_0014ceff:
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014cf05:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
int _mi_calc_bin_pack_key_length
(int8 param_1,int param_2,byte *param_3,char *param_4,char *param_5,
char *param_6,uint *param_7)
{
byte bVar1;
byte bVar2;
int iVar3;
char *pcVar4;
uint uVar5;
byte *pbVar6;
int local_60;
uint local_5c;
uint local_4c;
int local_44;
byte *local_40;
char *local_38;
char *local_30;
byte *local_28;
int local_c;
iVar3 = _mi_keylength(param_1,param_6);
uVar5 = iVar3 + param_2;
param_7[4] = uVar5;
*(char **)(param_7 + 8) = param_6;
*(char **)(param_7 + 10) = param_4;
local_38 = param_5;
if (param_5 == (char *)0x0) {
local_4c = 0;
*param_7 = 0;
local_44 = uVar5 + 1;
}
else {
for (local_40 = (byte *)param_6; *local_40 == *local_38 && local_40 < param_6 + uVar5;
local_40 = local_40 + 1) {
local_38 = local_38 + 1;
}
local_4c = (int)local_40 - (int)*(int8 *)(param_7 + 8);
*param_7 = local_4c;
local_44 = 1;
if (0xfe < local_4c) {
local_44 = 3;
}
local_44 = (uVar5 - local_4c) + local_44;
}
*(byte **)(param_7 + 0xc) = param_3;
if (param_3 == (byte *)0x0) {
local_c = local_44;
}
else {
if (*param_3 == 0xff) {
local_5c = (uint)CONCAT11(param_3[1],param_3[2]);
local_28 = param_3 + 3;
local_60 = 3;
}
else {
local_28 = param_3 + 1;
local_5c = (uint)*param_3;
local_60 = 1;
}
if (((local_38 == (char *)0x0) && (param_4 != (char *)0x0)) && (local_5c != 0)) {
local_40 = *(byte **)(param_7 + 8);
pcVar4 = (char *)local_40 + local_5c;
local_30 = param_4;
for (; *local_40 == *local_30 && local_40 < pcVar4; local_40 = local_40 + 1) {
local_30 = local_30 + 1;
}
local_4c = (int)local_40 - (int)*(int8 *)(param_7 + 8);
}
if (local_4c < local_5c) {
param_7[2] = local_4c;
param_7[6] = local_5c - local_4c;
*(ulong *)(param_7 + 10) = *(long *)(param_7 + 10) + (ulong)local_4c;
local_c = 1;
if (0xfe < local_4c) {
local_c = 3;
}
local_c = ((local_44 + param_7[6]) - local_60) + local_c;
}
else {
param_7[6] = 0;
local_40 = (byte *)(*(long *)(param_7 + 8) + (ulong)local_5c);
do {
pbVar6 = local_40 + 1;
bVar1 = *local_40;
bVar2 = *local_28;
local_40 = pbVar6;
local_28 = local_28 + 1;
} while (bVar1 == bVar2);
uVar5 = ((int)pbVar6 - (int)*(int8 *)(param_7 + 8)) - 1;
if (uVar5 == local_5c) {
param_7[0xc] = 0;
param_7[0xd] = 0;
local_c = local_44;
}
else {
param_7[2] = uVar5;
local_c = 1;
if (0xfe < uVar5) {
local_c = 3;
}
local_c = ((local_44 - (uVar5 - local_5c)) - local_60) + local_c;
}
}
}
return local_c;
}
|
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.