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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
7,700 |
my_scan_utf32
|
eloqsql/strings/ctype-ucs2.c
|
static size_t
my_scan_utf32(CHARSET_INFO *cs,
const char *str, const char *end, int sequence_type)
{
const char *str0= str;
switch (sequence_type)
{
case MY_SEQ_SPACES:
for ( ; str < end; )
{
my_wc_t wc;
int res= my_utf32_uni(cs, &wc, (uchar*) str, (uchar*) end);
if (res < 0 || wc != ' ')
break;
str+= res;
}
return (size_t) (str - str0);
case MY_SEQ_NONSPACES:
DBUG_ASSERT(0); /* Not implemented */
/* pass through */
default:
return 0;
}
}
|
O0
|
c
|
my_scan_utf32:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x40(%rbp)
subl $0x2, %eax
je 0xab8d6
jmp 0xab8cc
movl -0x40(%rbp), %eax
subl $0x3, %eax
je 0xab92d
jmp 0xab933
jmp 0xab8d8
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xab91c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x38(%rbp), %rsi
callq 0xaad40
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0xab907
cmpq $0x20, -0x38(%rbp)
je 0xab909
jmp 0xab91c
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0xab8d8
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xab93b
jmp 0xab92f
jmp 0xab931
jmp 0xab933
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
my_scan_utf32:
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_24], ecx
mov rax, [rbp+var_18]
mov [rbp+var_30], rax
mov eax, [rbp+var_24]
mov [rbp+var_40], eax
sub eax, 2
jz short loc_AB8D6
jmp short $+2
loc_AB8CC:
mov eax, [rbp+var_40]
sub eax, 3
jz short loc_AB92D
jmp short loc_AB933
loc_AB8D6:
jmp short $+2
loc_AB8D8:
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jnb short loc_AB91C
mov rdi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
lea rsi, [rbp+var_38]
call my_utf32_uni
mov [rbp+var_3C], eax
cmp [rbp+var_3C], 0
jl short loc_AB907
cmp [rbp+var_38], 20h ; ' '
jz short loc_AB909
loc_AB907:
jmp short loc_AB91C
loc_AB909:
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_18]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_18], rax
jmp short loc_AB8D8
loc_AB91C:
mov rax, [rbp+var_18]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_8], rax
jmp short loc_AB93B
loc_AB92D:
jmp short $+2
loc_AB92F:
jmp short $+2
loc_AB931:
jmp short $+2
loc_AB933:
mov [rbp+var_8], 0
loc_AB93B:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
unsigned long long my_scan_utf32(
long long a1,
unsigned long long a2,
unsigned long long a3,
int a4,
long long a5,
long long a6)
{
int v7; // [rsp+4h] [rbp-3Ch]
long long v8; // [rsp+8h] [rbp-38h] BYREF
unsigned long long v9; // [rsp+10h] [rbp-30h]
int v10; // [rsp+1Ch] [rbp-24h]
unsigned long long v11; // [rsp+20h] [rbp-20h]
unsigned long long v12; // [rsp+28h] [rbp-18h]
long long v13; // [rsp+30h] [rbp-10h]
v13 = a1;
v12 = a2;
v11 = a3;
v10 = a4;
v9 = a2;
if ( a4 != 2 )
return 0LL;
while ( v12 < v11 )
{
v7 = my_utf32_uni(v13, (long long)&v8, v12, v11, a5, a6);
if ( v7 < 0 || v8 != 32 )
break;
v12 += v7;
}
return v12 - v9;
}
|
my_scan_utf32:
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 dword ptr [RBP + -0x24],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x30],RAX
MOV EAX,dword ptr [RBP + -0x24]
MOV dword ptr [RBP + -0x40],EAX
SUB EAX,0x2
JZ 0x001ab8d6
JMP 0x001ab8cc
LAB_001ab8cc:
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,0x3
JZ 0x001ab92d
JMP 0x001ab933
LAB_001ab8d6:
JMP 0x001ab8d8
LAB_001ab8d8:
MOV RAX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RBP + -0x20]
JNC 0x001ab91c
MOV RDI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
LEA RSI,[RBP + -0x38]
CALL 0x001aad40
MOV dword ptr [RBP + -0x3c],EAX
CMP dword ptr [RBP + -0x3c],0x0
JL 0x001ab907
CMP qword ptr [RBP + -0x38],0x20
JZ 0x001ab909
LAB_001ab907:
JMP 0x001ab91c
LAB_001ab909:
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x18]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001ab8d8
LAB_001ab91c:
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001ab93b
LAB_001ab92d:
JMP 0x001ab92f
LAB_001ab92f:
JMP 0x001ab931
LAB_001ab931:
JMP 0x001ab933
LAB_001ab933:
MOV qword ptr [RBP + -0x8],0x0
LAB_001ab93b:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
long my_scan_utf32(int8 param_1,ulong param_2,ulong param_3,int param_4)
{
int iVar1;
long local_40;
ulong local_38;
int4 local_2c;
ulong local_28;
ulong local_20;
int8 local_18;
long local_10;
if (param_4 == 2) {
local_2c = 2;
local_38 = param_2;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
while (((local_20 < local_28 &&
(iVar1 = my_utf32_uni(local_18,&local_40,local_20,local_28), -1 < iVar1)) &&
(local_40 == 0x20))) {
local_20 = local_20 + (long)iVar1;
}
local_10 = local_20 - local_38;
}
else {
local_10 = 0;
}
return local_10;
}
|
|
7,701 |
parse_time
|
eloqsql/libmariadb/libmariadb/ma_stmt_codec.c
|
static int parse_time(const char *str, size_t length, const char **end_ptr, MYSQL_TIME *tm)
{
int err= 0;
const char *p = str;
const char *end = str + length;
size_t frac_len;
int ret=1;
tm->hour = my_strtoui(p, end-p, &p, &err);
if (err || tm->hour > 838 || p == end || *p != ':' )
goto end;
p++;
tm->minute = my_strtoui(p, end-p, &p, &err);
if (err || tm->minute > 59 || p == end || *p != ':')
goto end;
p++;
tm->second = my_strtoui(p, end-p, &p, &err);
if (err || tm->second > 59)
goto end;
ret = 0;
tm->second_part = 0;
if (p == end)
goto end;
/* Check for fractional part*/
if (*p != '.')
goto end;
p++;
frac_len = MIN(6,end-p);
tm->second_part = my_strtoui(p, frac_len, &p, &err);
if (err)
goto end;
if (frac_len < 6)
tm->second_part *= frac_mul[frac_len];
ret = 0;
/* Consume whole fractional part, even after 6 digits.*/
p += frac_len;
while(p < *end_ptr)
{
if (*p < '0' || *p > '9')
break;
p++;
}
end:
*end_ptr = p;
return ret;
}
|
O0
|
c
|
parse_time:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0x44(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x94150
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x92db8
movq -0x20(%rbp), %rax
cmpl $0x346, 0xc(%rax) # imm = 0x346
ja 0x92db8
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x92db8
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x92dbd
jmp 0x92f6c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x94150
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x92e14
movq -0x20(%rbp), %rax
cmpl $0x3b, 0x10(%rax)
ja 0x92e14
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x92e14
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
je 0x92e19
jmp 0x92f6c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x94150
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x92e5a
movq -0x20(%rbp), %rax
cmpl $0x3b, 0x14(%rax)
jbe 0x92e5f
jmp 0x92f6c
movl $0x0, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jne 0x92e81
jmp 0x92f6c
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0x92e92
jmp 0x92f6c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rax, %rcx
movl $0x6, %eax
cmpq %rcx, %rax
jge 0x92ebe
movl $0x6, %eax
movq %rax, -0x50(%rbp)
jmp 0x92ecd
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq 0x94150
movl %eax, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpl $0x0, -0x24(%rbp)
je 0x92efe
jmp 0x92f6c
cmpq $0x6, -0x40(%rbp)
jae 0x92f22
movq -0x40(%rbp), %rcx
leaq 0xde790(%rip), %rax # 0x1716a0
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
imulq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x92f6a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x92f5a
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x92f5c
jmp 0x92f6a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x92f35
jmp 0x92f6c
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
|
parse_time:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_24], 0
mov rax, [rbp+var_8]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
add rax, [rbp+var_10]
mov [rbp+var_38], rax
mov [rbp+var_44], 1
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+0Ch], ecx
cmp [rbp+var_24], 0
jnz short loc_92DB8
mov rax, [rbp+var_20]
cmp dword ptr [rax+0Ch], 346h
ja short loc_92DB8
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_92DB8
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 3Ah ; ':'
jz short loc_92DBD
loc_92DB8:
jmp loc_92F6C
loc_92DBD:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+10h], ecx
cmp [rbp+var_24], 0
jnz short loc_92E14
mov rax, [rbp+var_20]
cmp dword ptr [rax+10h], 3Bh ; ';'
ja short loc_92E14
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jz short loc_92E14
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 3Ah ; ':'
jz short loc_92E19
loc_92E14:
jmp loc_92F6C
loc_92E19:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_38]
mov rax, [rbp+var_30]
sub rsi, rax
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+14h], ecx
cmp [rbp+var_24], 0
jnz short loc_92E5A
mov rax, [rbp+var_20]
cmp dword ptr [rax+14h], 3Bh ; ';'
jbe short loc_92E5F
loc_92E5A:
jmp loc_92F6C
loc_92E5F:
mov [rbp+var_44], 0
mov rax, [rbp+var_20]
mov qword ptr [rax+18h], 0
mov rax, [rbp+var_30]
cmp rax, [rbp+var_38]
jnz short loc_92E81
jmp loc_92F6C
loc_92E81:
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 2Eh ; '.'
jz short loc_92E92
jmp loc_92F6C
loc_92E92:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
mov rcx, [rbp+var_38]
mov rax, [rbp+var_30]
sub rcx, rax
mov eax, 6
cmp rax, rcx
jge short loc_92EBE
mov eax, 6
mov [rbp+var_50], rax
jmp short loc_92ECD
loc_92EBE:
mov rax, [rbp+var_38]
mov rcx, [rbp+var_30]
sub rax, rcx
mov [rbp+var_50], rax
loc_92ECD:
mov rax, [rbp+var_50]
mov [rbp+var_40], rax
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_40]
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_24]
call my_strtoui
mov eax, eax
mov ecx, eax
mov rax, [rbp+var_20]
mov [rax+18h], rcx
cmp [rbp+var_24], 0
jz short loc_92EFE
jmp short loc_92F6C
loc_92EFE:
cmp [rbp+var_40], 6
jnb short loc_92F22
mov rcx, [rbp+var_40]
lea rax, frac_mul
mov eax, [rax+rcx*4]
mov ecx, eax
mov rax, [rbp+var_20]
imul rcx, [rax+18h]
mov [rax+18h], rcx
loc_92F22:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
add rax, [rbp+var_30]
mov [rbp+var_30], rax
loc_92F35:
mov rax, [rbp+var_30]
mov rcx, [rbp+var_18]
cmp rax, [rcx]
jnb short loc_92F6A
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 30h ; '0'
jl short loc_92F5A
mov rax, [rbp+var_30]
movsx eax, byte ptr [rax]
cmp eax, 39h ; '9'
jle short loc_92F5C
loc_92F5A:
jmp short loc_92F6A
loc_92F5C:
mov rax, [rbp+var_30]
add rax, 1
mov [rbp+var_30], rax
jmp short loc_92F35
loc_92F6A:
jmp short $+2
loc_92F6C:
mov rcx, [rbp+var_30]
mov rax, [rbp+var_18]
mov [rax], rcx
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
|
long long parse_time(_BYTE *a1, long long a2, _QWORD *a3, long long a4)
{
int v4; // eax
int v5; // eax
int v6; // eax
unsigned int v7; // eax
unsigned long long v9; // [rsp+0h] [rbp-50h]
unsigned int v10; // [rsp+Ch] [rbp-44h]
_BYTE *v11; // [rsp+18h] [rbp-38h]
_BYTE *v12; // [rsp+20h] [rbp-30h] BYREF
int v13; // [rsp+2Ch] [rbp-24h] BYREF
long long v14; // [rsp+30h] [rbp-20h]
_QWORD *v15; // [rsp+38h] [rbp-18h]
long long v16; // [rsp+40h] [rbp-10h]
_BYTE *v17; // [rsp+48h] [rbp-8h]
v17 = a1;
v16 = a2;
v15 = a3;
v14 = a4;
v13 = 0;
v12 = a1;
v11 = &a1[a2];
v10 = 1;
v4 = my_strtoui(a1, a2, &v12, &v13);
*(_DWORD *)(v14 + 12) = v4;
if ( !v13 && *(_DWORD *)(v14 + 12) <= 0x346u && v12 != v11 && *v12 == 58 )
{
++v12;
v5 = my_strtoui(v12, v11 - v12, &v12, &v13);
*(_DWORD *)(v14 + 16) = v5;
if ( !v13 && *(_DWORD *)(v14 + 16) <= 0x3Bu && v12 != v11 && *v12 == 58 )
{
++v12;
v6 = my_strtoui(v12, v11 - v12, &v12, &v13);
*(_DWORD *)(v14 + 20) = v6;
if ( !v13 && *(_DWORD *)(v14 + 20) <= 0x3Bu )
{
v10 = 0;
*(_QWORD *)(v14 + 24) = 0LL;
if ( v12 != v11 && *v12 == 46 )
{
++v12;
v9 = v11 - v12 <= 6 ? v11 - v12 : 6LL;
v7 = my_strtoui(v12, v9, &v12, &v13);
*(_QWORD *)(v14 + 24) = v7;
if ( !v13 )
{
if ( v9 < 6 )
*(_QWORD *)(v14 + 24) *= frac_mul[v9];
v10 = 0;
for ( v12 += v9; (unsigned long long)v12 < *v15 && (char)*v12 >= 48 && (char)*v12 <= 57; ++v12 )
;
}
}
}
}
}
*v15 = v12;
return v10;
}
|
parse_time:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV dword ptr [RBP + -0x24],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
ADD RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x38],RAX
MOV dword ptr [RBP + -0x44],0x1
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x00194150
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0xc],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00192db8
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0xc],0x346
JA 0x00192db8
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00192db8
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3a
JZ 0x00192dbd
LAB_00192db8:
JMP 0x00192f6c
LAB_00192dbd:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x00194150
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x10],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00192e14
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x10],0x3b
JA 0x00192e14
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JZ 0x00192e14
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x3a
JZ 0x00192e19
LAB_00192e14:
JMP 0x00192f6c
LAB_00192e19:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RSI,RAX
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x00194150
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV dword ptr [RAX + 0x14],ECX
CMP dword ptr [RBP + -0x24],0x0
JNZ 0x00192e5a
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x14],0x3b
JBE 0x00192e5f
LAB_00192e5a:
JMP 0x00192f6c
LAB_00192e5f:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],0x0
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,qword ptr [RBP + -0x38]
JNZ 0x00192e81
JMP 0x00192f6c
LAB_00192e81:
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2e
JZ 0x00192e92
JMP 0x00192f6c
LAB_00192e92:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x30]
SUB RCX,RAX
MOV EAX,0x6
CMP RAX,RCX
JGE 0x00192ebe
MOV EAX,0x6
MOV qword ptr [RBP + -0x50],RAX
JMP 0x00192ecd
LAB_00192ebe:
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x30]
SUB RAX,RCX
MOV qword ptr [RBP + -0x50],RAX
LAB_00192ecd:
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x40]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x24]
CALL 0x00194150
MOV EAX,EAX
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX + 0x18],RCX
CMP dword ptr [RBP + -0x24],0x0
JZ 0x00192efe
JMP 0x00192f6c
LAB_00192efe:
CMP qword ptr [RBP + -0x40],0x6
JNC 0x00192f22
MOV RCX,qword ptr [RBP + -0x40]
LEA RAX,[0x2716a0]
MOV EAX,dword ptr [RAX + RCX*0x4]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x20]
IMUL RCX,qword ptr [RAX + 0x18]
MOV qword ptr [RAX + 0x18],RCX
LAB_00192f22:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
ADD RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x30],RAX
LAB_00192f35:
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x18]
CMP RAX,qword ptr [RCX]
JNC 0x00192f6a
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x30
JL 0x00192f5a
MOV RAX,qword ptr [RBP + -0x30]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x39
JLE 0x00192f5c
LAB_00192f5a:
JMP 0x00192f6a
LAB_00192f5c:
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x1
MOV qword ptr [RBP + -0x30],RAX
JMP 0x00192f35
LAB_00192f6a:
JMP 0x00192f6c
LAB_00192f6c:
MOV RCX,qword ptr [RBP + -0x30]
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RAX],RCX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4 parse_time(char *param_1,long param_2,int8 *param_3,long param_4)
{
int4 uVar1;
uint uVar2;
char *pcVar3;
ulong local_58;
int4 local_4c;
char *local_38;
int local_2c;
long local_28;
int8 *local_20;
long local_18;
char *local_10;
local_2c = 0;
pcVar3 = param_1 + param_2;
local_4c = 1;
local_38 = param_1;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
uVar1 = my_strtoui(param_1,(long)pcVar3 - (long)param_1,&local_38,&local_2c);
*(int4 *)(local_28 + 0xc) = uVar1;
if ((((local_2c == 0) && (*(uint *)(local_28 + 0xc) < 0x347)) && (local_38 != pcVar3)) &&
(*local_38 == ':')) {
local_38 = local_38 + 1;
uVar1 = my_strtoui(local_38,(long)pcVar3 - (long)local_38,&local_38,&local_2c);
*(int4 *)(local_28 + 0x10) = uVar1;
if (((local_2c == 0) && (*(uint *)(local_28 + 0x10) < 0x3c)) &&
((local_38 != pcVar3 && (*local_38 == ':')))) {
local_38 = local_38 + 1;
uVar1 = my_strtoui(local_38,(long)pcVar3 - (long)local_38,&local_38,&local_2c);
*(int4 *)(local_28 + 0x14) = uVar1;
if ((local_2c == 0) && (*(uint *)(local_28 + 0x14) < 0x3c)) {
local_4c = 0;
*(int8 *)(local_28 + 0x18) = 0;
if ((local_38 != pcVar3) && (*local_38 == '.')) {
local_38 = local_38 + 1;
if ((long)pcVar3 - (long)local_38 < 7) {
local_58 = (long)pcVar3 - (long)local_38;
}
else {
local_58 = 6;
}
uVar2 = my_strtoui(local_38,local_58,&local_38,&local_2c);
*(ulong *)(local_28 + 0x18) = (ulong)uVar2;
if (local_2c == 0) {
if (local_58 < 6) {
*(ulong *)(local_28 + 0x18) =
(ulong)*(uint *)(frac_mul + local_58 * 4) * *(long *)(local_28 + 0x18);
}
local_4c = 0;
for (local_38 = local_38 + local_58;
((local_38 < (char *)*local_20 && ('/' < *local_38)) && (*local_38 < ':'));
local_38 = local_38 + 1) {
}
}
}
}
}
}
*local_20 = local_38;
return local_4c;
}
|
|
7,702 |
minja::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
llama.cpp/common/minja/minja.hpp
|
static std::vector<std::string> split(const std::string & s, const std::string & sep) {
std::vector<std::string> result;
size_t start = 0;
size_t end = s.find(sep);
while (end != std::string::npos) {
result.push_back(s.substr(start, end - start));
start = end + sep.length();
end = s.find(sep, start);
}
result.push_back(s.substr(start));
return result;
}
|
O3
|
cpp
|
minja::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x205e0
cmpq $-0x1, %rax
je 0xae570
movq %rax, %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r12, %rcx
subq %rbp, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x210e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x71942
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xae54f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20190
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r12, %rbp
addq %rcx, %rbp
movq %r14, %rdi
movq %rbp, %rdx
callq 0x205e0
movq %rax, %r12
cmpq $-0x1, %rax
jne 0xae514
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq $-0x1, %rcx
callq 0x210e0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x71942
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xae5af
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20190
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0xae5e0
jmp 0xae5ce
movq %rax, %r14
jmp 0xae5f2
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xae5f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20190
movq %rbx, %rdi
callq 0x2734c
movq %r14, %rdi
callq 0x20b00
|
_ZN5minjaL5splitERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES7_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rdx]
mov rcx, [rdx+8]
xor ebp, ebp
mov rdi, r14
xor edx, edx
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
cmp rax, 0FFFFFFFFFFFFFFFFh
jz short loc_AE570
mov r12, rax
xor ebp, ebp
lea r13, [rsp+58h+var_50]
loc_AE514:
mov rcx, r12
sub rcx, rbp
mov rdi, r13
mov rsi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
mov rdi, rbx
mov rsi, r13
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
mov rdi, [rsp+58h+var_50]; void *
lea rax, [rsp+58h+var_40]
cmp rdi, rax
jz short loc_AE54F
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AE54F:
mov rsi, [r15]
mov rcx, [r15+8]
mov rbp, r12
add rbp, rcx
mov rdi, r14
mov rdx, rbp
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE4findEPKcmm; std::string::find(char const*,ulong,ulong)
mov r12, rax
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_AE514
loc_AE570:
lea rdi, [rsp+58h+var_50]
mov rsi, r14
mov rdx, rbp
mov rcx, 0FFFFFFFFFFFFFFFFh
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6substrEmm; std::string::substr(ulong,ulong)
lea rsi, [rsp+58h+var_50]
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE12emplace_backIJS5_EEERS5_DpOT_; std::vector<std::string>::emplace_back<std::string>(std::string &&)
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_AE5AF
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AE5AF:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]
jmp short loc_AE5E0
jmp short $+2
loc_AE5CE:
mov r14, rax
jmp short loc_AE5F2
mov r14, rax
mov rdi, [rsp+arg_0]; void *
lea rax, [rsp+arg_10]
loc_AE5E0:
cmp rdi, rax
jz short loc_AE5F2
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_AE5F2:
mov rdi, rbx
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rdi, r14
call __Unwind_Resume
|
void minja::split(long long a1, long long a2, _QWORD *a3)
{
long long v4; // rbp
long long v5; // rax
long long v6; // r12
long long v7; // rcx
void *v8[2]; // [rsp+8h] [rbp-50h] BYREF
_QWORD v9[8]; // [rsp+18h] [rbp-40h] BYREF
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
v4 = 0LL;
v5 = std::string::find(a2, *a3, 0LL, a3[1]);
if ( v5 != -1 )
{
v6 = v5;
v4 = 0LL;
do
{
std::string::substr(v8, a2, v4, v6 - v4);
std::vector<std::string>::emplace_back<std::string>(a1, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
v7 = a3[1];
v4 = v7 + v6;
v6 = std::string::find(a2, *a3, v7 + v6, v7);
}
while ( v6 != -1 );
}
std::string::substr(v8, a2, v4, -1LL);
std::vector<std::string>::emplace_back<std::string>(a1, v8);
if ( v8[0] != v9 )
operator delete(v8[0], v9[0] + 1LL);
}
|
split:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RDX]
MOV RCX,qword ptr [RDX + 0x8]
XOR EBP,EBP
MOV RDI,R14
XOR EDX,EDX
CALL 0x001205e0
CMP RAX,-0x1
JZ 0x001ae570
MOV R12,RAX
XOR EBP,EBP
LEA R13,[RSP + 0x8]
LAB_001ae514:
MOV RCX,R12
SUB RCX,RBP
LAB_001ae51a:
MOV RDI,R13
MOV RSI,R14
MOV RDX,RBP
CALL 0x001210e0
LAB_001ae528:
MOV RDI,RBX
MOV RSI,R13
CALL 0x00171942
MOV RDI,qword ptr [RSP + 0x8]
LEA RAX,[RSP + 0x18]
CMP RDI,RAX
JZ 0x001ae54f
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120190
LAB_001ae54f:
MOV RSI,qword ptr [R15]
MOV RCX,qword ptr [R15 + 0x8]
MOV RBP,R12
ADD RBP,RCX
MOV RDI,R14
MOV RDX,RBP
CALL 0x001205e0
MOV R12,RAX
CMP RAX,-0x1
JNZ 0x001ae514
LAB_001ae570:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV RDX,RBP
MOV RCX,-0x1
CALL 0x001210e0
LAB_001ae587:
LEA RSI,[RSP + 0x8]
MOV RDI,RBX
CALL 0x00171942
LAB_001ae594:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001ae5af
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x00120190
LAB_001ae5af:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* minja::split(std::__cxx11::string const&, std::__cxx11::string const&) */
void __thiscall minja::split(minja *this,string *param_1,string *param_2)
{
long lVar1;
long *local_50 [2];
long local_40 [2];
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
lVar1 = std::__cxx11::string::find((char *)param_1,*(ulong *)param_2,0);
if (lVar1 != -1) {
do {
/* try { // try from 001ae51a to 001ae527 has its CatchHandler @ 001ae5ce */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 001ae528 to 001ae532 has its CatchHandler @ 001ae5d3 */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
lVar1 = std::__cxx11::string::find
((char *)param_1,*(ulong *)param_2,lVar1 + *(long *)(param_2 + 8));
} while (lVar1 != -1);
}
/* try { // try from 001ae570 to 001ae586 has its CatchHandler @ 001ae5cc */
std::__cxx11::string::substr((ulong)local_50,(ulong)param_1);
/* try { // try from 001ae587 to 001ae593 has its CatchHandler @ 001ae5be */
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::
emplace_back<std::__cxx11::string>
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)this,
(string *)local_50);
if (local_50[0] != local_40) {
operator_delete(local_50[0],local_40[0] + 1);
}
return;
}
|
|
7,703 |
google::protobuf::compiler::csharp::MessageFieldGenerator::GenerateExtensionCode(google::protobuf::io::Printer*)
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/compiler/csharp/csharp_message_field.cc
|
void MessageFieldGenerator::GenerateExtensionCode(io::Printer* printer) {
WritePropertyDocComment(printer, descriptor_);
AddDeprecatedFlag(printer);
printer->Print(
variables_,
"$access_level$ static readonly pb::Extension<$extended_type$, $type_name$> $property_name$ =\n"
" new pb::Extension<$extended_type$, $type_name$>($number$, ");
GenerateCodecCode(printer);
printer->Print(");\n");
}
|
O3
|
cpp
|
google::protobuf::compiler::csharp::MessageFieldGenerator::GenerateExtensionCode(google::protobuf::io::Printer*):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
callq 0x9d827
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa1280
leaq 0x20(%r14), %rsi
leaq 0x160205(%rip), %rdx # 0x19ed2d
movq %rbx, %rdi
callq 0x16cd32
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x20(%rax)
leaq 0x18f6d9(%rip), %rsi # 0x1ce21c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2e40a
|
_ZN6google8protobuf8compiler6csharp21MessageFieldGenerator21GenerateExtensionCodeEPNS0_2io7PrinterE:
push r14; char
push rbx; int
push rax; void *
mov rbx, rsi
mov r14, rdi
mov rsi, [rdi+10h]; google::protobuf::io::Printer *
mov rdi, rbx; this
call _ZN6google8protobuf8compiler6csharp23WritePropertyDocCommentEPNS0_2io7PrinterEPKNS0_15FieldDescriptorE; google::protobuf::compiler::csharp::WritePropertyDocComment(google::protobuf::io::Printer *,google::protobuf::FieldDescriptor const*)
mov rdi, r14; this
mov rsi, rbx; google::protobuf::io::Printer *
call _ZN6google8protobuf8compiler6csharp18FieldGeneratorBase17AddDeprecatedFlagEPNS0_2io7PrinterE; google::protobuf::compiler::csharp::FieldGeneratorBase::AddDeprecatedFlag(google::protobuf::io::Printer *)
lea rsi, [r14+20h]
lea rdx, aAccessLevelSta; "$access_level$ static readonly pb::Exte"...
mov rdi, rbx; this
call _ZN6google8protobuf2io7Printer5PrintERKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES9_St4lessIS9_ESaISt4pairIKS9_S9_EEEPKc; google::protobuf::io::Printer::Print(std::map<std::string,std::string> const&,char const*)
mov rax, [r14]
mov rdi, r14
mov rsi, rbx
call qword ptr [rax+20h]
lea rsi, aProtoNsInterna_15+6Eh; ");\n"
mov rdi, rbx
add rsp, 8
pop rbx
pop r14
jmp _ZN6google8protobuf2io7Printer5PrintIJEEEvPKcDpRKT_
|
GenerateExtensionCode:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RDI + 0x10]
MOV RDI,RBX
CALL 0x0019d827
MOV RDI,R14
MOV RSI,RBX
CALL 0x001a1280
LEA RSI,[R14 + 0x20]
LEA RDX,[0x29ed2d]
MOV RDI,RBX
CALL 0x0026cd32
MOV RAX,qword ptr [R14]
MOV RDI,R14
MOV RSI,RBX
CALL qword ptr [RAX + 0x20]
LEA RSI,[0x2ce21c]
MOV RDI,RBX
ADD RSP,0x8
POP RBX
POP R14
JMP 0x0012e40a
|
/* google::protobuf::compiler::csharp::MessageFieldGenerator::GenerateExtensionCode(google::protobuf::io::Printer*)
*/
void __thiscall
google::protobuf::compiler::csharp::MessageFieldGenerator::GenerateExtensionCode
(MessageFieldGenerator *this,Printer *param_1)
{
WritePropertyDocComment(param_1,*(FieldDescriptor **)(this + 0x10));
FieldGeneratorBase::AddDeprecatedFlag((FieldGeneratorBase *)this,param_1);
io::Printer::Print(param_1,(map *)(this + 0x20),
"$access_level$ static readonly pb::Extension<$extended_type$, $type_name$> $property_name$ =\n new pb::Extension<$extended_type$, $type_name$>($number$, "
);
(**(code **)(*(long *)this + 0x20))(this,param_1);
io::Printer::Print<>(param_1,");\n");
return;
}
|
||
7,704 |
mysql_stmt_prepare_start_internal
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
static void
mysql_stmt_prepare_start_internal(void *d)
{
MK_ASYNC_INTERNAL_BODY(
mysql_stmt_prepare,
(parms->stmt, parms->query, parms->length),
parms->stmt->mysql,
int,
r_int)
}
|
O3
|
c
|
mysql_stmt_prepare_start_internal:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
movq 0x38(%rax), %rcx
movq 0x480(%rcx), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdi), %rdx
movq %rax, %rdi
callq 0x91ce0
movl %eax, 0x8(%rbx)
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
mysql_stmt_prepare_start_internal:
push rbp
mov rbp, rsp
push rbx
push rax
mov rax, [rdi]
mov rsi, [rdi+8]
mov rcx, [rax+38h]
mov rcx, [rcx+480h]
mov rbx, [rcx+28h]
mov rdx, [rdi+10h]
mov rdi, rax
call mysql_stmt_prepare
mov [rbx+8], eax
mov dword ptr [rbx], 0
add rsp, 8
pop rbx
pop rbp
retn
|
long long mysql_stmt_prepare_start_internal(long long *a1)
{
_DWORD *v1; // rbx
long long result; // rax
v1 = *(_DWORD **)(*(_QWORD *)(*(_QWORD *)(*a1 + 56) + 1152LL) + 40LL);
result = mysql_stmt_prepare(*a1, a1[1], a1[2]);
v1[2] = result;
*v1 = 0;
return result;
}
|
mysql_stmt_prepare_start_internal:
PUSH RBP
MOV RBP,RSP
PUSH RBX
PUSH RAX
MOV RAX,qword ptr [RDI]
MOV RSI,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX + 0x38]
MOV RCX,qword ptr [RCX + 0x480]
MOV RBX,qword ptr [RCX + 0x28]
MOV RDX,qword ptr [RDI + 0x10]
MOV RDI,RAX
CALL 0x00191ce0
MOV dword ptr [RBX + 0x8],EAX
MOV dword ptr [RBX],0x0
ADD RSP,0x8
POP RBX
POP RBP
RET
|
void mysql_stmt_prepare_start_internal(long *param_1)
{
int4 *puVar1;
int4 uVar2;
puVar1 = *(int4 **)(*(long *)(*(long *)(*param_1 + 0x38) + 0x480) + 0x28);
uVar2 = mysql_stmt_prepare(*param_1,param_1[1],param_1[2]);
puVar1[2] = uVar2;
*puVar1 = 0;
return;
}
|
|
7,705 |
ModbusTcpPort::close()
|
serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpPort_unix.cpp
|
StatusCode ModbusTcpPort::close()
{
ModbusTcpPortPrivateUnix *d = d_unix(d_ptr);
if (!d->socket->isInvalid())
{
d->socket->shutdown();
d->socket->close();
}
d->state = STATE_CLOSED;
return Status_Good;
}
|
O1
|
cpp
|
ModbusTcpPort::close():
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
movq 0x180(%rbx), %rax
movl (%rax), %edi
cmpl $-0x1, %edi
je 0x11e8a
movl $0x2, %esi
callq 0x5420
movq 0x180(%rbx), %r14
movl (%r14), %edi
callq 0x55a0
movl $0xffffffff, (%r14) # imm = 0xFFFFFFFF
movl $0xa, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
_ZN13ModbusTcpPort5closeEv:
push r14
push rbx
push rax
mov rbx, [rdi+8]
mov rax, [rbx+180h]
mov edi, [rax]
cmp edi, 0FFFFFFFFh
jz short loc_11E8A
mov esi, 2
call _shutdown
mov r14, [rbx+180h]
mov edi, [r14]
call _close
mov dword ptr [r14], 0FFFFFFFFh
loc_11E8A:
mov dword ptr [rbx+8], 0Ah
xor eax, eax
add rsp, 8
pop rbx
pop r14
retn
|
long long ModbusTcpPort::close(ModbusTcpPort *this)
{
long long v1; // rbx
long long v2; // rdi
_DWORD *v3; // r14
v1 = *((_QWORD *)this + 1);
v2 = **(unsigned int **)(v1 + 384);
if ( (_DWORD)v2 != -1 )
{
shutdown(v2, 2LL);
v3 = *(_DWORD **)(v1 + 384);
close((unsigned int)*v3);
*v3 = -1;
}
*(_DWORD *)(v1 + 8) = 10;
return 0LL;
}
|
close:
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,qword ptr [RDI + 0x8]
MOV RAX,qword ptr [RBX + 0x180]
MOV EDI,dword ptr [RAX]
CMP EDI,-0x1
JZ 0x00111e8a
MOV ESI,0x2
CALL 0x00105420
MOV R14,qword ptr [RBX + 0x180]
MOV EDI,dword ptr [R14]
CALL 0x001055a0
MOV dword ptr [R14],0xffffffff
LAB_00111e8a:
MOV dword ptr [RBX + 0x8],0xa
XOR EAX,EAX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* ModbusTcpPort::close() */
int8 __thiscall ModbusTcpPort::close(ModbusTcpPort *this)
{
long lVar1;
int *piVar2;
lVar1 = *(long *)(this + 8);
if (**(int **)(lVar1 + 0x180) != -1) {
shutdown(**(int **)(lVar1 + 0x180),2);
piVar2 = *(int **)(lVar1 + 0x180);
::close(*piVar2);
*piVar2 = -1;
}
*(int4 *)(lVar1 + 8) = 10;
return 0;
}
|
|
7,706 |
ModbusTcpPort::close()
|
serhmarch[P]ModbusBridge/modbus/src/unix/ModbusTcpPort_unix.cpp
|
StatusCode ModbusTcpPort::close()
{
ModbusTcpPortPrivateUnix *d = d_unix(d_ptr);
if (!d->socket->isInvalid())
{
d->socket->shutdown();
d->socket->close();
}
d->state = STATE_CLOSED;
return Status_Good;
}
|
O2
|
cpp
|
ModbusTcpPort::close():
pushq %rbx
movq 0x8(%rdi), %rbx
movq 0x180(%rbx), %rdi
cmpl $-0x1, (%rdi)
je 0xf138
callq 0xf90c
movq 0x180(%rbx), %rdi
callq 0xf916
movl $0xa, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
retq
nop
|
_ZN13ModbusTcpPort5closeEv:
push rbx
mov rbx, [rdi+8]
mov rdi, [rbx+180h]; this
cmp dword ptr [rdi], 0FFFFFFFFh
jz short loc_F138
call _ZN15ModbusTcpSocket8shutdownEv; ModbusTcpSocket::shutdown(void)
mov rdi, [rbx+180h]; this
call _ZN15ModbusTcpSocket5closeEv; ModbusTcpSocket::close(void)
loc_F138:
mov dword ptr [rbx+8], 0Ah
xor eax, eax
pop rbx
retn
|
long long ModbusTcpPort::close(ModbusTcpPort *this)
{
long long v1; // rbx
ModbusTcpSocket *v2; // rdi
v1 = *((_QWORD *)this + 1);
v2 = *(ModbusTcpSocket **)(v1 + 384);
if ( *(_DWORD *)v2 != -1 )
{
ModbusTcpSocket::shutdown(v2);
ModbusTcpSocket::close(*(ModbusTcpSocket **)(v1 + 384));
}
*(_DWORD *)(v1 + 8) = 10;
return 0LL;
}
|
close:
PUSH RBX
MOV RBX,qword ptr [RDI + 0x8]
MOV RDI,qword ptr [RBX + 0x180]
CMP dword ptr [RDI],-0x1
JZ 0x0010f138
CALL 0x0010f90c
MOV RDI,qword ptr [RBX + 0x180]
CALL 0x0010f916
LAB_0010f138:
MOV dword ptr [RBX + 0x8],0xa
XOR EAX,EAX
POP RBX
RET
|
/* ModbusTcpPort::close() */
int8 __thiscall ModbusTcpPort::close(ModbusTcpPort *this)
{
long lVar1;
lVar1 = *(long *)(this + 8);
if (*(int *)*(ModbusTcpSocket **)(lVar1 + 0x180) != -1) {
ModbusTcpSocket::shutdown(*(ModbusTcpSocket **)(lVar1 + 0x180));
ModbusTcpSocket::close(*(ModbusTcpSocket **)(lVar1 + 0x180));
}
*(int4 *)(lVar1 + 8) = 10;
return 0;
}
|
|
7,707 |
LefDefParser::defiNet::setType(char const*)
|
Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiNet.cpp
|
void defiNet::setType(const char* typ) {
if (*typ == 'F') {
isFixed_ = 1;
} else if (*typ == 'C') {
isCover_ = 1;
} else if (*typ == 'R') {
isRouted_ = 1;
} else {
// Silently do nothing with bad input.
}
}
|
O3
|
cpp
|
LefDefParser::defiNet::setType(char const*):
movzbl (%rsi), %eax
cmpl $0x43, %eax
je 0x24840
cmpl $0x52, %eax
je 0x2483b
cmpl $0x46, %eax
jne 0x2483f
movb $0x1, 0x3d(%rdi)
retq
movb $0x1, 0x3e(%rdi)
retq
movb $0x1, 0x3f(%rdi)
retq
nop
|
_ZN12LefDefParser7defiNet7setTypeEPKc:
movzx eax, byte ptr [rsi]
cmp eax, 43h ; 'C'
jz short loc_24840
cmp eax, 52h ; 'R'
jz short loc_2483B
cmp eax, 46h ; 'F'
jnz short locret_2483F
mov byte ptr [rdi+3Dh], 1
retn
loc_2483B:
mov byte ptr [rdi+3Eh], 1
locret_2483F:
retn
loc_24840:
mov byte ptr [rdi+3Fh], 1
retn
|
long long LefDefParser::defiNet::setType(LefDefParser::defiNet *this, const char *a2)
{
long long result; // rax
result = *(unsigned __int8 *)a2;
switch ( (_DWORD)result )
{
case 'C':
*((_BYTE *)this + 63) = 1;
break;
case 'R':
*((_BYTE *)this + 62) = 1;
break;
case 'F':
*((_BYTE *)this + 61) = 1;
break;
}
return result;
}
|
setType:
MOVZX EAX,byte ptr [RSI]
CMP EAX,0x43
JZ 0x00124840
CMP EAX,0x52
JZ 0x0012483b
CMP EAX,0x46
JNZ 0x0012483f
MOV byte ptr [RDI + 0x3d],0x1
RET
LAB_0012483b:
MOV byte ptr [RDI + 0x3e],0x1
LAB_0012483f:
RET
LAB_00124840:
MOV byte ptr [RDI + 0x3f],0x1
RET
|
/* LefDefParser::defiNet::setType(char const*) */
void __thiscall LefDefParser::defiNet::setType(defiNet *this,char *param_1)
{
char cVar1;
cVar1 = *param_1;
if (cVar1 == 'C') {
this[0x3f] = (defiNet)0x1;
return;
}
if (cVar1 == 'R') {
this[0x3e] = (defiNet)0x1;
}
else if (cVar1 == 'F') {
this[0x3d] = (defiNet)0x1;
return;
}
return;
}
|
|
7,708 |
minja::ForNode::do_render(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, std::shared_ptr<minja::Context> const&) const
|
monkey531[P]llama/common/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 0x7dbd6
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
je 0x7dbf4
movq %rdx, %r15
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x6c432
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x28, %edi
callq 0x197a0
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 0x323(%rip), %rax # 0x7ddf8
movq %rax, 0x18(%rsp)
leaq 0x31f(%rip), %rcx # 0x7de00
movq %rcx, 0x10(%rsp)
cmpb $0x0, 0x68(%rbx)
je 0x7db11
movq %rsp, %rbx
leaq 0x40(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x7dd82
cmpq $0x0, 0x10(%rbx)
je 0x7dc26
movq 0x18(%rsp), %rax
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
callq *%rax
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7db32
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x7db4b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6c664
movq %rbx, %rdi
callq 0x293d4
movq -0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x7db73
callq 0x33e7e
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x7db82
callq 0x33e7e
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x7db91
callq 0x33e7e
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x7dbc7
movq 0x6a3ee(%rip), %rax # 0xe7f90
cmpb $0x0, (%rax)
je 0x7dbb2
movl 0xc(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rdi)
jmp 0x7dbbc
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rdi)
cmpl $0x1, %eax
jne 0x7dbc7
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x193b0
movq %rax, %r14
leaq 0x387e3(%rip), %rsi # 0xb63cd
movq %rax, %rdi
callq 0x192c0
jmp 0x7dc10
movl $0x10, %edi
callq 0x193b0
movq %rax, %r14
leaq 0x387de(%rip), %rsi # 0xb63e6
movq %rax, %rdi
callq 0x192c0
movq 0x6a3d9(%rip), %rsi # 0xe7ff0
movq 0x6a34a(%rip), %rdx # 0xe7f68
movq %r14, %rdi
callq 0x19da0
callq 0x192a0
jmp 0x7dc2d
movq %rax, %rbx
movq %r14, %rdi
callq 0x19570
jmp 0x7dc80
jmp 0x7dc8a
jmp 0x7dc8a
movq %rax, %rbx
jmp 0x7dc5d
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x7dc5d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x7dc76
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x48(%rsp), %rdi
callq 0x3227e
movq %rbx, %rdi
callq 0x19e10
jmp 0x7dc8a
movq %rax, %rdi
callq 0x20369
|
_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_7DBD6
mov rbx, rdi
cmp qword ptr [rdi+58h], 0
jz loc_7DBF4
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_7DB11
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_7DC26
mov rax, [rsp+0B8h+var_A0]
loc_7DB11:
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_7DB32
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_7DB32:
mov rax, qword ptr [rsp+0B8h+var_88]
test rax, rax
jz short loc_7DB4B
lea rdi, [rsp+0B8h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_7DB4B:
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()
mov rdi, [rbx-8]
test rdi, rdi
jz short loc_7DB73
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB73:
mov rdi, [rsp+0B8h+var_48]
test rdi, rdi
jz short loc_7DB82
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB82:
mov rdi, [rsp+0B8h+var_58]
test rdi, rdi
jz short loc_7DB91
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_7DB91:
mov rdi, [rsp+0B8h+var_68]
test rdi, rdi
jz short loc_7DBC7
mov rax, cs:__libc_single_threaded_ptr
cmp byte ptr [rax], 0
jz short loc_7DBB2
mov eax, [rdi+0Ch]
lea ecx, [rax-1]
mov [rdi+0Ch], ecx
jmp short loc_7DBBC
loc_7DBB2:
mov eax, 0FFFFFFFFh
lock xadd [rdi+0Ch], eax
loc_7DBBC:
cmp eax, 1
jnz short loc_7DBC7
mov rax, [rdi]
call qword ptr [rax+18h]
loc_7DBC7:
add rsp, 98h
pop rbx
pop r12
pop r14
pop r15
retn
loc_7DBD6:
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_7DC10
loc_7DBF4:
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_7DC10:
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_7DC26:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
jmp short $+2
loc_7DC2D:
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_7DC80
jmp short loc_7DC8A
jmp short loc_7DC8A
mov rbx, rax
jmp short loc_7DC5D
mov rbx, rax
mov rax, [rsp+0B8h+var_A8]
test rax, rax
jz short loc_7DC5D
mov rdi, rsp
mov rsi, rdi
mov edx, 3
call rax
loc_7DC5D:
mov rax, qword ptr [rsp+0B8h+var_88]
test rax, rax
jz short loc_7DC76
lea rdi, [rsp+0B8h+var_98]
mov rsi, rdi
mov edx, 3
call rax
loc_7DC76:
lea rdi, [rsp+0B8h+var_70]; this
call _ZN5minja5ValueD2Ev; minja::Value::~Value()
loc_7DC80:
mov rdi, rbx
call __Unwind_Resume
jmp short $+2
loc_7DC8A:
mov rdi, rax
call __clang_call_terminate
|
long long 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 result; // rax
long long v9; // rdi
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]
volatile signed __int32 *v20; // [rsp+70h] [rbp-48h]
volatile signed __int32 *v21; // [rsp+80h] [rbp-38h]
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_25;
}
if ( !*(_QWORD *)(a1 + 88) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "ForNode.body is null");
LABEL_25:
__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);
result = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(v22);
if ( v21 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v21);
if ( v20 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v20);
if ( v19 )
result = std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v19);
v9 = v18;
if ( v18 )
{
if ( _libc_single_threaded )
{
result = *(unsigned int *)(v18 + 12);
*(_DWORD *)(v18 + 12) = result - 1;
}
else
{
result = (unsigned int)_InterlockedExchangeAdd((volatile signed __int32 *)(v18 + 12), 0xFFFFFFFF);
}
if ( (_DWORD)result == 1 )
return (*(long long ( **)(long long, _QWORD))(*(_QWORD *)v9 + 24LL))(v9, 0LL);
}
return result;
}
|
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 0x0017dbd6
MOV RBX,RDI
CMP qword ptr [RDI + 0x58],0x0
JZ 0x0017dbf4
MOV R15,RDX
LEA R12,[RSP + 0x48]
MOV RDI,R12
CALL 0x0016c432
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x30],XMM0
MOVAPS xmmword ptr [RSP + 0x20],XMM0
MOV qword ptr [RSP + 0x8],0x0
LAB_0017daa8:
MOV EDI,0x28
CALL 0x001197a0
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,[0x17ddf8]
MOV qword ptr [RSP + 0x18],RAX
LEA RCX,[0x17de00]
MOV qword ptr [RSP + 0x10],RCX
CMP byte ptr [RBX + 0x68],0x0
JZ 0x0017db11
MOV RBX,RSP
LEA RSI,[RSP + 0x40]
MOV qword ptr [RSI],RBX
LEA RDI,[RSP + 0x20]
CALL 0x0017dd82
CMP qword ptr [RBX + 0x10],0x0
JZ 0x0017dc26
MOV RAX,qword ptr [RSP + 0x18]
LAB_0017db11:
MOV RDI,RSP
LEA RSI,[RSP + 0x48]
CALL RAX
MOV RAX,qword ptr [RSP + 0x10]
TEST RAX,RAX
JZ 0x0017db32
LAB_0017db25:
MOV RDI,RSP
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0017db32:
MOV RAX,qword ptr [RSP + 0x30]
TEST RAX,RAX
JZ 0x0017db4b
LAB_0017db3c:
LEA RDI,[RSP + 0x20]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_0017db4b:
LEA RBX,[RSP + 0x88]
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0016c664
MOV RDI,RBX
CALL 0x001293d4
MOV RDI,qword ptr [RBX + -0x8]
TEST RDI,RDI
JZ 0x0017db73
CALL 0x00133e7e
LAB_0017db73:
MOV RDI,qword ptr [RSP + 0x70]
TEST RDI,RDI
JZ 0x0017db82
CALL 0x00133e7e
LAB_0017db82:
MOV RDI,qword ptr [RSP + 0x60]
TEST RDI,RDI
JZ 0x0017db91
CALL 0x00133e7e
LAB_0017db91:
MOV RDI,qword ptr [RSP + 0x50]
TEST RDI,RDI
JZ 0x0017dbc7
MOV RAX,qword ptr [0x001e7f90]
CMP byte ptr [RAX],0x0
JZ 0x0017dbb2
MOV EAX,dword ptr [RDI + 0xc]
LEA ECX,[RAX + -0x1]
MOV dword ptr [RDI + 0xc],ECX
JMP 0x0017dbbc
LAB_0017dbb2:
MOV EAX,0xffffffff
XADD.LOCK dword ptr [RDI + 0xc],EAX
LAB_0017dbbc:
CMP EAX,0x1
JNZ 0x0017dbc7
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x18]
LAB_0017dbc7:
ADD RSP,0x98
POP RBX
POP R12
POP R14
POP R15
RET
LAB_0017dbd6:
MOV EDI,0x10
CALL 0x001193b0
MOV R14,RAX
LAB_0017dbe3:
LEA RSI,[0x1b63cd]
MOV RDI,RAX
CALL 0x001192c0
LAB_0017dbf2:
JMP 0x0017dc10
LAB_0017dbf4:
MOV EDI,0x10
CALL 0x001193b0
MOV R14,RAX
LAB_0017dc01:
LEA RSI,[0x1b63e6]
MOV RDI,RAX
CALL 0x001192c0
LAB_0017dc10:
MOV RSI,qword ptr [0x001e7ff0]
MOV RDX,qword ptr [0x001e7f68]
MOV RDI,R14
CALL 0x00119da0
LAB_0017dc26:
CALL 0x001192a0
|
/* 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;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_48;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_38;
data local_30 [16];
if (*(shared_ptr **)(this + 0x38) == (shared_ptr *)0x0) {
this_00 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017dbe3 to 0017dbf1 has its CatchHandler @ 0017dc2d */
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 0017daa8 to 0017dab1 has its CatchHandler @ 0017dc3e */
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 0017dc26 to 0017dc2a has its CatchHandler @ 0017dc43 */
std::__throw_bad_function_call();
}
/* try { // try from 0017db11 to 0017db1a has its CatchHandler @ 0017dc43 */
(*local_a0)(&local_b8,local_70);
if (local_a8 != (code *)0x0) {
/* try { // try from 0017db25 to 0017db31 has its CatchHandler @ 0017dc3c */
(*local_a8)(&local_b8,&local_b8,3);
}
if (local_88 != (code *)0x0) {
/* try { // try from 0017db3c to 0017db4a has its CatchHandler @ 0017dc3a */
(*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);
if (local_38 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_38);
}
if (local_48 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_48);
}
if (local_58 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_58);
}
if (local_68 != (long *)0x0) {
if (*PTR___libc_single_threaded_001e7f90 == '\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 0017dc01 to 0017dc0f has its CatchHandler @ 0017dc2b */
std::runtime_error::runtime_error(this_00,"ForNode.body is null");
}
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,PTR_typeinfo_001e7ff0,PTR__runtime_error_001e7f68);
}
|
|
7,709 |
google::protobuf::io::CopyingInputStreamAdaptor::FreeBuffer()
|
aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc
|
void CopyingInputStreamAdaptor::FreeBuffer() {
GOOGLE_CHECK_EQ(backup_bytes_, 0);
buffer_used_ = 0;
buffer_.reset();
}
|
O3
|
cpp
|
google::protobuf::io::CopyingInputStreamAdaptor::FreeBuffer():
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x30(%rdi)
je 0x9d40a
leaq 0x206b3(%rip), %rdx # 0xbda80
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x3, %esi
movl $0x123, %ecx # imm = 0x123
callq 0x169ca
leaq 0x20967(%rip), %rsi # 0xbdd52
movq %r14, %rdi
callq 0x164c8
leaq 0xf(%rsp), %rdi
movq %rax, %rsi
callq 0x165a2
leaq 0x10(%rsp), %rdi
callq 0x169e8
movl $0x0, 0x2c(%rbx)
movq 0x20(%rbx), %rdi
movq $0x0, 0x20(%rbx)
testq %rdi, %rdi
je 0x9d427
callq 0xf3f0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x9d431
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x169e8
movq %rbx, %rdi
callq 0xf570
|
_ZN6google8protobuf2io25CopyingInputStreamAdaptor10FreeBufferEv:
push r14
push rbx
sub rsp, 48h
mov rbx, rdi
cmp dword ptr [rdi+30h], 0
jz short loc_9D40A
lea rdx, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/aimrt_"...
lea r14, [rsp+58h+var_48]
mov rdi, r14
mov esi, 3
mov ecx, 123h
call _ZN6google8protobuf8internal10LogMessageC2ENS0_8LogLevelEPKci; google::protobuf::internal::LogMessage::LogMessage(google::protobuf::LogLevel,char const*,int)
lea rsi, aCheckFailedBac; "CHECK failed: (backup_bytes_) == (0): "
mov rdi, r14
call _ZN6google8protobuf8internal10LogMessagelsEPKc; google::protobuf::internal::LogMessage::operator<<(char const*)
lea rdi, [rsp+58h+var_49]
mov rsi, rax
call _ZN6google8protobuf8internal11LogFinisheraSERNS1_10LogMessageE; google::protobuf::internal::LogFinisher::operator=(google::protobuf::internal::LogMessage &)
lea rdi, [rsp+58h+var_48]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
loc_9D40A:
mov dword ptr [rbx+2Ch], 0
mov rdi, [rbx+20h]; void *
mov qword ptr [rbx+20h], 0
test rdi, rdi
jz short loc_9D427
call __ZdaPv; operator delete[](void *)
loc_9D427:
add rsp, 48h
pop rbx
pop r14
retn
jmp short $+2
loc_9D431:
mov rbx, rax
lea rdi, [rsp+arg_8]; this
call _ZN6google8protobuf8internal10LogMessageD2Ev; google::protobuf::internal::LogMessage::~LogMessage()
mov rdi, rbx
call __Unwind_Resume
|
void google::protobuf::io::CopyingInputStreamAdaptor::FreeBuffer(
google::protobuf::io::CopyingInputStreamAdaptor *this)
{
google::protobuf::internal::LogMessage *v2; // rax
void *v3; // rdi
char v4; // [rsp+Fh] [rbp-49h] BYREF
_BYTE v5[72]; // [rsp+10h] [rbp-48h] BYREF
if ( *((_DWORD *)this + 12) )
{
google::protobuf::internal::LogMessage::LogMessage(
(long long)v5,
3,
(long long)"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_str"
"eam_impl_lite.cc",
291);
v2 = (google::protobuf::internal::LogMessage *)google::protobuf::internal::LogMessage::operator<<(
(long long)v5,
(long long)"CHECK failed: (backup_bytes_) == (0): ");
google::protobuf::internal::LogFinisher::operator=((long long)&v4, v2);
google::protobuf::internal::LogMessage::~LogMessage((google::protobuf::internal::LogMessage *)v5);
}
*((_DWORD *)this + 11) = 0;
v3 = (void *)*((_QWORD *)this + 4);
*((_QWORD *)this + 4) = 0LL;
if ( v3 )
operator delete[](v3);
}
|
FreeBuffer:
PUSH R14
PUSH RBX
SUB RSP,0x48
MOV RBX,RDI
CMP dword ptr [RDI + 0x30],0x0
JZ 0x0019d40a
LEA RDX,[0x1bda80]
LEA R14,[RSP + 0x10]
MOV RDI,R14
MOV ESI,0x3
MOV ECX,0x123
CALL 0x001169ca
LAB_0019d3e4:
LEA RSI,[0x1bdd52]
MOV RDI,R14
CALL 0x001164c8
LAB_0019d3f3:
LEA RDI,[RSP + 0xf]
MOV RSI,RAX
CALL 0x001165a2
LAB_0019d400:
LEA RDI,[RSP + 0x10]
CALL 0x001169e8
LAB_0019d40a:
MOV dword ptr [RBX + 0x2c],0x0
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RBX + 0x20],0x0
TEST RDI,RDI
JZ 0x0019d427
CALL 0x0010f3f0
LAB_0019d427:
ADD RSP,0x48
POP RBX
POP R14
RET
|
/* google::protobuf::io::CopyingInputStreamAdaptor::FreeBuffer() */
void __thiscall
google::protobuf::io::CopyingInputStreamAdaptor::FreeBuffer(CopyingInputStreamAdaptor *this)
{
void *pvVar1;
LogMessage *pLVar2;
LogFinisher local_49;
LogMessage local_48 [56];
if (*(int *)(this + 0x30) != 0) {
internal::LogMessage::LogMessage
(local_48,3,
"/workspace/llm4binary/github2025/aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/io/zero_copy_stream_impl_lite.cc"
,0x123);
/* try { // try from 0019d3e4 to 0019d3f2 has its CatchHandler @ 0019d431 */
pLVar2 = (LogMessage *)
internal::LogMessage::operator<<(local_48,"CHECK failed: (backup_bytes_) == (0): ");
/* try { // try from 0019d3f3 to 0019d3ff has its CatchHandler @ 0019d42f */
internal::LogFinisher::operator=(&local_49,pLVar2);
internal::LogMessage::~LogMessage(local_48);
}
*(int4 *)(this + 0x2c) = 0;
pvVar1 = *(void **)(this + 0x20);
*(int8 *)(this + 0x20) = 0;
if (pvVar1 != (void *)0x0) {
operator_delete__(pvVar1);
}
return;
}
|
|
7,710 |
list_builtin_chat_templates[abi:cxx11]()
|
llama.cpp/common/arg.cpp
|
static std::string list_builtin_chat_templates() {
std::vector<const char *> supported_tmpl;
int32_t res = llama_chat_builtin_templates(nullptr, 0);
supported_tmpl.resize(res);
res = llama_chat_builtin_templates(supported_tmpl.data(), supported_tmpl.size());
std::ostringstream msg;
for (auto & tmpl : supported_tmpl) {
msg << tmpl << (&tmpl == &supported_tmpl.back() ? "" : ", ");
}
return msg.str();
}
|
O3
|
cpp
|
list_builtin_chat_templates[abi:cxx11]():
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x21cd0
movslq %eax, %rsi
movq %rsp, %rdi
callq 0x8f15a
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
subq %rdi, %rsi
sarq $0x3, %rsi
callq 0x21cd0
movq %rbx, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x22000
movq (%rsp), %r12
movq 0x8(%rsp), %r13
cmpq %r13, %r12
je 0x59f1c
leaq 0xc75e8(%rip), %rbp # 0x121490
leaq 0xcc972(%rip), %rbx # 0x126821
leaq 0x20(%rsp), %r14
movq (%r12), %r15
testq %r15, %r15
je 0x59ed5
movq %r15, %rdi
callq 0x21660
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x22060
jmp 0x59ef1
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x22290
movq 0x8(%rsp), %rax
addq $-0x8, %rax
xorl %edx, %edx
cmpq %rax, %r12
setne %dl
movq %rbx, %rsi
cmoveq %rbp, %rsi
addl %edx, %edx
movq %r14, %rdi
callq 0x22060
addq $0x8, %r12
cmpq %r13, %r12
jne 0x59eb4
leaq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x21640
movq 0x10b01e(%rip), %rsi # 0x164f50
leaq 0x20(%rsp), %rdi
callq 0x21c70
leaq 0x90(%rsp), %rdi
callq 0x21c40
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x59f5f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21170
addq $0x198, %rsp # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x59f7a
jmp 0x59f75
movq %rax, %rbx
jmp 0x59f9b
movq %rax, %rbx
movq 0x10afcc(%rip), %rsi # 0x164f50
leaq 0x20(%rsp), %rdi
callq 0x21c70
leaq 0x90(%rsp), %rdi
callq 0x21c40
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x59fb1
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x21170
movq %rbx, %rdi
callq 0x21af0
|
_ZL27list_builtin_chat_templatesB5cxx11v:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 198h
mov rbx, rdi
xorps xmm0, xmm0
movaps xmmword ptr [rsp+1C8h+var_1C8], xmm0
mov [rsp+1C8h+var_1B8], 0
xor edi, edi
xor esi, esi
call _llama_chat_builtin_templates
movsxd rsi, eax
mov rdi, rsp
call _ZNSt6vectorIPKcSaIS1_EE6resizeEm; std::vector<char const*>::resize(ulong)
mov rdi, [rsp+1C8h+var_1C8]
mov rsi, [rsp+1C8h+var_1C8+8]
sub rsi, rdi
sar rsi, 3
call _llama_chat_builtin_templates
mov [rsp+1C8h+var_1B0], rbx
lea rdi, [rsp+1C8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEC1Ev; std::ostringstream::basic_ostringstream(void)
mov r12, [rsp+1C8h+var_1C8]
mov r13, [rsp+1C8h+var_1C8+8]
cmp r12, r13
jz short loc_59F1C
lea rbp, aExampleToolCal+1Dh; ""
lea rbx, aZuD+6; ", "
lea r14, [rsp+1C8h+var_1A8]
loc_59EB4:
mov r15, [r12]
test r15, r15
jz short loc_59ED5
mov rdi, r15
call _strlen
mov rdi, r14
mov rsi, r15
mov rdx, rax
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
jmp short loc_59EF1
loc_59ED5:
mov rax, [rsp+1C8h+var_1A8]
mov rax, [rax-18h]
lea rdi, [rsp+rax+1C8h+var_1C8]
add rdi, 20h ; ' '
mov esi, [rdi+20h]
or esi, 1
call __ZNSt9basic_iosIcSt11char_traitsIcEE5clearESt12_Ios_Iostate; std::ios::clear(std::_Ios_Iostate)
loc_59EF1:
mov rax, [rsp+1C8h+var_1C8+8]
add rax, 0FFFFFFFFFFFFFFF8h
xor edx, edx
cmp r12, rax
setnz dl
mov rsi, rbx
cmovz rsi, rbp
add edx, edx
mov rdi, r14
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
add r12, 8
cmp r12, r13
jnz short loc_59EB4
loc_59F1C:
lea rsi, [rsp+1C8h+var_1A0]
mov rdi, [rsp+1C8h+var_1B0]
call __ZNKSt7__cxx1115basic_stringbufIcSt11char_traitsIcESaIcEE3strEv; std::stringbuf::str(void)
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+1C8h+var_1A8]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+1C8h+var_138]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
mov rdi, [rsp+1C8h+var_1C8]; void *
test rdi, rdi
jz short loc_59F5F
mov rsi, [rsp+1C8h+var_1B8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_59F5F:
add rsp, 198h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
jmp short loc_59F7A
jmp short $+2
loc_59F75:
mov rbx, rax
jmp short loc_59F9B
loc_59F7A:
mov rbx, rax
mov rsi, cs:_ZTTNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEEE_ptr
lea rdi, [rsp+arg_18]
call __ZNSt7__cxx1119basic_ostringstreamIcSt11char_traitsIcESaIcEED2Ev; std::ostringstream::~ostringstream()
lea rdi, [rsp+arg_88]; this
call __ZNSt8ios_baseD2Ev; std::ios_base::~ios_base()
loc_59F9B:
mov rdi, [rsp+0]; void *
test rdi, rdi
jz short loc_59FB1
mov rsi, [rsp+arg_8]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_59FB1:
mov rdi, rbx
call __Unwind_Resume
|
void list_builtin_chat_templates[abi:cxx11](long long a1)
{
int v1; // eax
_QWORD *v2; // r12
_QWORD *i; // r13
long long v4; // r15
long long v5; // rax
char *v6; // rsi
void *v7[2]; // [rsp+0h] [rbp-1C8h] BYREF
long long v8; // [rsp+10h] [rbp-1B8h]
long long v9; // [rsp+18h] [rbp-1B0h]
long long v10; // [rsp+20h] [rbp-1A8h] BYREF
_BYTE v11[104]; // [rsp+28h] [rbp-1A0h] BYREF
_BYTE v12[312]; // [rsp+90h] [rbp-138h] BYREF
*(_OWORD *)v7 = 0LL;
v8 = 0LL;
v1 = llama_chat_builtin_templates(0LL, 0LL);
std::vector<char const*>::resize(v7, v1);
llama_chat_builtin_templates(v7[0], ((char *)v7[1] - (char *)v7[0]) >> 3);
v9 = a1;
std::ostringstream::basic_ostringstream(&v10);
v2 = v7[0];
for ( i = v7[1]; v2 != i; ++v2 )
{
v4 = *v2;
if ( *v2 )
{
v5 = strlen(*v2);
std::__ostream_insert<char,std::char_traits<char>>(&v10, v4, v5);
}
else
{
std::ios::clear(&v11[*(_QWORD *)(v10 - 24) - 8], *(_DWORD *)&v11[*(_QWORD *)(v10 - 24) + 24] | 1u);
}
v6 = ", ";
if ( v2 == (_QWORD *)((char *)v7[1] - 8) )
v6 = "";
std::__ostream_insert<char,std::char_traits<char>>(
&v10,
v6,
2 * (unsigned int)(v2 != (_QWORD *)((char *)v7[1] - 8)));
}
std::stringbuf::str(v9, v11);
std::ostringstream::~ostringstream(&v10, &`VTT for'std::ostringstream);
std::ios_base::~ios_base((std::ios_base *)v12);
if ( v7[0] )
operator delete(v7[0], v8 - (unsigned long long)v7[0]);
}
|
list_builtin_chat_templates[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x198
MOV RBX,RDI
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RSP],XMM0
MOV qword ptr [RSP + 0x10],0x0
LAB_00159e5b:
XOR EDI,EDI
XOR ESI,ESI
CALL 0x00121cd0
MOVSXD RSI,EAX
MOV RDI,RSP
CALL 0x0018f15a
MOV RDI,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
SUB RSI,RDI
SAR RSI,0x3
CALL 0x00121cd0
LAB_00159e84:
MOV qword ptr [RSP + 0x18],RBX
LEA RDI,[RSP + 0x20]
CALL 0x00122000
MOV R12,qword ptr [RSP]
MOV R13,qword ptr [RSP + 0x8]
CMP R12,R13
JZ 0x00159f1c
LEA RBP,[0x221490]
LEA RBX,[0x226821]
LEA R14,[RSP + 0x20]
LAB_00159eb4:
MOV R15,qword ptr [R12]
TEST R15,R15
JZ 0x00159ed5
MOV RDI,R15
CALL 0x00121660
LAB_00159ec5:
MOV RDI,R14
MOV RSI,R15
MOV RDX,RAX
CALL 0x00122060
JMP 0x00159ef1
LAB_00159ed5:
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + -0x18]
LEA RDI,[RSP + RAX*0x1]
ADD RDI,0x20
MOV ESI,dword ptr [RDI + 0x20]
OR ESI,0x1
CALL 0x00122290
LAB_00159ef1:
MOV RAX,qword ptr [RSP + 0x8]
ADD RAX,-0x8
XOR EDX,EDX
CMP R12,RAX
SETNZ DL
MOV RSI,RBX
CMOVZ RSI,RBP
ADD EDX,EDX
MOV RDI,R14
CALL 0x00122060
ADD R12,0x8
CMP R12,R13
JNZ 0x00159eb4
LAB_00159f1c:
LEA RSI,[RSP + 0x28]
LAB_00159f21:
MOV RDI,qword ptr [RSP + 0x18]
CALL 0x00121640
LAB_00159f2b:
MOV RSI,qword ptr [0x00264f50]
LEA RDI,[RSP + 0x20]
CALL 0x00121c70
LEA RDI,[RSP + 0x90]
CALL 0x00121c40
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x00159f5f
MOV RSI,qword ptr [RSP + 0x10]
SUB RSI,RDI
CALL 0x00121170
LAB_00159f5f:
ADD RSP,0x198
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* list_builtin_chat_templates[abi:cxx11]() */
void list_builtin_chat_templates_abi_cxx11_(void)
{
int8 *puVar1;
int iVar2;
size_t sVar3;
char *pcVar4;
int8 *puVar5;
int8 *local_1c8;
int8 *puStack_1c0;
long local_1b8;
long local_1a8 [4];
uint auStack_188 [20];
ios_base local_138 [264];
local_1c8 = (int8 *)0x0;
puStack_1c0 = (int8 *)0x0;
local_1b8 = 0;
/* try { // try from 00159e5b to 00159e83 has its CatchHandler @ 00159f75 */
iVar2 = llama_chat_builtin_templates(0,0);
std::vector<char_const*,std::allocator<char_const*>>::resize
((vector<char_const*,std::allocator<char_const*>> *)&local_1c8,(long)iVar2);
llama_chat_builtin_templates(local_1c8,(long)puStack_1c0 - (long)local_1c8 >> 3);
/* try { // try from 00159e84 to 00159e92 has its CatchHandler @ 00159f73 */
std::__cxx11::ostringstream::ostringstream((ostringstream *)local_1a8);
puVar1 = puStack_1c0;
if (local_1c8 != puStack_1c0) {
puVar5 = local_1c8;
do {
pcVar4 = (char *)*puVar5;
if (pcVar4 == (char *)0x0) {
std::ios::clear((long)local_1a8 + *(long *)(local_1a8[0] + -0x18),
*(uint *)((long)auStack_188 + *(long *)(local_1a8[0] + -0x18)) | 1);
}
else {
sVar3 = strlen(pcVar4);
/* try { // try from 00159ec5 to 00159f12 has its CatchHandler @ 00159f7a */
std::__ostream_insert<char,std::char_traits<char>>((ostream *)local_1a8,pcVar4,sVar3);
}
pcVar4 = ", ";
if (puVar5 == puStack_1c0 + -1) {
pcVar4 = "";
}
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)local_1a8,pcVar4,(ulong)((uint)(puVar5 != puStack_1c0 + -1) * 2));
puVar5 = puVar5 + 1;
} while (puVar5 != puVar1);
}
/* try { // try from 00159f21 to 00159f2a has its CatchHandler @ 00159f71 */
std::__cxx11::stringbuf::str();
std::__cxx11::ostringstream::~ostringstream((ostringstream *)local_1a8);
std::ios_base::~ios_base(local_138);
if (local_1c8 != (int8 *)0x0) {
operator_delete(local_1c8,local_1b8 - (long)local_1c8);
}
return;
}
|
|
7,711 |
my_mb_wc_utf16_quick
|
eloqsql/strings/ctype-utf16.h
|
static inline int
my_mb_wc_utf16_quick(my_wc_t *pwc, const uchar *s, const uchar *e)
{
if (s + 2 > e)
return MY_CS_TOOSMALL2;
/*
High bytes: 0xD[89AB] = B'110110??'
Low bytes: 0xD[CDEF] = B'110111??'
Surrogate mask: 0xFC = B'11111100'
*/
if (MY_UTF16_HIGH_HEAD(*s)) /* Surrogate head */
{
if (s + 4 > e)
return MY_CS_TOOSMALL4;
if (!MY_UTF16_LOW_HEAD(s[2])) /* Broken surrigate pair */
return MY_CS_ILSEQ;
*pwc= MY_UTF16_WC4(s[0], s[1], s[2], s[3]);
return 4;
}
if (MY_UTF16_LOW_HEAD(*s)) /* Low surrogate part without high part */
return MY_CS_ILSEQ;
*pwc= MY_UTF16_WC2(s[0], s[1]);
return 2;
}
|
O0
|
c
|
my_mb_wc_utf16_quick:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
cmpq -0x20(%rbp), %rax
jbe 0x6906a
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x69148
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0xfc, %eax
cmpl $0xd8, %eax
jne 0x69107
movq -0x18(%rbp), %rax
addq $0x4, %rax
cmpq -0x20(%rbp), %rax
jbe 0x6909b
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x69148
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
andl $0xfc, %eax
cmpl $0xdc, %eax
je 0x690bb
movl $0x0, -0x4(%rbp)
jmp 0x69148
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0x3, %eax
shll $0x12, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0xa, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
andl $0x3, %ecx
shll $0x8, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
addl %ecx, %eax
addl $0x10000, %eax # imm = 0x10000
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x4, -0x4(%rbp)
jmp 0x69148
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0xfc, %eax
cmpl $0xdc, %eax
jne 0x69123
movl $0x0, -0x4(%rbp)
jmp 0x69148
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
addl %ecx, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
|
my_mb_wc_utf16_quick_0:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
add rax, 2
cmp rax, [rbp+var_20]
jbe short loc_6906A
mov [rbp+var_4], 0FFFFFF9Ah
jmp loc_69148
loc_6906A:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
and eax, 0FCh
cmp eax, 0D8h
jnz loc_69107
mov rax, [rbp+var_18]
add rax, 4
cmp rax, [rbp+var_20]
jbe short loc_6909B
mov [rbp+var_4], 0FFFFFF98h
jmp loc_69148
loc_6909B:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
and eax, 0FCh
cmp eax, 0DCh
jz short loc_690BB
mov [rbp+var_4], 0
jmp loc_69148
loc_690BB:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
and eax, 3
shl eax, 12h
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
shl ecx, 0Ah
add eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+2]
and ecx, 3
shl ecx, 8
add eax, ecx
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+3]
add eax, ecx
add eax, 10000h
movsxd rcx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 4
jmp short loc_69148
loc_69107:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
and eax, 0FCh
cmp eax, 0DCh
jnz short loc_69123
mov [rbp+var_4], 0
jmp short loc_69148
loc_69123:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax]
shl eax, 8
mov rcx, [rbp+var_18]
movzx ecx, byte ptr [rcx+1]
add eax, ecx
movsxd rcx, eax
mov rax, [rbp+var_10]
mov [rax], rcx
mov [rbp+var_4], 2
loc_69148:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long my_mb_wc_utf16_quick_0(_QWORD *a1, unsigned __int8 *a2, unsigned long long a3)
{
if ( (unsigned long long)(a2 + 2) <= a3 )
{
if ( (*a2 & 0xFC) == 0xD8 )
{
if ( (unsigned long long)(a2 + 4) <= a3 )
{
if ( (a2[2] & 0xFC) == 0xDC )
{
*a1 = a2[3] + ((a2[2] & 3) << 8) + (a2[1] << 10) + ((*a2 & 3) << 18) + 0x10000;
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
else if ( (*a2 & 0xFC) == 0xDC )
{
return 0;
}
else
{
*a1 = a2[1] + (*a2 << 8);
return 2;
}
}
else
{
return (unsigned int)-102;
}
}
|
my_mb_wc_utf16_quick:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0016906a
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x00169148
LAB_0016906a:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
AND EAX,0xfc
CMP EAX,0xd8
JNZ 0x00169107
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x4
CMP RAX,qword ptr [RBP + -0x20]
JBE 0x0016909b
MOV dword ptr [RBP + -0x4],0xffffff98
JMP 0x00169148
LAB_0016909b:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX + 0x2]
AND EAX,0xfc
CMP EAX,0xdc
JZ 0x001690bb
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169148
LAB_001690bb:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
AND EAX,0x3
SHL EAX,0x12
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0xa
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x2]
AND ECX,0x3
SHL ECX,0x8
ADD EAX,ECX
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x3]
ADD EAX,ECX
ADD EAX,0x10000
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x4
JMP 0x00169148
LAB_00169107:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
AND EAX,0xfc
CMP EAX,0xdc
JNZ 0x00169123
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00169148
LAB_00169123:
MOV RAX,qword ptr [RBP + -0x18]
MOVZX EAX,byte ptr [RAX]
SHL EAX,0x8
MOV RCX,qword ptr [RBP + -0x18]
MOVZX ECX,byte ptr [RCX + 0x1]
ADD EAX,ECX
MOVSXD RCX,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x2
LAB_00169148:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int4 my_mb_wc_utf16_quick(long *param_1,byte *param_2,byte *param_3)
{
int4 local_c;
if (param_3 < param_2 + 2) {
local_c = 0xffffff9a;
}
else if ((*param_2 & 0xfc) == 0xd8) {
if (param_3 < param_2 + 4) {
local_c = 0xffffff98;
}
else if ((param_2[2] & 0xfc) == 0xdc) {
*param_1 = (long)(int)((*param_2 & 3) * 0x40000 + (uint)param_2[1] * 0x400 +
(param_2[2] & 3) * 0x100 + (uint)param_2[3] + 0x10000);
local_c = 4;
}
else {
local_c = 0;
}
}
else if ((*param_2 & 0xfc) == 0xdc) {
local_c = 0;
}
else {
*param_1 = (long)(int)((uint)*param_2 * 0x100 + (uint)param_2[1]);
local_c = 2;
}
return local_c;
}
|
|
7,712 |
pfs_memory_alloc_v1
|
eloqsql/storage/perfschema/pfs.cc
|
PSI_memory_key pfs_memory_alloc_v1(PSI_memory_key key, size_t size, PSI_thread **owner)
{
PFS_thread ** owner_thread= reinterpret_cast<PFS_thread**>(owner);
assert(owner_thread != NULL);
if (! flag_global_instrumentation)
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
PFS_memory_class *klass= find_memory_class(key);
if (klass == NULL)
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
if (! klass->m_enabled)
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
PFS_memory_stat *event_name_array;
PFS_memory_stat *stat;
uint index= klass->m_event_name_index;
PFS_memory_stat_delta delta_buffer;
PFS_memory_stat_delta *delta;
if (flag_thread_instrumentation && ! klass->is_global())
{
PFS_thread *pfs_thread= my_thread_get_THR_PFS();
if (unlikely(pfs_thread == NULL))
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
if (! pfs_thread->m_enabled)
{
*owner_thread= NULL;
return PSI_NOT_INSTRUMENTED;
}
/* Aggregate to MEMORY_SUMMARY_BY_THREAD_BY_EVENT_NAME */
event_name_array= pfs_thread->write_instr_class_memory_stats();
stat= & event_name_array[index];
delta= stat->count_alloc(size, &delta_buffer);
if (delta != NULL)
{
pfs_thread->carry_memory_stat_delta(delta, index);
}
/* Flag this memory as owned by the current thread. */
*owner_thread= pfs_thread;
}
else
{
/* Aggregate to MEMORY_SUMMARY_GLOBAL_BY_EVENT_NAME */
event_name_array= global_instr_class_memory_array;
stat= & event_name_array[index];
(void) stat->count_alloc(size, &delta_buffer);
*owner_thread= NULL;
}
return key;
}
|
O0
|
cpp
|
pfs_memory_alloc_v1:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x3c08ee(%rip), %rax # 0x40df80
testb $0x1, (%rax)
jne 0x4d6ae
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4d814
movl -0x8(%rbp), %edi
callq 0x3b540
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4d6d8
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4d814
movq -0x28(%rbp), %rax
testb $0x1, 0x4(%rax)
jne 0x4d6f9
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4d814
movq -0x28(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x3c(%rbp)
leaq 0x3c08b6(%rip), %rax # 0x40dfc0
testb $0x1, (%rax)
je 0x4d7d2
movq -0x28(%rbp), %rdi
callq 0x4e8f0
testb $0x1, %al
jne 0x4d7d2
callq 0x45700
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x4d756
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4d814
movq -0x70(%rbp), %rax
testb $0x1, 0x7e0(%rax)
jne 0x4d77a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x4d814
movq -0x70(%rbp), %rdi
callq 0x36a70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4e910
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x4d7c5
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x2efc0
movq -0x70(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4d80e
leaq 0x3bc6af(%rip), %rax # 0x409e88
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x3c(%rbp), %ecx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4e910
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
|
pfs_memory_alloc_v1:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov [rbp+var_20], rax
lea rax, flag_global_instrumentation
test byte ptr [rax], 1
jnz short loc_4D6AE
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_4D814
loc_4D6AE:
mov edi, [rbp+var_8]; unsigned int
call _Z17find_memory_classj; find_memory_class(uint)
mov [rbp+var_28], rax
cmp [rbp+var_28], 0
jnz short loc_4D6D8
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_4D814
loc_4D6D8:
mov rax, [rbp+var_28]
test byte ptr [rax+4], 1
jnz short loc_4D6F9
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_4D814
loc_4D6F9:
mov rax, [rbp+var_28]
mov eax, [rax+10h]
mov [rbp+var_3C], eax
lea rax, flag_thread_instrumentation
test byte ptr [rax], 1
jz loc_4D7D2
mov rdi, [rbp+var_28]; this
call _ZNK16PFS_memory_class9is_globalEv; PFS_memory_class::is_global(void)
test al, 1
jnz loc_4D7D2
call _ZL21my_thread_get_THR_PFSv; my_thread_get_THR_PFS(void)
mov [rbp+var_70], rax
cmp [rbp+var_70], 0
setz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_4D756
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_4D814
loc_4D756:
mov rax, [rbp+var_70]
test byte ptr [rax+7E0h], 1
jnz short loc_4D77A
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
mov [rbp+var_4], 0
jmp loc_4D814
loc_4D77A:
mov rdi, [rbp+var_70]; this
call _ZN20PFS_connection_slice30write_instr_class_memory_statsEv; PFS_connection_slice::write_instr_class_memory_stats(void)
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 48h ; 'H'
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]; this
mov rsi, [rbp+var_10]; unsigned __int64
lea rdx, [rbp+var_60]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat11count_allocEmP21PFS_memory_stat_delta; PFS_memory_stat::count_alloc(ulong,PFS_memory_stat_delta *)
mov [rbp+var_68], rax
cmp [rbp+var_68], 0
jz short loc_4D7C5
mov rdi, [rbp+var_70]; this
mov rsi, [rbp+var_68]; PFS_memory_stat_delta *
mov edx, [rbp+var_3C]; unsigned int
call _ZN10PFS_thread23carry_memory_stat_deltaEP21PFS_memory_stat_deltaj; PFS_thread::carry_memory_stat_delta(PFS_memory_stat_delta *,uint)
loc_4D7C5:
mov rcx, [rbp+var_70]
mov rax, [rbp+var_20]
mov [rax], rcx
jmp short loc_4D80E
loc_4D7D2:
lea rax, global_instr_class_memory_array
mov rax, [rax]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov ecx, [rbp+var_3C]
imul rcx, 48h ; 'H'
add rax, rcx
mov [rbp+var_38], rax
mov rdi, [rbp+var_38]; this
mov rsi, [rbp+var_10]; unsigned __int64
lea rdx, [rbp+var_60]; PFS_memory_stat_delta *
call _ZN15PFS_memory_stat11count_allocEmP21PFS_memory_stat_delta; PFS_memory_stat::count_alloc(ulong,PFS_memory_stat_delta *)
mov rax, [rbp+var_20]
mov qword ptr [rax], 0
loc_4D80E:
mov eax, [rbp+var_8]
mov [rbp+var_4], eax
loc_4D814:
mov eax, [rbp+var_4]
add rsp, 70h
pop rbp
retn
|
long long pfs_memory_alloc_v1(unsigned int a1, unsigned long long a2, PFS_connection_slice **a3)
{
PFS_connection_slice *THR_PFS; // [rsp+0h] [rbp-70h]
PFS_memory_stat_delta *v5; // [rsp+8h] [rbp-68h]
_BYTE v6[36]; // [rsp+10h] [rbp-60h] BYREF
unsigned int v7; // [rsp+34h] [rbp-3Ch]
PFS_memory_stat *v8; // [rsp+38h] [rbp-38h]
PFS_memory_stat *v9; // [rsp+40h] [rbp-30h]
PFS_memory_class *memory_class; // [rsp+48h] [rbp-28h]
PFS_connection_slice **v11; // [rsp+50h] [rbp-20h]
PFS_connection_slice **v12; // [rsp+58h] [rbp-18h]
unsigned long long v13; // [rsp+60h] [rbp-10h]
unsigned int v14; // [rsp+68h] [rbp-8h]
v14 = a1;
v13 = a2;
v12 = a3;
v11 = a3;
if ( (flag_global_instrumentation & 1) != 0 )
{
memory_class = (PFS_memory_class *)find_memory_class(v14);
if ( memory_class )
{
if ( (*((_BYTE *)memory_class + 4) & 1) != 0 )
{
v7 = *((_DWORD *)memory_class + 4);
if ( (flag_thread_instrumentation & 1) == 0 || (PFS_memory_class::is_global(memory_class) & 1) != 0 )
{
v9 = global_instr_class_memory_array;
v8 = (PFS_memory_stat *)((char *)global_instr_class_memory_array + 72 * v7);
PFS_memory_stat::count_alloc(v8, v13, (PFS_memory_stat_delta *)v6);
*v11 = 0LL;
}
else
{
THR_PFS = (PFS_connection_slice *)my_thread_get_THR_PFS();
if ( !THR_PFS )
{
*v11 = 0LL;
return 0;
}
if ( (*((_BYTE *)THR_PFS + 2016) & 1) == 0 )
{
*v11 = 0LL;
return 0;
}
v9 = (PFS_memory_stat *)PFS_connection_slice::write_instr_class_memory_stats(THR_PFS);
v8 = (PFS_memory_stat *)((char *)v9 + 72 * v7);
v5 = (PFS_memory_stat_delta *)PFS_memory_stat::count_alloc(v8, v13, (PFS_memory_stat_delta *)v6);
if ( v5 )
PFS_thread::carry_memory_stat_delta((PFS_account **)THR_PFS, v5, v7);
*v11 = THR_PFS;
}
return v14;
}
*v11 = 0LL;
return 0;
}
else
{
*v11 = 0LL;
return 0;
}
}
else
{
*v11 = 0LL;
return 0;
}
}
|
pfs_memory_alloc_v1:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[0x50df80]
TEST byte ptr [RAX],0x1
JNZ 0x0014d6ae
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d814
LAB_0014d6ae:
MOV EDI,dword ptr [RBP + -0x8]
CALL 0x0013b540
MOV qword ptr [RBP + -0x28],RAX
CMP qword ptr [RBP + -0x28],0x0
JNZ 0x0014d6d8
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d814
LAB_0014d6d8:
MOV RAX,qword ptr [RBP + -0x28]
TEST byte ptr [RAX + 0x4],0x1
JNZ 0x0014d6f9
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d814
LAB_0014d6f9:
MOV RAX,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x3c],EAX
LEA RAX,[0x50dfc0]
TEST byte ptr [RAX],0x1
JZ 0x0014d7d2
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x0014e8f0
TEST AL,0x1
JNZ 0x0014d7d2
CALL 0x00145700
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x70],0x0
SETZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0014d756
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d814
LAB_0014d756:
MOV RAX,qword ptr [RBP + -0x70]
TEST byte ptr [RAX + 0x7e0],0x1
JNZ 0x0014d77a
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0014d814
LAB_0014d77a:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x00136a70
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x60]
CALL 0x0014e910
MOV qword ptr [RBP + -0x68],RAX
CMP qword ptr [RBP + -0x68],0x0
JZ 0x0014d7c5
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RBP + -0x3c]
CALL 0x0012efc0
LAB_0014d7c5:
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
JMP 0x0014d80e
LAB_0014d7d2:
LEA RAX,[0x509e88]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x38]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x60]
CALL 0x0014e910
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],0x0
LAB_0014d80e:
MOV EAX,dword ptr [RBP + -0x8]
MOV dword ptr [RBP + -0x4],EAX
LAB_0014d814:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x70
POP RBP
RET
|
uint pfs_memory_alloc_v1(uint param_1,ulong param_2,int8 *param_3)
{
ulong uVar1;
PFS_connection_slice *this;
PFS_memory_stat_delta *pPVar2;
PFS_memory_stat_delta local_68 [36];
uint local_44;
PFS_memory_stat *local_40;
long local_38;
PFS_memory_class *local_30;
int8 *local_28;
int8 *local_20;
ulong local_18;
uint local_10;
if ((flag_global_instrumentation & 1) == 0) {
*param_3 = 0;
return 0;
}
local_28 = param_3;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
local_30 = (PFS_memory_class *)find_memory_class(param_1);
if (local_30 == (PFS_memory_class *)0x0) {
*local_28 = 0;
return 0;
}
if (((byte)local_30[4] & 1) == 0) {
*local_28 = 0;
return 0;
}
local_44 = *(uint *)(local_30 + 0x10);
if (((flag_thread_instrumentation & 1) == 0) ||
(uVar1 = PFS_memory_class::is_global(local_30), (uVar1 & 1) != 0)) {
local_38 = global_instr_class_memory_array;
local_40 = (PFS_memory_stat *)(global_instr_class_memory_array + (ulong)local_44 * 0x48);
PFS_memory_stat::count_alloc(local_40,local_18,local_68);
*local_28 = 0;
}
else {
this = (PFS_connection_slice *)my_thread_get_THR_PFS();
if (this == (PFS_connection_slice *)0x0) {
*local_28 = 0;
return 0;
}
if (((byte)this[0x7e0] & 1) == 0) {
*local_28 = 0;
return 0;
}
local_38 = PFS_connection_slice::write_instr_class_memory_stats(this);
local_40 = (PFS_memory_stat *)(local_38 + (ulong)local_44 * 0x48);
pPVar2 = (PFS_memory_stat_delta *)PFS_memory_stat::count_alloc(local_40,local_18,local_68);
if (pPVar2 != (PFS_memory_stat_delta *)0x0) {
PFS_thread::carry_memory_stat_delta((PFS_thread *)this,pPVar2,local_44);
}
*local_28 = this;
}
return local_10;
}
|
|
7,713 |
my_hash_sort_simple
|
eloqsql/strings/ctype-simple.c
|
void my_hash_sort_simple(CHARSET_INFO *cs,
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
register const uchar *sort_order=cs->sort_order;
const uchar *end;
uint16 space_weight= sort_order[' '];
/*
Remove all trailing characters that are equal to space.
We have to do this to be able to compare 'A ' and 'A' as identical.
If the key is long enough, cut the trailing spaces (0x20) using an
optimized function implemented in skip_trailing_spaces().
"len > 16" is just some heuristic here.
Calling skip_triling_space() for short values is not desirable,
because its initialization block may be more expensive than the
performance gained.
*/
end= len > 16 ? skip_trailing_space(key, len) : key + len;
/*
We removed all trailing characters that are binary equal to space 0x20.
Now remove all trailing characters that have weights equal to space.
Some 8bit simple collations may have such characters:
- cp1250_general_ci 0xA0 NO-BREAK SPACE == 0x20 SPACE
- cp1251_ukrainian_ci 0x60 GRAVE ACCENT == 0x20 SPACE
- koi8u_general_ci 0x60 GRAVE ACCENT == 0x20 SPACE
*/
for ( ; key < end ; )
{
if (sort_order[*--end] != space_weight)
{
end++;
break;
}
}
my_hash_sort_simple_nopad(cs, key, end - key, nr1, nr2);
}
|
O3
|
c
|
my_hash_sort_simple:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
movq 0x58(%rdi), %rax
leaq (%rsi,%rdx), %rdi
cmpq $0x11, %rdx
jb 0x3c389
cmpq $0x15, %rdx
jb 0x3c374
movq %rdi, %r10
andq $-0x4, %r10
cmpq %rsi, %r10
jbe 0x3c374
leaq 0x3(%rsi), %r9
andq $-0x4, %r9
movq %rdi, %rdx
movb -0x1(%rdi), %r11b
cmpq %r10, %rdi
jbe 0x3c3f4
leaq -0x1(%rdx), %rdi
cmpb $0x20, %r11b
je 0x3c358
jmp 0x3c377
movq %rdi, %rdx
movq %rdx, %rdi
cmpq %rsi, %rdx
jbe 0x3c389
leaq -0x1(%rdi), %rdx
cmpb $0x20, -0x1(%rdi)
je 0x3c377
movb 0x20(%rax), %r9b
movq %rdi, %r11
subq %rsi, %r11
movq %rdi, %rdx
movq %r11, %r10
cmpq %rsi, %rdi
jbe 0x3c3b0
leaq -0x1(%rdx), %rdi
movzbl -0x1(%rdx), %ebx
leaq -0x1(%r10), %r11
cmpb %r9b, (%rax,%rbx)
je 0x3c393
movq (%rcx), %rdi
movq (%r8), %r9
testq %r10, %r10
jle 0x3c3eb
movl %edi, %r10d
andl $0x3f, %r10d
addq %r9, %r10
movzbl (%rsi), %r11d
movzbl (%rax,%r11), %r11d
imulq %r10, %r11
movq %rdi, %r10
shlq $0x8, %r10
addq %r11, %r10
xorq %r10, %rdi
addq $0x3, %r9
incq %rsi
cmpq %rdx, %rsi
jb 0x3c3bb
movq %rdi, (%rcx)
movq %r9, (%r8)
popq %rbx
popq %rbp
retq
cmpb $0x20, %r11b
setne %dil
cmpq %r10, %r9
setae %r10b
orb %dil, %r10b
jne 0x3c377
movq %rdx, %rdi
movq %rdi, %rdx
cmpq %r9, %rdi
jbe 0x3c377
leaq -0x4(%rdx), %rdi
cmpl $0x20202020, -0x4(%rdx) # imm = 0x20202020
je 0x3c40f
jmp 0x3c377
|
my_hash_sort_simple:
push rbp
mov rbp, rsp
push rbx
mov rax, [rdi+58h]
lea rdi, [rsi+rdx]
cmp rdx, 11h
jb short loc_3C389
cmp rdx, 15h
jb short loc_3C374
mov r10, rdi
and r10, 0FFFFFFFFFFFFFFFCh
cmp r10, rsi
jbe short loc_3C374
lea r9, [rsi+3]
and r9, 0FFFFFFFFFFFFFFFCh
loc_3C358:
mov rdx, rdi
mov r11b, [rdi-1]
cmp rdi, r10
jbe loc_3C3F4
lea rdi, [rdx-1]
cmp r11b, 20h ; ' '
jz short loc_3C358
jmp short loc_3C377
loc_3C374:
mov rdx, rdi
loc_3C377:
mov rdi, rdx
cmp rdx, rsi
jbe short loc_3C389
lea rdx, [rdi-1]
cmp byte ptr [rdi-1], 20h ; ' '
jz short loc_3C377
loc_3C389:
mov r9b, [rax+20h]
mov r11, rdi
sub r11, rsi
loc_3C393:
mov rdx, rdi
mov r10, r11
cmp rdi, rsi
jbe short loc_3C3B0
lea rdi, [rdx-1]
movzx ebx, byte ptr [rdx-1]
lea r11, [r10-1]
cmp [rax+rbx], r9b
jz short loc_3C393
loc_3C3B0:
mov rdi, [rcx]
mov r9, [r8]
test r10, r10
jle short loc_3C3EB
loc_3C3BB:
mov r10d, edi
and r10d, 3Fh
add r10, r9
movzx r11d, byte ptr [rsi]
movzx r11d, byte ptr [rax+r11]
imul r11, r10
mov r10, rdi
shl r10, 8
add r10, r11
xor rdi, r10
add r9, 3
inc rsi
cmp rsi, rdx
jb short loc_3C3BB
loc_3C3EB:
mov [rcx], rdi
mov [r8], r9
pop rbx
pop rbp
retn
loc_3C3F4:
cmp r11b, 20h ; ' '
setnz dil
cmp r9, r10
setnb r10b
or r10b, dil
jnz loc_3C377
mov rdi, rdx
loc_3C40F:
mov rdx, rdi
cmp rdi, r9
jbe loc_3C377
lea rdi, [rdx-4]
cmp dword ptr [rdx-4], 20202020h
jz short loc_3C40F
jmp loc_3C377
|
long long my_hash_sort_simple(long long a1, unsigned __int8 *a2, unsigned long long a3, long long *a4, long long *a5)
{
long long result; // rax
unsigned long long v6; // rdi
unsigned long long v7; // r10
unsigned long long v8; // r9
unsigned __int8 *v9; // rdx
char v10; // r11
long long v11; // r11
unsigned long long v12; // rdx
long long v13; // r10
long long v14; // rdi
long long v15; // r9
result = *(_QWORD *)(a1 + 88);
v6 = (unsigned long long)&a2[a3];
if ( a3 >= 0x11 )
{
if ( a3 < 0x15 || (v7 = v6 & 0xFFFFFFFFFFFFFFFCLL, (v6 & 0xFFFFFFFFFFFFFFFCLL) <= (unsigned long long)a2) )
{
v9 = &a2[a3];
}
else
{
v8 = (unsigned long long)(a2 + 3) & 0xFFFFFFFFFFFFFFFCLL;
while ( 1 )
{
v9 = (unsigned __int8 *)v6;
v10 = *(_BYTE *)(v6 - 1);
if ( v6 <= v7 )
break;
--v6;
if ( v10 != 32 )
goto LABEL_9;
}
if ( v10 == 32 && v8 < v7 )
{
do
{
v9 = (unsigned __int8 *)v6;
if ( v6 <= v8 )
break;
v6 -= 4LL;
}
while ( *((_DWORD *)v9 - 1) == 538976288 );
}
}
do
{
LABEL_9:
v6 = (unsigned long long)v9;
if ( v9 <= a2 )
break;
--v9;
}
while ( *(_BYTE *)(v6 - 1) == 32 );
}
v11 = v6 - (_QWORD)a2;
do
{
v12 = v6;
v13 = v11;
if ( v6 <= (unsigned long long)a2 )
break;
--v6;
--v11;
}
while ( *(_BYTE *)(result + *(unsigned __int8 *)(v12 - 1)) == *(_BYTE *)(result + 32) );
v14 = *a4;
v15 = *a5;
if ( v13 > 0 )
{
do
{
v14 ^= (v15 + (v14 & 0x3F)) * *(unsigned __int8 *)(result + *a2) + (v14 << 8);
v15 += 3LL;
++a2;
}
while ( (unsigned long long)a2 < v12 );
}
*a4 = v14;
*a5 = v15;
return result;
}
|
my_hash_sort_simple:
PUSH RBP
MOV RBP,RSP
PUSH RBX
MOV RAX,qword ptr [RDI + 0x58]
LEA RDI,[RSI + RDX*0x1]
CMP RDX,0x11
JC 0x0013c389
CMP RDX,0x15
JC 0x0013c374
MOV R10,RDI
AND R10,-0x4
CMP R10,RSI
JBE 0x0013c374
LEA R9,[RSI + 0x3]
AND R9,-0x4
LAB_0013c358:
MOV RDX,RDI
MOV R11B,byte ptr [RDI + -0x1]
CMP RDI,R10
JBE 0x0013c3f4
LEA RDI,[RDX + -0x1]
CMP R11B,0x20
JZ 0x0013c358
JMP 0x0013c377
LAB_0013c374:
MOV RDX,RDI
LAB_0013c377:
MOV RDI,RDX
CMP RDX,RSI
JBE 0x0013c389
LEA RDX,[RDI + -0x1]
CMP byte ptr [RDI + -0x1],0x20
JZ 0x0013c377
LAB_0013c389:
MOV R9B,byte ptr [RAX + 0x20]
MOV R11,RDI
SUB R11,RSI
LAB_0013c393:
MOV RDX,RDI
MOV R10,R11
CMP RDI,RSI
JBE 0x0013c3b0
LEA RDI,[RDX + -0x1]
MOVZX EBX,byte ptr [RDX + -0x1]
LEA R11,[R10 + -0x1]
CMP byte ptr [RAX + RBX*0x1],R9B
JZ 0x0013c393
LAB_0013c3b0:
MOV RDI,qword ptr [RCX]
MOV R9,qword ptr [R8]
TEST R10,R10
JLE 0x0013c3eb
LAB_0013c3bb:
MOV R10D,EDI
AND R10D,0x3f
ADD R10,R9
MOVZX R11D,byte ptr [RSI]
MOVZX R11D,byte ptr [RAX + R11*0x1]
IMUL R11,R10
MOV R10,RDI
SHL R10,0x8
ADD R10,R11
XOR RDI,R10
ADD R9,0x3
INC RSI
CMP RSI,RDX
JC 0x0013c3bb
LAB_0013c3eb:
MOV qword ptr [RCX],RDI
MOV qword ptr [R8],R9
POP RBX
POP RBP
RET
LAB_0013c3f4:
CMP R11B,0x20
SETNZ DIL
CMP R9,R10
SETNC R10B
OR R10B,DIL
JNZ 0x0013c377
MOV RDI,RDX
LAB_0013c40f:
MOV RDX,RDI
CMP RDI,R9
JBE 0x0013c377
LEA RDI,[RDX + -0x4]
CMP dword ptr [RDX + -0x4],0x20202020
JZ 0x0013c40f
JMP 0x0013c377
|
void my_hash_sort_simple(long param_1,byte *param_2,ulong param_3,ulong *param_4,long *param_5)
{
byte *pbVar1;
long lVar2;
byte *pbVar3;
ulong uVar4;
byte *pbVar5;
long lVar6;
byte *pbVar7;
long lVar8;
lVar2 = *(long *)(param_1 + 0x58);
pbVar5 = param_2 + param_3;
if (param_3 < 0x11) goto LAB_0013c389;
pbVar3 = pbVar5;
if ((0x14 < param_3) && (pbVar7 = (byte *)((ulong)pbVar5 & 0xfffffffffffffffc), param_2 < pbVar7))
{
do {
pbVar1 = pbVar5 + -1;
pbVar3 = pbVar5;
if (pbVar5 <= pbVar7) {
if ((byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc) < pbVar7 && *pbVar1 == 0x20)
goto LAB_0013c40f;
break;
}
pbVar5 = pbVar5 + -1;
} while (*pbVar1 == 0x20);
}
goto LAB_0013c377;
while (pbVar7 = pbVar5 + -4, pbVar5 = pbVar5 + -4, *(int *)pbVar7 == 0x20202020) {
LAB_0013c40f:
pbVar3 = pbVar5;
if (pbVar5 <= (byte *)((ulong)(param_2 + 3) & 0xfffffffffffffffc)) break;
}
LAB_0013c377:
do {
pbVar5 = pbVar3;
if (pbVar5 <= param_2) break;
pbVar3 = pbVar5 + -1;
} while (pbVar5[-1] == 0x20);
LAB_0013c389:
lVar6 = (long)pbVar5 - (long)param_2;
do {
lVar8 = lVar6;
pbVar3 = pbVar5;
if (pbVar3 <= param_2) break;
pbVar5 = pbVar3 + -1;
lVar6 = lVar8 + -1;
} while (*(char *)(lVar2 + (ulong)pbVar3[-1]) == *(char *)(lVar2 + 0x20));
uVar4 = *param_4;
lVar6 = *param_5;
if (0 < lVar8) {
do {
uVar4 = uVar4 ^ uVar4 * 0x100 +
(ulong)*(byte *)(lVar2 + (ulong)*param_2) *
((ulong)((uint)uVar4 & 0x3f) + lVar6);
lVar6 = lVar6 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar3);
}
*param_4 = uVar4;
*param_5 = lVar6;
return;
}
|
|
7,714 |
ftxui::bold(std::shared_ptr<ftxui::Node>)
|
Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/dom/bold.cpp
|
Element bold(Element child) {
return std::make_shared<Bold>(std::move(child));
}
|
O3
|
cpp
|
ftxui::bold(std::shared_ptr<ftxui::Node>):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl $0x70, %edi
callq 0xb3e0
movq %rax, %rbx
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x21301(%rip), %rax # 0x58778
movq %rax, (%rbx)
movq %rbx, %r15
addq $0x10, %r15
movups (%r12), %xmm0
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rax, (%r12)
movq %r15, %rdi
callq 0x22fbc
leaq 0x21322(%rip), %rax # 0x587c8
movq %rax, (%r15)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x374b8
callq 0x14af8
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x374e0
callq 0x14af8
movl $0x70, %esi
movq %rbx, %rdi
callq 0xb400
movq %r14, %rdi
callq 0xb780
nop
|
_ZN5ftxui4boldESt10shared_ptrINS_4NodeEE:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov r12, rsi
mov r14, rdi
mov edi, 70h ; 'p'; unsigned __int64
call __Znwm; operator new(ulong)
mov rbx, rax
mov rax, 100000001h
mov [rbx+8], rax
lea rax, off_58778
mov [rbx], rax
mov r15, rbx
add r15, 10h
movups xmm0, xmmword ptr [r12]
xor eax, eax
mov [r12+8], rax
mov rsi, rsp
movaps xmmword ptr [rsi], xmm0
mov [r12], rax
mov rdi, r15
call _ZN5ftxui13NodeDecoratorC2ESt10shared_ptrINS_4NodeEE; ftxui::NodeDecorator::NodeDecorator(std::shared_ptr<ftxui::Node>)
lea rax, off_587C8
mov [r15], rax
mov rdi, [rsp+38h+var_30]
test rdi, rdi
jz short loc_374B8
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_374B8:
mov [r14], r15
mov [r14+8], rbx
mov rax, r14
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_374E0
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_374E0:
mov esi, 70h ; 'p'; unsigned __int64
mov rdi, rbx; void *
call __ZdlPvm; operator delete(void *,ulong)
mov rdi, r14
call __Unwind_Resume
|
_QWORD * ftxui::bold(_QWORD *a1, long long a2)
{
_QWORD *v2; // rbx
__int128 v3; // xmm0
__int128 v5; // [rsp+0h] [rbp-38h] BYREF
v2 = (_QWORD *)operator new(0x70uLL);
v2[1] = 0x100000001LL;
*v2 = off_58778;
v3 = *(_OWORD *)a2;
*(_QWORD *)(a2 + 8) = 0LL;
v5 = v3;
*(_QWORD *)a2 = 0LL;
ftxui::NodeDecorator::NodeDecorator(v2 + 2, &v5);
v2[2] = off_587C8;
if ( *((_QWORD *)&v5 + 1) )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(*((volatile signed __int32 **)&v5 + 1));
*a1 = v2 + 2;
a1[1] = v2;
return a1;
}
|
bold:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R12,RSI
MOV R14,RDI
MOV EDI,0x70
CALL 0x0010b3e0
MOV RBX,RAX
MOV RAX,0x100000001
MOV qword ptr [RBX + 0x8],RAX
LEA RAX,[0x158778]
MOV qword ptr [RBX],RAX
MOV R15,RBX
ADD R15,0x10
MOVUPS XMM0,xmmword ptr [R12]
XOR EAX,EAX
MOV qword ptr [R12 + 0x8],RAX
MOV RSI,RSP
MOVAPS xmmword ptr [RSI],XMM0
MOV qword ptr [R12],RAX
LAB_00137497:
MOV RDI,R15
CALL 0x00122fbc
LAB_0013749f:
LEA RAX,[0x1587c8]
MOV qword ptr [R15],RAX
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x001374b8
CALL 0x00114af8
LAB_001374b8:
MOV qword ptr [R14],R15
MOV qword ptr [R14 + 0x8],RBX
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* ftxui::bold(std::shared_ptr<ftxui::Node>) */
ftxui * __thiscall ftxui::bold(ftxui *this,int8 *param_2)
{
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *this_00;
int8 *puVar1;
NodeDecorator *pNVar2;
puVar1 = (int8 *)operator_new(0x70);
puVar1[1] = 0x100000001;
*puVar1 = &PTR___Sp_counted_ptr_inplace_00158778;
pNVar2 = (NodeDecorator *)(puVar1 + 2);
this_00 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
/* try { // try from 00137497 to 0013749e has its CatchHandler @ 001374ce */
NodeDecorator::NodeDecorator(pNVar2);
*(int ***)pNVar2 = &PTR__Node_001587c8;
if (this_00 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(this_00);
}
*(NodeDecorator **)this = pNVar2;
*(int8 **)(this + 8) = puVar1;
return this;
}
|
|
7,715 |
lemonOutput[abi:cxx11]()
|
mihussein[P]Hlemon/src/lemonOutput.cpp
|
std::string lemonOutput() {
std::string separator = "%{F#777777}|%{F-}";
/*std::cout <<*/
/* "%{l} "*/
/* << Workspaces::getWorkspaces() << separator << " "*/
/* << Workspaces::getWindows()*/
/* << "%{r}"*/
/* << Volume::getVolume() << separator*/
/* << Mic::getMicVolume() << separator*/
/* << Brightness::getBrightness() << separator*/
/* << Battery::getBattery() << separator*/
/* << getClock()*/
/* << " " << std::endl;*/
return
"%{l} "
+ Workspaces::getWorkspaces()
+ Workspaces::getWindows()
+ "%{r}"
+ Volume::getVolume() + separator
+ Mic::getMicVolume() + separator
+ Brightness::getBrightness() + separator
+ Battery::getBattery() + separator
+ getClock()
+ " ";
}
|
O2
|
cpp
|
lemonOutput[abi:cxx11]():
pushq %rbx
subq $0x280, %rsp # imm = 0x280
movq %rdi, %rbx
leaq 0x3305(%rip), %rsi # 0x940f
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x593c
leaq 0x100(%rsp), %rdi
callq 0x76c4
leaq 0x32f6(%rip), %rsi # 0x9421
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rdx
callq 0x656b
leaq 0xe0(%rsp), %rdi
callq 0x75be
leaq 0x140(%rsp), %rdi
leaq 0x120(%rsp), %rsi
leaq 0xe0(%rsp), %rdx
callq 0x59e5
leaq 0x32b6(%rip), %rdx # 0x9427
leaq 0x160(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x59c6
leaq 0xc0(%rsp), %rdi
callq 0x84bc
leaq 0x180(%rsp), %rdi
leaq 0x160(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x59e5
leaq 0x1a0(%rsp), %rdi
leaq 0x180(%rsp), %rsi
movq %rsp, %rdx
callq 0x654c
leaq 0xa0(%rsp), %rdi
callq 0x8a22
leaq 0x1c0(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x59e5
leaq 0x1e0(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
movq %rsp, %rdx
callq 0x654c
leaq 0x80(%rsp), %rdi
callq 0x6856
leaq 0x200(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x59e5
leaq 0x220(%rsp), %rdi
leaq 0x200(%rsp), %rsi
movq %rsp, %rdx
callq 0x654c
leaq 0x60(%rsp), %rdi
callq 0x5600
leaq 0x240(%rsp), %rdi
leaq 0x220(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x59e5
leaq 0x260(%rsp), %rdi
leaq 0x240(%rsp), %rsi
movq %rsp, %rdx
callq 0x654c
leaq 0x40(%rsp), %rdi
callq 0x7ec4
leaq 0x20(%rsp), %rdi
leaq 0x260(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x59e5
leaq 0x2fa2(%rip), %rdx # 0x9252
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x59c6
leaq 0x20(%rsp), %rdi
callq 0x46e8
leaq 0x40(%rsp), %rdi
callq 0x46e8
leaq 0x260(%rsp), %rdi
callq 0x46e8
leaq 0x240(%rsp), %rdi
callq 0x46e8
leaq 0x60(%rsp), %rdi
callq 0x46e8
leaq 0x220(%rsp), %rdi
callq 0x46e8
leaq 0x200(%rsp), %rdi
callq 0x46e8
leaq 0x80(%rsp), %rdi
callq 0x46e8
leaq 0x1e0(%rsp), %rdi
callq 0x46e8
leaq 0x1c0(%rsp), %rdi
callq 0x46e8
leaq 0xa0(%rsp), %rdi
callq 0x46e8
leaq 0x1a0(%rsp), %rdi
callq 0x46e8
leaq 0x180(%rsp), %rdi
callq 0x46e8
leaq 0xc0(%rsp), %rdi
callq 0x46e8
leaq 0x160(%rsp), %rdi
callq 0x46e8
leaq 0x140(%rsp), %rdi
callq 0x46e8
leaq 0xe0(%rsp), %rdi
callq 0x46e8
leaq 0x120(%rsp), %rdi
callq 0x46e8
leaq 0x100(%rsp), %rdi
callq 0x46e8
movq %rsp, %rdi
callq 0x46e8
movq %rbx, %rax
addq $0x280, %rsp # imm = 0x280
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x46e8
jmp 0x63d1
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x46e8
jmp 0x63e0
movq %rax, %rbx
leaq 0x260(%rsp), %rdi
callq 0x46e8
jmp 0x63f2
movq %rax, %rbx
leaq 0x240(%rsp), %rdi
callq 0x46e8
jmp 0x6404
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x46e8
leaq 0x220(%rsp), %rdi
callq 0x46e8
leaq 0x200(%rsp), %rdi
callq 0x46e8
leaq 0x80(%rsp), %rdi
callq 0x46e8
leaq 0x1e0(%rsp), %rdi
callq 0x46e8
leaq 0x1c0(%rsp), %rdi
callq 0x46e8
leaq 0xa0(%rsp), %rdi
callq 0x46e8
leaq 0x1a0(%rsp), %rdi
callq 0x46e8
leaq 0x180(%rsp), %rdi
callq 0x46e8
leaq 0xc0(%rsp), %rdi
callq 0x46e8
leaq 0x160(%rsp), %rdi
callq 0x46e8
leaq 0x140(%rsp), %rdi
callq 0x46e8
leaq 0xe0(%rsp), %rdi
callq 0x46e8
leaq 0x120(%rsp), %rdi
callq 0x46e8
leaq 0x100(%rsp), %rdi
callq 0x46e8
movq %rsp, %rdi
callq 0x46e8
movq %rbx, %rdi
callq 0x4630
movq %rax, %rbx
jmp 0x640e
movq %rax, %rbx
jmp 0x641b
movq %rax, %rbx
jmp 0x6428
movq %rax, %rbx
jmp 0x6435
movq %rax, %rbx
jmp 0x6442
movq %rax, %rbx
jmp 0x644f
movq %rax, %rbx
jmp 0x645c
movq %rax, %rbx
jmp 0x6469
movq %rax, %rbx
jmp 0x6476
movq %rax, %rbx
jmp 0x6483
movq %rax, %rbx
jmp 0x6490
movq %rax, %rbx
jmp 0x649d
movq %rax, %rbx
jmp 0x64aa
movq %rax, %rbx
jmp 0x64b7
movq %rax, %rbx
jmp 0x64c4
|
_Z11lemonOutputB5cxx11v:
push rbx
sub rsp, 280h
mov rbx, rdi
lea rsi, aF777777F; "%{F#777777}|%{F-}"
mov rdi, rsp
lea rdx, [rsp+288h+var_268]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+288h+var_188]
call _ZN10Workspaces13getWorkspacesB5cxx11Ev; Workspaces::getWorkspaces(void)
lea rsi, asc_9421; "%{l} "
lea rdi, [rsp+288h+var_168]
lea rdx, [rsp+288h+var_188]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
lea rdi, [rsp+288h+var_1A8]
call _ZN10Workspaces10getWindowsB5cxx11Ev; Workspaces::getWindows(void)
lea rdi, [rsp+288h+var_148]
lea rsi, [rsp+288h+var_168]
lea rdx, [rsp+288h+var_1A8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, aR; "%{r}"
lea rdi, [rsp+288h+var_128]
lea rsi, [rsp+288h+var_148]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+288h+var_1C8]
call _ZN6Volume9getVolumeB5cxx11Ev; Volume::getVolume(void)
lea rdi, [rsp+288h+var_108]
lea rsi, [rsp+288h+var_128]
lea rdx, [rsp+288h+var_1C8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+288h+var_E8]
lea rsi, [rsp+288h+var_108]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdi, [rsp+288h+var_1E8]
call _ZN3Mic12getMicVolumeB5cxx11Ev; Mic::getMicVolume(void)
lea rdi, [rsp+288h+var_C8]
lea rsi, [rsp+288h+var_E8]
lea rdx, [rsp+288h+var_1E8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+288h+var_A8]
lea rsi, [rsp+288h+var_C8]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdi, [rsp+288h+var_208]
call _ZN10Brightness13getBrightnessB5cxx11Ev; Brightness::getBrightness(void)
lea rdi, [rsp+288h+var_88]
lea rsi, [rsp+288h+var_A8]
lea rdx, [rsp+288h+var_208]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+288h+var_68]
lea rsi, [rsp+288h+var_88]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdi, [rsp+288h+var_228]
call _ZN7Battery10getBatteryB5cxx11Ev; Battery::getBattery(void)
lea rdi, [rsp+288h+var_48]
lea rsi, [rsp+288h+var_68]
lea rdx, [rsp+288h+var_228]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdi, [rsp+288h+var_28]
lea rsi, [rsp+288h+var_48]
mov rdx, rsp
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
lea rdi, [rsp+288h+var_248]
call _Z8getClockB5cxx11v; getClock(void)
lea rdi, [rsp+288h+var_268]
lea rsi, [rsp+288h+var_28]
lea rdx, [rsp+288h+var_248]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
lea rdx, asc_9251+1; " "
lea rsi, [rsp+288h+var_268]
mov rdi, rbx
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+288h+var_268]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_248]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_228]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_88]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_208]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_1E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_E8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_1C8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_148]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_1A8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_168]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+288h+var_188]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, rbx
add rsp, 280h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_18]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_63D1
mov rbx, rax
loc_63D1:
lea rdi, [rsp+arg_38]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_63E0
mov rbx, rax
loc_63E0:
lea rdi, [rsp+arg_258]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_63F2
mov rbx, rax
loc_63F2:
lea rdi, [rsp+arg_238]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_6404
mov rbx, rax
loc_6404:
lea rdi, [rsp+arg_58]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_640E:
lea rdi, [rsp+arg_218]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_641B:
lea rdi, [rsp+arg_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6428:
lea rdi, [rsp+arg_78]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6435:
lea rdi, [rsp+arg_1D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6442:
lea rdi, [rsp+arg_1B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_644F:
lea rdi, [rsp+arg_98]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_645C:
lea rdi, [rsp+arg_198]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6469:
lea rdi, [rsp+arg_178]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6476:
lea rdi, [rsp+arg_B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6483:
lea rdi, [rsp+arg_158]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_6490:
lea rdi, [rsp+arg_138]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_649D:
lea rdi, [rsp+arg_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_64AA:
lea rdi, [rsp+arg_118]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_64B7:
lea rdi, [rsp+arg_F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_64C4:
mov rdi, rsp; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, rbx
call __Unwind_Resume
mov rbx, rax
jmp loc_640E
mov rbx, rax
jmp loc_641B
mov rbx, rax
jmp loc_6428
mov rbx, rax
jmp loc_6435
mov rbx, rax
jmp loc_6442
mov rbx, rax
jmp loc_644F
mov rbx, rax
jmp loc_645C
mov rbx, rax
jmp loc_6469
mov rbx, rax
jmp loc_6476
mov rbx, rax
jmp loc_6483
mov rbx, rax
jmp loc_6490
mov rbx, rax
jmp loc_649D
mov rbx, rax
jmp loc_64AA
mov rbx, rax
jmp loc_64B7
mov rbx, rax
jmp loc_64C4
|
long long lemonOutput[abi:cxx11](long long a1)
{
int v1; // edx
int v2; // ecx
int v3; // r8d
int v4; // r9d
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
int v9; // edx
int v10; // ecx
int v11; // r8d
int v12; // r9d
int v13; // edx
int v14; // ecx
int v15; // r8d
int v16; // r9d
int v17; // edx
int v18; // ecx
int v19; // r8d
int v20; // r9d
int v21; // edx
int v22; // ecx
int v23; // r8d
int v24; // r9d
long long v26; // [rsp+0h] [rbp-288h] BYREF
int v27; // [rsp+8h] [rbp-280h]
int v28; // [rsp+10h] [rbp-278h]
int v29; // [rsp+18h] [rbp-270h]
int v30; // [rsp+20h] [rbp-268h] BYREF
int v31; // [rsp+28h] [rbp-260h]
int v32; // [rsp+30h] [rbp-258h]
int v33; // [rsp+38h] [rbp-250h]
long long v34; // [rsp+40h] [rbp-248h] BYREF
int v35; // [rsp+48h] [rbp-240h]
int v36; // [rsp+50h] [rbp-238h]
int v37; // [rsp+58h] [rbp-230h]
long long v38; // [rsp+60h] [rbp-228h] BYREF
int v39; // [rsp+68h] [rbp-220h]
int v40; // [rsp+70h] [rbp-218h]
int v41; // [rsp+78h] [rbp-210h]
long long v42; // [rsp+80h] [rbp-208h] BYREF
int v43; // [rsp+88h] [rbp-200h]
int v44; // [rsp+90h] [rbp-1F8h]
int v45; // [rsp+98h] [rbp-1F0h]
long long v46; // [rsp+A0h] [rbp-1E8h] BYREF
int v47; // [rsp+A8h] [rbp-1E0h]
int v48; // [rsp+B0h] [rbp-1D8h]
int v49; // [rsp+B8h] [rbp-1D0h]
_QWORD v50[4]; // [rsp+C0h] [rbp-1C8h] BYREF
_QWORD v51[4]; // [rsp+E0h] [rbp-1A8h] BYREF
_BYTE v52[32]; // [rsp+100h] [rbp-188h] BYREF
_QWORD v53[4]; // [rsp+120h] [rbp-168h] BYREF
_BYTE v54[32]; // [rsp+140h] [rbp-148h] BYREF
_QWORD v55[4]; // [rsp+160h] [rbp-128h] BYREF
_BYTE v56[32]; // [rsp+180h] [rbp-108h] BYREF
_QWORD v57[4]; // [rsp+1A0h] [rbp-E8h] BYREF
_BYTE v58[32]; // [rsp+1C0h] [rbp-C8h] BYREF
_QWORD v59[4]; // [rsp+1E0h] [rbp-A8h] BYREF
_BYTE v60[32]; // [rsp+200h] [rbp-88h] BYREF
_QWORD v61[4]; // [rsp+220h] [rbp-68h] BYREF
_BYTE v62[32]; // [rsp+240h] [rbp-48h] BYREF
_QWORD v63[5]; // [rsp+260h] [rbp-28h] BYREF
std::string::basic_string<std::allocator<char>>(&v26, (long long)"%{F#777777}|%{F-}");
Workspaces::getWorkspaces[abi:cxx11](
(unsigned int)v52,
(unsigned int)"%{F#777777}|%{F-}",
v1,
v2,
v3,
v4,
v26,
v27,
v28,
v29,
v30);
std::operator+<char>(v53, "%{l} ", v52);
Workspaces::getWindows[abi:cxx11]((unsigned int)v51, (unsigned int)"%{l} ", v5, v6, v7, v8, v26, v27, v28, v29);
std::operator+<char>((long long)v54, v53, v51);
std::operator+<char>((long long)v55, (long long)v54, "%{r}");
Volume::getVolume[abi:cxx11](
(unsigned int)v50,
(unsigned int)v54,
v9,
v10,
v11,
v12,
v26,
v27,
v28,
v29,
v30,
v31,
v32,
v33,
v34,
v35,
v36,
v37,
v38,
v39,
v40,
v41,
v42,
v43,
v44,
v45,
v46);
std::operator+<char>((long long)v56, v55, v50);
std::operator+<char>(v57, v56, &v26);
Mic::getMicVolume[abi:cxx11](
(unsigned int)&v46,
(unsigned int)v56,
v13,
v14,
v15,
v16,
v26,
v27,
v28,
v29,
v30,
v31,
v32,
v33,
v34,
v35,
v36,
v37,
v38,
v39,
v40,
v41,
v42,
v43,
v44,
v45,
v46,
v47,
v48,
v49,
v50[0]);
std::operator+<char>((long long)v58, v57, &v46);
std::operator+<char>(v59, v58, &v26);
Brightness::getBrightness[abi:cxx11](
(unsigned int)&v42,
(unsigned int)v58,
v17,
v18,
v19,
v20,
v26,
v27,
v28,
v29,
v30,
v31,
v32,
v33,
v34,
v35,
v36,
v37,
v38,
v39,
v40,
v41,
v42,
v43,
v44,
v45,
v46);
std::operator+<char>((long long)v60, v59, &v42);
std::operator+<char>(v61, v60, &v26);
Battery::getBattery[abi:cxx11]((long long)&v38);
std::operator+<char>((long long)v62, v61, &v38);
std::operator+<char>(v63, v62, &v26);
getClock[abi:cxx11](
(unsigned int)&v34,
(unsigned int)v62,
v21,
v22,
v23,
v24,
v26,
v27,
v28,
v29,
v30,
v31,
v32,
v33,
v34);
std::operator+<char>((long long)&v30, v63, &v34);
std::operator+<char>(a1, (long long)&v30, " ");
std::string::~string(&v30);
std::string::~string(&v34);
std::string::~string(v63);
std::string::~string(v62);
std::string::~string(&v38);
std::string::~string(v61);
std::string::~string(v60);
std::string::~string(&v42);
std::string::~string(v59);
std::string::~string(v58);
std::string::~string(&v46);
std::string::~string(v57);
std::string::~string(v56);
std::string::~string(v50);
std::string::~string(v55);
std::string::~string(v54);
std::string::~string(v51);
std::string::~string(v53);
std::string::~string(v52);
std::string::~string(&v26);
return a1;
}
|
lemonOutput[abi:cxx11]:
PUSH RBX
SUB RSP,0x280
MOV RBX,RDI
LEA RSI,[0x10940f]
MOV RDI,RSP
LEA RDX,[RSP + 0x20]
CALL 0x0010593c
LAB_00106117:
LEA RDI,[RSP + 0x100]
CALL 0x001076c4
LAB_00106124:
LEA RSI,[0x109421]
LEA RDI,[RSP + 0x120]
LEA RDX,[RSP + 0x100]
CALL 0x0010656b
LAB_00106140:
LEA RDI,[RSP + 0xe0]
CALL 0x001075be
LAB_0010614d:
LEA RDI,[RSP + 0x140]
LEA RSI,[RSP + 0x120]
LEA RDX,[RSP + 0xe0]
CALL 0x001059e5
LAB_0010616a:
LEA RDX,[0x109427]
LEA RDI,[RSP + 0x160]
LEA RSI,[RSP + 0x140]
CALL 0x001059c6
LAB_00106186:
LEA RDI,[RSP + 0xc0]
CALL 0x001084bc
LAB_00106193:
LEA RDI,[RSP + 0x180]
LEA RSI,[RSP + 0x160]
LEA RDX,[RSP + 0xc0]
CALL 0x001059e5
LAB_001061b0:
LEA RDI,[RSP + 0x1a0]
LEA RSI,[RSP + 0x180]
MOV RDX,RSP
CALL 0x0010654c
LAB_001061c8:
LEA RDI,[RSP + 0xa0]
CALL 0x00108a22
LAB_001061d5:
LEA RDI,[RSP + 0x1c0]
LEA RSI,[RSP + 0x1a0]
LEA RDX,[RSP + 0xa0]
CALL 0x001059e5
LAB_001061f2:
LEA RDI,[RSP + 0x1e0]
LEA RSI,[RSP + 0x1c0]
MOV RDX,RSP
CALL 0x0010654c
LAB_0010620a:
LEA RDI,[RSP + 0x80]
CALL 0x00106856
LAB_00106217:
LEA RDI,[RSP + 0x200]
LEA RSI,[RSP + 0x1e0]
LEA RDX,[RSP + 0x80]
CALL 0x001059e5
LAB_00106234:
LEA RDI,[RSP + 0x220]
LEA RSI,[RSP + 0x200]
MOV RDX,RSP
CALL 0x0010654c
LAB_0010624c:
LEA RDI,[RSP + 0x60]
CALL 0x00105600
LAB_00106256:
LEA RDI,[RSP + 0x240]
LEA RSI,[RSP + 0x220]
LEA RDX,[RSP + 0x60]
CALL 0x001059e5
LAB_00106270:
LEA RDI,[RSP + 0x260]
LEA RSI,[RSP + 0x240]
MOV RDX,RSP
CALL 0x0010654c
LAB_00106288:
LEA RDI,[RSP + 0x40]
CALL 0x00107ec4
LAB_00106292:
LEA RDI,[RSP + 0x20]
LEA RSI,[RSP + 0x260]
LEA RDX,[RSP + 0x40]
CALL 0x001059e5
LAB_001062a9:
LEA RDX,[0x109252]
LEA RSI,[RSP + 0x20]
MOV RDI,RBX
CALL 0x001059c6
LAB_001062bd:
LEA RDI,[RSP + 0x20]
CALL 0x001046e8
LEA RDI,[RSP + 0x40]
CALL 0x001046e8
LEA RDI,[RSP + 0x260]
CALL 0x001046e8
LEA RDI,[RSP + 0x240]
CALL 0x001046e8
LEA RDI,[RSP + 0x60]
CALL 0x001046e8
LEA RDI,[RSP + 0x220]
CALL 0x001046e8
LEA RDI,[RSP + 0x200]
CALL 0x001046e8
LEA RDI,[RSP + 0x80]
CALL 0x001046e8
LEA RDI,[RSP + 0x1e0]
CALL 0x001046e8
LEA RDI,[RSP + 0x1c0]
CALL 0x001046e8
LEA RDI,[RSP + 0xa0]
CALL 0x001046e8
LEA RDI,[RSP + 0x1a0]
CALL 0x001046e8
LEA RDI,[RSP + 0x180]
CALL 0x001046e8
LEA RDI,[RSP + 0xc0]
CALL 0x001046e8
LEA RDI,[RSP + 0x160]
CALL 0x001046e8
LEA RDI,[RSP + 0x140]
CALL 0x001046e8
LEA RDI,[RSP + 0xe0]
CALL 0x001046e8
LEA RDI,[RSP + 0x120]
CALL 0x001046e8
LEA RDI,[RSP + 0x100]
CALL 0x001046e8
MOV RDI,RSP
CALL 0x001046e8
MOV RAX,RBX
ADD RSP,0x280
POP RBX
RET
|
/* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* lemonOutput[abi:cxx11]() */
void lemonOutput_abi_cxx11_(void)
{
string *in_RDI;
string asStack_288 [32];
allocator local_268 [32];
string local_248 [32];
Battery local_228 [32];
Brightness local_208 [32];
Mic local_1e8 [32];
Volume local_1c8 [32];
Workspaces local_1a8 [32];
Workspaces local_188 [32];
string local_168 [32];
string local_148 [32];
string local_128 [32];
string local_108 [32];
string local_e8 [32];
string local_c8 [32];
string local_a8 [32];
string local_88 [32];
string local_68 [32];
string local_48 [32];
string local_28 [32];
std::__cxx11::string::string<std::allocator<char>>(asStack_288,"%{F#777777}|%{F-}",local_268);
/* try { // try from 00106117 to 00106123 has its CatchHandler @ 00106544 */
Workspaces::getWorkspaces_abi_cxx11_(local_188);
/* try { // try from 00106124 to 0010613f has its CatchHandler @ 0010653c */
std::operator+((char *)local_168,(string *)"%{l} ");
/* try { // try from 00106140 to 0010614c has its CatchHandler @ 00106534 */
Workspaces::getWindows_abi_cxx11_(local_1a8);
/* try { // try from 0010614d to 00106169 has its CatchHandler @ 0010652c */
std::operator+(local_148,local_168);
/* try { // try from 0010616a to 00106185 has its CatchHandler @ 00106524 */
std::operator+(local_128,(char *)local_148);
/* try { // try from 00106186 to 00106192 has its CatchHandler @ 0010651c */
Volume::getVolume_abi_cxx11_(local_1c8);
/* try { // try from 00106193 to 001061af has its CatchHandler @ 00106514 */
std::operator+(local_108,local_128);
/* try { // try from 001061b0 to 001061c7 has its CatchHandler @ 0010650c */
std::operator+(local_e8,local_108);
/* try { // try from 001061c8 to 001061d4 has its CatchHandler @ 00106504 */
Mic::getMicVolume_abi_cxx11_(local_1e8);
/* try { // try from 001061d5 to 001061f1 has its CatchHandler @ 001064fc */
std::operator+(local_c8,local_e8);
/* try { // try from 001061f2 to 00106209 has its CatchHandler @ 001064f4 */
std::operator+(local_a8,local_c8);
/* try { // try from 0010620a to 00106216 has its CatchHandler @ 001064ec */
Brightness::getBrightness_abi_cxx11_(local_208);
/* try { // try from 00106217 to 00106233 has its CatchHandler @ 001064e4 */
std::operator+(local_88,local_a8);
/* try { // try from 00106234 to 0010624b has its CatchHandler @ 001064dc */
std::operator+(local_68,local_88);
/* try { // try from 0010624c to 00106255 has its CatchHandler @ 001064d4 */
Battery::getBattery_abi_cxx11_(local_228);
/* try { // try from 00106256 to 0010626f has its CatchHandler @ 00106401 */
std::operator+(local_48,local_68);
/* try { // try from 00106270 to 00106287 has its CatchHandler @ 001063ef */
std::operator+(local_28,local_48);
/* try { // try from 00106288 to 00106291 has its CatchHandler @ 001063dd */
getClock_abi_cxx11_();
/* try { // try from 00106292 to 001062a8 has its CatchHandler @ 001063ce */
std::operator+((string *)local_268,local_28);
/* try { // try from 001062a9 to 001062bc has its CatchHandler @ 001063bf */
std::operator+(in_RDI,(char *)local_268);
std::__cxx11::string::~string((string *)local_268);
std::__cxx11::string::~string(local_248);
std::__cxx11::string::~string(local_28);
std::__cxx11::string::~string(local_48);
std::__cxx11::string::~string((string *)local_228);
std::__cxx11::string::~string(local_68);
std::__cxx11::string::~string(local_88);
std::__cxx11::string::~string((string *)local_208);
std::__cxx11::string::~string(local_a8);
std::__cxx11::string::~string(local_c8);
std::__cxx11::string::~string((string *)local_1e8);
std::__cxx11::string::~string(local_e8);
std::__cxx11::string::~string(local_108);
std::__cxx11::string::~string((string *)local_1c8);
std::__cxx11::string::~string(local_128);
std::__cxx11::string::~string(local_148);
std::__cxx11::string::~string((string *)local_1a8);
std::__cxx11::string::~string(local_168);
std::__cxx11::string::~string((string *)local_188);
std::__cxx11::string::~string(asStack_288);
return;
}
|
|
7,716 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O0
|
cpp
|
minja::Parser::parseIfExpression():
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rsi
movq %rsi, 0x30(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x117240
leaq 0x88(%rsp), %rdi
callq 0x113450
testb $0x1, %al
jne 0x117645
movl $0x10, %edi
callq 0x5a710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
leaq 0x101a83(%rip), %rsi # 0x21906e
callq 0x5a4c0
jmp 0x1175f2
movq 0x18(%rsp), %rdi
movq 0x1929aa(%rip), %rsi # 0x2a9fa8
movq 0x192963(%rip), %rdx # 0x2a9f68
callq 0x5abb0
jmp 0x117823
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x5b0e0
jmp 0x117809
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x117809
leaq 0x193e54(%rip), %rax # 0x2ab4a0
cmpb $0x0, (%rax)
jne 0x1176a2
leaq 0x193e48(%rip), %rdi # 0x2ab4a0
callq 0x5a670
cmpl $0x0, %eax
je 0x1176a2
leaq 0x193e17(%rip), %rdi # 0x2ab480
leaq 0x101a1c(%rip), %rsi # 0x21908c
movl $0x10, %edx
callq 0xc73f0
jmp 0x11767c
leaq -0x4fdb3(%rip), %rdi # 0xc78d0
leaq 0x193df6(%rip), %rsi # 0x2ab480
leaq 0x1934e7(%rip), %rdx # 0x2aab78
callq 0x5b0c0
leaq 0x193e03(%rip), %rdi # 0x2ab4a0
callq 0x5aaa0
leaq 0x68(%rsp), %rdi
callq 0x113e10
movq 0x30(%rsp), %rsi
leaq 0x193dc8(%rip), %rdx # 0x2ab480
leaq 0x48(%rsp), %rdi
movl $0x1, %ecx
callq 0x113270
jmp 0x1176c9
leaq 0x48(%rsp), %rdi
callq 0x5a530
xorb $-0x1, %al
movb %al, 0x17(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5b6f8
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1176f0
jmp 0x1177c2
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x112e30
jmp 0x117706
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x113e20
leaq 0x38(%rsp), %rdi
callq 0x113260
leaq 0x68(%rsp), %rdi
callq 0x113450
testb $0x1, %al
jne 0x1177c0
movl $0x10, %edi
callq 0x5a710
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x101946(%rip), %rsi # 0x219093
callq 0x5a4c0
jmp 0x117754
movq 0x8(%rsp), %rdi
movq 0x192848(%rip), %rsi # 0x2a9fa8
movq 0x192801(%rip), %rdx # 0x2a9f68
callq 0x5abb0
jmp 0x117823
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x193d17(%rip), %rdi # 0x2ab4a0
callq 0x5a7b0
jmp 0x117809
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1177ff
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x5b0e0
jmp 0x1177ff
jmp 0x1177c2
movq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x12f310
jmp 0x1177db
leaq 0x68(%rsp), %rdi
callq 0x113260
leaq 0x88(%rsp), %rdi
callq 0x113260
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
leaq 0x68(%rsp), %rdi
callq 0x113260
leaq 0x88(%rsp), %rdi
callq 0x113260
movq 0x80(%rsp), %rdi
callq 0x5ac70
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN5minja6Parser17parseIfExpressionEv:
sub rsp, 0A8h
mov [rsp+0A8h+var_88], rdi
mov rax, rdi
mov [rsp+0A8h+var_80], rax
mov [rsp+0A8h+var_8], rdi
mov [rsp+0A8h+var_10], rsi
mov rsi, [rsp+0A8h+var_10]
mov qword ptr [rsp+0A8h+var_78], rsi
lea rdi, [rsp+0A8h+var_20]; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
lea rdi, [rsp+0A8h+var_20]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz short loc_117645
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0A8h+var_90], rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_1175F2:
mov rdi, [rsp+0A8h+var_90]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_117823
mov rdi, [rsp+arg_10]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
call ___cxa_free_exception
jmp loc_117809
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
jmp loc_117809
loc_117645:
lea rax, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
cmp byte ptr [rax], 0
jnz short loc_1176A2
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
cmp eax, 0
jz short loc_1176A2
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
jmp short $+2
loc_11767C:
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
loc_1176A2:
lea rdi, [rsp+0A8h+var_40]
call _ZNSt10shared_ptrIN5minja10ExpressionEEC2Ev; std::shared_ptr<minja::Expression>::shared_ptr(void)
mov rsi, qword ptr [rsp+0A8h+var_78]
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+0A8h+var_60]
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
jmp short $+2
loc_1176C9:
lea rdi, [rsp+0A8h+var_60]
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
xor al, 0FFh
mov [rsp+0A8h+var_91], al
lea rdi, [rsp+0A8h+var_60]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED1Ev; std::string::~string()
mov al, [rsp+0A8h+var_91]
test al, 1
jnz short loc_1176F0
jmp loc_1177C2
loc_1176F0:
mov rsi, qword ptr [rsp+0A8h+var_78]; bool
lea rdi, [rsp+0A8h+var_70]; this
mov edx, 1
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
jmp short $+2
loc_117706:
lea rdi, [rsp+0A8h+var_40]
lea rsi, [rsp+0A8h+var_70]
call _ZNSt10shared_ptrIN5minja10ExpressionEEaSEOS2_; std::shared_ptr<minja::Expression>::operator=(std::shared_ptr<minja::Expression>&&)
lea rdi, [rsp+0A8h+var_70]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
lea rdi, [rsp+0A8h+var_40]
call _ZNKSt12__shared_ptrIN5minja10ExpressionELN9__gnu_cxx12_Lock_policyE2EEcvbEv; std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(void)
test al, 1
jnz loc_1177C0
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rdi, rax; this
mov rax, rdi
mov [rsp+0A8h+var_A0], rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
jmp short $+2
loc_117754:
mov rdi, [rsp+0A8h+var_A0]; void *
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
call ___cxa_throw
jmp loc_117823
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_117809
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
jmp short loc_1177FF
mov rdi, [rsp+arg_0]; void *
mov rcx, rax
mov eax, edx
mov [rsp+arg_78], rcx
mov [rsp+arg_74], eax
call ___cxa_free_exception
jmp short loc_1177FF
loc_1177C0:
jmp short $+2
loc_1177C2:
mov rdi, [rsp+0A8h+var_88]
lea rsi, [rsp+0A8h+var_20]
lea rdx, [rsp+0A8h+var_40]
call _ZNSt4pairISt10shared_ptrIN5minja10ExpressionEES3_EC2IS3_S3_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIS7_S8_EEEbE4typeELb1EEEOS7_OS8_
jmp short $+2
loc_1177DB:
lea rdi, [rsp+0A8h+var_40]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
lea rdi, [rsp+0A8h+var_20]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
mov rax, [rsp+0A8h+var_80]
add rsp, 0A8h
retn
loc_1177FF:
lea rdi, [rsp+arg_60]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
loc_117809:
lea rdi, [rsp+arg_80]
call _ZNSt10shared_ptrIN5minja10ExpressionEED2Ev; std::shared_ptr<minja::Expression>::~shared_ptr()
mov rdi, [rsp+arg_78]
call __Unwind_Resume
loc_117823:
nop word ptr [rax+rax+00000000h]
nop dword ptr [rax]
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, long long a2)
{
std::runtime_error *v3; // [rsp+8h] [rbp-A0h]
char v4; // [rsp+17h] [rbp-91h]
std::runtime_error *exception; // [rsp+18h] [rbp-90h]
_BYTE v6[16]; // [rsp+38h] [rbp-70h] BYREF
_BYTE v7[32]; // [rsp+48h] [rbp-60h] BYREF
_QWORD v8[4]; // [rsp+68h] [rbp-40h] BYREF
_QWORD v9[4]; // [rsp+88h] [rbp-20h] BYREF
v9[3] = this;
v9[2] = a2;
minja::Parser::parseLogicalOr((minja::Parser *)v9, a2);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v9) )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
(long long)"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
std::shared_ptr<minja::Expression>::shared_ptr((long long)v8);
minja::Parser::consumeToken(
(long long)v7,
a2,
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
1u);
v4 = ~(unsigned __int8)std::string::empty(v7);
std::string::~string(v7);
if ( (v4 & 1) != 0 )
{
minja::Parser::parseExpression((minja::Parser *)v6, a2, 1);
std::shared_ptr<minja::Expression>::operator=((long long)v8, (long long)v6);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v6);
if ( !std::__shared_ptr<minja::Expression,(__gnu_cxx::_Lock_policy)2>::operator bool(v8) )
{
v3 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v3, "Expected 'else' expression");
__cxa_throw(
v3,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
ZNSt4pairISt10shared_ptrIN5minja10ExpressionEES3_EC2IS3_S3_TnNSt9enable_ifIXaaclsr5_PCCPE22_MoveConstructiblePairIT_T0_EEclsr5_PCCPE30_ImplicitlyMoveConvertiblePairIS7_S8_EEEbE4typeELb1EEEOS7_OS8_(
this,
v9,
v8);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v8);
std::shared_ptr<minja::Expression>::~shared_ptr((long long)v9);
return this;
}
| |||
7,717 |
minja::Parser::parseIfExpression()
|
monkey531[P]llama/common/minja.hpp
|
std::pair<std::shared_ptr<Expression>, std::shared_ptr<Expression>> parseIfExpression() {
auto condition = parseLogicalOr();
if (!condition) throw std::runtime_error("Expected condition expression");
static std::regex else_tok(R"(else\b)");
std::shared_ptr<Expression> else_expr;
if (!consumeToken(else_tok).empty()) {
else_expr = parseExpression();
if (!else_expr) throw std::runtime_error("Expected 'else' expression");
}
return std::pair(std::move(condition), std::move(else_expr));
}
|
O3
|
cpp
|
minja::Parser::parseIfExpression():
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x895ae
cmpq $0x0, (%r15)
je 0x89924
leaq 0xa8a11(%rip), %rax # 0x132278
movb (%rax), %al
testb %al, %al
je 0x89956
leaq 0xa89e0(%rip), %rdx # 0x132258
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq 0x88460
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
movq -0x8(%rax), %r15
cmpq %rax, %rdi
je 0x898a9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1b930
testq %r15, %r15
je 0x89903
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x8824c
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %r14
testq %rax, %rax
jne 0x89908
movl $0x10, %edi
callq 0x1b480
movq %rax, %r15
leaq 0x6bdb5(%rip), %rsi # 0xf5698
movq %rax, %rdi
callq 0x1b350
movq 0xa76f6(%rip), %rsi # 0x130fe8
movq 0xa7657(%rip), %rdx # 0x130f50
movq %r15, %rdi
callq 0x1c040
jmp 0x89956
xorl %eax, %eax
xorl %r14d, %r14d
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x1b480
movq %rax, %r14
leaq 0x6bd3b(%rip), %rsi # 0xf5673
movq %rax, %rdi
callq 0x1b350
movq 0xa76a1(%rip), %rsi # 0x130fe8
movq 0xa7602(%rip), %rdx # 0x130f50
movq %r14, %rdi
callq 0x1c040
leaq 0xa891b(%rip), %rdi # 0x132278
callq 0x1c130
testl %eax, %eax
je 0x89871
leaq 0xa88e7(%rip), %rdi # 0x132258
leaq 0x6bd19(%rip), %rsi # 0xf5691
movl $0x10, %edx
callq 0x675a8
leaq -0x220dd(%rip), %rdi # 0x678ac
leaq 0xa88c8(%rip), %rsi # 0x132258
leaq 0xa7fe1(%rip), %rdx # 0x131978
callq 0x1b7f0
leaq 0xa88d5(%rip), %rdi # 0x132278
callq 0x1b600
jmp 0x89871
movq %rax, %rbx
leaq 0xa88c1(%rip), %rdi # 0x132278
callq 0x1b5f0
jmp 0x899f1
movq %rax, %rbx
jmp 0x899ce
movq %rax, %rbx
movq %r15, %rdi
callq 0x1b6c0
testq %r14, %r14
je 0x899f1
movq %r14, %rdi
callq 0x267a6
jmp 0x899f1
jmp 0x899ee
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b6c0
jmp 0x899f1
jmp 0x899ee
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x89a00
callq 0x267a6
movq %rbx, %rdi
callq 0x1c0d0
|
_ZN5minja6Parser17parseIfExpressionEv:
push r15
push r14
push rbx
sub rsp, 30h
mov r14, rsi
mov rbx, rdi
mov r15, rsp
mov rdi, r15; this
call _ZN5minja6Parser14parseLogicalOrEv; minja::Parser::parseLogicalOr(void)
cmp qword ptr [r15], 0
jz loc_89924
lea rax, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; `guard variable for'minja::Parser::parseIfExpression(void)::else_tok
mov al, [rax]
test al, al
jz loc_89956
loc_89871:
lea rdx, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rdi, [rsp+48h+var_38]
mov rsi, r14
mov ecx, 1
call _ZN5minja6Parser12consumeTokenERKNSt7__cxx1111basic_regexIcNS1_12regex_traitsIcEEEENS_13SpaceHandlingE; minja::Parser::consumeToken(std::basic_regex<char,std::regex_traits<char>> const&,minja::SpaceHandling)
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
mov r15, [rax-8]
cmp rdi, rax
jz short loc_898A9
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_898A9:
test r15, r15
jz short loc_89903
lea rdi, [rsp+48h+var_38]; this
mov rsi, r14; bool
mov edx, 1
call _ZN5minja6Parser15parseExpressionEb; minja::Parser::parseExpression(bool)
mov rax, [rsp+48h+var_38]
mov r14, [rsp+48h+var_30]
test rax, rax
jnz short loc_89908
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aExpectedElseEx; "Expected 'else' expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
jmp short loc_89956
loc_89903:
xor eax, eax
xor r14d, r14d
loc_89908:
movaps xmm0, [rsp+48h+var_48]
movups xmmword ptr [rbx], xmm0
mov [rbx+10h], rax
mov [rbx+18h], r14
mov rax, rbx
add rsp, 30h
pop rbx
pop r14
pop r15
retn
loc_89924:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aExpectedCondit_1; "Expected condition expression"
mov rdi, rax; this
call __ZNSt13runtime_errorC1EPKc; std::runtime_error::runtime_error(char const*)
mov rsi, cs:_ZTISt13runtime_error_ptr; lptinfo
mov rdx, cs:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
loc_89956:
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_acquire
test eax, eax
jz loc_89871
lea rdi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; minja::Parser::parseIfExpression(void)::else_tok
lea rsi, aElseB; "else\\b"
mov edx, 10h
call _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEEC2EPKcNSt15regex_constants18syntax_option_typeE; std::basic_regex<char,std::regex_traits<char>>::basic_regex(char const*,std::regex_constants::syntax_option_type)
lea rdi, _ZNSt7__cxx1111basic_regexIcNS_12regex_traitsIcEEED2Ev; lpfunc
lea rsi, _ZZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; obj
lea rdx, __dso_handle; lpdso_handle
call ___cxa_atexit
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_release
jmp loc_89871
mov rbx, rax
lea rdi, _ZGVZN5minja6Parser17parseIfExpressionEvE8else_tokB5cxx11; __guard *
call ___cxa_guard_abort
jmp short loc_899F1
mov rbx, rax
jmp short loc_899CE
mov rbx, rax
mov rdi, r15; void *
call ___cxa_free_exception
loc_899CE:
test r14, r14
jz short loc_899F1
mov rdi, r14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
jmp short loc_899F1
jmp short loc_899EE
mov rbx, rax
mov rdi, r14; void *
call ___cxa_free_exception
jmp short loc_899F1
jmp short $+2
loc_899EE:
mov rbx, rax
loc_899F1:
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_89A00
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_89A00:
mov rdi, rbx
call __Unwind_Resume
|
minja::Parser * minja::Parser::parseIfExpression(minja::Parser *this, long long *a2)
{
long long v2; // r15
long long *v3; // rax
long long v4; // r14
std::runtime_error *v5; // r15
std::runtime_error *exception; // r14
__int128 v8; // [rsp+0h] [rbp-48h] BYREF
long long *v9; // [rsp+10h] [rbp-38h] BYREF
long long v10; // [rsp+18h] [rbp-30h]
long long v11; // [rsp+20h] [rbp-28h] BYREF
minja::Parser::parseLogicalOr((volatile signed __int32 **)&v8, a2);
if ( !(_QWORD)v8 )
{
exception = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(exception, "Expected condition expression");
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
if ( !(_BYTE)`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]
&& __cxa_guard_acquire(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]) )
{
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
(long long)"else\\b",
0x10u);
__cxa_atexit(
(void (*)(void *))std::basic_regex<char,std::regex_traits<char>>::~basic_regex,
&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
&_dso_handle);
__cxa_guard_release(&`guard variable for'minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11]);
}
minja::Parser::consumeToken(
(long long)&v9,
(long long)a2,
(long long)&minja::Parser::parseIfExpression(void)::else_tok[abi:cxx11],
1u);
v2 = v10;
if ( v9 != &v11 )
operator delete(v9, v11 + 1);
if ( v2 )
{
minja::Parser::parseExpression((minja::Parser *)&v9, a2, 1);
v3 = v9;
v4 = v10;
if ( !v9 )
{
v5 = (std::runtime_error *)__cxa_allocate_exception(0x10uLL);
std::runtime_error::runtime_error(v5, "Expected 'else' expression");
__cxa_throw(
v5,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
}
else
{
v3 = 0LL;
v4 = 0LL;
}
*(_OWORD *)this = v8;
*((_QWORD *)this + 2) = v3;
*((_QWORD *)this + 3) = v4;
return this;
}
|
parseIfExpression:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV R14,RSI
MOV RBX,RDI
MOV R15,RSP
MOV RDI,R15
CALL 0x001895ae
CMP qword ptr [R15],0x0
JZ 0x00189924
LEA RAX,[0x232278]
MOV AL,byte ptr [RAX]
TEST AL,AL
JZ 0x00189956
LAB_00189871:
LEA RDX,[0x232258]
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV ECX,0x1
CALL 0x00188460
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
MOV R15,qword ptr [RAX + -0x8]
CMP RDI,RAX
JZ 0x001898a9
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x0011b930
LAB_001898a9:
TEST R15,R15
JZ 0x00189903
LAB_001898ae:
LEA RDI,[RSP + 0x10]
MOV RSI,R14
MOV EDX,0x1
CALL 0x0018824c
LAB_001898c0:
MOV RAX,qword ptr [RSP + 0x10]
MOV R14,qword ptr [RSP + 0x18]
TEST RAX,RAX
JNZ 0x00189908
MOV EDI,0x10
CALL 0x0011b480
MOV R15,RAX
LAB_001898dc:
LEA RSI,[0x1f5698]
MOV RDI,RAX
CALL 0x0011b350
LAB_001898eb:
MOV RSI,qword ptr [0x00230fe8]
MOV RDX,qword ptr [0x00230f50]
MOV RDI,R15
CALL 0x0011c040
LAB_00189903:
XOR EAX,EAX
XOR R14D,R14D
LAB_00189908:
MOVAPS XMM0,xmmword ptr [RSP]
MOVUPS xmmword ptr [RBX],XMM0
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [RBX + 0x18],R14
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
LAB_00189924:
MOV EDI,0x10
CALL 0x0011b480
MOV R14,RAX
LAB_00189931:
LEA RSI,[0x1f5673]
MOV RDI,RAX
CALL 0x0011b350
LAB_00189940:
MOV RSI,qword ptr [0x00230fe8]
MOV RDX,qword ptr [0x00230f50]
MOV RDI,R14
CALL 0x0011c040
LAB_00189956:
LEA RDI,[0x232278]
CALL 0x0011c130
TEST EAX,EAX
JZ 0x00189871
LAB_0018996a:
LEA RDI,[0x232258]
LEA RSI,[0x1f5691]
MOV EDX,0x10
CALL 0x001675a8
LAB_00189982:
LEA RDI,[0x1678ac]
LEA RSI,[0x232258]
LEA RDX,[0x231978]
CALL 0x0011b7f0
LEA RDI,[0x232278]
CALL 0x0011b600
JMP 0x00189871
|
/* minja::Parser::parseIfExpression() */
void minja::Parser::parseIfExpression(void)
{
long lVar1;
int iVar2;
runtime_error *prVar3;
long *in_RDI;
long local_48;
long lStack_40;
long *local_38;
long local_30;
long local_28 [2];
parseLogicalOr();
if (local_48 == 0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 00189931 to 0018993f has its CatchHandler @ 001899df */
std::runtime_error::runtime_error(prVar3,"Expected condition expression");
/* try { // try from 00189940 to 00189955 has its CatchHandler @ 001899dd */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00230fe8,PTR__runtime_error_00230f50);
}
if (parseIfExpression()::else_tok_abi_cxx11_ == '\0') {
iVar2 = __cxa_guard_acquire(&parseIfExpression()::else_tok_abi_cxx11_);
if (iVar2 != 0) {
/* try { // try from 0018996a to 00189981 has its CatchHandler @ 001899ad */
std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::basic_regex
((basic_regex<char,std::__cxx11::regex_traits<char>> *)
parseIfExpression()::else_tok_abi_cxx11_,"else\\b",0x10);
__cxa_atexit(std::__cxx11::basic_regex<char,std::__cxx11::regex_traits<char>>::~basic_regex,
parseIfExpression()::else_tok_abi_cxx11_,&__dso_handle);
__cxa_guard_release(&parseIfExpression()::else_tok_abi_cxx11_);
}
}
/* try { // try from 00189871 to 00189889 has its CatchHandler @ 001899ee */
consumeToken(&local_38);
lVar1 = local_30;
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
if (lVar1 == 0) {
local_38 = (long *)0x0;
local_30 = 0;
}
else {
/* try { // try from 001898ae to 001898bf has its CatchHandler @ 001899ec */
parseExpression(SUB81(&local_38,0));
if (local_38 == (long *)0x0) {
prVar3 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 001898dc to 001898ea has its CatchHandler @ 001899c3 */
std::runtime_error::runtime_error(prVar3,"Expected \'else\' expression");
/* try { // try from 001898eb to 00189900 has its CatchHandler @ 001899be */
/* WARNING: Subroutine does not return */
__cxa_throw(prVar3,PTR_typeinfo_00230fe8,PTR__runtime_error_00230f50);
}
}
*in_RDI = local_48;
in_RDI[1] = lStack_40;
in_RDI[2] = (long)local_38;
in_RDI[3] = local_30;
return;
}
|
|
7,718 |
get_collation_number
|
eloqsql/mysys/charset.c
|
uint get_collation_number(const char *name, myf flags)
{
uint id;
char alias[64];
my_pthread_once(&charsets_initialized, init_available_charsets);
if ((id= get_collation_number_internal(name)))
return id;
if ((name= get_collation_name_alias(name, alias, sizeof(alias),flags)))
return get_collation_number_internal(name);
return 0;
}
|
O3
|
c
|
get_collation_number:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x18(%rbp)
leaq 0x348524(%rip), %rdi # 0x372c00
leaq 0x80(%rip), %rsi # 0x2a763
callq 0x242a0
movq %rbx, %rdi
callq 0x2a8e3
testl %eax, %eax
jne 0x2a746
leaq 0x3575f(%rip), %rsi # 0x5fe5a
movl $0x5, %edx
movq %rbx, %rdi
callq 0x24450
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2a746
btl $0xa, %r14d
movl $0x33, %ecx
sbbl $-0x1, %ecx
addq $0x5, %rbx
leaq 0x35738(%rip), %rdx # 0x5fe60
leaq -0x60(%rbp), %r14
movl $0x40, %esi
movq %r14, %rdi
movq %rbx, %r8
xorl %eax, %eax
callq 0x5db1a
movq %r14, %rdi
callq 0x2a8e3
movq %fs:0x28, %rcx
cmpq -0x18(%rbp), %rcx
jne 0x2a75e
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24370
|
get_collation_number:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov r14, rsi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
lea rdi, charsets_initialized
lea rsi, init_available_charsets
call _pthread_once
mov rdi, rbx
call get_collation_number_internal
test eax, eax
jnz short loc_2A746
lea rsi, aUtf8_0; "utf8_"
mov edx, 5
mov rdi, rbx
call _strncasecmp
mov ecx, eax
xor eax, eax
test ecx, ecx
jnz short loc_2A746
bt r14d, 0Ah
mov ecx, 33h ; '3'
sbb ecx, 0FFFFFFFFh
add rbx, 5
lea rdx, aUtf8mbCS; "utf8mb%c_%s"
lea r14, [rbp+var_60]
mov esi, 40h ; '@'
mov rdi, r14
mov r8, rbx
xor eax, eax
call my_snprintf
mov rdi, r14
call get_collation_number_internal
loc_2A746:
mov rcx, fs:28h
cmp rcx, [rbp+var_18]
jnz short loc_2A75E
add rsp, 50h
pop rbx
pop r14
pop rbp
retn
loc_2A75E:
call ___stack_chk_fail
|
long long get_collation_number(long long a1, __int16 a2)
{
long long result; // rax
int v3; // ecx
int v4; // r9d
_BYTE v5[72]; // [rsp+0h] [rbp-60h] BYREF
unsigned long long v6; // [rsp+48h] [rbp-18h]
v6 = __readfsqword(0x28u);
pthread_once(&charsets_initialized, init_available_charsets);
result = get_collation_number_internal(a1);
if ( !(_DWORD)result )
{
v3 = strncasecmp(a1, "utf8_", 5LL);
result = 0LL;
if ( !v3 )
{
my_snprintf((unsigned int)v5, 64, (unsigned int)"utf8mb%c_%s", 51 - (((a2 & 0x400) != 0) - 1), a1 + 5, v4);
return get_collation_number_internal(v5);
}
}
return result;
}
|
get_collation_number:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
LEA RDI,[0x472c00]
LEA RSI,[0x12a763]
CALL 0x001242a0
MOV RDI,RBX
CALL 0x0012a8e3
TEST EAX,EAX
JNZ 0x0012a746
LEA RSI,[0x15fe5a]
MOV EDX,0x5
MOV RDI,RBX
CALL 0x00124450
MOV ECX,EAX
XOR EAX,EAX
TEST ECX,ECX
JNZ 0x0012a746
BT R14D,0xa
MOV ECX,0x33
SBB ECX,-0x1
ADD RBX,0x5
LEA RDX,[0x15fe60]
LEA R14,[RBP + -0x60]
MOV ESI,0x40
MOV RDI,R14
MOV R8,RBX
XOR EAX,EAX
CALL 0x0015db1a
MOV RDI,R14
CALL 0x0012a8e3
LAB_0012a746:
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x18]
JNZ 0x0012a75e
ADD RSP,0x50
POP RBX
POP R14
POP RBP
RET
LAB_0012a75e:
CALL 0x00124370
|
int8 get_collation_number(char *param_1,uint param_2)
{
int iVar1;
int8 uVar2;
long in_FS_OFFSET;
int1 local_68 [72];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
pthread_once(&charsets_initialized,init_available_charsets);
uVar2 = get_collation_number_internal(param_1);
if ((int)uVar2 == 0) {
iVar1 = strncasecmp(param_1,"utf8_",5);
uVar2 = 0;
if (iVar1 == 0) {
my_snprintf(local_68,0x40,"utf8mb%c_%s",0x34 - (uint)((param_2 >> 10 & 1) != 0),param_1 + 5);
uVar2 = get_collation_number_internal(local_68);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_20) {
return uVar2;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
7,719 |
ma_tls_set_error
|
eloqsql/libmariadb/libmariadb/secure/openssl.c
|
static void ma_tls_set_error(MYSQL *mysql)
{
ulong ssl_errno= ERR_get_error();
char ssl_error[MAX_SSL_ERR_LEN];
const char *ssl_error_reason;
MARIADB_PVIO *pvio= mysql->net.pvio;
int save_errno= errno;
if (ssl_errno && (ssl_error_reason= ERR_reason_error_string(ssl_errno)))
{
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN,
0, ssl_error_reason);
return;
}
strerror_r(save_errno, ssl_error, MAX_SSL_ERR_LEN);
pvio->set_error(mysql, CR_SSL_CONNECTION_ERROR, SQLSTATE_UNKNOWN, "TLS/SSL error: %s (%d)",
ssl_error, save_errno);
return;
}
|
O3
|
c
|
ma_tls_set_error:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
callq 0x177b0
movq %rax, %r15
movq (%rbx), %r12
callq 0x17050
movl (%rax), %r14d
testq %r15, %r15
je 0x32194
movq %r15, %rdi
callq 0x17ad0
testq %rax, %rax
je 0x32194
movq 0x50(%r12), %r9
leaq 0x19bec(%rip), %rcx # 0x4bd50
movq (%rcx), %rdx
movq %fs:0x28, %rcx
cmpq -0x28(%rbp), %rcx
jne 0x321ed
movq %rbx, %rdi
movl $0x7ea, %esi # imm = 0x7EA
xorl %ecx, %ecx
movq %rax, %r8
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%r9
leaq -0x90(%rbp), %r15
movl $0x64, %edx
movl %r14d, %edi
movq %r15, %rsi
callq 0x17280
leaq 0x19b9e(%rip), %rax # 0x4bd50
movq (%rax), %rdx
leaq 0x91ca(%rip), %rcx # 0x3b386
movq %rbx, %rdi
movl $0x7ea, %esi # imm = 0x7EA
movq %r15, %r8
movl %r14d, %r9d
xorl %eax, %eax
callq *0x50(%r12)
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x321ed
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x17690
|
ma_tls_set_error:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 70h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
call _ERR_get_error
mov r15, rax
mov r12, [rbx]
call ___errno_location
mov r14d, [rax]
test r15, r15
jz short loc_32194
mov rdi, r15
call _ERR_reason_error_string
test rax, rax
jz short loc_32194
mov r9, [r12+50h]
lea rcx, SQLSTATE_UNKNOWN
mov rdx, [rcx]
mov rcx, fs:28h
cmp rcx, [rbp+var_28]
jnz short loc_321ED
mov rdi, rbx
mov esi, 7EAh
xor ecx, ecx
mov r8, rax
xor eax, eax
add rsp, 70h
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp r9
loc_32194:
lea r15, [rbp+var_90]
mov edx, 64h ; 'd'
mov edi, r14d
mov rsi, r15
call ___xpg_strerror_r
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rcx, aTlsSslErrorSD; "TLS/SSL error: %s (%d)"
mov rdi, rbx
mov esi, 7EAh
mov r8, r15
mov r9d, r14d
xor eax, eax
call qword ptr [r12+50h]
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_321ED
add rsp, 70h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_321ED:
call ___stack_chk_fail
|
long long ma_tls_set_error(long long *a1)
{
long long error; // r15
long long v2; // r12
unsigned int v3; // r14d
long long v4; // rax
char v6[104]; // [rsp+0h] [rbp-90h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-28h]
v7 = __readfsqword(0x28u);
error = ERR_get_error();
v2 = *a1;
v3 = *(_DWORD *)__errno_location(a1);
if ( error )
{
v4 = ERR_reason_error_string(error);
if ( v4 )
return (*(long long ( **)(long long *, long long, char *, _QWORD, long long))(v2 + 80))(
a1,
2026LL,
SQLSTATE_UNKNOWN,
0LL,
v4);
}
__xpg_strerror_r(v3, v6, 100LL);
(*(void (**)(long long *, long long, char *, const char *, ...))(v2 + 80))(
a1,
2026LL,
SQLSTATE_UNKNOWN,
"TLS/SSL error: %s (%d)",
v6,
v3);
return __readfsqword(0x28u);
}
|
ma_tls_set_error:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x70
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
CALL 0x001177b0
MOV R15,RAX
MOV R12,qword ptr [RBX]
CALL 0x00117050
MOV R14D,dword ptr [RAX]
TEST R15,R15
JZ 0x00132194
MOV RDI,R15
CALL 0x00117ad0
TEST RAX,RAX
JZ 0x00132194
MOV R9,qword ptr [R12 + 0x50]
LEA RCX,[0x14bd50]
MOV RDX,qword ptr [RCX]
MOV RCX,qword ptr FS:[0x28]
CMP RCX,qword ptr [RBP + -0x28]
JNZ 0x001321ed
MOV RDI,RBX
MOV ESI,0x7ea
XOR ECX,ECX
MOV R8,RAX
XOR EAX,EAX
ADD RSP,0x70
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP R9
LAB_00132194:
LEA R15,[RBP + -0x90]
MOV EDX,0x64
MOV EDI,R14D
MOV RSI,R15
CALL 0x00117280
LEA RAX,[0x14bd50]
MOV RDX,qword ptr [RAX]
LEA RCX,[0x13b386]
MOV RDI,RBX
MOV ESI,0x7ea
MOV R8,R15
MOV R9D,R14D
XOR EAX,EAX
CALL qword ptr [R12 + 0x50]
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x001321ed
ADD RSP,0x70
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001321ed:
CALL 0x00117690
|
void ma_tls_set_error(long *param_1)
{
int iVar1;
long lVar2;
code *UNRECOVERED_JUMPTABLE;
ulong e;
int *piVar3;
char *pcVar4;
long in_FS_OFFSET;
int1 local_98 [104];
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
e = ERR_get_error();
lVar2 = *param_1;
piVar3 = __errno_location();
iVar1 = *piVar3;
if (e != 0) {
pcVar4 = ERR_reason_error_string(e);
if (pcVar4 != (char *)0x0) {
UNRECOVERED_JUMPTABLE = *(code **)(lVar2 + 0x50);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
/* WARNING: Could not recover jumptable at 0x00132191. Too many branches */
/* WARNING: Treating indirect jump as call */
(*UNRECOVERED_JUMPTABLE)(param_1,0x7ea,SQLSTATE_UNKNOWN,0,pcVar4,UNRECOVERED_JUMPTABLE);
return;
}
goto LAB_001321ed;
}
}
__xpg_strerror_r(iVar1,local_98,100);
(**(code **)(lVar2 + 0x50))
(param_1,0x7ea,SQLSTATE_UNKNOWN,"TLS/SSL error: %s (%d)",local_98,iVar1);
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return;
}
LAB_001321ed:
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
7,720 |
evmone::instr::core::calldatacopy(evmone::StackTop, long, evmone::ExecutionState&)
|
corpus-core[P]colibri-stateless/build_O0/_deps/evmone_external-src/lib/evmone/instructions.hpp
|
inline Result calldatacopy(StackTop stack, int64_t gas_left, ExecutionState& state) noexcept
{
const auto& mem_index = stack.pop();
const auto& input_index = stack.pop();
const auto& size = stack.pop();
if (!check_memory(gas_left, state.memory, mem_index, size))
return {EVMC_OUT_OF_GAS, gas_left};
auto dst = static_cast<size_t>(mem_index);
auto src = state.msg->input_size < input_index ? state.msg->input_size :
static_cast<size_t>(input_index);
auto s = static_cast<size_t>(size);
auto copy_size = std::min(s, state.msg->input_size - src);
if (const auto cost = copy_cost(s); (gas_left -= cost) < 0)
return {EVMC_OUT_OF_GAS, gas_left};
if (copy_size > 0)
std::memcpy(&state.memory[dst], &state.msg->input_data[src], copy_size);
if (s - copy_size > 0)
std::memset(&state.memory[dst + copy_size], 0, s - copy_size);
return {EVMC_SUCCESS, gas_left};
}
|
O0
|
cpp
|
evmone::instr::core::calldatacopy(evmone::StackTop, long, evmone::ExecutionState&):
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x611b0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x20(%rbp), %rdi
callq 0x68460
testb $0x1, %al
jne 0x6916f
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6929e
movq -0x30(%rbp), %rdi
callq 0x68550
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x48, %rdi
movq -0x38(%rbp), %rsi
callq 0x69080
testb $0x1, %al
jne 0x69197
jmp 0x691a9
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x691b6
movq -0x38(%rbp), %rdi
callq 0x68550
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rdi
callq 0x68550
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x48(%rax), %rax
subq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3a680
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x692b0
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jge 0x69226
movl $0x3, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6929e
cmpq $0x0, -0x60(%rbp)
jbe 0x6925a
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x48(%rbp), %rsi
callq 0x60120
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x40(%rax), %rsi
addq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdx
callq 0x230a0
movq -0x58(%rbp), %rax
subq -0x60(%rbp), %rax
cmpq $0x0, %rax
jbe 0x6928f
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x48(%rbp), %rsi
addq -0x60(%rbp), %rsi
callq 0x60120
movq %rax, %rdi
movq -0x58(%rbp), %rdx
subq -0x60(%rbp), %rdx
xorl %esi, %esi
callq 0x231c0
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nop
|
_ZN6evmone5instr4core12calldatacopyENS_8StackTopElRNS_14ExecutionStateE:
push rbp
mov rbp, rsp
sub rsp, 80h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_30], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_38], rax
lea rdi, [rbp+var_18]; this
call _ZN6evmone8StackTop3popEv; evmone::StackTop::pop(void)
mov [rbp+var_40], rax
mov rsi, [rbp+var_28]
add rsi, 8
mov rdx, [rbp+var_30]
mov rcx, [rbp+var_40]
lea rdi, [rbp+var_20]
call _ZN6evmone12check_memoryERlRNS_6MemoryERKN4intx4uintILj256EEES7_; evmone::check_memory(long &,evmone::Memory &,intx::uint<256u> const&,intx::uint<256u> const&)
test al, 1
jnz short loc_6916F
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp loc_6929E
loc_6916F:
mov rdi, [rbp+var_30]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_48], rax
mov rax, [rbp+var_28]
mov rdi, [rax+20h]
add rdi, 48h ; 'H'
mov rsi, [rbp+var_38]
call _ZN4intxltILj256EmvEEbRKT0_RKNS_4uintIXT_EEE; intx::operator<<256u,ulong,void>(ulong const&,intx::uint<256u> const&)
test al, 1
jnz short loc_69197
jmp short loc_691A9
loc_69197:
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov rax, [rax+48h]
mov [rbp+var_78], rax
jmp short loc_691B6
loc_691A9:
mov rdi, [rbp+var_38]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_78], rax
loc_691B6:
mov rax, [rbp+var_78]
mov [rbp+var_50], rax
mov rdi, [rbp+var_40]
call _ZNK4intx4uintILj256EEcvT_ImvEEv; intx::uint<256u>::operator ulong<ulong,void>(void)
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov rax, [rax+48h]
sub rax, [rbp+var_50]
mov [rbp+var_68], rax
lea rdi, [rbp+var_58]
lea rsi, [rbp+var_68]; unsigned __int64
call _ZSt3minImERKT_S2_S2_; std::min<ulong>(ulong const&,ulong const&)
mov rax, [rax]
mov [rbp+var_60], rax
mov rdi, [rbp+var_58]; this
call _ZN6evmone9copy_costEm; evmone::copy_cost(ulong)
mov [rbp+var_70], rax
mov rcx, [rbp+var_70]
mov rax, [rbp+var_20]
sub rax, rcx
mov [rbp+var_20], rax
cmp rax, 0
jge short loc_69226
mov [rbp+var_10], 3
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
jmp short loc_6929E
loc_69226:
cmp [rbp+var_60], 0
jbe short loc_6925A
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_48]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov rdi, rax
mov rax, [rbp+var_28]
mov rax, [rax+20h]
mov rsi, [rax+40h]
add rsi, [rbp+var_50]
mov rdx, [rbp+var_60]
call _memcpy
loc_6925A:
mov rax, [rbp+var_58]
sub rax, [rbp+var_60]
cmp rax, 0
jbe short loc_6928F
mov rdi, [rbp+var_28]
add rdi, 8
mov rsi, [rbp+var_48]
add rsi, [rbp+var_60]
call _ZN6evmone6MemoryixEm; evmone::Memory::operator[](ulong)
mov rdi, rax
mov rdx, [rbp+var_58]
sub rdx, [rbp+var_60]
xor esi, esi
call _memset
loc_6928F:
mov [rbp+var_10], 0
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_6929E:
mov eax, [rbp+var_10]
mov rdx, [rbp+var_8]
add rsp, 80h
pop rbp
retn
|
long long evmone::instr::core::calldatacopy(long long a1, long long a2, long long a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-78h]
long long v7; // [rsp+10h] [rbp-70h]
unsigned long long v8; // [rsp+18h] [rbp-68h] BYREF
evmone *v9; // [rsp+20h] [rbp-60h]
evmone *v10; // [rsp+28h] [rbp-58h] BYREF
long long v11; // [rsp+30h] [rbp-50h]
long long v12; // [rsp+38h] [rbp-48h]
long long v13; // [rsp+40h] [rbp-40h]
long long v14; // [rsp+48h] [rbp-38h]
long long v15; // [rsp+50h] [rbp-30h]
long long v16; // [rsp+58h] [rbp-28h]
long long v17; // [rsp+60h] [rbp-20h] BYREF
long long v18; // [rsp+68h] [rbp-18h] BYREF
unsigned int v19; // [rsp+70h] [rbp-10h]
long long v20; // [rsp+78h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = evmone::StackTop::pop((evmone::StackTop *)&v18);
v14 = evmone::StackTop::pop((evmone::StackTop *)&v18);
v13 = evmone::StackTop::pop((evmone::StackTop *)&v18);
if ( (evmone::check_memory((long long)&v17, v16 + 8, v15, v13) & 1) != 0 )
{
v12 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v15);
if ( intx::operator<<256u,unsigned long,void>((long long *)(*(_QWORD *)(v16 + 32) + 72LL), v14) )
v6 = *(_QWORD *)(*(_QWORD *)(v16 + 32) + 72LL);
else
v6 = intx::uint<256u>::operator unsigned long<unsigned long,void>(v14);
v11 = v6;
v10 = (evmone *)intx::uint<256u>::operator unsigned long<unsigned long,void>(v13);
v8 = *(_QWORD *)(*(_QWORD *)(v16 + 32) + 72LL) - v6;
v9 = (evmone *)*std::min<unsigned long>(&v10, &v8);
v7 = evmone::copy_cost(v10, (unsigned long long)&v8);
v17 -= v7;
if ( v17 >= 0 )
{
if ( v9 )
{
v3 = evmone::Memory::operator[](v16 + 8, v12);
memcpy(v3, v11 + *(_QWORD *)(*(_QWORD *)(v16 + 32) + 64LL), v9);
}
if ( v10 != v9 )
{
v4 = evmone::Memory::operator[](v16 + 8, (long long)v9 + v12);
memset(v4, 0LL, v10 - v9);
}
v19 = 0;
v20 = v17;
}
else
{
v19 = 3;
v20 = v17;
}
}
else
{
v19 = 3;
v20 = v17;
}
return v19;
}
|
calldatacopy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x80
MOV qword ptr [RBP + -0x18],RDI
MOV qword ptr [RBP + -0x20],RSI
MOV qword ptr [RBP + -0x28],RDX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x30],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x38],RAX
LEA RDI,[RBP + -0x18]
CALL 0x001611b0
MOV qword ptr [RBP + -0x40],RAX
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x8
MOV RDX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x40]
LEA RDI,[RBP + -0x20]
CALL 0x00168460
TEST AL,0x1
JNZ 0x0016916f
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016929e
LAB_0016916f:
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x00168550
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,qword ptr [RAX + 0x20]
ADD RDI,0x48
MOV RSI,qword ptr [RBP + -0x38]
CALL 0x00169080
TEST AL,0x1
JNZ 0x00169197
JMP 0x001691a9
LAB_00169197:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x48]
MOV qword ptr [RBP + -0x78],RAX
JMP 0x001691b6
LAB_001691a9:
MOV RDI,qword ptr [RBP + -0x38]
CALL 0x00168550
MOV qword ptr [RBP + -0x78],RAX
LAB_001691b6:
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x00168550
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV RAX,qword ptr [RAX + 0x48]
SUB RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x68],RAX
LEA RDI,[RBP + -0x58]
LEA RSI,[RBP + -0x68]
CALL 0x0013a680
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x58]
CALL 0x001692b0
MOV qword ptr [RBP + -0x70],RAX
MOV RCX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x20]
SUB RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JGE 0x00169226
MOV dword ptr [RBP + -0x10],0x3
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0016929e
LAB_00169226:
CMP qword ptr [RBP + -0x60],0x0
JBE 0x0016925a
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00160120
MOV RDI,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX + 0x20]
MOV RSI,qword ptr [RAX + 0x40]
ADD RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x60]
CALL 0x001230a0
LAB_0016925a:
MOV RAX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RBP + -0x60]
CMP RAX,0x0
JBE 0x0016928f
MOV RDI,qword ptr [RBP + -0x28]
ADD RDI,0x8
MOV RSI,qword ptr [RBP + -0x48]
ADD RSI,qword ptr [RBP + -0x60]
CALL 0x00160120
MOV RDI,RAX
MOV RDX,qword ptr [RBP + -0x58]
SUB RDX,qword ptr [RBP + -0x60]
XOR ESI,ESI
CALL 0x001231c0
LAB_0016928f:
MOV dword ptr [RBP + -0x10],0x0
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_0016929e:
MOV EAX,dword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x8]
ADD RSP,0x80
POP RBP
RET
|
/* evmone::instr::core::calldatacopy(evmone::StackTop, long, evmone::ExecutionState&) */
int1 [16] evmone::instr::core::calldatacopy(int8 param_1,long param_2,long param_3)
{
bool bVar1;
ulong uVar2;
ulong *puVar3;
long lVar4;
void *pvVar5;
int1 auVar6 [16];
ulong local_80;
ulong local_70;
ulong local_68;
ulong local_60;
ulong local_58;
ulong local_50;
uint *local_48;
uint *local_40;
uint *local_38;
long local_30;
long local_28;
int8 local_20;
uint local_18;
long local_10;
local_30 = param_3;
local_28 = param_2;
local_20 = param_1;
local_38 = (uint *)StackTop::pop((StackTop *)&local_20);
local_40 = (uint *)StackTop::pop((StackTop *)&local_20);
local_48 = (uint *)StackTop::pop((StackTop *)&local_20);
uVar2 = check_memory(&local_28,(Memory *)(local_30 + 8),local_38,local_48);
if ((uVar2 & 1) == 0) {
local_18 = 3;
local_10 = local_28;
}
else {
local_50 = intx::uint::operator_cast_to_unsigned_long(local_38);
bVar1 = intx::operator<((ulong *)(*(long *)(local_30 + 0x20) + 0x48),local_40);
if (bVar1) {
local_80 = *(ulong *)(*(long *)(local_30 + 0x20) + 0x48);
}
else {
local_80 = intx::uint::operator_cast_to_unsigned_long(local_40);
}
local_58 = local_80;
local_60 = intx::uint::operator_cast_to_unsigned_long(local_48);
local_70 = *(long *)(*(long *)(local_30 + 0x20) + 0x48) - local_58;
puVar3 = std::min<unsigned_long>(&local_60,&local_70);
local_68 = *puVar3;
lVar4 = copy_cost(local_60);
local_28 = local_28 - lVar4;
if (local_28 < 0) {
local_18 = 3;
local_10 = local_28;
}
else {
if (local_68 != 0) {
pvVar5 = (void *)Memory::operator[]((Memory *)(local_30 + 8),local_50);
memcpy(pvVar5,(void *)(*(long *)(*(long *)(local_30 + 0x20) + 0x40) + local_58),local_68);
}
if (local_60 != local_68) {
pvVar5 = (void *)Memory::operator[]((Memory *)(local_30 + 8),local_50 + local_68);
memset(pvVar5,0,local_60 - local_68);
}
local_18 = 0;
local_10 = local_28;
}
}
auVar6._4_4_ = 0;
auVar6._0_4_ = local_18;
auVar6._8_8_ = local_10;
return auVar6;
}
|
|
7,721 |
inline_mysql_rwlock_unlock
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_rwlock_unlock(
mysql_rwlock_t *that)
{
int result;
#ifdef HAVE_PSI_RWLOCK_INTERFACE
if (psi_likely(that->m_psi != NULL))
PSI_RWLOCK_CALL(unlock_rwlock)(that->m_psi);
#endif
result= rw_unlock(&that->m_rwlock);
return result;
}
|
O0
|
c
|
inline_mysql_rwlock_unlock:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x90(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb3a21
leaq 0x217a46(%rip), %rax # 0x2cb450
movq (%rax), %rax
movq 0x168(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x100a20
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
inline_mysql_rwlock_unlock_8:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+90h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_B3A21
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+168h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+90h]
call rax
loc_B3A21:
mov rdi, [rbp+var_8]
call my_rw_unlock
mov [rbp+var_C], eax
mov eax, [rbp+var_C]
add rsp, 10h
pop rbp
retn
|
long long inline_mysql_rwlock_unlock_8(long long a1)
{
if ( *(_QWORD *)(a1 + 144) )
((void ( *)(_QWORD))PSI_server[45])(*(_QWORD *)(a1 + 144));
return (unsigned int)my_rw_unlock(a1);
}
|
inline_mysql_rwlock_unlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x90],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001b3a21
LEA RAX,[0x3cb450]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x168]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x90]
CALL RAX
LAB_001b3a21:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00200a20
MOV dword ptr [RBP + -0xc],EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD RSP,0x10
POP RBP
RET
|
int4 inline_mysql_rwlock_unlock(long param_1)
{
int4 uVar1;
if (*(long *)(param_1 + 0x90) != 0) {
(**(code **)(PSI_server + 0x168))(*(int8 *)(param_1 + 0x90));
}
uVar1 = my_rw_unlock(param_1);
return uVar1;
}
|
|
7,722 |
fct_update_mutex_derived_flags(PFS_mutex*)
|
eloqsql/storage/perfschema/pfs_instr.cc
|
static void fct_update_mutex_derived_flags(PFS_mutex *pfs)
{
PFS_mutex_class *klass= sanitize_mutex_class(pfs->m_class);
if (likely(klass != NULL))
{
pfs->m_enabled= klass->m_enabled && flag_global_instrumentation;
pfs->m_timed= klass->m_timed;
}
else
{
pfs->m_enabled= false;
pfs->m_timed= false;
}
}
|
O0
|
cpp
|
fct_update_mutex_derived_flags(PFS_mutex*):
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x42a30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3aa2a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x4(%rcx)
movb %al, -0x11(%rbp)
je 0x3aa0a
leaq 0x3d15fb(%rip), %rax # 0x40c000
movb (%rax), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
movq -0x10(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
jmp 0x3aa3a
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x5(%rax)
addq $0x20, %rsp
popq %rbp
retq
|
_ZL30fct_update_mutex_derived_flagsP9PFS_mutex:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rdi, [rax+18h]
call _Z20sanitize_mutex_classP15PFS_mutex_class; sanitize_mutex_class(PFS_mutex_class *)
mov [rbp+var_10], rax
cmp [rbp+var_10], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
jz short loc_3AA2A
mov rcx, [rbp+var_10]
xor eax, eax
test byte ptr [rcx+4], 1
mov [rbp+var_11], al
jz short loc_3AA0A
lea rax, flag_global_instrumentation
mov al, [rax]
mov [rbp+var_11], al
loc_3AA0A:
mov cl, [rbp+var_11]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+4], cl
mov rax, [rbp+var_10]
mov cl, [rax+5]
mov rax, [rbp+var_8]
and cl, 1
mov [rax+5], cl
jmp short loc_3AA3A
loc_3AA2A:
mov rax, [rbp+var_8]
mov byte ptr [rax+4], 0
mov rax, [rbp+var_8]
mov byte ptr [rax+5], 0
loc_3AA3A:
add rsp, 20h
pop rbp
retn
|
long long fct_update_mutex_derived_flags(long long a1)
{
long long result; // rax
char v2; // [rsp+Fh] [rbp-11h]
long long v3; // [rsp+10h] [rbp-10h]
v3 = sanitize_mutex_class(*(_QWORD *)(a1 + 24));
if ( v3 )
{
v2 = 0;
if ( (*(_BYTE *)(v3 + 4) & 1) != 0 )
v2 = flag_global_instrumentation;
*(_BYTE *)(a1 + 4) = v2 & 1;
result = a1;
*(_BYTE *)(a1 + 5) = *(_BYTE *)(v3 + 5) & 1;
}
else
{
*(_BYTE *)(a1 + 4) = 0;
result = a1;
*(_BYTE *)(a1 + 5) = 0;
}
return result;
}
|
fct_update_mutex_derived_flags:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00142a30
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RBP + -0x10],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x0013aa2a
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
TEST byte ptr [RCX + 0x4],0x1
MOV byte ptr [RBP + -0x11],AL
JZ 0x0013aa0a
LEA RAX,[0x50c000]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x11],AL
LAB_0013aa0a:
MOV CL,byte ptr [RBP + -0x11]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x4],CL
MOV RAX,qword ptr [RBP + -0x10]
MOV CL,byte ptr [RAX + 0x5]
MOV RAX,qword ptr [RBP + -0x8]
AND CL,0x1
MOV byte ptr [RAX + 0x5],CL
JMP 0x0013aa3a
LAB_0013aa2a:
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x4],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV byte ptr [RAX + 0x5],0x0
LAB_0013aa3a:
ADD RSP,0x20
POP RBP
RET
|
/* fct_update_mutex_derived_flags(PFS_mutex*) */
void fct_update_mutex_derived_flags(PFS_mutex *param_1)
{
long lVar1;
byte local_19;
lVar1 = sanitize_mutex_class(*(PFS_mutex_class **)(param_1 + 0x18));
if (lVar1 == 0) {
param_1[4] = (PFS_mutex)0x0;
param_1[5] = (PFS_mutex)0x0;
}
else {
local_19 = 0;
if ((*(byte *)(lVar1 + 4) & 1) != 0) {
local_19 = flag_global_instrumentation;
}
param_1[4] = (PFS_mutex)(local_19 & 1);
param_1[5] = (PFS_mutex)(*(byte *)(lVar1 + 5) & 1);
}
return;
}
|
|
7,723 |
lo0bits
|
eloqsql/strings/dtoa.c
|
static int lo0bits(ULong *y)
{
register int k;
register ULong x= *y;
if (x & 7)
{
if (x & 1)
return 0;
if (x & 2)
{
*y= x >> 1;
return 1;
}
*y= x >> 2;
return 2;
}
k= 0;
if (!(x & 0xffff))
{
k= 16;
x>>= 16;
}
if (!(x & 0xff))
{
k+= 8;
x>>= 8;
}
if (!(x & 0xf))
{
k+= 4;
x>>= 4;
}
if (!(x & 0x3))
{
k+= 2;
x>>= 2;
}
if (!(x & 1))
{
k++;
x>>= 1;
if (!x)
return 32;
}
*y= x;
return k;
}
|
O3
|
c
|
lo0bits:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %ecx
testb $0x7, %cl
je 0x2c896
xorl %eax, %eax
testb $0x1, %cl
jne 0x2c8fd
testb $0x2, %cl
jne 0x2c8f4
shrl $0x2, %ecx
movl $0x2, %eax
jmp 0x2c8fb
movl %ecx, %eax
shrl $0x10, %eax
xorl %edx, %edx
testl $0xfff8, %ecx # imm = 0xFFF8
cmovnel %ecx, %eax
sete %dl
shll $0x4, %edx
leal 0x8(%rdx), %ecx
movl %eax, %esi
shrl $0x8, %esi
testb %al, %al
cmovnel %edx, %ecx
cmovnel %eax, %esi
leal 0x4(%rcx), %edx
movl %esi, %r8d
shrl $0x4, %r8d
testb $0xf, %sil
cmovnel %ecx, %edx
cmovnel %esi, %r8d
leal 0x2(%rdx), %eax
movl %r8d, %ecx
shrl $0x2, %ecx
testb $0x3, %r8b
cmovnel %edx, %eax
cmovnel %r8d, %ecx
testb $0x1, %cl
jne 0x2c8fb
testl %ecx, %ecx
je 0x2c8ff
incl %eax
shrl %ecx
jmp 0x2c8fb
shrl %ecx
movl $0x1, %eax
movl %ecx, (%rdi)
popq %rbp
retq
movl $0x20, %eax
jmp 0x2c8fd
|
lo0bits:
push rbp
mov rbp, rsp
mov ecx, [rdi]
test cl, 7
jz short loc_2C896
xor eax, eax
test cl, 1
jnz short loc_2C8FD
test cl, 2
jnz short loc_2C8F4
shr ecx, 2
mov eax, 2
jmp short loc_2C8FB
loc_2C896:
mov eax, ecx
shr eax, 10h
xor edx, edx
test ecx, 0FFF8h
cmovnz eax, ecx
setz dl
shl edx, 4
lea ecx, [rdx+8]
mov esi, eax
shr esi, 8
test al, al
cmovnz ecx, edx
cmovnz esi, eax
lea edx, [rcx+4]
mov r8d, esi
shr r8d, 4
test sil, 0Fh
cmovnz edx, ecx
cmovnz r8d, esi
lea eax, [rdx+2]
mov ecx, r8d
shr ecx, 2
test r8b, 3
cmovnz eax, edx
cmovnz ecx, r8d
test cl, 1
jnz short loc_2C8FB
test ecx, ecx
jz short loc_2C8FF
inc eax
shr ecx, 1
jmp short loc_2C8FB
loc_2C8F4:
shr ecx, 1
mov eax, 1
loc_2C8FB:
mov [rdi], ecx
loc_2C8FD:
pop rbp
retn
loc_2C8FF:
mov eax, 20h ; ' '
jmp short loc_2C8FD
|
long long lo0bits(unsigned int *a1)
{
unsigned int v1; // ecx
long long result; // rax
unsigned int v3; // ecx
unsigned int v4; // eax
int v5; // edx
int v6; // edx
int v7; // ecx
unsigned int v8; // esi
unsigned int v9; // edx
unsigned int v10; // r8d
v1 = *a1;
if ( (*a1 & 7) != 0 )
{
result = 0LL;
if ( (v1 & 1) != 0 )
return result;
if ( (v1 & 2) != 0 )
{
v3 = v1 >> 1;
result = 1LL;
}
else
{
v3 = v1 >> 2;
result = 2LL;
}
}
else
{
v4 = HIWORD(v1);
v5 = 0;
if ( (v1 & 0xFFF8) != 0 )
v4 = *a1;
LOBYTE(v5) = (*a1 & 0xFFF8) == 0;
v6 = 16 * v5;
v7 = v6 + 8;
v8 = v4 >> 8;
if ( (_BYTE)v4 )
{
v7 = v6;
v8 = v4;
}
v9 = v7 + 4;
v10 = v8 >> 4;
if ( (v8 & 0xF) != 0 )
{
v9 = v7;
v10 = v8;
}
result = v9 + 2;
v3 = v10 >> 2;
if ( (v10 & 3) != 0 )
{
result = v9;
v3 = v10;
}
if ( (v3 & 1) == 0 )
{
if ( !v3 )
return 32LL;
result = (unsigned int)(result + 1);
v3 >>= 1;
}
}
*a1 = v3;
return result;
}
|
lo0bits:
PUSH RBP
MOV RBP,RSP
MOV ECX,dword ptr [RDI]
TEST CL,0x7
JZ 0x0012c896
XOR EAX,EAX
TEST CL,0x1
JNZ 0x0012c8fd
TEST CL,0x2
JNZ 0x0012c8f4
SHR ECX,0x2
MOV EAX,0x2
JMP 0x0012c8fb
LAB_0012c896:
MOV EAX,ECX
SHR EAX,0x10
XOR EDX,EDX
TEST ECX,0xfff8
CMOVNZ EAX,ECX
SETZ DL
SHL EDX,0x4
LEA ECX,[RDX + 0x8]
MOV ESI,EAX
SHR ESI,0x8
TEST AL,AL
CMOVNZ ECX,EDX
CMOVNZ ESI,EAX
LEA EDX,[RCX + 0x4]
MOV R8D,ESI
SHR R8D,0x4
TEST SIL,0xf
CMOVNZ EDX,ECX
CMOVNZ R8D,ESI
LEA EAX,[RDX + 0x2]
MOV ECX,R8D
SHR ECX,0x2
TEST R8B,0x3
CMOVNZ EAX,EDX
CMOVNZ ECX,R8D
TEST CL,0x1
JNZ 0x0012c8fb
TEST ECX,ECX
JZ 0x0012c8ff
INC EAX
SHR ECX,0x1
JMP 0x0012c8fb
LAB_0012c8f4:
SHR ECX,0x1
MOV EAX,0x1
LAB_0012c8fb:
MOV dword ptr [RDI],ECX
LAB_0012c8fd:
POP RBP
RET
LAB_0012c8ff:
MOV EAX,0x20
JMP 0x0012c8fd
|
int lo0bits(uint *param_1)
{
uint uVar1;
int iVar2;
uint uVar3;
int iVar4;
bool bVar5;
uVar3 = *param_1;
if ((uVar3 & 7) == 0) {
bVar5 = (uVar3 & 0xfff8) == 0;
uVar1 = uVar3 >> 0x10;
if (!bVar5) {
uVar1 = uVar3;
}
iVar4 = (uint)bVar5 * 0x10;
uVar3 = uVar1 >> 8;
iVar2 = iVar4 + 8;
if ((char)uVar1 != '\0') {
uVar3 = uVar1;
iVar2 = iVar4;
}
uVar1 = uVar3 >> 4;
iVar4 = iVar2 + 4;
if ((uVar3 & 0xf) != 0) {
uVar1 = uVar3;
iVar4 = iVar2;
}
uVar3 = uVar1 >> 2;
iVar2 = iVar4 + 2;
if ((uVar1 & 3) != 0) {
uVar3 = uVar1;
iVar2 = iVar4;
}
if ((uVar3 & 1) == 0) {
if (uVar3 == 0) {
return 0x20;
}
iVar2 = iVar2 + 1;
uVar3 = uVar3 >> 1;
}
}
else {
if ((uVar3 & 1) != 0) {
return 0;
}
if ((uVar3 & 2) == 0) {
uVar3 = uVar3 >> 2;
iVar2 = 2;
}
else {
uVar3 = uVar3 >> 1;
iVar2 = 1;
}
}
*param_1 = uVar3;
return iVar2;
}
|
|
7,724 |
minja::Value::to_int() const
|
monkey531[P]llama/common/minja.hpp
|
int64_t to_int() const {
if (is_null()) return 0;
if (is_boolean()) return get<bool>() ? 1 : 0;
if (is_number()) return static_cast<int64_t>(get<double>());
if (is_string()) {
try {
return std::stol(get<std::string>());
} catch (const std::exception &) {
return 0;
}
}
return 0;
}
|
O3
|
cpp
|
minja::Value::to_int() const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
cmpq $0x0, 0x20(%rdi)
movb 0x40(%rdi), %al
jne 0xb1bd0
cmpq $0x0, 0x10(%rsi)
jne 0xb1bd0
testb %al, %al
jne 0xb1bd0
cmpq $0x0, 0x30(%rsi)
jne 0xb1bd0
xorl %ebx, %ebx
jmp 0xb1c72
cmpb $0x4, %al
jne 0xb1be4
movq %rsi, %rdi
callq 0x88006
movzbl %al, %ebx
jmp 0xb1c72
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0xb1bfb
movq %rsi, %rdi
callq 0x8717c
cvttsd2si %xmm0, %rbx
jmp 0xb1c72
cmpb $0x3, %al
jne 0xb1bc9
leaq 0x8(%rsp), %rdi
callq 0x88116
movq 0x8(%rsp), %r15
callq 0x1a060
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x1abf0
cmpq %r15, (%r12)
je 0xb1c82
movq %rax, %rbx
movl (%r14), %eax
testl %eax, %eax
je 0xb1c54
cmpl $0x22, %eax
jne 0xb1c57
leaq 0x3f84a(%rip), %rdi # 0xf1499
callq 0x1ac40
movl %ebp, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1c72
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f810(%rip), %rdi # 0xf1499
callq 0x1a530
movq %rdx, %r15
movq %rax, %rbx
jmp 0xb1cc0
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0xb1ca5
movl %ebp, (%r14)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb1cc0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1a890
movq %rbx, %rdi
cmpl $0x1, %r15d
jne 0xb1cd8
callq 0x1a370
callq 0x1ade0
jmp 0xb1bc9
callq 0x1af20
nop
|
_ZNK5minja5Value6to_intEv:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 30h
mov rsi, rdi
cmp qword ptr [rdi+20h], 0
mov al, [rdi+40h]
jnz short loc_B1BD0
cmp qword ptr [rsi+10h], 0
jnz short loc_B1BD0
test al, al
jnz short loc_B1BD0
cmp qword ptr [rsi+30h], 0
jnz short loc_B1BD0
loc_B1BC9:
xor ebx, ebx
jmp loc_B1C72
loc_B1BD0:
cmp al, 4
jnz short loc_B1BE4
mov rdi, rsi
call _ZNK5minja5Value3getIbEET_v; minja::Value::get<bool>(void)
movzx ebx, al
jmp loc_B1C72
loc_B1BE4:
lea ecx, [rax-5]
cmp cl, 2
ja short loc_B1BFB
mov rdi, rsi
call _ZNK5minja5Value3getIdEET_v; minja::Value::get<double>(void)
cvttsd2si rbx, xmm0
jmp short loc_B1C72
loc_B1BFB:
cmp al, 3
jnz short loc_B1BC9
lea rdi, [rsp+58h+var_50]
call _ZNK5minja5Value3getINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEET_v; minja::Value::get<std::string>(void)
mov r15, [rsp+58h+var_50]
call ___errno_location
mov r14, rax
mov ebp, [rax]
mov dword ptr [rax], 0
lea r12, [rsp+58h+var_30]
mov rdi, r15
mov rsi, r12
mov edx, 0Ah
call _strtol
cmp [r12], r15
jz short loc_B1C82
mov rbx, rax
mov eax, [r14]
test eax, eax
jz short loc_B1C54
cmp eax, 22h ; '"'
jnz short loc_B1C57
lea rdi, aStol; "stol"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
loc_B1C54:
mov [r14], ebp
loc_B1C57:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1C72
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1C72:
mov rax, rbx
add rsp, 30h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_B1C82:
lea rdi, aStol; "stol"
call __ZSt24__throw_invalid_argumentPKc; std::__throw_invalid_argument(char const*)
mov r15, rdx
mov rbx, rax
jmp short loc_B1CC0
mov r15, rdx
mov rbx, rax
cmp dword ptr [r14], 0
jnz short loc_B1CA5
mov [r14], ebp
loc_B1CA5:
lea rax, [rsp+58h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_B1CC0
mov rsi, [rsp+58h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_B1CC0:
mov rdi, rbx; void *
cmp r15d, 1
jnz short loc_B1CD8
call ___cxa_begin_catch
call ___cxa_end_catch
jmp loc_B1BC9
loc_B1CD8:
call __Unwind_Resume
|
long long minja::Value::to_int(minja::Value *this, double a2)
{
char v2; // al
long long v3; // rbx
long long *v4; // r15
int *v5; // r14
int v6; // ebp
long long v7; // rax
void *v9; // rdi
int v10; // edx
long long *v11; // [rsp+8h] [rbp-50h] BYREF
long long v12; // [rsp+18h] [rbp-40h] BYREF
long long *v13; // [rsp+28h] [rbp-30h] BYREF
v2 = *((_BYTE *)this + 64);
if ( !*((_QWORD *)this + 4) && !*((_QWORD *)this + 2) && !v2 && !*((_QWORD *)this + 6) )
return 0LL;
if ( v2 == 4 )
return (unsigned __int8)minja::Value::get<bool>(this);
if ( (unsigned __int8)(v2 - 5) <= 2u )
return (unsigned int)(int)minja::Value::get<double>(this);
if ( v2 != 3 )
return 0LL;
minja::Value::get<std::string>((long long)&v11, this);
v4 = v11;
v5 = (int *)__errno_location(a2);
v6 = *v5;
*v5 = 0;
v7 = strtol(v4, &v13, 10LL);
if ( v13 == v4 )
{
v9 = (void *)std::__throw_invalid_argument("stol");
if ( v10 != 1 )
_Unwind_Resume(v9);
__cxa_begin_catch(v9);
__cxa_end_catch();
return 0LL;
}
v3 = v7;
if ( *v5 )
{
if ( *v5 == 34 )
std::__throw_out_of_range("stol");
}
else
{
*v5 = v6;
}
if ( v11 != &v12 )
operator delete(v11, v12 + 1);
return v3;
}
|
to_int:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV RSI,RDI
CMP qword ptr [RDI + 0x20],0x0
MOV AL,byte ptr [RDI + 0x40]
JNZ 0x001b1bd0
CMP qword ptr [RSI + 0x10],0x0
JNZ 0x001b1bd0
TEST AL,AL
JNZ 0x001b1bd0
CMP qword ptr [RSI + 0x30],0x0
JNZ 0x001b1bd0
LAB_001b1bc9:
XOR EBX,EBX
JMP 0x001b1c72
LAB_001b1bd0:
CMP AL,0x4
JNZ 0x001b1be4
MOV RDI,RSI
CALL 0x00188006
MOVZX EBX,AL
JMP 0x001b1c72
LAB_001b1be4:
LEA ECX,[RAX + -0x5]
CMP CL,0x2
JA 0x001b1bfb
MOV RDI,RSI
CALL 0x0018717c
CVTTSD2SI RBX,XMM0
JMP 0x001b1c72
LAB_001b1bfb:
CMP AL,0x3
JNZ 0x001b1bc9
LAB_001b1bff:
LEA RDI,[RSP + 0x8]
CALL 0x00188116
MOV R15,qword ptr [RSP + 0x8]
CALL 0x0011a060
MOV R14,RAX
MOV EBP,dword ptr [RAX]
MOV dword ptr [RAX],0x0
LEA R12,[RSP + 0x28]
MOV RDI,R15
MOV RSI,R12
MOV EDX,0xa
CALL 0x0011abf0
CMP qword ptr [R12],R15
JZ 0x001b1c82
MOV RBX,RAX
MOV EAX,dword ptr [R14]
TEST EAX,EAX
JZ 0x001b1c54
CMP EAX,0x22
JNZ 0x001b1c57
LAB_001b1c48:
LEA RDI,[0x1f1499]
CALL 0x0011ac40
LAB_001b1c54:
MOV dword ptr [R14],EBP
LAB_001b1c57:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001b1c72
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x0011a890
LAB_001b1c72:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001b1c82:
LEA RDI,[0x1f1499]
CALL 0x0011a530
LAB_001b1c8e:
MOV R15,RDX
MOV RBX,RAX
JMP 0x001b1cc0
LAB_001b1cc0:
MOV RDI,RBX
CMP R15D,0x1
JNZ 0x001b1cd8
CALL 0x0011a370
CALL 0x0011ade0
JMP 0x001b1bc9
LAB_001b1cd8:
CALL 0x0011af20
|
/* minja::Value::to_int() const */
ulong __thiscall minja::Value::to_int(Value *this)
{
Value VVar1;
int iVar2;
bool bVar3;
int *piVar4;
ulong uVar5;
double dVar6;
int1 auVar7 [12];
long *local_50;
long local_40 [2];
long *local_30;
VVar1 = this[0x40];
if ((((*(long *)(this + 0x20) == 0) && (*(long *)(this + 0x10) == 0)) && (VVar1 == (Value)0x0)) &&
(*(long *)(this + 0x30) == 0)) {
return 0;
}
if (VVar1 == (Value)0x4) {
bVar3 = get<bool>(this);
return (ulong)bVar3;
}
if ((byte)((char)VVar1 - 5U) < 3) {
dVar6 = get<double>(this);
return (long)dVar6;
}
if (VVar1 != (Value)0x3) {
return 0;
}
/* try { // try from 001b1bff to 001b1c08 has its CatchHandler @ 001b1c8e */
get<std::__cxx11::string>();
piVar4 = __errno_location();
iVar2 = *piVar4;
*piVar4 = 0;
uVar5 = strtol((char *)local_50,(char **)&local_30,10);
if (local_30 == local_50) {
auVar7 = std::__throw_invalid_argument("stol");
/* catch(type#1 @ 0022e8f0, ) { ... } // from try @ 001b1bff with catch @
001b1c8e */
if (auVar7._8_4_ == 1) {
__cxa_begin_catch();
__cxa_end_catch();
return 0;
}
/* WARNING: Subroutine does not return */
_Unwind_Resume(auVar7._0_8_);
}
if (*piVar4 != 0) {
if (*piVar4 != 0x22) goto LAB_001b1c57;
/* try { // try from 001b1c48 to 001b1c8d has its CatchHandler @ 001b1c96 */
std::__throw_out_of_range("stol");
}
*piVar4 = iVar2;
LAB_001b1c57:
if (local_50 != local_40) {
operator_delete(local_50,local_40[0] + 1);
return uVar5;
}
return uVar5;
}
|
|
7,725 |
print_name
|
eloqsql/mysys/my_getopt.c
|
static uint print_name(const struct my_option *optp)
{
const char *s= optp->name;
for (;*s;s++)
putchar(*s == '_' ? '-' : *s);
return (uint)(s - optp->name);
}
|
O0
|
c
|
print_name:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xf7b16
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0xf7af6
movl $0x2d, %eax
movl %eax, -0x14(%rbp)
jmp 0xf7b00
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x2a8c0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xf7ad7
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
print_name:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov rax, [rax]
mov [rbp+var_10], rax
loc_F7AD7:
mov rax, [rbp+var_10]
cmp byte ptr [rax], 0
jz short loc_F7B16
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
cmp eax, 5Fh ; '_'
jnz short loc_F7AF6
mov eax, 2Dh ; '-'
mov [rbp+var_14], eax
jmp short loc_F7B00
loc_F7AF6:
mov rax, [rbp+var_10]
movsx eax, byte ptr [rax]
mov [rbp+var_14], eax
loc_F7B00:
mov edi, [rbp+var_14]
call _putchar
mov rax, [rbp+var_10]
add rax, 1
mov [rbp+var_10], rax
jmp short loc_F7AD7
loc_F7B16:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_8]
mov rcx, [rcx]
sub rax, rcx
add rsp, 20h
pop rbp
retn
|
long long print_name(_BYTE **a1)
{
unsigned int v2; // [rsp+Ch] [rbp-14h]
_BYTE *i; // [rsp+10h] [rbp-10h]
for ( i = *a1; *i; ++i )
{
if ( *i == 95 )
v2 = 45;
else
v2 = (char)*i;
putchar(v2);
}
return i - *a1;
}
|
print_name:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001f7ad7:
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX],0x0
JZ 0x001f7b16
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x5f
JNZ 0x001f7af6
MOV EAX,0x2d
MOV dword ptr [RBP + -0x14],EAX
JMP 0x001f7b00
LAB_001f7af6:
MOV RAX,qword ptr [RBP + -0x10]
MOVSX EAX,byte ptr [RAX]
MOV dword ptr [RBP + -0x14],EAX
LAB_001f7b00:
MOV EDI,dword ptr [RBP + -0x14]
CALL 0x0012a8c0
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x1
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001f7ad7
LAB_001f7b16:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RCX]
SUB RAX,RCX
ADD RSP,0x20
POP RBP
RET
|
long print_name(long *param_1)
{
int local_1c;
char *local_18;
for (local_18 = (char *)*param_1; *local_18 != '\0'; local_18 = local_18 + 1) {
if (*local_18 == '_') {
local_1c = 0x2d;
}
else {
local_1c = (int)*local_18;
}
putchar(local_1c);
}
return (long)local_18 - *param_1;
}
|
|
7,726 |
my_b_cache_write
|
eloqsql/mysys/mf_iocache.c
|
int _my_b_cache_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
{
if (Buffer != info->write_buffer)
{
Count= IO_ROUND_DN(Count);
if (!Count)
return 0;
}
if (info->seek_not_done)
{
/*
Whenever a function which operates on IO_CACHE flushes/writes
some part of the IO_CACHE to disk it will set the property
"seek_not_done" to indicate this to other functions operating
on the IO_CACHE.
*/
if (mysql_file_seek(info->file, info->pos_in_file, MY_SEEK_SET,
MYF(info->myflags & MY_WME)) == MY_FILEPOS_ERROR)
{
info->error= -1;
return 1;
}
info->seek_not_done=0;
}
if (mysql_file_write(info->file, Buffer, Count, info->myflags | MY_NABP))
return info->error= -1;
info->pos_in_file+= Count;
return 0;
}
|
O0
|
c
|
my_b_cache_write:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0xe2b59
movabsq $0xfffff000, %rax # imm = 0xFFFFF000
andq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe2b57
movl $0x0, -0x4(%rbp)
jmp 0xe2c29
jmp 0xe2b59
movq -0x10(%rbp), %rax
cmpl $0x0, 0xe0(%rax)
je 0xe2bc5
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
andq $0x10, %r9
leaq 0x71618(%rip), %rdi # 0x1541a5
movl $0x5ef, %esi # imm = 0x5EF
xorl %r8d, %r8d
callq 0xe0230
cmpq $-0x1, %rax
jne 0xe2bb7
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0x1, -0x4(%rbp)
jmp 0xe2c29
movq -0x10(%rbp), %rax
movl $0x0, 0xe0(%rax)
movq -0x10(%rbp), %rax
movl 0xd4(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %r9
orq $0x4, %r9
leaq 0x715b8(%rip), %rdi # 0x1541a5
movl $0x5f6, %esi # imm = 0x5F6
callq 0xe1be0
cmpq $0x0, %rax
je 0xe2c14
movq -0x10(%rbp), %rax
movl $0xffffffff, 0xe4(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe2c29
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
_my_b_cache_write:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
cmp rax, [rcx+30h]
jz short loc_E2B59
mov rax, 0FFFFF000h
and rax, [rbp+var_20]
mov [rbp+var_20], rax
cmp [rbp+var_20], 0
jnz short loc_E2B57
mov [rbp+var_4], 0
jmp loc_E2C29
loc_E2B57:
jmp short $+2
loc_E2B59:
mov rax, [rbp+var_10]
cmp dword ptr [rax+0E0h], 0
jz short loc_E2BC5
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rax, [rbp+var_10]
mov rcx, [rax]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
and r9, 10h
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 5EFh
xor r8d, r8d
call inline_mysql_file_seek_6
cmp rax, 0FFFFFFFFFFFFFFFFh
jnz short loc_E2BB7
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 1
jmp short loc_E2C29
loc_E2BB7:
mov rax, [rbp+var_10]
mov dword ptr [rax+0E0h], 0
loc_E2BC5:
mov rax, [rbp+var_10]
mov edx, [rax+0D4h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov rax, [rbp+var_10]
mov r9, [rax+0F8h]
or r9, 4
lea rdi, aWorkspaceLlm4b_35; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 5F6h
call inline_mysql_file_write_3
cmp rax, 0
jz short loc_E2C14
mov rax, [rbp+var_10]
mov dword ptr [rax+0E4h], 0FFFFFFFFh
mov [rbp+var_4], 0FFFFFFFFh
jmp short loc_E2C29
loc_E2C14:
mov rcx, [rbp+var_20]
mov rax, [rbp+var_10]
add rcx, [rax]
mov [rax], rcx
mov [rbp+var_4], 0
loc_E2C29:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long my_b_cache_write(long long a1, long long a2, long long a3)
{
long long v4; // [rsp+0h] [rbp-20h]
v4 = a3;
if ( a2 == *(_QWORD *)(a1 + 48) || (v4 = (unsigned int)a3 & 0xFFFFF000, (a3 & 0xFFFFF000) != 0) )
{
if ( *(_DWORD *)(a1 + 224) )
{
if ( inline_mysql_file_seek_6(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x5EFu,
*(_DWORD *)(a1 + 212),
*(_QWORD *)a1,
0,
*(_QWORD *)(a1 + 248) & 0x10LL) == -1 )
{
*(_DWORD *)(a1 + 228) = -1;
return 1;
}
*(_DWORD *)(a1 + 224) = 0;
}
if ( inline_mysql_file_write_3(
(long long)"/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",
0x5F6u,
*(_DWORD *)(a1 + 212),
a2,
v4,
*(_QWORD *)(a1 + 248) | 4LL) )
{
*(_DWORD *)(a1 + 228) = -1;
return (unsigned int)-1;
}
else
{
*(_QWORD *)a1 += v4;
return 0;
}
}
else
{
return 0;
}
}
|
_my_b_cache_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x30]
JZ 0x001e2b59
MOV RAX,0xfffff000
AND RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x20],RAX
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x001e2b57
MOV dword ptr [RBP + -0x4],0x0
JMP 0x001e2c29
LAB_001e2b57:
JMP 0x001e2b59
LAB_001e2b59:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0xe0],0x0
JZ 0x001e2bc5
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
AND R9,0x10
LEA RDI,[0x2541a5]
MOV ESI,0x5ef
XOR R8D,R8D
CALL 0x001e0230
CMP RAX,-0x1
JNZ 0x001e2bb7
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0x1
JMP 0x001e2c29
LAB_001e2bb7:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe0],0x0
LAB_001e2bc5:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0xd4]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0xf8]
OR R9,0x4
LEA RDI,[0x2541a5]
MOV ESI,0x5f6
CALL 0x001e1be0
CMP RAX,0x0
JZ 0x001e2c14
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0xe4],0xffffffff
MOV dword ptr [RBP + -0x4],0xffffffff
JMP 0x001e2c29
LAB_001e2c14:
MOV RCX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
MOV dword ptr [RBP + -0x4],0x0
LAB_001e2c29:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 _my_b_cache_write(long *param_1,long param_2,ulong param_3)
{
long lVar1;
ulong local_28;
int4 local_c;
local_28 = param_3;
if ((param_2 == param_1[6]) || (local_28 = param_3 & 0xfffff000, local_28 != 0)) {
if ((int)param_1[0x1c] != 0) {
lVar1 = inline_mysql_file_seek
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x5ef,
*(int4 *)((long)param_1 + 0xd4),*param_1,0,param_1[0x1f] & 0x10);
if (lVar1 == -1) {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
return 1;
}
*(int4 *)(param_1 + 0x1c) = 0;
}
lVar1 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/mysys/mf_iocache.c",0x5f6,
*(int4 *)((long)param_1 + 0xd4),param_2,local_28,param_1[0x1f] | 4);
if (lVar1 == 0) {
*param_1 = local_28 + *param_1;
local_c = 0;
}
else {
*(int4 *)((long)param_1 + 0xe4) = 0xffffffff;
local_c = 0xffffffff;
}
}
else {
local_c = 0;
}
return local_c;
}
|
|
7,727 |
process_str_arg
|
eloqsql/strings/my_vsnprintf.c
|
static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
}
|
O3
|
c
|
process_str_arg:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r15
movq %rdi, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq %rdx, %r14
movq %rsi, -0x38(%rbp)
subq %rsi, %r14
leaq 0x1(%r14), %rbx
movq %rcx, %r13
negq %r13
movq %rcx, -0x40(%rbp)
cmovsq %rcx, %r13
testq %r9, %r9
leaq 0x56ec(%rip), %r12 # 0x62d2e
cmovneq %r9, %r12
cmpb $0x0, 0x18(%rbp)
je 0x5d68a
leaq 0x1(%r15), %rsi
movq %r12, %rdi
callq 0x24540
cmpq %r15, %rax
movq %r15, %rdx
cmovbq %rax, %rdx
cmpq %rdx, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movl $0x0, -0x2c(%rbp)
cmpq %rdx, %rax
movq %r13, -0x48(%rbp)
jbe 0x5d6bb
cmpq $0x2, %rdx
ja 0x5d6b0
movl %edx, -0x2c(%rbp)
xorl %edx, %edx
jmp 0x5d6bb
movq %r12, %rdi
movq %r15, %rsi
callq 0x24540
movq %rax, %rdx
cmpq %rax, %rbx
cmovbeq %r14, %rdx
cmovbeq %r14, %r13
movq %r13, -0x48(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x5d6bb
addq $-0x3, %rdx
movl $0x3, -0x2c(%rbp)
addq %r12, %rdx
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
leaq -0x70(%rbp), %rbx
movq %r12, %rsi
movq %r15, %rcx
movq %rbx, %r8
callq *0xc8(%rax)
movq (%rbx), %r13
subq %r12, %r13
movl 0x10(%rbp), %eax
testb $0x8, %al
jne 0x5d723
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
js 0x5d7f6
movl -0x2c(%rbp), %r14d
movl %r14d, %eax
addq %r13, %rax
movq -0x48(%rbp), %rsi
subq %rax, %rsi
jbe 0x5d800
movq -0x38(%rbp), %rdi
movl $0x20, %edx
callq 0x5df44
movq %rax, %rdi
jmp 0x5d804
movl -0x2c(%rbp), %eax
addq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
cmpq %r13, %r14
jbe 0x5d880
movq -0x38(%rbp), %rax
leaq 0x1(%rax), %r15
movb $0x60, (%rax)
testq %r13, %r13
jle 0x5d82f
addq %r12, %r13
xorl %r14d, %r14d
cmpl $0x0, -0x2c(%rbp)
je 0x5d786
movl %r14d, %eax
movq %r15, -0x70(%rbp,%rax,8)
movl %r14d, %eax
incl %eax
movl $0xaaaaaaab, %ecx # imm = 0xAAAAAAAB
imulq %rcx, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
negl %eax
addl %eax, %r14d
incl %r14d
movb (%r12), %bl
movq -0x58(%rbp), %rdi
movq 0xb8(%rdi), %rax
movq %r12, %rsi
movq %r13, %rdx
callq *0xc0(%rax)
cmpl $0x2, %eax
movl $0x1, %ecx
cmovll %ecx, %eax
jge 0x5d7c7
cmpb $0x60, %bl
jne 0x5d7c7
leaq 0x1(%r15), %rdi
cmpq -0x50(%rbp), %rdi
jae 0x5d880
movb $0x60, (%r15)
jmp 0x5d7ca
movq %r15, %rdi
movl %eax, %ebx
leaq (%rdi,%rbx), %rax
cmpq -0x50(%rbp), %rax
jae 0x5d880
movq %r12, %rsi
movq %rbx, %rdx
callq 0x5dfa4
movq %rax, %r15
addq %rbx, %r12
cmpq %r13, %r12
jb 0x5d75b
jmp 0x5d832
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %r14d
jmp 0x5d804
movq -0x38(%rbp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x5dfa4
movq %rax, %r15
testl %r14d, %r14d
je 0x5d894
movl %r14d, %r14d
movq %r15, %rdi
movq %r14, %rsi
movl $0x2e, %edx
callq 0x5df44
movq %rax, %r15
jmp 0x5d897
xorl %r14d, %r14d
leaq 0x1(%r15), %rax
cmpq -0x50(%rbp), %rax
jae 0x5d880
cmpl $0x0, -0x2c(%rbp)
je 0x5d8e2
subl $0x1, %r14d
movl $0x2, %eax
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %rdx
testq %rdx, %rdx
je 0x5d880
movl $0x1, %ecx
subl $0x1, %r14d
cmovbl %eax, %r14d
movq -0x70(%rbp,%r14,8), %r15
testq %r15, %r15
je 0x5d8ca
incl %ecx
movq %r15, %rdx
cmpl $0x3, %ecx
jne 0x5d862
jmp 0x5d8cd
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq %rax, %r15
movq -0x40(%rbp), %rbx
movq %r15, %r13
subq %rax, %r13
xorl %r14d, %r14d
testq %rbx, %rbx
jns 0x5d8b8
addq %r14, %r13
movq -0x48(%rbp), %rsi
subq %r13, %rsi
jbe 0x5d8b8
movq %r15, %rdi
movl $0x20, %edx
callq 0x5df44
movq %rax, %r15
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movl %ecx, %ebx
movq %r15, %rdi
movl $0x2e, %esi
movq %rbx, %rdx
callq 0x24180
addq %rbx, %r15
movb $0x60, (%r15)
incq %r15
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %rax
jmp 0x5d88e
|
process_str_arg:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, r8
mov [rbp+var_58], rdi
mov [rbp+var_50], rdx
mov r14, rdx
mov [rbp+var_38], rsi
sub r14, rsi
lea rbx, [r14+1]
mov r13, rcx
neg r13
mov [rbp+var_40], rcx
cmovs r13, rcx
test r9, r9
lea r12, aNull; "(null)"
cmovnz r12, r9
cmp [rbp+arg_8], 0
jz short loc_5D68A
lea rsi, [r15+1]
mov rdi, r12
call _strnlen
cmp rax, r15
mov rdx, r15
cmovb rdx, rax
cmp rbx, rdx
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_2C], 0
cmp rax, rdx
mov [rbp+var_48], r13
jbe short loc_5D6BB
cmp rdx, 2
ja short loc_5D6B0
mov [rbp+var_2C], edx
xor edx, edx
jmp short loc_5D6BB
loc_5D68A:
mov rdi, r12
mov rsi, r15
call _strnlen
mov rdx, rax
cmp rbx, rax
cmovbe rdx, r14
cmovbe r13, r14
mov [rbp+var_48], r13
mov [rbp+var_2C], 0
jmp short loc_5D6BB
loc_5D6B0:
add rdx, 0FFFFFFFFFFFFFFFDh
mov [rbp+var_2C], 3
loc_5D6BB:
add rdx, r12
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
lea rbx, [rbp+var_70]
mov rsi, r12
mov rcx, r15
mov r8, rbx
call qword ptr [rax+0C8h]
mov r13, [rbx]
sub r13, r12
mov eax, [rbp+arg_0]
test al, 8
jnz short loc_5D723
mov rbx, [rbp+var_40]
test rbx, rbx
js loc_5D7F6
mov r14d, [rbp+var_2C]
mov eax, r14d
add rax, r13
mov rsi, [rbp+var_48]
sub rsi, rax
jbe loc_5D800
mov rdi, [rbp+var_38]
mov edx, 20h ; ' '
call strfill
mov rdi, rax
jmp loc_5D804
loc_5D723:
mov eax, [rbp+var_2C]
add r13, rax
xorps xmm0, xmm0
movaps [rbp+var_70], xmm0
mov [rbp+var_60], 0
cmp r14, r13
jbe loc_5D880
mov rax, [rbp+var_38]
lea r15, [rax+1]
mov byte ptr [rax], 60h ; '`'
test r13, r13
jle loc_5D82F
add r13, r12
xor r14d, r14d
loc_5D75B:
cmp [rbp+var_2C], 0
jz short loc_5D786
mov eax, r14d
mov qword ptr [rbp+rax*8+var_70], r15
mov eax, r14d
inc eax
mov ecx, 0AAAAAAABh
imul rax, rcx
shr rax, 21h
lea eax, [rax+rax*2]
neg eax
add r14d, eax
inc r14d
loc_5D786:
mov bl, [r12]
mov rdi, [rbp+var_58]
mov rax, [rdi+0B8h]
mov rsi, r12
mov rdx, r13
call qword ptr [rax+0C0h]
cmp eax, 2
mov ecx, 1
cmovl eax, ecx
jge short loc_5D7C7
cmp bl, 60h ; '`'
jnz short loc_5D7C7
lea rdi, [r15+1]
cmp rdi, [rbp+var_50]
jnb loc_5D880
mov byte ptr [r15], 60h ; '`'
jmp short loc_5D7CA
loc_5D7C7:
mov rdi, r15
loc_5D7CA:
mov ebx, eax
lea rax, [rdi+rbx]
cmp rax, [rbp+var_50]
jnb loc_5D880
mov rsi, r12
mov rdx, rbx
call strnmov
mov r15, rax
add r12, rbx
cmp r12, r13
jb loc_5D75B
jmp short loc_5D832
loc_5D7F6:
mov rdi, [rbp+var_38]
mov r14d, [rbp+var_2C]
jmp short loc_5D804
loc_5D800:
mov rdi, [rbp+var_38]
loc_5D804:
mov rsi, r12
mov rdx, r13
call strnmov
mov r15, rax
test r14d, r14d
jz short loc_5D894
mov r14d, r14d
mov rdi, r15
mov rsi, r14
mov edx, 2Eh ; '.'
call strfill
mov r15, rax
jmp short loc_5D897
loc_5D82F:
xor r14d, r14d
loc_5D832:
lea rax, [r15+1]
cmp rax, [rbp+var_50]
jnb short loc_5D880
cmp [rbp+var_2C], 0
jz loc_5D8E2
sub r14d, 1
mov eax, 2
cmovb r14d, eax
mov rdx, qword ptr [rbp+r14*8+var_70]
test rdx, rdx
jz short loc_5D880
mov ecx, 1
loc_5D862:
sub r14d, 1
cmovb r14d, eax
mov r15, qword ptr [rbp+r14*8+var_70]
test r15, r15
jz short loc_5D8CA
inc ecx
mov rdx, r15
cmp ecx, 3
jnz short loc_5D862
jmp short loc_5D8CD
loc_5D880:
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov r15, rax
mov rbx, [rbp+var_40]
loc_5D88E:
mov r13, r15
sub r13, rax
loc_5D894:
xor r14d, r14d
loc_5D897:
test rbx, rbx
jns short loc_5D8B8
add r13, r14
mov rsi, [rbp+var_48]
sub rsi, r13
jbe short loc_5D8B8
mov rdi, r15
mov edx, 20h ; ' '
call strfill
mov r15, rax
loc_5D8B8:
mov rax, r15
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_5D8CA:
mov r15, rdx
loc_5D8CD:
mov ebx, ecx
mov rdi, r15
mov esi, 2Eh ; '.'
mov rdx, rbx
call _memset
add r15, rbx
loc_5D8E2:
mov byte ptr [r15], 60h ; '`'
inc r15
mov rbx, [rbp+var_40]
mov rax, [rbp+var_38]
jmp short loc_5D88E
|
long long process_str_arg(
long long a1,
_BYTE *a2,
unsigned long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
unsigned long long v9; // r14
unsigned long long v10; // rbx
long long v11; // r13
const char *v12; // r12
unsigned long long v13; // rax
unsigned long long v14; // rdx
long long v15; // rcx
long long v16; // r8
long long v17; // r9
long long v18; // r13
long long v19; // rbx
long long v20; // r14
unsigned long long v21; // rax
long long v22; // rdi
long long v23; // r13
_BYTE *v24; // r15
const char *v25; // r13
unsigned int v26; // r14d
char v27; // bl
unsigned int v28; // eax
_BYTE *v29; // rdi
long long v30; // rbx
long long v31; // rax
long long v32; // r15
bool v33; // cf
long long v34; // r14
long long v35; // rdx
unsigned int v36; // ecx
long long v37; // r15
_BYTE *v38; // rax
unsigned long long v39; // r13
long long v41; // rbx
__int128 v42; // [rsp+0h] [rbp-70h] BYREF
long long v43; // [rsp+10h] [rbp-60h]
long long v44; // [rsp+18h] [rbp-58h]
unsigned long long v45; // [rsp+20h] [rbp-50h]
unsigned long long v46; // [rsp+28h] [rbp-48h]
long long v47; // [rsp+30h] [rbp-40h]
_BYTE *v48; // [rsp+38h] [rbp-38h]
unsigned int v49; // [rsp+44h] [rbp-2Ch]
v44 = a1;
v45 = a3;
v48 = a2;
v9 = a3 - (_QWORD)a2;
v10 = a3 - (_QWORD)a2 + 1;
v11 = -a4;
v47 = a4;
if ( a4 > 0 )
v11 = a4;
v12 = "(null)";
if ( a6 )
v12 = a6;
if ( a8 )
{
v13 = strnlen(v12, a5 + 1);
v14 = a5;
if ( v13 < a5 )
v14 = v13;
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v49 = 0;
v46 = v11;
if ( v13 > v14 )
{
if ( v14 > 2 )
{
v14 -= 3LL;
v49 = 3;
}
else
{
v49 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v12, a5);
if ( v10 <= v14 )
{
v14 = v9;
v11 = v9;
}
v46 = v11;
v49 = 0;
}
(*(void ( **)(long long, const char *, const char *, unsigned long long, __int128 *))(*(_QWORD *)(v44 + 184)
+ 200LL))(
v44,
v12,
&v12[v14],
a5,
&v42);
v18 = v42 - (_QWORD)v12;
if ( (a7 & 8) != 0 )
{
v23 = v49 + v18;
v42 = 0LL;
v43 = 0LL;
if ( v9 > v23 )
{
v24 = v48 + 1;
*v48 = 96;
if ( v23 > 0 )
{
v25 = &v12[v23];
v26 = 0;
while ( 1 )
{
if ( v49 )
{
*((_QWORD *)&v42 + v26) = v24;
v15 = 2863311531LL;
v26 += -3 * ((v26 + 1) / 3) + 1;
}
v27 = *v12;
v28 = (*(long long ( **)(long long, const char *, const char *, long long, long long, long long, _QWORD, _QWORD, long long))(*(_QWORD *)(v44 + 184) + 192LL))(
v44,
v12,
v25,
v15,
v16,
v17,
v42,
*((_QWORD *)&v42 + 1),
v43);
if ( (int)v28 < 2 && (v28 = 1, v27 == 96) )
{
v29 = v24 + 1;
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
*v24 = 96;
}
else
{
v29 = v24;
}
v30 = v28;
if ( (unsigned long long)&v29[v28] >= v45 )
goto LABEL_50;
v24 = (_BYTE *)strnmov(v29, v12, v28);
v12 += v30;
if ( v12 >= v25 )
goto LABEL_39;
}
}
v26 = 0;
LABEL_39:
if ( (unsigned long long)(v24 + 1) >= v45 )
goto LABEL_50;
if ( !v49 )
{
LABEL_59:
*v24 = 96;
v32 = (long long)(v24 + 1);
v19 = v47;
v38 = v48;
goto LABEL_51;
}
v33 = v26 == 0;
v34 = v26 - 1;
if ( v33 )
v34 = 2LL;
v35 = *((_QWORD *)&v42 + v34);
if ( v35 )
{
v36 = 1;
while ( 1 )
{
v33 = (_DWORD)v34 == 0;
v34 = (unsigned int)(v34 - 1);
if ( v33 )
v34 = 2LL;
v37 = *((_QWORD *)&v42 + v34);
if ( !v37 )
break;
++v36;
v35 = *((_QWORD *)&v42 + v34);
if ( v36 == 3 )
goto LABEL_58;
}
v37 = v35;
LABEL_58:
v41 = v36;
memset(v37, 46LL, v36);
v24 = (_BYTE *)(v41 + v37);
goto LABEL_59;
}
}
LABEL_50:
v38 = v48;
*v48 = 0;
v32 = (long long)v38;
v19 = v47;
LABEL_51:
v18 = v32 - (_QWORD)v38;
LABEL_52:
v20 = 0LL;
goto LABEL_53;
}
v19 = v47;
if ( v47 < 0 )
{
v22 = (long long)v48;
LODWORD(v20) = v49;
}
else
{
LODWORD(v20) = v49;
v21 = v18 + v49;
if ( v46 <= v21 )
v22 = (long long)v48;
else
v22 = strfill(v48, v46 - v21, 32LL);
}
v31 = strnmov(v22, v12, v18);
v32 = v31;
if ( !(_DWORD)v20 )
goto LABEL_52;
v20 = (unsigned int)v20;
v32 = strfill(v31, (unsigned int)v20, 46LL);
LABEL_53:
if ( v19 < 0 )
{
v39 = v20 + v18;
if ( v46 > v39 )
return strfill(v32, v46 - v39, 32LL);
}
return v32;
}
|
process_str_arg:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,R8
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x50],RDX
MOV R14,RDX
MOV qword ptr [RBP + -0x38],RSI
SUB R14,RSI
LEA RBX,[R14 + 0x1]
MOV R13,RCX
NEG R13
MOV qword ptr [RBP + -0x40],RCX
CMOVS R13,RCX
TEST R9,R9
LEA R12,[0x162d2e]
CMOVNZ R12,R9
CMP byte ptr [RBP + 0x18],0x0
JZ 0x0015d68a
LEA RSI,[R15 + 0x1]
MOV RDI,R12
CALL 0x00124540
CMP RAX,R15
MOV RDX,R15
CMOVC RDX,RAX
CMP RBX,RDX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV dword ptr [RBP + -0x2c],0x0
CMP RAX,RDX
MOV qword ptr [RBP + -0x48],R13
JBE 0x0015d6bb
CMP RDX,0x2
JA 0x0015d6b0
MOV dword ptr [RBP + -0x2c],EDX
XOR EDX,EDX
JMP 0x0015d6bb
LAB_0015d68a:
MOV RDI,R12
MOV RSI,R15
CALL 0x00124540
MOV RDX,RAX
CMP RBX,RAX
CMOVBE RDX,R14
CMOVBE R13,R14
MOV qword ptr [RBP + -0x48],R13
MOV dword ptr [RBP + -0x2c],0x0
JMP 0x0015d6bb
LAB_0015d6b0:
ADD RDX,-0x3
MOV dword ptr [RBP + -0x2c],0x3
LAB_0015d6bb:
ADD RDX,R12
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
LEA RBX,[RBP + -0x70]
MOV RSI,R12
MOV RCX,R15
MOV R8,RBX
CALL qword ptr [RAX + 0xc8]
MOV R13,qword ptr [RBX]
SUB R13,R12
MOV EAX,dword ptr [RBP + 0x10]
TEST AL,0x8
JNZ 0x0015d723
MOV RBX,qword ptr [RBP + -0x40]
TEST RBX,RBX
JS 0x0015d7f6
MOV R14D,dword ptr [RBP + -0x2c]
MOV EAX,R14D
ADD RAX,R13
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,RAX
JBE 0x0015d800
MOV RDI,qword ptr [RBP + -0x38]
MOV EDX,0x20
CALL 0x0015df44
MOV RDI,RAX
JMP 0x0015d804
LAB_0015d723:
MOV EAX,dword ptr [RBP + -0x2c]
ADD R13,RAX
XORPS XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x70],XMM0
MOV qword ptr [RBP + -0x60],0x0
CMP R14,R13
JBE 0x0015d880
MOV RAX,qword ptr [RBP + -0x38]
LEA R15,[RAX + 0x1]
MOV byte ptr [RAX],0x60
TEST R13,R13
JLE 0x0015d82f
ADD R13,R12
XOR R14D,R14D
LAB_0015d75b:
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0015d786
MOV EAX,R14D
MOV qword ptr [RBP + RAX*0x8 + -0x70],R15
MOV EAX,R14D
INC EAX
MOV ECX,0xaaaaaaab
IMUL RAX,RCX
SHR RAX,0x21
LEA EAX,[RAX + RAX*0x2]
NEG EAX
ADD R14D,EAX
INC R14D
LAB_0015d786:
MOV BL,byte ptr [R12]
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RDI + 0xb8]
MOV RSI,R12
MOV RDX,R13
CALL qword ptr [RAX + 0xc0]
CMP EAX,0x2
MOV ECX,0x1
CMOVL EAX,ECX
JGE 0x0015d7c7
CMP BL,0x60
JNZ 0x0015d7c7
LEA RDI,[R15 + 0x1]
CMP RDI,qword ptr [RBP + -0x50]
JNC 0x0015d880
MOV byte ptr [R15],0x60
JMP 0x0015d7ca
LAB_0015d7c7:
MOV RDI,R15
LAB_0015d7ca:
MOV EBX,EAX
LEA RAX,[RDI + RBX*0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0015d880
MOV RSI,R12
MOV RDX,RBX
CALL 0x0015dfa4
MOV R15,RAX
ADD R12,RBX
CMP R12,R13
JC 0x0015d75b
JMP 0x0015d832
LAB_0015d7f6:
MOV RDI,qword ptr [RBP + -0x38]
MOV R14D,dword ptr [RBP + -0x2c]
JMP 0x0015d804
LAB_0015d800:
MOV RDI,qword ptr [RBP + -0x38]
LAB_0015d804:
MOV RSI,R12
MOV RDX,R13
CALL 0x0015dfa4
MOV R15,RAX
TEST R14D,R14D
JZ 0x0015d894
MOV R14D,R14D
MOV RDI,R15
MOV RSI,R14
MOV EDX,0x2e
CALL 0x0015df44
MOV R15,RAX
JMP 0x0015d897
LAB_0015d82f:
XOR R14D,R14D
LAB_0015d832:
LEA RAX,[R15 + 0x1]
CMP RAX,qword ptr [RBP + -0x50]
JNC 0x0015d880
CMP dword ptr [RBP + -0x2c],0x0
JZ 0x0015d8e2
SUB R14D,0x1
MOV EAX,0x2
CMOVC R14D,EAX
MOV RDX,qword ptr [RBP + R14*0x8 + -0x70]
TEST RDX,RDX
JZ 0x0015d880
MOV ECX,0x1
LAB_0015d862:
SUB R14D,0x1
CMOVC R14D,EAX
MOV R15,qword ptr [RBP + R14*0x8 + -0x70]
TEST R15,R15
JZ 0x0015d8ca
INC ECX
MOV RDX,R15
CMP ECX,0x3
JNZ 0x0015d862
JMP 0x0015d8cd
LAB_0015d880:
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV R15,RAX
MOV RBX,qword ptr [RBP + -0x40]
LAB_0015d88e:
MOV R13,R15
SUB R13,RAX
LAB_0015d894:
XOR R14D,R14D
LAB_0015d897:
TEST RBX,RBX
JNS 0x0015d8b8
ADD R13,R14
MOV RSI,qword ptr [RBP + -0x48]
SUB RSI,R13
JBE 0x0015d8b8
MOV RDI,R15
MOV EDX,0x20
CALL 0x0015df44
MOV R15,RAX
LAB_0015d8b8:
MOV RAX,R15
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0015d8ca:
MOV R15,RDX
LAB_0015d8cd:
MOV EBX,ECX
MOV RDI,R15
MOV ESI,0x2e
MOV RDX,RBX
CALL 0x00124180
ADD R15,RBX
LAB_0015d8e2:
MOV byte ptr [R15],0x60
INC R15
MOV RBX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x38]
JMP 0x0015d88e
|
int1 *
process_str_arg(long param_1,int1 *param_2,int1 *param_3,ulong param_4,ulong param_5,
char *param_6,uint param_7,char param_8)
{
char cVar1;
void *pvVar2;
uint uVar3;
uint uVar4;
size_t sVar5;
int1 *puVar6;
void *__s;
long lVar7;
char *__string;
long lVar8;
ulong uVar9;
char *pcVar10;
int iVar11;
ulong uVar12;
long local_78 [4];
int1 *local_58;
ulong local_50;
ulong local_48;
int1 *local_40;
uint local_34;
uVar12 = (long)param_3 - (long)param_2;
local_50 = -param_4;
if (0 < (long)param_4) {
local_50 = param_4;
}
__string = "(null)";
if (param_6 != (char *)0x0) {
__string = param_6;
}
local_78[3] = param_1;
local_58 = param_3;
local_48 = param_4;
local_40 = param_2;
if (param_8 == '\0') {
uVar9 = strnlen(__string,param_5);
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
}
else {
sVar5 = strnlen(__string,param_5 + 1);
uVar9 = param_5;
if (sVar5 < param_5) {
uVar9 = sVar5;
}
if (uVar12 + 1 <= uVar9) {
local_50 = uVar12;
uVar9 = uVar12;
}
local_34 = 0;
if (uVar9 < sVar5) {
if (uVar9 < 3) {
local_34 = (uint)uVar9;
uVar9 = 0;
}
else {
uVar9 = uVar9 - 3;
local_34 = 3;
}
}
}
(**(code **)(*(long *)(local_78[3] + 0xb8) + 200))
(local_78[3],__string,__string + uVar9,param_5,local_78);
uVar4 = local_34;
uVar9 = local_48;
lVar8 = local_78[0] - (long)__string;
if ((param_7 & 8) == 0) {
puVar6 = local_40;
if ((-1 < (long)local_48) &&
(lVar7 = local_50 - ((ulong)local_34 + lVar8),
(ulong)local_34 + lVar8 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(local_40,lVar7,0x20);
}
uVar12 = (ulong)uVar4;
puVar6 = (int1 *)strnmov(puVar6,__string,lVar8);
if (uVar4 != 0) {
puVar6 = (int1 *)strfill(puVar6,uVar12,0x2e);
goto LAB_0015d897;
}
}
else {
uVar9 = lVar8 + (ulong)local_34;
local_78[0] = 0;
local_78[1] = 0;
local_78[2] = 0;
if (uVar9 < uVar12) {
puVar6 = local_40 + 1;
*local_40 = 0x60;
if ((long)uVar9 < 1) {
iVar11 = 0;
}
else {
pcVar10 = __string + uVar9;
uVar12 = 0;
do {
if (local_34 != 0) {
local_78[uVar12] = (long)puVar6;
uVar12 = (ulong)((int)uVar12 + (((int)uVar12 + 1U) / 3) * -3 + 1);
}
iVar11 = (int)uVar12;
cVar1 = *__string;
uVar4 = (**(code **)(*(long *)(local_78[3] + 0xb8) + 0xc0))(local_78[3],__string,pcVar10);
if (((int)uVar4 < 2) && (uVar4 = 1, cVar1 == '`')) {
if (local_58 <= puVar6 + 1) goto LAB_0015d880;
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
uVar9 = (ulong)uVar4;
if (local_58 <= puVar6 + uVar9) goto LAB_0015d880;
puVar6 = (int1 *)strnmov(puVar6,__string,uVar9);
__string = __string + uVar9;
} while (__string < pcVar10);
}
if (local_58 <= puVar6 + 1) goto LAB_0015d880;
if (local_34 != 0) {
uVar4 = iVar11 - 1;
if (iVar11 == 0) {
uVar4 = 2;
}
uVar12 = (ulong)uVar4;
if ((void *)local_78[uVar12] == (void *)0x0) goto LAB_0015d880;
uVar4 = 1;
__s = (void *)local_78[uVar12];
do {
uVar3 = (int)uVar12 - 1;
if ((int)uVar12 == 0) {
uVar3 = 2;
}
uVar12 = (ulong)uVar3;
pvVar2 = (void *)local_78[uVar12];
} while ((pvVar2 != (void *)0x0) && (uVar4 = uVar4 + 1, __s = pvVar2, uVar4 != 3));
memset(__s,0x2e,(ulong)uVar4);
puVar6 = (int1 *)((long)__s + (ulong)uVar4);
}
*puVar6 = 0x60;
puVar6 = puVar6 + 1;
}
else {
LAB_0015d880:
*local_40 = 0;
puVar6 = local_40;
}
lVar8 = (long)puVar6 - (long)local_40;
uVar9 = local_48;
}
uVar12 = 0;
LAB_0015d897:
if (((long)uVar9 < 0) &&
(lVar7 = local_50 - (lVar8 + uVar12), lVar8 + uVar12 <= local_50 && lVar7 != 0)) {
puVar6 = (int1 *)strfill(puVar6,lVar7,0x20);
}
return puVar6;
}
|
|
7,728 |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
AlayaLite/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really want to get their impl back when
// they call GetDescriber().
// We use std::get on a tuple as a workaround of not having `if constexpr`.
return std::get<(
std::is_convertible<decltype(&P::Get(m)),
const MatcherDescriberInterface*>::value
? 1
: 0)>(std::make_tuple(&m, &P::Get(m)));
}
|
O3
|
c
|
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&):
movq %rdi, %rax
retq
|
_ZN7testing8internal11MatcherBaseIRKSt17basic_string_viewIcSt11char_traitsIcEEE16GetDescriberImplINS8_11ValuePolicyINS0_9EqMatcherINSt7__cxx1112basic_stringIcS4_SaIcEEEEELb0EEEEEPKNS_25MatcherDescriberInterfaceERKS8_:
mov rax, rdi
retn
|
long long testing::internal::MatcherBase<std::string_view const&>::GetDescriberImpl<testing::internal::MatcherBase<std::string_view const&>::ValuePolicy<testing::internal::EqMatcher<std::string>,false>>(
long long a1)
{
return a1;
}
|
GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>:
MOV RAX,RDI
RET
|
/* testing::MatcherDescriberInterface const*
testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
const&>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,
std::char_traits<char> > const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string
>, false> >(testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char> >
const&> const&) */
MatcherDescriberInterface *
testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::
GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char,std::char_traits<char>>const&>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::string>,false>>
(MatcherBase *param_1)
{
return (MatcherDescriberInterface *)param_1;
}
|
|
7,729 |
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>::empty() const
|
monkey531[P]llama/common/json.hpp
|
bool empty() const noexcept
{
switch (m_data.m_type)
{
case value_t::null:
{
// null values are empty
return true;
}
case value_t::array:
{
// delegate call to array_t::empty()
return m_data.m_value.array->empty();
}
case value_t::object:
{
// delegate call to object_t::empty()
return m_data.m_value.object->empty();
}
case value_t::string:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::binary:
case value_t::discarded:
default:
{
// all other types are nonempty
return false;
}
}
}
|
O1
|
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>::empty() const:
movzbl (%rdi), %eax
testl %eax, %eax
je 0xc71c8
cmpl $0x1, %eax
je 0xc71b9
cmpl $0x2, %eax
jne 0xc71cb
movq 0x8(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
sete %al
retq
movb $0x1, %al
retq
xorl %eax, %eax
retq
|
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE5emptyEv:
movzx eax, byte ptr [rdi]
test eax, eax
jz short loc_C71C8
cmp eax, 1
jz short loc_C71B9
cmp eax, 2
jnz short loc_C71CB
loc_C71B9:
mov rax, [rdi+8]
mov rcx, [rax]
cmp rcx, [rax+8]
setz al
retn
loc_C71C8:
mov al, 1
retn
loc_C71CB:
xor eax, eax
retn
|
bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::empty(
unsigned __int8 *a1)
{
int v1; // eax
v1 = *a1;
if ( !*a1 )
return 1;
if ( v1 == 1 || v1 == 2 )
return **((_QWORD **)a1 + 1) == *(_QWORD *)(*((_QWORD *)a1 + 1) + 8LL);
return 0;
}
|
empty:
MOVZX EAX,byte ptr [RDI]
TEST EAX,EAX
JZ 0x001c71c8
CMP EAX,0x1
JZ 0x001c71b9
CMP EAX,0x2
JNZ 0x001c71cb
LAB_001c71b9:
MOV RAX,qword ptr [RDI + 0x8]
MOV RCX,qword ptr [RAX]
CMP RCX,qword ptr [RAX + 0x8]
SETZ AL
RET
LAB_001c71c8:
MOV AL,0x1
RET
LAB_001c71cb:
XOR EAX,EAX
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>::empty() const */
int8 __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::empty(basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this)
{
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
bVar1;
long *plVar2;
bVar1 = *this;
if (bVar1 == (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
)0x0) {
return 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>
)0x1) &&
(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)) {
return 0;
}
plVar2 = *(long **)(this + 8);
return CONCAT71((int7)((ulong)plVar2 >> 8),*plVar2 == plVar2[1]);
}
|
|
7,730 |
ma_get_bitmap_description
|
eloqsql/storage/maria/ma_bitmap.c
|
size_t _ma_get_bitmap_description(MARIA_FILE_BITMAP *bitmap,
uchar *bitmap_data,
pgcache_page_no_t page,
char *out)
{
uchar *pos, *end;
size_t count=0, dot_printed= 0, len;
char buff[80], last[80];
page++;
last[0]=0;
for (pos= bitmap_data, end= pos+ bitmap->used_size ; pos < end ; pos+= 6)
{
ulonglong bits= uint6korr(pos); /* 6 bytes = 6*8/3= 16 patterns */
uint i;
for (i= 0; i < 16 ; i++, bits>>= 3)
{
if (count > 60)
{
if (memcmp(buff, last, count))
{
memcpy(last, buff, count);
len= sprintf(out, "%8lu: ", (ulong) (page - count));
memcpy(out+len, buff, count);
out+= len + count + 1;
out[-1]= '\n';
dot_printed= 0;
}
else if (!(dot_printed++))
{
out= strmov(out, "...\n");
}
count= 0;
}
buff[count++]= '0' + (uint) (bits & 7);
page++;
}
}
len= sprintf(out, "%8lu: ", (ulong) (page - count));
memcpy(out+len, buff, count);
out[len + count]= '\n';
out[len + count + 1]= 0;
return len + count + 1;
}
|
O3
|
c
|
ma_get_bitmap_description:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, -0xd8(%rbp)
movq %rdx, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
incq %r14
movb $0x0, -0xd0(%rbp)
movl 0x24(%rdi), %eax
testq %rax, %rax
je 0x4045a
addq %rsi, %rax
leaq -0x80(%rbp), %rbx
leaq -0xd0(%rbp), %rcx
xorl %edx, %edx
xorl %r12d, %r12d
movq %rax, -0xe8(%rbp)
movl (%rsi), %eax
movq %rsi, -0xf0(%rbp)
movzwl 0x4(%rsi), %r15d
shlq $0x20, %r15
orq %rax, %r15
movl $0x10, %r13d
cmpq $0x3d, %r12
jb 0x4041e
movq %rdx, -0xe0(%rbp)
movq %rbx, %rdi
movq %rcx, %rsi
movq %r12, %rdx
callq 0x29560
testl %eax, %eax
je 0x403e2
movl $0x50, %ecx
leaq -0xd0(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x29420
movq %r14, %r8
subq %r12, %r8
movq -0xd8(%rbp), %rdi
movl $0x1, %esi
movq $-0x1, %rdx
leaq 0x994c9(%rip), %rcx # 0xd9857
xorl %eax, %eax
callq 0x29970
movslq %eax, %rcx
movq %rcx, -0xe0(%rbp)
movq -0xd8(%rbp), %rax
leaq (%rax,%rcx), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x29080
addq -0xe0(%rbp), %r12
movq -0xd8(%rbp), %rax
addq %r12, %rax
incq %rax
movq %rax, -0xd8(%rbp)
movb $0xa, -0x1(%rax)
xorl %r12d, %r12d
xorl %edx, %edx
leaq -0xd0(%rbp), %rcx
jmp 0x4041e
leaq -0xd0(%rbp), %rcx
movq -0xe0(%rbp), %rdx
testq %rdx, %rdx
je 0x403fa
incq %rdx
jmp 0x4041b
movq -0xd8(%rbp), %rax
movb $0x0, 0x4(%rax)
movl $0xa2e2e2e, (%rax) # imm = 0xA2E2E2E
addq $0x4, %rax
movl $0x1, %edx
movq %rax, -0xd8(%rbp)
xorl %r12d, %r12d
movl %r15d, %eax
andb $0x7, %al
orb $0x30, %al
movb %al, -0x80(%rbp,%r12)
incq %r12
incq %r14
shrq $0x3, %r15
decl %r13d
jne 0x40330
movq -0xf0(%rbp), %rsi
addq $0x6, %rsi
movq -0xe8(%rbp), %rax
cmpq %rax, %rsi
jb 0x40315
jmp 0x4045d
xorl %r12d, %r12d
subq %r12, %r14
leaq 0x993f0(%rip), %rcx # 0xd9857
movq -0xd8(%rbp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
movq $-0x1, %rdx
movq %r14, %r8
xorl %eax, %eax
callq 0x29970
movslq %eax, %r14
leaq (%rbx,%r14), %rdi
leaq -0x80(%rbp), %rsi
movq %r12, %rdx
callq 0x29080
leaq (%r12,%r14), %rax
movw $0xa, (%rbx,%rax)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x404cc
leaq (%r12,%r14), %rax
incq %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29270
|
_ma_get_bitmap_description:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 0C8h
mov [rbp+var_D8], rcx
mov r14, rdx
mov rax, fs:28h
mov [rbp+var_30], rax
inc r14
mov [rbp+var_D0], 0
mov eax, [rdi+24h]
test rax, rax
jz loc_4045A
add rax, rsi
lea rbx, [rbp+var_80]
lea rcx, [rbp+var_D0]
xor edx, edx
xor r12d, r12d
mov [rbp+var_E8], rax
loc_40315:
mov eax, [rsi]
mov [rbp+var_F0], rsi
movzx r15d, word ptr [rsi+4]
shl r15, 20h
or r15, rax
mov r13d, 10h
loc_40330:
cmp r12, 3Dh ; '='
jb loc_4041E
mov [rbp+var_E0], rdx
mov rdi, rbx
mov rsi, rcx
mov rdx, r12
call _bcmp
test eax, eax
jz loc_403E2
mov ecx, 50h ; 'P'
lea rdi, [rbp+var_D0]
mov rsi, rbx
mov rdx, r12
call ___memcpy_chk
mov r8, r14
sub r8, r12
mov rdi, [rbp+var_D8]
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
lea rcx, a8lu; "%8lu: "
xor eax, eax
call ___sprintf_chk
movsxd rcx, eax
mov [rbp+var_E0], rcx
mov rax, [rbp+var_D8]
lea rdi, [rax+rcx]
mov rsi, rbx
mov rdx, r12
call _memcpy
add r12, [rbp+var_E0]
mov rax, [rbp+var_D8]
add rax, r12
inc rax
mov [rbp+var_D8], rax
mov byte ptr [rax-1], 0Ah
xor r12d, r12d
xor edx, edx
lea rcx, [rbp+var_D0]
jmp short loc_4041E
loc_403E2:
lea rcx, [rbp+var_D0]
mov rdx, [rbp+var_E0]
test rdx, rdx
jz short loc_403FA
inc rdx
jmp short loc_4041B
loc_403FA:
mov rax, [rbp+var_D8]
mov byte ptr [rax+4], 0
mov dword ptr [rax], 0A2E2E2Eh
add rax, 4
mov edx, 1
mov [rbp+var_D8], rax
loc_4041B:
xor r12d, r12d
loc_4041E:
mov eax, r15d
and al, 7
or al, 30h
mov [rbp+r12+var_80], al
inc r12
inc r14
shr r15, 3
dec r13d
jnz loc_40330
mov rsi, [rbp+var_F0]
add rsi, 6
mov rax, [rbp+var_E8]
cmp rsi, rax
jb loc_40315
jmp short loc_4045D
loc_4045A:
xor r12d, r12d
loc_4045D:
sub r14, r12
lea rcx, a8lu; "%8lu: "
mov rbx, [rbp+var_D8]
mov rdi, rbx
mov esi, 1
mov rdx, 0FFFFFFFFFFFFFFFFh
mov r8, r14
xor eax, eax
call ___sprintf_chk
movsxd r14, eax
lea rdi, [rbx+r14]
lea rsi, [rbp+var_80]
mov rdx, r12
call _memcpy
lea rax, [r12+r14]
mov word ptr [rbx+rax], 0Ah
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_404CC
lea rax, [r12+r14]
inc rax
add rsp, 0C8h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_404CC:
call ___stack_chk_fail
|
long long ma_get_bitmap_description(long long a1, unsigned int *a2, long long a3, char *a4)
{
long long v4; // r14
long long v5; // rdx
unsigned long long v6; // r12
unsigned long long v7; // r15
int v8; // r13d
long long v9; // r14
unsigned int *v11; // [rsp+0h] [rbp-F0h]
unsigned long long v12; // [rsp+8h] [rbp-E8h]
long long v13; // [rsp+10h] [rbp-E0h]
long long v14; // [rsp+10h] [rbp-E0h]
_BYTE v16[80]; // [rsp+20h] [rbp-D0h] BYREF
_BYTE v17[80]; // [rsp+70h] [rbp-80h] BYREF
unsigned long long v18; // [rsp+C0h] [rbp-30h]
v18 = __readfsqword(0x28u);
v4 = a3 + 1;
v16[0] = 0;
if ( *(_DWORD *)(a1 + 36) )
{
v5 = 0LL;
v6 = 0LL;
v12 = (unsigned long long)a2 + *(unsigned int *)(a1 + 36);
do
{
v11 = a2;
v7 = *a2 | ((unsigned long long)*((unsigned __int16 *)a2 + 2) << 32);
v8 = 16;
do
{
if ( v6 >= 0x3D )
{
v13 = v5;
if ( (unsigned int)bcmp(v17, v16, v6) )
{
__memcpy_chk(v16, v17, v6, 80LL);
v14 = (int)__sprintf_chk(a4, 1LL, -1LL, "%8lu: ", v4 - v6);
memcpy(&a4[v14], v17, v6);
a4 += v14 + v6 + 1;
*(a4 - 1) = 10;
v6 = 0LL;
v5 = 0LL;
}
else
{
if ( v13 )
{
v5 = v13 + 1;
}
else
{
strcpy(a4, "...\n");
v5 = 1LL;
a4 += 4;
}
v6 = 0LL;
}
}
v17[v6++] = v7 & 7 | 0x30;
++v4;
v7 >>= 3;
--v8;
}
while ( v8 );
a2 = (unsigned int *)((char *)a2 + 6);
}
while ( (unsigned long long)v11 + 6 < v12 );
}
else
{
v6 = 0LL;
}
v9 = (int)__sprintf_chk(a4, 1LL, -1LL, "%8lu: ", v4 - v6);
memcpy(&a4[v9], v17, v6);
*(_WORD *)&a4[v6 + v9] = 10;
return v6 + v9 + 1;
}
|
_ma_get_bitmap_description:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xd8],RCX
MOV R14,RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
INC R14
MOV byte ptr [RBP + -0xd0],0x0
MOV EAX,dword ptr [RDI + 0x24]
TEST RAX,RAX
JZ 0x0014045a
ADD RAX,RSI
LEA RBX,[RBP + -0x80]
LEA RCX,[RBP + -0xd0]
XOR EDX,EDX
XOR R12D,R12D
MOV qword ptr [RBP + -0xe8],RAX
LAB_00140315:
MOV EAX,dword ptr [RSI]
MOV qword ptr [RBP + -0xf0],RSI
MOVZX R15D,word ptr [RSI + 0x4]
SHL R15,0x20
OR R15,RAX
MOV R13D,0x10
LAB_00140330:
CMP R12,0x3d
JC 0x0014041e
MOV qword ptr [RBP + -0xe0],RDX
MOV RDI,RBX
MOV RSI,RCX
MOV RDX,R12
CALL 0x00129560
TEST EAX,EAX
JZ 0x001403e2
MOV ECX,0x50
LEA RDI,[RBP + -0xd0]
MOV RSI,RBX
MOV RDX,R12
CALL 0x00129420
MOV R8,R14
SUB R8,R12
MOV RDI,qword ptr [RBP + -0xd8]
MOV ESI,0x1
MOV RDX,-0x1
LEA RCX,[0x1d9857]
XOR EAX,EAX
CALL 0x00129970
MOVSXD RCX,EAX
MOV qword ptr [RBP + -0xe0],RCX
MOV RAX,qword ptr [RBP + -0xd8]
LEA RDI,[RAX + RCX*0x1]
MOV RSI,RBX
MOV RDX,R12
CALL 0x00129080
ADD R12,qword ptr [RBP + -0xe0]
MOV RAX,qword ptr [RBP + -0xd8]
ADD RAX,R12
INC RAX
MOV qword ptr [RBP + -0xd8],RAX
MOV byte ptr [RAX + -0x1],0xa
XOR R12D,R12D
XOR EDX,EDX
LEA RCX,[RBP + -0xd0]
JMP 0x0014041e
LAB_001403e2:
LEA RCX,[RBP + -0xd0]
MOV RDX,qword ptr [RBP + -0xe0]
TEST RDX,RDX
JZ 0x001403fa
INC RDX
JMP 0x0014041b
LAB_001403fa:
MOV RAX,qword ptr [RBP + -0xd8]
MOV byte ptr [RAX + 0x4],0x0
MOV dword ptr [RAX],0xa2e2e2e
ADD RAX,0x4
MOV EDX,0x1
MOV qword ptr [RBP + -0xd8],RAX
LAB_0014041b:
XOR R12D,R12D
LAB_0014041e:
MOV EAX,R15D
AND AL,0x7
OR AL,0x30
MOV byte ptr [RBP + R12*0x1 + -0x80],AL
INC R12
INC R14
SHR R15,0x3
DEC R13D
JNZ 0x00140330
MOV RSI,qword ptr [RBP + -0xf0]
ADD RSI,0x6
MOV RAX,qword ptr [RBP + -0xe8]
CMP RSI,RAX
JC 0x00140315
JMP 0x0014045d
LAB_0014045a:
XOR R12D,R12D
LAB_0014045d:
SUB R14,R12
LEA RCX,[0x1d9857]
MOV RBX,qword ptr [RBP + -0xd8]
MOV RDI,RBX
MOV ESI,0x1
MOV RDX,-0x1
MOV R8,R14
XOR EAX,EAX
CALL 0x00129970
MOVSXD R14,EAX
LEA RDI,[RBX + R14*0x1]
LEA RSI,[RBP + -0x80]
MOV RDX,R12
CALL 0x00129080
LEA RAX,[R12 + R14*0x1]
MOV word ptr [RBX + RAX*0x1],0xa
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001404cc
LEA RAX,[R12 + R14*0x1]
INC RAX
ADD RSP,0xc8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001404cc:
CALL 0x00129270
|
long _ma_get_bitmap_description(long param_1,uint6 *param_2,long param_3,int4 *param_4)
{
int iVar1;
uint6 *puVar2;
int1 *puVar3;
size_t __n;
int iVar4;
long lVar5;
ulong uVar6;
long in_FS_OFFSET;
int4 *local_e0;
int1 local_d8 [80];
byte local_88 [80];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
param_3 = param_3 + 1;
local_d8[0] = 0;
local_e0 = param_4;
if ((ulong)*(uint *)(param_1 + 0x24) == 0) {
__n = 0;
}
else {
puVar2 = (uint6 *)((ulong)*(uint *)(param_1 + 0x24) + (long)param_2);
lVar5 = 0;
__n = 0;
do {
uVar6 = (ulong)*param_2;
iVar4 = 0x10;
do {
if (0x3c < __n) {
iVar1 = bcmp(local_88,local_d8,__n);
if (iVar1 == 0) {
if (lVar5 == 0) {
*(int1 *)(local_e0 + 1) = 0;
*local_e0 = 0xa2e2e2e;
local_e0 = local_e0 + 1;
lVar5 = 1;
}
else {
lVar5 = lVar5 + 1;
}
__n = 0;
}
else {
__memcpy_chk(local_d8,local_88,__n,0x50);
iVar1 = __sprintf_chk(local_e0,1,0xffffffffffffffff,"%8lu: ",param_3 - __n);
memcpy((int1 *)((long)local_e0 + (long)iVar1),local_88,__n);
puVar3 = (int1 *)((long)local_e0 + __n + (long)iVar1);
local_e0 = (int4 *)(puVar3 + 1);
*puVar3 = 10;
__n = 0;
lVar5 = 0;
}
}
local_88[__n] = (byte)uVar6 & 7 | 0x30;
__n = __n + 1;
param_3 = param_3 + 1;
uVar6 = uVar6 >> 3;
iVar4 = iVar4 + -1;
} while (iVar4 != 0);
param_2 = (uint6 *)((long)param_2 + 6);
} while (param_2 < puVar2);
}
iVar4 = __sprintf_chk(local_e0,1,0xffffffffffffffff,"%8lu: ",param_3 - __n);
lVar5 = (long)iVar4;
memcpy((int1 *)((long)local_e0 + lVar5),local_88,__n);
*(int2 *)((long)local_e0 + __n + lVar5) = 10;
if (*(long *)(in_FS_OFFSET + 0x28) != local_38) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return __n + lVar5 + 1;
}
|
|
7,731 |
lf_dynarray_iterate
|
eloqsql/mysys/lf_dynarray.c
|
int lf_dynarray_iterate(LF_DYNARRAY *array, lf_dynarray_func func, void *arg)
{
int i, res;
for (i= 0; i < LF_DYNARRAY_LEVELS; i++)
if ((res= recursive_iterate(array, array->level[i], i, func, arg)))
return res;
return 0;
}
|
O0
|
c
|
lf_dynarray_iterate:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0xfe5ce
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movl -0x24(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0xfe5e0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
je 0xfe5c1
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfe5d5
jmp 0xfe5c3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xfe58b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
|
lf_dynarray_iterate:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], 0
loc_FE58B:
cmp [rbp+var_24], 4
jge short loc_FE5CE
mov rdi, [rbp+var_10]
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_24]
mov rsi, [rax+rcx*8]
mov edx, [rbp+var_24]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
call recursive_iterate
mov [rbp+var_28], eax
cmp eax, 0
jz short loc_FE5C1
mov eax, [rbp+var_28]
mov [rbp+var_4], eax
jmp short loc_FE5D5
loc_FE5C1:
jmp short $+2
loc_FE5C3:
mov eax, [rbp+var_24]
add eax, 1
mov [rbp+var_24], eax
jmp short loc_FE58B
loc_FE5CE:
mov [rbp+var_4], 0
loc_FE5D5:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
|
long long lf_dynarray_iterate(long long a1, long long a2, long long a3)
{
unsigned int v4; // [rsp+8h] [rbp-28h]
int i; // [rsp+Ch] [rbp-24h]
for ( i = 0; i < 4; ++i )
{
v4 = recursive_iterate(a1, *(_QWORD *)(a1 + 8LL * i), (unsigned int)i, a2, a3);
if ( v4 )
return v4;
}
return 0;
}
|
lf_dynarray_iterate:
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 dword ptr [RBP + -0x24],0x0
LAB_001fe58b:
CMP dword ptr [RBP + -0x24],0x4
JGE 0x001fe5ce
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RSI,qword ptr [RAX + RCX*0x8]
MOV EDX,dword ptr [RBP + -0x24]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
CALL 0x001fe5e0
MOV dword ptr [RBP + -0x28],EAX
CMP EAX,0x0
JZ 0x001fe5c1
MOV EAX,dword ptr [RBP + -0x28]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x001fe5d5
LAB_001fe5c1:
JMP 0x001fe5c3
LAB_001fe5c3:
MOV EAX,dword ptr [RBP + -0x24]
ADD EAX,0x1
MOV dword ptr [RBP + -0x24],EAX
JMP 0x001fe58b
LAB_001fe5ce:
MOV dword ptr [RBP + -0x4],0x0
LAB_001fe5d5:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int lf_dynarray_iterate(long param_1,int8 param_2,int8 param_3)
{
int iVar1;
int local_2c;
local_2c = 0;
while( true ) {
if (3 < local_2c) {
return 0;
}
iVar1 = recursive_iterate(param_1,*(int8 *)(param_1 + (long)local_2c * 8),local_2c,param_2
,param_3);
if (iVar1 != 0) break;
local_2c = local_2c + 1;
}
return iVar1;
}
|
|
7,732 |
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)::$_0::operator()[abi:cxx11](unsigned long) const
|
monkey531[P]llama/common/minja.hpp
|
static std::string error_location_suffix(const std::string & source, size_t pos) {
auto get_line = [&](size_t line) {
auto start = source.begin();
for (size_t i = 1; i < line; ++i) {
start = std::find(start, source.end(), '\n') + 1;
}
auto end = std::find(start, source.end(), '\n');
return std::string(start, end);
};
auto start = source.begin();
auto end = source.end();
auto it = start + pos;
auto line = std::count(start, it, '\n') + 1;
auto max_line = std::count(start, end, '\n') + 1;
auto col = pos - std::string(start, it).rfind('\n');
std::ostringstream out;
out << " at row " << line << ", column " << col << ":\n";
if (line > 1) out << get_line(line - 1) << "\n";
out << get_line(line) << "\n";
out << std::string(col - 1, ' ') << "^\n";
if (line < max_line) out << get_line(line + 1) << "\n";
return out.str();
}
|
O2
|
cpp
|
minja::error_location_suffix(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)::$_0::operator()[abi:cxx11](unsigned long) const:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %r14
pushq $0x1
popq %rbp
leaq 0x6(%rsp), %r13
movq (%r12), %rax
movq (%rax), %rsi
addq 0x8(%rax), %rsi
cmpq %r15, %rbp
jae 0xbb677
movb $0xa, 0x6(%rsp)
movq %r14, %rdi
movq %r13, %rdx
callq 0x8e1f0
movq %rax, %r14
incq %r14
incq %rbp
jmp 0xbb64c
leaq 0x7(%rsp), %rdx
movb $0xa, (%rdx)
movq %r14, %rdi
callq 0x8e1f0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6e97a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
_ZZN5minjaL21error_location_suffixERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEmENK3$_0clB5cxx11Em_0:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov rbx, rdi
mov rax, [rsi]
mov r14, [rax]
push 1
pop rbp
lea r13, [rsp+38h+var_32]
loc_BB64C:
mov rax, [r12]
mov rsi, [rax]
add rsi, [rax+8]
cmp rbp, r15
jnb short loc_BB677
mov [rsp+38h+var_32], 0Ah
mov rdi, r14
mov rdx, r13
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
mov r14, rax
inc r14
inc rbp
jmp short loc_BB64C
loc_BB677:
lea rdx, [rsp+38h+var_31]
mov byte ptr [rdx], 0Ah
mov rdi, r14
call _ZSt9__find_ifIN9__gnu_cxx17__normal_iteratorIPKcNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEENS0_5__ops16_Iter_equals_valIS2_EEET_SE_SE_T0_St26random_access_iterator_tag; std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>,std::random_access_iterator_tag)
lea rcx, [rbx+10h]
mov [rbx], rcx
mov rdi, rbx
mov rsi, r14
mov rdx, rax
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIN9__gnu_cxx17__normal_iteratorIPKcS4_EEEEvT_SB_St20forward_iterator_tag; std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>(__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__normal_iterator<char const*,std::string>,std::forward_iterator_tag)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
_QWORD * minja::error_location_suffix(std::string const&,unsigned long)::$_0::operator()[abi:cxx11](
_QWORD *a1,
_BYTE ***a2,
unsigned long long a3)
{
long long v3; // rax
_BYTE *v6; // r14
unsigned long long i; // rbp
long long v8; // rsi
_BYTE *v9; // rax
_WORD v11[25]; // [rsp+0h] [rbp-32h] BYREF
v11[0] = HIWORD(v3);
v6 = **a2;
for ( i = 1LL; ; ++i )
{
v8 = (long long)&(**a2)[(_QWORD)(*a2)[1]];
if ( i >= a3 )
break;
LOBYTE(v11[0]) = 10;
v6 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
(long long)v6,
v8,
(char *)v11)
+ 1;
}
HIBYTE(v11[0]) = 10;
v9 = std::__find_if<__gnu_cxx::__normal_iterator<char const*,std::string>,__gnu_cxx::__ops::_Iter_equals_val<char const>>(
(long long)v6,
v8,
(char *)v11 + 1);
*a1 = a1 + 2;
std::string::_M_construct<__gnu_cxx::__normal_iterator<char const*,std::string>>((long long)a1, v6, (long long)v9);
return a1;
}
|
operator()[abi:cxx11]:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV R14,qword ptr [RAX]
PUSH 0x1
POP RBP
LEA R13,[RSP + 0x6]
LAB_001bb64c:
MOV RAX,qword ptr [R12]
MOV RSI,qword ptr [RAX]
ADD RSI,qword ptr [RAX + 0x8]
CMP RBP,R15
JNC 0x001bb677
MOV byte ptr [RSP + 0x6],0xa
MOV RDI,R14
MOV RDX,R13
CALL 0x0018e1f0
MOV R14,RAX
INC R14
INC RBP
JMP 0x001bb64c
LAB_001bb677:
LEA RDX,[RSP + 0x7]
MOV byte ptr [RDX],0xa
MOV RDI,R14
CALL 0x0018e1f0
LEA RCX,[RBX + 0x10]
MOV qword ptr [RBX],RCX
MOV RDI,RBX
MOV RSI,R14
MOV RDX,RAX
CALL 0x0016e97a
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* operator()[abi:cxx11](unsigned long) const */
ulong minja::error_location_suffix(std::__cxx11::string_const&,unsigned_long)::$_0::
operator()[abi_cxx11_(ulong param_1)
{
int8 in_RAX;
long lVar1;
int8 uVar2;
ulong in_RDX;
ulong uVar3;
long *in_RSI;
long lVar4;
int8 uStack_38;
lVar1 = *(long *)*in_RSI;
uStack_38 = in_RAX;
for (uVar3 = 1; lVar4 = *(long *)*in_RSI + ((long *)*in_RSI)[1], uVar3 < in_RDX; uVar3 = uVar3 + 1
) {
uStack_38._0_7_ = CONCAT16(10,(int6)uStack_38);
lVar1 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar1,lVar4,(long)&uStack_38 + 6);
lVar1 = lVar1 + 1;
}
uStack_38 = CONCAT17(10,(int7)uStack_38);
uVar2 = std::
__find_if<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>,__gnu_cxx::__ops::_Iter_equals_val<char_const>>
(lVar1,lVar4);
*(ulong *)param_1 = param_1 + 0x10;
std::__cxx11::string::_M_construct<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>
(param_1,lVar1,uVar2);
return param_1;
}
|
|
7,733 |
maria_page_crc_check_data
|
eloqsql/storage/maria/ma_pagecrc.c
|
my_bool maria_page_crc_check_data(int res, PAGECACHE_IO_HOOK_ARGS *args)
{
uchar *page= args->page;
pgcache_page_no_t page_no= args->pageno;
MARIA_SHARE *share= (MARIA_SHARE *)args->data;
if (res)
{
return 1;
}
return (maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_NORMAL_PAGE,
share->block_size - CRC_SIZE));
}
|
O0
|
c
|
maria_page_crc_check_data:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x5d6de
movb $0x1, -0x1(%rbp)
jmp 0x5d70a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %eax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movq -0x28(%rbp), %rax
movl 0x7bc(%rax), %r8d
subl $0x4, %r8d
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x5d430
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
maria_page_crc_check_data:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], edi
mov [rbp+var_10], rsi
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
cmp [rbp+var_8], 0
jz short loc_5D6DE
mov [rbp+var_1], 1
jmp short loc_5D70A
loc_5D6DE:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov eax, eax
mov esi, eax
mov rdx, [rbp+var_28]
mov rax, [rbp+var_28]
mov r8d, [rax+7BCh]
sub r8d, 4
mov ecx, 0FFFFFFFFh
call maria_page_crc_check
mov [rbp+var_1], al
loc_5D70A:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
|
bool maria_page_crc_check_data(int a1, long long a2)
{
return a1
|| maria_page_crc_check(
*(_BYTE **)a2,
(const char *)(unsigned int)*(_QWORD *)(a2 + 8),
*(_QWORD *)(a2 + 16),
-1,
*(_DWORD *)(*(_QWORD *)(a2 + 16) + 1980LL) - 4);
}
|
maria_page_crc_check_data:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV dword ptr [RBP + -0x8],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
CMP dword ptr [RBP + -0x8],0x0
JZ 0x0015d6de
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0015d70a
LAB_0015d6de:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,EAX
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x28]
MOV R8D,dword ptr [RAX + 0x7bc]
SUB R8D,0x4
MOV ECX,0xffffffff
CALL 0x0015d430
MOV byte ptr [RBP + -0x1],AL
LAB_0015d70a:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 maria_page_crc_check_data(int param_1,int8 *param_2)
{
int1 local_9;
if (param_1 == 0) {
local_9 = maria_page_crc_check
(*param_2,param_2[1] & 0xffffffff,param_2[2],0xffffffff,
*(int *)(param_2[2] + 0x7bc) + -4);
}
else {
local_9 = 1;
}
return local_9;
}
|
|
7,734 |
net_stmt_close
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
static my_bool net_stmt_close(MYSQL_STMT *stmt, my_bool remove)
{
char stmt_id[STMT_ID_LENGTH];
MA_MEM_ROOT *fields_ma_alloc_root= &((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root;
/* clear memory */
ma_free_root(&stmt->result.alloc, MYF(0)); /* allocated in mysql_stmt_store_result */
ma_free_root(&stmt->mem_root,MYF(0));
ma_free_root(fields_ma_alloc_root, MYF(0));
if (stmt->mysql)
{
CLEAR_CLIENT_ERROR(stmt->mysql);
/* remove from stmt list */
if (remove)
stmt->mysql->stmts= list_delete(stmt->mysql->stmts, &stmt->list);
/* check if all data are fetched */
if (stmt->mysql->status != MYSQL_STATUS_READY)
{
do {
stmt->mysql->methods->db_stmt_flush_unbuffered(stmt);
} while(mysql_stmt_more_results(stmt));
stmt->mysql->status= MYSQL_STATUS_READY;
}
if (stmt->state > MYSQL_STMT_INITTED)
{
int4store(stmt_id, stmt->stmt_id);
if (stmt->mysql->methods->db_command(stmt->mysql,COM_STMT_CLOSE, stmt_id,
sizeof(stmt_id), 1, stmt))
{
UPDATE_STMT_ERROR(stmt);
return 1;
}
}
}
return 0;
}
|
O3
|
c
|
net_stmt_close:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x28(%rbp)
movq 0x340(%rdi), %r12
addq $0x90, %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x2528b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2528b
movq %r12, %rdi
xorl %esi, %esi
callq 0x2528b
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x28bfa
movl $0x0, 0x90(%rax)
movq 0x38(%rbx), %rax
movw $0x30, 0x29b(%rax)
movl $0x30303030, 0x297(%rax) # imm = 0x30303030
movq 0x38(%rbx), %rax
movb $0x0, 0x97(%rax)
movq 0x38(%rbx), %rax
movq 0x2a0(%rax), %rcx
testq %rcx, %rcx
je 0x28b08
movl $0x0, 0x4(%rcx)
movq 0x38(%rbx), %rax
testb %r14b, %r14b
je 0x28b2f
movq 0x4c8(%rax), %rdi
leaq 0x320(%rbx), %rsi
callq 0x24328
movq 0x38(%rbx), %rcx
movq %rax, 0x4c8(%rcx)
movq 0x38(%rbx), %rax
cmpl $0x0, 0x488(%rax)
je 0x28b67
movq 0x4d0(%rax), %rax
movq %rbx, %rdi
callq *0x78(%rax)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x28b5d
movzwl 0x380(%rax), %ecx
testl $0x1008, %ecx # imm = 0x1008
jne 0x28b38
movl $0x0, 0x488(%rax)
cmpl $0x0, 0x50(%rbx)
je 0x28bf7
movl 0x40(%rbx), %eax
leaq -0x2c(%rbp), %rdx
movl %eax, (%rdx)
movq 0x38(%rbx), %rdi
movq 0x4d0(%rdi), %rax
movl $0x4, %ecx
movl $0x19, %esi
movl $0x1, %r8d
movq %rbx, %r9
callq *0x10(%rax)
testl %eax, %eax
je 0x28bf7
movq 0x38(%rbx), %rsi
movl 0x90(%rsi), %eax
movl %eax, 0x108(%rbx)
leaq 0x30d(%rbx), %rdi
addq $0x297, %rsi # imm = 0x297
movl $0x5, %edx
callq 0x172d0
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
movl $0x97, %esi
addq 0x38(%rbx), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x172d0
movb %r14b, 0x30b(%rbx)
movb $0x1, %r15b
jmp 0x28bfa
xorl %r15d, %r15d
movq %fs:0x28, %rax
cmpq -0x28(%rbp), %rax
jne 0x28c19
movl %r15d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x17690
|
net_stmt_close:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r14d, esi
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_28], rax
mov r12, [rdi+340h]
add rdi, 90h
xor r15d, r15d
xor esi, esi
call ma_free_root
mov rdi, rbx
xor esi, esi
call ma_free_root
mov rdi, r12
xor esi, esi
call ma_free_root
mov rax, [rbx+38h]
test rax, rax
jz loc_28BFA
mov dword ptr [rax+90h], 0
mov rax, [rbx+38h]
mov word ptr [rax+29Bh], 30h ; '0'
mov dword ptr [rax+297h], 30303030h
mov rax, [rbx+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbx+38h]
mov rcx, [rax+2A0h]
test rcx, rcx
jz short loc_28B08
mov dword ptr [rcx+4], 0
mov rax, [rbx+38h]
loc_28B08:
test r14b, r14b
jz short loc_28B2F
mov rdi, [rax+4C8h]
lea rsi, [rbx+320h]
call list_delete
mov rcx, [rbx+38h]
mov [rcx+4C8h], rax
mov rax, [rbx+38h]
loc_28B2F:
cmp dword ptr [rax+488h], 0
jz short loc_28B67
loc_28B38:
mov rax, [rax+4D0h]
mov rdi, rbx
call qword ptr [rax+78h]
mov rax, [rbx+38h]
test rax, rax
jz short loc_28B5D
movzx ecx, word ptr [rax+380h]
test ecx, 1008h
jnz short loc_28B38
loc_28B5D:
mov dword ptr [rax+488h], 0
loc_28B67:
cmp dword ptr [rbx+50h], 0
jz loc_28BF7
mov eax, [rbx+40h]
lea rdx, [rbp+var_2C]
mov [rdx], eax
mov rdi, [rbx+38h]
mov rax, [rdi+4D0h]
mov ecx, 4
mov esi, 19h
mov r8d, 1
mov r9, rbx
call qword ptr [rax+10h]
test eax, eax
jz short loc_28BF7
mov rsi, [rbx+38h]
mov eax, [rsi+90h]
mov [rbx+108h], eax
lea rdi, [rbx+30Dh]
add rsi, 297h
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
mov esi, 97h
add rsi, [rbx+38h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov r15b, 1
jmp short loc_28BFA
loc_28BF7:
xor r15d, r15d
loc_28BFA:
mov rax, fs:28h
cmp rax, [rbp+var_28]
jnz short loc_28C19
mov eax, r15d
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_28C19:
call ___stack_chk_fail
|
long long net_stmt_close(long long a1, char a2)
{
long long v2; // r12
unsigned int v3; // r15d
long long v4; // rax
long long v5; // rax
long long v6; // rcx
long long v7; // rsi
int v9; // [rsp+4h] [rbp-2Ch] BYREF
unsigned long long v10; // [rsp+8h] [rbp-28h]
v10 = __readfsqword(0x28u);
v2 = *(_QWORD *)(a1 + 832);
v3 = 0;
ma_free_root(a1 + 144, 0);
ma_free_root(a1, 0);
ma_free_root(v2, 0);
v4 = *(_QWORD *)(a1 + 56);
if ( v4 )
{
*(_DWORD *)(v4 + 144) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v5 = *(_QWORD *)(a1 + 56);
v6 = *(_QWORD *)(v5 + 672);
if ( v6 )
{
*(_DWORD *)(v6 + 4) = 0;
v5 = *(_QWORD *)(a1 + 56);
}
if ( a2 )
{
*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1224LL) = list_delete(*(_QWORD **)(v5 + 1224), (_QWORD *)(a1 + 800));
v5 = *(_QWORD *)(a1 + 56);
}
if ( *(_DWORD *)(v5 + 1160) )
{
do
{
(*(void ( **)(long long))(*(_QWORD *)(v5 + 1232) + 120LL))(a1);
v5 = *(_QWORD *)(a1 + 56);
}
while ( v5 && (*(_WORD *)(v5 + 896) & 0x1008) != 0 );
*(_DWORD *)(v5 + 1160) = 0;
}
if ( *(_DWORD *)(a1 + 80)
&& (v9 = *(_DWORD *)(a1 + 64),
(*(unsigned int ( **)(_QWORD, long long, int *, long long, long long, long long))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL)
+ 16LL))(
*(_QWORD *)(a1 + 56),
25LL,
&v9,
4LL,
1LL,
a1)) )
{
v7 = *(_QWORD *)(a1 + 56);
*(_DWORD *)(a1 + 264) = *(_DWORD *)(v7 + 144);
strncpy(a1 + 781, v7 + 663, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, *(_QWORD *)(a1 + 56) + 151LL, 512LL);
*(_BYTE *)(a1 + 779) = 0;
LOBYTE(v3) = 1;
}
else
{
return 0;
}
}
return v3;
}
|
net_stmt_close:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R14D,ESI
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
MOV R12,qword ptr [RDI + 0x340]
ADD RDI,0x90
XOR R15D,R15D
XOR ESI,ESI
CALL 0x0012528b
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0012528b
MOV RDI,R12
XOR ESI,ESI
CALL 0x0012528b
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x00128bfa
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBX + 0x38]
MOV word ptr [RAX + 0x29b],0x30
MOV dword ptr [RAX + 0x297],0x30303030
MOV RAX,qword ptr [RBX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RAX + 0x2a0]
TEST RCX,RCX
JZ 0x00128b08
MOV dword ptr [RCX + 0x4],0x0
MOV RAX,qword ptr [RBX + 0x38]
LAB_00128b08:
TEST R14B,R14B
JZ 0x00128b2f
MOV RDI,qword ptr [RAX + 0x4c8]
LEA RSI,[RBX + 0x320]
CALL 0x00124328
MOV RCX,qword ptr [RBX + 0x38]
MOV qword ptr [RCX + 0x4c8],RAX
MOV RAX,qword ptr [RBX + 0x38]
LAB_00128b2f:
CMP dword ptr [RAX + 0x488],0x0
JZ 0x00128b67
LAB_00128b38:
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RDI,RBX
CALL qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBX + 0x38]
TEST RAX,RAX
JZ 0x00128b5d
MOVZX ECX,word ptr [RAX + 0x380]
TEST ECX,0x1008
JNZ 0x00128b38
LAB_00128b5d:
MOV dword ptr [RAX + 0x488],0x0
LAB_00128b67:
CMP dword ptr [RBX + 0x50],0x0
JZ 0x00128bf7
MOV EAX,dword ptr [RBX + 0x40]
LEA RDX,[RBP + -0x2c]
MOV dword ptr [RDX],EAX
MOV RDI,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RDI + 0x4d0]
MOV ECX,0x4
MOV ESI,0x19
MOV R8D,0x1
MOV R9,RBX
CALL qword ptr [RAX + 0x10]
TEST EAX,EAX
JZ 0x00128bf7
MOV RSI,qword ptr [RBX + 0x38]
MOV EAX,dword ptr [RSI + 0x90]
MOV dword ptr [RBX + 0x108],EAX
LEA RDI,[RBX + 0x30d]
ADD RSI,0x297
MOV EDX,0x5
CALL 0x001172d0
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
MOV ESI,0x97
ADD RSI,qword ptr [RBX + 0x38]
MOV EDX,0x200
CALL 0x001172d0
MOV byte ptr [RBX + 0x30b],R14B
MOV R15B,0x1
JMP 0x00128bfa
LAB_00128bf7:
XOR R15D,R15D
LAB_00128bfa:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x28]
JNZ 0x00128c19
MOV EAX,R15D
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00128c19:
CALL 0x00117690
|
int8 net_stmt_close(long param_1,char param_2)
{
int iVar1;
int8 uVar2;
long lVar3;
int8 uVar4;
long in_FS_OFFSET;
int4 local_34;
long local_30;
local_30 = *(long *)(in_FS_OFFSET + 0x28);
uVar2 = *(int8 *)(param_1 + 0x340);
uVar4 = 0;
ma_free_root(param_1 + 0x90,0);
ma_free_root(param_1,0);
ma_free_root(uVar2,0);
if (*(long *)(param_1 + 0x38) != 0) {
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar3 = *(long *)(param_1 + 0x38);
*(int2 *)(lVar3 + 0x29b) = 0x30;
*(int4 *)(lVar3 + 0x297) = 0x30303030;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar3 = *(long *)(param_1 + 0x38);
if (*(long *)(lVar3 + 0x2a0) != 0) {
*(int4 *)(*(long *)(lVar3 + 0x2a0) + 4) = 0;
lVar3 = *(long *)(param_1 + 0x38);
}
if (param_2 != '\0') {
uVar2 = list_delete(*(int8 *)(lVar3 + 0x4c8),param_1 + 800);
*(int8 *)(*(long *)(param_1 + 0x38) + 0x4c8) = uVar2;
lVar3 = *(long *)(param_1 + 0x38);
}
if (*(int *)(lVar3 + 0x488) != 0) {
do {
(**(code **)(*(long *)(lVar3 + 0x4d0) + 0x78))(param_1);
lVar3 = *(long *)(param_1 + 0x38);
if (lVar3 == 0) break;
} while ((*(ushort *)(lVar3 + 0x380) & 0x1008) != 0);
*(int4 *)(lVar3 + 0x488) = 0;
}
if (*(int *)(param_1 + 0x50) != 0) {
local_34 = *(int4 *)(param_1 + 0x40);
iVar1 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x10))
(*(long *)(param_1 + 0x38),0x19,&local_34,4,1,param_1);
if (iVar1 != 0) {
*(int4 *)(param_1 + 0x108) = *(int4 *)(*(long *)(param_1 + 0x38) + 0x90);
strncpy((char *)(param_1 + 0x30d),(char *)(*(long *)(param_1 + 0x38) + 0x297),5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),(char *)(*(long *)(param_1 + 0x38) + 0x97),0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar4 = 1;
goto LAB_00128bfa;
}
}
uVar4 = 0;
}
LAB_00128bfa:
if (*(long *)(in_FS_OFFSET + 0x28) == local_30) {
return uVar4;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
7,735 |
r3d_frustum_is_point_in
|
r3d/src/details/r3d_frustum.c
|
bool r3d_frustum_is_point_in(const r3d_frustum_t* frustum, Vector3 position)
{
for (int i = 0; i < R3D_PLANE_COUNT; i++) {
if (r3d_frustum_distance_to_plane(frustum->planes[i], position) <= 0) {
return false;
}
}
return true;
}
|
O3
|
c
|
r3d_frustum_is_point_in:
movsd (%rdi), %xmm2
movsd 0x8(%rdi), %xmm3
movaps %xmm2, %xmm4
mulps %xmm0, %xmm4
shufps $0x55, %xmm4, %xmm4 # xmm4 = xmm4[1,1,1,1]
mulss %xmm0, %xmm2
addss %xmm4, %xmm2
movaps %xmm3, %xmm4
mulss %xmm1, %xmm4
addss %xmm2, %xmm4
shufps $0x55, %xmm3, %xmm3 # xmm3 = xmm3[1,1,1,1]
addss %xmm4, %xmm3
xorps %xmm2, %xmm2
ucomiss %xmm3, %xmm2
jae 0xdf5e1
pushq %rbp
movq %rsp, %rbp
addq $0x18, %rdi
xorl %ecx, %ecx
movq %rcx, %rax
cmpq $0x5, %rcx
je 0xdf5d8
movsd -0x8(%rdi), %xmm3
movsd (%rdi), %xmm4
movaps %xmm3, %xmm5
mulps %xmm0, %xmm5
shufps $0x55, %xmm5, %xmm5 # xmm5 = xmm5[1,1,1,1]
mulss %xmm0, %xmm3
addss %xmm5, %xmm3
movaps %xmm4, %xmm5
mulss %xmm1, %xmm5
addss %xmm3, %xmm5
shufps $0x55, %xmm4, %xmm4 # xmm4 = xmm4[1,1,1,1]
addss %xmm5, %xmm4
addq $0x10, %rdi
leaq 0x1(%rax), %rcx
ucomiss %xmm4, %xmm2
jb 0xdf594
cmpq $0x5, %rax
setae %al
popq %rbp
retq
xorl %eax, %eax
retq
|
r3d_frustum_is_point_in:
movsd xmm2, qword ptr [rdi]
movsd xmm3, qword ptr [rdi+8]
movaps xmm4, xmm2
mulps xmm4, xmm0
shufps xmm4, xmm4, 55h ; 'U'
mulss xmm2, xmm0
addss xmm2, xmm4
movaps xmm4, xmm3
mulss xmm4, xmm1
addss xmm4, xmm2
shufps xmm3, xmm3, 55h ; 'U'
addss xmm3, xmm4
xorps xmm2, xmm2
ucomiss xmm2, xmm3
jnb short loc_DF5E1
push rbp
mov rbp, rsp
add rdi, 18h
xor ecx, ecx
loc_DF594:
mov rax, rcx
cmp rcx, 5
jz short loc_DF5D8
movsd xmm3, qword ptr [rdi-8]
movsd xmm4, qword ptr [rdi]
movaps xmm5, xmm3
mulps xmm5, xmm0
shufps xmm5, xmm5, 55h ; 'U'
mulss xmm3, xmm0
addss xmm3, xmm5
movaps xmm5, xmm4
mulss xmm5, xmm1
addss xmm5, xmm3
shufps xmm4, xmm4, 55h ; 'U'
addss xmm4, xmm5
add rdi, 10h
lea rcx, [rax+1]
ucomiss xmm2, xmm4
jb short loc_DF594
loc_DF5D8:
cmp rax, 5
setnb al
pop rbp
retn
loc_DF5E1:
xor eax, eax
retn
|
bool r3d_frustum_is_point_in(unsigned long long *a1, __m128 a2, float a3)
{
__m128 v3; // xmm4
unsigned long long *v4; // rdi
unsigned long long v5; // rcx
unsigned long long v6; // rax
__m128 v7; // xmm5
float v8; // xmm4_4
v3 = _mm_mul_ps((__m128)*a1, a2);
if ( (float)(_mm_shuffle_ps((__m128)a1[1], (__m128)a1[1], 85).m128_f32[0]
+ (float)((float)(COERCE_FLOAT(a1[1]) * a3)
+ (float)((float)(COERCE_FLOAT(*a1) * a2.m128_f32[0]) + _mm_shuffle_ps(v3, v3, 85).m128_f32[0]))) <= 0.0 )
return 0;
v4 = a1 + 3;
v5 = 0LL;
do
{
v6 = v5;
if ( v5 == 5 )
break;
v7 = _mm_mul_ps((__m128)*(v4 - 1), a2);
v8 = _mm_shuffle_ps((__m128)*v4, (__m128)*v4, 85).m128_f32[0]
+ (float)((float)(COERCE_FLOAT(*v4) * a3)
+ (float)((float)(COERCE_FLOAT(*(v4 - 1)) * a2.m128_f32[0]) + _mm_shuffle_ps(v7, v7, 85).m128_f32[0]));
v4 += 2;
++v5;
}
while ( v8 > 0.0 );
return v6 >= 5;
}
|
r3d_frustum_is_point_in:
MOVSD XMM2,qword ptr [RDI]
MOVSD XMM3,qword ptr [RDI + 0x8]
MOVAPS XMM4,XMM2
MULPS XMM4,XMM0
SHUFPS XMM4,XMM4,0x55
MULSS XMM2,XMM0
ADDSS XMM2,XMM4
MOVAPS XMM4,XMM3
MULSS XMM4,XMM1
ADDSS XMM4,XMM2
SHUFPS XMM3,XMM3,0x55
ADDSS XMM3,XMM4
XORPS XMM2,XMM2
UCOMISS XMM2,XMM3
JNC 0x001df5e1
PUSH RBP
MOV RBP,RSP
ADD RDI,0x18
XOR ECX,ECX
LAB_001df594:
MOV RAX,RCX
CMP RCX,0x5
JZ 0x001df5d8
MOVSD XMM3,qword ptr [RDI + -0x8]
MOVSD XMM4,qword ptr [RDI]
MOVAPS XMM5,XMM3
MULPS XMM5,XMM0
SHUFPS XMM5,XMM5,0x55
MULSS XMM3,XMM0
ADDSS XMM3,XMM5
MOVAPS XMM5,XMM4
MULSS XMM5,XMM1
ADDSS XMM5,XMM3
SHUFPS XMM4,XMM4,0x55
ADDSS XMM4,XMM5
ADD RDI,0x10
LEA RCX,[RAX + 0x1]
UCOMISS XMM2,XMM4
JC 0x001df594
LAB_001df5d8:
CMP RAX,0x5
SETNC AL
POP RBP
RET
LAB_001df5e1:
XOR EAX,EAX
RET
|
int8 r3d_frustum_is_point_in(int8 param_1,float param_2,int8 *param_3)
{
int8 *puVar1;
int8 uVar2;
ulong uVar3;
ulong uVar4;
float fVar5;
fVar5 = (float)((ulong)param_1 >> 0x20);
if ((float)((ulong)param_3[1] >> 0x20) +
(float)param_3[1] * param_2 +
(float)*param_3 * (float)param_1 + (float)((ulong)*param_3 >> 0x20) * fVar5 <= 0.0) {
return 0;
}
param_3 = param_3 + 3;
uVar3 = 0;
do {
uVar4 = uVar3;
if (uVar4 == 5) break;
puVar1 = param_3 + -1;
uVar2 = *param_3;
param_3 = param_3 + 2;
uVar3 = uVar4 + 1;
} while (0.0 < (float)((ulong)uVar2 >> 0x20) +
(float)uVar2 * param_2 +
(float)*puVar1 * (float)param_1 + (float)((ulong)*puVar1 >> 0x20) * fVar5);
return CONCAT71((int7)(uVar4 >> 8),4 < uVar4);
}
|
|
7,736 |
my_casedn_utf8mb4
|
eloqsql/strings/ctype-utf8.c
|
static size_t
my_casedn_utf8mb4(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->casedn_multiply == 1);
while ((src < srcend) &&
(srcres= my_mb_wc_utf8mb4(cs, &wc,
(uchar*) src, (uchar*) srcend)) > 0)
{
my_tolower_utf8mb4(uni_plane, &wc);
if ((dstres= my_wc_mb_utf8mb4(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
}
|
O0
|
c
|
my_casedn_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0xb8f6a
jmp 0xb8f6c
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0xb8f9c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xb8ae0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xb8fa5
jmp 0xb8ff8
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbcf40
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0xb8b10
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0xb8fd1
jmp 0xb8ff8
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 0xb8f6c
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
my_casedn_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
add rax, [rbp+var_18]
mov [rbp+var_40], rax
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
mov rax, [rbp+var_8]
mov rax, [rax+78h]
mov [rbp+var_58], rax
jmp short $+2
loc_B8F6A:
jmp short $+2
loc_B8F6C:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_B8F9C
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_B8F9C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_B8FA5
jmp short loc_B8FF8
loc_B8FA5:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_tolower_utf8mb4
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_wc_mb_utf8mb4
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_B8FD1
jmp short loc_B8FF8
loc_B8FD1:
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_B8F6C
loc_B8FF8:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
|
_BYTE * my_casedn_utf8mb4(long long a1, unsigned long long a2, long long a3, _BYTE *a4, long long a5, long long a6)
{
bool v7; // [rsp+7h] [rbp-59h]
long long v8; // [rsp+8h] [rbp-58h]
unsigned long long v10; // [rsp+18h] [rbp-48h]
unsigned long long v11; // [rsp+20h] [rbp-40h]
int v12; // [rsp+28h] [rbp-38h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14[2]; // [rsp+30h] [rbp-30h] BYREF
_BYTE *v15; // [rsp+40h] [rbp-20h]
long long v16; // [rsp+48h] [rbp-18h]
unsigned long long v17; // [rsp+50h] [rbp-10h]
long long v18; // [rsp+58h] [rbp-8h]
v18 = a1;
v17 = a2;
v16 = a3;
v15 = a4;
v14[1] = a5;
v11 = a3 + a2;
v10 = (unsigned long long)&a4[a5];
v8 = *(_QWORD *)(a1 + 120);
while ( 1 )
{
v7 = 0;
if ( v17 < v11 )
{
v13 = my_mb_wc_utf8mb4(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_tolower_utf8mb4(v8, v14);
v12 = my_wc_mb_utf8mb4(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
|
my_casedn_utf8mb4:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001b8f6a
LAB_001b8f6a:
JMP 0x001b8f6c
LAB_001b8f6c:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x001b8f9c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001b8ae0
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_001b8f9c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x001b8fa5
JMP 0x001b8ff8
LAB_001b8fa5:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x001bcf40
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 0x001b8b10
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x001b8fd1
JMP 0x001b8ff8
LAB_001b8fd1:
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 0x001b8f6c
LAB_001b8ff8:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_casedn_utf8mb4(long param_1,ulong param_2,long param_3,long param_4,long param_5)
{
int8 uVar1;
bool bVar2;
int iVar3;
int local_3c;
int8 local_38;
long local_30;
long local_28;
long local_20;
ulong local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
bVar2 = false;
if (local_18 < param_2 + param_3) {
local_3c = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_tolower_utf8mb4(uVar1,&local_38);
iVar3 = my_wc_mb_utf8mb4(local_10,local_38,local_28,param_4 + param_5);
if (iVar3 < 1) break;
local_18 = local_18 + (long)local_3c;
local_28 = local_28 + iVar3;
}
return local_28 - param_4;
}
|
|
7,737 |
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&)
|
monkey531[P]llama/common/json.hpp
|
std::pair<iterator, bool> emplace(const key_type& key, T&& t)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return {it, false};
}
}
Container::emplace_back(key, std::forward<T>(t));
return {std::prev(this->end()), true};
}
|
O2
|
cpp
|
nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::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>, minja::Value, std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const, minja::Value>>>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, minja::Value&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdi), %rbx
cmpq 0x8(%r14), %rbx
je 0x50dd5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4f2ca
testb %al, %al
jne 0x50def
addq $0x60, %rbx
jmp 0x50dba
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x50e00
movq 0x8(%r14), %rbx
addq $-0x60, %rbx
movb $0x1, %dl
jmp 0x50df1
xorl %edx, %edx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_ZN8nlohmann16json_abi_v3_11_311ordered_mapINS0_10basic_jsonIS1_St6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEN5minja5ValueESt4lessISD_ESaISt4pairIKSD_SF_EEE7emplaceERSJ_OSF_:
push r15
push r14
push r12
push rbx
push rax
mov r15, rdx
mov r12, rsi
mov r14, rdi
mov rbx, [rdi]
loc_50DBA:
cmp rbx, [r14+8]
jz short loc_50DD5
mov rdi, rbx
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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, al
jnz short loc_50DEF
add rbx, 60h ; '`'
jmp short loc_50DBA
loc_50DD5:
mov rdi, r14
mov rsi, r12
mov rdx, r15
call _ZNSt6vectorISt4pairIKN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES_IhSaIhEEvEEN5minja5ValueEESaISI_EE12emplace_backIJRSF_SH_EEERSI_DpOT_; std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value>(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,minja::Value &&)
mov rbx, [r14+8]
add rbx, 0FFFFFFFFFFFFFFA0h
mov dl, 1
jmp short loc_50DF1
loc_50DEF:
xor edx, edx
loc_50DF1:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
|
long long nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>>::emplace(
unsigned __int8 **a1,
unsigned __int8 *a2,
long long a3,
__m128d a4)
{
unsigned __int8 *i; // rbx
for ( i = *a1; i != a1[1]; i += 96 )
{
if ( nlohmann::json_abi_v3_11_3::operator==(i, a2, a4) )
return (long long)i;
}
std::vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const,minja::Value>>::emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const&,minja::Value>(
a1,
a2,
a3);
return (long long)(a1[1] - 96);
}
|
emplace:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,RDX
MOV R12,RSI
MOV R14,RDI
MOV RBX,qword ptr [RDI]
LAB_00150dba:
CMP RBX,qword ptr [R14 + 0x8]
JZ 0x00150dd5
MOV RDI,RBX
MOV RSI,R12
CALL 0x0014f2ca
TEST AL,AL
JNZ 0x00150def
ADD RBX,0x60
JMP 0x00150dba
LAB_00150dd5:
MOV RDI,R14
MOV RSI,R12
MOV RDX,R15
CALL 0x00150e00
MOV RBX,qword ptr [R14 + 0x8]
ADD RBX,-0x60
MOV DL,0x1
JMP 0x00150df1
LAB_00150def:
XOR EDX,EDX
LAB_00150df1:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* nlohmann::json_abi_v3_11_3::ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>, minja::Value,
std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >,
std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const, minja::Value> >
>::emplace(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, minja::Value&&) */
int1 [16] __thiscall
nlohmann::json_abi_v3_11_3::
ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::emplace(ordered_map<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,minja::Value,std::less<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*this,basic_json *param_1,Value *param_2)
{
char cVar1;
int8 extraout_RDX;
int8 uVar2;
basic_json *pbVar3;
int1 auVar4 [16];
pbVar3 = *(basic_json **)this;
do {
if (pbVar3 == *(basic_json **)(this + 8)) {
std::
vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
::
emplace_back<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,minja::Value>
((vector<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>,std::allocator<std::pair<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const,minja::Value>>>
*)this,param_1,param_2);
pbVar3 = (basic_json *)(*(long *)(this + 8) + -0x60);
uVar2 = CONCAT71((int7)((ulong)extraout_RDX >> 8),1);
LAB_00150df1:
auVar4._8_8_ = uVar2;
auVar4._0_8_ = pbVar3;
return auVar4;
}
cVar1 = operator==(pbVar3,param_1);
if (cVar1 != '\0') {
uVar2 = 0;
goto LAB_00150df1;
}
pbVar3 = pbVar3 + 0x60;
} while( true );
}
|
|
7,738 |
my_rw_trywrlock
|
eloqsql/mysys/thr_rwlock.c
|
int my_rw_trywrlock(my_rw_lock_t *rwp)
{
int res;
pthread_mutex_lock(&rwp->lock);
if (rwp->state)
res= EBUSY; /* Can't get lock */
else
{
res=0;
rwp->state = -1;
#ifdef SAFE_MUTEX
rwp->write_thread= pthread_self();
#endif
}
pthread_mutex_unlock(&rwp->lock);
return(res);
}
|
O3
|
c
|
my_rw_trywrlock:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2a230
movl $0x10, %r14d
cmpl $0x0, 0x88(%rbx)
jne 0xc3ea2
movl $0xffffffff, 0x88(%rbx) # imm = 0xFFFFFFFF
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2a1f0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
|
my_rw_trywrlock:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
call _pthread_mutex_lock
mov r14d, 10h
cmp dword ptr [rbx+88h], 0
jnz short loc_C3EA2
mov dword ptr [rbx+88h], 0FFFFFFFFh
xor r14d, r14d
loc_C3EA2:
mov rdi, rbx
call _pthread_mutex_unlock
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
|
long long my_rw_trywrlock(long long a1)
{
unsigned int v1; // r14d
pthread_mutex_lock(a1);
v1 = 16;
if ( !*(_DWORD *)(a1 + 136) )
{
*(_DWORD *)(a1 + 136) = -1;
v1 = 0;
}
pthread_mutex_unlock(a1);
return v1;
}
|
my_rw_trywrlock:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
CALL 0x0012a230
MOV R14D,0x10
CMP dword ptr [RBX + 0x88],0x0
JNZ 0x001c3ea2
MOV dword ptr [RBX + 0x88],0xffffffff
XOR R14D,R14D
LAB_001c3ea2:
MOV RDI,RBX
CALL 0x0012a1f0
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
|
int8 my_rw_trywrlock(pthread_mutex_t *param_1)
{
int8 uVar1;
pthread_mutex_lock(param_1);
uVar1 = 0x10;
if (*(int *)((long)param_1 + 0x88) == 0) {
*(int4 *)((long)param_1 + 0x88) = 0xffffffff;
uVar1 = 0;
}
pthread_mutex_unlock(param_1);
return uVar1;
}
|
|
7,739 |
js_symbol_toString
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_symbol_toString(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue val, ret;
val = js_thisSymbolValue(ctx, this_val);
if (JS_IsException(val))
return val;
/* XXX: use JS_ToStringInternal() with a flags */
ret = js_string_constructor(ctx, JS_UNDEFINED, 1, &val);
JS_FreeValue(ctx, val);
return ret;
}
|
O1
|
c
|
js_symbol_toString:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
callq 0x7db4e
movq %rax, %rbx
movq %rdx, %r14
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $0x6, %r14d
je 0x7da74
movq %rsp, %r8
movl $0x3, %edx
movq %r15, %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x37dc4
movq %rax, %r12
movq %rdx, %r13
movq 0x18(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1ccb2
movq %r12, %rbx
movq %r13, %r14
movq %rbx, %rax
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
js_symbol_toString:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r15, rdi
call js_thisSymbolValue
mov rbx, rax
mov r14, rdx
mov [rsp+38h+var_38], rax
mov [rsp+38h+var_30], rdx
cmp r14d, 6
jz short loc_7DA74
mov r8, rsp
mov edx, 3
mov rdi, r15
xor esi, esi
mov ecx, 1
call js_string_constructor
mov r12, rax
mov r13, rdx
mov rdi, [r15+18h]
mov rsi, rbx
mov rdx, r14
call JS_FreeValueRT
mov rbx, r12
mov r14, r13
loc_7DA74:
mov rax, rbx
mov rdx, r14
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
_DWORD * js_symbol_toString(
long long a1,
__m128 a2,
__m128 a3,
__m128 a4,
__m128 a5,
double a6,
double a7,
__m128 a8,
__m128 a9)
{
_DWORD *v9; // rbx
long long v10; // r9
__m128 v11; // xmm4
__m128 v12; // xmm5
long long v13; // rdx
long long v14; // r14
unsigned long long v15; // r12
long long v17[7]; // [rsp+0h] [rbp-38h] BYREF
v9 = (_DWORD *)js_thisSymbolValue();
v14 = v13;
v17[0] = (long long)v9;
v17[1] = v13;
if ( (_DWORD)v13 != 6 )
{
v15 = js_string_constructor(a1, 0LL, 3LL, 1, v17, v10, a2, a3, a4, a5, v11, v12, a8, a9);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v9, v14);
return (_DWORD *)v15;
}
return v9;
}
|
js_symbol_toString:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RDI
CALL 0x0017db4e
MOV RBX,RAX
MOV R14,RDX
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],RDX
CMP R14D,0x6
JZ 0x0017da74
MOV R8,RSP
MOV EDX,0x3
MOV RDI,R15
XOR ESI,ESI
MOV ECX,0x1
CALL 0x00137dc4
MOV R12,RAX
MOV R13,RDX
MOV RDI,qword ptr [R15 + 0x18]
MOV RSI,RBX
MOV RDX,R14
CALL 0x0011ccb2
MOV RBX,R12
MOV R14,R13
LAB_0017da74:
MOV RAX,RBX
MOV RDX,R14
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
int1 [16] js_symbol_toString(long param_1)
{
int8 uVar1;
int8 uVar2;
int1 auVar3 [16];
int1 local_38 [16];
auVar3 = js_thisSymbolValue();
uVar2 = auVar3._8_8_;
uVar1 = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
local_38 = auVar3;
auVar3 = js_string_constructor(param_1,0,3,1,local_38);
JS_FreeValueRT(*(int8 *)(param_1 + 0x18),uVar1,uVar2);
}
return auVar3;
}
|
|
7,740 |
ma_apply_redo_index_free_page
|
eloqsql/storage/maria/ma_key_recover.c
|
uint _ma_apply_redo_index_free_page(MARIA_HA *info,
LSN lsn,
const uchar *header)
{
pgcache_page_no_t page= page_korr(header);
pgcache_page_no_t free_page= page_korr(header + PAGE_STORE_SIZE);
my_off_t old_link;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
uchar *buff;
int result;
DBUG_ENTER("_ma_apply_redo_index_free_page");
DBUG_PRINT("enter", ("page: %lu free_page: %lu",
(ulong) page, (ulong) free_page));
share->state.changed|= (STATE_CHANGED | STATE_NOT_OPTIMIZED_KEYS |
STATE_NOT_SORTED_PAGES | STATE_NOT_ZEROFILLED |
STATE_NOT_MOVABLE);
if (cmp_translog_addr(lsn, share->state.is_of_horizon) >= 0)
share->state.key_del= (my_off_t) page * share->block_size;
old_link= ((free_page != IMPOSSIBLE_PAGE_NO) ?
(my_off_t) free_page * share->block_size :
HA_OFFSET_ERROR);
if (!(buff= pagecache_read(share->pagecache, &share->kfile,
page, 0, 0,
PAGECACHE_PLAIN_PAGE, PAGECACHE_LOCK_WRITE,
&page_link.link)))
{
result= (uint) my_errno;
_ma_set_fatal_error(info, my_errno);
goto err;
}
if (lsn_korr(buff) >= lsn)
{
/* Already applied */
check_skipped_lsn(info, lsn_korr(buff), 0, page);
result= 0;
goto err;
}
/* Free page */
bzero(buff + LSN_STORE_SIZE, share->keypage_header - LSN_STORE_SIZE);
_ma_store_keynr(share, buff, (uchar) MARIA_DELETE_KEY_NR);
_ma_store_page_used(share, buff, share->keypage_header + 8);
mi_sizestore(buff + share->keypage_header, old_link);
#ifdef IDENTICAL_PAGES_AFTER_RECOVERY
{
bzero(buff + share->keypage_header + 8,
share->block_size - share->keypage_header - 8 -
KEYPAGE_CHECKSUM_SIZE);
}
#endif
/* Mark page to be unlocked and written at _ma_unpin_all_pages() */
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= 1;
push_dynamic(&info->pinned_pages, (void*) &page_link);
DBUG_RETURN(0);
err:
pagecache_unlock_by_link(share->pagecache, page_link.link,
PAGECACHE_LOCK_WRITE_UNLOCK,
PAGECACHE_UNPIN, LSN_IMPOSSIBLE,
LSN_IMPOSSIBLE, 0, FALSE);
DBUG_RETURN(result);
}
|
O0
|
c
|
ma_apply_redo_index_free_page:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x42080
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
addq $0x5, %rdi
callq 0x42080
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0x420f2
movq -0x58(%rbp), %rax
movl 0x170(%rax), %ecx
orl $0x1b1, %ecx # imm = 0x1B1
movl %ecx, 0x170(%rax)
movq -0x18(%rbp), %rax
movq -0x58(%rbp), %rcx
subq 0x180(%rcx), %rax
cmpq $0x0, %rax
jl 0x4213a
movq -0x28(%rbp), %rcx
movq -0x58(%rbp), %rax
movl 0x7bc(%rax), %eax
imulq %rax, %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x120(%rax)
movabsq $0xffffffffff, %rax # imm = 0xFFFFFFFFFF
cmpq %rax, -0x30(%rbp)
je 0x42165
movq -0x30(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
imulq %rcx, %rax
movq %rax, -0x90(%rbp)
jmp 0x42175
movq $-0x1, %rax
movq %rax, -0x90(%rbp)
jmp 0x42175
movq -0x90(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x58(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x58(%rbp), %rsi
addq $0x750, %rsi # imm = 0x750
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x99430
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
jne 0x421f1
callq 0xfea30
movl (%rax), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0xfea30
movq -0x98(%rbp), %rdi
movl (%rax), %esi
callq 0x390d0
jmp 0x42426
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
movq -0x60(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
shlq $0x20, %rax
movq -0x60(%rbp), %rcx
movl 0x3(%rcx), %ecx
orq %rcx, %rax
cmpq -0x18(%rbp), %rax
jl 0x42276
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
movq -0x60(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x60(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x20, %rsi
movq -0x60(%rbp), %rax
movl 0x3(%rax), %eax
orq %rax, %rsi
movq -0x28(%rbp), %rcx
xorl %edx, %edx
callq 0x90290
movl $0x0, -0x64(%rbp)
jmp 0x42426
movq -0x60(%rbp), %rdi
addq $0x7, %rdi
movq -0x58(%rbp), %rax
movl 0x744(%rax), %eax
subl $0x7, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2a2a0
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
subl $0x1, %ecx
subl $0x1, %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movb $-0x1, (%rax,%rcx)
movq -0x58(%rbp), %rax
movl 0x744(%rax), %eax
addl $0x8, %eax
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %eax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x1(%rax,%rcx)
movl -0x68(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, -0x2(%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x38(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x3(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x8, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x2(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x10, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x1(%rax,%rcx)
movq -0x80(%rbp), %rax
shrq $0x18, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, (%rax,%rcx)
movq -0x70(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x7(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x8, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x6(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x10, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x5(%rax,%rcx)
movq -0x88(%rbp), %rax
shrq $0x18, %rax
movb %al, %dl
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movl 0x744(%rcx), %ecx
movb %dl, 0x4(%rax,%rcx)
movl $0x6, -0x48(%rbp)
movb $0x1, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x50(%rbp), %rsi
callq 0xdf950
movl $0x0, -0x4(%rbp)
jmp 0x42463
movq -0x58(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x50(%rbp), %rsi
movl $0x6, %edx
movl $0x3, %ecx
xorl %eax, %eax
movl %eax, %r9d
xorl %eax, %eax
movq %r9, %r8
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x991d0
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nop
|
_ma_apply_redo_index_free_page:
push rbp
mov rbp, rsp
sub rsp, 0B0h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rdi, [rbp+var_20]
call uint5korr
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
add rdi, 5
call uint5korr
mov [rbp+var_30], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_58], rax
jmp short $+2
loc_420F2:
mov rax, [rbp+var_58]
mov ecx, [rax+170h]
or ecx, 1B1h
mov [rax+170h], ecx
mov rax, [rbp+var_18]
mov rcx, [rbp+var_58]
sub rax, [rcx+180h]
cmp rax, 0
jl short loc_4213A
mov rcx, [rbp+var_28]
mov rax, [rbp+var_58]
mov eax, [rax+7BCh]
imul rcx, rax
mov rax, [rbp+var_58]
mov [rax+120h], rcx
loc_4213A:
mov rax, 0FFFFFFFFFFh
cmp [rbp+var_30], rax
jz short loc_42165
mov rax, [rbp+var_30]
mov rcx, [rbp+var_58]
mov ecx, [rcx+7BCh]
imul rax, rcx
mov [rbp+var_90], rax
jmp short loc_42175
loc_42165:
mov rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_90], rax
jmp short $+2
loc_42175:
mov rax, [rbp+var_90]
mov [rbp+var_38], rax
mov rax, [rbp+var_58]
mov rdi, [rax+600h]
mov rsi, [rbp+var_58]
add rsi, 750h
mov rdx, [rbp+var_28]
lea rax, [rbp+var_50]
xor ecx, ecx
xor r8d, r8d
mov r9d, 1
mov [rsp+0B0h+var_B0], 4
mov [rsp+0B0h+var_A8], rax
call pagecache_read
mov [rbp+var_60], rax
cmp rax, 0
jnz short loc_421F1
call _my_thread_var
mov eax, [rax]
mov [rbp+var_64], eax
mov rax, [rbp+var_10]
mov [rbp+var_98], rax
call _my_thread_var
mov rdi, [rbp+var_98]
mov esi, [rax]
call _ma_set_fatal_error
jmp loc_42426
loc_421F1:
mov rax, [rbp+var_60]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
shl rax, 20h
mov rcx, [rbp+var_60]
mov ecx, [rcx+3]
or rax, rcx
cmp rax, [rbp+var_18]
jl short loc_42276
mov rdi, [rbp+var_10]
mov rax, [rbp+var_60]
movzx eax, byte ptr [rax]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+1]
shl ecx, 8
or eax, ecx
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx+2]
shl ecx, 10h
or eax, ecx
mov eax, eax
mov esi, eax
shl rsi, 20h
mov rax, [rbp+var_60]
mov eax, [rax+3]
or rsi, rax
mov rcx, [rbp+var_28]
xor edx, edx
call check_skipped_lsn
mov [rbp+var_64], 0
jmp loc_42426
loc_42276:
mov rdi, [rbp+var_60]
add rdi, 7
mov rax, [rbp+var_58]
mov eax, [rax+744h]
sub eax, 7
mov eax, eax
mov edx, eax
xor esi, esi
call _memset
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
sub ecx, 1
sub ecx, 1
sub ecx, 2
mov ecx, ecx
mov byte ptr [rax+rcx], 0FFh
mov rax, [rbp+var_58]
mov eax, [rax+744h]
add eax, 8
mov [rbp+var_68], eax
mov eax, [rbp+var_68]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx-1], dl
mov eax, [rbp+var_68]
shr eax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx-2], dl
mov rax, [rbp+var_38]
mov [rbp+var_70], rax
mov rax, [rbp+var_38]
shr rax, 20h
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov [rbp+var_80], rax
mov rax, [rbp+var_80]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+3], dl
mov rax, [rbp+var_80]
shr rax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+2], dl
mov rax, [rbp+var_80]
shr rax, 10h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+1], dl
mov rax, [rbp+var_80]
shr rax, 18h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx], dl
mov rax, [rbp+var_70]
mov [rbp+var_88], rax
mov rax, [rbp+var_88]
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+7], dl
mov rax, [rbp+var_88]
shr rax, 8
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+6], dl
mov rax, [rbp+var_88]
shr rax, 10h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+5], dl
mov rax, [rbp+var_88]
shr rax, 18h
mov dl, al
mov rax, [rbp+var_60]
mov rcx, [rbp+var_58]
mov ecx, [rcx+744h]
mov [rax+rcx+4], dl
mov [rbp+var_48], 6
mov [rbp+var_40], 1
mov rdi, [rbp+var_10]
add rdi, 2E8h
lea rsi, [rbp+var_50]
call insert_dynamic
mov [rbp+var_4], 0
jmp short loc_42463
loc_42426:
mov rax, [rbp+var_58]
mov rdi, [rax+600h]
mov rsi, [rbp+var_50]
mov edx, 6
mov ecx, 3
xor eax, eax
mov r9d, eax
xor eax, eax
mov r8, r9
mov [rsp+0B0h+var_B0], 0
mov dword ptr [rsp+0B0h+var_A8], 0
call pagecache_unlock_by_link
mov eax, [rbp+var_64]
mov [rbp+var_4], eax
loc_42463:
mov eax, [rbp+var_4]
add rsp, 0B0h
pop rbp
retn
|
long long ma_apply_redo_index_free_page(_QWORD *a1, signed long long a2, unsigned int *a3)
{
long long v3; // rdi
const char *v4; // rsi
unsigned int *v5; // rax
long long v6; // rdx
long long v7; // rcx
long long v8; // r8
int v9; // r9d
_DWORD *v11; // [rsp+18h] [rbp-98h]
long long v12; // [rsp+20h] [rbp-90h]
unsigned long long v13; // [rsp+30h] [rbp-80h]
int v14; // [rsp+40h] [rbp-70h]
int v15; // [rsp+48h] [rbp-68h]
_BYTE v16[12]; // [rsp+4Ch] [rbp-64h]
long long v17; // [rsp+58h] [rbp-58h]
long long v18; // [rsp+60h] [rbp-50h] BYREF
int v19; // [rsp+68h] [rbp-48h]
char v20; // [rsp+70h] [rbp-40h]
unsigned long long v21; // [rsp+78h] [rbp-38h]
unsigned long long v22; // [rsp+80h] [rbp-30h]
unsigned long long v23; // [rsp+88h] [rbp-28h]
unsigned int *v24; // [rsp+90h] [rbp-20h]
signed long long v25; // [rsp+98h] [rbp-18h]
_DWORD *v26; // [rsp+A0h] [rbp-10h]
v26 = a1;
v25 = a2;
v24 = a3;
v23 = uint5korr(a3);
v22 = uint5korr((unsigned int *)((char *)v24 + 5));
v17 = *a1;
*(_DWORD *)(v17 + 368) |= 0x1B1u;
if ( v25 - *(_QWORD *)(v17 + 384) >= 0 )
*(_QWORD *)(v17 + 288) = *(unsigned int *)(v17 + 1980) * v23;
if ( v22 == 0xFFFFFFFFFFLL )
v12 = -1LL;
else
v12 = *(unsigned int *)(v17 + 1980) * v22;
v21 = v12;
v3 = *(_QWORD *)(v17 + 1536);
v4 = (const char *)(v17 + 1872);
*(_QWORD *)&v16[4] = pagecache_read(v3, (int)v17 + 1872, v23, 0, 0, 1, 4, (long long)&v18);
if ( !*(_QWORD *)&v16[4] )
{
*(_QWORD *)v16 = *(unsigned int *)my_thread_var(v3, v4);
v11 = v26;
v5 = (unsigned int *)my_thread_var(v3, v4);
ma_set_fatal_error(v11, *v5, v6, v7, v8, v9);
LABEL_11:
pagecache_unlock_by_link(*(_QWORD *)(v17 + 1536), v18, 6, 3, 0, 0, 0, 0);
return *(unsigned int *)v16;
}
if ( (long long)(*(unsigned int *)(*(_QWORD *)&v16[4] + 3LL) | ((unsigned long long)((*(unsigned __int8 *)(*(_QWORD *)&v16[4] + 2LL) << 16) | (unsigned int)(unsigned __int16)**(_WORD **)&v16[4]) << 32)) >= v25 )
{
check_skipped_lsn(
v26,
*(unsigned int *)(*(_QWORD *)&v16[4] + 3LL) | ((unsigned long long)((*(unsigned __int8 *)(*(_QWORD *)&v16[4] + 2LL) << 16) | (unsigned int)(unsigned __int16)**(_WORD **)&v16[4]) << 32),
0LL,
v23);
*(_DWORD *)v16 = 0;
goto LABEL_11;
}
memset(*(_QWORD *)&v16[4] + 7LL, 0LL, (unsigned int)(*(_DWORD *)(v17 + 1860) - 7));
*(_BYTE *)(*(_QWORD *)&v16[4] + (unsigned int)(*(_DWORD *)(v17 + 1860) - 4)) = -1;
v15 = *(_DWORD *)(v17 + 1860) + 8;
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) - 1LL) = v15;
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) - 2LL) = BYTE1(v15);
v14 = v21;
v13 = HIDWORD(v21);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 3LL) = BYTE4(v21);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 2LL) = BYTE1(v13);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 1LL) = BYTE2(v13);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860)) = BYTE3(v13);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 7LL) = v14;
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 6LL) = BYTE1(v14);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 5LL) = BYTE2(v14);
*(_BYTE *)(*(_QWORD *)&v16[4] + *(unsigned int *)(v17 + 1860) + 4LL) = HIBYTE(v14);
v19 = 6;
v20 = 1;
insert_dynamic(v26 + 186, &v18);
return 0;
}
|
_ma_apply_redo_index_free_page:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xb0
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00142080
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
ADD RDI,0x5
CALL 0x00142080
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001420f2
LAB_001420f2:
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX + 0x170]
OR ECX,0x1b1
MOV dword ptr [RAX + 0x170],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x58]
SUB RAX,qword ptr [RCX + 0x180]
CMP RAX,0x0
JL 0x0014213a
MOV RCX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x7bc]
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RAX + 0x120],RCX
LAB_0014213a:
MOV RAX,0xffffffffff
CMP qword ptr [RBP + -0x30],RAX
JZ 0x00142165
MOV RAX,qword ptr [RBP + -0x30]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x7bc]
IMUL RAX,RCX
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00142175
LAB_00142165:
MOV RAX,-0x1
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00142175
LAB_00142175:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x58]
ADD RSI,0x750
MOV RDX,qword ptr [RBP + -0x28]
LEA RAX,[RBP + -0x50]
XOR ECX,ECX
XOR R8D,R8D
MOV R9D,0x1
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x00199430
MOV qword ptr [RBP + -0x60],RAX
CMP RAX,0x0
JNZ 0x001421f1
CALL 0x001fea30
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x64],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x98],RAX
CALL 0x001fea30
MOV RDI,qword ptr [RBP + -0x98]
MOV ESI,dword ptr [RAX]
CALL 0x001390d0
JMP 0x00142426
LAB_001421f1:
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
SHL RAX,0x20
MOV RCX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RCX + 0x3]
OR RAX,RCX
CMP RAX,qword ptr [RBP + -0x18]
JL 0x00142276
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x60]
MOVZX EAX,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x1]
SHL ECX,0x8
OR EAX,ECX
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX + 0x2]
SHL ECX,0x10
OR EAX,ECX
MOV EAX,EAX
MOV ESI,EAX
SHL RSI,0x20
MOV RAX,qword ptr [RBP + -0x60]
MOV EAX,dword ptr [RAX + 0x3]
OR RSI,RAX
MOV RCX,qword ptr [RBP + -0x28]
XOR EDX,EDX
CALL 0x00190290
MOV dword ptr [RBP + -0x64],0x0
JMP 0x00142426
LAB_00142276:
MOV RDI,qword ptr [RBP + -0x60]
ADD RDI,0x7
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x744]
SUB EAX,0x7
MOV EAX,EAX
MOV EDX,EAX
XOR ESI,ESI
CALL 0x0012a2a0
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
SUB ECX,0x1
SUB ECX,0x1
SUB ECX,0x2
MOV ECX,ECX
MOV byte ptr [RAX + RCX*0x1],0xff
MOV RAX,qword ptr [RBP + -0x58]
MOV EAX,dword ptr [RAX + 0x744]
ADD EAX,0x8
MOV dword ptr [RBP + -0x68],EAX
MOV EAX,dword ptr [RBP + -0x68]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x1],DL
MOV EAX,dword ptr [RBP + -0x68]
SHR EAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + -0x2],DL
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x38]
SHR RAX,0x20
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x80],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x3],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x2],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x10
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x1],DL
MOV RAX,qword ptr [RBP + -0x80]
SHR RAX,0x18
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1],DL
MOV RAX,qword ptr [RBP + -0x70]
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x88]
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x7],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x8
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x6],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x10
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x5],DL
MOV RAX,qword ptr [RBP + -0x88]
SHR RAX,0x18
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RCX + 0x744]
MOV byte ptr [RAX + RCX*0x1 + 0x4],DL
MOV dword ptr [RBP + -0x48],0x6
MOV byte ptr [RBP + -0x40],0x1
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x50]
CALL 0x001df950
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00142463
LAB_00142426:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x50]
MOV EDX,0x6
MOV ECX,0x3
XOR EAX,EAX
MOV R9D,EAX
XOR EAX,EAX
MOV R8,R9
MOV dword ptr [RSP],0x0
MOV dword ptr [RSP + 0x8],0x0
CALL 0x001991d0
MOV EAX,dword ptr [RBP + -0x64]
MOV dword ptr [RBP + -0x4],EAX
LAB_00142463:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0xb0
POP RBP
RET
|
int4 _ma_apply_redo_index_free_page(long *param_1,long param_2,long param_3)
{
long lVar1;
long *plVar2;
int iVar3;
int3 *puVar4;
int4 *puVar5;
int8 *puVar6;
long local_98;
int4 local_6c;
int8 local_58;
int4 local_50;
int1 local_48;
long local_40;
long local_38;
long local_30;
long local_28;
long local_20;
long *local_18;
local_28 = param_3;
local_20 = param_2;
local_18 = param_1;
local_30 = uint5korr(param_3);
local_38 = uint5korr(local_28 + 5);
lVar1 = *local_18;
*(uint *)(lVar1 + 0x170) = *(uint *)(lVar1 + 0x170) | 0x1b1;
if (-1 < local_20 - *(long *)(lVar1 + 0x180)) {
*(ulong *)(lVar1 + 0x120) = local_30 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
if (local_38 == 0xffffffffff) {
local_98 = -1;
}
else {
local_98 = local_38 * (ulong)*(uint *)(lVar1 + 0x7bc);
}
local_40 = local_98;
puVar6 = &local_58;
puVar4 = (int3 *)
pagecache_read(*(int8 *)(lVar1 + 0x600),lVar1 + 0x750,local_30,0,0,1,4,puVar6);
if (puVar4 == (int3 *)0x0) {
puVar5 = (int4 *)_my_thread_var();
plVar2 = local_18;
local_6c = *puVar5;
puVar5 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar2,*puVar5);
}
else {
if ((long)(ulong)CONCAT34(*puVar4,*(int4 *)((long)puVar4 + 3)) < local_20) {
memset((void *)((long)puVar4 + 7),0,(ulong)(*(int *)(lVar1 + 0x744) - 7));
*(int1 *)((long)puVar4 + (ulong)(*(int *)(lVar1 + 0x744) - 4)) = 0xff;
iVar3 = *(int *)(lVar1 + 0x744) + 8;
*(char *)((long)puVar4 + ((ulong)*(uint *)(lVar1 + 0x744) - 1)) = (char)iVar3;
*(char *)((long)puVar4 + ((ulong)*(uint *)(lVar1 + 0x744) - 2)) = (char)((uint)iVar3 >> 8);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 3) =
(char)((ulong)local_40 >> 0x20);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 2) =
(char)((ulong)local_40 >> 0x28);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 1) =
(char)((ulong)local_40 >> 0x30);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744)) = (char)((ulong)local_40 >> 0x38);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 7) = (char)local_40;
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 6) = (char)((ulong)local_40 >> 8);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 5) =
(char)((ulong)local_40 >> 0x10);
*(char *)((long)puVar4 + (ulong)*(uint *)(lVar1 + 0x744) + 4) =
(char)((ulong)local_40 >> 0x18);
local_50 = 6;
local_48 = 1;
insert_dynamic(local_18 + 0x5d,&local_58);
return 0;
}
check_skipped_lsn(local_18,(ulong)CONCAT34(*puVar4,*(int4 *)((long)puVar4 + 3)),0,local_30
);
local_6c = 0;
}
pagecache_unlock_by_link
(*(int8 *)(lVar1 + 0x600),local_58,6,3,0,0,0,(ulong)puVar6 & 0xffffffff00000000);
return local_6c;
}
|
|
7,741 |
mi_recinfo_write
|
eloqsql/storage/myisam/mi_open.c
|
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
{
uchar buff[MI_COLUMNDEF_SIZE];
uchar *ptr=buff;
mi_int2store(ptr,recinfo->type); ptr +=2;
mi_int2store(ptr,recinfo->length); ptr +=2;
*ptr++ = recinfo->null_bit;
mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
}
|
O0
|
c
|
mi_recinfo_write:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
leaq -0xf(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movb -0x2c(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x2b(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movb -0x30(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x2f(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb 0xc(%rax), %dl
movq -0x28(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax)
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, -0x34(%rbp)
movb -0x34(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x33(%rbp), %dl
movq -0x28(%rbp), %rax
movb %dl, (%rax)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %r8
subq %rcx, %r8
leaq 0x1bdc0e(%rip), %rdi # 0x14395c6
movl $0x4e3, %esi # imm = 0x4E3
movl $0x4, %r9d
callq 0x127a6d0
testq %rax, %rax
setne %al
movzbl %al, %eax
movl %eax, -0x38(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x127b9ef
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
callq 0x758480
nopw %cs:(%rax,%rax)
|
mi_recinfo_write:
push rbp
mov rbp, rsp
sub rsp, 40h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_14], edi
mov [rbp+var_20], rsi
lea rcx, [rbp+var_F]
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
mov eax, [rax]
mov [rbp+var_2C], eax
mov dl, byte ptr [rbp+var_2C]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_2C+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+4]
mov [rbp+var_30], eax
mov dl, byte ptr [rbp+var_30]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_30+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov rax, [rbp+var_20]
mov dl, [rax+0Ch]
mov rax, [rbp+var_28]
mov rsi, rax
inc rsi
mov [rbp+var_28], rsi
mov [rax], dl
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+0Eh]
mov [rbp+var_34], eax
mov dl, byte ptr [rbp+var_34]
mov rax, [rbp+var_28]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_34+1]
mov rax, [rbp+var_28]
mov [rax], dl
mov rax, [rbp+var_28]
add rax, 2
mov [rbp+var_28], rax
mov edx, [rbp+var_14]
mov r8, [rbp+var_28]
sub r8, rcx
lea rdi, aWorkspaceLlm4b_329; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 4E3h
mov r9d, 4
call inline_mysql_file_write_4
test rax, rax
setnz al
movzx eax, al
mov [rbp+var_38], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_127B9EF
mov eax, [rbp+var_38]
add rsp, 40h
pop rbp
retn
loc_127B9EF:
call ___stack_chk_fail
|
_BOOL8 mi_recinfo_write(unsigned int a1, long long a2)
{
__int16 v2; // kr00_2
__int16 v3; // kr02_2
__int16 v4; // kr04_2
_BYTE v6[7]; // [rsp+31h] [rbp-Fh] BYREF
unsigned long long v7; // [rsp+38h] [rbp-8h]
v7 = __readfsqword(0x28u);
v2 = *(_DWORD *)a2;
v6[0] = HIBYTE(v2);
v6[1] = v2;
v3 = *(_WORD *)(a2 + 4);
v6[2] = HIBYTE(v3);
v6[3] = v3;
v6[4] = *(_BYTE *)(a2 + 12);
v4 = *(_WORD *)(a2 + 14);
v6[5] = HIBYTE(v4);
v6[6] = v4;
return inline_mysql_file_write_4(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_open.c",
0x4E3u,
a1,
(long long)v6,
7LL,
4LL) != 0;
}
|
buf_print_io_instance:
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
JMP 0x0127b903
LAB_0127b903:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX]
MOV R8,qword ptr [RAX + 0x8]
MOV RCX,qword ptr [RAX + 0x18]
MOV R9,qword ptr [RAX + 0x10]
MOV RBX,qword ptr [RAX + 0x20]
MOVQ XMM0,RBX
MOVAPS XMM3,xmmword ptr [0x015446b0]
PUNPCKLDQ XMM0,XMM3
MOVAPD XMM2,xmmword ptr [0x015446c0]
SUBPD XMM0,XMM2
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOV RAX,R8
ADD RAX,RCX
MOVQ XMM1,RAX
PUNPCKLDQ XMM1,XMM3
SUBPD XMM1,XMM2
MOVAPS XMM2,XMM1
UNPCKHPD XMM1,XMM1
ADDSD XMM1,XMM2
MOVSD XMM2,qword ptr [0x01544338]
ADDSD XMM1,XMM2
DIVSD XMM0,XMM1
MOVSD XMM1,qword ptr [0x015443a8]
MULSD XMM0,XMM1
LEA RAX,[0x265e600]
MOVSD XMM1,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x10]
MOV R11,qword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x10]
MOV R10,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
LEA RSI,[0x152de3a]
MOV qword ptr [RSP],RBX
MOV qword ptr [RSP + 0x8],R11
MOV qword ptr [RSP + 0x10],R10
MOV qword ptr [RSP + 0x18],RAX
MOV AL,0x2
CALL 0x00859490
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x48]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0x50]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0x98]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM1,qword ptr [RAX + 0xa0]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0x60]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x68]
MOV RSI,qword ptr [RBP + -0x10]
MOVSD XMM2,qword ptr [RSI + 0xa8]
MOV RSI,qword ptr [RBP + -0x10]
MOVSD XMM3,qword ptr [RSI + 0xb0]
MOV RSI,qword ptr [RBP + -0x10]
MOVSD XMM4,qword ptr [RSI + 0xb8]
LEA RSI,[0x152df35]
MOV qword ptr [RSP],RAX
MOV AL,0x5
CALL 0x00859490
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x90],0x0
JZ 0x0127bbc8
MOV RAX,qword ptr [RBP + -0x10]
MOVQ XMM0,qword ptr [RAX + 0xc0]
MOVAPS XMM3,xmmword ptr [0x015446b0]
PUNPCKLDQ XMM0,XMM3
MOVAPD XMM2,xmmword ptr [0x015446c0]
SUBPD XMM0,XMM2
MOVAPS XMM1,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM1
MOVQ XMM1,qword ptr [RAX + 0x90]
PUNPCKLDQ XMM1,XMM3
SUBPD XMM1,XMM2
MOVAPS XMM2,XMM1
UNPCKHPD XMM1,XMM1
ADDSD XMM1,XMM2
DIVSD XMM0,XMM1
MOVSD qword ptr [RBP + -0x20],XMM0
MOVSD XMM0,qword ptr [RBP + -0x20]
MOVSD XMM1,qword ptr [0x01544338]
UCOMISD XMM0,XMM1
JBE 0x0127bac1
MOVSD XMM0,qword ptr [0x01544338]
MOVSD qword ptr [RBP + -0x20],XMM0
LAB_0127bac1:
MOV RDI,qword ptr [RBP + -0x18]
MOVSD XMM1,qword ptr [RBP + -0x20]
MOVSD XMM0,qword ptr [0x01544338]
SUBSD XMM0,XMM1
MOVSD XMM3,qword ptr [0x015443c0]
MULSD XMM0,XMM3
MOVAPS XMM1,XMM0
CVTTSD2SI RDX,XMM1
MOV RCX,RDX
SAR RCX,0x3f
MOVSD XMM1,qword ptr [0x015442d0]
SUBSD XMM0,XMM1
CVTTSD2SI RAX,XMM0
AND RAX,RCX
OR RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOVQ XMM0,qword ptr [RAX + 0xc8]
MOVAPS XMM5,xmmword ptr [0x015446b0]
PUNPCKLDQ XMM0,XMM5
MOVAPD XMM4,xmmword ptr [0x015446c0]
SUBPD XMM0,XMM4
MOVAPS XMM2,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM2
MULSD XMM0,XMM3
MOVQ XMM2,qword ptr [RAX + 0x90]
PUNPCKLDQ XMM2,XMM5
SUBPD XMM2,XMM4
MOVAPS XMM6,XMM2
UNPCKHPD XMM2,XMM2
ADDSD XMM2,XMM6
DIVSD XMM0,XMM2
MOVAPS XMM6,XMM0
CVTTSD2SI RCX,XMM6
MOV R8,RCX
SAR R8,0x3f
SUBSD XMM0,XMM1
CVTTSD2SI RSI,XMM0
AND RSI,R8
OR RCX,RSI
MOVQ XMM0,qword ptr [RAX + 0xd0]
PUNPCKLDQ XMM0,XMM5
SUBPD XMM0,XMM4
MOVAPS XMM4,XMM0
UNPCKHPD XMM0,XMM0
ADDSD XMM0,XMM4
MULSD XMM0,XMM3
DIVSD XMM0,XMM2
MOVAPS XMM2,XMM0
CVTTSD2SI R8,XMM2
MOV RSI,R8
SAR RSI,0x3f
SUBSD XMM0,XMM1
CVTTSD2SI RAX,XMM0
AND RAX,RSI
OR R8,RAX
LEA RSI,[0x152dfd0]
MOV AL,0x0
CALL 0x00859490
JMP 0x0127bbd8
LAB_0127bbc8:
MOV RSI,qword ptr [RBP + -0x18]
LEA RDI,[0x152e01e]
CALL 0x008584f0
LAB_0127bbd8:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM0,qword ptr [RAX + 0xe0]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM1,qword ptr [RAX + 0xe8]
MOV RAX,qword ptr [RBP + -0x10]
MOVSD XMM2,qword ptr [RAX + 0xd8]
LEA RSI,[0x152e050]
MOV AL,0x3
CALL 0x00859490
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RAX + 0xf0]
MOV RAX,qword ptr [RBP + -0x10]
MOV R8,qword ptr [RAX + 0xf8]
MOV RAX,qword ptr [RBP + -0x10]
MOV R9,qword ptr [RAX + 0x100]
MOV RAX,qword ptr [RBP + -0x10]
MOV R10,qword ptr [RAX + 0x108]
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x110]
LEA RSI,[0x152e0a2]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV AL,0x0
CALL 0x00859490
ADD RSP,0x38
POP RBX
POP RBP
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* buf_print_io_instance(buf_pool_info_t*, _IO_FILE*) */
void buf_print_io_instance(buf_pool_info_t *param_1,_IO_FILE *param_2)
{
int8 uVar1;
int8 uVar2;
long lVar3;
ulong uVar4;
ulong uVar5;
ulong uVar6;
double dVar7;
double dVar8;
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int1 auVar12 [16];
int1 auVar13 [16];
int1 auVar14 [16];
double dVar15;
int1 auVar16 [16];
double local_28;
uVar2 = *(int8 *)(param_1 + 0x20);
auVar9._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar9._0_8_ = uVar2;
auVar9._12_4_ = _UNK_015446b4;
lVar3 = *(long *)(param_1 + 8) + *(long *)(param_1 + 0x18);
auVar13._8_4_ = (int)((ulong)lVar3 >> 0x20);
auVar13._0_8_ = lVar3;
auVar13._12_4_ = _UNK_015446b4;
fprintf(param_2,
"Buffer pool size %zu\nFree buffers %zu\nDatabase pages %zu\nOld database pages %zu\nModified db pages %zu\nPercent of dirty pages(LRU & free pages): %.3f\nMax dirty pages percent: %.3f\nPending reads %zu\nPending writes: LRU %zu, flush list %zu\n"
,(((auVar9._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar2) - _DAT_015446c0)) /
((auVar13._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)lVar3) - _DAT_015446c0) + DAT_01544338)) *
DAT_015443a8,srv_max_buf_pool_modified_pct,*(int8 *)param_1,
*(long *)(param_1 + 0x18),*(long *)(param_1 + 8),*(int8 *)(param_1 + 0x10),uVar2,
*(int8 *)(param_1 + 0x30),*(int8 *)(param_1 + 0x38),
*(int8 *)(param_1 + 0x40));
fprintf(param_2,
"Pages made young %zu, not young %zu\n%.2f youngs/s, %.2f non-youngs/s\nPages read %zu, created %zu, written %zu\n%.2f reads/s, %.2f creates/s, %.2f writes/s\n"
,*(int8 *)(param_1 + 0x98),*(int8 *)(param_1 + 0xa0),
*(int8 *)(param_1 + 0xa8),*(int8 *)(param_1 + 0xb0),
*(int8 *)(param_1 + 0xb8),*(int8 *)(param_1 + 0x48),
*(int8 *)(param_1 + 0x50),*(int8 *)(param_1 + 0x58),
*(int8 *)(param_1 + 0x60),*(int8 *)(param_1 + 0x68));
if (*(long *)(param_1 + 0x90) == 0) {
fputs("No buffer pool page gets since the last printout\n",param_2);
}
else {
uVar2 = *(int8 *)(param_1 + 0xc0);
auVar10._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar10._0_8_ = uVar2;
auVar10._12_4_ = _UNK_015446b4;
uVar1 = *(int8 *)(param_1 + 0x90);
auVar14._8_4_ = (int)((ulong)uVar1 >> 0x20);
auVar14._0_8_ = uVar1;
auVar14._12_4_ = _UNK_015446b4;
local_28 = ((auVar10._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar2) - _DAT_015446c0)) /
((auVar14._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar1) - _DAT_015446c0));
if (DAT_01544338 < local_28) {
local_28 = DAT_01544338;
}
dVar7 = (DAT_01544338 - local_28) * DAT_015443c0;
uVar5 = (ulong)dVar7;
uVar2 = *(int8 *)(param_1 + 200);
auVar11._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar11._0_8_ = uVar2;
auVar11._12_4_ = _UNK_015446b4;
uVar1 = *(int8 *)(param_1 + 0x90);
auVar16._8_4_ = (int)((ulong)uVar1 >> 0x20);
auVar16._0_8_ = uVar1;
auVar16._12_4_ = _UNK_015446b4;
dVar15 = (auVar16._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar1) - _DAT_015446c0);
dVar8 = (((auVar11._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar2) - _DAT_015446c0)) * DAT_015443c0) / dVar15;
uVar4 = (ulong)dVar8;
uVar2 = *(int8 *)(param_1 + 0xd0);
auVar12._8_4_ = (int)((ulong)uVar2 >> 0x20);
auVar12._0_8_ = uVar2;
auVar12._12_4_ = _UNK_015446b4;
dVar15 = (((auVar12._8_8_ - _UNK_015446c8) +
((double)CONCAT44(_DAT_015446b0,(int)uVar2) - _DAT_015446c0)) * DAT_015443c0) / dVar15
;
uVar6 = (ulong)dVar15;
fprintf(param_2,"Buffer pool hit rate %zu / 1000, young-making rate %zu / 1000 not %zu / 1000\n"
,uVar5 | (long)(dVar7 - DAT_015442d0) & (long)uVar5 >> 0x3f,
uVar4 | (long)(dVar8 - DAT_015442d0) & (long)uVar4 >> 0x3f,
uVar6 | (long)(dVar15 - DAT_015442d0) & (long)uVar6 >> 0x3f);
}
fprintf(param_2,
"Pages read ahead %.2f/s, evicted without access %.2f/s, Random read ahead %.2f/s\n",
*(int8 *)(param_1 + 0xe0),*(int8 *)(param_1 + 0xe8),
*(int8 *)(param_1 + 0xd8));
fprintf(param_2,
"LRU len: %zu, unzip_LRU len: %zu\nI/O sum[%zu]:cur[%zu], unzip sum[%zu]:cur[%zu]\n",
*(int8 *)(param_1 + 8),*(int8 *)(param_1 + 0xf0),
*(int8 *)(param_1 + 0xf8),*(int8 *)(param_1 + 0x100),
*(int8 *)(param_1 + 0x108),*(int8 *)(param_1 + 0x110));
return;
}
|
|
7,742 |
stbi_loadf_from_memory
|
monkey531[P]llama/examples/llava/../../common/stb_image.h
|
STBIDEF float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__loadf_main(&s,x,y,comp,req_comp);
}
|
O3
|
c
|
stbi_loadf_from_memory:
subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, %r8d
callq 0x28e51
addq $0xe8, %rsp
retq
|
stbi_loadf_from_memory:
sub rsp, 0E8h
lea rax, [rsp+0E8h+var_E0]
mov qword ptr [rax+10h], 0
xor r10d, r10d
mov [rax+30h], r10d
mov [rax+0B8h], r10d
mov [rax+0D0h], rdi
mov [rax+0C0h], rdi
movsxd rsi, esi
add rsi, rdi
mov [rax+0D8h], rsi
mov [rax+0C8h], rsi
mov rdi, rax
mov rsi, rdx
mov rdx, rcx
mov rcx, r8
mov r8d, r9d
call _ZL16stbi__loadf_mainP13stbi__contextPiS1_S1_i; stbi__loadf_main(stbi__context *,int *,int *,int *,int)
add rsp, 0E8h
retn
|
long long stbi_loadf_from_memory(long long a1, int a2, long long a3, long long a4, long long a5, unsigned int a6)
{
_BYTE v7[16]; // [rsp+8h] [rbp-E0h] BYREF
long long v8; // [rsp+18h] [rbp-D0h]
int v9; // [rsp+38h] [rbp-B0h]
int v10; // [rsp+C0h] [rbp-28h]
long long v11; // [rsp+C8h] [rbp-20h]
long long v12; // [rsp+D0h] [rbp-18h]
long long v13; // [rsp+D8h] [rbp-10h]
long long v14; // [rsp+E0h] [rbp-8h]
v8 = 0LL;
v9 = 0;
v10 = 0;
v13 = a1;
v11 = a1;
v14 = a1 + a2;
v12 = v14;
return stbi__loadf_main(v7, a3, a4, a5, a6);
}
|
stbi_loadf_from_memory:
SUB RSP,0xe8
LEA RAX,[RSP + 0x8]
MOV qword ptr [RAX + 0x10],0x0
XOR R10D,R10D
MOV dword ptr [RAX + 0x30],R10D
MOV dword ptr [RAX + 0xb8],R10D
MOV qword ptr [RAX + 0xd0],RDI
MOV qword ptr [RAX + 0xc0],RDI
MOVSXD RSI,ESI
ADD RSI,RDI
MOV qword ptr [RAX + 0xd8],RSI
MOV qword ptr [RAX + 0xc8],RSI
MOV RDI,RAX
MOV RSI,RDX
MOV RDX,RCX
MOV RCX,R8
MOV R8D,R9D
CALL 0x00128e51
ADD RSP,0xe8
RET
|
void stbi_loadf_from_memory
(long param_1,int param_2,int *param_3,int *param_4,int *param_5,int param_6)
{
stbi__context local_e0 [16];
int8 local_d0;
int4 local_b0;
int4 local_28;
long local_20;
long local_18;
long local_10;
long local_8;
local_d0 = 0;
local_b0 = 0;
local_28 = 0;
local_18 = param_2 + param_1;
local_20 = param_1;
local_10 = param_1;
local_8 = local_18;
stbi__loadf_main(local_e0,param_3,param_4,param_5,param_6);
return;
}
|
|
7,743 |
spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&, spdlog::details::async_msg_type, spdlog::details::log_msg const&)
|
AlayaLite/build_O3/_deps/spdlog-src/include/spdlog/details/thread_pool.h
|
async_msg(async_logger_ptr &&worker, async_msg_type the_type, const details::log_msg &m)
: log_msg_buffer{m},
msg_type{the_type},
worker_ptr{std::move(worker)},
flush_promise{} {}
|
O3
|
c
|
spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&, spdlog::details::async_msg_type, spdlog::details::log_msg const&):
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rcx, %rsi
callq 0x2c9c4
movl %ebp, 0x180(%rbx)
xorl %eax, %eax
movq %rax, 0x190(%rbx)
movups (%r14), %xmm0
movq %rax, 0x8(%r14)
movups %xmm0, 0x188(%rbx)
movq %rax, (%r14)
leaq 0x198(%rbx), %rdi
callq 0x3f582
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq 0x190(%rbx), %rdi
testq %rdi, %rdi
je 0x3f572
callq 0x1912a
movq %rbx, %rdi
callq 0x12c7d
movq %r14, %rdi
callq 0x11760
|
_ZN6spdlog7details9async_msgC2EOSt10shared_ptrINS_12async_loggerEENS0_14async_msg_typeERKNS0_7log_msgE:
push rbp
push r14
push rbx
mov ebp, edx
mov r14, rsi
mov rbx, rdi
mov rsi, rcx
call _ZN6spdlog7details14log_msg_bufferC2ERKNS0_7log_msgE; spdlog::details::log_msg_buffer::log_msg_buffer(spdlog::details::log_msg const&)
mov [rbx+180h], ebp
xor eax, eax
mov [rbx+190h], rax
movups xmm0, xmmword ptr [r14]
mov [r14+8], rax
movups xmmword ptr [rbx+188h], xmm0
mov [r14], rax
lea rdi, [rbx+198h]
call _ZNSt7promiseIvEC2Ev; std::promise<void>::promise(void)
pop rbx
pop r14
pop rbp
retn
mov r14, rax
mov rdi, [rbx+190h]
test rdi, rdi
jz short loc_3F572
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_3F572:
mov rdi, rbx
call _ZN6spdlog7details9async_msgC2EOSt10shared_ptrINS_12async_loggerEENS0_14async_msg_typeERKNS0_7log_msgE_cold_1; spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger> &&,spdlog::details::async_msg_type,spdlog::details::log_msg const&) [clone]
mov rdi, r14
call __Unwind_Resume
|
long long spdlog::details::async_msg::async_msg(long long a1, __int128 *a2, int a3, const void *a4)
{
__int128 v5; // xmm0
spdlog::details::log_msg_buffer::log_msg_buffer((_QWORD *)a1, a4);
*(_DWORD *)(a1 + 384) = a3;
*(_QWORD *)(a1 + 400) = 0LL;
v5 = *a2;
*((_QWORD *)a2 + 1) = 0LL;
*(_OWORD *)(a1 + 392) = v5;
*(_QWORD *)a2 = 0LL;
return std::promise<void>::promise(a1 + 408);
}
|
async_msg:
PUSH RBP
PUSH R14
PUSH RBX
MOV EBP,EDX
MOV R14,RSI
MOV RBX,RDI
MOV RSI,RCX
CALL 0x0012c9c4
MOV dword ptr [RBX + 0x180],EBP
XOR EAX,EAX
MOV qword ptr [RBX + 0x190],RAX
MOVUPS XMM0,xmmword ptr [R14]
MOV qword ptr [R14 + 0x8],RAX
MOVUPS xmmword ptr [RBX + 0x188],XMM0
MOV qword ptr [R14],RAX
LEA RDI,[RBX + 0x198]
LAB_0013f554:
CALL 0x0013f582
LAB_0013f559:
POP RBX
POP R14
POP RBP
RET
|
/* spdlog::details::async_msg::async_msg(std::shared_ptr<spdlog::async_logger>&&,
spdlog::details::async_msg_type, spdlog::details::log_msg const&) */
void __thiscall
spdlog::details::async_msg::async_msg
(async_msg *this,int8 *param_1,int4 param_3,log_msg *param_4)
{
int8 uVar1;
log_msg_buffer::log_msg_buffer((log_msg_buffer *)this,param_4);
*(int4 *)(this + 0x180) = param_3;
*(int8 *)(this + 400) = 0;
uVar1 = param_1[1];
param_1[1] = 0;
*(int8 *)(this + 0x188) = *param_1;
*(int8 *)(this + 400) = uVar1;
*param_1 = 0;
/* try { // try from 0013f554 to 0013f558 has its CatchHandler @ 0013f55e */
std::promise<void>::promise((promise<void> *)(this + 0x198));
return;
}
|
|
7,744 |
thr_print_locks
|
eloqsql/mysys/thr_lock.c
|
void thr_print_locks(void)
{
LIST *list;
uint count=0;
mysql_mutex_lock(&THR_LOCK_lock);
puts("Current active THR (table level locks):");
for (list= thr_lock_thread_list; list && count++ < MAX_THREADS;
list= list_rest(list))
{
THR_LOCK *lock=(THR_LOCK*) list->data;
mysql_mutex_lock(&lock->mutex);
if ((lock->write.data || lock->read.data ||
lock->write_wait.data || lock->read_wait.data))
{
printf("lock: %p:", lock);
if ((lock->write_wait.data || lock->read_wait.data) &&
(! lock->read.data && ! lock->write.data))
printf(" WARNING: ");
if (lock->write.data)
printf(" write");
if (lock->write_wait.data)
printf(" write_wait");
if (lock->read.data)
printf(" read");
if (lock->read_wait.data)
printf(" read_wait");
puts("");
thr_print_lock("write",&lock->write);
thr_print_lock("write_wait",&lock->write_wait);
thr_print_lock("read",&lock->read);
thr_print_lock("read_wait",&lock->read_wait);
puts("");
}
mysql_mutex_unlock(&lock->mutex);
}
fflush(stdout);
mysql_mutex_unlock(&THR_LOCK_lock);
}
|
O3
|
c
|
thr_print_locks:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0xb647d9(%rip), %rax # 0xc08778
cmpq $0x0, 0x40(%rax)
jne 0xa41dc
leaq 0xb647c7(%rip), %rdi # 0xc08778
callq 0x29220
leaq 0x38886(%rip), %rdi # 0xdc843
callq 0x297e0
leaq 0xb64a5f(%rip), %rax # 0xc08a28
movq (%rax), %r15
testq %r15, %r15
je 0xa41a3
movl $0x3e9, %ebx # imm = 0x3E9
decl %ebx
je 0xa41a3
movq 0x10(%r15), %r14
leaq 0x18(%r14), %r12
cmpq $0x0, 0x58(%r14)
jne 0xa4178
movq %r12, %rdi
callq 0x29220
cmpq $0x0, 0x90(%r14)
jne 0xa4023
cmpq $0x0, 0x70(%r14)
jne 0xa4023
cmpq $0x0, 0x80(%r14)
jne 0xa4023
cmpq $0x0, 0x60(%r14)
je 0xa4140
movq %r15, -0x38(%rbp)
leaq 0x90(%r14), %r15
movl $0x1, %edi
leaq 0x38831(%rip), %rsi # 0xdc86b
movq %r14, %rdx
xorl %eax, %eax
callq 0x29810
cmpq $0x0, 0x80(%r14)
jne 0xa4055
cmpq $0x0, 0x60(%r14)
je 0xa405c
cmpq $0x0, 0x70(%r14)
je 0xa4064
cmpq $0x0, (%r15)
jne 0xa406e
jmp 0xa4081
cmpq $0x0, (%r15)
je 0xa4160
movl $0x1, %edi
leaq 0x38806(%rip), %rsi # 0xdc880
xorl %eax, %eax
callq 0x29810
movq %r12, -0x40(%rbp)
leaq 0x80(%r14), %r12
cmpq $0x0, (%r12)
je 0xa40a6
movl $0x1, %edi
leaq 0x387e8(%rip), %rsi # 0xdc887
xorl %eax, %eax
callq 0x29810
cmpq $0x0, 0x70(%r14)
je 0xa40c0
movl $0x1, %edi
leaq 0x3c5dc(%rip), %rsi # 0xe0695
xorl %eax, %eax
callq 0x29810
movl %ebx, -0x2c(%rbp)
cmpq $0x0, 0x60(%r14)
je 0xa40dd
movl $0x1, %edi
leaq 0x387bd(%rip), %rsi # 0xdc893
xorl %eax, %eax
callq 0x29810
leaq 0x70(%r14), %r13
leaq 0x60(%r14), %rbx
movl $0xa, %edi
callq 0x29900
leaq 0x3878b(%rip), %rdi # 0xdc881
movq %r15, %rsi
callq 0xa41f8
leaq 0x38783(%rip), %rdi # 0xdc888
movq %r12, %rsi
callq 0xa41f8
leaq 0x3c582(%rip), %rdi # 0xe0696
movq %r13, %rsi
callq 0xa41f8
leaq 0x38771(%rip), %rdi # 0xdc894
movq %rbx, %rsi
callq 0xa41f8
movl $0xa, %edi
callq 0x29900
movl -0x2c(%rbp), %ebx
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r15
movq 0x58(%r14), %rdi
testq %rdi, %rdi
jne 0xa4191
movq %r12, %rdi
callq 0x291e0
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xa3fda
jmp 0xa41a3
movl $0x1, %edi
leaq 0x38709(%rip), %rsi # 0xdc875
xorl %eax, %eax
callq 0x29810
jmp 0xa405c
movq %r12, %rdi
leaq 0x38687(%rip), %rsi # 0xdc809
movl $0x621, %edx # imm = 0x621
callq 0x2eb8f
jmp 0xa3ffd
leaq 0x2e1e78(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xa4149
movq 0x2dfdfe(%rip), %rax # 0x383fa8
movq (%rax), %rdi
callq 0x29400
leaq 0xb645bf(%rip), %rax # 0xc08778
movq 0x40(%rax), %rdi
testq %rdi, %rdi
jne 0xa41e6
leaq 0xb645af(%rip), %rdi # 0xc08778
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x291e0
callq 0x2f208
jmp 0xa3fb6
leaq 0x2e1e23(%rip), %rax # 0x386010
movq (%rax), %rax
callq *0x160(%rax)
jmp 0xa41c2
|
thr_print_locks:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
lea rax, THR_LOCK_lock
cmp qword ptr [rax+40h], 0
jnz loc_A41DC
lea rdi, THR_LOCK_lock
call _pthread_mutex_lock
loc_A3FB6:
lea rdi, aCurrentActiveT; "Current active THR (table level locks):"
call _puts
lea rax, thr_lock_thread_list
mov r15, [rax]
test r15, r15
jz loc_A41A3
mov ebx, 3E9h
loc_A3FDA:
dec ebx
jz loc_A41A3
mov r14, [r15+10h]
lea r12, [r14+18h]
cmp qword ptr [r14+58h], 0
jnz loc_A4178
mov rdi, r12
call _pthread_mutex_lock
loc_A3FFD:
cmp qword ptr [r14+90h], 0
jnz short loc_A4023
cmp qword ptr [r14+70h], 0
jnz short loc_A4023
cmp qword ptr [r14+80h], 0
jnz short loc_A4023
cmp qword ptr [r14+60h], 0
jz loc_A4140
loc_A4023:
mov [rbp+var_38], r15
lea r15, [r14+90h]
mov edi, 1
lea rsi, aLockP; "lock: %p:"
mov rdx, r14
xor eax, eax
call ___printf_chk
cmp qword ptr [r14+80h], 0
jnz short loc_A4055
cmp qword ptr [r14+60h], 0
jz short loc_A405C
loc_A4055:
cmp qword ptr [r14+70h], 0
jz short loc_A4064
loc_A405C:
cmp qword ptr [r15], 0
jnz short loc_A406E
jmp short loc_A4081
loc_A4064:
cmp qword ptr [r15], 0
jz loc_A4160
loc_A406E:
mov edi, 1
lea rsi, aWrite_0; " write"
xor eax, eax
call ___printf_chk
loc_A4081:
mov [rbp+var_40], r12
lea r12, [r14+80h]
cmp qword ptr [r12], 0
jz short loc_A40A6
mov edi, 1
lea rsi, aWriteWait; " write_wait"
xor eax, eax
call ___printf_chk
loc_A40A6:
cmp qword ptr [r14+70h], 0
jz short loc_A40C0
mov edi, 1
lea rsi, aTheEventWasCor+34h; " read"
xor eax, eax
call ___printf_chk
loc_A40C0:
mov [rbp+var_2C], ebx
cmp qword ptr [r14+60h], 0
jz short loc_A40DD
mov edi, 1
lea rsi, aReadWait; " read_wait"
xor eax, eax
call ___printf_chk
loc_A40DD:
lea r13, [r14+70h]
lea rbx, [r14+60h]
mov edi, 0Ah
call _putchar
lea rdi, aWrite_0+1; "write"
mov rsi, r15
call thr_print_lock
lea rdi, aWriteWait+1; "write_wait"
mov rsi, r12
call thr_print_lock
lea rdi, aTheEventWasCor+35h; "read"
mov rsi, r13
call thr_print_lock
lea rdi, aReadWait+1; "read_wait"
mov rsi, rbx
call thr_print_lock
mov edi, 0Ah
call _putchar
mov ebx, [rbp+var_2C]
mov r12, [rbp+var_40]
mov r15, [rbp+var_38]
loc_A4140:
mov rdi, [r14+58h]
test rdi, rdi
jnz short loc_A4191
loc_A4149:
mov rdi, r12
call _pthread_mutex_unlock
mov r15, [r15+8]
test r15, r15
jnz loc_A3FDA
jmp short loc_A41A3
loc_A4160:
mov edi, 1
lea rsi, aWarning; " WARNING: "
xor eax, eax
call ___printf_chk
jmp loc_A405C
loc_A4178:
mov rdi, r12
lea rsi, aWorkspaceLlm4b_23; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 621h
call psi_mutex_lock
jmp loc_A3FFD
loc_A4191:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_A4149
loc_A41A3:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
lea rax, THR_LOCK_lock
mov rdi, [rax+40h]
test rdi, rdi
jnz short loc_A41E6
loc_A41C2:
lea rdi, THR_LOCK_lock
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _pthread_mutex_unlock
loc_A41DC:
call thr_print_locks_cold_1
jmp loc_A3FB6
loc_A41E6:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_A41C2
|
long long thr_print_locks()
{
long long *v0; // r15
int v1; // ebx
_QWORD *v2; // r14
_QWORD *v3; // r12
_QWORD *v4; // r15
long long *v6; // [rsp+8h] [rbp-38h]
if ( THR_LOCK_lock[8] )
thr_print_locks_cold_1();
else
pthread_mutex_lock(THR_LOCK_lock);
puts("Current active THR (table level locks):");
v0 = thr_lock_thread_list;
if ( thr_lock_thread_list )
{
v1 = 1001;
while ( 1 )
{
if ( !--v1 )
goto LABEL_32;
v2 = (_QWORD *)v0[2];
v3 = v2 + 3;
if ( v2[11] )
psi_mutex_lock((long long)(v2 + 3), (long long)"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c", 0x621u);
else
pthread_mutex_lock(v2 + 3);
if ( v2[18] || v2[14] || v2[16] || v2[12] )
break;
LABEL_26:
if ( v2[11] )
PSI_server[44]();
pthread_mutex_unlock(v3);
v0 = (long long *)v0[1];
if ( !v0 )
goto LABEL_32;
}
v6 = v0;
v4 = v2 + 18;
__printf_chk(1LL, "lock: %p:", v2);
if ( (v2[16] || v2[12]) && !v2[14] )
{
if ( *v4 )
{
LABEL_18:
__printf_chk(1LL, " write");
LABEL_19:
if ( v2[16] )
__printf_chk(1LL, " write_wait");
if ( v2[14] )
__printf_chk(1LL, " read");
if ( v2[12] )
__printf_chk(1LL, " read_wait");
putchar(10LL);
thr_print_lock("write", v2 + 18);
thr_print_lock("write_wait", v2 + 16);
thr_print_lock("read", v2 + 14);
thr_print_lock("read_wait", v2 + 12);
putchar(10LL);
v3 = v2 + 3;
v0 = v6;
goto LABEL_26;
}
__printf_chk(1LL, " WARNING: ");
}
if ( !*v4 )
goto LABEL_19;
goto LABEL_18;
}
LABEL_32:
fflush(stdout);
if ( THR_LOCK_lock[8] )
PSI_server[44]();
return pthread_mutex_unlock(THR_LOCK_lock);
}
|
thr_print_locks:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
LEA RAX,[0xd08778]
CMP qword ptr [RAX + 0x40],0x0
JNZ 0x001a41dc
LEA RDI,[0xd08778]
CALL 0x00129220
LAB_001a3fb6:
LEA RDI,[0x1dc843]
CALL 0x001297e0
LEA RAX,[0xd08a28]
MOV R15,qword ptr [RAX]
TEST R15,R15
JZ 0x001a41a3
MOV EBX,0x3e9
LAB_001a3fda:
DEC EBX
JZ 0x001a41a3
MOV R14,qword ptr [R15 + 0x10]
LEA R12,[R14 + 0x18]
CMP qword ptr [R14 + 0x58],0x0
JNZ 0x001a4178
MOV RDI,R12
CALL 0x00129220
LAB_001a3ffd:
CMP qword ptr [R14 + 0x90],0x0
JNZ 0x001a4023
CMP qword ptr [R14 + 0x70],0x0
JNZ 0x001a4023
CMP qword ptr [R14 + 0x80],0x0
JNZ 0x001a4023
CMP qword ptr [R14 + 0x60],0x0
JZ 0x001a4140
LAB_001a4023:
MOV qword ptr [RBP + -0x38],R15
LEA R15,[R14 + 0x90]
MOV EDI,0x1
LEA RSI,[0x1dc86b]
MOV RDX,R14
XOR EAX,EAX
CALL 0x00129810
CMP qword ptr [R14 + 0x80],0x0
JNZ 0x001a4055
CMP qword ptr [R14 + 0x60],0x0
JZ 0x001a405c
LAB_001a4055:
CMP qword ptr [R14 + 0x70],0x0
JZ 0x001a4064
LAB_001a405c:
CMP qword ptr [R15],0x0
JNZ 0x001a406e
JMP 0x001a4081
LAB_001a4064:
CMP qword ptr [R15],0x0
JZ 0x001a4160
LAB_001a406e:
MOV EDI,0x1
LEA RSI,[0x1dc880]
XOR EAX,EAX
CALL 0x00129810
LAB_001a4081:
MOV qword ptr [RBP + -0x40],R12
LEA R12,[R14 + 0x80]
CMP qword ptr [R12],0x0
JZ 0x001a40a6
MOV EDI,0x1
LEA RSI,[0x1dc887]
XOR EAX,EAX
CALL 0x00129810
LAB_001a40a6:
CMP qword ptr [R14 + 0x70],0x0
JZ 0x001a40c0
MOV EDI,0x1
LEA RSI,[0x1e0695]
XOR EAX,EAX
CALL 0x00129810
LAB_001a40c0:
MOV dword ptr [RBP + -0x2c],EBX
CMP qword ptr [R14 + 0x60],0x0
JZ 0x001a40dd
MOV EDI,0x1
LEA RSI,[0x1dc893]
XOR EAX,EAX
CALL 0x00129810
LAB_001a40dd:
LEA R13,[R14 + 0x70]
LEA RBX,[R14 + 0x60]
MOV EDI,0xa
CALL 0x00129900
LEA RDI,[0x1dc881]
MOV RSI,R15
CALL 0x001a41f8
LEA RDI,[0x1dc888]
MOV RSI,R12
CALL 0x001a41f8
LEA RDI,[0x1e0696]
MOV RSI,R13
CALL 0x001a41f8
LEA RDI,[0x1dc894]
MOV RSI,RBX
CALL 0x001a41f8
MOV EDI,0xa
CALL 0x00129900
MOV EBX,dword ptr [RBP + -0x2c]
MOV R12,qword ptr [RBP + -0x40]
MOV R15,qword ptr [RBP + -0x38]
LAB_001a4140:
MOV RDI,qword ptr [R14 + 0x58]
TEST RDI,RDI
JNZ 0x001a4191
LAB_001a4149:
MOV RDI,R12
CALL 0x001291e0
MOV R15,qword ptr [R15 + 0x8]
TEST R15,R15
JNZ 0x001a3fda
JMP 0x001a41a3
LAB_001a4160:
MOV EDI,0x1
LEA RSI,[0x1dc875]
XOR EAX,EAX
CALL 0x00129810
JMP 0x001a405c
LAB_001a4178:
MOV RDI,R12
LEA RSI,[0x1dc809]
MOV EDX,0x621
CALL 0x0012eb8f
JMP 0x001a3ffd
LAB_001a4191:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001a4149
LAB_001a41a3:
MOV RAX,qword ptr [0x00483fa8]
MOV RDI,qword ptr [RAX]
CALL 0x00129400
LEA RAX,[0xd08778]
MOV RDI,qword ptr [RAX + 0x40]
TEST RDI,RDI
JNZ 0x001a41e6
LAB_001a41c2:
LEA RDI,[0xd08778]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001291e0
LAB_001a41dc:
CALL 0x0012f208
JMP 0x001a3fb6
LAB_001a41e6:
LEA RAX,[0x486010]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x001a41c2
|
void thr_print_locks(void)
{
pthread_mutex_t *__mutex;
long *plVar1;
long lVar2;
int iVar3;
long lVar4;
if (THR_LOCK_lock._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_lock);
}
else {
thr_print_locks_cold_1();
}
puts("Current active THR (table level locks):");
if (thr_lock_thread_list != 0) {
iVar3 = 0x3e9;
lVar4 = thr_lock_thread_list;
do {
iVar3 = iVar3 + -1;
if (iVar3 == 0) break;
lVar2 = *(long *)(lVar4 + 0x10);
__mutex = (pthread_mutex_t *)(lVar2 + 0x18);
if (*(long *)(lVar2 + 0x58) == 0) {
pthread_mutex_lock(__mutex);
}
else {
psi_mutex_lock(__mutex,"/workspace/llm4binary/github2025/eloqsql/mysys/thr_lock.c",0x621);
}
if ((((*(long *)(lVar2 + 0x90) != 0) || (*(long *)(lVar2 + 0x70) != 0)) ||
(*(long *)(lVar2 + 0x80) != 0)) || (*(long *)(lVar2 + 0x60) != 0)) {
plVar1 = (long *)(lVar2 + 0x90);
__printf_chk(1,"lock: %p:",lVar2);
if (((*(long *)(lVar2 + 0x80) == 0) && (*(long *)(lVar2 + 0x60) == 0)) ||
(*(long *)(lVar2 + 0x70) != 0)) {
LAB_001a405c:
if (*plVar1 != 0) goto LAB_001a406e;
}
else {
if (*plVar1 == 0) {
__printf_chk(1," WARNING: ");
goto LAB_001a405c;
}
LAB_001a406e:
__printf_chk(1," write");
}
if (*(long *)(lVar2 + 0x80) != 0) {
__printf_chk(1," write_wait");
}
if (*(long *)(lVar2 + 0x70) != 0) {
__printf_chk(1," read");
}
if (*(long *)(lVar2 + 0x60) != 0) {
__printf_chk(1," read_wait");
}
putchar(10);
thr_print_lock("write",plVar1);
thr_print_lock("write_wait",(long *)(lVar2 + 0x80));
thr_print_lock("read",lVar2 + 0x70);
thr_print_lock("read_wait",lVar2 + 0x60);
putchar(10);
}
if (*(long *)(lVar2 + 0x58) != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock(__mutex);
lVar4 = *(long *)(lVar4 + 8);
} while (lVar4 != 0);
}
fflush(*(FILE **)PTR_stdout_00483fa8);
if (THR_LOCK_lock._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_lock);
return;
}
|
|
7,745 |
test_upscale::build_graph(ggml_context*)
|
monkey531[P]llama/tests/test-backend-ops.cpp
|
ggml_tensor * build_graph(ggml_context * ctx) override {
ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
ggml_set_name(a, "a");
if (transpose) {
a = ggml_transpose(ctx, a);
ggml_set_name(a, "a_transposed");
}
ggml_tensor * out = ggml_upscale(ctx, a, scale_factor);
ggml_set_name(out, "out");
return out;
}
|
O3
|
cpp
|
test_upscale::build_graph(ggml_context*):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x38(%rdi), %esi
leaq 0x40(%rdi), %rcx
movq %rbx, %rdi
movl $0x4, %edx
callq 0xd080
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b8ae
leaq 0x8e47(%rip), %rsi # 0x44b87
movq %r15, %rdi
callq 0xdb10
cmpb $0x1, 0x64(%r14)
jne 0x3bd6c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd7c0
movq %rax, %r15
leaq 0x91a3(%rip), %rsi # 0x44f07
movq %rax, %rdi
callq 0xdb10
movl 0x60(%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd770
movq %rax, %rbx
leaq 0x93a9(%rip), %rsi # 0x4512e
movq %rax, %rdi
callq 0xdb10
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
|
_ZN12test_upscale11build_graphEP12ggml_context:
push r15
push r14
push rbx
mov rbx, rsi
mov r14, rdi
mov esi, [rdi+38h]
lea rcx, [rdi+40h]
mov rdi, rbx
mov edx, 4
call _ggml_new_tensor
mov r15, rax
mov rdi, r14
mov rsi, rbx
call _ZN9test_case12add_sentinelEP12ggml_context; test_case::add_sentinel(ggml_context *)
lea rsi, aViewOfA+8; "a"
mov rdi, r15
call _ggml_set_name
cmp byte ptr [r14+64h], 1
jnz short loc_3BD6C
mov rdi, rbx
mov rsi, r15
call _ggml_transpose
mov r15, rax
lea rsi, aATransposed; "a_transposed"
mov rdi, rax
call _ggml_set_name
loc_3BD6C:
mov edx, [r14+60h]
mov rdi, rbx
mov rsi, r15
call _ggml_upscale
mov rbx, rax
lea rsi, aSumOfOut+7; "out"
mov rdi, rax
call _ggml_set_name
mov rax, rbx
pop rbx
pop r14
pop r15
retn
|
long long test_upscale::build_graph(long long a1, long long a2)
{
long long v2; // r15
long long v3; // rbx
v2 = ggml_new_tensor(a2, *(unsigned int *)(a1 + 56), 4LL);
test_case::add_sentinel(a1, a2);
ggml_set_name(v2, "a");
if ( *(_BYTE *)(a1 + 100) == 1 )
{
v2 = ggml_transpose(a2, v2);
ggml_set_name(v2, "a_transposed");
}
v3 = ggml_upscale(a2, v2, *(unsigned int *)(a1 + 96));
ggml_set_name(v3, "out");
return v3;
}
|
build_graph:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R14,RDI
MOV ESI,dword ptr [RDI + 0x38]
LEA RCX,[RDI + 0x40]
MOV RDI,RBX
MOV EDX,0x4
CALL 0x0010d080
MOV R15,RAX
MOV RDI,R14
MOV RSI,RBX
CALL 0x0011b8ae
LEA RSI,[0x144b87]
MOV RDI,R15
CALL 0x0010db10
CMP byte ptr [R14 + 0x64],0x1
JNZ 0x0013bd6c
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d7c0
MOV R15,RAX
LEA RSI,[0x144f07]
MOV RDI,RAX
CALL 0x0010db10
LAB_0013bd6c:
MOV EDX,dword ptr [R14 + 0x60]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0010d770
MOV RBX,RAX
LEA RSI,[0x14512e]
MOV RDI,RAX
CALL 0x0010db10
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* test_upscale::build_graph(ggml_context*) */
int8 __thiscall test_upscale::build_graph(test_upscale *this,ggml_context *param_1)
{
int8 uVar1;
uVar1 = ggml_new_tensor(param_1,*(int4 *)(this + 0x38),4,this + 0x40);
test_case::add_sentinel((test_case *)this,param_1);
ggml_set_name(uVar1,"a");
if (this[100] == (test_upscale)0x1) {
uVar1 = ggml_transpose(param_1,uVar1);
ggml_set_name(uVar1,"a_transposed");
}
uVar1 = ggml_upscale(param_1,uVar1,*(int4 *)(this + 0x60));
ggml_set_name(uVar1,"out");
return uVar1;
}
|
|
7,746 |
ma_ll2str
|
eloqsql/libmariadb/libmariadb/ma_ll2str.c
|
char *ma_ll2str(long long val,char *dst,int radix)
{
char buffer[65];
register char *p;
long long_val;
if (radix < 0)
{
if (radix < -36 || radix > -2) return (char*) 0;
if (val < 0) {
*dst++ = '-';
val = 0ULL - val;
}
radix = -radix;
}
else
{
if (radix > 36 || radix < 2) return (char*) 0;
}
if (val == 0)
{
*dst++='0';
*dst='\0';
return dst;
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
while ((ulonglong) val > (ulonglong) LONG_MAX)
{
ulonglong quo=(ulonglong) val/(uint) radix;
uint rem= (uint) (val- quo* (uint) radix);
*--p = _dig_vec[rem];
val= quo;
}
long_val= (long) val;
while (long_val != 0)
{
long quo= long_val/radix;
*--p = _dig_vec[(uchar) (long_val - quo*radix)];
long_val= quo;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O0
|
c
|
ma_ll2str:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x60(%rbp)
movq %rsi, -0x68(%rbp)
movl %edx, -0x6c(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x6d70f
cmpl $-0x24, -0x6c(%rbp)
jl 0x6d6d5
cmpl $-0x2, -0x6c(%rbp)
jle 0x6d6e2
movq $0x0, -0x58(%rbp)
jmp 0x6d87a
cmpq $0x0, -0x60(%rbp)
jge 0x6d705
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0x2d, (%rax)
xorl %eax, %eax
subq -0x60(%rbp), %rax
movq %rax, -0x60(%rbp)
xorl %eax, %eax
subl -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
jmp 0x6d72a
cmpl $0x24, -0x6c(%rbp)
jg 0x6d71b
cmpl $0x2, -0x6c(%rbp)
jge 0x6d728
movq $0x0, -0x58(%rbp)
jmp 0x6d87a
jmp 0x6d72a
cmpq $0x0, -0x60(%rbp)
jne 0x6d757
movq -0x68(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x68(%rbp)
movb $0x30, (%rax)
movq -0x68(%rbp), %rax
movb $0x0, (%rax)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x6d87a
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movb $0x0, (%rax)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x60(%rbp)
jbe 0x6d7d9
movq -0x60(%rbp), %rax
movl -0x6c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x88(%rbp)
movq -0x60(%rbp), %rax
movq -0x88(%rbp), %rcx
movl -0x6c(%rbp), %edx
imulq %rdx, %rcx
subq %rcx, %rax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, %ecx
leaq 0x1c7b69(%rip), %rax # 0x235320
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x6d76a
movq -0x60(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
je 0x6d840
movq -0x80(%rbp), %rax
movslq -0x6c(%rbp), %rcx
cqto
idivq %rcx
movq %rax, -0x98(%rbp)
movq -0x80(%rbp), %rax
movq -0x98(%rbp), %rcx
movslq -0x6c(%rbp), %rdx
imulq %rdx, %rcx
subq %rcx, %rax
movzbl %al, %eax
movl %eax, %ecx
leaq 0x1c7b02(%rip), %rax # 0x235320
movb (%rax,%rcx), %cl
movq -0x78(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x78(%rbp)
movb %cl, -0x1(%rax)
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x6d7e1
jmp 0x6d842
movq -0x78(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x78(%rbp)
movb (%rax), %al
movq -0x68(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x68(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x6d86e
jmp 0x6d842
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x6d8a7
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
callq 0x362a0
nopl (%rax)
|
ma_ll2str:
push rbp
mov rbp, rsp
sub rsp, 0A0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_60], rdi
mov [rbp+var_68], rsi
mov [rbp+var_6C], edx
cmp [rbp+var_6C], 0
jge short loc_6D70F
cmp [rbp+var_6C], 0FFFFFFDCh
jl short loc_6D6D5
cmp [rbp+var_6C], 0FFFFFFFEh
jle short loc_6D6E2
loc_6D6D5:
mov [rbp+var_58], 0
jmp loc_6D87A
loc_6D6E2:
cmp [rbp+var_60], 0
jge short loc_6D705
mov rax, [rbp+var_68]
mov rcx, rax
add rcx, 1
mov [rbp+var_68], rcx
mov byte ptr [rax], 2Dh ; '-'
xor eax, eax
sub rax, [rbp+var_60]
mov [rbp+var_60], rax
loc_6D705:
xor eax, eax
sub eax, [rbp+var_6C]
mov [rbp+var_6C], eax
jmp short loc_6D72A
loc_6D70F:
cmp [rbp+var_6C], 24h ; '$'
jg short loc_6D71B
cmp [rbp+var_6C], 2
jge short loc_6D728
loc_6D71B:
mov [rbp+var_58], 0
jmp loc_6D87A
loc_6D728:
jmp short $+2
loc_6D72A:
cmp [rbp+var_60], 0
jnz short loc_6D757
mov rax, [rbp+var_68]
mov rcx, rax
add rcx, 1
mov [rbp+var_68], rcx
mov byte ptr [rax], 30h ; '0'
mov rax, [rbp+var_68]
mov byte ptr [rax], 0
mov rax, [rbp+var_68]
mov [rbp+var_58], rax
jmp loc_6D87A
loc_6D757:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_78], rax
mov rax, [rbp+var_78]
mov byte ptr [rax], 0
loc_6D76A:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_60], rax
jbe short loc_6D7D9
mov rax, [rbp+var_60]
mov ecx, [rbp+var_6C]
xor edx, edx
div rcx
mov [rbp+var_88], rax
mov rax, [rbp+var_60]
mov rcx, [rbp+var_88]
mov edx, [rbp+var_6C]
imul rcx, rdx
sub rax, rcx
mov [rbp+var_8C], eax
mov eax, [rbp+var_8C]
mov ecx, eax
lea rax, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_88]
mov [rbp+var_60], rax
jmp short loc_6D76A
loc_6D7D9:
mov rax, [rbp+var_60]
mov [rbp+var_80], rax
loc_6D7E1:
cmp [rbp+var_80], 0
jz short loc_6D840
mov rax, [rbp+var_80]
movsxd rcx, [rbp+var_6C]
cqo
idiv rcx
mov [rbp+var_98], rax
mov rax, [rbp+var_80]
mov rcx, [rbp+var_98]
movsxd rdx, [rbp+var_6C]
imul rcx, rdx
sub rax, rcx
movzx eax, al
mov ecx, eax
lea rax, _dig_vec; "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
mov cl, [rax+rcx]
mov rax, [rbp+var_78]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_78], rdx
mov [rax-1], cl
mov rax, [rbp+var_98]
mov [rbp+var_80], rax
jmp short loc_6D7E1
loc_6D840:
jmp short $+2
loc_6D842:
mov rax, [rbp+var_78]
mov rcx, rax
add rcx, 1
mov [rbp+var_78], rcx
mov al, [rax]
mov rcx, [rbp+var_68]
mov rdx, rcx
add rdx, 1
mov [rbp+var_68], rdx
mov [rcx], al
movsx eax, al
cmp eax, 0
jz short loc_6D86E
jmp short loc_6D842
loc_6D86E:
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_58], rax
loc_6D87A:
mov rax, [rbp+var_58]
mov [rbp+var_A0], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_6D8A7
mov rax, [rbp+var_A0]
add rsp, 0A0h
pop rbp
retn
loc_6D8A7:
call ___stack_chk_fail
|
_BYTE * ma_ll2str(long long a1, _BYTE *a2, int a3)
{
_BYTE *v3; // rax
char *v4; // rax
char *v5; // rax
char *v6; // rax
_BYTE *v7; // rcx
signed long long i; // [rsp+20h] [rbp-80h]
char *v10; // [rsp+28h] [rbp-78h]
int v11; // [rsp+34h] [rbp-6Ch]
_BYTE *v12; // [rsp+38h] [rbp-68h]
_BYTE *v13; // [rsp+38h] [rbp-68h]
unsigned long long v14; // [rsp+40h] [rbp-60h]
char v16; // [rsp+90h] [rbp-10h] BYREF
unsigned long long v17; // [rsp+98h] [rbp-8h]
v17 = __readfsqword(0x28u);
v14 = a1;
v12 = a2;
v11 = a3;
if ( a3 >= 0 )
{
if ( a3 > 36 || a3 < 2 )
return 0LL;
}
else
{
if ( a3 < -36 || a3 > -2 )
return 0LL;
if ( a1 < 0 )
{
v12 = a2 + 1;
*a2 = 45;
v14 = -a1;
}
v11 = -a3;
}
if ( v14 )
{
v10 = &v16;
v16 = 0;
while ( v14 > 0x7FFFFFFFFFFFFFFFLL )
{
v4 = v10--;
*(v4 - 1) = dig_vec[v14 % (unsigned int)v11];
v14 /= (unsigned int)v11;
}
for ( i = v14; i; i /= v11 )
{
v5 = v10--;
*(v5 - 1) = dig_vec[(unsigned __int8)(i % v11)];
}
do
{
v6 = v10++;
LOBYTE(v6) = *v6;
v7 = v12++;
*v7 = (_BYTE)v6;
}
while ( (_BYTE)v6 );
return v12 - 1;
}
else
{
v3 = v12;
v13 = v12 + 1;
*v3 = 48;
*v13 = 0;
return v13;
}
}
|
ma_ll2str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xa0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x60],RDI
MOV qword ptr [RBP + -0x68],RSI
MOV dword ptr [RBP + -0x6c],EDX
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x0016d70f
CMP dword ptr [RBP + -0x6c],-0x24
JL 0x0016d6d5
CMP dword ptr [RBP + -0x6c],-0x2
JLE 0x0016d6e2
LAB_0016d6d5:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x0016d87a
LAB_0016d6e2:
CMP qword ptr [RBP + -0x60],0x0
JGE 0x0016d705
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x68],RCX
MOV byte ptr [RAX],0x2d
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x60],RAX
LAB_0016d705:
XOR EAX,EAX
SUB EAX,dword ptr [RBP + -0x6c]
MOV dword ptr [RBP + -0x6c],EAX
JMP 0x0016d72a
LAB_0016d70f:
CMP dword ptr [RBP + -0x6c],0x24
JG 0x0016d71b
CMP dword ptr [RBP + -0x6c],0x2
JGE 0x0016d728
LAB_0016d71b:
MOV qword ptr [RBP + -0x58],0x0
JMP 0x0016d87a
LAB_0016d728:
JMP 0x0016d72a
LAB_0016d72a:
CMP qword ptr [RBP + -0x60],0x0
JNZ 0x0016d757
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x68],RCX
MOV byte ptr [RAX],0x30
MOV RAX,qword ptr [RBP + -0x68]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x0016d87a
LAB_0016d757:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x78],RAX
MOV RAX,qword ptr [RBP + -0x78]
MOV byte ptr [RAX],0x0
LAB_0016d76a:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0x60],RAX
JBE 0x0016d7d9
MOV RAX,qword ptr [RBP + -0x60]
MOV ECX,dword ptr [RBP + -0x6c]
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x88]
MOV EDX,dword ptr [RBP + -0x6c]
IMUL RCX,RDX
SUB RAX,RCX
MOV dword ptr [RBP + -0x8c],EAX
MOV EAX,dword ptr [RBP + -0x8c]
MOV ECX,EAX
LEA RAX,[0x335320]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0016d76a
LAB_0016d7d9:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x80],RAX
LAB_0016d7e1:
CMP qword ptr [RBP + -0x80],0x0
JZ 0x0016d840
MOV RAX,qword ptr [RBP + -0x80]
MOVSXD RCX,dword ptr [RBP + -0x6c]
CQO
IDIV RCX
MOV qword ptr [RBP + -0x98],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x98]
MOVSXD RDX,dword ptr [RBP + -0x6c]
IMUL RCX,RDX
SUB RAX,RCX
MOVZX EAX,AL
MOV ECX,EAX
LEA RAX,[0x335320]
MOV CL,byte ptr [RAX + RCX*0x1]
MOV RAX,qword ptr [RBP + -0x78]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x78],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0x98]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0016d7e1
LAB_0016d840:
JMP 0x0016d842
LAB_0016d842:
MOV RAX,qword ptr [RBP + -0x78]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x78],RCX
MOV AL,byte ptr [RAX]
MOV RCX,qword ptr [RBP + -0x68]
MOV RDX,RCX
ADD RDX,0x1
MOV qword ptr [RBP + -0x68],RDX
MOV byte ptr [RCX],AL
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0016d86e
JMP 0x0016d842
LAB_0016d86e:
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x58],RAX
LAB_0016d87a:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0016d8a7
MOV RAX,qword ptr [RBP + -0xa0]
ADD RSP,0xa0
POP RBP
RET
LAB_0016d8a7:
CALL 0x001362a0
|
char * ma_ll2str(ulong param_1,char *param_2,uint param_3)
{
char cVar1;
char *pcVar2;
long in_FS_OFFSET;
ulong local_88;
char *local_80;
uint local_74;
char *local_70;
ulong local_68;
char *local_60;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_70 = param_2;
local_68 = param_1;
if ((int)param_3 < 0) {
if (((int)param_3 < -0x24) || (-2 < (int)param_3)) {
local_60 = (char *)0x0;
goto LAB_0016d87a;
}
if ((long)param_1 < 0) {
local_70 = param_2 + 1;
*param_2 = '-';
local_68 = -param_1;
}
local_74 = -param_3;
}
else if ((0x24 < (int)param_3) || (local_74 = param_3, (int)param_3 < 2)) {
local_60 = (char *)0x0;
goto LAB_0016d87a;
}
if (local_68 == 0) {
local_60 = local_70 + 1;
*local_70 = '0';
*local_60 = '\0';
}
else {
local_19[1] = 0;
local_80 = local_19 + 1;
while (0x7fffffffffffffff < local_68) {
local_80[-1] = _dig_vec[(int)local_68 - (int)(local_68 / local_74) * local_74];
local_80 = local_80 + -1;
local_68 = local_68 / local_74;
}
local_88 = local_68;
while (pcVar2 = local_70, local_88 != 0) {
local_80[-1] = _dig_vec[(byte)((char)local_88 -
(char)((long)local_88 / (long)(int)local_74) * (char)local_74)];
local_88 = (long)local_88 / (long)(int)local_74;
local_80 = local_80 + -1;
}
do {
local_70 = pcVar2;
cVar1 = *local_80;
*local_70 = cVar1;
local_80 = local_80 + 1;
pcVar2 = local_70 + 1;
} while (cVar1 != '\0');
local_60 = local_70;
}
LAB_0016d87a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_60;
}
|
|
7,747 |
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u])
|
dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp
|
bool SVGEnumeration<Enum>::parseEnum(std::string_view input, const SVGEnumerationEntry<Enum>(&entries)[N])
{
stripLeadingAndTrailingSpaces(input);
for(const auto& entry : entries) {
if(input == entry.second) {
m_value = entry.first;
return true;
}
}
return false;
}
|
O0
|
cpp
|
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u]):
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x32fd0
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x4b679
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x22010
testb $0x1, %al
jne 0x4b656
jmp 0x4b669
movq -0x70(%rbp), %rax
movq -0x48(%rbp), %rcx
movb (%rcx), %cl
movb %cl, 0x9(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4b67d
jmp 0x4b66b
movq -0x38(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
jmp 0x4b605
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
_ZN7lunasvg14SVGEnumerationINS_12LengthAdjustEE9parseEnumILj2EEEbSt17basic_string_viewIcSt11char_traitsIcEERAT__KSt4pairIS1_S7_E:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_18], rsi
mov [rbp+var_10], rdx
mov [rbp+var_20], rdi
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
lea rdi, [rbp+var_18]
call _ZN7lunasvg29stripLeadingAndTrailingSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::stripLeadingAndTrailingSpaces(std::string_view &)
mov rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rax, [rbp+var_30]
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
add rax, 30h ; '0'
mov [rbp+var_40], rax
loc_4B605:
mov rax, [rbp+var_38]
cmp rax, [rbp+var_40]
jz short loc_4B679
mov rax, [rbp+var_38]
mov [rbp+var_48], rax
mov rax, [rbp+var_18]
mov [rbp+var_58], rax
mov rax, [rbp+var_10]
mov [rbp+var_50], rax
mov rax, [rbp+var_48]
mov rcx, [rax+8]
mov [rbp+var_68], rcx
mov rax, [rax+10h]
mov [rbp+var_60], rax
mov rdi, [rbp+var_58]
mov rsi, [rbp+var_50]
mov rdx, [rbp+var_68]
mov rcx, [rbp+var_60]
call _ZSteqIcSt11char_traitsIcEEbSt17basic_string_viewIT_T0_ES5_; std::operator==<char,std::char_traits<char>>(std::string_view,std::string_view)
test al, 1
jnz short loc_4B656
jmp short loc_4B669
loc_4B656:
mov rax, [rbp+var_70]
mov rcx, [rbp+var_48]
mov cl, [rcx]
mov [rax+9], cl
mov [rbp+var_1], 1
jmp short loc_4B67D
loc_4B669:
jmp short $+2
loc_4B66B:
mov rax, [rbp+var_38]
add rax, 18h
mov [rbp+var_38], rax
jmp short loc_4B605
loc_4B679:
mov [rbp+var_1], 0
loc_4B67D:
mov al, [rbp+var_1]
and al, 1
add rsp, 70h
pop rbp
retn
|
char lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>(
long long a1,
long long a2,
long long a3,
long long a4)
{
long long i; // [rsp+38h] [rbp-38h]
long long v7; // [rsp+58h] [rbp-18h] BYREF
long long v8; // [rsp+60h] [rbp-10h]
v7 = a2;
v8 = a3;
lunasvg::stripLeadingAndTrailingSpaces((long long)&v7);
for ( i = a4; i != a4 + 48; i += 24LL )
{
if ( std::operator==<char,std::char_traits<char>>(v7, v8, *(_QWORD *)(i + 8), *(_QWORD *)(i + 16)) )
{
*(_BYTE *)(a1 + 9) = *(_BYTE *)i;
return 1;
}
}
return 0;
}
|
parseEnum<2u>:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x10],RDX
MOV qword ptr [RBP + -0x20],RDI
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
LEA RDI,[RBP + -0x18]
CALL 0x00132fd0
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
ADD RAX,0x30
MOV qword ptr [RBP + -0x40],RAX
LAB_0014b605:
MOV RAX,qword ptr [RBP + -0x38]
CMP RAX,qword ptr [RBP + -0x40]
JZ 0x0014b679
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RCX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x68],RCX
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x60],RAX
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x60]
CALL 0x00122010
TEST AL,0x1
JNZ 0x0014b656
JMP 0x0014b669
LAB_0014b656:
MOV RAX,qword ptr [RBP + -0x70]
MOV RCX,qword ptr [RBP + -0x48]
MOV CL,byte ptr [RCX]
MOV byte ptr [RAX + 0x9],CL
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0014b67d
LAB_0014b669:
JMP 0x0014b66b
LAB_0014b66b:
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x18
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0014b605
LAB_0014b679:
MOV byte ptr [RBP + -0x1],0x0
LAB_0014b67d:
MOV AL,byte ptr [RBP + -0x1]
AND AL,0x1
ADD RSP,0x70
POP RBP
RET
|
/* bool lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>(std::basic_string_view<char,
std::char_traits<char> >, std::pair<lunasvg::LengthAdjust, std::basic_string_view<char,
std::char_traits<char> > > const (&) [2u]) */
bool lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>
(long param_1,int8 param_2,int8 param_3,int1 *param_4)
{
bool bVar1;
int1 *local_40;
int8 local_20;
int8 local_18;
local_20 = param_2;
local_18 = param_3;
stripLeadingAndTrailingSpaces((basic_string_view *)&local_20);
local_40 = param_4;
while( true ) {
if (local_40 == param_4 + 0x30) {
return false;
}
bVar1 = std::operator==(local_20,local_18,*(int8 *)(local_40 + 8),
*(int8 *)(local_40 + 0x10));
if (bVar1) break;
local_40 = local_40 + 0x18;
}
*(int1 *)(param_1 + 9) = *local_40;
return true;
}
|
|
7,748 |
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u])
|
dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp
|
bool SVGEnumeration<Enum>::parseEnum(std::string_view input, const SVGEnumerationEntry<Enum>(&entries)[N])
{
stripLeadingAndTrailingSpaces(input);
for(const auto& entry : entries) {
if(input == entry.second) {
m_value = entry.first;
return true;
}
}
return false;
}
|
O1
|
cpp
|
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u]):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq %rsi, (%r12)
movq %rdx, 0x8(%r12)
movq %r12, %rdi
callq 0x171df
movq (%r12), %r15
movq 0x8(%r12), %r12
movb $0x1, %bpl
movl $0x10, %r13d
cmpq -0x8(%rbx,%r13), %r15
jne 0x2085b
testq %r15, %r15
je 0x2086b
movq (%rbx,%r13), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0xa330
testl %eax, %eax
je 0x2086b
addq $0x18, %r13
cmpq $0x40, %r13
setne %bpl
jne 0x2083c
jmp 0x20874
movb -0x10(%rbx,%r13), %al
movb %al, 0x9(%r14)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
_ZN7lunasvg14SVGEnumerationINS_12LengthAdjustEE9parseEnumILj2EEEbSt17basic_string_viewIcSt11char_traitsIcEERAT__KSt4pairIS1_S7_E:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rcx
mov r14, rdi
lea r12, [rsp+48h+var_40]
mov [r12], rsi
mov [r12+8], rdx
mov rdi, r12
call _ZN7lunasvg29stripLeadingAndTrailingSpacesERSt17basic_string_viewIcSt11char_traitsIcEE; lunasvg::stripLeadingAndTrailingSpaces(std::string_view &)
mov r15, [r12]
mov r12, [r12+8]
mov bpl, 1
mov r13d, 10h
loc_2083C:
cmp r15, [rbx+r13-8]
jnz short loc_2085B
test r15, r15
jz short loc_2086B
mov rsi, [rbx+r13]
mov rdi, r12
mov rdx, r15
call _bcmp
test eax, eax
jz short loc_2086B
loc_2085B:
add r13, 18h
cmp r13, 40h ; '@'
setnz bpl
jnz short loc_2083C
jmp short loc_20874
loc_2086B:
mov al, [rbx+r13-10h]
mov [r14+9], al
loc_20874:
and bpl, 1
mov eax, ebp
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>(
long long a1,
long long a2,
long long a3,
long long a4)
{
unsigned int v4; // ebp
long long v6; // r15
long long v7; // r12
long long v8; // r13
long long v10; // [rsp+8h] [rbp-40h] BYREF
long long v11; // [rsp+10h] [rbp-38h]
v10 = a2;
v11 = a3;
lunasvg::stripLeadingAndTrailingSpaces(&v10);
v6 = v10;
v7 = v11;
LOBYTE(v4) = 1;
v8 = 16LL;
while ( v6 != *(_QWORD *)(a4 + v8 - 8) || v6 && (unsigned int)bcmp(v7, *(_QWORD *)(a4 + v8)) )
{
v8 += 24LL;
LOBYTE(v4) = v8 != 64;
if ( v8 == 64 )
goto LABEL_8;
}
*(_BYTE *)(a1 + 9) = *(_BYTE *)(a4 + v8 - 16);
LABEL_8:
LOBYTE(v4) = v4 & 1;
return v4;
}
|
parseEnum<2u>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RCX
MOV R14,RDI
LEA R12,[RSP + 0x8]
MOV qword ptr [R12],RSI
MOV qword ptr [R12 + 0x8],RDX
MOV RDI,R12
CALL 0x001171df
MOV R15,qword ptr [R12]
MOV R12,qword ptr [R12 + 0x8]
MOV BPL,0x1
MOV R13D,0x10
LAB_0012083c:
CMP R15,qword ptr [RBX + R13*0x1 + -0x8]
JNZ 0x0012085b
TEST R15,R15
JZ 0x0012086b
MOV RSI,qword ptr [RBX + R13*0x1]
MOV RDI,R12
MOV RDX,R15
CALL 0x0010a330
TEST EAX,EAX
JZ 0x0012086b
LAB_0012085b:
ADD R13,0x18
CMP R13,0x40
SETNZ BPL
JNZ 0x0012083c
JMP 0x00120874
LAB_0012086b:
MOV AL,byte ptr [RBX + R13*0x1 + -0x10]
MOV byte ptr [R14 + 0x9],AL
LAB_00120874:
AND BPL,0x1
MOV EAX,EBP
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* bool lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>(std::basic_string_view<char,
std::char_traits<char> >, std::pair<lunasvg::LengthAdjust, std::basic_string_view<char,
std::char_traits<char> > > const (&) [2u]) */
bool lunasvg::SVGEnumeration<lunasvg::LengthAdjust>::parseEnum<2u>
(long param_1,size_t param_2,void *param_3,long param_4)
{
size_t __n;
void *__s1;
int iVar1;
long lVar2;
bool bVar3;
size_t local_40;
void *local_38;
local_40 = param_2;
local_38 = param_3;
stripLeadingAndTrailingSpaces((basic_string_view *)&local_40);
__s1 = local_38;
__n = local_40;
bVar3 = true;
lVar2 = 0x10;
while ((__n != *(size_t *)(param_4 + -8 + lVar2) ||
((__n != 0 && (iVar1 = bcmp(__s1,*(void **)(param_4 + lVar2),__n), iVar1 != 0))))) {
lVar2 = lVar2 + 0x18;
bVar3 = lVar2 != 0x40;
if (!bVar3) {
return bVar3;
}
}
*(int1 *)(param_1 + 9) = *(int1 *)(param_4 + -0x10 + lVar2);
return bVar3;
}
|
|
7,749 |
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u])
|
dmazzella[P]pylunasvg/lunasvg/source/svgproperty.cpp
|
bool SVGEnumeration<Enum>::parseEnum(std::string_view input, const SVGEnumerationEntry<Enum>(&entries)[N])
{
stripLeadingAndTrailingSpaces(input);
for(const auto& entry : entries) {
if(input == entry.second) {
m_value = entry.first;
return true;
}
}
return false;
}
|
O3
|
cpp
|
bool lunasvg::SVGEnumeration<lunasvg::SpreadMethod>::parseEnum<3u>(std::basic_string_view<char, std::char_traits<char>>, std::pair<lunasvg::SpreadMethod, std::basic_string_view<char, std::char_traits<char>>> const (&) [3u]):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x20689
leaq (%rdx,%rsi), %rdi
movq %rsi, %rax
negq %rax
movabsq $0x100002600, %rcx # imm = 0x100002600
xorl %r12d, %r12d
movq %rdx, %r15
movzbl (%r15), %r8d
cmpq $0x20, %r8
ja 0x20691
btq %r8, %rcx
jae 0x20691
incq %r15
incq %rax
jne 0x2066c
movq %rdi, %r15
jmp 0x206c4
xorl %r12d, %r12d
movq %rdx, %r15
jmp 0x206c4
addq %rsi, %rdx
decq %rdx
leaq 0x1(%rax), %rsi
xorl %r12d, %r12d
movzbl (%rdx,%r12), %edi
cmpq $0x20, %rdi
ja 0x206c1
btq %rdi, %rcx
jae 0x206c1
leaq -0x1(%r12), %rdi
cmpq %r12, %rsi
movq %rdi, %r12
jne 0x2069e
xorl %r12d, %r12d
jmp 0x206c4
subq %rax, %r12
movl $0x10, %r13d
cmpq -0x8(%rbx,%r13), %r12
jne 0x206e9
testq %r12, %r12
je 0x206f7
movq (%rbx,%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xa300
testl %eax, %eax
je 0x206f7
addq $0x18, %r13
cmpq $0x40, %r13
jne 0x206ca
xorl %eax, %eax
jmp 0x20702
movb -0x10(%rbx,%r13), %al
movb %al, 0x9(%r14)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
_ZN7lunasvg14SVGEnumerationINS_11MarkerUnitsEE9parseEnumILj2EEEbSt17basic_string_viewIcSt11char_traitsIcEERAT__KSt4pairIS1_S7_E:
push r15
push r14
push r13
push r12
push rbx
mov rbx, rcx
mov r14, rdi
test rsi, rsi
jz short loc_20689
lea rdi, [rdx+rsi]
mov rax, rsi
neg rax
mov rcx, 100002600h
xor r12d, r12d
mov r15, rdx
loc_2066C:
movzx r8d, byte ptr [r15]
cmp r8, 20h ; ' '
ja short loc_20691
bt rcx, r8
jnb short loc_20691
inc r15
inc rax
jnz short loc_2066C
mov r15, rdi
jmp short loc_206C4
loc_20689:
xor r12d, r12d
mov r15, rdx
jmp short loc_206C4
loc_20691:
add rdx, rsi
dec rdx
lea rsi, [rax+1]
xor r12d, r12d
loc_2069E:
movzx edi, byte ptr [rdx+r12]
cmp rdi, 20h ; ' '
ja short loc_206C1
bt rcx, rdi
jnb short loc_206C1
lea rdi, [r12-1]
cmp rsi, r12
mov r12, rdi
jnz short loc_2069E
xor r12d, r12d
jmp short loc_206C4
loc_206C1:
sub r12, rax
loc_206C4:
mov r13d, 10h
loc_206CA:
cmp r12, [rbx+r13-8]
jnz short loc_206E9
test r12, r12
jz short loc_206F7
mov rsi, [rbx+r13]
mov rdi, r15
mov rdx, r12
call _bcmp
test eax, eax
jz short loc_206F7
loc_206E9:
add r13, 18h
cmp r13, 40h ; '@'
jnz short loc_206CA
xor eax, eax
jmp short loc_20702
loc_206F7:
mov al, [rbx+r13-10h]
mov [r14+9], al
mov al, 1
loc_20702:
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
|
char lunasvg::SVGEnumeration<lunasvg::MarkerUnits>::parseEnum<2u>(
long long a1,
long long a2,
unsigned __int8 *a3,
long long a4)
{
long long v6; // rax
long long v7; // rcx
long long v8; // r12
unsigned __int8 *v9; // r15
unsigned long long v10; // r8
long long v11; // rdx
long long v12; // r12
unsigned long long v13; // rdi
long long v15; // r13
if ( a2 )
{
v6 = -a2;
v7 = 0x100002600LL;
v8 = 0LL;
v9 = a3;
while ( 1 )
{
v10 = *v9;
if ( v10 > 0x20 || !_bittest64(&v7, v10) )
break;
++v9;
if ( !++v6 )
{
v9 = &a3[a2];
goto LABEL_14;
}
}
v11 = (long long)&a3[a2 - 1];
v12 = 0LL;
while ( 1 )
{
v13 = *(unsigned __int8 *)(v11 + v12);
if ( v13 > 0x20 || !_bittest64(&v7, v13) )
break;
if ( v6 + 1 == v12-- )
{
v8 = 0LL;
goto LABEL_14;
}
}
v8 = v12 - v6;
}
else
{
v8 = 0LL;
v9 = a3;
}
LABEL_14:
v15 = 16LL;
while ( v8 != *(_QWORD *)(a4 + v15 - 8) || v8 && (unsigned int)bcmp(v9, *(_QWORD *)(a4 + v15), v8) )
{
v15 += 24LL;
if ( v15 == 64 )
return 0;
}
*(_BYTE *)(a1 + 9) = *(_BYTE *)(a4 + v15 - 16);
return 1;
}
|
parseEnum<2u>:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RCX
MOV R14,RDI
TEST RSI,RSI
JZ 0x00120689
LEA RDI,[RDX + RSI*0x1]
MOV RAX,RSI
NEG RAX
MOV RCX,0x100002600
XOR R12D,R12D
MOV R15,RDX
LAB_0012066c:
MOVZX R8D,byte ptr [R15]
CMP R8,0x20
JA 0x00120691
BT RCX,R8
JNC 0x00120691
INC R15
INC RAX
JNZ 0x0012066c
MOV R15,RDI
JMP 0x001206c4
LAB_00120689:
XOR R12D,R12D
MOV R15,RDX
JMP 0x001206c4
LAB_00120691:
ADD RDX,RSI
DEC RDX
LEA RSI,[RAX + 0x1]
XOR R12D,R12D
LAB_0012069e:
MOVZX EDI,byte ptr [RDX + R12*0x1]
CMP RDI,0x20
JA 0x001206c1
BT RCX,RDI
JNC 0x001206c1
LEA RDI,[R12 + -0x1]
CMP RSI,R12
MOV R12,RDI
JNZ 0x0012069e
XOR R12D,R12D
JMP 0x001206c4
LAB_001206c1:
SUB R12,RAX
LAB_001206c4:
MOV R13D,0x10
LAB_001206ca:
CMP R12,qword ptr [RBX + R13*0x1 + -0x8]
JNZ 0x001206e9
TEST R12,R12
JZ 0x001206f7
MOV RSI,qword ptr [RBX + R13*0x1]
MOV RDI,R15
MOV RDX,R12
CALL 0x0010a300
TEST EAX,EAX
JZ 0x001206f7
LAB_001206e9:
ADD R13,0x18
CMP R13,0x40
JNZ 0x001206ca
XOR EAX,EAX
JMP 0x00120702
LAB_001206f7:
MOV AL,byte ptr [RBX + R13*0x1 + -0x10]
MOV byte ptr [R14 + 0x9],AL
MOV AL,0x1
LAB_00120702:
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* bool lunasvg::SVGEnumeration<lunasvg::MarkerUnits>::parseEnum<2u>(std::basic_string_view<char,
std::char_traits<char> >, std::pair<lunasvg::MarkerUnits, std::basic_string_view<char,
std::char_traits<char> > > const (&) [2u]) */
bool lunasvg::SVGEnumeration<lunasvg::MarkerUnits>::parseEnum<2u>
(long param_1,long param_2,byte *param_3,long param_4)
{
int iVar1;
long lVar2;
long lVar3;
size_t __n;
byte *pbVar4;
byte *pbVar5;
bool bVar6;
if (param_2 == 0) {
__n = 0;
pbVar5 = param_3;
}
else {
pbVar5 = param_3 + param_2;
lVar2 = -param_2;
__n = 0;
pbVar4 = param_3;
do {
if ((0x20 < (ulong)*pbVar4) || ((0x100002600U >> ((ulong)*pbVar4 & 0x3f) & 1) == 0)) {
lVar3 = 0;
goto LAB_0012069e;
}
pbVar4 = pbVar4 + 1;
lVar2 = lVar2 + 1;
} while (lVar2 != 0);
}
goto LAB_001206c4;
while (bVar6 = lVar2 + 1 != lVar3, lVar3 = lVar3 + -1, bVar6) {
LAB_0012069e:
pbVar5 = pbVar4;
if ((0x20 < (ulong)param_3[lVar3 + param_2 + -1]) ||
((0x100002600U >> ((ulong)param_3[lVar3 + param_2 + -1] & 0x3f) & 1) == 0)) {
__n = lVar3 - lVar2;
goto LAB_001206c4;
}
}
__n = 0;
LAB_001206c4:
lVar2 = 0x10;
while ((__n != *(size_t *)(param_4 + -8 + lVar2) ||
((__n != 0 && (iVar1 = bcmp(pbVar5,*(void **)(param_4 + lVar2),__n), iVar1 != 0))))) {
lVar2 = lVar2 + 0x18;
if (lVar2 == 0x40) {
return false;
}
}
*(int1 *)(param_1 + 9) = *(int1 *)(param_4 + -0x10 + lVar2);
return true;
}
|
|
7,750 |
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t)
|
monkey531[P]llama/common/json.hpp
|
void destroy(value_t t)
{
if (
(t == value_t::object && object == nullptr) ||
(t == value_t::array && array == nullptr) ||
(t == value_t::string && string == nullptr) ||
(t == value_t::binary && binary == nullptr)
)
{
//not initialized (e.g. due to exception in the ctor)
return;
}
if (t == value_t::array || t == value_t::object)
{
// flatten the current json_value to a heap-allocated stack
std::vector<basic_json> stack;
// move the top-level items to stack
if (t == value_t::array)
{
stack.reserve(array->size());
std::move(array->begin(), array->end(), std::back_inserter(stack));
}
else
{
stack.reserve(object->size());
for (auto&& it : *object)
{
stack.push_back(std::move(it.second));
}
}
while (!stack.empty())
{
// move the last item to local variable to be processed
basic_json current_item(std::move(stack.back()));
stack.pop_back();
// if current_item is array/object, move
// its children to the stack to be processed later
if (current_item.is_array())
{
std::move(current_item.m_data.m_value.array->begin(), current_item.m_data.m_value.array->end(), std::back_inserter(stack));
current_item.m_data.m_value.array->clear();
}
else if (current_item.is_object())
{
for (auto&& it : *current_item.m_data.m_value.object)
{
stack.push_back(std::move(it.second));
}
current_item.m_data.m_value.object->clear();
}
// it's now safe that current_item get destructed
// since it doesn't have any children
}
}
switch (t)
{
case value_t::object:
{
AllocatorType<object_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
break;
}
case value_t::array:
{
AllocatorType<array_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
break;
}
case value_t::string:
{
AllocatorType<string_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
break;
}
case value_t::binary:
{
AllocatorType<binary_t> alloc;
std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
break;
}
case value_t::null:
case value_t::boolean:
case value_t::number_integer:
case value_t::number_unsigned:
case value_t::number_float:
case value_t::discarded:
default:
{
break;
}
}
}
|
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t):
subq $0x128, %rsp # imm = 0x128
movb %sil, %al
movq %rdi, 0x120(%rsp)
movb %al, 0x11f(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpb $0x1, 0x11f(%rsp)
jne 0xbcb4b
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbcb8a
cmpb $0x2, 0x11f(%rsp)
jne 0xbcb60
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbcb8a
cmpb $0x3, 0x11f(%rsp)
jne 0xbcb75
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbcb8a
cmpb $0x8, 0x11f(%rsp)
jne 0xbcb8f
movq 0x50(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbcb8f
jmp 0xbd0e7
cmpb $0x2, 0x11f(%rsp)
je 0xbcba7
cmpb $0x1, 0x11f(%rsp)
jne 0xbcf10
leaq 0x100(%rsp), %rdi
callq 0xaa3d0
cmpb $0x2, 0x11f(%rsp)
jne 0xbcc7e
movq 0x50(%rsp), %rax
movq (%rax), %rdi
callq 0xb8190
movq %rax, %rsi
leaq 0x100(%rsp), %rdi
callq 0xbd100
jmp 0xbcbe1
movq 0x50(%rsp), %rax
movq (%rax), %rdi
callq 0xb8050
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0xe8(%rsp)
movq (%rax), %rdi
callq 0xb7ec0
movq %rax, 0xe0(%rsp)
leaq 0x100(%rsp), %rdi
callq 0xbd280
movq %rax, 0x48(%rsp)
jmp 0xbcc22
movq 0x48(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xe8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
callq 0xbd210
movq %rax, 0x40(%rsp)
jmp 0xbcc53
movq 0x40(%rsp), %rax
movq %rax, 0xd0(%rsp)
jmp 0xbcd35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0xbcefe
movq 0x50(%rsp), %rax
movq (%rax), %rdi
callq 0xb8d90
movq %rax, %rsi
leaq 0x100(%rsp), %rdi
callq 0xbd100
jmp 0xbcc9d
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xbd2b0
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xbd2e0
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xbd310
testb $0x1, %al
jne 0xbccf2
jmp 0xbcd33
leaq 0xc0(%rsp), %rdi
callq 0xbd350
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
addq $0x20, %rsi
leaq 0x100(%rsp), %rdi
callq 0xbd360
jmp 0xbcd22
jmp 0xbcd24
leaq 0xc0(%rsp), %rdi
callq 0xbd390
jmp 0xbccd7
jmp 0xbcd35
jmp 0xbcd37
leaq 0x100(%rsp), %rdi
callq 0xbd3b0
xorb $-0x1, %al
testb $0x1, %al
jne 0xbcd4f
jmp 0xbceef
leaq 0x100(%rsp), %rdi
callq 0xb7b80
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
callq 0xb7a10
leaq 0x100(%rsp), %rdi
callq 0xbd400
leaq 0xa0(%rsp), %rdi
callq 0xb7ac0
testb $0x1, %al
jne 0xbcd8f
jmp 0xbce43
movq 0xa8(%rsp), %rdi
callq 0xb8050
movq %rax, 0x98(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xb7ec0
movq %rax, 0x90(%rsp)
leaq 0x100(%rsp), %rdi
callq 0xbd280
movq %rax, 0x38(%rsp)
jmp 0xbcdcd
movq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0xbd210
movq %rax, 0x30(%rsp)
jmp 0xbcdfe
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xa8(%rsp), %rdi
callq 0xbd420
jmp 0xbcedd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xa8760
jmp 0xbcefe
leaq 0xa0(%rsp), %rdi
callq 0xb7ae0
testb $0x1, %al
jne 0xbce59
jmp 0xbcedb
movq 0xa8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xbd2b0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0xbd2e0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xbd310
testb $0x1, %al
jne 0xbce99
jmp 0xbcece
leaq 0x70(%rsp), %rdi
callq 0xbd350
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rsi
addq $0x20, %rsi
leaq 0x100(%rsp), %rdi
callq 0xbd360
jmp 0xbcec0
jmp 0xbcec2
leaq 0x70(%rsp), %rdi
callq 0xbd390
jmp 0xbce84
movq 0xa8(%rsp), %rdi
callq 0xbd440
jmp 0xbcedd
leaq 0xa0(%rsp), %rdi
callq 0xa8760
jmp 0xbcd37
leaq 0x100(%rsp), %rdi
callq 0xbd460
jmp 0xbcf10
leaq 0x100(%rsp), %rdi
callq 0xbd460
jmp 0xbd0ef
movzbl 0x11f(%rsp), %eax
movq %rax, 0x28(%rsp)
subq $0x9, %rax
ja 0xbd0e5
movq 0x28(%rsp), %rax
leaq 0x151c55(%rip), %rcx # 0x20eb88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xa9980
movq 0x50(%rsp), %rax
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
callq 0xbd4c0
movq 0x50(%rsp), %rax
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0xa9fd0
jmp 0xbcf76
leaq 0x5f(%rsp), %rdi
callq 0xa9af0
jmp 0xbd0e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x5f(%rsp), %rdi
callq 0xa9af0
jmp 0xbd0ef
leaq 0x5e(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xaa040
movq 0x50(%rsp), %rax
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0xbd4f0
movq 0x50(%rsp), %rax
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0xaa670
jmp 0xbcfe2
leaq 0x5e(%rsp), %rdi
callq 0xaa1b0
jmp 0xbd0e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x5e(%rsp), %rdi
callq 0xaa1b0
jmp 0xbd0ef
leaq 0x5d(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x68940
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
callq 0x96400
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0x69220
jmp 0xbd04e
leaq 0x5d(%rsp), %rdi
callq 0x689e0
jmp 0xbd0e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x5d(%rsp), %rdi
callq 0x689e0
jmp 0xbd0ef
leaq 0x5c(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xaabe0
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0xbd520
movq 0x50(%rsp), %rax
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
movl $0x1, %edx
callq 0xab230
jmp 0xbd0b7
leaq 0x5c(%rsp), %rdi
callq 0xaad50
jmp 0xbd0e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x5c(%rsp), %rdi
callq 0xaad50
jmp 0xbd0ef
jmp 0xbd0e5
jmp 0xbd0e7
addq $0x128, %rsp # imm = 0x128
retq
movq 0xf8(%rsp), %rdi
callq 0x5ac70
nopl (%rax)
|
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE10json_value7destroyENS0_6detail7value_tE:
sub rsp, 128h
mov al, sil
mov [rsp+128h+var_8], rdi
mov [rsp+128h+var_9], al
mov rax, [rsp+128h+var_8]
mov [rsp+128h+var_D8], rax
cmp [rsp+128h+var_9], 1
jnz short loc_BCB4B
mov rax, [rsp+128h+var_D8]
cmp qword ptr [rax], 0
jz short loc_BCB8A
loc_BCB4B:
cmp [rsp+128h+var_9], 2
jnz short loc_BCB60
mov rax, [rsp+128h+var_D8]
cmp qword ptr [rax], 0
jz short loc_BCB8A
loc_BCB60:
cmp [rsp+128h+var_9], 3
jnz short loc_BCB75
mov rax, [rsp+128h+var_D8]
cmp qword ptr [rax], 0
jz short loc_BCB8A
loc_BCB75:
cmp [rsp+128h+var_9], 8
jnz short loc_BCB8F
mov rax, [rsp+128h+var_D8]
cmp qword ptr [rax], 0
jnz short loc_BCB8F
loc_BCB8A:
jmp loc_BD0E7
loc_BCB8F:
cmp [rsp+128h+var_9], 2
jz short loc_BCBA7
cmp [rsp+128h+var_9], 1
jnz loc_BCF10
loc_BCBA7:
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEC2Ev; 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>>::vector(void)
cmp [rsp+128h+var_9], 2
jnz loc_BCC7E
mov rax, [rsp+128h+var_D8]
mov rdi, [rax]
call _ZNKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_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>>::size(void)
mov rsi, rax
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; 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>>::reserve(ulong)
jmp short $+2
loc_BCBE1:
mov rax, [rsp+128h+var_D8]
mov rdi, [rax]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5beginEv; 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>>::begin(void)
mov rcx, rax
mov rax, [rsp+128h+var_D8]
mov [rsp+128h+var_40], rcx
mov rdi, [rax]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE3endEv; 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>>::end(void)
mov [rsp+128h+var_48], rax
lea rdi, [rsp+128h+var_28]
call _ZSt13back_inserterISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES0_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES0_IhSaIhEEvEESaISE_EEESt20back_insert_iteratorIT_ERSI_; std::back_inserter<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>(std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&)
mov [rsp+128h+var_E0], rax
jmp short $+2
loc_BCC22:
mov rax, [rsp+128h+var_E0]
mov [rsp+128h+var_50], rax
mov rdi, [rsp+128h+var_40]
mov rsi, [rsp+128h+var_48]
mov rdx, [rsp+128h+var_50]
call _ZSt4moveIN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES6_ISG_SaISG_EEEESt20back_insert_iteratorISJ_EET0_T_SO_SN_; std::move<__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>>>,std::back_insert_iterator<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>>>>(__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>>>,__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>>>,std::back_insert_iterator<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 [rsp+128h+var_E8], rax
jmp short $+2
loc_BCC53:
mov rax, [rsp+128h+var_E8]
mov [rsp+128h+var_58], rax
jmp loc_BCD35
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
jmp loc_BCEFE
loc_BCC7E:
mov rax, [rsp+128h+var_D8]
mov rdi, [rax]
call _ZNKSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE4sizeEv; 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>>>::size(void)
mov rsi, rax
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE7reserveEm; 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>>::reserve(ulong)
jmp short $+2
loc_BCC9D:
mov rax, [rsp+128h+var_D8]
mov rax, [rax]
mov [rsp+128h+var_60], rax
mov rdi, [rsp+128h+var_60]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+128h+var_68], rax
mov rdi, [rsp+128h+var_60]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+128h+var_70], rax
loc_BCCD7:
lea rdi, [rsp+128h+var_68]
lea rsi, [rsp+128h+var_70]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_BCCF2
jmp short loc_BCD33
loc_BCCF2:
lea rdi, [rsp+128h+var_68]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov [rsp+128h+var_78], rax
mov rsi, [rsp+128h+var_78]
add rsi, 20h ; ' '
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE9push_backEOSD_; 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>>::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>&&)
jmp short $+2
loc_BCD22:
jmp short $+2
loc_BCD24:
lea rdi, [rsp+128h+var_68]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_BCCD7
loc_BCD33:
jmp short $+2
loc_BCD35:
jmp short $+2
loc_BCD37:
lea rdi, [rsp+128h+var_28]
call _ZNKSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_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>>::empty(void)
xor al, 0FFh
test al, 1
jnz short loc_BCD4F
jmp loc_BCEEF
loc_BCD4F:
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE4backEv; std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::back(void)
mov rsi, rax
lea rdi, [rsp+128h+var_88]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EOSD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&&)
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_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>>::pop_back(void)
lea rdi, [rsp+128h+var_88]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8is_arrayEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_array(void)
test al, 1
jnz short loc_BCD8F
jmp loc_BCE43
loc_BCD8F:
mov rdi, [rsp+128h+var_80]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5beginEv; 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>>::begin(void)
mov [rsp+128h+var_90], rax
mov rdi, [rsp+128h+var_80]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE3endEv; 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>>::end(void)
mov [rsp+128h+var_98], rax
lea rdi, [rsp+128h+var_28]
call _ZSt13back_inserterISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES0_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES0_IhSaIhEEvEESaISE_EEESt20back_insert_iteratorIT_ERSI_; std::back_inserter<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>(std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>&)
mov [rsp+128h+var_F0], rax
jmp short $+2
loc_BCDCD:
mov rax, [rsp+128h+var_F0]
mov [rsp+128h+var_A0], rax
mov rdi, [rsp+128h+var_90]
mov rsi, [rsp+128h+var_98]
mov rdx, [rsp+128h+var_A0]
call _ZSt4moveIN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonINS3_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES6_ISG_SaISG_EEEESt20back_insert_iteratorISJ_EET0_T_SO_SN_; std::move<__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>>>,std::back_insert_iterator<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>>>>(__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>>>,__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>>>,std::back_insert_iterator<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 [rsp+128h+var_F8], rax
jmp short $+2
loc_BCDFE:
mov rax, [rsp+128h+var_F8]
mov [rsp+128h+var_A8], rax
mov rdi, [rsp+128h+var_80]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE5clearEv; 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>>::clear(void)
jmp loc_BCEDD
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
lea rdi, [rsp+arg_98]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_BCEFE
loc_BCE43:
lea rdi, [rsp+128h+var_88]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE9is_objectEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::is_object(void)
test al, 1
jnz short loc_BCE59
jmp loc_BCEDB
loc_BCE59:
mov rax, [rsp+128h+var_80]
mov [rsp+128h+var_B0], rax
mov rdi, [rsp+128h+var_B0]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5beginEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::begin(void)
mov [rsp+128h+var_B8], rax
mov rdi, [rsp+128h+var_B0]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE3endEv; std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>::end(void)
mov [rsp+128h+var_C0], rax
loc_BCE84:
lea rdi, [rsp+128h+var_B8]
lea rsi, [rsp+128h+var_C0]
call _ZN9__gnu_cxxneIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEEbRKNS_17__normal_iteratorIT_T0_EESR_; __gnu_cxx::operator!=<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>(__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&,__gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> const&)
test al, 1
jnz short loc_BCE99
jmp short loc_BCECE
loc_BCE99:
lea rdi, [rsp+128h+var_B8]
call _ZNK9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEdeEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator*(void)
mov [rsp+128h+var_C8], rax
mov rsi, [rsp+128h+var_C8]
add rsi, 20h ; ' '
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EE9push_backEOSD_; 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>>::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>&&)
jmp short $+2
loc_BCEC0:
jmp short $+2
loc_BCEC2:
lea rdi, [rsp+128h+var_B8]
call _ZN9__gnu_cxx17__normal_iteratorIPSt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINSA_11ordered_mapESt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEESD_ISI_SaISI_EEEppEv; __gnu_cxx::__normal_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *,std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>::operator++(void)
jmp short loc_BCE84
loc_BCECE:
mov rdi, [rsp+128h+var_80]
call _ZNSt6vectorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonINS9_11ordered_mapES_S6_blmdSaNS9_14adl_serializerES_IhSaIhEEvEEESaISG_EE5clearEv; 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>>>::clear(void)
loc_BCEDB:
jmp short $+2
loc_BCEDD:
lea rdi, [rsp+128h+var_88]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
jmp loc_BCD37
loc_BCEEF:
lea rdi, [rsp+128h+var_28]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; 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>>::~vector()
jmp short loc_BCF10
loc_BCEFE:
lea rdi, [rsp+arg_F8]
call _ZNSt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EED2Ev; 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>>::~vector()
jmp loc_BD0EF
loc_BCF10:
movzx eax, [rsp+128h+var_9]
mov [rsp+128h+var_100], rax
sub rax, 9; switch 10 cases
ja def_BCF3A; jumptable 00000000000BCF3A default case
mov rax, [rsp+128h+var_100]
lea rcx, jpt_BCF3A
movsxd rax, ds:(jpt_BCF3A - 20EB88h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_BCF3C:
lea rdi, [rsp+128h+var_C9]; jumptable 00000000000BCF3A case 1
mov [rsp+128h+var_108], rdi
call _ZNSaIN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEEEC2Ev; std::allocator<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>>>>>::allocator(void)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_108]
mov rsi, [rax]
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS1_10basic_jsonIS2_St6vectorS8_blmdSaNS1_14adl_serializerESA_IhSaIhEEvEESt4lessIvESaISt4pairIKS8_SE_EEEEEE7destroyISL_EEvRSM_PT_; std::allocator_traits<std::allocator<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>>>>>>::destroy<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>>>>>(std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>>&,nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>> *)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_108]
mov rsi, [rax]
mov edx, 1
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS1_10basic_jsonIS2_St6vectorS8_blmdSaNS1_14adl_serializerESA_IhSaIhEEvEESt4lessIvESaISt4pairIKS8_SE_EEEEEE10deallocateERSM_PSL_m; std::allocator_traits<std::allocator<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>>>>>>::deallocate(std::allocator<nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>>&,nlohmann::json_abi_v3_11_3::ordered_map<std::string,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,std::less<void>,std::allocator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>>*,ulong)
jmp short $+2
loc_BCF76:
lea rdi, [rsp+128h+var_C9]
call _ZNSaIN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEEED2Ev; std::allocator<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>>>>>::~allocator()
jmp loc_BD0E7
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
lea rdi, [rsp+arg_57]
call _ZNSaIN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEEEED2Ev; std::allocator<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>>>>>::~allocator()
jmp loc_BD0EF
loc_BCFA8:
lea rdi, [rsp+128h+var_CA]; jumptable 00000000000BCF3A case 2
mov [rsp+128h+var_110], rdi
call _ZNSaISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEEC2Ev; std::allocator<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>>>::allocator(void)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_110]
mov rsi, [rax]
call _ZNSt16allocator_traitsISaISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES0_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES0_IhSaIhEEvEESaISE_EEEE7destroyISG_EEvRSH_PT_; std::allocator_traits<std::allocator<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>>>>::destroy<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<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>&,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_110]
mov rsi, [rax]
mov edx, 1
call _ZNSt16allocator_traitsISaISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS2_11ordered_mapES0_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS2_14adl_serializerES0_IhSaIhEEvEESaISE_EEEE10deallocateERSH_PSG_m; std::allocator_traits<std::allocator<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>>>>::deallocate(std::allocator<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>&,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>*,ulong)
jmp short $+2
loc_BCFE2:
lea rdi, [rsp+128h+var_CA]
call _ZNSaISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEED2Ev; std::allocator<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>>>::~allocator()
jmp loc_BD0E7
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
lea rdi, [rsp+arg_56]
call _ZNSaISt6vectorIN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapES_NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES_IhSaIhEEvEESaISD_EEED2Ev; std::allocator<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>>>::~allocator()
jmp loc_BD0EF
loc_BD014:
lea rdi, [rsp+128h+var_CB]; jumptable 00000000000BCF3A case 3
mov [rsp+128h+var_118], rdi
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEC2Ev; std::allocator<std::string>::allocator(void)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_118]
mov rsi, [rax]
call _ZNSt16allocator_traitsISaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE7destroyIS5_EEvRS6_PT_; std::allocator_traits<std::allocator<std::string>>::destroy<std::string>(std::allocator<std::string>&,std::string *)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_118]
mov rsi, [rax]
mov edx, 1
call _ZNSt16allocator_traitsISaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEE10deallocateERS6_PS5_m; std::allocator_traits<std::allocator<std::string>>::deallocate(std::allocator<std::string>&,std::string*,ulong)
jmp short $+2
loc_BD04E:
lea rdi, [rsp+128h+var_CB]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
jmp loc_BD0E7
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
lea rdi, [rsp+arg_55]
call _ZNSaINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEED2Ev; std::allocator<std::string>::~allocator()
jmp short loc_BD0EF
loc_BD07D:
lea rdi, [rsp+128h+var_CC]; jumptable 00000000000BCF3A case 8
mov [rsp+128h+var_120], rdi
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEC2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::allocator(void)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_120]
mov rsi, [rax]
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEE7destroyIS6_EEvRS7_PT_; std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>>::destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>(std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>&,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>> *)
mov rax, [rsp+128h+var_D8]
mov rdi, [rsp+128h+var_120]
mov rsi, [rax]
mov edx, 1
call _ZNSt16allocator_traitsISaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEEE10deallocateERS7_PS6_m; std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>>::deallocate(std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>&,nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>*,ulong)
jmp short $+2
loc_BD0B7:
lea rdi, [rsp+128h+var_CC]
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEED2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::~allocator()
jmp short loc_BD0E7
mov rcx, rax
mov eax, edx
mov [rsp+arg_F0], rcx
mov [rsp+arg_EC], eax
lea rdi, [rsp+arg_54]
call _ZNSaIN8nlohmann16json_abi_v3_11_327byte_container_with_subtypeISt6vectorIhSaIhEEEEED2Ev; std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<uchar>>>::~allocator()
jmp short loc_BD0EF
loc_BD0E3:
jmp short $+2; jumptable 00000000000BCF3A cases 0,4-7,9
def_BCF3A:
jmp short $+2; jumptable 00000000000BCF3A default case
loc_BD0E7:
add rsp, 128h
retn
loc_BD0EF:
mov rdi, [rsp+arg_F0]
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>::json_value::destroy(
long long *a1,
unsigned __int8 a2)
{
long long result; // rax
long long v3; // rax
long long v4; // rax
long long v5; // rsi
long long v6; // rcx
long long v7; // r8
long long v8; // r9
long long v9; // rcx
long long v10; // r8
long long v11; // r9
long long v12; // rcx
long long v13; // r8
long long v14; // r9
long long v15; // rcx
long long v16; // r8
long long v17; // r9
char v18; // [rsp+5Ch] [rbp-CCh] BYREF
char v19; // [rsp+5Dh] [rbp-CBh] BYREF
char v20; // [rsp+5Eh] [rbp-CAh] BYREF
char v21; // [rsp+5Fh] [rbp-C9h] BYREF
long long v22; // [rsp+60h] [rbp-C8h]
long long v23; // [rsp+68h] [rbp-C0h] BYREF
long long v24; // [rsp+70h] [rbp-B8h] BYREF
long long v25; // [rsp+78h] [rbp-B0h]
long long v26; // [rsp+80h] [rbp-A8h]
long long v27; // [rsp+88h] [rbp-A0h]
long long v28; // [rsp+90h] [rbp-98h]
long long v29; // [rsp+98h] [rbp-90h]
__int128 v30; // [rsp+A0h] [rbp-88h] BYREF
long long v31; // [rsp+B0h] [rbp-78h]
long long v32; // [rsp+B8h] [rbp-70h] BYREF
long long v33; // [rsp+C0h] [rbp-68h] BYREF
long long v34; // [rsp+C8h] [rbp-60h]
long long v35; // [rsp+D0h] [rbp-58h]
long long v36; // [rsp+D8h] [rbp-50h]
long long v37; // [rsp+E0h] [rbp-48h]
long long v38; // [rsp+E8h] [rbp-40h]
_BYTE v39[31]; // [rsp+100h] [rbp-28h] BYREF
unsigned __int8 v40; // [rsp+11Fh] [rbp-9h]
long long *v41; // [rsp+120h] [rbp-8h]
v41 = a1;
v40 = a2;
if ( a2 != 1 || (result = (long long)a1, *a1) )
{
if ( v40 != 2 || (result = (long long)a1, *a1) )
{
if ( v40 != 3 || (result = (long long)a1, *a1) )
{
if ( v40 != 8 || (result = (long long)a1, *a1) )
{
if ( v40 == 2 || v40 == 1 )
{
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>>::vector((long long)v39);
if ( v40 == 2 )
{
v3 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::size((_QWORD *)*a1);
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>>::reserve(
v39,
v3);
v38 = 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>>::begin(*a1);
v37 = 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>>::end(*a1);
v36 = std::back_inserter<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>>>(v39);
v35 = std::move<__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,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::back_insert_iterator<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>>>>(
v38,
v37,
v36);
}
else
{
v4 = 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>>>::size((_QWORD *)*a1);
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>>::reserve(
v39,
v4);
v34 = *a1;
v33 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(v34);
v32 = 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(v34);
while ( (__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>>>>(
&v33,
&v32) & 1) != 0 )
{
v31 = __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*(&v33);
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>>::push_back(
v39,
v31 + 32);
__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++(&v33);
}
}
while ( (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>>::empty(v39) & 1) == 0 )
{
v5 = std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::back((long long)v39);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(
&v30,
v5);
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>>::pop_back(v39);
if ( nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::is_array(&v30) )
{
v29 = 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>>::begin(*((long long *)&v30 + 1));
v28 = 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>>::end(*((long long *)&v30 + 1));
v27 = std::back_inserter<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>>>(v39);
v26 = std::move<__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,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,std::back_insert_iterator<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>>>>(
v29,
v28,
v27);
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>>::clear(*((_QWORD *)&v30 + 1));
}
else 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(&v30) )
{
v25 = *((_QWORD *)&v30 + 1);
v24 = std::vector<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::begin(*((_QWORD *)&v30 + 1));
v23 = 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(v25);
while ( (__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>>>>(
&v24,
&v23) & 1) != 0 )
{
v22 = __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*(&v24);
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>>::push_back(
v39,
v22 + 32);
__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++(&v24);
}
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>>>::clear(*((_QWORD *)&v30 + 1));
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)&v30);
}
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>>::~vector(v39);
}
result = v40;
switch ( v40 )
{
case 1u:
std::allocator<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>>>>>::allocator((long long)&v21);
std::allocator_traits<std::allocator<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>>>>>>::destroy<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>>>>>(
&v21,
*a1);
std::allocator_traits<std::allocator<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>>>>>>::deallocate(
(long long)&v21,
*a1,
1LL,
v6,
v7,
v8);
result = std::allocator<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>>>>>::~allocator((long long)&v21);
break;
case 2u:
std::allocator<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>>>::allocator((long long)&v20);
std::allocator_traits<std::allocator<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>>>>::destroy<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>>>(
&v20,
*a1);
std::allocator_traits<std::allocator<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>>>>::deallocate(
(long long)&v20,
*a1,
1LL,
v9,
v10,
v11);
result = std::allocator<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>>>::~allocator((long long)&v20);
break;
case 3u:
std::allocator<std::string>::allocator((long long)&v19);
std::allocator_traits<std::allocator<std::string>>::destroy<std::string>((long long)&v19, *a1);
std::allocator_traits<std::allocator<std::string>>::deallocate((long long)&v19, *a1, 1LL, v12, v13, v14);
result = std::allocator<std::string>::~allocator((long long)&v19);
break;
case 8u:
std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>::allocator((long long)&v18);
std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>>::destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>(
&v18,
*a1);
std::allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>>::deallocate(
(long long)&v18,
*a1,
1LL,
v15,
v16,
v17);
result = std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned char>>>::~allocator((long long)&v18);
break;
default:
return result;
}
}
}
}
}
return result;
}
|
destroy:
SUB RSP,0x128
MOV AL,SIL
MOV qword ptr [RSP + 0x120],RDI
MOV byte ptr [RSP + 0x11f],AL
MOV RAX,qword ptr [RSP + 0x120]
MOV qword ptr [RSP + 0x50],RAX
CMP byte ptr [RSP + 0x11f],0x1
JNZ 0x001bcb4b
MOV RAX,qword ptr [RSP + 0x50]
CMP qword ptr [RAX],0x0
JZ 0x001bcb8a
LAB_001bcb4b:
CMP byte ptr [RSP + 0x11f],0x2
JNZ 0x001bcb60
MOV RAX,qword ptr [RSP + 0x50]
CMP qword ptr [RAX],0x0
JZ 0x001bcb8a
LAB_001bcb60:
CMP byte ptr [RSP + 0x11f],0x3
JNZ 0x001bcb75
MOV RAX,qword ptr [RSP + 0x50]
CMP qword ptr [RAX],0x0
JZ 0x001bcb8a
LAB_001bcb75:
CMP byte ptr [RSP + 0x11f],0x8
JNZ 0x001bcb8f
MOV RAX,qword ptr [RSP + 0x50]
CMP qword ptr [RAX],0x0
JNZ 0x001bcb8f
LAB_001bcb8a:
JMP 0x001bd0e7
LAB_001bcb8f:
CMP byte ptr [RSP + 0x11f],0x2
JZ 0x001bcba7
CMP byte ptr [RSP + 0x11f],0x1
JNZ 0x001bcf10
LAB_001bcba7:
LEA RDI,[RSP + 0x100]
CALL 0x001aa3d0
CMP byte ptr [RSP + 0x11f],0x2
JNZ 0x001bcc7e
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
CALL 0x001b8190
MOV RSI,RAX
LAB_001bcbd2:
LEA RDI,[RSP + 0x100]
CALL 0x001bd100
JMP 0x001bcbe1
LAB_001bcbe1:
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
CALL 0x001b8050
MOV RCX,RAX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0xe8],RCX
MOV RDI,qword ptr [RAX]
CALL 0x001b7ec0
MOV qword ptr [RSP + 0xe0],RAX
LEA RDI,[RSP + 0x100]
CALL 0x001bd280
MOV qword ptr [RSP + 0x48],RAX
JMP 0x001bcc22
LAB_001bcc22:
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xe8]
MOV RSI,qword ptr [RSP + 0xe0]
MOV RDX,qword ptr [RSP + 0xd8]
CALL 0x001bd210
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001bcc53
LAB_001bcc53:
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0xd0],RAX
JMP 0x001bcd35
LAB_001bcc7e:
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RAX]
CALL 0x001b8d90
MOV RSI,RAX
LEA RDI,[RSP + 0x100]
CALL 0x001bd100
JMP 0x001bcc9d
LAB_001bcc9d:
MOV RAX,qword ptr [RSP + 0x50]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xc8],RAX
MOV RDI,qword ptr [RSP + 0xc8]
CALL 0x001bd2b0
MOV qword ptr [RSP + 0xc0],RAX
MOV RDI,qword ptr [RSP + 0xc8]
CALL 0x001bd2e0
MOV qword ptr [RSP + 0xb8],RAX
LAB_001bccd7:
LEA RDI,[RSP + 0xc0]
LEA RSI,[RSP + 0xb8]
CALL 0x001bd310
TEST AL,0x1
JNZ 0x001bccf2
JMP 0x001bcd33
LAB_001bccf2:
LEA RDI,[RSP + 0xc0]
CALL 0x001bd350
MOV qword ptr [RSP + 0xb0],RAX
MOV RSI,qword ptr [RSP + 0xb0]
ADD RSI,0x20
LEA RDI,[RSP + 0x100]
CALL 0x001bd360
JMP 0x001bcd22
LAB_001bcd22:
JMP 0x001bcd24
LAB_001bcd24:
LEA RDI,[RSP + 0xc0]
CALL 0x001bd390
JMP 0x001bccd7
LAB_001bcd33:
JMP 0x001bcd35
LAB_001bcd35:
JMP 0x001bcd37
LAB_001bcd37:
LEA RDI,[RSP + 0x100]
CALL 0x001bd3b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001bcd4f
JMP 0x001bceef
LAB_001bcd4f:
LEA RDI,[RSP + 0x100]
CALL 0x001b7b80
MOV RSI,RAX
LEA RDI,[RSP + 0xa0]
CALL 0x001b7a10
LEA RDI,[RSP + 0x100]
CALL 0x001bd400
LEA RDI,[RSP + 0xa0]
CALL 0x001b7ac0
TEST AL,0x1
JNZ 0x001bcd8f
JMP 0x001bce43
LAB_001bcd8f:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001b8050
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001b7ec0
MOV qword ptr [RSP + 0x90],RAX
LAB_001bcdb9:
LEA RDI,[RSP + 0x100]
CALL 0x001bd280
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001bcdcd
LAB_001bcdcd:
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x98]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x001bd210
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001bcdfe
LAB_001bcdfe:
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x80],RAX
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001bd420
JMP 0x001bcedd
LAB_001bce43:
LEA RDI,[RSP + 0xa0]
CALL 0x001b7ae0
TEST AL,0x1
JNZ 0x001bce59
JMP 0x001bcedb
LAB_001bce59:
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RSP + 0x78],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001bd2b0
MOV qword ptr [RSP + 0x70],RAX
MOV RDI,qword ptr [RSP + 0x78]
CALL 0x001bd2e0
MOV qword ptr [RSP + 0x68],RAX
LAB_001bce84:
LEA RDI,[RSP + 0x70]
LEA RSI,[RSP + 0x68]
CALL 0x001bd310
TEST AL,0x1
JNZ 0x001bce99
JMP 0x001bcece
LAB_001bce99:
LEA RDI,[RSP + 0x70]
CALL 0x001bd350
MOV qword ptr [RSP + 0x60],RAX
MOV RSI,qword ptr [RSP + 0x60]
ADD RSI,0x20
LEA RDI,[RSP + 0x100]
CALL 0x001bd360
JMP 0x001bcec0
LAB_001bcec0:
JMP 0x001bcec2
LAB_001bcec2:
LEA RDI,[RSP + 0x70]
CALL 0x001bd390
JMP 0x001bce84
LAB_001bcece:
MOV RDI,qword ptr [RSP + 0xa8]
CALL 0x001bd440
LAB_001bcedb:
JMP 0x001bcedd
LAB_001bcedd:
LEA RDI,[RSP + 0xa0]
CALL 0x001a8760
JMP 0x001bcd37
LAB_001bceef:
LEA RDI,[RSP + 0x100]
CALL 0x001bd460
JMP 0x001bcf10
LAB_001bcf10:
MOVZX EAX,byte ptr [RSP + 0x11f]
MOV qword ptr [RSP + 0x28],RAX
SUB RAX,0x9
JA 0x001bd0e5
MOV RAX,qword ptr [RSP + 0x28]
LEA RCX,[0x30eb88]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
LEA RDI,[RSP + 0x5f]
MOV qword ptr [RSP + 0x20],RDI
CALL 0x001a9980
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
CALL 0x001bd4c0
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RAX]
LAB_001bcf6a:
MOV EDX,0x1
CALL 0x001a9fd0
JMP 0x001bcf76
LAB_001bcf76:
LEA RDI,[RSP + 0x5f]
CALL 0x001a9af0
JMP 0x001bd0e7
caseD_2:
LEA RDI,[RSP + 0x5e]
MOV qword ptr [RSP + 0x18],RDI
CALL 0x001aa040
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
CALL 0x001bd4f0
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x18]
MOV RSI,qword ptr [RAX]
LAB_001bcfd6:
MOV EDX,0x1
CALL 0x001aa670
JMP 0x001bcfe2
LAB_001bcfe2:
LEA RDI,[RSP + 0x5e]
CALL 0x001aa1b0
JMP 0x001bd0e7
caseD_3:
LEA RDI,[RSP + 0x5d]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x00168940
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
CALL 0x00196400
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
LAB_001bd042:
MOV EDX,0x1
CALL 0x00169220
JMP 0x001bd04e
LAB_001bd04e:
LEA RDI,[RSP + 0x5d]
CALL 0x001689e0
JMP 0x001bd0e7
caseD_8:
LEA RDI,[RSP + 0x5c]
MOV qword ptr [RSP + 0x8],RDI
CALL 0x001aabe0
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
CALL 0x001bd520
MOV RAX,qword ptr [RSP + 0x50]
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RAX]
LAB_001bd0ab:
MOV EDX,0x1
CALL 0x001ab230
LAB_001bd0b5:
JMP 0x001bd0b7
LAB_001bd0b7:
LEA RDI,[RSP + 0x5c]
CALL 0x001aad50
JMP 0x001bd0e7
caseD_0:
JMP 0x001bd0e5
LAB_001bd0e5:
JMP 0x001bd0e7
default:
ADD RSP,0x128
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>::json_value::destroy(nlohmann::json_abi_v3_11_3::detail::value_t) */
void __thiscall
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::json_value::destroy(json_value *this,char param_2)
{
byte bVar1;
bool bVar2;
ulong uVar3;
basic_json *pbVar4;
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
local_cc;
allocator<std::__cxx11::string> local_cb;
allocator<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>>>>
local_ca;
allocator<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>>>>>
local_c9;
long local_c8;
int8 local_c0;
int8 local_b8;
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*local_b0;
int8 local_a8;
int8 local_a0;
int8 local_98;
int8 local_90;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_88 [8];
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>>>
*local_80;
long local_78;
int8 local_70;
int8 local_68;
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*local_60;
int8 local_58;
int8 local_50;
int8 local_48;
int8 local_40;
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>>>
local_28 [31];
char local_9;
json_value *local_8;
if (((((param_2 != '\x01') || (*(long *)this != 0)) &&
((param_2 != '\x02' || (*(long *)this != 0)))) &&
((param_2 != '\x03' || (*(long *)this != 0)))) && ((param_2 != '\b' || (*(long *)this != 0))))
{
local_9 = param_2;
local_8 = this;
if ((param_2 == '\x02') || (param_2 == '\x01')) {
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::vector(local_28);
if (local_9 == '\x02') {
uVar3 = std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::size(*(vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)this);
/* try { // try from 001bcbd2 to 001bcd1f has its CatchHandler @ 001bcc65 */
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>>>
::reserve(local_28,uVar3);
local_40 = 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>>>
::begin(*(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);
local_48 = 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>>>
::end(*(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);
local_50 = std::
back_inserter<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
((vector *)local_28);
local_58 = std::
move<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,std::back_insert_iterator<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>>>>>
(local_40,local_48,local_50);
}
else {
uVar3 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::size(*(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this);
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>>>
::reserve(local_28,uVar3);
local_60 = *(vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
**)this;
local_68 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::begin(local_60);
local_70 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(local_60);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_68,(__normal_iterator *)&local_70),
bVar2) {
local_78 = __gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator*((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_68);
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::push_back(local_28,(basic_json *)(local_78 + 0x20));
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator++((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_68);
}
}
while (bVar1 = 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(local_28), ((bVar1 ^ 0xff) & 1) != 0) {
pbVar4 = (basic_json *)
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(local_28);
basic_json(local_88,pbVar4);
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(local_28);
uVar3 = is_array(local_88);
if ((uVar3 & 1) == 0) {
uVar3 = is_object(local_88);
if ((uVar3 & 1) != 0) {
local_b0 = (vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)local_80;
local_b8 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::begin((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)local_80);
local_c0 = std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::end(local_b0);
while (bVar2 = __gnu_cxx::operator!=
((__normal_iterator *)&local_b8,(__normal_iterator *)&local_c0)
, bVar2) {
local_c8 = __gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator*((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_b8);
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::push_back(local_28,(basic_json *)(local_c8 + 0x20));
__gnu_cxx::
__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
::operator++((__normal_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>*,std::vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>>
*)&local_b8);
}
std::
vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::clear((vector<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)local_80);
}
}
else {
local_90 = 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>>>
::begin(local_80);
local_98 = 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>>>
::end(local_80);
/* try { // try from 001bcdb9 to 001bcebd has its CatchHandler @ 001bce1d */
local_a0 = std::
back_inserter<std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
((vector *)local_28);
local_a8 = std::
move<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,std::back_insert_iterator<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>>>>>
(local_90,local_98,local_a0);
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>>>
::clear(local_80);
}
~basic_json(local_88);
}
std::
vector<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::~vector(local_28);
}
switch(local_9) {
case '\0':
case '\x04':
case '\x05':
case '\x06':
case '\a':
case '\t':
break;
case '\x01':
std::
allocator<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>>>>>
::allocator(&local_c9);
std::
allocator_traits<std::allocator<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>>>>>>
::
destroy<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>>>>>
((allocator *)&local_c9,*(ordered_map **)this);
/* try { // try from 001bcf6a to 001bcf73 has its CatchHandler @ 001bcf85 */
std::
allocator_traits<std::allocator<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>>>>>>
::deallocate((allocator *)&local_c9,*(ordered_map **)this,1);
std::
allocator<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>>>>>
::~allocator(&local_c9);
break;
case '\x02':
std::
allocator<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>>>>
::allocator(&local_ca);
std::
allocator_traits<std::allocator<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>>>>>
::
destroy<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>>>>
((allocator *)&local_ca,*(vector **)this);
/* try { // try from 001bcfd6 to 001bcfdf has its CatchHandler @ 001bcff1 */
std::
allocator_traits<std::allocator<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>>>>>
::deallocate((allocator *)&local_ca,*(vector **)this,1);
std::
allocator<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>>>>
::~allocator(&local_ca);
break;
case '\x03':
std::allocator<std::__cxx11::string>::allocator(&local_cb);
std::allocator_traits<std::allocator<std::__cxx11::string>>::destroy<std::__cxx11::string>
((allocator *)&local_cb,*(string **)this);
/* try { // try from 001bd042 to 001bd04b has its CatchHandler @ 001bd05d */
std::allocator_traits<std::allocator<std::__cxx11::string>>::deallocate
((allocator *)&local_cb,*(string **)this,1);
std::allocator<std::__cxx11::string>::~allocator(&local_cb);
break;
case '\b':
std::
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
::allocator(&local_cc);
std::
allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>>
::
destroy<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
((allocator *)&local_cc,*(byte_container_with_subtype **)this);
/* try { // try from 001bd0ab to 001bd0b4 has its CatchHandler @ 001bd0c3 */
std::
allocator_traits<std::allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>>
::deallocate((allocator *)&local_cc,*(byte_container_with_subtype **)this,1);
std::
allocator<nlohmann::json_abi_v3_11_3::byte_container_with_subtype<std::vector<unsigned_char,std::allocator<unsigned_char>>>>
::~allocator(&local_cc);
}
}
return;
}
|
|
7,751 |
alaya::GraphSearchJob<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::search_solo_updated(float*, unsigned int, unsigned int*, unsigned int)
|
AlayaLite/include/executor/jobs/graph_search_job.hpp
|
void search_solo_updated(DataType *query, uint32_t k, IDType *ids, uint32_t ef) {
auto query_computer = space_->get_query_computer(query);
LinearPool<DistanceType, IDType> pool(space_->get_data_num(), ef);
graph_->initialize_search(pool, query_computer);
while (pool.has_next()) {
auto u = pool.pop();
if (job_context_->removed_node_nbrs_.find(u) != job_context_->removed_node_nbrs_.end()) {
for (auto &second_hop_nbr : job_context_->removed_node_nbrs_.at(u)) {
if (pool.vis_.get(u)) {
continue;
}
pool.vis_.set(u);
auto dist = query_computer(u);
pool.insert(u, dist);
}
continue;
}
for (int i = 0; i < graph_->max_nbrs_; ++i) {
int v = graph_->at(u, i);
if (v == -1) {
break;
}
if (pool.vis_.get(v)) {
continue;
}
pool.vis_.set(v);
auto jump_prefetch = i + 3;
if (jump_prefetch < graph_->max_nbrs_) {
auto prefetch_id = graph_->at(u, jump_prefetch);
if (prefetch_id != -1) {
space_->prefetch_by_id(prefetch_id);
}
}
auto cur_dist = query_computer(v);
pool.insert(v, cur_dist);
}
}
for (int i = 0; i < k; i++) {
ids[i] = pool.id(i);
}
}
|
O3
|
cpp
|
alaya::GraphSearchJob<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float, unsigned int>>, float, float, unsigned int>::search_solo_updated(float*, unsigned int, unsigned int*, unsigned int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %r8d, %r15d
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x23dc0
movq (%r14), %rax
movl 0x18(%rax), %esi
leaq 0x18(%rsp), %rdi
movl %r15d, %edx
callq 0x23b4e
movq 0x10(%r14), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x23bba
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x27335
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x23c38
movl %eax, 0x4(%rsp)
movq 0x20(%r14), %rdi
addq $0x70, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2894c
testq %rax, %rax
je 0x27225
movq 0x20(%r14), %rdi
addq $0x70, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2894c
testq %rax, %rax
je 0x2739e
movq 0x10(%rax), %r13
movq 0x18(%rax), %rbp
cmpq %rbp, %r13
je 0x27325
movl 0x4(%rsp), %ecx
movl %ecx, %eax
shrl $0x6, %eax
movq 0x58(%rsp), %rdx
movq (%rdx,%rax,8), %rsi
movl $0x1, %edi
shlq %cl, %rdi
btq %rcx, %rsi
jb 0x2721f
orq %rsi, %rdi
movq %rdi, (%rdx,%rax,8)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdx
movl %ecx, %esi
andl $-0x8, %esi
movl (%rdx,%rsi), %edx
movl %ecx, %esi
andl $0x7, %esi
btl %esi, %edx
movss 0x57ec0(%rip), %xmm0 # 0x7f0b8
jae 0x27215
imulq 0x30(%rax), %rcx
movq 0x10(%rsp), %rdi
addq 0x50(%rax), %rcx
movl 0x14(%rax), %edx
movq %rcx, %rsi
callq *0x8(%rax)
movl 0x4(%rsp), %ecx
movq %r15, %rdi
movl %ecx, %esi
callq 0x23cc8
addq $0x4, %r13
jmp 0x271a7
movq 0x10(%r14), %rax
movl 0x4(%rax), %edx
testl %edx, %edx
je 0x27325
xorl %ebp, %ebp
movl 0x4(%rsp), %esi
movq 0x30(%rax), %rdi
movq 0x10(%rax), %rcx
imulq %rsi, %rcx
addq %rdi, %rcx
movslq (%rcx,%rbp,4), %rcx
cmpq $-0x1, %rcx
je 0x27325
movq %rcx, %r8
shrq $0x6, %r8
movq 0x58(%rsp), %r9
movq (%r9,%r8,8), %r10
movl $0x1, %r11d
shlq %cl, %r11
btq %rcx, %r10
jb 0x27316
orq %r11, %r10
movq %r10, (%r9,%r8,8)
leaq 0x3(%rbp), %r8
movl %edx, %edx
cmpq %rdx, %r8
jae 0x272c9
imulq 0x10(%rax), %rsi
addq %rsi, %rdi
movl 0xc(%rdi,%rbp,4), %eax
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
cmpq %rdx, %rax
je 0x272c9
movq (%r14), %rsi
movl 0x10(%rsi), %edx
cmpq $0x40, %rdx
jb 0x272c9
imulq 0x30(%rsi), %rax
addq 0x50(%rsi), %rax
andl $-0x40, %edx
xorl %esi, %esi
prefetcht0 (%rax,%rsi)
addq $0x40, %rsi
cmpq %rsi, %rdx
jne 0x272bc
movl %ecx, %r13d
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdx
movl %r13d, %esi
andl $-0x8, %esi
movl (%rdx,%rsi), %edx
movl %r13d, %esi
andl $0x7, %esi
btl %esi, %edx
movss 0x57dc9(%rip), %xmm0 # 0x7f0b8
jae 0x27307
movl %ecx, %esi
imulq 0x30(%rax), %rsi
movq 0x10(%rsp), %rdi
addq 0x50(%rax), %rsi
movl 0x14(%rax), %edx
callq *0x8(%rax)
movq %r15, %rdi
movl %r13d, %esi
callq 0x23cc8
movq 0x10(%r14), %rax
incq %rbp
movl 0x4(%rax), %edx
cmpq %rdx, %rbp
jb 0x27236
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x2715d
testl %r12d, %r12d
je 0x2735c
movq 0x40(%rsp), %rax
movl %r12d, %ecx
xorl %edx, %edx
movl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movl (%rax), %edi
andl %esi, %edi
movl %edi, (%rbx,%rdx,4)
incq %rdx
addq $0xc, %rax
cmpq %rdx, %rcx
jne 0x27349
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x27373
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x11120
cmpq $0x0, 0x40(%rsp)
je 0x27385
movq 0x38(%rsp), %rdi
callq 0x111e0
movq 0x10(%rsp), %rdi
callq 0x111e0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x598d6(%rip), %rdi # 0x80c7b
callq 0x11710
jmp 0x273bb
movq %rax, %rbx
jmp 0x273c8
jmp 0x273bb
jmp 0x273bb
jmp 0x273bb
jmp 0x273bb
jmp 0x273bb
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x23d94
movq 0x10(%rsp), %rdi
callq 0x111e0
movq %rbx, %rdi
callq 0x11760
|
_ZN5alaya14GraphSearchJobINS_8RawSpaceIffjNS_17SequentialStorageIfjEEEEffjE19search_solo_updatedEPfjPjj:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 78h
mov r15d, r8d
mov rbx, rcx
mov r12d, edx
mov rdx, rsi
mov r14, rdi
mov rsi, [rdi]
lea rdi, [rsp+0A8h+var_A0]
call _ZN5alaya8RawSpaceIffjNS_17SequentialStorageIfjEEE13QueryComputerC2ERKS3_PKf; alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>::QueryComputer::QueryComputer(alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>> const&,float const*)
mov rax, [r14]
mov esi, [rax+18h]
lea rdi, [rsp+0A8h+var_90]
mov edx, r15d
call _ZN5alaya10LinearPoolIfjEC2Eji; alaya::LinearPool<float,uint>::LinearPool(uint,int)
mov rdi, [r14+10h]
lea rsi, [rsp+0A8h+var_90]
lea rdx, [rsp+0A8h+var_A0]
call _ZNK5alaya5GraphIfjNS_17SequentialStorageIjjEEE17initialize_searchINS_10LinearPoolIfjEENS_8RawSpaceIffjNS1_IfjEEE13QueryComputerEEEvRT_RKT0_; alaya::Graph<float,uint,alaya::SequentialStorage<uint,uint>>::initialize_search<alaya::LinearPool<float,uint>,alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>::QueryComputer>(alaya::LinearPool<float,uint> &,alaya::RawSpace<float,float,uint,alaya::SequentialStorage<float,uint>>::QueryComputer const&)
mov rax, [rsp+0A8h+var_80]
cmp rax, [rsp+0A8h+var_88]
jnb loc_27335
lea r15, [rsp+0A8h+var_90]
loc_2715D:
mov rdi, r15
call _ZN5alaya10LinearPoolIfjE3popEv; alaya::LinearPool<float,uint>::pop(void)
mov [rsp+0A8h+var_A4], eax
mov rdi, [r14+20h]
add rdi, 70h ; 'p'
lea rsi, [rsp+0A8h+var_A4]
call _ZNSt10_HashtableIjSt4pairIKjSt6vectorIjSaIjEEESaIS5_ENSt8__detail10_Select1stESt8equal_toIjESt4hashIjENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS1_; std::_Hashtable<uint,std::pair<uint const,std::vector<uint>>,std::allocator<std::pair<uint const,std::vector<uint>>>,std::__detail::_Select1st,std::equal_to<uint>,std::hash<uint>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(uint const&)
test rax, rax
jz loc_27225
mov rdi, [r14+20h]
add rdi, 70h ; 'p'
lea rsi, [rsp+0A8h+var_A4]
call _ZNSt10_HashtableIjSt4pairIKjSt6vectorIjSaIjEEESaIS5_ENSt8__detail10_Select1stESt8equal_toIjESt4hashIjENS7_18_Mod_range_hashingENS7_20_Default_ranged_hashENS7_20_Prime_rehash_policyENS7_17_Hashtable_traitsILb0ELb0ELb1EEEE4findERS1_; std::_Hashtable<uint,std::pair<uint const,std::vector<uint>>,std::allocator<std::pair<uint const,std::vector<uint>>>,std::__detail::_Select1st,std::equal_to<uint>,std::hash<uint>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(uint const&)
test rax, rax
jz loc_2739E
mov r13, [rax+10h]
mov rbp, [rax+18h]
loc_271A7:
cmp r13, rbp
jz loc_27325
mov ecx, [rsp+0A8h+var_A4]
mov eax, ecx
shr eax, 6
mov rdx, [rsp+0A8h+var_50]
mov rsi, [rdx+rax*8]
mov edi, 1
shl rdi, cl
bt rsi, rcx
jb short loc_2721F
or rdi, rsi
mov [rdx+rax*8], rdi
mov rax, [rsp+0A8h+var_A0]
mov rdx, [rax+58h]
mov esi, ecx
and esi, 0FFFFFFF8h
mov edx, [rdx+rsi]
mov esi, ecx
and esi, 7
bt edx, esi
movss xmm0, cs:dword_7F0B8
jnb short loc_27215
imul rcx, [rax+30h]
mov rdi, [rsp+0A8h+var_98]
add rcx, [rax+50h]
mov edx, [rax+14h]
mov rsi, rcx
call qword ptr [rax+8]
mov ecx, [rsp+0A8h+var_A4]
loc_27215:
mov rdi, r15
mov esi, ecx
call _ZN5alaya10LinearPoolIfjE6insertEjf; alaya::LinearPool<float,uint>::insert(uint,float)
loc_2721F:
add r13, 4
jmp short loc_271A7
loc_27225:
mov rax, [r14+10h]
mov edx, [rax+4]
test edx, edx
jz loc_27325
xor ebp, ebp
loc_27236:
mov esi, [rsp+0A8h+var_A4]
mov rdi, [rax+30h]
mov rcx, [rax+10h]
imul rcx, rsi
add rcx, rdi
movsxd rcx, dword ptr [rcx+rbp*4]
cmp rcx, 0FFFFFFFFFFFFFFFFh
jz loc_27325
mov r8, rcx
shr r8, 6
mov r9, [rsp+0A8h+var_50]
mov r10, [r9+r8*8]
mov r11d, 1
shl r11, cl
bt r10, rcx
jb loc_27316
or r10, r11
mov [r9+r8*8], r10
lea r8, [rbp+3]
mov edx, edx
cmp r8, rdx
jnb short loc_272C9
imul rsi, [rax+10h]
add rdi, rsi
mov eax, [rdi+rbp*4+0Ch]
mov edx, 0FFFFFFFFh
cmp rax, rdx
jz short loc_272C9
mov rsi, [r14]
mov edx, [rsi+10h]
cmp rdx, 40h ; '@'
jb short loc_272C9
imul rax, [rsi+30h]
add rax, [rsi+50h]
and edx, 0FFFFFFC0h
xor esi, esi
loc_272BC:
prefetcht0 byte ptr [rax+rsi]
add rsi, 40h ; '@'
cmp rdx, rsi
jnz short loc_272BC
loc_272C9:
mov r13d, ecx
mov rax, [rsp+0A8h+var_A0]
mov rdx, [rax+58h]
mov esi, r13d
and esi, 0FFFFFFF8h
mov edx, [rdx+rsi]
mov esi, r13d
and esi, 7
bt edx, esi
movss xmm0, cs:dword_7F0B8
jnb short loc_27307
mov esi, ecx
imul rsi, [rax+30h]
mov rdi, [rsp+0A8h+var_98]
add rsi, [rax+50h]
mov edx, [rax+14h]
call qword ptr [rax+8]
loc_27307:
mov rdi, r15
mov esi, r13d
call _ZN5alaya10LinearPoolIfjE6insertEjf; alaya::LinearPool<float,uint>::insert(uint,float)
mov rax, [r14+10h]
loc_27316:
inc rbp
mov edx, [rax+4]
cmp rbp, rdx
jb loc_27236
loc_27325:
mov rax, [rsp+0A8h+var_80]
cmp rax, [rsp+0A8h+var_88]
jb loc_2715D
loc_27335:
test r12d, r12d
jz short loc_2735C
mov rax, [rsp+0A8h+var_68]
mov ecx, r12d
xor edx, edx
mov esi, 7FFFFFFFh
loc_27349:
mov edi, [rax]
and edi, esi
mov [rbx+rdx*4], edi
inc rdx
add rax, 0Ch
cmp rcx, rdx
jnz short loc_27349
loc_2735C:
mov rdi, [rsp+0A8h+var_50]; void *
test rdi, rdi
jz short loc_27373
mov rsi, [rsp+0A8h+var_40]
sub rsi, rdi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_27373:
cmp [rsp+0A8h+var_68], 0
jz short loc_27385
mov rdi, [rsp+0A8h+var_70]
call _free
loc_27385:
mov rdi, [rsp+0A8h+var_98]
call _free
add rsp, 78h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2739E:
lea rdi, aMapBaseAt; "_Map_base::at"
call __ZSt20__throw_out_of_rangePKc; std::__throw_out_of_range(char const*)
jmp short loc_273BB
mov rbx, rax
jmp short loc_273C8
jmp short loc_273BB
jmp short loc_273BB
jmp short loc_273BB
jmp short loc_273BB
jmp short $+2
loc_273BB:
mov rbx, rax
lea rdi, [rsp+0A8h+var_90]
call _ZN5alaya10LinearPoolIfjED2Ev; alaya::LinearPool<float,uint>::~LinearPool()
loc_273C8:
mov rdi, [rsp+0A8h+var_98]
call _free
mov rdi, rbx
call __Unwind_Resume
|
long long alaya::GraphSearchJob<alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>,float,float,unsigned int>::search_solo_updated(
_DWORD **a1,
long long a2,
int a3,
long long a4,
int a5)
{
long long v9; // rax
long long v10; // r13
long long v11; // rbp
long long v12; // rcx
long long v13; // rax
long long v14; // rsi
int v15; // edx
_DWORD *v16; // rax
unsigned long long v17; // rdx
unsigned long long v18; // rbp
long long v19; // rsi
long long v20; // rdi
unsigned long long v21; // rcx
long long v22; // r10
long long v23; // rax
unsigned long long v24; // rdx
long long v25; // rax
long long v26; // rdx
long long v27; // rsi
int v28; // r13d
int v29; // edx
float v30; // xmm0_4
_DWORD *v31; // rax
long long v32; // rdx
unsigned int v34; // [rsp+4h] [rbp-A4h] BYREF
long long v35; // [rsp+8h] [rbp-A0h] BYREF
long long v36; // [rsp+10h] [rbp-98h]
long long v37; // [rsp+18h] [rbp-90h] BYREF
unsigned long long v38; // [rsp+20h] [rbp-88h]
unsigned long long v39; // [rsp+28h] [rbp-80h]
long long v40; // [rsp+38h] [rbp-70h]
_DWORD *v41; // [rsp+40h] [rbp-68h]
void *v42; // [rsp+58h] [rbp-50h]
long long v43; // [rsp+68h] [rbp-40h]
alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>::QueryComputer::QueryComputer(
&v35,
*a1,
a2);
alaya::LinearPool<float,unsigned int>::LinearPool((long long)&v37, (*a1)[6], a5);
alaya::Graph<float,unsigned int,alaya::SequentialStorage<unsigned int,unsigned int>>::initialize_search<alaya::LinearPool<float,unsigned int>,alaya::RawSpace<float,float,unsigned int,alaya::SequentialStorage<float,unsigned int>>::QueryComputer>(
a1[2],
(long long)&v37,
(long long)&v35);
while ( v39 < v38 )
{
v34 = alaya::LinearPool<float,unsigned int>::pop(&v37);
if ( std::_Hashtable<unsigned int,std::pair<unsigned int const,std::vector<unsigned int>>,std::allocator<std::pair<unsigned int const,std::vector<unsigned int>>>,std::__detail::_Select1st,std::equal_to<unsigned int>,std::hash<unsigned int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(
a1[4] + 28,
&v34) )
{
v9 = std::_Hashtable<unsigned int,std::pair<unsigned int const,std::vector<unsigned int>>,std::allocator<std::pair<unsigned int const,std::vector<unsigned int>>>,std::__detail::_Select1st,std::equal_to<unsigned int>,std::hash<unsigned int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>::find(
a1[4] + 28,
&v34);
if ( !v9 )
std::__throw_out_of_range("_Map_base::at");
v10 = *(_QWORD *)(v9 + 16);
v11 = *(_QWORD *)(v9 + 24);
while ( v10 != v11 )
{
v12 = v34;
v13 = v34 >> 6;
v14 = *((_QWORD *)v42 + v13);
if ( !_bittest64(&v14, v34) )
{
*((_QWORD *)v42 + v13) = v14 | (1LL << v34);
v15 = *(_DWORD *)(*(_QWORD *)(v35 + 88) + ((unsigned int)v12 & 0xFFFFFFF8));
if ( _bittest(&v15, v12 & 7) )
{
(*(void ( **)(long long, long long, _QWORD, float))(v35 + 8))(
v36,
*(_QWORD *)(v35 + 80) + *(_QWORD *)(v35 + 48) * v12,
*(unsigned int *)(v35 + 20),
3.4028235e38);
LODWORD(v12) = v34;
}
alaya::LinearPool<float,unsigned int>::insert(&v37, v12, 3.4028235e38);
}
v10 += 4LL;
}
}
else
{
v16 = a1[2];
LODWORD(v17) = v16[1];
if ( (_DWORD)v17 )
{
v18 = 0LL;
do
{
v19 = v34;
v20 = *((_QWORD *)v16 + 6);
v21 = *(int *)(v20 + v34 * *((_QWORD *)v16 + 2) + 4 * v18);
if ( v21 == -1LL )
break;
v22 = *((_QWORD *)v42 + (v21 >> 6));
if ( !_bittest64(&v22, v21) )
{
*((_QWORD *)v42 + (v21 >> 6)) = (1LL << v21) | v22;
if ( v18 + 3 < (unsigned int)v17 )
{
v23 = *(unsigned int *)(*((_QWORD *)v16 + 2) * v19 + v20 + 4 * v18 + 12);
if ( v23 != 0xFFFFFFFFLL )
{
v24 = (unsigned int)(*a1)[4];
if ( v24 >= 0x40 )
{
v25 = *((_QWORD *)*a1 + 10) + *((_QWORD *)*a1 + 6) * v23;
v26 = (unsigned int)v24 & 0xFFFFFFC0;
v27 = 0LL;
do
{
_mm_prefetch((const char *)(v25 + v27), 1);
v27 += 64LL;
}
while ( v26 != v27 );
}
}
}
v28 = v21;
v29 = *(_DWORD *)(*(_QWORD *)(v35 + 88) + ((unsigned int)v21 & 0xFFFFFFF8));
v30 = 3.4028235e38;
if ( _bittest(&v29, v21 & 7) )
v30 = (*(float ( **)(long long, _QWORD, _QWORD, float))(v35 + 8))(
v36,
*(_QWORD *)(v35 + 80) + *(_QWORD *)(v35 + 48) * (unsigned int)v21,
*(unsigned int *)(v35 + 20),
3.4028235e38);
alaya::LinearPool<float,unsigned int>::insert(&v37, v28, v30);
v16 = a1[2];
}
++v18;
v17 = (unsigned int)v16[1];
}
while ( v18 < v17 );
}
}
}
if ( a3 )
{
v31 = v41;
v32 = 0LL;
do
{
*(_DWORD *)(a4 + 4 * v32++) = *v31 & 0x7FFFFFFF;
v31 += 3;
}
while ( a3 != v32 );
}
if ( v42 )
operator delete(v42, v43 - (_QWORD)v42);
if ( v41 )
free(v40);
return free(v36);
}
|
search_solo_updated:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV R15D,R8D
MOV RBX,RCX
MOV R12D,EDX
MOV RDX,RSI
MOV R14,RDI
MOV RSI,qword ptr [RDI]
LEA RDI,[RSP + 0x8]
CALL 0x00123dc0
MOV RAX,qword ptr [R14]
MOV ESI,dword ptr [RAX + 0x18]
LAB_00127128:
LEA RDI,[RSP + 0x18]
MOV EDX,R15D
CALL 0x00123b4e
MOV RDI,qword ptr [R14 + 0x10]
LAB_00127139:
LEA RSI,[RSP + 0x18]
LEA RDX,[RSP + 0x8]
CALL 0x00123bba
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RSP + 0x20]
JNC 0x00127335
LEA R15,[RSP + 0x18]
LAB_0012715d:
MOV RDI,R15
CALL 0x00123c38
MOV dword ptr [RSP + 0x4],EAX
MOV RDI,qword ptr [R14 + 0x20]
ADD RDI,0x70
LAB_00127171:
LEA RSI,[RSP + 0x4]
CALL 0x0012894c
TEST RAX,RAX
JZ 0x00127225
MOV RDI,qword ptr [R14 + 0x20]
ADD RDI,0x70
LAB_0012718c:
LEA RSI,[RSP + 0x4]
CALL 0x0012894c
TEST RAX,RAX
JZ 0x0012739e
MOV R13,qword ptr [RAX + 0x10]
MOV RBP,qword ptr [RAX + 0x18]
LAB_001271a7:
CMP R13,RBP
JZ 0x00127325
MOV ECX,dword ptr [RSP + 0x4]
MOV EAX,ECX
SHR EAX,0x6
MOV RDX,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RDX + RAX*0x8]
MOV EDI,0x1
SHL RDI,CL
BT RSI,RCX
JC 0x0012721f
OR RDI,RSI
MOV qword ptr [RDX + RAX*0x8],RDI
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX + 0x58]
MOV ESI,ECX
AND ESI,0xfffffff8
MOV EDX,dword ptr [RDX + RSI*0x1]
MOV ESI,ECX
AND ESI,0x7
BT EDX,ESI
MOVSS XMM0,dword ptr [0x0017f0b8]
JNC 0x00127215
IMUL RCX,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RSP + 0x10]
ADD RCX,qword ptr [RAX + 0x50]
MOV EDX,dword ptr [RAX + 0x14]
LAB_0012720b:
MOV RSI,RCX
CALL qword ptr [RAX + 0x8]
MOV ECX,dword ptr [RSP + 0x4]
LAB_00127215:
MOV RDI,R15
MOV ESI,ECX
CALL 0x00123cc8
LAB_0012721f:
ADD R13,0x4
JMP 0x001271a7
LAB_00127225:
MOV RAX,qword ptr [R14 + 0x10]
MOV EDX,dword ptr [RAX + 0x4]
TEST EDX,EDX
JZ 0x00127325
XOR EBP,EBP
LAB_00127236:
MOV ESI,dword ptr [RSP + 0x4]
MOV RDI,qword ptr [RAX + 0x30]
MOV RCX,qword ptr [RAX + 0x10]
IMUL RCX,RSI
ADD RCX,RDI
MOVSXD RCX,dword ptr [RCX + RBP*0x4]
CMP RCX,-0x1
JZ 0x00127325
MOV R8,RCX
SHR R8,0x6
MOV R9,qword ptr [RSP + 0x58]
MOV R10,qword ptr [R9 + R8*0x8]
MOV R11D,0x1
SHL R11,CL
BT R10,RCX
JC 0x00127316
OR R10,R11
MOV qword ptr [R9 + R8*0x8],R10
LEA R8,[RBP + 0x3]
MOV EDX,EDX
CMP R8,RDX
JNC 0x001272c9
IMUL RSI,qword ptr [RAX + 0x10]
ADD RDI,RSI
MOV EAX,dword ptr [RDI + RBP*0x4 + 0xc]
MOV EDX,0xffffffff
CMP RAX,RDX
JZ 0x001272c9
MOV RSI,qword ptr [R14]
MOV EDX,dword ptr [RSI + 0x10]
CMP RDX,0x40
JC 0x001272c9
IMUL RAX,qword ptr [RSI + 0x30]
ADD RAX,qword ptr [RSI + 0x50]
AND EDX,0xffffffc0
XOR ESI,ESI
LAB_001272bc:
NOP dword ptr [RAX + RSI*0x1]
ADD RSI,0x40
CMP RDX,RSI
JNZ 0x001272bc
LAB_001272c9:
MOV R13D,ECX
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX + 0x58]
MOV ESI,R13D
AND ESI,0xfffffff8
MOV EDX,dword ptr [RDX + RSI*0x1]
MOV ESI,R13D
AND ESI,0x7
BT EDX,ESI
MOVSS XMM0,dword ptr [0x0017f0b8]
JNC 0x00127307
MOV ESI,ECX
IMUL RSI,qword ptr [RAX + 0x30]
MOV RDI,qword ptr [RSP + 0x10]
ADD RSI,qword ptr [RAX + 0x50]
MOV EDX,dword ptr [RAX + 0x14]
LAB_00127304:
CALL qword ptr [RAX + 0x8]
LAB_00127307:
MOV RDI,R15
MOV ESI,R13D
CALL 0x00123cc8
MOV RAX,qword ptr [R14 + 0x10]
LAB_00127316:
INC RBP
MOV EDX,dword ptr [RAX + 0x4]
CMP RBP,RDX
JC 0x00127236
LAB_00127325:
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,qword ptr [RSP + 0x20]
JC 0x0012715d
LAB_00127335:
TEST R12D,R12D
JZ 0x0012735c
MOV RAX,qword ptr [RSP + 0x40]
MOV ECX,R12D
XOR EDX,EDX
MOV ESI,0x7fffffff
LAB_00127349:
MOV EDI,dword ptr [RAX]
AND EDI,ESI
MOV dword ptr [RBX + RDX*0x4],EDI
INC RDX
ADD RAX,0xc
CMP RCX,RDX
JNZ 0x00127349
LAB_0012735c:
MOV RDI,qword ptr [RSP + 0x58]
TEST RDI,RDI
JZ 0x00127373
MOV RSI,qword ptr [RSP + 0x68]
SUB RSI,RDI
CALL 0x00111120
LAB_00127373:
CMP qword ptr [RSP + 0x40],0x0
JZ 0x00127385
MOV RDI,qword ptr [RSP + 0x38]
CALL 0x001111e0
LAB_00127385:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001111e0
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012739e:
LEA RDI,[0x180c7b]
CALL 0x00111710
LAB_001273aa:
JMP 0x001273bb
LAB_001273bb:
MOV RBX,RAX
LEA RDI,[RSP + 0x18]
CALL 0x00123d94
LAB_001273c8:
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001111e0
MOV RDI,RBX
CALL 0x00111760
|
/* alaya::GraphSearchJob<alaya::RawSpace<float, float, unsigned int, alaya::SequentialStorage<float,
unsigned int> >, float, float, unsigned int>::search_solo_updated(float*, unsigned int, unsigned
int*, unsigned int) */
void __thiscall
alaya::
GraphSearchJob<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>
::search_solo_updated
(GraphSearchJob<alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>,float,float,unsigned_int>
*this,float *param_1,uint param_2,uint *param_3,uint param_4)
{
uint uVar1;
long lVar2;
ulong uVar3;
long lVar4;
uint *puVar5;
int8 uVar6;
ulong uVar7;
ulong uVar8;
ulong uVar9;
float fVar10;
uint local_a4;
long local_a0;
void *local_98;
LinearPool<float,unsigned_int> local_90 [8];
ulong local_88;
ulong local_80;
void *local_70;
uint *local_68;
void *local_50;
long local_40;
RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>::QueryComputer::
QueryComputer((QueryComputer *)&local_a0,*(RawSpace **)this,param_1);
/* try { // try from 00127128 to 00127134 has its CatchHandler @ 001273ac */
LinearPool<float,unsigned_int>::LinearPool(local_90,*(uint *)(*(long *)this + 0x18),param_4);
/* try { // try from 00127139 to 00127147 has its CatchHandler @ 001273aa */
Graph<float,unsigned_int,alaya::SequentialStorage<unsigned_int,unsigned_int>>::
initialize_search<alaya::LinearPool<float,unsigned_int>,alaya::RawSpace<float,float,unsigned_int,alaya::SequentialStorage<float,unsigned_int>>::QueryComputer>
(*(Graph<float,unsigned_int,alaya::SequentialStorage<unsigned_int,unsigned_int>> **)
(this + 0x10),(LinearPool *)local_90,(QueryComputer *)&local_a0);
if (local_80 < local_88) {
do {
/* try { // try from 0012715d to 00127164 has its CatchHandler @ 001273b5 */
local_a4 = LinearPool<float,unsigned_int>::pop(local_90);
/* try { // try from 00127171 to 0012717a has its CatchHandler @ 001273b7 */
lVar4 = std::
_Hashtable<unsigned_int,std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::allocator<std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>>,std::__detail::_Select1st,std::equal_to<unsigned_int>,std::hash<unsigned_int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<unsigned_int,std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::allocator<std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>>,std::__detail::_Select1st,std::equal_to<unsigned_int>,std::hash<unsigned_int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(*(long *)(this + 0x20) + 0x70),&local_a4);
if (lVar4 == 0) {
lVar4 = *(long *)(this + 0x10);
uVar8 = (ulong)*(uint *)(lVar4 + 4);
if (*(uint *)(lVar4 + 4) != 0) {
uVar9 = 0;
do {
lVar2 = *(long *)(lVar4 + 0x30);
uVar1 = *(uint *)(*(long *)(lVar4 + 0x10) * (ulong)local_a4 + lVar2 + uVar9 * 4);
uVar7 = (ulong)(int)uVar1;
if (uVar7 == 0xffffffffffffffff) break;
uVar3 = *(ulong *)((long)local_50 + (uVar7 >> 6) * 8);
if ((uVar3 >> (uVar7 & 0x3f) & 1) == 0) {
*(ulong *)((long)local_50 + (uVar7 >> 6) * 8) = uVar3 | 1L << ((byte)uVar1 & 0x3f);
if (((uVar9 + 3 < uVar8) &&
(*(int *)(lVar2 + (ulong)local_a4 * *(long *)(lVar4 + 0x10) + 0xc + uVar9 * 4) !=
-1)) && (0x3f < *(uint *)(*(long *)this + 0x10))) {
uVar8 = 0;
do {
uVar8 = uVar8 + 0x40;
} while ((*(uint *)(*(long *)this + 0x10) & 0xffffffc0) != uVar8);
}
fVar10 = DAT_0017f0b8;
if ((*(uint *)(*(long *)(local_a0 + 0x58) + (ulong)(uVar1 & 0xfffffff8)) >>
(uVar1 & 7) & 1) != 0) {
/* try { // try from 00127304 to 00127311 has its CatchHandler @ 001273b9 */
fVar10 = (float)(**(code **)(local_a0 + 8))
(local_98,(ulong)uVar1 * *(long *)(local_a0 + 0x30) +
*(long *)(local_a0 + 0x50),
*(int4 *)(local_a0 + 0x14));
}
LinearPool<float,unsigned_int>::insert(local_90,uVar1,fVar10);
lVar4 = *(long *)(this + 0x10);
}
uVar9 = uVar9 + 1;
uVar8 = (ulong)*(uint *)(lVar4 + 4);
} while (uVar9 < uVar8);
}
}
else {
/* try { // try from 0012718c to 00127195 has its CatchHandler @ 001273b3 */
lVar4 = std::
_Hashtable<unsigned_int,std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::allocator<std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>>,std::__detail::_Select1st,std::equal_to<unsigned_int>,std::hash<unsigned_int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
::find((_Hashtable<unsigned_int,std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>,std::allocator<std::pair<unsigned_int_const,std::vector<unsigned_int,std::allocator<unsigned_int>>>>,std::__detail::_Select1st,std::equal_to<unsigned_int>,std::hash<unsigned_int>,std::__detail::_Mod_range_hashing,std::__detail::_Default_ranged_hash,std::__detail::_Prime_rehash_policy,std::__detail::_Hashtable_traits<false,false,true>>
*)(*(long *)(this + 0x20) + 0x70),&local_a4);
if (lVar4 == 0) {
/* try { // try from 0012739e to 001273a9 has its CatchHandler @ 001273b1 */
uVar6 = std::__throw_out_of_range("_Map_base::at");
/* catch() { ... } // from try @ 00127139 with catch @ 001273aa */
/* catch() { ... } // from try @ 0012720b with catch @ 001273bb */
LinearPool<float,unsigned_int>::~LinearPool(local_90);
free(local_98);
/* WARNING: Subroutine does not return */
_Unwind_Resume(uVar6);
}
lVar2 = *(long *)(lVar4 + 0x18);
for (lVar4 = *(long *)(lVar4 + 0x10); lVar4 != lVar2; lVar4 = lVar4 + 4) {
uVar8 = *(ulong *)((long)local_50 + (ulong)(local_a4 >> 6) * 8);
if ((uVar8 >> ((ulong)local_a4 & 0x3f) & 1) == 0) {
*(ulong *)((long)local_50 + (ulong)(local_a4 >> 6) * 8) =
1L << ((byte)local_a4 & 0x3f) | uVar8;
fVar10 = DAT_0017f0b8;
if ((*(uint *)(*(long *)(local_a0 + 0x58) + (ulong)(local_a4 & 0xfffffff8)) >>
(local_a4 & 7) & 1) != 0) {
/* try { // try from 0012720b to 0012721e has its CatchHandler @ 001273bb */
fVar10 = (float)(**(code **)(local_a0 + 8))
(local_98,(ulong)local_a4 * *(long *)(local_a0 + 0x30) +
*(long *)(local_a0 + 0x50),
*(int4 *)(local_a0 + 0x14));
}
LinearPool<float,unsigned_int>::insert(local_90,local_a4,fVar10);
}
}
}
} while (local_80 < local_88);
}
if (param_2 != 0) {
uVar8 = 0;
puVar5 = local_68;
do {
param_3[uVar8] = *puVar5 & 0x7fffffff;
uVar8 = uVar8 + 1;
puVar5 = puVar5 + 3;
} while (param_2 != uVar8);
}
if (local_50 != (void *)0x0) {
operator_delete(local_50,local_40 - (long)local_50);
}
if (local_68 != (uint *)0x0) {
free(local_70);
}
free(local_98);
return;
}
|
|
7,752 |
my_caseup_utf8mb3
|
eloqsql/strings/ctype-utf8.c
|
static size_t my_caseup_utf8mb3(CHARSET_INFO *cs,
const char *src, size_t srclen,
char *dst, size_t dstlen)
{
my_wc_t wc;
int srcres, dstres;
const char *srcend= src + srclen;
char *dstend= dst + dstlen, *dst0= dst;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
DBUG_ASSERT(src != dst || cs->caseup_multiply == 1);
while ((src < srcend) &&
(srcres= my_utf8mb3_uni(cs, &wc, (uchar *) src, (uchar*) srcend)) > 0)
{
my_toupper_utf8mb3(uni_plane, &wc);
if ((dstres= my_uni_utf8mb3(cs, wc, (uchar*) dst, (uchar*) dstend)) <= 0)
break;
src+= srcres;
dst+= dstres;
}
return (size_t) (dst - dst0);
}
|
O0
|
c
|
my_caseup_utf8mb3:
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 0x79afa
jmp 0x79afc
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x40(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x79b2c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0x79790
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x79b35
jmp 0x79b88
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7a900
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x48(%rbp), %rcx
callq 0x797c0
movl %eax, -0x38(%rbp)
cmpl $0x0, %eax
jg 0x79b61
jmp 0x79b88
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 0x79afc
movq -0x20(%rbp), %rax
movq -0x50(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
my_caseup_utf8mb3:
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_79AFA:
jmp short $+2
loc_79AFC:
mov rcx, [rbp+var_10]
xor eax, eax
cmp rcx, [rbp+var_40]
mov [rbp+var_59], al
jnb short loc_79B2C
mov rdi, [rbp+var_8]
mov rdx, [rbp+var_10]
mov rcx, [rbp+var_40]
lea rsi, [rbp+var_30]
call my_utf8mb3_uni
mov [rbp+var_34], eax
cmp eax, 0
setnle al
mov [rbp+var_59], al
loc_79B2C:
mov al, [rbp+var_59]
test al, 1
jnz short loc_79B35
jmp short loc_79B88
loc_79B35:
mov rdi, [rbp+var_58]
lea rsi, [rbp+var_30]
call my_toupper_utf8mb3
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_48]
call my_uni_utf8mb3
mov [rbp+var_38], eax
cmp eax, 0
jg short loc_79B61
jmp short loc_79B88
loc_79B61:
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_79AFC
loc_79B88:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_50]
sub rax, rcx
add rsp, 60h
pop rbp
retn
|
_BYTE * my_caseup_utf8mb3(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_utf8mb3_uni(v18, (long long)v14, v17, v11, a5, a6);
v7 = v13 > 0;
}
if ( !v7 )
break;
my_toupper_utf8mb3(v8, v14);
v12 = my_uni_utf8mb3(v18, v14[0], v15, v10);
if ( v12 <= 0 )
break;
v17 += v13;
v15 += v12;
}
return (_BYTE *)(v15 - a4);
}
|
my_caseup_utf8mb3:
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 0x00179afa
LAB_00179afa:
JMP 0x00179afc
LAB_00179afc:
MOV RCX,qword ptr [RBP + -0x10]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x40]
MOV byte ptr [RBP + -0x59],AL
JNC 0x00179b2c
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x00179790
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
SETG AL
MOV byte ptr [RBP + -0x59],AL
LAB_00179b2c:
MOV AL,byte ptr [RBP + -0x59]
TEST AL,0x1
JNZ 0x00179b35
JMP 0x00179b88
LAB_00179b35:
MOV RDI,qword ptr [RBP + -0x58]
LEA RSI,[RBP + -0x30]
CALL 0x0017a900
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 0x001797c0
MOV dword ptr [RBP + -0x38],EAX
CMP EAX,0x0
JG 0x00179b61
JMP 0x00179b88
LAB_00179b61:
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 0x00179afc
LAB_00179b88:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x50]
SUB RAX,RCX
ADD RSP,0x60
POP RBP
RET
|
long my_caseup_utf8mb3(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_utf8mb3_uni(local_10,&local_38,local_18,param_2 + param_3);
bVar2 = 0 < local_3c;
}
if (!bVar2) break;
my_toupper_utf8mb3(uVar1,&local_38);
iVar3 = my_uni_utf8mb3(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;
}
|
|
7,753 |
find_type_with_warning
|
eloqsql/mysys/typelib.c
|
int find_type_with_warning(const char *x, TYPELIB *typelib, const char *option)
{
int res;
const char **ptr;
if ((res= find_type((char *) x, typelib, FIND_TYPE_BASIC)) <= 0)
{
ptr= typelib->type_names;
if (!*x)
fprintf(stderr, "No option given to %s\n", option);
else
fprintf(stderr, "Unknown option to %s: %s\n", option, x);
fprintf(stderr, "Alternatives are: '%s'", *ptr);
while (*++ptr)
fprintf(stderr, ",'%s'", *ptr);
fprintf(stderr, "\n");
}
return res;
}
|
O0
|
c
|
find_type_with_warning:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x30c60
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jg 0x30c50
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x30bc2
movq 0x1a842d(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x52ca0(%rip), %rsi # 0x83859
movb $0x0, %al
callq 0x254d0
jmp 0x30be2
movq 0x1a840f(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x52c95(%rip), %rsi # 0x83870
movb $0x0, %al
callq 0x254d0
movq 0x1a83ef(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x52c90(%rip), %rsi # 0x8388a
movb $0x0, %al
callq 0x254d0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x30c38
movq 0x1a83ba(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
leaq 0x52c72(%rip), %rsi # 0x838a1
movb $0x0, %al
callq 0x254d0
jmp 0x30c01
movq 0x1a8399(%rip), %rax # 0x1d8fd8
movq (%rax), %rdi
leaq 0x56790(%rip), %rsi # 0x873d9
movb $0x0, %al
callq 0x254d0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
|
find_type_with_warning:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
xor edx, edx
call find_type
mov [rbp+var_1C], eax
cmp eax, 0
jg loc_30C50
mov rax, [rbp+var_10]
mov rax, [rax+10h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
cmp byte ptr [rax], 0
jnz short loc_30BC2
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_18]
lea rsi, aNoOptionGivenT; "No option given to %s\n"
mov al, 0
call _fprintf
jmp short loc_30BE2
loc_30BC2:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_8]
lea rsi, aUnknownOptionT; "Unknown option to %s: %s\n"
mov al, 0
call _fprintf
loc_30BE2:
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, [rbp+var_28]
mov rdx, [rax]
lea rsi, aAlternativesAr; "Alternatives are: '%s'"
mov al, 0
call _fprintf
loc_30C01:
mov rax, [rbp+var_28]
mov rcx, rax
add rcx, 8
mov [rbp+var_28], rcx
cmp qword ptr [rax+8], 0
jz short loc_30C38
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rax, [rbp+var_28]
mov rdx, [rax]
lea rsi, aS_0; ",'%s'"
mov al, 0
call _fprintf
jmp short loc_30C01
loc_30C38:
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, asc_873D6+3; "\n"
mov al, 0
call _fprintf
loc_30C50:
mov eax, [rbp+var_1C]
add rsp, 30h
pop rbp
retn
|
long long find_type_with_warning(const char *a1, long long a2, const char *a3)
{
const char **v3; // rax
const char **v5; // [rsp+8h] [rbp-28h]
int type; // [rsp+14h] [rbp-1Ch]
type = find_type(a1, a2, 0LL);
if ( type <= 0 )
{
v5 = *(const char ***)(a2 + 16);
if ( *a1 )
fprintf(stderr, "Unknown option to %s: %s\n", a3, a1);
else
fprintf(stderr, "No option given to %s\n", a3);
fprintf(stderr, "Alternatives are: '%s'", *v5);
while ( 1 )
{
v3 = v5++;
if ( !v3[1] )
break;
fprintf(stderr, ",'%s'", *v5);
}
fprintf(stderr, "\n");
}
return (unsigned int)type;
}
|
find_type_with_warning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
XOR EDX,EDX
CALL 0x00130c60
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JG 0x00130c50
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX],0x0
JNZ 0x00130bc2
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
LEA RSI,[0x183859]
MOV AL,0x0
CALL 0x001254d0
JMP 0x00130be2
LAB_00130bc2:
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x8]
LEA RSI,[0x183870]
MOV AL,0x0
CALL 0x001254d0
LAB_00130be2:
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x18388a]
MOV AL,0x0
CALL 0x001254d0
LAB_00130c01:
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,RAX
ADD RCX,0x8
MOV qword ptr [RBP + -0x28],RCX
CMP qword ptr [RAX + 0x8],0x0
JZ 0x00130c38
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x1838a1]
MOV AL,0x0
CALL 0x001254d0
JMP 0x00130c01
LAB_00130c38:
MOV RAX,qword ptr [0x002d8fd8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x1873d9]
MOV AL,0x0
CALL 0x001254d0
LAB_00130c50:
MOV EAX,dword ptr [RBP + -0x1c]
ADD RSP,0x30
POP RBP
RET
|
int find_type_with_warning(char *param_1,long param_2,int8 param_3)
{
int iVar1;
int8 *local_30;
iVar1 = find_type(param_1,param_2,0);
if (iVar1 < 1) {
local_30 = *(int8 **)(param_2 + 0x10);
if (*param_1 == '\0') {
fprintf(*(FILE **)PTR_stderr_002d8fd8,"No option given to %s\n",param_3);
}
else {
fprintf(*(FILE **)PTR_stderr_002d8fd8,"Unknown option to %s: %s\n",param_3,param_1);
}
fprintf(*(FILE **)PTR_stderr_002d8fd8,"Alternatives are: \'%s\'",*local_30);
while( true ) {
if (local_30[1] == 0) break;
fprintf(*(FILE **)PTR_stderr_002d8fd8,",\'%s\'",local_30[1]);
local_30 = local_30 + 1;
}
fprintf(*(FILE **)PTR_stderr_002d8fd8,"\n");
}
return iVar1;
}
|
|
7,754 |
glfwGetMonitorWorkarea
|
untodesu[P]riteg/build_O3/_deps/glfw-src/src/monitor.c
|
GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* handle,
int* xpos, int* ypos,
int* width, int* height)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xpos)
*xpos = 0;
if (ypos)
*ypos = 0;
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetMonitorWorkarea(monitor, xpos, ypos, width, height);
}
|
O3
|
c
|
glfwGetMonitorWorkarea:
testq %rdi, %rdi
je 0x1bf69
testq %rsi, %rsi
je 0x1bf28
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x1bf33
movl $0x0, (%rdx)
testq %rcx, %rcx
je 0x1bf3e
movl $0x0, (%rcx)
testq %r8, %r8
je 0x1bf4a
movl $0x0, (%r8)
leaq 0x8c6e7(%rip), %rax # 0xa8638
cmpl $0x0, (%rax)
je 0x1bf5b
jmp 0x21057
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x18e91
pushq %rax
leaq 0x6761f(%rip), %rdi # 0x83590
leaq 0x67594(%rip), %rsi # 0x8350c
leaq 0x67655(%rip), %rcx # 0x835d4
movl $0x152, %edx # imm = 0x152
callq 0xc540
|
glfwGetMonitorWorkarea:
test rdi, rdi
jz short loc_1BF69
test rsi, rsi
jz short loc_1BF28
mov dword ptr [rsi], 0
loc_1BF28:
test rdx, rdx
jz short loc_1BF33
mov dword ptr [rdx], 0
loc_1BF33:
test rcx, rcx
jz short loc_1BF3E
mov dword ptr [rcx], 0
loc_1BF3E:
test r8, r8
jz short loc_1BF4A
mov dword ptr [r8], 0
loc_1BF4A:
lea rax, _glfw
cmp dword ptr [rax], 0
jz short loc_1BF5B
jmp _glfwPlatformGetMonitorWorkarea
loc_1BF5B:
mov edi, offset loc_10001
xor esi, esi
xor eax, eax
jmp _glfwInputError
loc_1BF69:
push rax
lea rdi, aMonitorNull; "monitor != NULL"
lea rsi, aWorkspaceLlm4b_13; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aVoidGlfwgetmon_0; "void glfwGetMonitorWorkarea(GLFWmonitor"...
mov edx, 152h
call ___assert_fail
|
long long ( * glfwGetMonitorWorkarea(
long long a1,
_DWORD *a2,
_DWORD *a3,
_DWORD *a4,
_DWORD *a5))(_QWORD, _QWORD)
{
if ( !a1 )
__assert_fail(
"monitor != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/monitor.c",
338LL,
"void glfwGetMonitorWorkarea(GLFWmonitor *, int *, int *, int *, int *)");
if ( a2 )
*a2 = 0;
if ( a3 )
*a3 = 0;
if ( a4 )
*a4 = 0;
if ( a5 )
*a5 = 0;
if ( glfw[0] )
return (long long ( *)(_QWORD, _QWORD))glfwPlatformGetMonitorWorkarea();
else
return glfwInputError((unsigned int)&loc_10001, 0LL);
}
|
glfwGetMonitorWorkarea:
TEST RDI,RDI
JZ 0x0011bf69
TEST RSI,RSI
JZ 0x0011bf28
MOV dword ptr [RSI],0x0
LAB_0011bf28:
TEST RDX,RDX
JZ 0x0011bf33
MOV dword ptr [RDX],0x0
LAB_0011bf33:
TEST RCX,RCX
JZ 0x0011bf3e
MOV dword ptr [RCX],0x0
LAB_0011bf3e:
TEST R8,R8
JZ 0x0011bf4a
MOV dword ptr [R8],0x0
LAB_0011bf4a:
LEA RAX,[0x1a8638]
CMP dword ptr [RAX],0x0
JZ 0x0011bf5b
JMP 0x00121057
LAB_0011bf5b:
MOV EDI,0x10001
XOR ESI,ESI
XOR EAX,EAX
JMP 0x00118e91
LAB_0011bf69:
PUSH RAX
LEA RDI,[0x183590]
LEA RSI,[0x18350c]
LEA RCX,[0x1835d4]
MOV EDX,0x152
CALL 0x0010c540
|
void glfwGetMonitorWorkarea
(long param_1,int4 *param_2,int4 *param_3,int4 *param_4,
int4 *param_5)
{
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("monitor != NULL",
"/workspace/llm4binary/github/2025_star3/untodesu[P]riteg/build_O3/_deps/glfw-src/src/monitor.c"
,0x152,"void glfwGetMonitorWorkarea(GLFWmonitor *, int *, int *, int *, int *)");
}
if (param_2 != (int4 *)0x0) {
*param_2 = 0;
}
if (param_3 != (int4 *)0x0) {
*param_3 = 0;
}
if (param_4 != (int4 *)0x0) {
*param_4 = 0;
}
if (param_5 != (int4 *)0x0) {
*param_5 = 0;
}
if (_glfw != 0) {
_glfwPlatformGetMonitorWorkarea();
return;
}
_glfwInputError(0x10001,0);
return;
}
|
|
7,755 |
wqueue_add_to_queue
|
eloqsql/mysys/wqueue.c
|
void wqueue_add_to_queue(WQUEUE *wqueue, struct st_my_thread_var *thread)
{
struct st_my_thread_var *last;
if (!(last= wqueue->last_thread))
thread->next= thread;
else
{
thread->next= last->next;
last->next= thread;
}
#ifndef DBUG_OFF
thread->prev= NULL; /* force segfault if used */
#endif
wqueue->last_thread= thread;
}
|
O3
|
c
|
wqueue_add_to_queue:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
testq %rax, %rax
je 0xa6861
movq 0x88(%rax), %rcx
addq $0x88, %rax
movq %rcx, 0x88(%rsi)
jmp 0xa6868
leaq 0x88(%rsi), %rax
movq %rsi, (%rax)
movq %rsi, (%rdi)
popq %rbp
retq
|
wqueue_add_to_queue:
push rbp
mov rbp, rsp
mov rax, [rdi]
test rax, rax
jz short loc_A6861
mov rcx, [rax+88h]
add rax, 88h
mov [rsi+88h], rcx
jmp short loc_A6868
loc_A6861:
lea rax, [rsi+88h]
loc_A6868:
mov [rax], rsi
mov [rdi], rsi
pop rbp
retn
|
_QWORD * wqueue_add_to_queue(long long *a1, long long a2)
{
long long v2; // rax
long long v3; // rcx
_QWORD *result; // rax
v2 = *a1;
if ( *a1 )
{
v3 = *(_QWORD *)(v2 + 136);
result = (_QWORD *)(v2 + 136);
*(_QWORD *)(a2 + 136) = v3;
}
else
{
result = (_QWORD *)(a2 + 136);
}
*result = a2;
*a1 = a2;
return result;
}
|
wqueue_add_to_queue:
PUSH RBP
MOV RBP,RSP
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001a6861
MOV RCX,qword ptr [RAX + 0x88]
ADD RAX,0x88
MOV qword ptr [RSI + 0x88],RCX
JMP 0x001a6868
LAB_001a6861:
LEA RAX,[RSI + 0x88]
LAB_001a6868:
MOV qword ptr [RAX],RSI
MOV qword ptr [RDI],RSI
POP RBP
RET
|
void wqueue_add_to_queue(long *param_1,long param_2)
{
long lVar1;
long *plVar2;
lVar1 = *param_1;
if (lVar1 == 0) {
plVar2 = (long *)(param_2 + 0x88);
}
else {
plVar2 = (long *)(lVar1 + 0x88);
*(int8 *)(param_2 + 0x88) = *(int8 *)(lVar1 + 0x88);
}
*plVar2 = param_2;
*param_1 = param_2;
return;
}
|
|
7,756 |
ggml_backend_tensor_get_async
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp
|
void ggml_backend_tensor_get_async(ggml_backend_t backend, const struct ggml_tensor * tensor, void * data, size_t offset, size_t size) {
GGML_ASSERT(tensor->data != NULL && "tensor not allocated");
GGML_ASSERT(offset + size <= ggml_nbytes(tensor) && "tensor read out of bounds");
if (backend->iface.get_tensor_async == NULL) {
ggml_backend_tensor_get(tensor, data, offset, size);
} else {
backend->iface.get_tensor_async(backend, tensor, data, offset, size);
}
}
|
O0
|
cpp
|
ggml_backend_tensor_get_async:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x5e31b
leaq 0x56916(%rip), %rdi # 0xb4c17
movl $0xf4, %esi
leaq 0x532fc(%rip), %rdx # 0xb1609
leaq 0x569ee(%rip), %rcx # 0xb4d02
movb $0x0, %al
callq 0x48a00
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42650
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jbe 0x5e35d
leaq 0x568d4(%rip), %rdi # 0xb4c17
movl $0xf5, %esi
leaq 0x532ba(%rip), %rdx # 0xb1609
leaq 0x56a20(%rip), %rcx # 0xb4d76
movb $0x0, %al
callq 0x48a00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x5e37f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x46620
jmp 0x5e39d
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq *%rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ggml_backend_tensor_get_async:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
mov [rbp+var_20], rcx
mov [rbp+var_28], r8
mov rax, [rbp+var_10]
cmp qword ptr [rax+0F8h], 0
jnz short loc_5E31B
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0F4h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorDataNull; "tensor->data != NULL && \"tensor not al"...
mov al, 0
call _ggml_abort
loc_5E31B:
mov rax, [rbp+var_20]
add rax, [rbp+var_28]
mov [rbp+var_30], rax
mov rdi, [rbp+var_10]
call _ggml_nbytes
mov rcx, rax
mov rax, [rbp+var_30]
cmp rax, rcx
jbe short loc_5E35D
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
mov esi, 0F5h
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aOffsetSizeGgml_0; "offset + size <= ggml_nbytes(tensor) &&"...
mov al, 0
call _ggml_abort
loc_5E35D:
mov rax, [rbp+var_8]
cmp qword ptr [rax+20h], 0
jnz short loc_5E37F
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
call _ggml_backend_tensor_get
jmp short loc_5E39D
loc_5E37F:
mov rax, [rbp+var_8]
mov rax, [rax+20h]
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_20]
mov r8, [rbp+var_28]
call rax
loc_5E39D:
add rsp, 30h
pop rbp
retn
|
long long ggml_backend_tensor_get_async(long long a1, long long a2, long long a3, long long a4, long long a5)
{
if ( !*(_QWORD *)(a2 + 248) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
244,
(long long)"GGML_ASSERT(%s) failed",
"tensor->data != NULL && \"tensor not allocated\"");
if ( a5 + a4 > (unsigned long long)ggml_nbytes((unsigned int *)a2) )
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
245,
(long long)"GGML_ASSERT(%s) failed",
"offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"");
if ( *(_QWORD *)(a1 + 32) )
return (*(long long ( **)(long long, long long, long long, long long, long long))(a1 + 32))(a1, a2, a3, a4, a5);
else
return ggml_backend_tensor_get(a2, a3, a4, a5);
}
|
ggml_backend_tensor_get_async:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0xf8],0x0
JNZ 0x0015e31b
LEA RDI,[0x1b4c17]
MOV ESI,0xf4
LEA RDX,[0x1b1609]
LEA RCX,[0x1b4d02]
MOV AL,0x0
CALL 0x00148a00
LAB_0015e31b:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00142650
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x30]
CMP RAX,RCX
JBE 0x0015e35d
LEA RDI,[0x1b4c17]
MOV ESI,0xf5
LEA RDX,[0x1b1609]
LEA RCX,[0x1b4d76]
MOV AL,0x0
CALL 0x00148a00
LAB_0015e35d:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x20],0x0
JNZ 0x0015e37f
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x00146620
JMP 0x0015e39d
LAB_0015e37f:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x20]
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x20]
MOV R8,qword ptr [RBP + -0x28]
CALL RAX
LAB_0015e39d:
ADD RSP,0x30
POP RBP
RET
|
void ggml_backend_tensor_get_async
(long param_1,long param_2,int8 param_3,long param_4,long param_5)
{
ulong uVar1;
if (*(long *)(param_2 + 0xf8) == 0) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0xf4,"GGML_ASSERT(%s) failed","tensor->data != NULL && \"tensor not allocated\"");
}
uVar1 = ggml_nbytes(param_2);
if (uVar1 < (ulong)(param_4 + param_5)) {
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,0xf5,"GGML_ASSERT(%s) failed",
"offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"");
}
if (*(long *)(param_1 + 0x20) == 0) {
ggml_backend_tensor_get(param_2,param_3,param_4,param_5);
}
else {
(**(code **)(param_1 + 0x20))(param_1,param_2,param_3,param_4,param_5);
}
return;
}
|
|
7,757 |
ggml_backend_tensor_get_async
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp
|
void ggml_backend_tensor_get_async(ggml_backend_t backend, const struct ggml_tensor * tensor, void * data, size_t offset, size_t size) {
GGML_ASSERT(tensor->data != NULL && "tensor not allocated");
GGML_ASSERT(offset + size <= ggml_nbytes(tensor) && "tensor read out of bounds");
if (backend->iface.get_tensor_async == NULL) {
ggml_backend_tensor_get(tensor, data, offset, size);
} else {
backend->iface.get_tensor_async(backend, tensor, data, offset, size);
}
}
|
O2
|
cpp
|
ggml_backend_tensor_get_async:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0xf8(%rsi)
je 0x2b799
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq (%r8,%rcx), %rbp
movq %rsi, %rdi
callq 0x1d300
cmpq %rax, %rbp
ja 0x2b7b5
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x2b77a
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1eb30
leaq 0x25fe4(%rip), %rdi # 0x51784
leaq 0x22e2e(%rip), %rdx # 0x4e5d5
leaq 0x260c1(%rip), %rcx # 0x5186f
movl $0xf4, %esi
jmp 0x2b7cf
leaq 0x25fc8(%rip), %rdi # 0x51784
leaq 0x22e12(%rip), %rdx # 0x4e5d5
leaq 0x26119(%rip), %rcx # 0x518e3
movl $0xf5, %esi
xorl %eax, %eax
callq 0x1f9b0
|
ggml_backend_tensor_get_async:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp qword ptr [rsi+0F8h], 0
jz short loc_2B799
mov rbx, r8
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov r13, rdi
lea rbp, [r8+rcx]
mov rdi, rsi
call _ggml_nbytes
cmp rbp, rax
ja short loc_2B7B5
mov rax, [r13+20h]
test rax, rax
jz short loc_2B77A
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_2B77A:
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_backend_tensor_get
loc_2B799:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorDataNull; "tensor->data != NULL && \"tensor not al"...
mov esi, 0F4h
jmp short loc_2B7CF
loc_2B7B5:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aOffsetSizeGgml_0; "offset + size <= ggml_nbytes(tensor) &&"...
mov esi, 0F5h
loc_2B7CF:
xor eax, eax
call _ggml_abort
|
long long ggml_backend_tensor_get_async(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v14; // al
long long ( *v18)(long long, long long, long long, long long, long long); // rax
const char *v20; // rcx
int v21; // esi
char v22; // [rsp-8h] [rbp-38h]
v22 = v14;
if ( !*(_QWORD *)(a2 + 248) )
{
v20 = "tensor->data != NULL && \"tensor not allocated\"";
v21 = 244;
goto LABEL_8;
}
if ( a5 + a4 > ggml_nbytes((unsigned int *)a2) )
{
v20 = "offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"";
v21 = 245;
LABEL_8:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
v21,
(long long)"GGML_ASSERT(%s) failed",
(long long)v20,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v22);
}
v18 = *(long long ( **)(long long, long long, long long, long long, long long))(a1 + 32);
if ( v18 )
return v18(a1, a2, a3, a4, a5);
else
return ggml_backend_tensor_get(a2, a3, a4, a5);
}
|
ggml_backend_tensor_get_async:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP qword ptr [RSI + 0xf8],0x0
JZ 0x0012b799
MOV RBX,R8
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
LEA RBP,[R8 + RCX*0x1]
MOV RDI,RSI
CALL 0x0011d300
CMP RBP,RAX
JA 0x0012b7b5
MOV RAX,qword ptr [R13 + 0x20]
TEST RAX,RAX
JZ 0x0012b77a
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_0012b77a:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x0011eb30
LAB_0012b799:
LEA RDI,[0x151784]
LEA RDX,[0x14e5d5]
LEA RCX,[0x15186f]
MOV ESI,0xf4
JMP 0x0012b7cf
LAB_0012b7b5:
LEA RDI,[0x151784]
LEA RDX,[0x14e5d5]
LEA RCX,[0x1518e3]
MOV ESI,0xf5
LAB_0012b7cf:
XOR EAX,EAX
CALL 0x0011f9b0
|
void ggml_backend_tensor_get_async
(long param_1,long param_2,int8 param_3,long param_4,long param_5)
{
ulong uVar1;
char *pcVar2;
int8 uVar3;
if (*(long *)(param_2 + 0xf8) == 0) {
pcVar2 = "tensor->data != NULL && \"tensor not allocated\"";
uVar3 = 0xf4;
}
else {
uVar1 = ggml_nbytes(param_2);
if ((ulong)(param_5 + param_4) <= uVar1) {
if (*(code **)(param_1 + 0x20) != (code *)0x0) {
/* WARNING: Could not recover jumptable at 0x0012b778. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x20))(param_1,param_2,param_3,param_4,param_5);
return;
}
ggml_backend_tensor_get(param_2,param_3,param_4,param_5);
return;
}
pcVar2 = "offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"";
uVar3 = 0xf5;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
7,758 |
ggml_backend_tensor_get_async
|
Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp
|
void ggml_backend_tensor_get_async(ggml_backend_t backend, const struct ggml_tensor * tensor, void * data, size_t offset, size_t size) {
GGML_ASSERT(tensor->data != NULL && "tensor not allocated");
GGML_ASSERT(offset + size <= ggml_nbytes(tensor) && "tensor read out of bounds");
if (backend->iface.get_tensor_async == NULL) {
ggml_backend_tensor_get(tensor, data, offset, size);
} else {
backend->iface.get_tensor_async(backend, tensor, data, offset, size);
}
}
|
O3
|
cpp
|
ggml_backend_tensor_get_async:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0xf8(%rsi)
je 0x25bd6
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq (%r8,%rcx), %rbp
movq %rsi, %rdi
callq 0x161c0
cmpq %rax, %rbp
ja 0x25bf2
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x25bb7
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17310
leaq 0x29c37(%rip), %rdi # 0x4f814
leaq 0x26a81(%rip), %rdx # 0x4c665
leaq 0x29d14(%rip), %rcx # 0x4f8ff
movl $0xf4, %esi
jmp 0x25c0c
leaq 0x29c1b(%rip), %rdi # 0x4f814
leaq 0x26a65(%rip), %rdx # 0x4c665
leaq 0x29d6c(%rip), %rcx # 0x4f973
movl $0xf5, %esi
xorl %eax, %eax
callq 0x17cd0
|
ggml_backend_tensor_get_async:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp qword ptr [rsi+0F8h], 0
jz short loc_25BD6
mov rbx, r8
mov r14, rcx
mov r15, rdx
mov r12, rsi
mov r13, rdi
lea rbp, [r8+rcx]
mov rdi, rsi
call _ggml_nbytes
cmp rbp, rax
ja short loc_25BF2
mov rax, [r13+20h]
test rax, rax
jz short loc_25BB7
mov rdi, r13
mov rsi, r12
mov rdx, r15
mov rcx, r14
mov r8, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp rax
loc_25BB7:
mov rdi, r12
mov rsi, r15
mov rdx, r14
mov rcx, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp _ggml_backend_tensor_get
loc_25BD6:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aTensorDataNull; "tensor->data != NULL && \"tensor not al"...
mov esi, 0F4h
jmp short loc_25C0C
loc_25BF2:
lea rdi, aWorkspaceLlm4b_2; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aOffsetSizeGgml_0; "offset + size <= ggml_nbytes(tensor) &&"...
mov esi, 0F5h
loc_25C0C:
xor eax, eax
call _ggml_abort
|
long long ggml_backend_tensor_get_async(long long a1, long long a2, long long a3, long long a4, long long a5, int a6)
{
long long ( *v9)(long long, long long, long long, long long, long long); // rax
const char *v11; // rcx
int v12; // esi
if ( !*(_QWORD *)(a2 + 248) )
{
v11 = "tensor->data != NULL && \"tensor not allocated\"";
v12 = 244;
goto LABEL_8;
}
if ( a5 + a4 > ggml_nbytes((unsigned int *)a2) )
{
v11 = "offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"";
v12 = 245;
LABEL_8:
ggml_abort(
(unsigned int)"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp",
v12,
(unsigned int)"GGML_ASSERT(%s) failed",
(_DWORD)v11,
a5,
a6);
}
v9 = *(long long ( **)(long long, long long, long long, long long, long long))(a1 + 32);
if ( v9 )
return v9(a1, a2, a3, a4, a5);
else
return ggml_backend_tensor_get(a2, a3, a4, a5);
}
|
ggml_backend_tensor_get_async:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
CMP qword ptr [RSI + 0xf8],0x0
JZ 0x00125bd6
MOV RBX,R8
MOV R14,RCX
MOV R15,RDX
MOV R12,RSI
MOV R13,RDI
LEA RBP,[R8 + RCX*0x1]
MOV RDI,RSI
CALL 0x001161c0
CMP RBP,RAX
JA 0x00125bf2
MOV RAX,qword ptr [R13 + 0x20]
TEST RAX,RAX
JZ 0x00125bb7
MOV RDI,R13
MOV RSI,R12
MOV RDX,R15
MOV RCX,R14
MOV R8,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP RAX
LAB_00125bb7:
MOV RDI,R12
MOV RSI,R15
MOV RDX,R14
MOV RCX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00117310
LAB_00125bd6:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14f8ff]
MOV ESI,0xf4
JMP 0x00125c0c
LAB_00125bf2:
LEA RDI,[0x14f814]
LEA RDX,[0x14c665]
LEA RCX,[0x14f973]
MOV ESI,0xf5
LAB_00125c0c:
XOR EAX,EAX
CALL 0x00117cd0
|
void ggml_backend_tensor_get_async
(long param_1,long param_2,int8 param_3,long param_4,long param_5)
{
ulong uVar1;
char *pcVar2;
int8 uVar3;
if (*(long *)(param_2 + 0xf8) == 0) {
pcVar2 = "tensor->data != NULL && \"tensor not allocated\"";
uVar3 = 0xf4;
}
else {
uVar1 = ggml_nbytes(param_2);
if ((ulong)(param_5 + param_4) <= uVar1) {
if (*(code **)(param_1 + 0x20) != (code *)0x0) {
/* WARNING: Could not recover jumptable at 0x00125bb5. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)(param_1 + 0x20))(param_1,param_2,param_3,param_4,param_5);
return;
}
ggml_backend_tensor_get(param_2,param_3,param_4,param_5);
return;
}
pcVar2 = "offset + size <= ggml_nbytes(tensor) && \"tensor read out of bounds\"";
uVar3 = 0xf5;
}
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-backend.cpp"
,uVar3,"GGML_ASSERT(%s) failed",pcVar2);
}
|
|
7,759 |
my_longlong10_to_str_8bit
|
eloqsql/strings/ctype-simple.c
|
size_t my_longlong10_to_str_8bit(CHARSET_INFO *cs __attribute__((unused)),
char *dst, size_t len, int radix,
longlong val)
{
char buffer[65];
register char *p, *e;
long long_val;
uint sign= 0;
ulonglong uval = (ulonglong)val;
if (radix < 0)
{
if (val < 0)
{
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (ulonglong)0 - uval;
*dst++= '-';
len--;
sign= 1;
}
}
e = p = &buffer[sizeof(buffer)-1];
*p= 0;
if (uval == 0)
{
*--p= '0';
len= 1;
goto cnv;
}
while (uval > (ulonglong) LONG_MAX)
{
ulonglong quo= uval/(uint) 10;
uint rem= (uint) (uval- quo* (uint) 10);
*--p = '0' + rem;
uval= quo;
}
long_val= (long) uval;
while (long_val != 0)
{
long quo= long_val/10;
*--p = (char) ('0' + (long_val - quo*10));
long_val= quo;
}
len= MY_MIN(len, (size_t) (e-p));
cnv:
memcpy(dst, p, len);
return len+sign;
}
|
O0
|
c
|
my_longlong10_to_str_8bit:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movl %ecx, -0x6c(%rbp)
movq %r8, -0x78(%rbp)
movl $0x0, -0x94(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpl $0x0, -0x6c(%rbp)
jge 0x54bb7
cmpq $0x0, -0x78(%rbp)
jge 0x54bb5
xorl %eax, %eax
subq -0xa0(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x60(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x60(%rbp)
movb $0x2d, (%rax)
movq -0x68(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x68(%rbp)
movl $0x1, -0x94(%rbp)
jmp 0x54bb7
leaq -0x50(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rax
movb $0x0, (%rax)
cmpq $0x0, -0xa0(%rbp)
jne 0x54bfb
movq -0x80(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x80(%rbp)
movb $0x30, -0x1(%rax)
movq $0x1, -0x68(%rbp)
jmp 0x54d1b
jmp 0x54bfd
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0xa0(%rbp)
jbe 0x54c6d
movq -0xa0(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0xa8(%rbp)
movq -0xa0(%rbp), %rax
imulq $0xa, -0xa8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
addl $0x30, %eax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0xa8(%rbp), %rax
movq %rax, -0xa0(%rbp)
jmp 0x54bfd
movq -0xa0(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
je 0x54cd7
movq -0x90(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0xb8(%rbp)
movq -0x90(%rbp), %rax
imulq $0xa, -0xb8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rax
movb %al, %cl
movq -0x80(%rbp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x80(%rbp)
movb %cl, -0x1(%rax)
movq -0xb8(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x54c7b
movq -0x68(%rbp), %rax
movq -0x88(%rbp), %rcx
movq -0x80(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jae 0x54cfb
movq -0x68(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x54d10
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0xc0(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x25230
movq -0x68(%rbp), %rax
movl -0x94(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xc8(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x54d62
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
callq 0x25340
nopw (%rax,%rax)
|
my_longlong10_to_str_8bit:
push rbp
mov rbp, rsp
sub rsp, 0D0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_58], rdi
mov [rbp+var_60], rsi
mov [rbp+var_68], rdx
mov [rbp+var_6C], ecx
mov [rbp+var_78], r8
mov [rbp+var_94], 0
mov rax, [rbp+var_78]
mov [rbp+var_A0], rax
cmp [rbp+var_6C], 0
jge short loc_54BB7
cmp [rbp+var_78], 0
jge short loc_54BB5
xor eax, eax
sub rax, [rbp+var_A0]
mov [rbp+var_A0], rax
mov rax, [rbp+var_60]
mov rcx, rax
add rcx, 1
mov [rbp+var_60], rcx
mov byte ptr [rax], 2Dh ; '-'
mov rax, [rbp+var_68]
add rax, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_68], rax
mov [rbp+var_94], 1
loc_54BB5:
jmp short $+2
loc_54BB7:
lea rax, [rbp+var_50]
add rax, 40h ; '@'
mov [rbp+var_80], rax
mov [rbp+var_88], rax
mov rax, [rbp+var_80]
mov byte ptr [rax], 0
cmp [rbp+var_A0], 0
jnz short loc_54BFB
mov rax, [rbp+var_80]
mov rcx, rax
add rcx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rcx
mov byte ptr [rax-1], 30h ; '0'
mov [rbp+var_68], 1
jmp loc_54D1B
loc_54BFB:
jmp short $+2
loc_54BFD:
mov rax, 7FFFFFFFFFFFFFFFh
cmp [rbp+var_A0], rax
jbe short loc_54C6D
mov rax, [rbp+var_A0]
mov ecx, 0Ah
xor edx, edx
div rcx
mov [rbp+var_A8], rax
mov rax, [rbp+var_A0]
imul rcx, [rbp+var_A8], 0Ah
sub rax, rcx
mov [rbp+var_AC], eax
mov eax, [rbp+var_AC]
add eax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_A8]
mov [rbp+var_A0], rax
jmp short loc_54BFD
loc_54C6D:
mov rax, [rbp+var_A0]
mov [rbp+var_90], rax
loc_54C7B:
cmp [rbp+var_90], 0
jz short loc_54CD7
mov rax, [rbp+var_90]
mov ecx, 0Ah
cqo
idiv rcx
mov [rbp+var_B8], rax
mov rax, [rbp+var_90]
imul rcx, [rbp+var_B8], 0Ah
sub rax, rcx
add rax, 30h ; '0'
mov cl, al
mov rax, [rbp+var_80]
mov rdx, rax
add rdx, 0FFFFFFFFFFFFFFFFh
mov [rbp+var_80], rdx
mov [rax-1], cl
mov rax, [rbp+var_B8]
mov [rbp+var_90], rax
jmp short loc_54C7B
loc_54CD7:
mov rax, [rbp+var_68]
mov rcx, [rbp+var_88]
mov rdx, [rbp+var_80]
sub rcx, rdx
cmp rax, rcx
jnb short loc_54CFB
mov rax, [rbp+var_68]
mov [rbp+var_C0], rax
jmp short loc_54D10
loc_54CFB:
mov rax, [rbp+var_88]
mov rcx, [rbp+var_80]
sub rax, rcx
mov [rbp+var_C0], rax
loc_54D10:
mov rax, [rbp+var_C0]
mov [rbp+var_68], rax
loc_54D1B:
mov rdi, [rbp+var_60]
mov rsi, [rbp+var_80]
mov rdx, [rbp+var_68]
call _memcpy
mov rax, [rbp+var_68]
mov ecx, [rbp+var_94]
add rax, rcx
mov [rbp+var_C8], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_54D62
mov rax, [rbp+var_C8]
add rsp, 0D0h
pop rbp
retn
loc_54D62:
call ___stack_chk_fail
|
long long my_longlong10_to_str_8bit(long long a1, _BYTE *a2, _BYTE *a3, int a4, long long a5)
{
char *v5; // rax
char *v6; // rax
_BYTE *v8; // [rsp+10h] [rbp-C0h]
unsigned long long v9; // [rsp+30h] [rbp-A0h]
unsigned int v10; // [rsp+3Ch] [rbp-94h]
signed long long i; // [rsp+40h] [rbp-90h]
char *v12; // [rsp+50h] [rbp-80h]
_BYTE *v13; // [rsp+68h] [rbp-68h]
long long v14; // [rsp+68h] [rbp-68h]
_BYTE *v15; // [rsp+70h] [rbp-60h]
char v16; // [rsp+BFh] [rbp-11h] BYREF
_BYTE v17[8]; // [rsp+C0h] [rbp-10h] BYREF
unsigned long long v18; // [rsp+C8h] [rbp-8h]
v18 = __readfsqword(0x28u);
v15 = a2;
v13 = a3;
v10 = 0;
v9 = a5;
if ( a4 < 0 && a5 < 0 )
{
v9 = -a5;
v15 = a2 + 1;
*a2 = 45;
v13 = a3 - 1;
v10 = 1;
}
v12 = v17;
v17[0] = 0;
if ( v9 )
{
while ( v9 > 0x7FFFFFFFFFFFFFFFLL )
{
v5 = v12--;
*(v5 - 1) = v9 % 0xA + 48;
v9 /= 0xAuLL;
}
for ( i = v9; i; i /= 10LL )
{
v6 = v12--;
*(v6 - 1) = i % 10 + 48;
}
if ( (unsigned long long)v13 >= v17 - v12 )
v8 = (_BYTE *)(v17 - v12);
else
v8 = v13;
v14 = (long long)v8;
}
else
{
v12 = &v16;
v16 = 48;
v14 = 1LL;
}
memcpy(v15, v12, v14);
return v10 + v14;
}
|
my_longlong10_to_str_8bit:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xd0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x58],RDI
MOV qword ptr [RBP + -0x60],RSI
MOV qword ptr [RBP + -0x68],RDX
MOV dword ptr [RBP + -0x6c],ECX
MOV qword ptr [RBP + -0x78],R8
MOV dword ptr [RBP + -0x94],0x0
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0xa0],RAX
CMP dword ptr [RBP + -0x6c],0x0
JGE 0x00154bb7
CMP qword ptr [RBP + -0x78],0x0
JGE 0x00154bb5
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0xa0],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RCX,RAX
ADD RCX,0x1
MOV qword ptr [RBP + -0x60],RCX
MOV byte ptr [RAX],0x2d
MOV RAX,qword ptr [RBP + -0x68]
ADD RAX,-0x1
MOV qword ptr [RBP + -0x68],RAX
MOV dword ptr [RBP + -0x94],0x1
LAB_00154bb5:
JMP 0x00154bb7
LAB_00154bb7:
LEA RAX,[RBP + -0x50]
ADD RAX,0x40
MOV qword ptr [RBP + -0x80],RAX
MOV qword ptr [RBP + -0x88],RAX
MOV RAX,qword ptr [RBP + -0x80]
MOV byte ptr [RAX],0x0
CMP qword ptr [RBP + -0xa0],0x0
JNZ 0x00154bfb
MOV RAX,qword ptr [RBP + -0x80]
MOV RCX,RAX
ADD RCX,-0x1
MOV qword ptr [RBP + -0x80],RCX
MOV byte ptr [RAX + -0x1],0x30
MOV qword ptr [RBP + -0x68],0x1
JMP 0x00154d1b
LAB_00154bfb:
JMP 0x00154bfd
LAB_00154bfd:
MOV RAX,0x7fffffffffffffff
CMP qword ptr [RBP + -0xa0],RAX
JBE 0x00154c6d
MOV RAX,qword ptr [RBP + -0xa0]
MOV ECX,0xa
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0xa0]
IMUL RCX,qword ptr [RBP + -0xa8],0xa
SUB RAX,RCX
MOV dword ptr [RBP + -0xac],EAX
MOV EAX,dword ptr [RBP + -0xac]
ADD EAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xa8]
MOV qword ptr [RBP + -0xa0],RAX
JMP 0x00154bfd
LAB_00154c6d:
MOV RAX,qword ptr [RBP + -0xa0]
MOV qword ptr [RBP + -0x90],RAX
LAB_00154c7b:
CMP qword ptr [RBP + -0x90],0x0
JZ 0x00154cd7
MOV RAX,qword ptr [RBP + -0x90]
MOV ECX,0xa
CQO
IDIV RCX
MOV qword ptr [RBP + -0xb8],RAX
MOV RAX,qword ptr [RBP + -0x90]
IMUL RCX,qword ptr [RBP + -0xb8],0xa
SUB RAX,RCX
ADD RAX,0x30
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x80]
MOV RDX,RAX
ADD RDX,-0x1
MOV qword ptr [RBP + -0x80],RDX
MOV byte ptr [RAX + -0x1],CL
MOV RAX,qword ptr [RBP + -0xb8]
MOV qword ptr [RBP + -0x90],RAX
JMP 0x00154c7b
LAB_00154cd7:
MOV RAX,qword ptr [RBP + -0x68]
MOV RCX,qword ptr [RBP + -0x88]
MOV RDX,qword ptr [RBP + -0x80]
SUB RCX,RDX
CMP RAX,RCX
JNC 0x00154cfb
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0xc0],RAX
JMP 0x00154d10
LAB_00154cfb:
MOV RAX,qword ptr [RBP + -0x88]
MOV RCX,qword ptr [RBP + -0x80]
SUB RAX,RCX
MOV qword ptr [RBP + -0xc0],RAX
LAB_00154d10:
MOV RAX,qword ptr [RBP + -0xc0]
MOV qword ptr [RBP + -0x68],RAX
LAB_00154d1b:
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,qword ptr [RBP + -0x80]
MOV RDX,qword ptr [RBP + -0x68]
CALL 0x00125230
MOV RAX,qword ptr [RBP + -0x68]
MOV ECX,dword ptr [RBP + -0x94]
ADD RAX,RCX
MOV qword ptr [RBP + -0xc8],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00154d62
MOV RAX,qword ptr [RBP + -0xc8]
ADD RSP,0xd0
POP RBP
RET
LAB_00154d62:
CALL 0x00125340
|
long my_longlong10_to_str_8bit
(int8 param_1,int1 *param_2,ulong param_3,int param_4,ulong param_5)
{
char *pcVar1;
long in_FS_OFFSET;
ulong local_c8;
ulong local_a8;
uint local_9c;
ulong local_98;
char *local_88;
size_t local_70;
int1 *local_68;
char local_19 [9];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_9c = 0;
local_a8 = param_5;
local_70 = param_3;
local_68 = param_2;
if (param_4 < 0) {
if ((long)param_5 < 0) {
local_a8 = -param_5;
local_68 = param_2 + 1;
*param_2 = 0x2d;
local_70 = param_3 - 1;
}
local_9c = (uint)((long)param_5 < 0);
}
pcVar1 = local_19 + 1;
local_19[1] = 0;
local_88 = pcVar1;
if (local_a8 == 0) {
local_88 = local_19;
local_19[0] = '0';
local_70 = 1;
}
else {
while (0x7fffffffffffffff < local_a8) {
local_88[-1] = (char)local_a8 + (char)(local_a8 / 10) * -10 + '0';
local_a8 = local_a8 / 10;
local_88 = local_88 + -1;
}
local_98 = local_a8;
while (local_98 != 0) {
local_88[-1] = (char)local_98 + (char)((long)local_98 / 10) * -10 + '0';
local_98 = (long)local_98 / 10;
local_88 = local_88 + -1;
}
if (local_70 < (ulong)((long)pcVar1 - (long)local_88)) {
local_c8 = local_70;
}
else {
local_c8 = (long)pcVar1 - (long)local_88;
}
local_70 = local_c8;
}
memcpy(local_68,local_88,local_70);
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_70 + local_9c;
}
|
|
7,760 |
minja::Value::get(minja::Value const&)
|
monkey531[P]llama/common/./minja.hpp
|
Value get(const Value& key) {
if (array_) {
if (!key.is_number_integer()) {
return Value();
}
auto index = key.get<int>();
return array_->at(index < 0 ? array_->size() + index : index);
} else if (object_) {
if (!key.is_hashable()) throw std::runtime_error("Unashable type: " + dump());
auto it = object_->find(key.primitive_);
if (it == object_->end()) return Value();
return it->second;
}
return Value();
}
|
O3
|
cpp
|
minja::Value::get(minja::Value const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rsi)
je 0x48f90
movb 0x40(%r15), %al
addb $-0x5, %al
cmpb $0x2, %al
jae 0x4903e
movq %r15, %rdi
callq 0x3de48
movq 0x10(%r14), %rcx
testl %eax, %eax
js 0x48fed
movl %eax, %eax
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
jmp 0x4900e
movq 0x20(%r14), %r13
testq %r13, %r13
je 0x4903e
cmpq $0x0, 0x10(%r15)
jne 0x4907f
cmpq $0x0, 0x20(%r15)
jne 0x4907f
cmpq $0x0, 0x30(%r15)
jne 0x4907f
movq (%r13), %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
je 0x4902b
addq $0x40, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x353cc
testb %al, %al
jne 0x49020
addq $0x60, %r12
movq 0x8(%r13), %rsi
cmpq %rsi, %r12
jne 0x48fcf
jmp 0x49023
movq (%rcx), %rsi
movq 0x8(%rcx), %rcx
subq %rsi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rdx
cltq
addq %rdx, %rax
cmpq %rax, %rdx
jbe 0x4906e
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq %rax, %rsi
jmp 0x49034
movq %r12, %rsi
movq 0x20(%r14), %rax
movq 0x8(%rax), %r12
cmpq %r12, %rsi
je 0x4903e
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x3db22
jmp 0x4905c
movq $0x0, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movb $0x0, 0x40(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x682ed(%rip), %rdi # 0xb1362
movq %rax, %rsi
xorl %eax, %eax
callq 0x19be0
movl $0x10, %edi
callq 0x193b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x3c472
leaq 0x684e0(%rip), %rsi # 0xb1587
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x20f0f
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x19cd0
xorl %ebp, %ebp
movq 0x9ef21(%rip), %rsi # 0xe7ff0
movq 0x9ee92(%rip), %rdx # 0xe7f68
movq %rbx, %rdi
callq 0x19da0
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x490fc
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x197b0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49117
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x197b0
testb %bpl, %bpl
jne 0x49141
jmp 0x49149
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49141
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x197b0
jmp 0x49141
movq %rax, %r14
movq %rbx, %rdi
callq 0x19570
movq %r14, %rdi
callq 0x19e10
nop
|
_ZN5minja5Value3getERKS0_:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r15, rdx
mov r14, rsi
mov rbx, rdi
cmp qword ptr [rsi+10h], 0
jz short loc_48F90
mov al, [r15+40h]
add al, 0FBh
cmp al, 2
jnb loc_4903E
mov rdi, r15
call _ZNK5minja5Value3getIiEET_v; minja::Value::get<int>(void)
mov rcx, [r14+10h]
test eax, eax
js short loc_48FED
mov eax, eax
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
jmp short loc_4900E
loc_48F90:
mov r13, [r14+20h]
test r13, r13
jz loc_4903E
cmp qword ptr [r15+10h], 0
jnz loc_4907F
cmp qword ptr [r15+20h], 0
jnz loc_4907F
cmp qword ptr [r15+30h], 0
jnz loc_4907F
mov r12, [r13+0]
mov rsi, [r13+8]
cmp r12, rsi
jz short loc_4902B
add r15, 40h ; '@'
loc_48FCF:
mov rdi, r12
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_3eqERKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEESF_; nlohmann::json_abi_v3_11_3::operator==(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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, al
jnz short loc_49020
add r12, 60h ; '`'
mov rsi, [r13+8]
cmp r12, rsi
jnz short loc_48FCF
jmp short loc_49023
loc_48FED:
mov rsi, [rcx]
mov rcx, [rcx+8]
sub rcx, rsi
sar rcx, 4
mov rdx, 0CCCCCCCCCCCCCCCDh
imul rdx, rcx
cdqe
add rax, rdx
loc_4900E:
cmp rdx, rax
jbe short loc_4906E
lea rax, [rax+rax*4]
shl rax, 4
add rsi, rax
jmp short loc_49034
loc_49020:
mov rsi, r12
loc_49023:
mov rax, [r14+20h]
mov r12, [rax+8]
loc_4902B:
cmp rsi, r12
jz short loc_4903E
add rsi, 10h; minja::Value *
loc_49034:
mov rdi, rbx; this
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
jmp short loc_4905C
loc_4903E:
mov qword ptr [rbx+48h], 0
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
movups xmmword ptr [rbx+10h], xmm0
movups xmmword ptr [rbx+20h], xmm0
movups xmmword ptr [rbx+30h], xmm0
mov byte ptr [rbx+40h], 0
loc_4905C:
mov rax, rbx
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_4906E:
lea rdi, aVectorMRangeCh; "vector::_M_range_check: __n (which is %"...
mov rsi, rax
xor eax, eax
call __ZSt24__throw_out_of_range_fmtPKcz; std::__throw_out_of_range_fmt(char const*,...)
loc_4907F:
mov edi, 10h; thrown_size
call ___cxa_allocate_exception
mov rbx, rax
lea rdi, [rsp+78h+var_70]
mov rsi, r14
mov edx, 0FFFFFFFFh
xor ecx, ecx
call _ZNK5minja5Value4dumpB5cxx11Eib; minja::Value::dump(int,bool)
lea rsi, aUnashableType; "Unashable type: "
lea rdi, [rsp+78h+var_50]
lea rdx, [rsp+78h+var_70]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_OS8_; std::operator+<char>(char const*,std::string&&)
mov bpl, 1
lea rsi, [rsp+78h+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:_ZTISt19_Sp_make_shared_tag; void (*)(void *)
mov rdi, rbx; void *
call ___cxa_throw
mov r14, rax
lea rax, [rsp+78h+var_40]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_490FC
mov rsi, [rsp+78h+var_40]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_490FC:
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_49117
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_49117:
test bpl, bpl
jnz short loc_49141
jmp short loc_49149
mov r14, rax
lea rax, [rsp+78h+var_60]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_49141
mov rsi, [rsp+78h+var_60]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_49141
mov r14, rax
loc_49141:
mov rdi, rbx; void *
call ___cxa_free_exception
loc_49149:
mov rdi, r14
call __Unwind_Resume
|
minja::Value * minja::Value::get(minja::Value *this, const minja::Value *a2, long long a3, __m128d a4)
{
unsigned long long v5; // rax
long long *v6; // rcx
long long v7; // rsi
unsigned long long v8; // rdx
unsigned __int8 **v9; // r13
unsigned __int8 *v10; // r12
unsigned __int8 *v11; // rsi
unsigned __int8 *v12; // r15
const minja::Value *v13; // rsi
void *exception; // rbx
_BYTE v16[16]; // [rsp+8h] [rbp-70h] BYREF
_BYTE v17[16]; // [rsp+28h] [rbp-50h] BYREF
if ( *((_QWORD *)a2 + 2) )
{
if ( (unsigned __int8)(*(_BYTE *)(a3 + 64) - 5) < 2u )
{
LODWORD(v5) = minja::Value::get<int>((_QWORD *)a3);
v6 = (long long *)*((_QWORD *)a2 + 2);
if ( (v5 & 0x80000000) != 0LL )
{
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
v5 = v8 + (int)v5;
}
else
{
v5 = (unsigned int)v5;
v7 = *v6;
v8 = 0xCCCCCCCCCCCCCCCDLL * ((v6[1] - *v6) >> 4);
}
if ( v8 <= v5 )
std::__throw_out_of_range_fmt(
"vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",
v5,
v8);
v13 = (const minja::Value *)(80 * v5 + v7);
goto LABEL_21;
}
LABEL_22:
*((_QWORD *)this + 9) = 0LL;
*(_OWORD *)this = 0LL;
*((_OWORD *)this + 1) = 0LL;
*((_OWORD *)this + 2) = 0LL;
*((_OWORD *)this + 3) = 0LL;
*((_BYTE *)this + 64) = 0;
return this;
}
v9 = (unsigned __int8 **)*((_QWORD *)a2 + 4);
if ( !v9 )
goto LABEL_22;
if ( *(_QWORD *)(a3 + 16) || *(_QWORD *)(a3 + 32) || *(_QWORD *)(a3 + 48) )
{
exception = __cxa_allocate_exception(0x10uLL);
minja::Value::dump[abi:cxx11]((long long)v16, (long long)a2, 0xFFFFFFFF, 0);
std::operator+<char>((long long)v17, (long long)"Unashable type: ", (long long)v16);
std::runtime_error::runtime_error(exception, v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v10 = *v9;
v11 = v9[1];
if ( *v9 != v11 )
{
v12 = (unsigned __int8 *)(a3 + 64);
while ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::operator==(v10, v12, a4) )
{
v10 += 96;
v11 = v9[1];
if ( v10 == v11 )
goto LABEL_18;
}
v11 = v10;
LABEL_18:
v10 = *(unsigned __int8 **)(*((_QWORD *)a2 + 4) + 8LL);
}
if ( v11 == v10 )
goto LABEL_22;
v13 = (const minja::Value *)(v11 + 16);
LABEL_21:
minja::Value::Value(this, v13);
return this;
}
|
get:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
CMP qword ptr [RSI + 0x10],0x0
JZ 0x00148f90
MOV AL,byte ptr [R15 + 0x40]
ADD AL,0xfb
CMP AL,0x2
JNC 0x0014903e
MOV RDI,R15
CALL 0x0013de48
MOV RCX,qword ptr [R14 + 0x10]
TEST EAX,EAX
JS 0x00148fed
MOV EAX,EAX
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
JMP 0x0014900e
LAB_00148f90:
MOV R13,qword ptr [R14 + 0x20]
TEST R13,R13
JZ 0x0014903e
CMP qword ptr [R15 + 0x10],0x0
JNZ 0x0014907f
CMP qword ptr [R15 + 0x20],0x0
JNZ 0x0014907f
CMP qword ptr [R15 + 0x30],0x0
JNZ 0x0014907f
MOV R12,qword ptr [R13]
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JZ 0x0014902b
ADD R15,0x40
LAB_00148fcf:
MOV RDI,R12
MOV RSI,R15
CALL 0x001353cc
TEST AL,AL
JNZ 0x00149020
ADD R12,0x60
MOV RSI,qword ptr [R13 + 0x8]
CMP R12,RSI
JNZ 0x00148fcf
JMP 0x00149023
LAB_00148fed:
MOV RSI,qword ptr [RCX]
MOV RCX,qword ptr [RCX + 0x8]
SUB RCX,RSI
SAR RCX,0x4
MOV RDX,-0x3333333333333333
IMUL RDX,RCX
CDQE
ADD RAX,RDX
LAB_0014900e:
CMP RDX,RAX
JBE 0x0014906e
LEA RAX,[RAX + RAX*0x4]
SHL RAX,0x4
ADD RSI,RAX
JMP 0x00149034
LAB_00149020:
MOV RSI,R12
LAB_00149023:
MOV RAX,qword ptr [R14 + 0x20]
MOV R12,qword ptr [RAX + 0x8]
LAB_0014902b:
CMP RSI,R12
JZ 0x0014903e
ADD RSI,0x10
LAB_00149034:
MOV RDI,RBX
CALL 0x0013db22
JMP 0x0014905c
LAB_0014903e:
MOV qword ptr [RBX + 0x48],0x0
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
MOVUPS xmmword ptr [RBX + 0x10],XMM0
MOVUPS xmmword ptr [RBX + 0x20],XMM0
MOVUPS xmmword ptr [RBX + 0x30],XMM0
MOV byte ptr [RBX + 0x40],0x0
LAB_0014905c:
MOV RAX,RBX
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0014906e:
LEA RDI,[0x1b1362]
MOV RSI,RAX
XOR EAX,EAX
CALL 0x00119be0
LAB_0014907f:
MOV EDI,0x10
CALL 0x001193b0
MOV RBX,RAX
LAB_0014908c:
LEA RDI,[RSP + 0x8]
MOV RSI,R14
MOV EDX,0xffffffff
XOR ECX,ECX
CALL 0x0013c472
LAB_001490a0:
LEA RSI,[0x1b1587]
LEA RDI,[RSP + 0x28]
LEA RDX,[RSP + 0x8]
CALL 0x00120f0f
MOV BPL,0x1
LAB_001490b9:
LEA RSI,[RSP + 0x28]
MOV RDI,RBX
CALL 0x00119cd0
XOR EBP,EBP
MOV RSI,qword ptr [0x001e7ff0]
MOV RDX,qword ptr [0x001e7f68]
MOV RDI,RBX
CALL 0x00119da0
|
/* minja::Value::get(minja::Value const&) */
Value * minja::Value::get(Value *param_1)
{
long *plVar1;
char cVar2;
uint uVar3;
ulong uVar4;
runtime_error *this;
Value *in_RDX;
ulong uVar5;
long in_RSI;
long lVar6;
Value *pVVar7;
basic_json *pbVar8;
basic_json *pbVar9;
Value local_70 [32];
string local_50 [32];
if (*(long *)(in_RSI + 0x10) == 0) {
plVar1 = *(long **)(in_RSI + 0x20);
if (plVar1 != (long *)0x0) {
if (((*(long *)(in_RDX + 0x10) != 0) || (*(long *)(in_RDX + 0x20) != 0)) ||
(*(long *)(in_RDX + 0x30) != 0)) goto LAB_0014907f;
pbVar9 = (basic_json *)*plVar1;
pbVar8 = (basic_json *)plVar1[1];
if (pbVar9 != pbVar8) {
do {
pbVar8 = pbVar9;
cVar2 = nlohmann::json_abi_v3_11_3::operator==(pbVar8,(basic_json *)(in_RDX + 0x40));
if (cVar2 != '\0') break;
pbVar9 = pbVar8 + 0x60;
pbVar8 = (basic_json *)plVar1[1];
} while (pbVar9 != pbVar8);
pbVar9 = *(basic_json **)(*(long *)(in_RSI + 0x20) + 8);
}
if (pbVar8 != pbVar9) {
pVVar7 = (Value *)(pbVar8 + 0x10);
goto LAB_00149034;
}
}
}
else if ((byte)((char)in_RDX[0x40] - 5U) < 2) {
uVar3 = get<int>(in_RDX);
plVar1 = *(long **)(in_RSI + 0x10);
if ((int)uVar3 < 0) {
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
uVar4 = (long)(int)uVar3 + uVar5;
}
else {
uVar4 = (ulong)uVar3;
lVar6 = *plVar1;
uVar5 = (plVar1[1] - lVar6 >> 4) * -0x3333333333333333;
}
if (uVar4 < uVar5) {
pVVar7 = (Value *)(lVar6 + uVar4 * 0x50);
LAB_00149034:
Value(param_1,pVVar7);
return param_1;
}
std::__throw_out_of_range_fmt
("vector::_M_range_check: __n (which is %zu) >= this->size() (which is %zu)",uVar4);
LAB_0014907f:
this = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0014908c to 0014909f has its CatchHandler @ 0014913e */
dump_abi_cxx11_(local_70,(int)in_RSI,true);
/* try { // try from 001490a0 to 001490b5 has its CatchHandler @ 0014911e */
std::operator+((char *)local_50,(string *)"Unashable type: ");
/* try { // try from 001490b9 to 001490dd has its CatchHandler @ 001490de */
std::runtime_error::runtime_error(this,local_50);
/* WARNING: Subroutine does not return */
__cxa_throw(this,PTR_typeinfo_001e7ff0,PTR__runtime_error_001e7f68);
}
*(int8 *)(param_1 + 0x48) = 0;
*(int8 *)param_1 = 0;
*(int8 *)(param_1 + 8) = 0;
*(int8 *)(param_1 + 0x10) = 0;
*(int8 *)(param_1 + 0x18) = 0;
*(int8 *)(param_1 + 0x20) = 0;
*(int8 *)(param_1 + 0x28) = 0;
*(int8 *)(param_1 + 0x30) = 0;
*(int8 *)(param_1 + 0x38) = 0;
param_1[0x40] = (Value)0x0;
return param_1;
}
|
|
7,761 |
maria_delete_table_files
|
eloqsql/storage/maria/ma_delete_table.c
|
int maria_delete_table_files(const char *name, my_bool temporary, myf flags)
{
int error= 0;
DBUG_ENTER("maria_delete_table_files");
if (mysql_file_delete_with_symlink(key_file_kfile, name, MARIA_NAME_IEXT,
flags))
error= my_errno;
if (mysql_file_delete_with_symlink(key_file_dfile, name, MARIA_NAME_DEXT,
flags))
error= my_errno;
if (!temporary)
{
/* This is delete a possible temporary aria_chk file */
mysql_file_delete_with_symlink(key_file_dfile, name, DATA_TMP_EXT, MYF(0));
#ifdef SUPPORT_ARIA_PACK
/* This is delete a possible temporary aria_pack file */
mysql_file_delete_with_symlink(key_file_dfile, name, ".OLD", MYF(0));
#endif
}
DBUG_RETURN(error);
}
|
O0
|
c
|
maria_delete_table_files:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x416ec4(%rip), %rax # 0x4ad098
movl (%rax), %edi
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %r9
leaq 0xeaa6f(%rip), %rsi # 0x180c54
movl $0x65, %edx
leaq 0xe9534(%rip), %r8 # 0x17f725
callq 0x96280
cmpl $0x0, %eax
je 0x96205
callq 0x122520
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
leaq 0x416e90(%rip), %rax # 0x4ad09c
movl (%rax), %edi
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %r9
leaq 0xeaa37(%rip), %rsi # 0x180c54
movl $0x68, %edx
leaq 0xe9558(%rip), %r8 # 0x17f781
callq 0x96280
cmpl $0x0, %eax
je 0x9623d
callq 0x122520
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpb $0x0, -0x9(%rbp)
jne 0x9626d
leaq 0x416e52(%rip), %rax # 0x4ad09c
movl (%rax), %edi
movq -0x8(%rbp), %rcx
leaq 0xea9fd(%rip), %rsi # 0x180c54
movl $0x6d, %edx
leaq 0xeaa3a(%rip), %r8 # 0x180c9d
xorl %eax, %eax
movl %eax, %r9d
callq 0x96280
jmp 0x9626f
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
|
maria_delete_table_files:
push rbp
mov rbp, rsp
sub rsp, 20h
mov al, sil
mov [rbp+var_8], rdi
mov [rbp+var_9], al
mov [rbp+var_18], rdx
mov [rbp+var_1C], 0
lea rax, key_file_kfile
mov edi, [rax]
mov rcx, [rbp+var_8]
mov r9, [rbp+var_18]
lea rsi, aWorkspaceLlm4b_23; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 65h ; 'e'
lea r8, aMai; ".MAI"
call inline_mysql_file_delete_with_symlink
cmp eax, 0
jz short loc_96205
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
loc_96205:
lea rax, key_file_dfile
mov edi, [rax]
mov rcx, [rbp+var_8]
mov r9, [rbp+var_18]
lea rsi, aWorkspaceLlm4b_23; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 68h ; 'h'
lea r8, aMad; ".MAD"
call inline_mysql_file_delete_with_symlink
cmp eax, 0
jz short loc_9623D
call _my_thread_var
mov eax, [rax]
mov [rbp+var_1C], eax
loc_9623D:
cmp [rbp+var_9], 0
jnz short loc_9626D
lea rax, key_file_dfile
mov edi, [rax]
mov rcx, [rbp+var_8]
lea rsi, aWorkspaceLlm4b_23; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 6Dh ; 'm'
lea r8, aTmd; ".TMD"
xor eax, eax
mov r9d, eax
call inline_mysql_file_delete_with_symlink
loc_9626D:
jmp short $+2
loc_9626F:
mov eax, [rbp+var_1C]
mov [rbp+var_20], eax
mov eax, [rbp+var_20]
add rsp, 20h
pop rbp
retn
|
long long maria_delete_table_files(long long a1, char a2, long long a3)
{
long long v3; // rdi
long long v4; // rdx
long long v5; // rcx
long long v6; // r8
long long v7; // r9
long long v8; // rdi
long long v9; // rdx
long long v10; // rcx
long long v11; // r8
long long v12; // r9
unsigned int v14; // [rsp+4h] [rbp-1Ch]
v14 = 0;
v3 = key_file_kfile;
if ( (unsigned int)inline_mysql_file_delete_with_symlink(
key_file_kfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
101LL,
a1,
".MAI",
a3) )
v14 = *(_DWORD *)my_thread_var(
v3,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
v4,
v5,
v6,
v7);
v8 = key_file_dfile;
if ( (unsigned int)inline_mysql_file_delete_with_symlink(
key_file_dfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
104LL,
a1,
".MAD",
a3) )
v14 = *(_DWORD *)my_thread_var(
v8,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
v9,
v10,
v11,
v12);
if ( !a2 )
inline_mysql_file_delete_with_symlink(
key_file_dfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
109LL,
a1,
".TMD",
0LL);
return v14;
}
|
maria_delete_table_files:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV AL,SIL
MOV qword ptr [RBP + -0x8],RDI
MOV byte ptr [RBP + -0x9],AL
MOV qword ptr [RBP + -0x18],RDX
MOV dword ptr [RBP + -0x1c],0x0
LEA RAX,[0x5ad098]
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV R9,qword ptr [RBP + -0x18]
LEA RSI,[0x280c54]
MOV EDX,0x65
LEA R8,[0x27f725]
CALL 0x00196280
CMP EAX,0x0
JZ 0x00196205
CALL 0x00222520
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
LAB_00196205:
LEA RAX,[0x5ad09c]
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
MOV R9,qword ptr [RBP + -0x18]
LEA RSI,[0x280c54]
MOV EDX,0x68
LEA R8,[0x27f781]
CALL 0x00196280
CMP EAX,0x0
JZ 0x0019623d
CALL 0x00222520
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0019623d:
CMP byte ptr [RBP + -0x9],0x0
JNZ 0x0019626d
LEA RAX,[0x5ad09c]
MOV EDI,dword ptr [RAX]
MOV RCX,qword ptr [RBP + -0x8]
LEA RSI,[0x280c54]
MOV EDX,0x6d
LEA R8,[0x280c9d]
XOR EAX,EAX
MOV R9D,EAX
CALL 0x00196280
LAB_0019626d:
JMP 0x0019626f
LAB_0019626f:
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x20],EAX
MOV EAX,dword ptr [RBP + -0x20]
ADD RSP,0x20
POP RBP
RET
|
int4 maria_delete_table_files(int8 param_1,char param_2,int8 param_3)
{
int iVar1;
int4 *puVar2;
int4 local_24;
local_24 = 0;
iVar1 = inline_mysql_file_delete_with_symlink
(key_file_kfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",0x65
,param_1,&DAT_0027f725,param_3);
if (iVar1 != 0) {
puVar2 = (int4 *)_my_thread_var();
local_24 = *puVar2;
}
iVar1 = inline_mysql_file_delete_with_symlink
(key_file_dfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",0x68
,param_1,&DAT_0027f781,param_3);
if (iVar1 != 0) {
puVar2 = (int4 *)_my_thread_var();
local_24 = *puVar2;
}
if (param_2 == '\0') {
inline_mysql_file_delete_with_symlink
(key_file_dfile,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",0x6d,
param_1,&DAT_00280c9d,0);
}
return local_24;
}
|
|
7,762 |
maria_delete_table_files
|
eloqsql/storage/maria/ma_delete_table.c
|
int maria_delete_table_files(const char *name, my_bool temporary, myf flags)
{
int error= 0;
DBUG_ENTER("maria_delete_table_files");
if (mysql_file_delete_with_symlink(key_file_kfile, name, MARIA_NAME_IEXT,
flags))
error= my_errno;
if (mysql_file_delete_with_symlink(key_file_dfile, name, MARIA_NAME_DEXT,
flags))
error= my_errno;
if (!temporary)
{
/* This is delete a possible temporary aria_chk file */
mysql_file_delete_with_symlink(key_file_dfile, name, DATA_TMP_EXT, MYF(0));
#ifdef SUPPORT_ARIA_PACK
/* This is delete a possible temporary aria_pack file */
mysql_file_delete_with_symlink(key_file_dfile, name, ".OLD", MYF(0));
#endif
}
DBUG_RETURN(error);
}
|
O3
|
c
|
maria_delete_table_files:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdx, %r12
movl %esi, -0x23c(%rbp)
movq %rdi, %rsi
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
leaq 0x3b1de6(%rip), %rax # 0x425508
movl (%rax), %r13d
leaq 0x88c48(%rip), %rdx # 0xfc374
leaq 0x86f92(%rip), %rcx # 0xfa6c5
leaq -0x230(%rbp), %rdi
movq %rsi, -0x248(%rbp)
movl $0x104, %r8d # imm = 0x104
callq 0xb02b0
movq %rax, %r15
leaq 0x33b2c2(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x290(%rbp), %rdi
leaq -0x238(%rbp), %r14
movl %r13d, %esi
movl $0xe, %edx
movq %r15, %rcx
movq %r14, %r8
callq *0x148(%rax)
movq %rax, (%r14)
testq %rax, %rax
jne 0x738cf
movq %r15, %rdi
movq %r12, %rsi
callq 0xc0da6
movl %eax, %r15d
testl %r15d, %r15d
je 0x737a3
callq 0xc14ee
movl (%rax), %ebx
jmp 0x737a5
xorl %ebx, %ebx
leaq 0x3b1d60(%rip), %rax # 0x42550c
movl (%rax), %r14d
leaq 0x88bbe(%rip), %rdx # 0xfc374
leaq 0x86f64(%rip), %rcx # 0xfa721
leaq -0x230(%rbp), %rdi
movq -0x248(%rbp), %rsi
movl $0x104, %r8d # imm = 0x104
callq 0xb02b0
movq %rax, %r13
leaq 0x33b238(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x290(%rbp), %rdi
leaq -0x238(%rbp), %r15
movl %r14d, %esi
movl $0xe, %edx
movq %r13, %rcx
movq %r15, %r8
callq *0x148(%rax)
movq %rax, (%r15)
testq %rax, %rax
jne 0x73914
movq %r13, %rdi
movq %r12, %rsi
callq 0xc0da6
movl %eax, %r12d
testl %r12d, %r12d
movl %ebx, %r12d
je 0x7382f
callq 0xc14ee
movl (%rax), %r12d
cmpb $0x0, -0x23c(%rbp)
jne 0x738a7
leaq 0x3b1ccd(%rip), %rax # 0x42550c
movl (%rax), %r14d
leaq 0x88b2b(%rip), %rdx # 0xfc374
leaq 0x883ed(%rip), %rcx # 0xfbc3d
leaq -0x230(%rbp), %rdi
movq -0x248(%rbp), %rsi
movl $0x104, %r8d # imm = 0x104
callq 0xb02b0
movq %rax, %rbx
leaq 0x33b1a5(%rip), %rax # 0x3aea18
movq (%rax), %rax
leaq -0x290(%rbp), %rdi
movl %r14d, %esi
movl $0xe, %edx
movq %rbx, %rcx
movq %r15, %r8
callq *0x148(%rax)
movq %rax, (%r15)
testq %rax, %rax
jne 0x73959
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc0da6
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x73970
movl %r12d, %eax
addq $0x268, %rsp # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33b142(%rip), %r14 # 0x3aea18
movq (%r14), %rcx
leaq 0x88314(%rip), %rsi # 0xfbbf4
movq %rax, %rdi
movl $0x65, %edx
callq *0x220(%rcx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xc0da6
movl %eax, %r15d
movq (%r14), %rax
movq -0x238(%rbp), %rdi
movl %r15d, %esi
callq *0x228(%rax)
jmp 0x73795
leaq 0x33b0fd(%rip), %r14 # 0x3aea18
movq (%r14), %rcx
leaq 0x882cf(%rip), %rsi # 0xfbbf4
movq %rax, %rdi
movl $0x68, %edx
callq *0x220(%rcx)
movq %r13, %rdi
movq %r12, %rsi
callq 0xc0da6
movl %eax, %r12d
movq (%r14), %rax
movq -0x238(%rbp), %rdi
movl %r12d, %esi
callq *0x228(%rax)
jmp 0x7381f
leaq -0x238(%rbp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2e9a6
jmp 0x738a7
callq 0x2a280
nopl (%rax)
|
maria_delete_table_files:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 268h
mov r12, rdx
mov [rbp+var_23C], esi
mov rsi, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
lea rax, key_file_kfile
mov r13d, [rax]
lea rdx, aTotalKeyblocks+30h; ""
lea rcx, aMai; ".MAI"
lea rdi, [rbp+var_230]
mov [rbp+var_248], rsi
mov r8d, 104h
call fn_format
mov r15, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_290]
lea r14, [rbp+var_238]
mov esi, r13d
mov edx, 0Eh
mov rcx, r15
mov r8, r14
call qword ptr [rax+148h]
mov [r14], rax
test rax, rax
jnz loc_738CF
mov rdi, r15
mov rsi, r12
call my_handler_delete_with_symlink
mov r15d, eax
loc_73795:
test r15d, r15d
jz short loc_737A3
call _my_thread_var
mov ebx, [rax]
jmp short loc_737A5
loc_737A3:
xor ebx, ebx
loc_737A5:
lea rax, key_file_dfile
mov r14d, [rax]
lea rdx, aTotalKeyblocks+30h; ""
lea rcx, aMad; ".MAD"
lea rdi, [rbp+var_230]
mov rsi, [rbp+var_248]
mov r8d, 104h
call fn_format
mov r13, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_290]
lea r15, [rbp+var_238]
mov esi, r14d
mov edx, 0Eh
mov rcx, r13
mov r8, r15
call qword ptr [rax+148h]
mov [r15], rax
test rax, rax
jnz loc_73914
mov rdi, r13
mov rsi, r12
call my_handler_delete_with_symlink
mov r12d, eax
loc_7381F:
test r12d, r12d
mov r12d, ebx
jz short loc_7382F
call _my_thread_var
mov r12d, [rax]
loc_7382F:
cmp byte ptr [rbp+var_23C], 0
jnz short loc_738A7
lea rax, key_file_dfile
mov r14d, [rax]
lea rdx, aTotalKeyblocks+30h; ""
lea rcx, aTmd; ".TMD"
lea rdi, [rbp+var_230]
mov rsi, [rbp+var_248]
mov r8d, 104h
call fn_format
mov rbx, rax
lea rax, PSI_server
mov rax, [rax]
lea rdi, [rbp+var_290]
mov esi, r14d
mov edx, 0Eh
mov rcx, rbx
mov r8, r15
call qword ptr [rax+148h]
mov [r15], rax
test rax, rax
jnz loc_73959
mov rdi, rbx
xor esi, esi
call my_handler_delete_with_symlink
loc_738A7:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_73970
mov eax, r12d
add rsp, 268h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_738CF:
lea r14, PSI_server
mov rcx, [r14]
lea rsi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 65h ; 'e'
call qword ptr [rcx+220h]
mov rdi, r15
mov rsi, r12
call my_handler_delete_with_symlink
mov r15d, eax
mov rax, [r14]
mov rdi, [rbp+var_238]
mov esi, r15d
call qword ptr [rax+228h]
jmp loc_73795
loc_73914:
lea r14, PSI_server
mov rcx, [r14]
lea rsi, aWorkspaceLlm4b_14; "/workspace/llm4binary/github2025/eloqsq"...
mov rdi, rax
mov edx, 68h ; 'h'
call qword ptr [rcx+220h]
mov rdi, r13
mov rsi, r12
call my_handler_delete_with_symlink
mov r12d, eax
mov rax, [r14]
mov rdi, [rbp+var_238]
mov esi, r12d
call qword ptr [rax+228h]
jmp loc_7381F
loc_73959:
lea rdx, [rbp+var_238]
mov rdi, rax
mov rsi, rbx
call maria_delete_table_files_cold_1
jmp loc_738A7
loc_73970:
call ___stack_chk_fail
|
long long maria_delete_table_files(long long a1, int a2, long long a3)
{
unsigned int v4; // r13d
long long v5; // r15
long long v6; // rax
long long v7; // rdi
unsigned int v8; // ebx
unsigned int v9; // r14d
long long v10; // r13
long long v11; // rax
long long v12; // rdi
bool v13; // zf
unsigned int v14; // r12d
unsigned int v15; // r14d
long long v16; // rbx
long long v17; // rax
_BYTE v19[72]; // [rsp+0h] [rbp-290h] BYREF
long long v20; // [rsp+48h] [rbp-248h]
int v21; // [rsp+54h] [rbp-23Ch]
long long v22; // [rsp+58h] [rbp-238h] BYREF
_BYTE v23[512]; // [rsp+60h] [rbp-230h] BYREF
unsigned long long v24; // [rsp+260h] [rbp-30h]
v21 = a2;
v24 = __readfsqword(0x28u);
v4 = key_file_kfile;
v20 = a1;
v5 = fn_format(v23, a1, "", ".MAI", 260LL);
v6 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v19, v4, 14LL, v5, &v22);
v22 = v6;
if ( v6 )
{
((void ( *)(long long, const char *, long long))PSI_server[68])(
v6,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
101LL);
v5 = (unsigned int)my_handler_delete_with_symlink(v5, a3);
v7 = v22;
((void ( *)(long long, long long))PSI_server[69])(v22, v5);
}
else
{
v7 = v5;
LODWORD(v5) = my_handler_delete_with_symlink(v5, a3);
}
if ( (_DWORD)v5 )
v8 = *(_DWORD *)my_thread_var(v7);
else
v8 = 0;
v9 = key_file_dfile;
v10 = fn_format(v23, v20, "", ".MAD", 260LL);
v11 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(v19, v9, 14LL, v10, &v22);
v22 = v11;
if ( v11 )
{
((void ( *)(long long, const char *, long long))PSI_server[68])(
v11,
"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
104LL);
a3 = (unsigned int)my_handler_delete_with_symlink(v10, a3);
v12 = v22;
((void ( *)(long long, long long))PSI_server[69])(v22, a3);
}
else
{
v12 = v10;
LODWORD(a3) = my_handler_delete_with_symlink(v10, a3);
}
v13 = (_DWORD)a3 == 0;
v14 = v8;
if ( !v13 )
v14 = *(_DWORD *)my_thread_var(v12);
if ( !(_BYTE)v21 )
{
v15 = key_file_dfile;
v16 = fn_format(v23, v20, "", ".TMD", 260LL);
v17 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, long long *))PSI_server[41])(
v19,
v15,
14LL,
v16,
&v22);
v22 = v17;
if ( v17 )
maria_delete_table_files_cold_1(v17, v16, &v22);
else
my_handler_delete_with_symlink(v16, 0LL);
}
return v14;
}
|
maria_delete_table_files:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x268
MOV R12,RDX
MOV dword ptr [RBP + -0x23c],ESI
MOV RSI,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
LEA RAX,[0x525508]
MOV R13D,dword ptr [RAX]
LEA RDX,[0x1fc374]
LEA RCX,[0x1fa6c5]
LEA RDI,[RBP + -0x230]
MOV qword ptr [RBP + -0x248],RSI
MOV R8D,0x104
CALL 0x001b02b0
MOV R15,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x290]
LEA R14,[RBP + -0x238]
MOV ESI,R13D
MOV EDX,0xe
MOV RCX,R15
MOV R8,R14
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R14],RAX
TEST RAX,RAX
JNZ 0x001738cf
MOV RDI,R15
MOV RSI,R12
CALL 0x001c0da6
MOV R15D,EAX
LAB_00173795:
TEST R15D,R15D
JZ 0x001737a3
CALL 0x001c14ee
MOV EBX,dword ptr [RAX]
JMP 0x001737a5
LAB_001737a3:
XOR EBX,EBX
LAB_001737a5:
LEA RAX,[0x52550c]
MOV R14D,dword ptr [RAX]
LEA RDX,[0x1fc374]
LEA RCX,[0x1fa721]
LEA RDI,[RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x248]
MOV R8D,0x104
CALL 0x001b02b0
MOV R13,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x290]
LEA R15,[RBP + -0x238]
MOV ESI,R14D
MOV EDX,0xe
MOV RCX,R13
MOV R8,R15
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R15],RAX
TEST RAX,RAX
JNZ 0x00173914
MOV RDI,R13
MOV RSI,R12
CALL 0x001c0da6
MOV R12D,EAX
LAB_0017381f:
TEST R12D,R12D
MOV R12D,EBX
JZ 0x0017382f
CALL 0x001c14ee
MOV R12D,dword ptr [RAX]
LAB_0017382f:
CMP byte ptr [RBP + -0x23c],0x0
JNZ 0x001738a7
LEA RAX,[0x52550c]
MOV R14D,dword ptr [RAX]
LEA RDX,[0x1fc374]
LEA RCX,[0x1fbc3d]
LEA RDI,[RBP + -0x230]
MOV RSI,qword ptr [RBP + -0x248]
MOV R8D,0x104
CALL 0x001b02b0
MOV RBX,RAX
LEA RAX,[0x4aea18]
MOV RAX,qword ptr [RAX]
LEA RDI,[RBP + -0x290]
MOV ESI,R14D
MOV EDX,0xe
MOV RCX,RBX
MOV R8,R15
CALL qword ptr [RAX + 0x148]
MOV qword ptr [R15],RAX
TEST RAX,RAX
JNZ 0x00173959
MOV RDI,RBX
XOR ESI,ESI
CALL 0x001c0da6
LAB_001738a7:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x00173970
MOV EAX,R12D
ADD RSP,0x268
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001738cf:
LEA R14,[0x4aea18]
MOV RCX,qword ptr [R14]
LEA RSI,[0x1fbbf4]
MOV RDI,RAX
MOV EDX,0x65
CALL qword ptr [RCX + 0x220]
MOV RDI,R15
MOV RSI,R12
CALL 0x001c0da6
MOV R15D,EAX
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RBP + -0x238]
MOV ESI,R15D
CALL qword ptr [RAX + 0x228]
JMP 0x00173795
LAB_00173914:
LEA R14,[0x4aea18]
MOV RCX,qword ptr [R14]
LEA RSI,[0x1fbbf4]
MOV RDI,RAX
MOV EDX,0x68
CALL qword ptr [RCX + 0x220]
MOV RDI,R13
MOV RSI,R12
CALL 0x001c0da6
MOV R12D,EAX
MOV RAX,qword ptr [R14]
MOV RDI,qword ptr [RBP + -0x238]
MOV ESI,R12D
CALL qword ptr [RAX + 0x228]
JMP 0x0017381f
LAB_00173959:
LEA RDX,[RBP + -0x238]
MOV RDI,RAX
MOV RSI,RBX
CALL 0x0012e9a6
JMP 0x001738a7
LAB_00173970:
CALL 0x0012a280
|
int4 maria_delete_table_files(int8 param_1,int4 param_2,int8 param_3)
{
int4 uVar1;
int iVar2;
int8 uVar3;
int4 *puVar4;
int4 uVar5;
long in_FS_OFFSET;
int1 local_298 [72];
int8 local_250;
int4 local_244;
long local_240;
int1 local_238 [512];
long local_38;
uVar5 = key_file_kfile;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_250 = param_1;
local_244 = param_2;
uVar3 = fn_format(local_238,param_1,"",&DAT_001fa6c5,0x104);
local_240 = (**(code **)(PSI_server + 0x148))(local_298,uVar5,0xe,uVar3,&local_240);
if (local_240 == 0) {
iVar2 = my_handler_delete_with_symlink(uVar3,param_3);
}
else {
(**(code **)(PSI_server + 0x220))
(local_240,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
0x65);
iVar2 = my_handler_delete_with_symlink(uVar3,param_3);
(**(code **)(PSI_server + 0x228))(local_240,iVar2);
}
if (iVar2 == 0) {
uVar5 = 0;
}
else {
puVar4 = (int4 *)_my_thread_var();
uVar5 = *puVar4;
}
uVar1 = key_file_dfile;
uVar3 = fn_format(local_238,local_250,"",&DAT_001fa721,0x104);
local_240 = (**(code **)(PSI_server + 0x148))(local_298,uVar1,0xe,uVar3,&local_240);
if (local_240 == 0) {
iVar2 = my_handler_delete_with_symlink(uVar3,param_3);
}
else {
(**(code **)(PSI_server + 0x220))
(local_240,"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_delete_table.c",
0x68);
iVar2 = my_handler_delete_with_symlink(uVar3,param_3);
(**(code **)(PSI_server + 0x228))(local_240,iVar2);
}
if (iVar2 != 0) {
puVar4 = (int4 *)_my_thread_var();
uVar5 = *puVar4;
}
uVar1 = key_file_dfile;
if ((char)local_244 == '\0') {
uVar3 = fn_format(local_238,local_250,"",&DAT_001fbc3d,0x104);
local_240 = (**(code **)(PSI_server + 0x148))(local_298,uVar1,0xe,uVar3,&local_240);
if (local_240 == 0) {
my_handler_delete_with_symlink(uVar3,0);
}
else {
maria_delete_table_files_cold_1(local_240,uVar3,&local_240);
}
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar5;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
|
|
7,763 |
common_embd_normalize(float const*, float*, int, int)
|
monkey531[P]llama/common/common.cpp
|
void common_embd_normalize(const float * inp, float * out, int n, int embd_norm) {
double sum = 0.0;
switch (embd_norm) {
case -1: // no normalisation
sum = 1.0;
break;
case 0: // max absolute
for (int i = 0; i < n; i++) {
if (sum < std::abs(inp[i])) {
sum = std::abs(inp[i]);
}
}
sum /= 32760.0; // make an int16 range
break;
case 2: // euclidean
for (int i = 0; i < n; i++) {
sum += inp[i] * inp[i];
}
sum = std::sqrt(sum);
break;
default: // p-norm (euclidean is p-norm p=2)
for (int i = 0; i < n; i++) {
sum += std::pow(std::abs(inp[i]), embd_norm);
}
sum = std::pow(sum, 1.0 / embd_norm);
break;
}
const float norm = sum > 0.0 ? 1.0 / sum : 0.0f;
for (int i = 0; i < n; i++) {
out[i] = inp[i] * norm;
}
}
|
O2
|
cpp
|
common_embd_normalize(float const*, float*, int, int):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, %ecx
je 0x275ef
testl %ecx, %ecx
je 0x275ad
cmpl $-0x1, %ecx
jne 0x2762a
xorl %r15d, %r15d
testl %edx, %edx
cmovgl %edx, %r15d
movsd 0x64e80(%rip), %xmm0 # 0x8c428
jmp 0x276a0
xorl %eax, %eax
testl %edx, %edx
movl %edx, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
movaps 0x64dcd(%rip), %xmm1 # 0x8c390
cmpq %rax, %r15
je 0x275e2
movss (%r14,%rax,4), %xmm2
andps %xmm1, %xmm2
cvtss2sd %xmm2, %xmm2
maxsd %xmm0, %xmm2
incq %rax
movapd %xmm2, %xmm0
jmp 0x275c3
divsd 0x64e36(%rip), %xmm0 # 0x8c420
jmp 0x276a0
xorl %eax, %eax
testl %edx, %edx
movl %edx, %r15d
cmovlel %eax, %r15d
xorpd %xmm0, %xmm0
cmpq %rax, %r15
je 0x2761a
movss (%r14,%rax,4), %xmm1
mulss %xmm1, %xmm1
cvtss2sd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x275fe
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2769b
sqrtsd %xmm0, %xmm0
jmp 0x276a0
cvtsi2sd %ecx, %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %r12d, %r12d
testl %edx, %edx
movl %edx, %r15d
cmovlel %r12d, %r15d
xorpd %xmm0, %xmm0
cmpq %r12, %r15
je 0x27686
movsd %xmm0, 0x8(%rsp)
movss (%r14,%r12,4), %xmm0
andps 0x64d34(%rip), %xmm0 # 0x8c390
cvtss2sd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x20b70
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
incq %r12
jmp 0x27644
movsd 0x64d9a(%rip), %xmm1 # 0x8c428
divsd 0x10(%rsp), %xmm1
callq 0x20b70
jmp 0x276a0
callq 0x20580
movsd 0x64d80(%rip), %xmm1 # 0x8c428
divsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpltsd %xmm0, %xmm2
andpd %xmm1, %xmm2
cvtsd2ss %xmm2, %xmm0
xorl %eax, %eax
cmpq %rax, %r15
je 0x276d8
movss (%r14,%rax,4), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rbx,%rax,4)
incq %rax
jmp 0x276bf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
_Z21common_embd_normalizePKfPfii:
push r15
push r14
push r12
push rbx
sub rsp, 18h
mov rbx, rsi
mov r14, rdi
cmp ecx, 2
jz short loc_275EF
test ecx, ecx
jz short loc_275AD
cmp ecx, 0FFFFFFFFh
jnz loc_2762A
xor r15d, r15d
test edx, edx
cmovg r15d, edx
movsd xmm0, cs:qword_8C428
jmp loc_276A0
loc_275AD:
xor eax, eax
test edx, edx
mov r15d, edx
cmovle r15d, eax
xorpd xmm0, xmm0
movaps xmm1, cs:xmmword_8C390
loc_275C3:
cmp r15, rax
jz short loc_275E2
movss xmm2, dword ptr [r14+rax*4]
andps xmm2, xmm1
cvtss2sd xmm2, xmm2
maxsd xmm2, xmm0
inc rax
movapd xmm0, xmm2
jmp short loc_275C3
loc_275E2:
divsd xmm0, cs:qword_8C420
jmp loc_276A0
loc_275EF:
xor eax, eax
test edx, edx
mov r15d, edx
cmovle r15d, eax
xorpd xmm0, xmm0
loc_275FE:
cmp r15, rax
jz short loc_2761A
movss xmm1, dword ptr [r14+rax*4]
mulss xmm1, xmm1
cvtss2sd xmm1, xmm1
addsd xmm0, xmm1
inc rax
jmp short loc_275FE
loc_2761A:
xorpd xmm1, xmm1
ucomisd xmm0, xmm1
jb short loc_2769B
sqrtsd xmm0, xmm0
jmp short loc_276A0
loc_2762A:
cvtsi2sd xmm0, ecx
movsd [rsp+38h+var_28], xmm0
xor r12d, r12d
test edx, edx
mov r15d, edx
cmovle r15d, r12d
xorpd xmm0, xmm0
loc_27644:
cmp r15, r12
jz short loc_27686
movsd [rsp+38h+var_30], xmm0
movss xmm0, dword ptr [r14+r12*4]
andps xmm0, cs:xmmword_8C390
cvtss2sd xmm0, xmm0
movsd xmm1, [rsp+38h+var_28]
call _pow
movsd xmm1, [rsp+38h+var_30]
addsd xmm1, xmm0
movsd [rsp+38h+var_30], xmm1
movsd xmm0, [rsp+38h+var_30]
inc r12
jmp short loc_27644
loc_27686:
movsd xmm1, cs:qword_8C428
divsd xmm1, [rsp+38h+var_28]
call _pow
jmp short loc_276A0
loc_2769B:
call _sqrt
loc_276A0:
movsd xmm1, cs:qword_8C428
divsd xmm1, xmm0
xorpd xmm2, xmm2
cmpltsd xmm2, xmm0
andpd xmm2, xmm1
cvtsd2ss xmm0, xmm2
xor eax, eax
loc_276BF:
cmp r15, rax
jz short loc_276D8
movss xmm1, dword ptr [r14+rax*4]
mulss xmm1, xmm0
movss dword ptr [rbx+rax*4], xmm1
inc rax
jmp short loc_276BF
loc_276D8:
add rsp, 18h
pop rbx
pop r12
pop r14
pop r15
retn
|
long long common_embd_normalize(const float *a1, float *a2, int a3, int a4)
{
long long v4; // r15
__m128d v5; // xmm0
long long v6; // rax
double v7; // xmm0_8
double v8; // xmm2_8
long long v9; // rax
double v10; // xmm0_8
long long v11; // r12
double v12; // xmm0_8
float v13; // xmm0_4
long long result; // rax
double v15; // [rsp+10h] [rbp-28h]
if ( a4 == 2 )
{
v9 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v10 = 0.0;
while ( v4 != v9 )
{
v10 = v10 + (float)(a1[v9] * a1[v9]);
++v9;
}
if ( v10 < 0.0 )
v5.m128d_f64[0] = sqrt(v10);
else
v5.m128d_f64[0] = sqrt(v10);
}
else if ( a4 )
{
if ( a4 == -1 )
{
v4 = 0LL;
if ( a3 > 0 )
v4 = (unsigned int)a3;
v5.m128d_f64[0] = 1.0;
}
else
{
v15 = (double)a4;
v11 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v12 = 0.0;
while ( v4 != v11 )
v12 = v12 + pow(fabs(a1[v11++]), v15);
v5.m128d_f64[0] = pow(v12, 1.0 / v15);
}
}
else
{
v6 = 0LL;
v4 = (unsigned int)a3;
if ( a3 <= 0 )
v4 = 0LL;
v7 = 0.0;
while ( v4 != v6 )
{
v8 = fmax(fabs(a1[v6++]), v7);
v7 = v8;
}
v5.m128d_f64[0] = v7 / 32760.0;
}
v13 = COERCE_DOUBLE(*(_OWORD *)&_mm_cmplt_sd((__m128d)0LL, v5) & COERCE_UNSIGNED_INT64(1.0 / v5.m128d_f64[0]));
for ( result = 0LL; v4 != result; ++result )
a2[result] = a1[result] * v13;
return result;
}
|
common_embd_normalize:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RSI
MOV R14,RDI
CMP ECX,0x2
JZ 0x001275ef
TEST ECX,ECX
JZ 0x001275ad
CMP ECX,-0x1
JNZ 0x0012762a
XOR R15D,R15D
TEST EDX,EDX
CMOVG R15D,EDX
MOVSD XMM0,qword ptr [0x0018c428]
JMP 0x001276a0
LAB_001275ad:
XOR EAX,EAX
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,EAX
XORPD XMM0,XMM0
MOVAPS XMM1,xmmword ptr [0x0018c390]
LAB_001275c3:
CMP R15,RAX
JZ 0x001275e2
MOVSS XMM2,dword ptr [R14 + RAX*0x4]
ANDPS XMM2,XMM1
CVTSS2SD XMM2,XMM2
MAXSD XMM2,XMM0
INC RAX
MOVAPD XMM0,XMM2
JMP 0x001275c3
LAB_001275e2:
DIVSD XMM0,qword ptr [0x0018c420]
JMP 0x001276a0
LAB_001275ef:
XOR EAX,EAX
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,EAX
XORPD XMM0,XMM0
LAB_001275fe:
CMP R15,RAX
JZ 0x0012761a
MOVSS XMM1,dword ptr [R14 + RAX*0x4]
MULSS XMM1,XMM1
CVTSS2SD XMM1,XMM1
ADDSD XMM0,XMM1
INC RAX
JMP 0x001275fe
LAB_0012761a:
XORPD XMM1,XMM1
UCOMISD XMM0,XMM1
JC 0x0012769b
SQRTSD XMM0,XMM0
JMP 0x001276a0
LAB_0012762a:
CVTSI2SD XMM0,ECX
MOVSD qword ptr [RSP + 0x10],XMM0
XOR R12D,R12D
TEST EDX,EDX
MOV R15D,EDX
CMOVLE R15D,R12D
XORPD XMM0,XMM0
LAB_00127644:
CMP R15,R12
JZ 0x00127686
MOVSD qword ptr [RSP + 0x8],XMM0
MOVSS XMM0,dword ptr [R14 + R12*0x4]
ANDPS XMM0,xmmword ptr [0x0018c390]
CVTSS2SD XMM0,XMM0
MOVSD XMM1,qword ptr [RSP + 0x10]
CALL 0x00120b70
MOVSD XMM1,qword ptr [RSP + 0x8]
ADDSD XMM1,XMM0
MOVSD qword ptr [RSP + 0x8],XMM1
MOVSD XMM0,qword ptr [RSP + 0x8]
INC R12
JMP 0x00127644
LAB_00127686:
MOVSD XMM1,qword ptr [0x0018c428]
DIVSD XMM1,qword ptr [RSP + 0x10]
CALL 0x00120b70
JMP 0x001276a0
LAB_0012769b:
CALL 0x00120580
LAB_001276a0:
MOVSD XMM1,qword ptr [0x0018c428]
DIVSD XMM1,XMM0
XORPD XMM2,XMM2
CMPLTSD XMM2,XMM0
ANDPD XMM2,XMM1
CVTSD2SS XMM0,XMM2
XOR EAX,EAX
LAB_001276bf:
CMP R15,RAX
JZ 0x001276d8
MOVSS XMM1,dword ptr [R14 + RAX*0x4]
MULSS XMM1,XMM0
MOVSS dword ptr [RBX + RAX*0x4],XMM1
INC RAX
JMP 0x001276bf
LAB_001276d8:
ADD RSP,0x18
POP RBX
POP R12
POP R14
POP R15
RET
|
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* common_embd_normalize(float const*, float*, int, int) */
void common_embd_normalize(float *param_1,float *param_2,int param_3,int param_4)
{
ulong uVar1;
ulong uVar2;
double dVar3;
double dVar4;
if (param_4 == 2) {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar3 = dVar3 + (double)(param_1[uVar1] * param_1[uVar1]);
}
if (dVar3 < 0.0) {
dVar3 = sqrt(dVar3);
}
else {
dVar3 = SQRT(dVar3);
}
}
else if (param_4 == 0) {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar4 = (double)(float)((uint)param_1[uVar1] & _DAT_0018c390);
if ((double)(float)((uint)param_1[uVar1] & _DAT_0018c390) <= dVar3) {
dVar4 = dVar3;
}
dVar3 = dVar4;
}
dVar3 = dVar3 / _DAT_0018c420;
}
else if (param_4 == -1) {
uVar2 = 0;
dVar3 = DAT_0018c428;
if (0 < param_3) {
uVar2 = (ulong)(uint)param_3;
}
}
else {
uVar1 = 0;
uVar2 = (ulong)(uint)param_3;
if (param_3 < 1) {
uVar2 = uVar1;
}
dVar3 = 0.0;
for (; uVar2 != uVar1; uVar1 = uVar1 + 1) {
dVar4 = pow((double)(float)((uint)param_1[uVar1] & _DAT_0018c390),(double)param_4);
dVar3 = dVar3 + dVar4;
}
dVar3 = pow(dVar3,DAT_0018c428 / (double)param_4);
}
dVar4 = DAT_0018c428 / dVar3;
for (uVar1 = 0; uVar2 != uVar1; uVar1 = uVar1 + 1) {
param_2[uVar1] = param_1[uVar1] * (float)(double)(-(ulong)(0.0 < dVar3) & (ulong)dVar4);
}
return;
}
|
|
7,764 |
js_std_cmd
|
bluesky950520[P]quickjs/quickjs.c
|
uintptr_t js_std_cmd(int cmd, ...) {
JSRuntime *rt;
uintptr_t rv;
va_list ap;
rv = 0;
va_start(ap, cmd);
switch (cmd) {
case 0: // GetOpaque
rt = va_arg(ap, JSRuntime *);
rv = (uintptr_t)rt->libc_opaque;
break;
case 1: // SetOpaque
rt = va_arg(ap, JSRuntime *);
rt->libc_opaque = va_arg(ap, void *);
break;
default:
rv = -1;
}
va_end(ap);
return rv;
}
|
O0
|
c
|
js_std_cmd:
subq $0xb8, %rsp
testb %al, %al
je 0x598b2
movaps %xmm0, (%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm3, 0x30(%rsp)
movaps %xmm4, 0x40(%rsp)
movaps %xmm5, 0x50(%rsp)
movaps %xmm6, 0x60(%rsp)
movaps %xmm7, 0x70(%rsp)
movq %r9, -0x8(%rsp)
movq %r8, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rsi, -0x28(%rsp)
movl %edi, 0xb4(%rsp)
movq $0x0, 0xa0(%rsp)
leaq -0x30(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x30, 0x84(%rsp)
movl $0x8, 0x80(%rsp)
movl 0xb4(%rsp), %eax
movl %eax, -0x34(%rsp)
testl %eax, %eax
je 0x59934
jmp 0x59922
movl -0x34(%rsp), %eax
subl $0x1, %eax
je 0x599b2
jmp 0x59a7f
leaq 0x80(%rsp), %rax
movq %rax, -0x40(%rsp)
movl 0x80(%rsp), %eax
movl %eax, -0x38(%rsp)
cmpl $0x28, %eax
ja 0x5996d
movq -0x40(%rsp), %rcx
movl -0x38(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x48(%rsp)
jmp 0x59986
movq -0x40(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq 0x218(%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x59a8b
leaq 0x80(%rsp), %rax
movq %rax, -0x58(%rsp)
movl 0x80(%rsp), %eax
movl %eax, -0x4c(%rsp)
cmpl $0x28, %eax
ja 0x599eb
movq -0x58(%rsp), %rcx
movl -0x4c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x60(%rsp)
jmp 0x59a04
movq -0x58(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x60(%rsp)
movq -0x60(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, -0x70(%rsp)
movl 0x80(%rsp), %eax
movl %eax, -0x64(%rsp)
cmpl $0x28, %eax
ja 0x59a4d
movq -0x70(%rsp), %rcx
movl -0x64(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x78(%rsp)
jmp 0x59a66
movq -0x70(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x78(%rsp)
movq -0x78(%rsp), %rax
movq (%rax), %rcx
movq 0xa8(%rsp), %rax
movq %rcx, 0x218(%rax)
jmp 0x59a8b
movq $-0x1, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
|
js_std_cmd:
sub rsp, 0B8h
test al, al
jz short loc_598B2
movaps [rsp+0B8h+var_B8], xmm0
movaps [rsp+0B8h+var_A8], xmm1
movaps [rsp+0B8h+var_98], xmm2
movaps [rsp+0B8h+var_88], xmm3
movaps [rsp+0B8h+var_78], xmm4
movaps [rsp+0B8h+var_68], xmm5
movaps [rsp+0B8h+var_58], xmm6
movaps [rsp+0B8h+var_48], xmm7
loc_598B2:
mov [rsp+0B8h+var_C0], r9
mov [rsp+0B8h+var_C8], r8
mov [rsp+0B8h+var_D0], rcx
mov [rsp+0B8h+var_D8], rdx
mov [rsp+0B8h+var_E0], rsi
mov [rsp+0B8h+var_4], edi
mov [rsp+0B8h+var_18], 0
lea rax, [rsp+0B8h+var_E8]
mov [rsp+0B8h+var_28], rax
lea rax, [rsp+0B8h+arg_0]
mov [rsp+0B8h+var_30], rax
mov [rsp+0B8h+var_34], 30h ; '0'
mov [rsp+0B8h+var_38], 8
mov eax, [rsp+0B8h+var_4]
mov [rsp+0B8h+var_EC], eax
test eax, eax
jz short loc_59934
jmp short $+2
loc_59922:
mov eax, [rsp+0B8h+var_EC]
sub eax, 1
jz loc_599B2
jmp loc_59A7F
loc_59934:
lea rax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_F8], rax
mov eax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_F0], eax
cmp eax, 28h ; '('
ja short loc_5996D
mov rcx, [rsp+0B8h+var_F8]
mov edx, [rsp+0B8h+var_F0]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rsp+0B8h+var_100], rax
jmp short loc_59986
loc_5996D:
mov rcx, [rsp+0B8h+var_F8]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rsp+0B8h+var_100], rax
loc_59986:
mov rax, [rsp+0B8h+var_100]
mov rax, [rax]
mov [rsp+0B8h+var_10], rax
mov rax, [rsp+0B8h+var_10]
mov rax, [rax+218h]
mov [rsp+0B8h+var_18], rax
jmp loc_59A8B
loc_599B2:
lea rax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_110], rax
mov eax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_104], eax
cmp eax, 28h ; '('
ja short loc_599EB
mov rcx, [rsp+0B8h+var_110]
mov edx, [rsp+0B8h+var_104]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rsp+0B8h+var_118], rax
jmp short loc_59A04
loc_599EB:
mov rcx, [rsp+0B8h+var_110]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rsp+0B8h+var_118], rax
loc_59A04:
mov rax, [rsp+0B8h+var_118]
mov rax, [rax]
mov [rsp+0B8h+var_10], rax
lea rax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_128], rax
mov eax, [rsp+0B8h+var_38]
mov [rsp+0B8h+var_11C], eax
cmp eax, 28h ; '('
ja short loc_59A4D
mov rcx, [rsp+0B8h+var_128]
mov edx, [rsp+0B8h+var_11C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rsp+0B8h+var_130], rax
jmp short loc_59A66
loc_59A4D:
mov rcx, [rsp+0B8h+var_128]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rsp+0B8h+var_130], rax
loc_59A66:
mov rax, [rsp+0B8h+var_130]
mov rcx, [rax]
mov rax, [rsp+0B8h+var_10]
mov [rax+218h], rcx
jmp short loc_59A8B
loc_59A7F:
mov [rsp+0B8h+var_18], 0FFFFFFFFFFFFFFFFh
loc_59A8B:
mov rax, [rsp+0B8h+var_18]
add rsp, 0B8h
retn
|
long long js_std_cmd(
int 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,
char a15)
{
long long *v15; // rax
long long *v16; // rax
char *v17; // rax
char v19; // [rsp+48h] [rbp-E8h] BYREF
long long v20; // [rsp+50h] [rbp-E0h]
long long v21; // [rsp+58h] [rbp-D8h]
long long v22; // [rsp+60h] [rbp-D0h]
long long v23; // [rsp+68h] [rbp-C8h]
long long v24; // [rsp+70h] [rbp-C0h]
__m128 v25; // [rsp+88h] [rbp-A8h]
__m128 v26; // [rsp+98h] [rbp-98h]
__m128 v27; // [rsp+A8h] [rbp-88h]
__m128 v28; // [rsp+B8h] [rbp-78h]
__m128 v29; // [rsp+C8h] [rbp-68h]
__m128 v30; // [rsp+D8h] [rbp-58h]
__m128 v31; // [rsp+E8h] [rbp-48h]
int v32; // [rsp+F8h] [rbp-38h]
int v33; // [rsp+FCh] [rbp-34h]
char *v34; // [rsp+100h] [rbp-30h]
char *v35; // [rsp+108h] [rbp-28h]
long long v36; // [rsp+118h] [rbp-18h]
long long v37; // [rsp+120h] [rbp-10h]
int v38; // [rsp+12Ch] [rbp-4h]
v20 = a2;
v21 = a3;
v22 = a4;
v23 = a5;
v24 = a6;
v25 = a8;
v26 = a9;
v27 = a10;
v28 = a11;
v29 = a12;
v30 = a13;
v31 = a14;
v38 = a1;
v36 = 0LL;
v35 = &v19;
v34 = &a15;
v33 = 48;
v32 = 8;
if ( a1 )
{
if ( a1 == 1 )
{
v16 = (long long *)&v35[v32];
v32 += 8;
v37 = *v16;
if ( (unsigned int)v32 > 0x28 )
{
v17 = v34;
v34 += 8;
}
else
{
v17 = &v35[v32];
v32 += 8;
}
*(_QWORD *)(v37 + 536) = *(_QWORD *)v17;
}
else
{
return -1LL;
}
}
else
{
v15 = (long long *)&v35[v32];
v32 += 8;
v37 = *v15;
return *(_QWORD *)(v37 + 536);
}
return v36;
}
|
js_std_cmd:
SUB RSP,0xb8
TEST AL,AL
JZ 0x001598b2
MOVAPS xmmword ptr [RSP],XMM0
MOVAPS xmmword ptr [RSP + 0x10],XMM1
MOVAPS xmmword ptr [RSP + 0x20],XMM2
MOVAPS xmmword ptr [RSP + 0x30],XMM3
MOVAPS xmmword ptr [RSP + 0x40],XMM4
MOVAPS xmmword ptr [RSP + 0x50],XMM5
MOVAPS xmmword ptr [RSP + 0x60],XMM6
MOVAPS xmmword ptr [RSP + 0x70],XMM7
LAB_001598b2:
MOV qword ptr [RSP + -0x8],R9
MOV qword ptr [RSP + -0x10],R8
MOV qword ptr [RSP + -0x18],RCX
MOV qword ptr [RSP + -0x20],RDX
MOV qword ptr [RSP + -0x28],RSI
MOV dword ptr [RSP + 0xb4],EDI
MOV qword ptr [RSP + 0xa0],0x0
LEA RAX,[RSP + -0x30]
MOV qword ptr [RSP + 0x90],RAX
LEA RAX,[RSP + 0xc0]
MOV qword ptr [RSP + 0x88],RAX
MOV dword ptr [RSP + 0x84],0x30
MOV dword ptr [RSP + 0x80],0x8
MOV EAX,dword ptr [RSP + 0xb4]
MOV dword ptr [RSP + -0x34],EAX
TEST EAX,EAX
JZ 0x00159934
JMP 0x00159922
LAB_00159922:
MOV EAX,dword ptr [RSP + -0x34]
SUB EAX,0x1
JZ 0x001599b2
JMP 0x00159a7f
LAB_00159934:
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + -0x40],RAX
MOV EAX,dword ptr [RSP + 0x80]
MOV dword ptr [RSP + -0x38],EAX
CMP EAX,0x28
JA 0x0015996d
MOV RCX,qword ptr [RSP + -0x40]
MOV EDX,dword ptr [RSP + -0x38]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RSP + -0x48],RAX
JMP 0x00159986
LAB_0015996d:
MOV RCX,qword ptr [RSP + -0x40]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RSP + -0x48],RAX
LAB_00159986:
MOV RAX,qword ptr [RSP + -0x48]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xa8],RAX
MOV RAX,qword ptr [RSP + 0xa8]
MOV RAX,qword ptr [RAX + 0x218]
MOV qword ptr [RSP + 0xa0],RAX
JMP 0x00159a8b
LAB_001599b2:
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + -0x58],RAX
MOV EAX,dword ptr [RSP + 0x80]
MOV dword ptr [RSP + -0x4c],EAX
CMP EAX,0x28
JA 0x001599eb
MOV RCX,qword ptr [RSP + -0x58]
MOV EDX,dword ptr [RSP + -0x4c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RSP + -0x60],RAX
JMP 0x00159a04
LAB_001599eb:
MOV RCX,qword ptr [RSP + -0x58]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RSP + -0x60],RAX
LAB_00159a04:
MOV RAX,qword ptr [RSP + -0x60]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0xa8],RAX
LEA RAX,[RSP + 0x80]
MOV qword ptr [RSP + -0x70],RAX
MOV EAX,dword ptr [RSP + 0x80]
MOV dword ptr [RSP + -0x64],EAX
CMP EAX,0x28
JA 0x00159a4d
MOV RCX,qword ptr [RSP + -0x70]
MOV EDX,dword ptr [RSP + -0x64]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RSP + -0x78],RAX
JMP 0x00159a66
LAB_00159a4d:
MOV RCX,qword ptr [RSP + -0x70]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RSP + -0x78],RAX
LAB_00159a66:
MOV RAX,qword ptr [RSP + -0x78]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RSP + 0xa8]
MOV qword ptr [RAX + 0x218],RCX
JMP 0x00159a8b
LAB_00159a7f:
MOV qword ptr [RSP + 0xa0],-0x1
LAB_00159a8b:
MOV RAX,qword ptr [RSP + 0xa0]
ADD RSP,0xb8
RET
|
/* WARNING: Removing unreachable block (ram,0x001599eb) */
/* WARNING: Removing unreachable block (ram,0x0015996d) */
/* WARNING: Removing unreachable block (ram,0x00159a4d) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xffffffffffffff20 : 0x0015998b */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8 js_std_cmd(int param_1)
{
long local_e0;
int8 local_d8;
int8 local_18;
if (param_1 == 0) {
local_18 = *(int8 *)(local_e0 + 0x218);
}
else if (param_1 == 1) {
local_18 = 0;
*(int8 *)(local_e0 + 0x218) = local_d8;
}
else {
local_18 = 0xffffffffffffffff;
}
return local_18;
}
|
|
7,765 |
js_std_cmd
|
bluesky950520[P]quickjs/quickjs.c
|
uintptr_t js_std_cmd(int cmd, ...) {
JSRuntime *rt;
uintptr_t rv;
va_list ap;
rv = 0;
va_start(ap, cmd);
switch (cmd) {
case 0: // GetOpaque
rt = va_arg(ap, JSRuntime *);
rv = (uintptr_t)rt->libc_opaque;
break;
case 1: // SetOpaque
rt = va_arg(ap, JSRuntime *);
rt->libc_opaque = va_arg(ap, void *);
break;
default:
rv = -1;
}
va_end(ap);
return rv;
}
|
O3
|
c
|
js_std_cmd:
subq $0x58, %rsp
leaq -0x60(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x3af7c
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %r10, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000008, %rax # imm = 0x3000000008
movq %rax, -0x80(%rsp)
cmpl $0x1, %edi
je 0x3afc9
movq $-0x1, %rax
testl %edi, %edi
jne 0x3b03f
movl -0x80(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x3affa
movq %rcx, %rax
addq -0x70(%rsp), %rax
addl $0x8, %ecx
movl %ecx, -0x80(%rsp)
jmp 0x3b008
movl -0x80(%rsp), %edx
cmpq $0x29, %rdx
jae 0x3b014
movq -0x70(%rsp), %rax
movq %rdx, %rcx
addq $0x8, %rcx
movl %ecx, -0x80(%rsp)
movq (%rax,%rdx), %rax
cmpl $0x20, %edx
ja 0x3b025
addq -0x70(%rsp), %rcx
addl $0x10, %edx
movl %edx, -0x80(%rsp)
jmp 0x3b033
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq 0x218(%rax), %rax
jmp 0x3b03f
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, -0x78(%rsp)
movq (%rcx), %rcx
movq %rcx, 0x218(%rax)
xorl %eax, %eax
addq $0x58, %rsp
retq
|
js_std_cmd:
sub rsp, 58h
lea r10, [rsp+58h+var_B8]
mov [r10+8], rsi
mov [r10+10h], rdx
mov [r10+18h], rcx
mov [r10+20h], r8
mov [r10+28h], r9
test al, al
jz short loc_3AF7C
movaps [rsp+58h+var_88], xmm0
movaps [rsp+58h+var_78], xmm1
movaps [rsp+58h+var_68], xmm2
movaps [rsp+58h+var_58], xmm3
movaps [rsp+58h+var_48], xmm4
movaps [rsp+58h+var_38], xmm5
movaps [rsp+58h+var_28], xmm6
movaps [rsp+58h+var_18], xmm7
loc_3AF7C:
mov [rsp+58h+var_C8], r10
lea rax, [rsp+58h+arg_0]
mov [rsp+58h+var_D0], rax
mov rax, 3000000008h
mov [rsp+58h+var_D8], rax
cmp edi, 1
jz short loc_3AFC9
mov rax, 0FFFFFFFFFFFFFFFFh
test edi, edi
jnz loc_3B03F
mov ecx, dword ptr [rsp+58h+var_D8]
cmp rcx, 28h ; '('
ja short loc_3AFFA
mov rax, rcx
add rax, [rsp+58h+var_C8]
add ecx, 8
mov dword ptr [rsp+58h+var_D8], ecx
jmp short loc_3B008
loc_3AFC9:
mov edx, dword ptr [rsp+58h+var_D8]
cmp rdx, 29h ; ')'
jnb short loc_3B014
mov rax, [rsp+58h+var_C8]
mov rcx, rdx
add rcx, 8
mov dword ptr [rsp+58h+var_D8], ecx
mov rax, [rax+rdx]
cmp edx, 20h ; ' '
ja short loc_3B025
add rcx, [rsp+58h+var_C8]
add edx, 10h
mov dword ptr [rsp+58h+var_D8], edx
jmp short loc_3B033
loc_3AFFA:
mov rax, [rsp+58h+var_D0]
lea rcx, [rax+8]
mov [rsp+58h+var_D0], rcx
loc_3B008:
mov rax, [rax]
mov rax, [rax+218h]
jmp short loc_3B03F
loc_3B014:
mov rax, [rsp+58h+var_D0]
lea rcx, [rax+8]
mov [rsp+58h+var_D0], rcx
mov rax, [rax]
loc_3B025:
mov rcx, [rsp+58h+var_D0]
lea rdx, [rcx+8]
mov [rsp+58h+var_D0], rdx
loc_3B033:
mov rcx, [rcx]
mov [rax+218h], rcx
xor eax, eax
loc_3B03F:
add rsp, 58h
retn
|
long long js_std_cmd(
int 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)
{
long long result; // rax
long long v15; // [rsp+28h] [rbp-B0h]
long long v16; // [rsp+30h] [rbp-A8h]
long long v17; // [rsp+38h] [rbp-A0h]
long long v18; // [rsp+40h] [rbp-98h]
long long v19; // [rsp+48h] [rbp-90h]
__m128 v20; // [rsp+50h] [rbp-88h]
__m128 v21; // [rsp+60h] [rbp-78h]
__m128 v22; // [rsp+70h] [rbp-68h]
__m128 v23; // [rsp+80h] [rbp-58h]
__m128 v24; // [rsp+90h] [rbp-48h]
__m128 v25; // [rsp+A0h] [rbp-38h]
__m128 v26; // [rsp+B0h] [rbp-28h]
v20 = a8;
v21 = a9;
v22 = a10;
v23 = a11;
v24 = a12;
v25 = a13;
v26 = a14;
v15 = a2;
v16 = a3;
v17 = a4;
v18 = a5;
v19 = a6;
if ( a1 == 1 )
{
*(_QWORD *)(v15 + 536) = v16;
return 0LL;
}
else
{
result = -1LL;
if ( !a1 )
return *(_QWORD *)(v15 + 536);
}
return result;
}
|
js_std_cmd:
SUB RSP,0x58
LEA R10,[RSP + -0x60]
MOV qword ptr [R10 + 0x8],RSI
MOV qword ptr [R10 + 0x10],RDX
MOV qword ptr [R10 + 0x18],RCX
MOV qword ptr [R10 + 0x20],R8
MOV qword ptr [R10 + 0x28],R9
TEST AL,AL
JZ 0x0013af7c
MOVAPS xmmword ptr [RSP + -0x30],XMM0
MOVAPS xmmword ptr [RSP + -0x20],XMM1
MOVAPS xmmword ptr [RSP + -0x10],XMM2
MOVAPS xmmword ptr [RSP],XMM3
MOVAPS xmmword ptr [RSP + 0x10],XMM4
MOVAPS xmmword ptr [RSP + 0x20],XMM5
MOVAPS xmmword ptr [RSP + 0x30],XMM6
MOVAPS xmmword ptr [RSP + 0x40],XMM7
LAB_0013af7c:
MOV qword ptr [RSP + -0x70],R10
LEA RAX,[RSP + 0x60]
MOV qword ptr [RSP + -0x78],RAX
MOV RAX,0x3000000008
MOV qword ptr [RSP + -0x80],RAX
CMP EDI,0x1
JZ 0x0013afc9
MOV RAX,-0x1
TEST EDI,EDI
JNZ 0x0013b03f
MOV ECX,dword ptr [RSP + -0x80]
CMP RCX,0x28
JA 0x0013affa
MOV RAX,RCX
ADD RAX,qword ptr [RSP + -0x70]
ADD ECX,0x8
MOV dword ptr [RSP + -0x80],ECX
JMP 0x0013b008
LAB_0013afc9:
MOV EDX,dword ptr [RSP + -0x80]
CMP RDX,0x29
JNC 0x0013b014
MOV RAX,qword ptr [RSP + -0x70]
MOV RCX,RDX
ADD RCX,0x8
MOV dword ptr [RSP + -0x80],ECX
MOV RAX,qword ptr [RAX + RDX*0x1]
CMP EDX,0x20
JA 0x0013b025
ADD RCX,qword ptr [RSP + -0x70]
ADD EDX,0x10
MOV dword ptr [RSP + -0x80],EDX
JMP 0x0013b033
LAB_0013affa:
MOV RAX,qword ptr [RSP + -0x78]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + -0x78],RCX
LAB_0013b008:
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x218]
JMP 0x0013b03f
LAB_0013b014:
MOV RAX,qword ptr [RSP + -0x78]
LEA RCX,[RAX + 0x8]
MOV qword ptr [RSP + -0x78],RCX
MOV RAX,qword ptr [RAX]
LAB_0013b025:
MOV RCX,qword ptr [RSP + -0x78]
LEA RDX,[RCX + 0x8]
MOV qword ptr [RSP + -0x78],RDX
LAB_0013b033:
MOV RCX,qword ptr [RCX]
MOV qword ptr [RAX + 0x218],RCX
XOR EAX,EAX
LAB_0013b03f:
ADD RSP,0x58
RET
|
/* WARNING: Removing unreachable block (ram,0x0013affa) */
/* WARNING: Removing unreachable block (ram,0x0013b014) */
/* WARNING: Removing unreachable block (ram,0x0013b025) */
/* WARNING: Heritage AFTER dead removal. Example location: s0xffffffffffffff50 : 0x0013b008 */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
int8 js_std_cmd(int param_1,long param_2)
{
int8 uVar1;
long local_b0;
int8 local_a8;
if (param_1 == 1) {
*(int8 *)(param_2 + 0x218) = local_a8;
uVar1 = 0;
}
else {
uVar1 = 0xffffffffffffffff;
if (param_1 == 0) {
uVar1 = *(int8 *)(local_b0 + 0x218);
}
}
return uVar1;
}
|
|
7,766 |
my_mb_wc_big5
|
eloqsql/strings/ctype-big5.c
|
static int
my_mb_wc_big5(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc,const uchar *s,const uchar *e)
{
int hi;
if (s >= e)
return MY_CS_TOOSMALL;
if ((hi= s[0]) < 0x80)
{
pwc[0]=hi;
return 1;
}
if (s+2>e)
return MY_CS_TOOSMALL2;
if (!IS_MB2_CHAR(hi, s[1]))
return MY_CS_ILSEQ;
if (!(pwc[0]=func_big5_uni_onechar((hi<<8)+s[1])))
return -2;
return 2;
}
|
O3
|
c
|
my_mb_wc_big5:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x65f9a
movsbq (%rdx), %rdi
testq %rdi, %rdi
js 0x65f64
movq %rdi, (%rsi)
movl $0x1, %eax
retq
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0x65f9a
leal 0x5f(%rdi), %ecx
xorl %eax, %eax
cmpb $0x58, %cl
ja 0x65f9a
movzbl 0x1(%rdx), %ecx
leal -0x7f(%rcx), %edx
cmpb $-0x3f, %dl
setb %dl
leal 0x1(%rcx), %r8d
cmpb $-0x5e, %r8b
setb %r8b
testb %r8b, %dl
je 0x65f9b
retq
pushq %rbp
movq %rsp, %rbp
movzbl %dil, %eax
shll $0x8, %eax
leal (%rax,%rcx), %edx
addl $0xffff5ec0, %edx # imm = 0xFFFF5EC0
cmpl $0x26bc, %edx # imm = 0x26BC
ja 0x65fc2
movl %edx, %eax
leaq 0x37670(%rip), %rcx # 0x9d630
jmp 0x65fd9
orl %ecx, %eax
addl $0xffff36c0, %eax # imm = 0xFFFF36C0
cmpl $0x309d, %eax # imm = 0x309D
jae 0x65ff2
movl %eax, %eax
leaq 0x3c3d7(%rip), %rcx # 0xa23b0
leaq (%rcx,%rax,2), %rax
movzwl (%rax), %eax
movzwl %ax, %ecx
movq %rcx, (%rsi)
movl $0x2, %eax
testw %cx, %cx
jne 0x65ffe
jmp 0x65ff9
movq $0x0, (%rsi)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
popq %rbp
retq
|
my_mb_wc_big5:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_65F9A
movsx rdi, byte ptr [rdx]
test rdi, rdi
js short loc_65F64
mov [rsi], rdi
mov eax, 1
retn
loc_65F64:
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja short locret_65F9A
lea ecx, [rdi+5Fh]
xor eax, eax
cmp cl, 58h ; 'X'
ja short locret_65F9A
movzx ecx, byte ptr [rdx+1]
lea edx, [rcx-7Fh]
cmp dl, 0C1h
setb dl
lea r8d, [rcx+1]
cmp r8b, 0A2h
setb r8b
test dl, r8b
jz short loc_65F9B
locret_65F9A:
retn
loc_65F9B:
push rbp
mov rbp, rsp
movzx eax, dil
shl eax, 8
lea edx, [rax+rcx]
add edx, 0FFFF5EC0h
cmp edx, 26BCh
ja short loc_65FC2
mov eax, edx
lea rcx, tab_big5_uni0
jmp short loc_65FD9
loc_65FC2:
or eax, ecx
add eax, 0FFFF36C0h
cmp eax, 309Dh
jnb short loc_65FF2
mov eax, eax
lea rcx, tab_big5_uni1
loc_65FD9:
lea rax, [rcx+rax*2]
movzx eax, word ptr [rax]
movzx ecx, ax
mov [rsi], rcx
mov eax, 2
test cx, cx
jnz short loc_65FFE
jmp short loc_65FF9
loc_65FF2:
mov qword ptr [rsi], 0
loc_65FF9:
mov eax, 0FFFFFFFEh
loc_65FFE:
pop rbp
retn
|
long long my_mb_wc_big5(long long a1, long long *a2, char *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rdi
int v6; // ecx
int v7; // eax
unsigned int v8; // edx
long long v9; // rax
unsigned __int16 *v10; // rcx
long long v11; // rcx
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
v5 = *a3;
if ( v5 >= 0 )
{
*a2 = v5;
return 1LL;
}
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
result = 0LL;
if ( (unsigned __int8)(v5 + 95) <= 0x58u )
{
v6 = (unsigned __int8)a3[1];
if ( (unsigned __int8)(v6 + 1) >= 0xA2u || (unsigned __int8)(v6 - 127) >= 0xC1u )
{
v7 = (unsigned __int8)v5 << 8;
v8 = v7 + v6 - 41280;
if ( v8 > 0x26BC )
{
LODWORD(v9) = (v6 | v7) - 51520;
if ( (unsigned int)v9 >= 0x309D )
{
*a2 = 0LL;
return 4294967294LL;
}
v9 = (unsigned int)v9;
v10 = (unsigned __int16 *)&tab_big5_uni1;
}
else
{
v9 = v8;
v10 = (unsigned __int16 *)&tab_big5_uni0;
}
v11 = v10[v9];
*a2 = v11;
result = 2LL;
if ( (_WORD)v11 )
return result;
return 4294967294LL;
}
}
}
}
return result;
}
|
my_mb_wc_big5:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00165f9a
MOVSX RDI,byte ptr [RDX]
TEST RDI,RDI
JS 0x00165f64
MOV qword ptr [RSI],RDI
MOV EAX,0x1
RET
LAB_00165f64:
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x00165f9a
LEA ECX,[RDI + 0x5f]
XOR EAX,EAX
CMP CL,0x58
JA 0x00165f9a
MOVZX ECX,byte ptr [RDX + 0x1]
LEA EDX,[RCX + -0x7f]
CMP DL,0xc1
SETC DL
LEA R8D,[RCX + 0x1]
CMP R8B,0xa2
SETC R8B
TEST DL,R8B
JZ 0x00165f9b
LAB_00165f9a:
RET
LAB_00165f9b:
PUSH RBP
MOV RBP,RSP
MOVZX EAX,DIL
SHL EAX,0x8
LEA EDX,[RAX + RCX*0x1]
ADD EDX,0xffff5ec0
CMP EDX,0x26bc
JA 0x00165fc2
MOV EAX,EDX
LEA RCX,[0x19d630]
JMP 0x00165fd9
LAB_00165fc2:
OR EAX,ECX
ADD EAX,0xffff36c0
CMP EAX,0x309d
JNC 0x00165ff2
MOV EAX,EAX
LEA RCX,[0x1a23b0]
LAB_00165fd9:
LEA RAX,[RCX + RAX*0x2]
MOVZX EAX,word ptr [RAX]
MOVZX ECX,AX
MOV qword ptr [RSI],RCX
MOV EAX,0x2
TEST CX,CX
JNZ 0x00165ffe
JMP 0x00165ff9
LAB_00165ff2:
MOV qword ptr [RSI],0x0
LAB_00165ff9:
MOV EAX,0xfffffffe
LAB_00165ffe:
POP RBP
RET
|
int8 my_mb_wc_big5(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
ushort uVar3;
int *puVar4;
uint uVar5;
if (param_4 <= param_3) {
return 0xffffff9b;
}
bVar1 = *param_3;
if (-1 < (long)(char)bVar1) {
*param_2 = (long)(char)bVar1;
return 1;
}
if (param_4 < param_3 + 2) {
return 0xffffff9a;
}
if ((byte)(bVar1 + 0x5f) < 0x59) {
bVar2 = param_3[1];
if ((byte)(bVar2 + 0x81) < 0xc1 && (byte)(bVar2 + 1) < 0xa2) {
return 0;
}
uVar5 = ((uint)bVar1 * 0x100 + (uint)bVar2) - 0xa140;
if (uVar5 < 0x26bd) {
puVar4 = &tab_big5_uni0;
}
else {
uVar5 = CONCAT11(bVar1,bVar2) - 0xc940;
if (0x309c < uVar5) {
*param_2 = 0;
return 0xfffffffe;
}
puVar4 = &tab_big5_uni1;
}
uVar3 = *(ushort *)(puVar4 + (ulong)uVar5 * 2);
*param_2 = (ulong)uVar3;
if (uVar3 == 0) {
return 0xfffffffe;
}
return 2;
}
return 0;
}
|
|
7,767 |
string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&)
|
llama.cpp/common/common.cpp
|
bool string_parse_kv_override(const char * data, std::vector<llama_model_kv_override> & overrides) {
const char * sep = strchr(data, '=');
if (sep == nullptr || sep - data >= 128) {
LOG_ERR("%s: malformed KV override '%s'\n", __func__, data);
return false;
}
llama_model_kv_override kvo;
std::strncpy(kvo.key, data, sep - data);
kvo.key[sep - data] = 0;
sep++;
if (strncmp(sep, "int:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_INT;
kvo.val_i64 = std::atol(sep);
} else if (strncmp(sep, "float:", 6) == 0) {
sep += 6;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_FLOAT;
kvo.val_f64 = std::atof(sep);
} else if (strncmp(sep, "bool:", 5) == 0) {
sep += 5;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_BOOL;
if (std::strcmp(sep, "true") == 0) {
kvo.val_bool = true;
} else if (std::strcmp(sep, "false") == 0) {
kvo.val_bool = false;
} else {
LOG_ERR("%s: invalid boolean value for KV override '%s'\n", __func__, data);
return false;
}
} else if (strncmp(sep, "str:", 4) == 0) {
sep += 4;
kvo.tag = LLAMA_KV_OVERRIDE_TYPE_STR;
if (strlen(sep) > 127) {
LOG_ERR("%s: malformed KV override '%s', value cannot exceed 127 chars\n", __func__, data);
return false;
}
strncpy(kvo.val_str, sep, 127);
kvo.val_str[127] = '\0';
} else {
LOG_ERR("%s: invalid type for KV override '%s'\n", __func__, data);
return false;
}
overrides.emplace_back(std::move(kvo));
return true;
}
|
O3
|
cpp
|
string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
movl $0x3d, %esi
callq 0x208e0
testq %rax, %rax
je 0xf85dc
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
cmpq $0x80, %r12
jl 0xf8618
leaq 0x6c355(%rip), %rax # 0x164938
cmpl $0x0, (%rax)
js 0xf87c4
callq 0x10d65b
leaq 0x2c4fb(%rip), %rdx # 0x124af3
leaq 0x2c514(%rip), %rcx # 0x124b13
xorl %ebp, %ebp
movq %rax, %rdi
movl $0x4, %esi
movq %rbx, %r8
xorl %eax, %eax
callq 0x10d6f8
jmp 0xf87c6
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x20200
movb $0x0, 0xc(%rsp,%r12)
leaq 0x1(%r15), %r12
leaq 0x2c4f3(%rip), %rsi # 0x124b2c
movl $0x4, %edx
movq %r12, %rdi
callq 0x203a0
testl %eax, %eax
je 0xf86bb
leaq 0x2c4e0(%rip), %rsi # 0x124b31
movl $0x6, %edx
movq %r12, %rdi
callq 0x203a0
testl %eax, %eax
je 0xf86d9
leaq 0x2c4cf(%rip), %rsi # 0x124b38
movl $0x5, %edx
movq %r12, %rdi
callq 0x203a0
testl %eax, %eax
je 0xf8734
leaq 0x2c4e9(%rip), %rsi # 0x124b6e
movl $0x4, %edx
movq %r12, %rdi
callq 0x203a0
testl %eax, %eax
je 0xf878b
leaq 0x6c297(%rip), %rax # 0x164938
cmpl $0x0, (%rax)
js 0xf87c4
callq 0x10d65b
leaq 0x2c4fc(%rip), %rdx # 0x124bb2
jmp 0xf85f8
addq $0x5, %r15
movl $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x20a10
movq %rax, 0x90(%rsp)
jmp 0xf86f6
addq $0x7, %r15
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x20e40
movsd %xmm0, 0x90(%rsp)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0xf871c
leaq 0x8(%rsp), %rsi
movl $0x108, %edx # imm = 0x108
movq %rax, %rdi
callq 0x200f0
addq $0x108, 0x8(%r14) # imm = 0x108
jmp 0xf872c
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xfb96e
movb $0x1, %bpl
jmp 0xf87c6
addq $0x6, %r15
movl $0x2, 0x8(%rsp)
leaq 0x1b19c(%rip), %rsi # 0x1138e3
movq %r15, %rdi
callq 0x20e50
testl %eax, %eax
je 0xf87d8
leaq 0x1e0b2(%rip), %rsi # 0x116810
movq %r15, %rdi
callq 0x20e50
testl %eax, %eax
je 0xf8806
leaq 0x6c1c3(%rip), %rax # 0x164938
cmpl $0x0, (%rax)
js 0xf87c4
callq 0x10d65b
leaq 0x2c3b8(%rip), %rdx # 0x124b3e
jmp 0xf85f8
addq $0x5, %r15
movl $0x3, 0x8(%rsp)
movq %r15, %rdi
callq 0x20680
cmpq $0x80, %rax
jb 0xf87e5
leaq 0x6c18a(%rip), %rax # 0x164938
cmpl $0x0, (%rax)
js 0xf87c4
callq 0x10d65b
leaq 0x2c3b4(%rip), %rdx # 0x124b73
jmp 0xf85f8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x110, %rsp # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, 0x90(%rsp)
jmp 0xf86f6
leaq 0x90(%rsp), %rbx
movl $0x7f, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20200
movb $0x0, 0x7f(%rbx)
jmp 0xf86f6
movb $0x0, 0x90(%rsp)
jmp 0xf86f6
|
_Z24string_parse_kv_overridePKcRSt6vectorI23llama_model_kv_overrideSaIS2_EE:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 110h
mov r14, rsi
mov rbx, rdi
mov esi, 3Dh ; '='
call _strchr
test rax, rax
jz short loc_F85DC
mov r15, rax
mov r12, rax
sub r12, rbx
cmp r12, 80h
jl short loc_F8618
loc_F85DC:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_F87C4
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
loc_F85F8:
lea rcx, aStringParseKvO; "string_parse_kv_override"
xor ebp, ebp
mov rdi, rax
mov esi, 4
mov r8, rbx
xor eax, eax
call _Z14common_log_addP10common_log14ggml_log_levelPKcz; common_log_add(common_log *,ggml_log_level,char const*,...)
jmp loc_F87C6
loc_F8618:
lea rdi, [rsp+138h+var_12C]
mov rsi, rbx
mov rdx, r12
call _strncpy
mov [rsp+r12+138h+var_12C], 0
lea r12, [r15+1]
lea rsi, aInt; "int:"
mov edx, 4
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_F86BB
lea rsi, aFloat_0; "float:"
mov edx, 6
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_F86D9
lea rsi, aBool; "bool:"
mov edx, 5
mov rdi, r12
call _strncmp
test eax, eax
jz loc_F8734
lea rsi, aStr; "str:"
mov edx, 4
mov rdi, r12
call _strncmp
test eax, eax
jz loc_F878B
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_F87C4
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
jmp loc_F85F8
loc_F86BB:
add r15, 5
mov [rsp+138h+var_130], 0
mov rdi, r15
call _atol
mov [rsp+138h+var_A8], rax
jmp short loc_F86F6
loc_F86D9:
add r15, 7
mov [rsp+138h+var_130], 1
mov rdi, r15
call _atof
movsd [rsp+138h+var_A8], xmm0
loc_F86F6:
mov rax, [r14+8]
cmp rax, [r14+10h]
jz short loc_F871C
lea rsi, [rsp+138h+var_130]
mov edx, 108h
mov rdi, rax
call _memcpy
add qword ptr [r14+8], 108h
jmp short loc_F872C
loc_F871C:
lea rdx, [rsp+138h+var_130]
mov rdi, r14
mov rsi, rax
call _ZNSt6vectorI23llama_model_kv_overrideSaIS0_EE17_M_realloc_insertIJS0_EEEvN9__gnu_cxx17__normal_iteratorIPS0_S2_EEDpOT_; std::vector<llama_model_kv_override>::_M_realloc_insert<llama_model_kv_override>(__gnu_cxx::__normal_iterator<llama_model_kv_override*,std::vector<llama_model_kv_override>>,llama_model_kv_override &&)
loc_F872C:
mov bpl, 1
jmp loc_F87C6
loc_F8734:
add r15, 6
mov [rsp+138h+var_130], 2
lea rsi, aTrue; "true"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_F87D8
lea rsi, aAdvancedOption+0ABh; "false"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_F8806
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_F87C4
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
jmp loc_F85F8
loc_F878B:
add r15, 5
mov [rsp+138h+var_130], 3
mov rdi, r15
call _strlen
cmp rax, 80h
jb short loc_F87E5
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_F87C4
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
jmp loc_F85F8
loc_F87C4:
xor ebp, ebp
loc_F87C6:
mov eax, ebp
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_F87D8:
mov byte ptr [rsp+138h+var_A8], 1
jmp loc_F86F6
loc_F87E5:
lea rbx, [rsp+138h+var_A8]
mov edx, 7Fh
mov rdi, rbx
mov rsi, r15
call _strncpy
mov byte ptr [rbx+7Fh], 0
jmp loc_F86F6
loc_F8806:
mov byte ptr [rsp+138h+var_A8], 0
jmp loc_F86F6
|
long long string_parse_kv_override(long long a1, long long a2)
{
unsigned int v2; // ebp
long long v3; // rax
long long v4; // r15
long long v5; // r12
int v6; // eax
int v7; // r9d
const char *v8; // rdx
long long v9; // r15
long long v10; // r15
int v12; // [rsp+8h] [rbp-130h] BYREF
_BYTE v13[132]; // [rsp+Ch] [rbp-12Ch] BYREF
long long v14[15]; // [rsp+90h] [rbp-A8h] BYREF
char v15; // [rsp+10Fh] [rbp-29h]
v3 = strchr(a1, 61LL);
if ( !v3 || (v4 = v3, v5 = v3 - a1, v3 - a1 >= 128) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s'\n";
LABEL_5:
v2 = 0;
common_log_add(v6, 4, (_DWORD)v8, (unsigned int)"string_parse_kv_override", a1, v7);
return v2;
}
return 0;
}
strncpy(v13, a1, v3 - a1);
v13[v5] = 0;
if ( !(unsigned int)strncmp(v4 + 1, "int:", 4LL) )
{
v12 = 0;
v14[0] = atol(v4 + 5);
}
else if ( !(unsigned int)strncmp(v4 + 1, "float:", 6LL) )
{
v12 = 1;
v14[0] = atof(v4 + 7);
}
else if ( !(unsigned int)strncmp(v4 + 1, "bool:", 5LL) )
{
v9 = v4 + 6;
v12 = 2;
if ( !(unsigned int)strcmp(v9, "true") )
{
LOBYTE(v14[0]) = 1;
}
else
{
if ( (unsigned int)strcmp(v9, "false") )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid boolean value for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
LOBYTE(v14[0]) = 0;
}
}
else
{
if ( (unsigned int)strncmp(v4 + 1, "str:", 4LL) )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: invalid type for KV override '%s'\n";
goto LABEL_5;
}
return 0;
}
v10 = v4 + 5;
v12 = 3;
if ( (unsigned long long)strlen(v10) >= 0x80 )
{
if ( common_log_verbosity_thold >= 0 )
{
v6 = common_log_main();
v8 = "%s: malformed KV override '%s', value cannot exceed 127 chars\n";
goto LABEL_5;
}
return 0;
}
strncpy(v14, v10, 127LL);
v15 = 0;
}
if ( *(_QWORD *)(a2 + 8) == *(_QWORD *)(a2 + 16) )
{
std::vector<llama_model_kv_override>::_M_realloc_insert<llama_model_kv_override>(a2, *(_QWORD *)(a2 + 8), &v12);
}
else
{
memcpy(*(_QWORD *)(a2 + 8), &v12, 264LL);
*(_QWORD *)(a2 + 8) += 264LL;
}
LOBYTE(v2) = 1;
return v2;
}
|
string_parse_kv_override:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x110
MOV R14,RSI
MOV RBX,RDI
MOV ESI,0x3d
CALL 0x001208e0
TEST RAX,RAX
JZ 0x001f85dc
MOV R15,RAX
MOV R12,RAX
SUB R12,RBX
CMP R12,0x80
JL 0x001f8618
LAB_001f85dc:
LEA RAX,[0x264938]
CMP dword ptr [RAX],0x0
JS 0x001f87c4
CALL 0x0020d65b
LEA RDX,[0x224af3]
LAB_001f85f8:
LEA RCX,[0x224b13]
XOR EBP,EBP
MOV RDI,RAX
MOV ESI,0x4
MOV R8,RBX
XOR EAX,EAX
CALL 0x0020d6f8
JMP 0x001f87c6
LAB_001f8618:
LEA RDI,[RSP + 0xc]
MOV RSI,RBX
MOV RDX,R12
CALL 0x00120200
MOV byte ptr [RSP + R12*0x1 + 0xc],0x0
LEA R12,[R15 + 0x1]
LEA RSI,[0x224b2c]
MOV EDX,0x4
MOV RDI,R12
CALL 0x001203a0
TEST EAX,EAX
JZ 0x001f86bb
LEA RSI,[0x224b31]
MOV EDX,0x6
MOV RDI,R12
CALL 0x001203a0
TEST EAX,EAX
JZ 0x001f86d9
LEA RSI,[0x224b38]
MOV EDX,0x5
MOV RDI,R12
CALL 0x001203a0
TEST EAX,EAX
JZ 0x001f8734
LEA RSI,[0x224b6e]
MOV EDX,0x4
MOV RDI,R12
CALL 0x001203a0
TEST EAX,EAX
JZ 0x001f878b
LEA RAX,[0x264938]
CMP dword ptr [RAX],0x0
JS 0x001f87c4
CALL 0x0020d65b
LEA RDX,[0x224bb2]
JMP 0x001f85f8
LAB_001f86bb:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x0
MOV RDI,R15
CALL 0x00120a10
MOV qword ptr [RSP + 0x90],RAX
JMP 0x001f86f6
LAB_001f86d9:
ADD R15,0x7
MOV dword ptr [RSP + 0x8],0x1
MOV RDI,R15
CALL 0x00120e40
MOVSD qword ptr [RSP + 0x90],XMM0
LAB_001f86f6:
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [R14 + 0x10]
JZ 0x001f871c
LEA RSI,[RSP + 0x8]
MOV EDX,0x108
MOV RDI,RAX
CALL 0x001200f0
ADD qword ptr [R14 + 0x8],0x108
JMP 0x001f872c
LAB_001f871c:
LEA RDX,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
CALL 0x001fb96e
LAB_001f872c:
MOV BPL,0x1
JMP 0x001f87c6
LAB_001f8734:
ADD R15,0x6
MOV dword ptr [RSP + 0x8],0x2
LEA RSI,[0x2138e3]
MOV RDI,R15
CALL 0x00120e50
TEST EAX,EAX
JZ 0x001f87d8
LEA RSI,[0x216810]
MOV RDI,R15
CALL 0x00120e50
TEST EAX,EAX
JZ 0x001f8806
LEA RAX,[0x264938]
CMP dword ptr [RAX],0x0
JS 0x001f87c4
CALL 0x0020d65b
LEA RDX,[0x224b3e]
JMP 0x001f85f8
LAB_001f878b:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x3
MOV RDI,R15
CALL 0x00120680
CMP RAX,0x80
JC 0x001f87e5
LEA RAX,[0x264938]
CMP dword ptr [RAX],0x0
JS 0x001f87c4
CALL 0x0020d65b
LEA RDX,[0x224b73]
JMP 0x001f85f8
LAB_001f87c4:
XOR EBP,EBP
LAB_001f87c6:
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_001f87d8:
MOV byte ptr [RSP + 0x90],0x1
JMP 0x001f86f6
LAB_001f87e5:
LEA RBX,[RSP + 0x90]
MOV EDX,0x7f
MOV RDI,RBX
MOV RSI,R15
CALL 0x00120200
MOV byte ptr [RBX + 0x7f],0x0
JMP 0x001f86f6
LAB_001f8806:
MOV byte ptr [RSP + 0x90],0x0
JMP 0x001f86f6
|
/* string_parse_kv_override(char const*, std::vector<llama_model_kv_override,
std::allocator<llama_model_kv_override> >&) */
ulong string_parse_kv_override(char *param_1,vector *param_2)
{
char *__s1;
void *__dest;
int iVar1;
char *pcVar2;
int8 uVar3;
int8 unaff_RBP;
ulong uVar4;
size_t sVar5;
int4 local_130;
char local_12c [132];
double local_a8 [15];
int1 local_29;
pcVar2 = strchr(param_1,0x3d);
if ((pcVar2 == (char *)0x0) || (sVar5 = (long)pcVar2 - (long)param_1, 0x7f < (long)sVar5)) {
if (common_log_verbosity_thold < 0) goto LAB_001f87c4;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\'\n";
goto LAB_001f85f8;
}
strncpy(local_12c,param_1,sVar5);
local_12c[sVar5] = '\0';
__s1 = pcVar2 + 1;
iVar1 = strncmp(__s1,"int:",4);
if (iVar1 == 0) {
local_130 = 0;
local_a8[0] = (double)atol(pcVar2 + 5);
}
else {
iVar1 = strncmp(__s1,"float:",6);
if (iVar1 == 0) {
local_130 = 1;
local_a8[0] = atof(pcVar2 + 7);
}
else {
iVar1 = strncmp(__s1,"bool:",5);
if (iVar1 != 0) {
iVar1 = strncmp(__s1,"str:",4);
if (iVar1 == 0) {
local_130 = 3;
sVar5 = strlen(pcVar2 + 5);
if (sVar5 < 0x80) {
strncpy((char *)local_a8,pcVar2 + 5,0x7f);
local_29 = 0;
goto LAB_001f86f6;
}
if (common_log_verbosity_thold < 0) goto LAB_001f87c4;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\', value cannot exceed 127 chars\n";
}
else {
if (common_log_verbosity_thold < 0) {
LAB_001f87c4:
uVar4 = 0;
goto LAB_001f87c6;
}
uVar3 = common_log_main();
pcVar2 = "%s: invalid type for KV override \'%s\'\n";
}
LAB_001f85f8:
uVar4 = 0;
common_log_add(uVar3,4,pcVar2,"string_parse_kv_override",param_1);
goto LAB_001f87c6;
}
local_130 = 2;
iVar1 = strcmp(pcVar2 + 6,"true");
if (iVar1 == 0) {
local_a8[0] = (double)CONCAT71(local_a8[0]._1_7_,1);
}
else {
iVar1 = strcmp(pcVar2 + 6,"false");
if (iVar1 != 0) {
if (common_log_verbosity_thold < 0) goto LAB_001f87c4;
uVar3 = common_log_main();
pcVar2 = "%s: invalid boolean value for KV override \'%s\'\n";
goto LAB_001f85f8;
}
local_a8[0] = (double)((ulong)local_a8[0] & 0xffffffffffffff00);
}
}
}
LAB_001f86f6:
__dest = *(void **)(param_2 + 8);
if (__dest == *(void **)(param_2 + 0x10)) {
std::vector<llama_model_kv_override,std::allocator<llama_model_kv_override>>::
_M_realloc_insert<llama_model_kv_override>
((vector<llama_model_kv_override,std::allocator<llama_model_kv_override>> *)param_2,
__dest,&local_130);
}
else {
memcpy(__dest,&local_130,0x108);
*(long *)(param_2 + 8) = *(long *)(param_2 + 8) + 0x108;
}
uVar4 = CONCAT71((int7)((ulong)unaff_RBP >> 8),1);
LAB_001f87c6:
return uVar4 & 0xffffffff;
}
|
|
7,768 |
madb_get_os_character_set
|
eloqsql/libmariadb/libmariadb/ma_charset.c
|
const char *madb_get_os_character_set()
{
unsigned int i= 0;
char *p= NULL;
#ifdef _WIN32
char codepage[FN_REFLEN];
snprintf(codepage, FN_REFLEN, "%u", GetConsoleCP() ? GetConsoleCP() : GetACP());
p= codepage;
#elif defined(HAVE_NL_LANGINFO) && defined(HAVE_SETLOCALE)
if (setlocale(LC_CTYPE, ""))
p= nl_langinfo(CODESET);
#endif
if (!p)
return MADB_DEFAULT_CHARSET_NAME;
while (MADB_OS_CHARSET[i].identifier)
{
if (MADB_OS_CHARSET[i].supported > MADB_CS_UNSUPPORTED &&
strcasecmp(MADB_OS_CHARSET[i].identifier, p) == 0)
return MADB_OS_CHARSET[i].charset;
i++;
}
return MADB_DEFAULT_CHARSET_NAME;
}
|
O3
|
c
|
madb_get_os_character_set:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x56b0(%rip), %rsi # 0x3a208
xorl %edi, %edi
callq 0x133e0
leaq 0x5707(%rip), %rbx # 0x3a26d
testq %rax, %rax
je 0x34bcb
movl $0xe, %edi
callq 0x13450
movq %rax, %r14
testq %rax, %rax
sete %al
leaq 0x1a9bb(%rip), %r15 # 0x4f540
movq (%r15), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x34bcb
movl $0x1, %r12d
movq %r15, %r13
cmpb $0x0, 0x20(%r13)
je 0x34bae
movq %r14, %rsi
callq 0x134e0
testl %eax, %eax
je 0x34bc7
movl %r12d, %eax
leaq (%rax,%rax,4), %rax
leaq (%r15,%rax,8), %r13
movq (%r13), %rdi
incl %r12d
testq %rdi, %rdi
jne 0x34b9b
jmp 0x34bcb
movq 0x10(%r13), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
madb_get_os_character_set:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
lea rsi, aDDD+12h; ""
xor edi, edi
call _setlocale
lea rbx, aCreateTableCon+48h; "latin1"
test rax, rax
jz short loc_34BCB
mov edi, 0Eh
call _nl_langinfo
mov r14, rax
test rax, rax
setz al
lea r15, MADB_OS_CHARSET
mov rdi, [r15]
test rdi, rdi
setz cl
or cl, al
jnz short loc_34BCB
mov r12d, 1
mov r13, r15
loc_34B9B:
cmp byte ptr [r13+20h], 0
jz short loc_34BAE
mov rsi, r14
call _strcasecmp
test eax, eax
jz short loc_34BC7
loc_34BAE:
mov eax, r12d
lea rax, [rax+rax*4]
lea r13, [r15+rax*8]
mov rdi, [r13+0]
inc r12d
test rdi, rdi
jnz short loc_34B9B
jmp short loc_34BCB
loc_34BC7:
mov rbx, [r13+10h]
loc_34BCB:
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
char *madb_get_os_character_set()
{
char *v0; // rbx
long long v1; // r14
void *v2; // rdi
unsigned int v3; // r12d
_UNKNOWN **v4; // r13
v0 = "latin1";
if ( setlocale(0LL, "") )
{
v1 = nl_langinfo(14LL);
v2 = MADB_OS_CHARSET;
if ( v1 != 0 && MADB_OS_CHARSET != 0LL )
{
v3 = 1;
v4 = &MADB_OS_CHARSET;
while ( !*((_BYTE *)v4 + 32) || (unsigned int)strcasecmp(v2, v1) )
{
v4 = &MADB_OS_CHARSET + 5 * v3;
v2 = *v4;
++v3;
if ( !*v4 )
return v0;
}
return (char *)v4[2];
}
}
return v0;
}
|
madb_get_os_character_set:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
LEA RSI,[0x13a208]
XOR EDI,EDI
CALL 0x001133e0
LEA RBX,[0x13a26d]
TEST RAX,RAX
JZ 0x00134bcb
MOV EDI,0xe
CALL 0x00113450
MOV R14,RAX
TEST RAX,RAX
SETZ AL
LEA R15,[0x14f540]
MOV RDI,qword ptr [R15]
TEST RDI,RDI
SETZ CL
OR CL,AL
JNZ 0x00134bcb
MOV R12D,0x1
MOV R13,R15
LAB_00134b9b:
CMP byte ptr [R13 + 0x20],0x0
JZ 0x00134bae
MOV RSI,R14
CALL 0x001134e0
TEST EAX,EAX
JZ 0x00134bc7
LAB_00134bae:
MOV EAX,R12D
LEA RAX,[RAX + RAX*0x4]
LEA R13,[R15 + RAX*0x8]
MOV RDI,qword ptr [R13]
INC R12D
TEST RDI,RDI
JNZ 0x00134b9b
JMP 0x00134bcb
LAB_00134bc7:
MOV RBX,qword ptr [R13 + 0x10]
LAB_00134bcb:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
char * madb_get_os_character_set(void)
{
int iVar1;
char *pcVar2;
char *__s1;
ulong uVar3;
int **ppuVar4;
pcVar2 = setlocale(0,"");
if ((pcVar2 != (char *)0x0) &&
(pcVar2 = nl_langinfo(0xe), MADB_OS_CHARSET != (int *)0x0 && pcVar2 != (char *)0x0)) {
uVar3 = 1;
ppuVar4 = &MADB_OS_CHARSET;
__s1 = MADB_OS_CHARSET;
do {
if ((*(char *)(ppuVar4 + 4) != '\0') && (iVar1 = strcasecmp(__s1,pcVar2), iVar1 == 0)) {
return ppuVar4[2];
}
ppuVar4 = &MADB_OS_CHARSET + uVar3 * 5;
__s1 = *ppuVar4;
uVar3 = (ulong)((int)uVar3 + 1);
} while (__s1 != (char *)0x0);
}
return "latin1";
}
|
|
7,769 |
flux::parser::GetExpr::clone() const
|
kvthweatt[P]FluxLang/src/parser/ast.cpp
|
std::unique_ptr<Expr> GetExpr::clone() const {
return std::make_unique<GetExpr>(object->clone(), name, range);
}
|
O1
|
cpp
|
flux::parser::GetExpr::clone() const:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x28(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movl $0x90, %edi
callq 0x6270
movq %rax, %r14
leaq 0x8(%r15), %rcx
addq $0x30, %r15
movq (%rsp), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r15, %rdx
callq 0x129fe
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd6cc
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd6de
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xd6fe
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl $0x90, %esi
movq %r14, %rdi
callq 0x6280
jmp 0xd719
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xd728
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x6440
|
_ZNK4flux6parser7GetExpr5cloneEv:
push r15
push r14
push rbx
sub rsp, 10h
mov r15, rsi
mov rbx, rdi
mov rsi, [rsi+28h]
mov rax, [rsi]
mov rdi, rsp
call qword ptr [rax+18h]
mov edi, 90h; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
lea rcx, [r15+8]
add r15, 30h ; '0'
mov rax, [rsp+28h+var_28]
lea rsi, [rsp+28h+var_20]
mov [rsi], rax
mov [rsp+28h+var_28], 0
mov rdi, r14
mov rdx, r15
call _ZN4flux6parser7GetExprC2ESt10unique_ptrINS0_4ExprESt14default_deleteIS3_EERKNS_5lexer5TokenERKNS_6common11SourceRangeE; flux::parser::GetExpr::GetExpr(std::unique_ptr<flux::parser::Expr>,flux::lexer::Token const&,flux::common::SourceRange const&)
mov rdi, [rsp+28h+var_20]
test rdi, rdi
jz short loc_D6CC
mov rax, [rdi]
call qword ptr [rax+8]
loc_D6CC:
mov [rbx], r14
mov rdi, [rsp+28h+var_28]
test rdi, rdi
jz short loc_D6DE
mov rax, [rdi]
call qword ptr [rax+8]
loc_D6DE:
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
mov rdi, [rsp+arg_0]
test rdi, rdi
jz short loc_D6FE
mov rax, [rdi]
call qword ptr [rax+8]
loc_D6FE:
mov [rsp+arg_0], 0
mov esi, 90h; unsigned __int64
mov rdi, r14; void *
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_D719
mov rbx, rax
loc_D719:
mov rdi, [rsp+0]
test rdi, rdi
jz short loc_D728
mov rax, [rdi]
call qword ptr [rax+8]
loc_D728:
mov rdi, rbx
call __Unwind_Resume
|
flux::parser::GetExpr * flux::parser::GetExpr::clone(flux::parser::GetExpr *this, long long a2)
{
long long v2; // r14
long long v4; // [rsp+0h] [rbp-28h] BYREF
_QWORD v5[4]; // [rsp+8h] [rbp-20h] BYREF
(*(void ( **)(long long *))(**(_QWORD **)(a2 + 40) + 24LL))(&v4);
v2 = operator new(0x90uLL);
v5[0] = v4;
v4 = 0LL;
flux::parser::GetExpr::GetExpr(v2, v5, a2 + 48, a2 + 8);
if ( v5[0] )
(*(void ( **)(_QWORD))(*(_QWORD *)v5[0] + 8LL))(v5[0]);
*(_QWORD *)this = v2;
if ( v4 )
(*(void ( **)(long long))(*(_QWORD *)v4 + 8LL))(v4);
return this;
}
|
clone:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV R15,RSI
MOV RBX,RDI
MOV RSI,qword ptr [RSI + 0x28]
MOV RAX,qword ptr [RSI]
MOV RDI,RSP
CALL qword ptr [RAX + 0x18]
LAB_0010d688:
MOV EDI,0x90
CALL 0x00106270
MOV R14,RAX
LEA RCX,[R15 + 0x8]
ADD R15,0x30
MOV RAX,qword ptr [RSP]
LEA RSI,[RSP + 0x8]
MOV qword ptr [RSI],RAX
MOV qword ptr [RSP],0x0
LAB_0010d6b1:
MOV RDI,R14
MOV RDX,R15
CALL 0x001129fe
LAB_0010d6bc:
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x0010d6cc
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010d6cc:
MOV qword ptr [RBX],R14
MOV RDI,qword ptr [RSP]
TEST RDI,RDI
JZ 0x0010d6de
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x8]
LAB_0010d6de:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP R15
RET
|
/* flux::parser::GetExpr::clone() const */
void flux::parser::GetExpr::clone(void)
{
GetExpr *pGVar1;
long in_RSI;
int8 *in_RDI;
long *local_28;
long *local_20;
(**(code **)(**(long **)(in_RSI + 0x28) + 0x18))(&local_28);
/* try { // try from 0010d688 to 0010d691 has its CatchHandler @ 0010d716 */
pGVar1 = (GetExpr *)operator_new(0x90);
local_20 = local_28;
local_28 = (long *)0x0;
/* try { // try from 0010d6b1 to 0010d6bb has its CatchHandler @ 0010d6eb */
GetExpr(pGVar1,&local_20,in_RSI + 0x30,in_RSI + 8);
if (local_20 != (long *)0x0) {
(**(code **)(*local_20 + 8))();
}
*in_RDI = pGVar1;
if (local_28 != (long *)0x0) {
(**(code **)(*local_28 + 8))();
}
return;
}
|
|
7,770 |
llama_data_write::write_model_info(llama_context const*)
|
monkey531[P]llama/src/llama-context.cpp
|
void write_model_info(const struct llama_context * ctx) {
const std::string arch_str = llm_arch_name(ctx->model.arch);
write_string(arch_str);
// TODO: add more model-specific info which should prevent loading the session file if not identical
}
|
O3
|
cpp
|
llama_data_write::write_model_info(llama_context const*):
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movl 0x4(%rax), %edi
callq 0x68840
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x6b1d0
movl 0x8(%r14), %eax
movl %eax, (%r15)
movq (%rbx), %rax
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq *(%rax)
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa02fe
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x681a0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa0326
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x681a0
movq %rbx, %rdi
callq 0x6b5d0
|
_ZN16llama_data_write16write_model_infoEPK13llama_context:
push r15
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
mov rax, [rsi]
mov edi, [rax+4]
call __Z13llm_arch_name8llm_arch; llm_arch_name(llm_arch)
lea r14, [rsp+48h+var_38]
lea r15, [rsp+48h+var_3C]
mov rdi, r14
mov rsi, rax
mov rdx, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov eax, [r14+8]
mov [r15], eax
mov rax, [rbx]
lea rsi, [rsp+48h+var_3C]
mov edx, 4
mov rdi, rbx
call qword ptr [rax]
mov rsi, [rsp+48h+var_38]
mov edx, [rsp+48h+var_3C]
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax]
lea rax, [rsp+48h+var_28]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A02FE
mov rsi, [rsp+48h+var_28]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A02FE:
add rsp, 30h
pop rbx
pop r14
pop r15
retn
mov rbx, rax
lea rax, [rsp+arg_18]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_A0326
mov rsi, [rsp+arg_18]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_A0326:
mov rdi, rbx
call __Unwind_Resume
|
void llama_data_write::write_model_info(llama_data_write *this, const llama_context *a2)
{
const char *v3; // rax
unsigned int v4; // [rsp+Ch] [rbp-3Ch] BYREF
long long *v5; // [rsp+10h] [rbp-38h] BYREF
unsigned int v6; // [rsp+18h] [rbp-30h]
long long v7; // [rsp+20h] [rbp-28h] BYREF
v3 = llm_arch_name(*(_DWORD *)(*(_QWORD *)a2 + 4LL));
std::string::basic_string<std::allocator<char>>(&v5, v3, &v4);
v4 = v6;
(**(void ( ***)(llama_data_write *, unsigned int *, long long))this)(this, &v4, 4LL);
(**(void ( ***)(llama_data_write *, long long *, _QWORD))this)(this, v5, v4);
if ( v5 != &v7 )
operator delete(v5, v7 + 1);
}
|
write_model_info:
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
MOV RAX,qword ptr [RSI]
MOV EDI,dword ptr [RAX + 0x4]
CALL 0x00168840
LEA R14,[RSP + 0x10]
LEA R15,[RSP + 0xc]
MOV RDI,R14
MOV RSI,RAX
MOV RDX,R15
CALL 0x0016b1d0
MOV EAX,dword ptr [R14 + 0x8]
MOV dword ptr [R15],EAX
MOV RAX,qword ptr [RBX]
LAB_001a02c3:
LEA RSI,[RSP + 0xc]
MOV EDX,0x4
MOV RDI,RBX
CALL qword ptr [RAX]
MOV RSI,qword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX]
LAB_001a02e3:
LEA RAX,[RSP + 0x20]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x001a02fe
MOV RSI,qword ptr [RSP + 0x20]
INC RSI
CALL 0x001681a0
LAB_001a02fe:
ADD RSP,0x30
POP RBX
POP R14
POP R15
RET
|
/* llama_data_write::write_model_info(llama_context const*) */
void __thiscall llama_data_write::write_model_info(llama_data_write *this,llama_context *param_1)
{
char *pcVar1;
int4 local_3c;
long *local_38;
int4 local_30;
long local_28 [2];
pcVar1 = (char *)llm_arch_name(*(int4 *)(*(long *)param_1 + 4));
std::__cxx11::string::string<std::allocator<char>>
((string *)&local_38,pcVar1,(allocator *)&local_3c);
local_3c = local_30;
/* try { // try from 001a02c3 to 001a02e2 has its CatchHandler @ 001a0308 */
(*(code *)**(int8 **)this)(this,&local_3c,4);
(*(code *)**(int8 **)this)(this,local_38,local_3c);
if (local_38 != local_28) {
operator_delete(local_38,local_28[0] + 1);
}
return;
}
|
|
7,771 |
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
monkey531[P]llama/common/arg.cpp
|
bool common_arg::get_value_from_env(std::string & output) {
if (env == nullptr) return false;
char * value = std::getenv(env);
if (value) {
output = value;
return true;
}
return false;
}
|
O0
|
cpp
|
common_arg::get_value_from_env(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&):
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x88(%rax)
jne 0x69c58
movb $0x0, 0x27(%rsp)
jmp 0x69c90
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0x59d20
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x69c8b
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x596a0
movb $0x1, 0x27(%rsp)
jmp 0x69c90
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
|
_ZN10common_arg18get_value_from_envERNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
sub rsp, 28h
mov [rsp+28h+var_10], rdi
mov [rsp+28h+var_18], rsi
mov rax, [rsp+28h+var_10]
mov [rsp+28h+var_28], rax
cmp qword ptr [rax+88h], 0
jnz short loc_69C58
mov [rsp+28h+var_1], 0
jmp short loc_69C90
loc_69C58:
mov rax, [rsp+28h+var_28]
mov rdi, [rax+88h]
call _getenv
mov [rsp+28h+var_20], rax
cmp [rsp+28h+var_20], 0
jz short loc_69C8B
mov rsi, [rsp+28h+var_20]
mov rdi, [rsp+28h+var_18]
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSEPKc; std::string::operator=(char const*)
mov [rsp+28h+var_1], 1
jmp short loc_69C90
loc_69C8B:
mov [rsp+28h+var_1], 0
loc_69C90:
mov al, [rsp+28h+var_1]
and al, 1
add rsp, 28h
retn
|
char common_arg::get_value_from_env(long long a1, long long a2)
{
long long v3; // [rsp+8h] [rbp-20h]
if ( !*(_QWORD *)(a1 + 136) )
return 0;
v3 = getenv(*(_QWORD *)(a1 + 136));
if ( !v3 )
return 0;
std::string::operator=(a2, v3);
return 1;
}
|
get_value_from_env:
SUB RSP,0x28
MOV qword ptr [RSP + 0x18],RDI
MOV qword ptr [RSP + 0x10],RSI
MOV RAX,qword ptr [RSP + 0x18]
MOV qword ptr [RSP],RAX
CMP qword ptr [RAX + 0x88],0x0
JNZ 0x00169c58
MOV byte ptr [RSP + 0x27],0x0
JMP 0x00169c90
LAB_00169c58:
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x00159d20
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JZ 0x00169c8b
MOV RSI,qword ptr [RSP + 0x8]
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x001596a0
MOV byte ptr [RSP + 0x27],0x1
JMP 0x00169c90
LAB_00169c8b:
MOV byte ptr [RSP + 0x27],0x0
LAB_00169c90:
MOV AL,byte ptr [RSP + 0x27]
AND AL,0x1
ADD RSP,0x28
RET
|
/* common_arg::get_value_from_env(std::__cxx11::string&) */
int1 __thiscall common_arg::get_value_from_env(common_arg *this,string *param_1)
{
char *pcVar1;
int1 local_1;
if (*(long *)(this + 0x88) == 0) {
local_1 = 0;
}
else {
pcVar1 = getenv(*(char **)(this + 0x88));
if (pcVar1 == (char *)0x0) {
local_1 = 0;
}
else {
std::__cxx11::string::operator=(param_1,pcVar1);
local_1 = 1;
}
}
return local_1;
}
|
|
7,772 |
ntt_fft_partial
|
bluesky950520[P]quickjs/libbf.c
|
static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
int k1, int k2, limb_t n1, limb_t n2, int inverse,
limb_t m_idx)
{
limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
NTTLimb *buf2, *buf3;
buf2 = NULL;
buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
if (!buf3)
goto fail;
if (k2 == 0) {
if (ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx))
goto fail;
} else {
strip_len = STRIP_LEN;
buf2 = ntt_malloc(s, sizeof(NTTLimb) * n1 * strip_len);
if (!buf2)
goto fail;
m = ntt_mods[m_idx];
m_inv = s->ntt_mods_div[m_idx];
c0 = s->ntt_proot_pow[m_idx][inverse][k1 + k2];
c_mul = 1;
assert((n2 % strip_len) == 0);
for(j = 0; j < n2; j += strip_len) {
for(i = 0; i < n1; i++) {
for(l = 0; l < strip_len; l++) {
buf2[i + l * n1] = buf1[i * n2 + (j + l)];
}
}
for(l = 0; l < strip_len; l++) {
if (inverse)
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
if (ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx))
goto fail;
if (!inverse)
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
}
for(i = 0; i < n1; i++) {
for(l = 0; l < strip_len; l++) {
buf1[i * n2 + (j + l)] = buf2[i + l *n1];
}
}
}
ntt_free(s, buf2);
}
ntt_free(s, buf3);
return 0;
fail:
ntt_free(s, buf2);
ntt_free(s, buf3);
return -1;
}
|
O0
|
c
|
ntt_fft_partial:
subq $0x88, %rsp
movq 0x98(%rsp), %rax
movl 0x90(%rsp), %eax
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movl %ecx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x78(%rsp), %rdi
movq 0x60(%rsp), %rsi
shlq $0x3, %rsi
callq 0xf9df0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xface0
jmp 0xfb05a
cmpl $0x0, 0x68(%rsp)
jne 0xfad27
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x6c(%rsp), %r8d
movl 0x90(%rsp), %r9d
movq 0x98(%rsp), %rax
movl %eax, (%rsp)
callq 0xfb220
cmpl $0x0, %eax
je 0xfad22
jmp 0xfb05a
jmp 0xfb03e
movq $0x10, 0x20(%rsp)
movq 0x78(%rsp), %rdi
movq 0x60(%rsp), %rsi
shlq $0x3, %rsi
imulq 0x20(%rsp), %rsi
callq 0xf9df0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfad5b
jmp 0xfb05a
movq 0x98(%rsp), %rcx
leaq 0x15c06(%rip), %rax # 0x110970
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %rax
movq 0x98(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
addq $0x30, %rax
imulq $0x340, 0x98(%rsp), %rcx # imm = 0x340
addq %rcx, %rax
movslq 0x90(%rsp), %rcx
imulq $0x1a0, %rcx, %rcx # imm = 0x1A0
addq %rcx, %rax
movl 0x6c(%rsp), %ecx
addl 0x68(%rsp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
movq $0x1, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0xfb02f
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0xfae73
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xfae61
movq 0x70(%rsp), %rax
movq 0x50(%rsp), %rcx
imulq 0x58(%rsp), %rcx
movq 0x48(%rsp), %rdx
addq 0x18(%rsp), %rdx
addq %rdx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x50(%rsp), %rcx
movq 0x18(%rsp), %rsi
imulq 0x60(%rsp), %rsi
addq %rsi, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xfae08
jmp 0xfae63
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0xfadf3
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xfaf90
cmpl $0x0, 0x90(%rsp)
je 0xfaec6
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
imulq 0x60(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xfb620
movq 0x78(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
imulq 0x60(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rax
imulq 0x60(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq 0x8(%rsp), %rcx
movl 0x6c(%rsp), %r8d
movl 0x90(%rsp), %r9d
movq 0x98(%rsp), %rax
movl %eax, (%rsp)
callq 0xfb220
cmpl $0x0, %eax
je 0xfaf25
jmp 0xfb05a
cmpl $0x0, 0x90(%rsp)
jne 0xfaf5f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
imulq 0x60(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x60(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xfb620
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0xfab00
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xfae7c
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x60(%rsp), %rax
jae 0xfb019
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0xfb007
movq 0x10(%rsp), %rax
movq 0x50(%rsp), %rcx
movq 0x18(%rsp), %rdx
imulq 0x60(%rsp), %rdx
addq %rdx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x70(%rsp), %rax
movq 0x50(%rsp), %rcx
imulq 0x58(%rsp), %rcx
movq 0x48(%rsp), %rsi
addq 0x18(%rsp), %rsi
addq %rsi, %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xfafae
jmp 0xfb009
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0xfaf99
jmp 0xfb01b
movq 0x20(%rsp), %rax
addq 0x48(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0xfadda
movq 0x78(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf9a80
movq 0x78(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf9a80
movl $0x0, 0x84(%rsp)
jmp 0xfb083
movq 0x78(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf9a80
movq 0x78(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf9a80
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
|
ntt_fft_partial:
sub rsp, 88h
mov rax, [rsp+88h+arg_8]
mov eax, [rsp+88h+arg_0]
mov [rsp+88h+var_10], rdi
mov [rsp+88h+var_18], rsi
mov [rsp+88h+var_1C], edx
mov [rsp+88h+var_20], ecx
mov [rsp+88h+var_28], r8
mov [rsp+88h+var_30], r9
mov [rsp+88h+var_78], 0
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_28]
shl rsi, 3
call ntt_malloc
mov [rsp+88h+var_80], rax
cmp [rsp+88h+var_80], 0
jnz short loc_FACE0
jmp loc_FB05A
loc_FACE0:
cmp [rsp+88h+var_20], 0
jnz short loc_FAD27
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_18]
mov rdx, [rsp+88h+var_18]
mov rcx, [rsp+88h+var_80]
mov r8d, [rsp+88h+var_1C]
mov r9d, [rsp+88h+arg_0]
mov rax, [rsp+88h+arg_8]
mov [rsp+88h+var_88], eax
call ntt_fft
cmp eax, 0
jz short loc_FAD22
jmp loc_FB05A
loc_FAD22:
jmp loc_FB03E
loc_FAD27:
mov [rsp+88h+var_68], 10h
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_28]
shl rsi, 3
imul rsi, [rsp+88h+var_68]
call ntt_malloc
mov [rsp+88h+var_78], rax
cmp [rsp+88h+var_78], 0
jnz short loc_FAD5B
jmp loc_FB05A
loc_FAD5B:
mov rcx, [rsp+88h+arg_8]
lea rax, ntt_mods
mov rax, [rax+rcx*8]
mov [rsp+88h+var_58], rax
mov rax, [rsp+88h+var_10]
mov rcx, [rsp+88h+arg_8]
mov rax, [rax+rcx*8+8]
mov [rsp+88h+var_60], rax
mov rax, [rsp+88h+var_10]
add rax, 30h ; '0'
imul rcx, [rsp+88h+arg_8], 340h
add rax, rcx
movsxd rcx, [rsp+88h+arg_0]
imul rcx, 1A0h
add rax, rcx
mov ecx, [rsp+88h+var_1C]
add ecx, [rsp+88h+var_20]
movsxd rcx, ecx
mov rax, [rax+rcx*8]
mov [rsp+88h+var_50], rax
mov [rsp+88h+var_48], 1
mov [rsp+88h+var_40], 0
loc_FADDA:
mov rax, [rsp+88h+var_40]
cmp rax, [rsp+88h+var_30]
jnb loc_FB02F
mov [rsp+88h+var_38], 0
loc_FADF3:
mov rax, [rsp+88h+var_38]
cmp rax, [rsp+88h+var_28]
jnb short loc_FAE73
mov [rsp+88h+var_70], 0
loc_FAE08:
mov rax, [rsp+88h+var_70]
cmp rax, [rsp+88h+var_68]
jnb short loc_FAE61
mov rax, [rsp+88h+var_18]
mov rcx, [rsp+88h+var_38]
imul rcx, [rsp+88h+var_30]
mov rdx, [rsp+88h+var_40]
add rdx, [rsp+88h+var_70]
add rcx, rdx
mov rdx, [rax+rcx*8]
mov rax, [rsp+88h+var_78]
mov rcx, [rsp+88h+var_38]
mov rsi, [rsp+88h+var_70]
imul rsi, [rsp+88h+var_28]
add rcx, rsi
mov [rax+rcx*8], rdx
mov rax, [rsp+88h+var_70]
add rax, 1
mov [rsp+88h+var_70], rax
jmp short loc_FAE08
loc_FAE61:
jmp short $+2
loc_FAE63:
mov rax, [rsp+88h+var_38]
add rax, 1
mov [rsp+88h+var_38], rax
jmp short loc_FADF3
loc_FAE73:
mov [rsp+88h+var_70], 0
loc_FAE7C:
mov rax, [rsp+88h+var_70]
cmp rax, [rsp+88h+var_68]
jnb loc_FAF90
cmp [rsp+88h+arg_0], 0
jz short loc_FAEC6
mov rdi, [rsp+88h+var_78]
mov rax, [rsp+88h+var_70]
imul rax, [rsp+88h+var_28]
shl rax, 3
add rdi, rax
mov rsi, [rsp+88h+var_28]
mov rdx, [rsp+88h+var_48]
mov rcx, [rsp+88h+var_58]
mov r8, [rsp+88h+var_60]
call mul_trig
loc_FAEC6:
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_78]
mov rax, [rsp+88h+var_70]
imul rax, [rsp+88h+var_28]
shl rax, 3
add rsi, rax
mov rdx, [rsp+88h+var_78]
mov rax, [rsp+88h+var_70]
imul rax, [rsp+88h+var_28]
shl rax, 3
add rdx, rax
mov rcx, [rsp+88h+var_80]
mov r8d, [rsp+88h+var_1C]
mov r9d, [rsp+88h+arg_0]
mov rax, [rsp+88h+arg_8]
mov [rsp+88h+var_88], eax
call ntt_fft
cmp eax, 0
jz short loc_FAF25
jmp loc_FB05A
loc_FAF25:
cmp [rsp+88h+arg_0], 0
jnz short loc_FAF5F
mov rdi, [rsp+88h+var_78]
mov rax, [rsp+88h+var_70]
imul rax, [rsp+88h+var_28]
shl rax, 3
add rdi, rax
mov rsi, [rsp+88h+var_28]
mov rdx, [rsp+88h+var_48]
mov rcx, [rsp+88h+var_58]
mov r8, [rsp+88h+var_60]
call mul_trig
loc_FAF5F:
mov rdi, [rsp+88h+var_48]
mov rsi, [rsp+88h+var_50]
mov rdx, [rsp+88h+var_58]
mov rcx, [rsp+88h+var_60]
call mul_mod_fast
mov [rsp+88h+var_48], rax
mov rax, [rsp+88h+var_70]
add rax, 1
mov [rsp+88h+var_70], rax
jmp loc_FAE7C
loc_FAF90:
mov [rsp+88h+var_38], 0
loc_FAF99:
mov rax, [rsp+88h+var_38]
cmp rax, [rsp+88h+var_28]
jnb short loc_FB019
mov [rsp+88h+var_70], 0
loc_FAFAE:
mov rax, [rsp+88h+var_70]
cmp rax, [rsp+88h+var_68]
jnb short loc_FB007
mov rax, [rsp+88h+var_78]
mov rcx, [rsp+88h+var_38]
mov rdx, [rsp+88h+var_70]
imul rdx, [rsp+88h+var_28]
add rcx, rdx
mov rdx, [rax+rcx*8]
mov rax, [rsp+88h+var_18]
mov rcx, [rsp+88h+var_38]
imul rcx, [rsp+88h+var_30]
mov rsi, [rsp+88h+var_40]
add rsi, [rsp+88h+var_70]
add rcx, rsi
mov [rax+rcx*8], rdx
mov rax, [rsp+88h+var_70]
add rax, 1
mov [rsp+88h+var_70], rax
jmp short loc_FAFAE
loc_FB007:
jmp short $+2
loc_FB009:
mov rax, [rsp+88h+var_38]
add rax, 1
mov [rsp+88h+var_38], rax
jmp short loc_FAF99
loc_FB019:
jmp short $+2
loc_FB01B:
mov rax, [rsp+88h+var_68]
add rax, [rsp+88h+var_40]
mov [rsp+88h+var_40], rax
jmp loc_FADDA
loc_FB02F:
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_78]
call ntt_free
loc_FB03E:
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_80]
call ntt_free
mov [rsp+88h+var_4], 0
jmp short loc_FB083
loc_FB05A:
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_78]
call ntt_free
mov rdi, [rsp+88h+var_10]
mov rsi, [rsp+88h+var_80]
call ntt_free
mov [rsp+88h+var_4], 0FFFFFFFFh
loc_FB083:
mov eax, [rsp+88h+var_4]
add rsp, 88h
retn
|
long long ntt_fft_partial(
long long *a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
unsigned long long a6,
int a7,
long long a8)
{
long long v8; // rdx
long long v9; // rcx
long long v10; // r8
long long v11; // r9
long long v12; // rcx
long long v13; // rdx
long long v14; // rcx
long long v15; // r8
long long v16; // r9
long long v18; // [rsp+8h] [rbp-80h]
long long v19; // [rsp+10h] [rbp-78h]
unsigned long long k; // [rsp+18h] [rbp-70h]
unsigned long long m; // [rsp+18h] [rbp-70h]
unsigned long long ii; // [rsp+18h] [rbp-70h]
long long v23; // [rsp+28h] [rbp-60h]
long long v24; // [rsp+30h] [rbp-58h]
unsigned long long v25; // [rsp+38h] [rbp-50h]
unsigned long long v26; // [rsp+40h] [rbp-48h]
unsigned long long i; // [rsp+48h] [rbp-40h]
unsigned long long j; // [rsp+50h] [rbp-38h]
unsigned long long n; // [rsp+50h] [rbp-38h]
int v32; // [rsp+68h] [rbp-20h]
int v33; // [rsp+6Ch] [rbp-1Ch]
v33 = a3;
v32 = a4;
v19 = 0LL;
v18 = ntt_malloc(a1, 8 * a5, a3, a4, a5, a6);
if ( !v18 )
goto LABEL_31;
if ( v32 )
{
v19 = ntt_malloc(a1, a5 << 7, v8, v9, v10, v11);
if ( v19 )
{
v24 = ntt_mods[a8];
v23 = a1[a8 + 1];
v12 = v32 + v33;
v25 = a1[104 * a8 + 6 + 52 * a7 + v12];
v26 = 1LL;
for ( i = 0LL; i < a6; i += 16LL )
{
for ( j = 0LL; j < a5; ++j )
{
for ( k = 0LL; k < 0x10; ++k )
{
v8 = *(_QWORD *)(a2 + 8 * (k + i + a6 * j));
v12 = a5 * k + j;
*(_QWORD *)(v19 + 8 * v12) = v8;
}
}
for ( m = 0LL; m < 0x10; ++m )
{
if ( a7 )
mul_trig(8 * a5 * m + v19, a5, v26, v24, v23);
if ( (unsigned int)ntt_fft(
(_DWORD)a1,
8 * (int)a5 * (int)m + (int)v19,
8 * (int)a5 * (int)m + (int)v19,
v18,
v33,
a7,
a8) )
goto LABEL_31;
if ( !a7 )
mul_trig(8 * a5 * m + v19, a5, v26, v24, v23);
v26 = mul_mod_fast(v26, v25, v24, v23);
}
for ( n = 0LL; n < a5; ++n )
{
for ( ii = 0LL; ii < 0x10; ++ii )
{
v8 = *(_QWORD *)(v19 + 8 * (a5 * ii + n));
v12 = ii + i + a6 * n;
*(_QWORD *)(a2 + 8 * v12) = v8;
}
}
}
ntt_free(a1, v19, v8, v12, v10, v11);
goto LABEL_30;
}
LABEL_31:
ntt_free(a1, v19, v8, v9, v10, v11);
ntt_free(a1, v18, v13, v14, v15, v16);
return (unsigned int)-1;
}
if ( (unsigned int)ntt_fft((_DWORD)a1, a2, a2, v18, v33, a7, a8) )
goto LABEL_31;
LABEL_30:
ntt_free(a1, v18, v8, v9, v10, v11);
return 0;
}
|
ntt_fft_partial:
SUB RSP,0x88
MOV RAX,qword ptr [RSP + 0x98]
MOV EAX,dword ptr [RSP + 0x90]
MOV qword ptr [RSP + 0x78],RDI
MOV qword ptr [RSP + 0x70],RSI
MOV dword ptr [RSP + 0x6c],EDX
MOV dword ptr [RSP + 0x68],ECX
MOV qword ptr [RSP + 0x60],R8
MOV qword ptr [RSP + 0x58],R9
MOV qword ptr [RSP + 0x10],0x0
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x60]
SHL RSI,0x3
CALL 0x001f9df0
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001face0
JMP 0x001fb05a
LAB_001face0:
CMP dword ptr [RSP + 0x68],0x0
JNZ 0x001fad27
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x70]
MOV RDX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x8]
MOV R8D,dword ptr [RSP + 0x6c]
MOV R9D,dword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x98]
MOV dword ptr [RSP],EAX
CALL 0x001fb220
CMP EAX,0x0
JZ 0x001fad22
JMP 0x001fb05a
LAB_001fad22:
JMP 0x001fb03e
LAB_001fad27:
MOV qword ptr [RSP + 0x20],0x10
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x60]
SHL RSI,0x3
IMUL RSI,qword ptr [RSP + 0x20]
CALL 0x001f9df0
MOV qword ptr [RSP + 0x10],RAX
CMP qword ptr [RSP + 0x10],0x0
JNZ 0x001fad5b
JMP 0x001fb05a
LAB_001fad5b:
MOV RCX,qword ptr [RSP + 0x98]
LEA RAX,[0x210970]
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x30],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV RCX,qword ptr [RSP + 0x98]
MOV RAX,qword ptr [RAX + RCX*0x8 + 0x8]
MOV qword ptr [RSP + 0x28],RAX
MOV RAX,qword ptr [RSP + 0x78]
ADD RAX,0x30
IMUL RCX,qword ptr [RSP + 0x98],0x340
ADD RAX,RCX
MOVSXD RCX,dword ptr [RSP + 0x90]
IMUL RCX,RCX,0x1a0
ADD RAX,RCX
MOV ECX,dword ptr [RSP + 0x6c]
ADD ECX,dword ptr [RSP + 0x68]
MOVSXD RCX,ECX
MOV RAX,qword ptr [RAX + RCX*0x8]
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],0x1
MOV qword ptr [RSP + 0x48],0x0
LAB_001fadda:
MOV RAX,qword ptr [RSP + 0x48]
CMP RAX,qword ptr [RSP + 0x58]
JNC 0x001fb02f
MOV qword ptr [RSP + 0x50],0x0
LAB_001fadf3:
MOV RAX,qword ptr [RSP + 0x50]
CMP RAX,qword ptr [RSP + 0x60]
JNC 0x001fae73
MOV qword ptr [RSP + 0x18],0x0
LAB_001fae08:
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x20]
JNC 0x001fae61
MOV RAX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x50]
IMUL RCX,qword ptr [RSP + 0x58]
MOV RDX,qword ptr [RSP + 0x48]
ADD RDX,qword ptr [RSP + 0x18]
ADD RCX,RDX
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x50]
MOV RSI,qword ptr [RSP + 0x18]
IMUL RSI,qword ptr [RSP + 0x60]
ADD RCX,RSI
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001fae08
LAB_001fae61:
JMP 0x001fae63
LAB_001fae63:
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x1
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001fadf3
LAB_001fae73:
MOV qword ptr [RSP + 0x18],0x0
LAB_001fae7c:
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x20]
JNC 0x001faf90
CMP dword ptr [RSP + 0x90],0x0
JZ 0x001faec6
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
IMUL RAX,qword ptr [RSP + 0x60]
SHL RAX,0x3
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x28]
CALL 0x001fb620
LAB_001faec6:
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
IMUL RAX,qword ptr [RSP + 0x60]
SHL RAX,0x3
ADD RSI,RAX
MOV RDX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
IMUL RAX,qword ptr [RSP + 0x60]
SHL RAX,0x3
ADD RDX,RAX
MOV RCX,qword ptr [RSP + 0x8]
MOV R8D,dword ptr [RSP + 0x6c]
MOV R9D,dword ptr [RSP + 0x90]
MOV RAX,qword ptr [RSP + 0x98]
MOV dword ptr [RSP],EAX
CALL 0x001fb220
CMP EAX,0x0
JZ 0x001faf25
JMP 0x001fb05a
LAB_001faf25:
CMP dword ptr [RSP + 0x90],0x0
JNZ 0x001faf5f
MOV RDI,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RSP + 0x18]
IMUL RAX,qword ptr [RSP + 0x60]
SHL RAX,0x3
ADD RDI,RAX
MOV RSI,qword ptr [RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x40]
MOV RCX,qword ptr [RSP + 0x30]
MOV R8,qword ptr [RSP + 0x28]
CALL 0x001fb620
LAB_001faf5f:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x30]
MOV RCX,qword ptr [RSP + 0x28]
CALL 0x001fab00
MOV qword ptr [RSP + 0x40],RAX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001fae7c
LAB_001faf90:
MOV qword ptr [RSP + 0x50],0x0
LAB_001faf99:
MOV RAX,qword ptr [RSP + 0x50]
CMP RAX,qword ptr [RSP + 0x60]
JNC 0x001fb019
MOV qword ptr [RSP + 0x18],0x0
LAB_001fafae:
MOV RAX,qword ptr [RSP + 0x18]
CMP RAX,qword ptr [RSP + 0x20]
JNC 0x001fb007
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x50]
MOV RDX,qword ptr [RSP + 0x18]
IMUL RDX,qword ptr [RSP + 0x60]
ADD RCX,RDX
MOV RDX,qword ptr [RAX + RCX*0x8]
MOV RAX,qword ptr [RSP + 0x70]
MOV RCX,qword ptr [RSP + 0x50]
IMUL RCX,qword ptr [RSP + 0x58]
MOV RSI,qword ptr [RSP + 0x48]
ADD RSI,qword ptr [RSP + 0x18]
ADD RCX,RSI
MOV qword ptr [RAX + RCX*0x8],RDX
MOV RAX,qword ptr [RSP + 0x18]
ADD RAX,0x1
MOV qword ptr [RSP + 0x18],RAX
JMP 0x001fafae
LAB_001fb007:
JMP 0x001fb009
LAB_001fb009:
MOV RAX,qword ptr [RSP + 0x50]
ADD RAX,0x1
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001faf99
LAB_001fb019:
JMP 0x001fb01b
LAB_001fb01b:
MOV RAX,qword ptr [RSP + 0x20]
ADD RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x48],RAX
JMP 0x001fadda
LAB_001fb02f:
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x001f9a80
LAB_001fb03e:
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001f9a80
MOV dword ptr [RSP + 0x84],0x0
JMP 0x001fb083
LAB_001fb05a:
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x001f9a80
MOV RDI,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x001f9a80
MOV dword ptr [RSP + 0x84],0xffffffff
LAB_001fb083:
MOV EAX,dword ptr [RSP + 0x84]
ADD RSP,0x88
RET
|
int4
ntt_fft_partial(long param_1,long param_2,int param_3,int param_4,ulong param_5,ulong param_6,
int param_7,long param_8)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
long lVar5;
long local_78;
ulong local_70;
int8 local_48;
ulong local_40;
ulong local_38;
local_78 = 0;
lVar5 = ntt_malloc(param_1,param_5 << 3);
if (lVar5 != 0) {
if (param_4 == 0) {
iVar4 = ntt_fft(param_1,param_2,param_2,lVar5,param_3,param_7,(int)param_8);
if (iVar4 == 0) {
LAB_001fb03e:
ntt_free(param_1,lVar5);
return 0;
}
}
else {
local_78 = ntt_malloc(param_1,param_5 << 7);
if (local_78 != 0) {
uVar1 = *(int8 *)(ntt_mods + param_8 * 8);
uVar2 = *(int8 *)(param_1 + 8 + param_8 * 8);
uVar3 = *(int8 *)
(param_1 + 0x30 + param_8 * 0x340 + (long)param_7 * 0x1a0 +
(long)(param_3 + param_4) * 8);
local_48 = 1;
for (local_40 = 0; local_40 < param_6; local_40 = local_40 + 0x10) {
for (local_38 = 0; local_38 < param_5; local_38 = local_38 + 1) {
for (local_70 = 0; local_70 < 0x10; local_70 = local_70 + 1) {
*(int8 *)(local_78 + (local_38 + local_70 * param_5) * 8) =
*(int8 *)(param_2 + (local_38 * param_6 + local_40 + local_70) * 8);
}
}
for (local_70 = 0; local_70 < 0x10; local_70 = local_70 + 1) {
if (param_7 != 0) {
mul_trig(local_78 + local_70 * param_5 * 8,param_5,local_48,uVar1,uVar2);
}
iVar4 = ntt_fft(param_1,local_78 + local_70 * param_5 * 8,
local_78 + local_70 * param_5 * 8,lVar5,param_3,param_7,(int)param_8);
if (iVar4 != 0) goto LAB_001fb05a;
if (param_7 == 0) {
mul_trig(local_78 + local_70 * param_5 * 8,param_5,local_48,uVar1,uVar2);
}
local_48 = mul_mod_fast(local_48,uVar3,uVar1,uVar2);
}
for (local_38 = 0; local_38 < param_5; local_38 = local_38 + 1) {
for (local_70 = 0; local_70 < 0x10; local_70 = local_70 + 1) {
*(int8 *)(param_2 + (local_38 * param_6 + local_40 + local_70) * 8) =
*(int8 *)(local_78 + (local_38 + local_70 * param_5) * 8);
}
}
}
ntt_free(param_1,local_78);
goto LAB_001fb03e;
}
}
}
LAB_001fb05a:
ntt_free(param_1,local_78);
ntt_free(param_1,lVar5);
return 0xffffffff;
}
|
|
7,773 |
ntt_fft_partial
|
bluesky950520[P]quickjs/libbf.c
|
static int ntt_fft_partial(BFNTTState *s, NTTLimb *buf1,
int k1, int k2, limb_t n1, limb_t n2, int inverse,
limb_t m_idx)
{
limb_t i, j, c_mul, c0, m, m_inv, strip_len, l;
NTTLimb *buf2, *buf3;
buf2 = NULL;
buf3 = ntt_malloc(s, sizeof(NTTLimb) * n1);
if (!buf3)
goto fail;
if (k2 == 0) {
if (ntt_fft(s, buf1, buf1, buf3, k1, inverse, m_idx))
goto fail;
} else {
strip_len = STRIP_LEN;
buf2 = ntt_malloc(s, sizeof(NTTLimb) * n1 * strip_len);
if (!buf2)
goto fail;
m = ntt_mods[m_idx];
m_inv = s->ntt_mods_div[m_idx];
c0 = s->ntt_proot_pow[m_idx][inverse][k1 + k2];
c_mul = 1;
assert((n2 % strip_len) == 0);
for(j = 0; j < n2; j += strip_len) {
for(i = 0; i < n1; i++) {
for(l = 0; l < strip_len; l++) {
buf2[i + l * n1] = buf1[i * n2 + (j + l)];
}
}
for(l = 0; l < strip_len; l++) {
if (inverse)
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
if (ntt_fft(s, buf2 + l * n1, buf2 + l * n1, buf3, k1, inverse, m_idx))
goto fail;
if (!inverse)
mul_trig(buf2 + l * n1, n1, c_mul, m, m_inv);
c_mul = mul_mod_fast(c_mul, c0, m, m_inv);
}
for(i = 0; i < n1; i++) {
for(l = 0; l < strip_len; l++) {
buf1[i * n2 + (j + l)] = buf2[i + l *n1];
}
}
}
ntt_free(s, buf2);
}
ntt_free(s, buf3);
return 0;
fail:
ntt_free(s, buf2);
ntt_free(s, buf3);
return -1;
}
|
O1
|
c
|
ntt_fft_partial:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x38(%rsp)
movq %r8, %r13
movl %ecx, %r15d
movl %edx, 0x14(%rsp)
movq %rsi, %rbp
leaq (,%r8,8), %r12
movq %rdi, 0x8(%rsp)
movq (%rdi), %rax
movq (%rax), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
movq %r12, %rdx
callq *0x8(%rax)
movq %rax, %r14
testq %rax, %rax
je 0x9349d
movq 0xa8(%rsp), %rax
movl 0xa0(%rsp), %r9d
testl %r15d, %r15d
je 0x93470
movq %r13, %rdx
shlq $0x7, %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq *0x8(%rax)
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x9349d
movq %rbp, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq 0x38(%rsp), %rsi
testq %rsi, %rsi
movl 0xa0(%rsp), %r9d
je 0x93452
leaq 0xe707(%rip), %rax # 0xa1960
movq 0xa8(%rsp), %rdx
movq (%rax,%rdx,8), %rbp
movq 0x8(%rsp), %rcx
movq 0x8(%rcx,%rdx,8), %rbx
imulq $0x340, %rdx, %rax # imm = 0x340
addq %rcx, %rax
movl %r9d, %ecx
addl 0x14(%rsp), %r15d
movslq %r15d, %rdx
imulq $0x1a0, %rcx, %rcx # imm = 0x1A0
addq %rax, %rcx
movq 0x30(%rcx,%rdx,8), %rax
movq %rax, 0x58(%rsp)
leaq (,%rbp,2), %rax
movq %rax, 0x50(%rsp)
leaq (,%rsi,8), %r11
movl $0x1, %r14d
xorl %eax, %eax
movq %r11, 0x40(%rsp)
movq %rax, 0x48(%rsp)
testq %r13, %r13
je 0x932f7
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %edi, %edi
movq (%rax,%rdi,8), %r8
movq %r8, (%rsi)
incq %rdi
addq %r12, %rsi
cmpq $0x10, %rdi
jne 0x932d5
incq %rdx
addq $0x8, %rcx
addq %r11, %rax
cmpq %r13, %rdx
jne 0x932d0
movl $0x10, %r15d
movq 0x18(%rsp), %rsi
movq %r15, 0x60(%rsp)
testl %r9d, %r9d
movq %rsi, 0x30(%rsp)
je 0x93332
movq %rsi, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x936f2
movq 0x30(%rsp), %rsi
movl 0xa0(%rsp), %r9d
movq %r14, %r15
movq %rbx, %r14
movq %rbp, %rbx
movq %r13, %rbp
movq 0xa8(%rsp), %rax
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movq %rsi, %rdx
movq 0x28(%rsp), %rcx
movl 0x14(%rsp), %r8d
movl %r9d, %r13d
callq 0x934e3
testl %eax, %eax
jne 0x93493
testl %r13d, %r13d
movl %r13d, %r9d
movq %rbp, %r13
movq %rbx, %rbp
movq %r14, %rbx
movq %r15, %r14
movq 0x60(%rsp), %r15
jne 0x933a2
movq 0x30(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbp, %rcx
movq %rbx, %r8
callq 0x936f2
movl 0xa0(%rsp), %r9d
movq %r14, %rax
mulq 0x58(%rsp)
movq %rax, %rsi
movq %rdx, %rcx
movq %rdx, %rax
shldq $0x3, %rsi, %rax
mulq %rbx
movq %rdx, %rax
mulq %rbp
addq 0x50(%rsp), %rax
adcq $0x0, %rdx
subq %rax, %rsi
sbbq %rdx, %rcx
movq %rcx, %rax
sarq %rax
andq %rbp, %rax
addq %rsi, %rax
adcq $0x0, %rcx
andq %rbp, %rcx
leaq (%rcx,%rax), %r14
movq 0x30(%rsp), %rsi
addq %r12, %rsi
decq %r15
jne 0x93302
testq %r13, %r13
movq 0x38(%rsp), %r10
movq 0x40(%rsp), %r11
je 0x9343a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
movq %rcx, %rsi
xorl %edi, %edi
movq (%rsi), %r8
movq %r8, (%rax,%rdi,8)
incq %rdi
addq %r12, %rsi
cmpq $0x10, %rdi
jne 0x93418
incq %rdx
addq $0x8, %rcx
addq %r11, %rax
cmpq %r13, %rdx
jne 0x93413
movq 0x48(%rsp), %rax
addq $0x10, %rax
subq $-0x80, 0x20(%rsp)
cmpq %r10, %rax
jb 0x932ba
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
xorl %ebx, %ebx
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq *0x8(%rax)
movq 0x28(%rsp), %r14
jmp 0x934bf
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %rbp, %rdx
movq %r14, %rcx
movl 0x14(%rsp), %r8d
callq 0x934e3
xorl %ebx, %ebx
testl %eax, %eax
jne 0x9349d
jmp 0x934bf
movq 0x18(%rsp), %rbx
movq 0x28(%rsp), %r14
testq %rbx, %rbx
je 0x934b5
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq *0x8(%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x934d2
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *0x8(%rax)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
ntt_fft_partial:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 68h
mov [rsp+98h+var_60], r9
mov r13, r8
mov r15d, ecx
mov [rsp+98h+var_84], edx
mov rbp, rsi
lea r12, ds:0[r8*8]
mov [rsp+98h+var_90], rdi
mov rax, [rdi]
mov rdi, [rax]
xor ebx, ebx
xor esi, esi
mov rdx, r12
call qword ptr [rax+8]
mov r14, rax
test rax, rax
jz loc_9349D
mov rax, [rsp+98h+arg_8]
mov r9d, [rsp+98h+arg_0]
test r15d, r15d
jz loc_93470
mov rdx, r13
shl rdx, 7
mov rax, [rsp+98h+var_90]
mov rax, [rax]
mov rdi, [rax]
xor ebx, ebx
xor esi, esi
call qword ptr [rax+8]
mov [rsp+98h+var_80], rax
test rax, rax
jz loc_9349D
mov [rsp+98h+var_78], rbp
mov [rsp+98h+var_70], r14
mov rsi, [rsp+98h+var_60]
test rsi, rsi
mov r9d, [rsp+98h+arg_0]
jz loc_93452
lea rax, ntt_mods
mov rdx, [rsp+98h+arg_8]
mov rbp, [rax+rdx*8]
mov rcx, [rsp+98h+var_90]
mov rbx, [rcx+rdx*8+8]
imul rax, rdx, 340h
add rax, rcx
mov ecx, r9d
add r15d, [rsp+98h+var_84]
movsxd rdx, r15d
imul rcx, 1A0h
add rcx, rax
mov rax, [rcx+rdx*8+30h]
mov [rsp+98h+var_40], rax
lea rax, ds:0[rbp*2]
mov [rsp+98h+var_48], rax
lea r11, ds:0[rsi*8]
mov r14d, 1
xor eax, eax
mov [rsp+98h+var_58], r11
loc_932BA:
mov [rsp+98h+var_50], rax
test r13, r13
jz short loc_932F7
mov rax, [rsp+98h+var_78]
mov rcx, [rsp+98h+var_80]
xor edx, edx
loc_932D0:
mov rsi, rcx
xor edi, edi
loc_932D5:
mov r8, [rax+rdi*8]
mov [rsi], r8
inc rdi
add rsi, r12
cmp rdi, 10h
jnz short loc_932D5
inc rdx
add rcx, 8
add rax, r11
cmp rdx, r13
jnz short loc_932D0
loc_932F7:
mov r15d, 10h
mov rsi, [rsp+98h+var_80]
loc_93302:
mov [rsp+98h+var_38], r15
test r9d, r9d
mov [rsp+98h+var_68], rsi
jz short loc_93332
mov rdi, rsi
mov rsi, r13
mov rdx, r14
mov rcx, rbp
mov r8, rbx
call mul_trig
mov rsi, [rsp+98h+var_68]
mov r9d, [rsp+98h+arg_0]
loc_93332:
mov r15, r14
mov r14, rbx
mov rbx, rbp
mov rbp, r13
mov rax, [rsp+98h+arg_8]
mov [rsp+98h+var_98], eax
mov rdi, [rsp+98h+var_90]
mov rdx, rsi
mov rcx, [rsp+98h+var_70]
mov r8d, [rsp+98h+var_84]
mov r13d, r9d
call ntt_fft
test eax, eax
jnz loc_93493
test r13d, r13d
mov r9d, r13d
mov r13, rbp
mov rbp, rbx
mov rbx, r14
mov r14, r15
mov r15, [rsp+98h+var_38]
jnz short loc_933A2
mov rdi, [rsp+98h+var_68]
mov rsi, r13
mov rdx, r14
mov rcx, rbp
mov r8, rbx
call mul_trig
mov r9d, [rsp+98h+arg_0]
loc_933A2:
mov rax, r14
mul [rsp+98h+var_40]
mov rsi, rax
mov rcx, rdx
mov rax, rdx
shld rax, rsi, 3
mul rbx
mov rax, rdx
mul rbp
add rax, [rsp+98h+var_48]
adc rdx, 0
sub rsi, rax
sbb rcx, rdx
mov rax, rcx
sar rax, 1
and rax, rbp
add rax, rsi
adc rcx, 0
and rcx, rbp
lea r14, [rcx+rax]
mov rsi, [rsp+98h+var_68]
add rsi, r12
dec r15
jnz loc_93302
test r13, r13
mov r10, [rsp+98h+var_60]
mov r11, [rsp+98h+var_58]
jz short loc_9343A
mov rax, [rsp+98h+var_78]
mov rcx, [rsp+98h+var_80]
xor edx, edx
loc_93413:
mov rsi, rcx
xor edi, edi
loc_93418:
mov r8, [rsi]
mov [rax+rdi*8], r8
inc rdi
add rsi, r12
cmp rdi, 10h
jnz short loc_93418
inc rdx
add rcx, 8
add rax, r11
cmp rdx, r13
jnz short loc_93413
loc_9343A:
mov rax, [rsp+98h+var_50]
add rax, 10h
sub [rsp+98h+var_78], 0FFFFFFFFFFFFFF80h
cmp rax, r10
jb loc_932BA
loc_93452:
mov rax, [rsp+98h+var_90]
mov rax, [rax]
mov rdi, [rax]
xor ebx, ebx
mov rsi, [rsp+98h+var_80]
xor edx, edx
call qword ptr [rax+8]
mov r14, [rsp+98h+var_70]
jmp short loc_934BF
loc_93470:
mov [rsp+98h+var_98], eax
mov rdi, [rsp+98h+var_90]
mov rsi, rbp
mov rdx, rbp
mov rcx, r14
mov r8d, [rsp+98h+var_84]
call ntt_fft
xor ebx, ebx
test eax, eax
jnz short loc_9349D
jmp short loc_934BF
loc_93493:
mov rbx, [rsp+98h+var_80]
mov r14, [rsp+98h+var_70]
loc_9349D:
test rbx, rbx
jz short loc_934B5
mov rax, [rsp+98h+var_90]
mov rax, [rax]
mov rdi, [rax]
mov rsi, rbx
xor edx, edx
call qword ptr [rax+8]
loc_934B5:
mov ebx, 0FFFFFFFFh
test r14, r14
jz short loc_934D2
loc_934BF:
mov rax, [rsp+98h+var_90]
mov rax, [rax]
mov rdi, [rax]
mov rsi, r14
xor edx, edx
call qword ptr [rax+8]
loc_934D2:
mov eax, ebx
add rsp, 68h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
|
long long ntt_fft_partial(
_QWORD **a1,
long long a2,
int a3,
int a4,
long long a5,
unsigned long long a6,
unsigned int a7,
long long a8)
{
long long v8; // r13
long long v10; // r12
long long v11; // rbx
long long v12; // rcx
long long v13; // r8
long long v14; // r14
long long *v15; // rcx
long long v16; // r8
long long v17; // r9
unsigned long long v18; // rbp
_QWORD *v19; // rbx
long long v20; // r11
long long v21; // r14
long long v22; // rax
long long v23; // rax
_QWORD *v24; // rcx
long long i; // rdx
_QWORD *v26; // rsi
long long j; // rdi
long long v28; // r15
long long v29; // rsi
long long v30; // r15
unsigned long long v31; // r14
unsigned long long v32; // rbx
long long v33; // rbp
unsigned int v34; // r13d
bool v35; // zf
unsigned __int128 v36; // rax
long long v37; // rax
long long k; // rdx
long long *v39; // rsi
long long m; // rdi
long long v44; // [rsp+18h] [rbp-80h]
long long v45; // [rsp+20h] [rbp-78h]
long long v46; // [rsp+28h] [rbp-70h]
long long v48; // [rsp+48h] [rbp-50h]
long long v49; // [rsp+50h] [rbp-48h]
unsigned long long v50; // [rsp+58h] [rbp-40h]
long long v51; // [rsp+60h] [rbp-38h]
v8 = a5;
v10 = 8 * a5;
v11 = 0LL;
v14 = ((long long ( *)(_QWORD, _QWORD, long long))(*a1)[1])(**a1, 0LL, 8 * a5);
if ( v14 )
{
if ( a4 )
{
v11 = 0LL;
v44 = ((long long ( *)(_QWORD, _QWORD, long long, long long, long long, _QWORD))(*a1)[1])(
**a1,
0LL,
v8 << 7,
v12,
v13,
a7);
if ( v44 )
{
v45 = a2;
v46 = v14;
v17 = a7;
if ( a6 )
{
v18 = ntt_mods[a8];
v19 = a1[a8 + 1];
v50 = (unsigned long long)(&(&(&a1[104 * a8])[52 * a7])[a3])[a4 + 6];
v49 = 2 * v18;
v20 = 8 * a6;
v21 = 1LL;
v22 = 0LL;
do
{
v48 = v22;
if ( v8 )
{
v23 = v45;
v24 = (_QWORD *)v44;
for ( i = 0LL; i != v8; ++i )
{
v26 = v24;
for ( j = 0LL; j != 16; ++j )
{
*v26 = *(_QWORD *)(v23 + 8 * j);
v26 = (_QWORD *)((char *)v26 + v10);
}
++v24;
v23 += v20;
}
}
v28 = 16LL;
v29 = v44;
do
{
v51 = v28;
if ( (_DWORD)v17 )
{
mul_trig(v29, v8, v21, v18, v19);
LODWORD(v17) = a7;
}
v30 = v21;
v31 = (unsigned long long)v19;
v32 = v18;
v33 = v8;
v34 = v17;
if ( (unsigned int)ntt_fft((_DWORD)a1, v29, v29, v46, a3, v17, a8) )
{
v11 = v44;
v14 = v46;
goto LABEL_28;
}
v35 = v34 == 0;
v17 = v34;
v8 = v33;
v18 = v32;
v19 = (_QWORD *)v31;
if ( v35 )
{
mul_trig(v29, v8, v30, v18, v31);
v17 = a7;
}
v36 = (unsigned long long)v49
+ v18
* ((v31
* (unsigned __int128)(unsigned long long)((__int128)(v50 * (unsigned __int128)(unsigned long long)v30) >> 61)) >> 64);
v15 = (long long *)(v18 & ((v50 * (unsigned __int128)(unsigned long long)v30
- v36
+ (v18 & ((long long)((v50 * (unsigned __int128)(unsigned long long)v30 - v36) >> 64) >> 1))) >> 64));
v21 = (long long)v15
+ v50 * v30
- v36
+ (v18 & ((long long)((v50 * (unsigned __int128)(unsigned long long)v30 - v36) >> 64) >> 1));
v29 += v10;
v28 = v51 - 1;
}
while ( v51 != 1 );
v20 = 8 * a6;
if ( v8 )
{
v37 = v45;
v15 = (long long *)v44;
for ( k = 0LL; k != v8; ++k )
{
v39 = v15;
for ( m = 0LL; m != 16; ++m )
{
v16 = *v39;
*(_QWORD *)(v37 + 8 * m) = *v39;
v39 = (long long *)((char *)v39 + v10);
}
++v15;
v37 += 8 * a6;
}
}
v22 = v48 + 16;
v45 += 128LL;
}
while ( v48 + 16 < a6 );
}
LODWORD(v11) = 0;
((void ( *)(_QWORD, long long, _QWORD, long long *, long long, long long))(*a1)[1])(
**a1,
v44,
0LL,
v15,
v16,
v17);
v14 = v46;
goto LABEL_31;
}
}
else
{
v11 = 0LL;
if ( !(unsigned int)ntt_fft((_DWORD)a1, a2, a2, v14, a3, a7, a8) )
{
LABEL_31:
((void ( *)(_QWORD, long long, _QWORD))(*a1)[1])(**a1, v14, 0LL);
return (unsigned int)v11;
}
}
}
LABEL_28:
if ( v11 )
((void ( *)(_QWORD, long long, _QWORD))(*a1)[1])(**a1, v11, 0LL);
LODWORD(v11) = -1;
if ( v14 )
goto LABEL_31;
return (unsigned int)v11;
}
|
ntt_fft_partial:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RSP + 0x38],R9
MOV R13,R8
MOV R15D,ECX
MOV dword ptr [RSP + 0x14],EDX
MOV RBP,RSI
LEA R12,[R8*0x8]
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr [RDI]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
XOR ESI,ESI
MOV RDX,R12
CALL qword ptr [RAX + 0x8]
MOV R14,RAX
TEST RAX,RAX
JZ 0x0019349d
MOV RAX,qword ptr [RSP + 0xa8]
MOV R9D,dword ptr [RSP + 0xa0]
TEST R15D,R15D
JZ 0x00193470
MOV RDX,R13
SHL RDX,0x7
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
XOR ESI,ESI
CALL qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x18],RAX
TEST RAX,RAX
JZ 0x0019349d
MOV qword ptr [RSP + 0x20],RBP
MOV qword ptr [RSP + 0x28],R14
MOV RSI,qword ptr [RSP + 0x38]
TEST RSI,RSI
MOV R9D,dword ptr [RSP + 0xa0]
JZ 0x00193452
LEA RAX,[0x1a1960]
MOV RDX,qword ptr [RSP + 0xa8]
MOV RBP,qword ptr [RAX + RDX*0x8]
MOV RCX,qword ptr [RSP + 0x8]
MOV RBX,qword ptr [RCX + RDX*0x8 + 0x8]
IMUL RAX,RDX,0x340
ADD RAX,RCX
MOV ECX,R9D
ADD R15D,dword ptr [RSP + 0x14]
MOVSXD RDX,R15D
IMUL RCX,RCX,0x1a0
ADD RCX,RAX
MOV RAX,qword ptr [RCX + RDX*0x8 + 0x30]
MOV qword ptr [RSP + 0x58],RAX
LEA RAX,[RBP*0x2]
MOV qword ptr [RSP + 0x50],RAX
LEA R11,[RSI*0x8]
MOV R14D,0x1
XOR EAX,EAX
MOV qword ptr [RSP + 0x40],R11
LAB_001932ba:
MOV qword ptr [RSP + 0x48],RAX
TEST R13,R13
JZ 0x001932f7
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
XOR EDX,EDX
LAB_001932d0:
MOV RSI,RCX
XOR EDI,EDI
LAB_001932d5:
MOV R8,qword ptr [RAX + RDI*0x8]
MOV qword ptr [RSI],R8
INC RDI
ADD RSI,R12
CMP RDI,0x10
JNZ 0x001932d5
INC RDX
ADD RCX,0x8
ADD RAX,R11
CMP RDX,R13
JNZ 0x001932d0
LAB_001932f7:
MOV R15D,0x10
MOV RSI,qword ptr [RSP + 0x18]
LAB_00193302:
MOV qword ptr [RSP + 0x60],R15
TEST R9D,R9D
MOV qword ptr [RSP + 0x30],RSI
JZ 0x00193332
MOV RDI,RSI
MOV RSI,R13
MOV RDX,R14
MOV RCX,RBP
MOV R8,RBX
CALL 0x001936f2
MOV RSI,qword ptr [RSP + 0x30]
MOV R9D,dword ptr [RSP + 0xa0]
LAB_00193332:
MOV R15,R14
MOV R14,RBX
MOV RBX,RBP
MOV RBP,R13
MOV RAX,qword ptr [RSP + 0xa8]
MOV dword ptr [RSP],EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RDX,RSI
MOV RCX,qword ptr [RSP + 0x28]
MOV R8D,dword ptr [RSP + 0x14]
MOV R13D,R9D
CALL 0x001934e3
TEST EAX,EAX
JNZ 0x00193493
TEST R13D,R13D
MOV R9D,R13D
MOV R13,RBP
MOV RBP,RBX
MOV RBX,R14
MOV R14,R15
MOV R15,qword ptr [RSP + 0x60]
JNZ 0x001933a2
MOV RDI,qword ptr [RSP + 0x30]
MOV RSI,R13
MOV RDX,R14
MOV RCX,RBP
MOV R8,RBX
CALL 0x001936f2
MOV R9D,dword ptr [RSP + 0xa0]
LAB_001933a2:
MOV RAX,R14
MUL qword ptr [RSP + 0x58]
MOV RSI,RAX
MOV RCX,RDX
MOV RAX,RDX
SHLD RAX,RSI,0x3
MUL RBX
MOV RAX,RDX
MUL RBP
ADD RAX,qword ptr [RSP + 0x50]
ADC RDX,0x0
SUB RSI,RAX
SBB RCX,RDX
MOV RAX,RCX
SAR RAX,0x1
AND RAX,RBP
ADD RAX,RSI
ADC RCX,0x0
AND RCX,RBP
LEA R14,[RCX + RAX*0x1]
MOV RSI,qword ptr [RSP + 0x30]
ADD RSI,R12
DEC R15
JNZ 0x00193302
TEST R13,R13
MOV R10,qword ptr [RSP + 0x38]
MOV R11,qword ptr [RSP + 0x40]
JZ 0x0019343a
MOV RAX,qword ptr [RSP + 0x20]
MOV RCX,qword ptr [RSP + 0x18]
XOR EDX,EDX
LAB_00193413:
MOV RSI,RCX
XOR EDI,EDI
LAB_00193418:
MOV R8,qword ptr [RSI]
MOV qword ptr [RAX + RDI*0x8],R8
INC RDI
ADD RSI,R12
CMP RDI,0x10
JNZ 0x00193418
INC RDX
ADD RCX,0x8
ADD RAX,R11
CMP RDX,R13
JNZ 0x00193413
LAB_0019343a:
MOV RAX,qword ptr [RSP + 0x48]
ADD RAX,0x10
SUB qword ptr [RSP + 0x20],-0x80
CMP RAX,R10
JC 0x001932ba
LAB_00193452:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
XOR EBX,EBX
MOV RSI,qword ptr [RSP + 0x18]
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
MOV R14,qword ptr [RSP + 0x28]
JMP 0x001934bf
LAB_00193470:
MOV dword ptr [RSP],EAX
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,RBP
MOV RDX,RBP
MOV RCX,R14
MOV R8D,dword ptr [RSP + 0x14]
CALL 0x001934e3
XOR EBX,EBX
TEST EAX,EAX
JNZ 0x0019349d
JMP 0x001934bf
LAB_00193493:
MOV RBX,qword ptr [RSP + 0x18]
MOV R14,qword ptr [RSP + 0x28]
LAB_0019349d:
TEST RBX,RBX
JZ 0x001934b5
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
MOV RSI,RBX
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_001934b5:
MOV EBX,0xffffffff
TEST R14,R14
JZ 0x001934d2
LAB_001934bf:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX]
MOV RSI,R14
XOR EDX,EDX
CALL qword ptr [RAX + 0x8]
LAB_001934d2:
MOV EAX,EBX
ADD RSP,0x68
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
ntt_fft_partial(long *param_1,long param_2,int param_3,int param_4,long param_5,ulong param_6,
uint param_7,long param_8)
{
ulong uVar1;
ulong uVar2;
ulong uVar3;
int1 auVar4 [16];
int1 auVar5 [16];
int1 auVar6 [16];
int1 auVar7 [16];
int1 auVar8 [16];
int1 auVar9 [16];
int1 auVar10 [16];
int1 auVar11 [16];
int iVar12;
long lVar13;
int8 *puVar14;
long lVar15;
ulong uVar16;
int8 *puVar17;
long lVar18;
int8 uVar19;
int8 *puVar20;
long lVar21;
ulong uVar22;
long local_78;
lVar13 = (*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,0,param_5 * 8);
puVar17 = (int8 *)0x0;
if (lVar13 != 0) {
if (param_4 == 0) {
iVar12 = ntt_fft(param_1,param_2,param_2,lVar13,param_3,param_7,(int)param_8);
uVar19 = 0;
puVar17 = (int8 *)0x0;
if (iVar12 == 0) goto LAB_001934bf;
}
else {
puVar14 = (int8 *)
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,0,param_5 << 7);
puVar17 = (int8 *)0x0;
if (puVar14 != (int8 *)0x0) {
if (param_6 != 0) {
uVar1 = (&ntt_mods)[param_8];
uVar2 = param_1[param_8 + 1];
uVar3 = param_1[param_8 * 0x68 + (ulong)param_7 * 0x34 + (long)(param_4 + param_3) + 6];
auVar11._8_8_ = 0;
auVar11._0_8_ = uVar1 * 2;
uVar22 = 1;
uVar16 = 0;
local_78 = param_2;
do {
if (param_5 != 0) {
lVar18 = 0;
lVar15 = local_78;
puVar17 = puVar14;
do {
lVar21 = 0;
puVar20 = puVar17;
do {
*puVar20 = *(int8 *)(lVar15 + lVar21 * 8);
lVar21 = lVar21 + 1;
puVar20 = puVar20 + param_5;
} while (lVar21 != 0x10);
lVar18 = lVar18 + 1;
puVar17 = puVar17 + 1;
lVar15 = lVar15 + param_6 * 8;
} while (lVar18 != param_5);
}
lVar15 = 0x10;
puVar20 = puVar14;
do {
if (param_7 != 0) {
mul_trig(puVar20,param_5,uVar22,uVar1,uVar2);
}
iVar12 = ntt_fft(param_1,puVar20,puVar20,lVar13,param_3,param_7,(int)param_8);
puVar17 = puVar14;
if (iVar12 != 0) goto LAB_0019349d;
if (param_7 == 0) {
mul_trig(puVar20,param_5,uVar22,uVar1,uVar2);
}
auVar4._8_8_ = 0;
auVar4._0_8_ = uVar22;
auVar7._8_8_ = 0;
auVar7._0_8_ = uVar3;
auVar4 = auVar4 * auVar7;
auVar5._8_8_ = 0;
auVar5._0_8_ = auVar4._8_8_ << 3 | auVar4._0_8_ >> 0x3d;
auVar8._8_8_ = 0;
auVar8._0_8_ = uVar2;
auVar6._8_8_ = 0;
auVar6._0_8_ = SUB168(auVar5 * auVar8,8);
auVar9._8_8_ = 0;
auVar9._0_8_ = uVar1;
auVar4 = auVar4 - (auVar6 * auVar9 + auVar11);
auVar10._8_8_ = 0;
auVar10._0_8_ = auVar4._8_8_ >> 1 & uVar1;
auVar4 = auVar4 + auVar10;
uVar22 = (auVar4._8_8_ & uVar1) + auVar4._0_8_;
puVar20 = puVar20 + param_5;
lVar15 = lVar15 + -1;
} while (lVar15 != 0);
if (param_5 != 0) {
lVar18 = 0;
lVar15 = local_78;
do {
lVar21 = 0;
puVar20 = puVar17;
do {
*(int8 *)(lVar15 + lVar21 * 8) = *puVar20;
lVar21 = lVar21 + 1;
puVar20 = puVar20 + param_5;
} while (lVar21 != 0x10);
lVar18 = lVar18 + 1;
puVar17 = puVar17 + 1;
lVar15 = lVar15 + param_6 * 8;
} while (lVar18 != param_5);
}
uVar16 = uVar16 + 0x10;
local_78 = local_78 + 0x80;
} while (uVar16 < param_6);
}
uVar19 = 0;
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,puVar14,0);
goto LAB_001934bf;
}
}
}
LAB_0019349d:
if (puVar17 != (int8 *)0x0) {
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,puVar17,0);
}
uVar19 = 0xffffffff;
if (lVar13 == 0) {
return 0xffffffff;
}
LAB_001934bf:
(*(code *)((int8 *)*param_1)[1])(*(int8 *)*param_1,lVar13,0);
return uVar19;
}
|
|
7,774 |
js_free_modules
|
bluesky950520[P]quickjs/quickjs.c
|
static void js_free_modules(JSContext *ctx, JSFreeModuleEnum flag)
{
struct list_head *el, *el1;
list_for_each_safe(el, el1, &ctx->loaded_modules) {
JSModuleDef *m = list_entry(el, JSModuleDef, link);
if (flag == JS_FREE_MODULE_ALL ||
(flag == JS_FREE_MODULE_NOT_RESOLVED && !m->resolved)) {
js_free_module_def(ctx, m);
}
}
}
|
O0
|
c
|
js_free_modules:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq 0x1e8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1e0, %rcx # imm = 0x1E0
cmpq %rcx, %rax
je 0x2e18c
movq 0x10(%rsp), %rax
addq $-0x8, %rax
movq %rax, (%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x2e162
cmpl $0x1, 0x1c(%rsp)
jne 0x2e170
movq (%rsp), %rax
movl 0x80(%rax), %eax
shll $0x10, %eax
sarl $0x18, %eax
cmpl $0x0, %eax
jne 0x2e170
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x628e0
jmp 0x2e172
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2e11c
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
|
js_free_modules:
sub rsp, 28h
mov [rsp+28h+var_8], rdi
mov [rsp+28h+var_C], esi
mov rax, [rsp+28h+var_8]
mov rax, [rax+1E8h]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov rax, [rax+8]
mov [rsp+28h+var_20], rax
loc_2E11C:
mov rax, [rsp+28h+var_18]
mov rcx, [rsp+28h+var_8]
add rcx, 1E0h
cmp rax, rcx
jz short loc_2E18C
mov rax, [rsp+28h+var_18]
add rax, 0FFFFFFFFFFFFFFF8h
mov [rsp+28h+var_28], rax
cmp [rsp+28h+var_C], 0
jz short loc_2E162
cmp [rsp+28h+var_C], 1
jnz short loc_2E170
mov rax, [rsp+28h+var_28]
mov eax, [rax+80h]
shl eax, 10h
sar eax, 18h
cmp eax, 0
jnz short loc_2E170
loc_2E162:
mov rdi, [rsp+28h+var_8]
mov rsi, [rsp+28h+var_28]
call js_free_module_def
loc_2E170:
jmp short $+2
loc_2E172:
mov rax, [rsp+28h+var_20]
mov [rsp+28h+var_18], rax
mov rax, [rsp+28h+var_18]
mov rax, [rax+8]
mov [rsp+28h+var_20], rax
jmp short loc_2E11C
loc_2E18C:
add rsp, 28h
retn
|
long long js_free_modules(long long a1, int a2)
{
long long result; // rax
long long v3; // [rsp+0h] [rbp-28h]
long long i; // [rsp+8h] [rbp-20h]
long long v5; // [rsp+10h] [rbp-18h]
v5 = *(_QWORD *)(a1 + 488);
for ( i = *(_QWORD *)(v5 + 8); ; i = *(_QWORD *)(i + 8) )
{
result = v5;
if ( v5 == a1 + 480 )
break;
v3 = v5 - 8;
if ( !a2 || a2 == 1 && !((int)(*(_DWORD *)(v3 + 128) << 16) >> 24) )
js_free_module_def(a1, v3);
v5 = i;
}
return result;
}
|
js_free_modules:
SUB RSP,0x28
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ESI
MOV RAX,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RAX + 0x1e8]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
LAB_0012e11c:
MOV RAX,qword ptr [RSP + 0x10]
MOV RCX,qword ptr [RSP + 0x20]
ADD RCX,0x1e0
CMP RAX,RCX
JZ 0x0012e18c
MOV RAX,qword ptr [RSP + 0x10]
ADD RAX,-0x8
MOV qword ptr [RSP],RAX
CMP dword ptr [RSP + 0x1c],0x0
JZ 0x0012e162
CMP dword ptr [RSP + 0x1c],0x1
JNZ 0x0012e170
MOV RAX,qword ptr [RSP]
MOV EAX,dword ptr [RAX + 0x80]
SHL EAX,0x10
SAR EAX,0x18
CMP EAX,0x0
JNZ 0x0012e170
LAB_0012e162:
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP]
CALL 0x001628e0
LAB_0012e170:
JMP 0x0012e172
LAB_0012e172:
MOV RAX,qword ptr [RSP + 0x8]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RSP + 0x8],RAX
JMP 0x0012e11c
LAB_0012e18c:
ADD RSP,0x28
RET
|
void js_free_modules(long param_1,int param_2)
{
int8 local_20;
int8 local_18;
local_18 = *(long *)(param_1 + 0x1e8);
local_20 = *(long *)(local_18 + 8);
while (local_18 != param_1 + 0x1e0) {
if ((param_2 == 0) || ((param_2 == 1 && ((*(int *)(local_18 + 0x78) << 0x10) >> 0x18 == 0)))) {
js_free_module_def(param_1,local_18 + -8);
}
local_18 = local_20;
local_20 = *(long *)(local_20 + 8);
}
return;
}
|
|
7,775 |
mju_free
|
aimrt_mujoco_sim/_deps/mujoco-src/src/engine/engine_util_errmem.c
|
void mju_free(void* ptr) {
// return if null
if (!ptr) {
return;
}
// free with user or built-in function
if (mju_user_free) {
mju_user_free(ptr);
} else {
mju_alignedFree(ptr);
}
}
|
O3
|
c
|
mju_free:
testq %rdi, %rdi
je 0x9ca40
movq 0x1d54ba(%rip), %rax # 0x271ef0
movq (%rax), %rax
testq %rax, %rax
je 0x9ca41
jmpq *%rax
retq
jmp 0x2e430
|
mju_free:
test rdi, rdi
jz short locret_9CA40
mov rax, cs:mju_user_free_ptr
mov rax, [rax]
test rax, rax
jz short loc_9CA41
jmp rax
locret_9CA40:
retn
loc_9CA41:
jmp _free
|
long long mju_free(long long a1)
{
long long result; // rax
if ( a1 )
{
if ( mju_user_free )
return mju_user_free();
else
return free();
}
return result;
}
|
mju_free:
TEST RDI,RDI
JZ 0x0019ca40
MOV RAX,qword ptr [0x00371ef0]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0019ca41
JMP RAX
LAB_0019ca40:
RET
LAB_0019ca41:
JMP 0x0012e430
|
void mju_free(void *param_1)
{
if (param_1 == (void *)0x0) {
return;
}
if (*(code **)PTR_mju_user_free_00371ef0 != (code *)0x0) {
/* WARNING: Could not recover jumptable at 0x0019ca3e. Too many branches */
/* WARNING: Treating indirect jump as call */
(**(code **)PTR_mju_user_free_00371ef0)();
return;
}
free(param_1);
return;
}
|
|
7,776 |
malloc_debug
|
seiftnesse[P]memoryallocator/src/custom_alloc_debug.c
|
void *_malloc_debug(size_t size, const char *file, int line) {
HEAP_LOG("Debug malloc: size=%zu, file=%s, line=%d\n", size, file ? file : "unknown", line);
void *ptr = _malloc(size);
if (ptr && !is_small_allocation(ptr) && track_allocations) {
segment_t *s = PtrToSegment(ptr);
s->allocation_file = file;
s->allocation_line = line;
HEAP_LOG("Debug info recorded for allocation: %p, id=%u\n", ptr, s->allocation_id);
}
return ptr;
}
|
O3
|
c
|
malloc_debug:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
callq 0x172f
movq %rax, %r15
testq %rax, %rax
je 0x26c5
movq %r15, %rdi
callq 0x1dd3
testl %eax, %eax
jne 0x26c5
cmpl $0x0, 0x4103a40(%rip) # 0x41060f4
je 0x26c5
movq %r15, %rdi
callq 0x1f9c
movq %r14, 0x18(%rax)
movl %ebx, 0x20(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
|
_malloc_debug:
push r15
push r14
push rbx
mov ebx, edx
mov r14, rsi
call _malloc
mov r15, rax
test rax, rax
jz short loc_26C5
mov rdi, r15
call is_small_allocation
test eax, eax
jnz short loc_26C5
cmp cs:track_allocations, 0
jz short loc_26C5
mov rdi, r15
call PtrToSegment
mov [rax+18h], r14
mov [rax+20h], ebx
loc_26C5:
mov rax, r15
pop rbx
pop r14
pop r15
retn
|
long long malloc_debug(unsigned long long a1, long long a2, int a3)
{
unsigned long long v4; // rax
long long v5; // r15
unsigned long long v6; // rax
v4 = malloc(a1);
v5 = v4;
if ( v4 && !(unsigned int)is_small_allocation(v4) && track_allocations )
{
v6 = PtrToSegment(v5);
*(_QWORD *)(v6 + 24) = a2;
*(_DWORD *)(v6 + 32) = a3;
}
return v5;
}
|
_malloc_debug:
PUSH R15
PUSH R14
PUSH RBX
MOV EBX,EDX
MOV R14,RSI
CALL 0x0010172f
MOV R15,RAX
TEST RAX,RAX
JZ 0x001026c5
MOV RDI,R15
CALL 0x00101dd3
TEST EAX,EAX
JNZ 0x001026c5
CMP dword ptr [0x042060f4],0x0
JZ 0x001026c5
MOV RDI,R15
CALL 0x00101f9c
MOV qword ptr [RAX + 0x18],R14
MOV dword ptr [RAX + 0x20],EBX
LAB_001026c5:
MOV RAX,R15
POP RBX
POP R14
POP R15
RET
|
void * _malloc_debug(size_t param_1,int8 param_2,int4 param_3)
{
int iVar1;
void *pvVar2;
long lVar3;
pvVar2 = _malloc(param_1);
if (pvVar2 != (void *)0x0) {
iVar1 = is_small_allocation(pvVar2);
if ((iVar1 == 0) && (track_allocations != 0)) {
lVar3 = PtrToSegment(pvVar2);
*(int8 *)(lVar3 + 0x18) = param_2;
*(int4 *)(lVar3 + 0x20) = param_3;
}
}
return pvVar2;
}
|
|
7,777 |
mysql_stmt_fetch
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
}
|
O0
|
c
|
mysql_stmt_fetch:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x50(%rax)
ja 0x440a7
jmp 0x44038
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x3ce48(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x3ce2e(%rip), %rax # 0x80eb0
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x44275
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jb 0x440bb
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x4412c
jmp 0x440bd
movq -0x10(%rbp), %rax
movl $0x7de, 0x108(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x3cdc3(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x3cda9(%rip), %rax # 0x80eb0
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x44275
movq -0x10(%rbp), %rax
cmpl $0x3, 0x50(%rax)
jne 0x44147
movq -0x10(%rbp), %rax
movq 0x358(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x44149
movq -0x10(%rbp), %rax
cmpl $0x6, 0x50(%rax)
jne 0x4415f
movl $0x64, -0x4(%rbp)
jmp 0x44275
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x441ac
movq -0x10(%rbp), %rax
movl $0x6, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x488(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x44275
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x4d0(%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x5, 0x50(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x269b0(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x4423b
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x4423d
jmp 0x4423f
movq -0x10(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x26950(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x10(%rbp), %rax
movb $0x0, 0x10c(%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
|
mysql_stmt_fetch:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 2
ja short loc_440A7
jmp short $+2
loc_44038:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_44275
loc_440A7:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jb short loc_440BB
mov rax, [rbp+var_10]
cmp dword ptr [rax+60h], 0
jnz short loc_4412C
loc_440BB:
jmp short $+2
loc_440BD:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+312h], 0
mov rdi, [rbp+var_10]
add rdi, 10Ch
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_44275
loc_4412C:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 3
jnz short loc_44147
mov rax, [rbp+var_10]
mov rax, [rax+358h]
mov rdi, [rbp+var_10]
call rax
loc_44147:
jmp short $+2
loc_44149:
mov rax, [rbp+var_10]
cmp dword ptr [rax+50h], 6
jnz short loc_4415F
mov [rbp+var_4], 64h ; 'd'
jmp loc_44275
loc_4415F:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+68h]
mov rdi, [rbp+var_10]
lea rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
cmp eax, 0
jz short loc_441AC
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 6
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+488h], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
jmp loc_44275
loc_441AC:
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+4D0h]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call rax
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
mov dword ptr [rax+50h], 5
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov dword ptr [rax+90h], 0
mov rax, [rbp+var_10]
mov rdi, [rax+38h]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
mov rax, [rax+38h]
cmp qword ptr [rax+2A0h], 0
jz short loc_4423B
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_4423B:
jmp short $+2
loc_4423D:
jmp short $+2
loc_4423F:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 0
mov rdi, [rbp+var_10]
add rdi, 30Dh
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+10Ch], 0
mov eax, [rbp+var_1C]
mov [rbp+var_4], eax
loc_44275:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
|
long long mysql_stmt_fetch(long long a1)
{
unsigned int v2; // [rsp+4h] [rbp-1Ch]
unsigned int v3; // [rsp+4h] [rbp-1Ch]
long long v4; // [rsp+8h] [rbp-18h] BYREF
long long v5; // [rsp+10h] [rbp-10h]
v5 = a1;
if ( *(_DWORD *)(a1 + 80) > 2u && *(_DWORD *)(v5 + 80) >= 3u && *(_DWORD *)(v5 + 96) )
{
if ( *(_DWORD *)(v5 + 80) == 3 )
(*(void ( **)(long long))(v5 + 856))(v5);
if ( *(_DWORD *)(v5 + 80) == 6 )
{
return 100;
}
else
{
v2 = (*(long long ( **)(long long, long long *))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 104LL))(v5, &v4);
if ( v2 )
{
*(_DWORD *)(v5 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 1160LL) = 0;
return v2;
}
else
{
v3 = (*(long long ( **)(long long, long long))(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 1232LL) + 112LL))(v5, v4);
*(_DWORD *)(v5 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(v5 + 56) + 144LL) = 0;
strcpy(*(_QWORD *)(v5 + 56) + 663LL, "00000");
*(_BYTE *)(*(_QWORD *)(v5 + 56) + 151LL) = 0;
if ( *(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) )
*(_DWORD *)(*(_QWORD *)(*(_QWORD *)(v5 + 56) + 672LL) + 4LL) = 0;
*(_DWORD *)(v5 + 264) = 0;
strcpy(v5 + 781, "00000");
*(_BYTE *)(v5 + 268) = 0;
return v3;
}
}
}
else
{
*(_DWORD *)(v5 + 264) = 2014;
strncpy(v5 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(v5 + 786) = 0;
strncpy(v5 + 268, client_errors[14], 512LL);
*(_BYTE *)(v5 + 779) = 0;
return 1;
}
}
|
mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x2
JA 0x001440a7
JMP 0x00144038
LAB_00144038:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00144275
LAB_001440a7:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JC 0x001440bb
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x60],0x0
JNZ 0x0014412c
LAB_001440bb:
JMP 0x001440bd
LAB_001440bd:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00144275
LAB_0014412c:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x3
JNZ 0x00144147
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x358]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
LAB_00144147:
JMP 0x00144149
LAB_00144149:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x50],0x6
JNZ 0x0014415f
MOV dword ptr [RBP + -0x4],0x64
JMP 0x00144275
LAB_0014415f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x68]
MOV RDI,qword ptr [RBP + -0x10]
LEA RSI,[RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
CMP EAX,0x0
JZ 0x001441ac
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x6
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x488],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00144275
LAB_001441ac:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x50],0x5
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV dword ptr [RAX + 0x90],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x38]
ADD RDI,0x297
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x0014423b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_0014423b:
JMP 0x0014423d
LAB_0014423d:
JMP 0x0014423f
LAB_0014423f:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x10c],0x0
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x4],EAX
LAB_00144275:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int mysql_stmt_fetch(long param_1)
{
int iVar1;
int8 local_20;
long local_18;
int local_c;
local_18 = param_1;
if (*(uint *)(param_1 + 0x50) < 3) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_00180f20,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else if ((*(uint *)(param_1 + 0x50) < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(local_18 + 0x312) = 0;
strncpy((char *)(local_18 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_00180f20,0x200);
*(int1 *)(local_18 + 0x30b) = 0;
local_c = 1;
}
else {
if (*(int *)(param_1 + 0x50) == 3) {
(**(code **)(param_1 + 0x358))(param_1);
}
if (*(int *)(local_18 + 0x50) == 6) {
local_c = 100;
}
else {
local_c = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x68))
(local_18,&local_20);
if (local_c == 0) {
iVar1 = (**(code **)(*(long *)(*(long *)(local_18 + 0x38) + 0x4d0) + 0x70))
(local_18,local_20);
*(int4 *)(local_18 + 0x50) = 5;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x90) = 0;
strcpy((char *)(*(long *)(local_18 + 0x38) + 0x297),"00000");
*(int1 *)(*(long *)(local_18 + 0x38) + 0x97) = 0;
if (*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) != 0) {
*(int4 *)(*(long *)(*(long *)(local_18 + 0x38) + 0x2a0) + 4) = 0;
}
*(int4 *)(local_18 + 0x108) = 0;
strcpy((char *)(local_18 + 0x30d),"00000");
*(int1 *)(local_18 + 0x10c) = 0;
local_c = iVar1;
}
else {
*(int4 *)(local_18 + 0x50) = 6;
*(int4 *)(*(long *)(local_18 + 0x38) + 0x488) = 0;
}
}
}
return local_c;
}
|
|
7,778 |
mysql_stmt_fetch
|
eloqsql/libmariadb/libmariadb/mariadb_stmt.c
|
int STDCALL mysql_stmt_fetch(MYSQL_STMT *stmt)
{
unsigned char *row;
int rc;
if (stmt->state <= MYSQL_STMT_EXECUTED)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (stmt->state < MYSQL_STMT_WAITING_USE_OR_STORE || !stmt->field_count)
{
SET_CLIENT_STMT_ERROR(stmt, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
return(1);
} else if (stmt->state== MYSQL_STMT_WAITING_USE_OR_STORE)
{
stmt->default_rset_handler(stmt);
}
if (stmt->state == MYSQL_STMT_FETCH_DONE)
return(MYSQL_NO_DATA);
if ((rc= stmt->mysql->methods->db_stmt_fetch(stmt, &row)))
{
stmt->state= MYSQL_STMT_FETCH_DONE;
stmt->mysql->status= MYSQL_STATUS_READY;
/* to fetch data again, stmt must be executed again */
return(rc);
}
rc= stmt->mysql->methods->db_stmt_fetch_to_bind(stmt, row);
stmt->state= MYSQL_STMT_USER_FETCHING;
CLEAR_CLIENT_ERROR(stmt->mysql);
CLEAR_CLIENT_STMT_ERROR(stmt);
return(rc);
}
|
O3
|
c
|
mysql_stmt_fetch:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x50(%rdi), %ecx
cmpl $0x2, %ecx
jbe 0x31dde
cmpl $0x0, 0x60(%rbx)
je 0x31dde
cmpl $0x3, %ecx
jne 0x31da0
movq %rbx, %rdi
callq *0x358(%rbx)
movl 0x50(%rbx), %ecx
movl $0x64, %eax
cmpl $0x6, %ecx
je 0x31e35
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x68(%rax)
testl %eax, %eax
je 0x31e3e
movl $0x6, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x488(%rcx)
jmp 0x31e35
movl $0x7de, 0x108(%rbx) # imm = 0x7DE
leaq 0x30d(%rbx), %rdi
leaq 0x30bfa(%rip), %rax # 0x629f0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14230
xorl %r14d, %r14d
movb %r14b, 0x312(%rbx)
leaq 0x10c(%rbx), %rdi
leaq 0x30be5(%rip), %rax # 0x62a00
movq 0x70(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x14230
movb %r14b, 0x30b(%rbx)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x38(%rbx), %rax
movq 0x4d0(%rax), %rax
movq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq *0x70(%rax)
movl $0x5, 0x50(%rbx)
movq 0x38(%rbx), %rcx
movl $0x0, 0x90(%rcx)
movq 0x38(%rbx), %rcx
movl $0x30303030, 0x297(%rcx) # imm = 0x30303030
movw $0x30, 0x29b(%rcx)
movq 0x38(%rbx), %rcx
movb $0x0, 0x97(%rcx)
movq 0x38(%rbx), %rcx
movq 0x2a0(%rcx), %rcx
testq %rcx, %rcx
je 0x31ea1
movl $0x0, 0x4(%rcx)
movl $0x0, 0x108(%rbx)
movl $0x30303030, 0x30d(%rbx) # imm = 0x30303030
movw $0x30, 0x311(%rbx)
movb $0x0, 0x10c(%rbx)
jmp 0x31e35
|
mysql_stmt_fetch:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 10h
mov rbx, rdi
mov ecx, [rdi+50h]
cmp ecx, 2
jbe short loc_31DDE
cmp dword ptr [rbx+60h], 0
jz short loc_31DDE
cmp ecx, 3
jnz short loc_31DA0
mov rdi, rbx
call qword ptr [rbx+358h]
mov ecx, [rbx+50h]
loc_31DA0:
mov eax, 64h ; 'd'
cmp ecx, 6
jz loc_31E35
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
lea rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+68h]
test eax, eax
jz short loc_31E3E
mov dword ptr [rbx+50h], 6
mov rcx, [rbx+38h]
mov dword ptr [rcx+488h], 0
jmp short loc_31E35
loc_31DDE:
mov dword ptr [rbx+108h], 7DEh
lea rdi, [rbx+30Dh]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+312h], r14b
lea rdi, [rbx+10Ch]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 200h
call _strncpy
mov [rbx+30Bh], r14b
mov eax, 1
loc_31E35:
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
loc_31E3E:
mov rax, [rbx+38h]
mov rax, [rax+4D0h]
mov rsi, [rbp+var_18]
mov rdi, rbx
call qword ptr [rax+70h]
mov dword ptr [rbx+50h], 5
mov rcx, [rbx+38h]
mov dword ptr [rcx+90h], 0
mov rcx, [rbx+38h]
mov dword ptr [rcx+297h], 30303030h
mov word ptr [rcx+29Bh], 30h ; '0'
mov rcx, [rbx+38h]
mov byte ptr [rcx+97h], 0
mov rcx, [rbx+38h]
mov rcx, [rcx+2A0h]
test rcx, rcx
jz short loc_31EA1
mov dword ptr [rcx+4], 0
loc_31EA1:
mov dword ptr [rbx+108h], 0
mov dword ptr [rbx+30Dh], 30303030h
mov word ptr [rbx+311h], 30h ; '0'
mov byte ptr [rbx+10Ch], 0
jmp loc_31E35
|
long long mysql_stmt_fetch(long long a1)
{
unsigned int v1; // ecx
long long result; // rax
long long v3; // rcx
_QWORD v4[3]; // [rsp+8h] [rbp-18h] BYREF
v1 = *(_DWORD *)(a1 + 80);
if ( v1 > 2 && *(_DWORD *)(a1 + 96) )
{
if ( v1 == 3 )
{
(*(void ( **)(long long))(a1 + 856))(a1);
v1 = *(_DWORD *)(a1 + 80);
}
result = 100LL;
if ( v1 != 6 )
{
result = (*(long long ( **)(long long, _QWORD *))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 104LL))(
a1,
v4);
if ( (_DWORD)result )
{
*(_DWORD *)(a1 + 80) = 6;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 1160LL) = 0;
}
else
{
result = (*(long long ( **)(long long, _QWORD))(*(_QWORD *)(*(_QWORD *)(a1 + 56) + 1232LL) + 112LL))(
a1,
v4[0]);
*(_DWORD *)(a1 + 80) = 5;
*(_DWORD *)(*(_QWORD *)(a1 + 56) + 144LL) = 0;
strcpy((char *)(*(_QWORD *)(a1 + 56) + 663LL), "00000");
*(_BYTE *)(*(_QWORD *)(a1 + 56) + 151LL) = 0;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 56) + 672LL);
if ( v3 )
*(_DWORD *)(v3 + 4) = 0;
*(_DWORD *)(a1 + 264) = 0;
strcpy((char *)(a1 + 781), "00000");
*(_BYTE *)(a1 + 268) = 0;
}
}
}
else
{
*(_DWORD *)(a1 + 264) = 2014;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[14], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1LL;
}
return result;
}
|
mysql_stmt_fetch:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV ECX,dword ptr [RDI + 0x50]
CMP ECX,0x2
JBE 0x00131dde
CMP dword ptr [RBX + 0x60],0x0
JZ 0x00131dde
CMP ECX,0x3
JNZ 0x00131da0
MOV RDI,RBX
CALL qword ptr [RBX + 0x358]
MOV ECX,dword ptr [RBX + 0x50]
LAB_00131da0:
MOV EAX,0x64
CMP ECX,0x6
JZ 0x00131e35
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
LEA RSI,[RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x68]
TEST EAX,EAX
JZ 0x00131e3e
MOV dword ptr [RBX + 0x50],0x6
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x488],0x0
JMP 0x00131e35
LAB_00131dde:
MOV dword ptr [RBX + 0x108],0x7de
LEA RDI,[RBX + 0x30d]
LEA RAX,[0x1629f0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114230
XOR R14D,R14D
MOV byte ptr [RBX + 0x312],R14B
LEA RDI,[RBX + 0x10c]
LEA RAX,[0x162a00]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x200
CALL 0x00114230
MOV byte ptr [RBX + 0x30b],R14B
MOV EAX,0x1
LAB_00131e35:
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
LAB_00131e3e:
MOV RAX,qword ptr [RBX + 0x38]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDI,RBX
CALL qword ptr [RAX + 0x70]
MOV dword ptr [RBX + 0x50],0x5
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x90],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV dword ptr [RCX + 0x297],0x30303030
MOV word ptr [RCX + 0x29b],0x30
MOV RCX,qword ptr [RBX + 0x38]
MOV byte ptr [RCX + 0x97],0x0
MOV RCX,qword ptr [RBX + 0x38]
MOV RCX,qword ptr [RCX + 0x2a0]
TEST RCX,RCX
JZ 0x00131ea1
MOV dword ptr [RCX + 0x4],0x0
LAB_00131ea1:
MOV dword ptr [RBX + 0x108],0x0
MOV dword ptr [RBX + 0x30d],0x30303030
MOV word ptr [RBX + 0x311],0x30
MOV byte ptr [RBX + 0x10c],0x0
JMP 0x00131e35
|
int8 mysql_stmt_fetch(long param_1)
{
long lVar1;
int8 uVar2;
uint uVar3;
int8 local_20;
uVar3 = *(uint *)(param_1 + 0x50);
if ((uVar3 < 3) || (*(int *)(param_1 + 0x60) == 0)) {
*(int4 *)(param_1 + 0x108) = 0x7de;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Commands_out_of_sync__you_can_t_r_00162a70,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
uVar2 = 1;
}
else {
if (uVar3 == 3) {
(**(code **)(param_1 + 0x358))(param_1);
uVar3 = *(uint *)(param_1 + 0x50);
}
uVar2 = 100;
if (uVar3 != 6) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x68))(param_1,&local_20);
if ((int)uVar2 == 0) {
uVar2 = (**(code **)(*(long *)(*(long *)(param_1 + 0x38) + 0x4d0) + 0x70))(param_1,local_20)
;
*(int4 *)(param_1 + 0x50) = 5;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x90) = 0;
lVar1 = *(long *)(param_1 + 0x38);
*(int4 *)(lVar1 + 0x297) = 0x30303030;
*(int2 *)(lVar1 + 0x29b) = 0x30;
*(int1 *)(*(long *)(param_1 + 0x38) + 0x97) = 0;
lVar1 = *(long *)(*(long *)(param_1 + 0x38) + 0x2a0);
if (lVar1 != 0) {
*(int4 *)(lVar1 + 4) = 0;
}
*(int4 *)(param_1 + 0x108) = 0;
*(int4 *)(param_1 + 0x30d) = 0x30303030;
*(int2 *)(param_1 + 0x311) = 0x30;
*(int1 *)(param_1 + 0x10c) = 0;
}
else {
*(int4 *)(param_1 + 0x50) = 6;
*(int4 *)(*(long *)(param_1 + 0x38) + 0x488) = 0;
}
}
}
return uVar2;
}
|
|
7,779 |
xml_easy_child
|
eloqsql/storage/maria/libmarias3/src/xml.c
|
struct xml_node* xml_easy_child(struct xml_node* node, uint8_t const* child_name, ...) {
/* Find children, one by one
*/
struct xml_node* current = node;
va_list arguments;
va_start(arguments, child_name);
/* Descent to current.child
*/
while (child_name) {
/* Convert child_name to xml_string for easy comparison
*/
struct xml_string cn = {
.buffer = child_name,
.length = strlen((const char*)child_name)
};
/* Interate through all children
*/
struct xml_node* next = 0;
size_t i = 0; for (; i < xml_node_children(current); ++i) {
struct xml_node* child = xml_node_child(current, i);
if (xml_string_equals(xml_node_name(child), &cn)) {
if (!next) {
next = child;
/* Two children with the same name
*/
} else {
va_end(arguments);
return 0;
}
}
}
/* No child with that name found
*/
if (!next) {
va_end(arguments);
return 0;
}
current = next;
/* Find name of next child
*/
child_name = va_arg(arguments, uint8_t const*);
}
va_end(arguments);
/* Return current element
*/
return current;
}
|
O0
|
c
|
xml_easy_child:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
testb %al, %al
je 0x18264
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rcx, -0x108(%rbp)
movq %rdx, -0x110(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x183f2
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa270
movq %rax, -0x48(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x128(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa6a0
movq %rax, %rcx
movq -0x128(%rbp), %rax
cmpq %rcx, %rax
jae 0x1836a
movq -0x20(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0xa630
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xab70
movq %rax, %rdi
leaq -0x50(%rbp), %rsi
callq 0x18410
testb $0x1, %al
jne 0x18333
jmp 0x18357
cmpq $0x0, -0x58(%rbp)
jne 0x18344
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x18355
leaq -0x40(%rbp), %rax
movq $0x0, -0x8(%rbp)
jmp 0x183fe
jmp 0x18357
jmp 0x18359
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x182e4
cmpq $0x0, -0x58(%rbp)
jne 0x1837f
leaq -0x40(%rbp), %rax
movq $0x0, -0x8(%rbp)
jmp 0x183fe
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x138(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x12c(%rbp)
cmpl $0x28, %eax
ja 0x183c2
movq -0x138(%rbp), %rcx
movl -0x12c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x140(%rbp)
jmp 0x183df
movq -0x138(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x182b4
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x140, %rsp # imm = 0x140
popq %rbp
retq
nopl (%rax,%rax)
|
xml_easy_child:
push rbp
mov rbp, rsp
sub rsp, 140h
test al, al
jz short loc_18264
movaps [rbp+var_F0], xmm0
movaps [rbp+var_E0], xmm1
movaps [rbp+var_D0], xmm2
movaps [rbp+var_C0], xmm3
movaps [rbp+var_B0], xmm4
movaps [rbp+var_A0], xmm5
movaps [rbp+var_90], xmm6
movaps [rbp+var_80], xmm7
loc_18264:
mov [rbp+var_F8], r9
mov [rbp+var_100], r8
mov [rbp+var_108], rcx
mov [rbp+var_110], rdx
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov rax, [rbp+var_10]
mov [rbp+var_20], rax
lea rax, [rbp+var_40]
lea rcx, [rbp+var_120]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
loc_182B4:
cmp [rbp+var_18], 0
jz loc_183F2
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov rdi, [rbp+var_18]
call _strlen
mov [rbp+var_48], rax
mov [rbp+var_58], 0
mov [rbp+var_60], 0
loc_182E4:
mov rax, [rbp+var_60]
mov [rbp+var_128], rax
mov rdi, [rbp+var_20]
call _xml_node_children
mov rcx, rax
mov rax, [rbp+var_128]
cmp rax, rcx
jnb short loc_1836A
mov rdi, [rbp+var_20]
mov rsi, [rbp+var_60]
call _xml_node_child
mov [rbp+var_68], rax
mov rdi, [rbp+var_68]
call _xml_node_name
mov rdi, rax
lea rsi, [rbp+var_50]
call xml_string_equals
test al, 1
jnz short loc_18333
jmp short loc_18357
loc_18333:
cmp [rbp+var_58], 0
jnz short loc_18344
mov rax, [rbp+var_68]
mov [rbp+var_58], rax
jmp short loc_18355
loc_18344:
lea rax, [rbp+var_40]
mov [rbp+var_8], 0
jmp loc_183FE
loc_18355:
jmp short $+2
loc_18357:
jmp short $+2
loc_18359:
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp loc_182E4
loc_1836A:
cmp [rbp+var_58], 0
jnz short loc_1837F
lea rax, [rbp+var_40]
mov [rbp+var_8], 0
jmp short loc_183FE
loc_1837F:
mov rax, [rbp+var_58]
mov [rbp+var_20], rax
lea rax, [rbp+var_40]
mov [rbp+var_138], rax
mov eax, [rbp+var_40]
mov [rbp+var_12C], eax
cmp eax, 28h ; '('
ja short loc_183C2
mov rcx, [rbp+var_138]
mov edx, [rbp+var_12C]
movsxd rax, edx
add rax, [rcx+10h]
add edx, 8
mov [rcx], edx
mov [rbp+var_140], rax
jmp short loc_183DF
loc_183C2:
mov rcx, [rbp+var_138]
mov rax, [rcx+8]
mov rdx, rax
add rdx, 8
mov [rcx+8], rdx
mov [rbp+var_140], rax
loc_183DF:
mov rax, [rbp+var_140]
mov rax, [rax]
mov [rbp+var_18], rax
jmp loc_182B4
loc_183F2:
lea rax, [rbp+var_40]
mov rax, [rbp+var_20]
mov [rbp+var_8], rax
loc_183FE:
mov rax, [rbp+var_8]
add rsp, 140h
pop rbp
retn
|
long long xml_easy_child(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14,
char a15)
{
long long v15; // rax
char *v16; // rax
unsigned long long v18; // [rsp+18h] [rbp-128h]
char v19; // [rsp+20h] [rbp-120h] BYREF
long long v20; // [rsp+30h] [rbp-110h]
long long v21; // [rsp+38h] [rbp-108h]
long long v22; // [rsp+40h] [rbp-100h]
long long v23; // [rsp+48h] [rbp-F8h]
__m128 v24; // [rsp+50h] [rbp-F0h]
__m128 v25; // [rsp+60h] [rbp-E0h]
__m128 v26; // [rsp+70h] [rbp-D0h]
__m128 v27; // [rsp+80h] [rbp-C0h]
__m128 v28; // [rsp+90h] [rbp-B0h]
__m128 v29; // [rsp+A0h] [rbp-A0h]
__m128 v30; // [rsp+B0h] [rbp-90h]
__m128 v31; // [rsp+C0h] [rbp-80h]
long long v32; // [rsp+D8h] [rbp-68h]
unsigned long long i; // [rsp+E0h] [rbp-60h]
long long v34; // [rsp+E8h] [rbp-58h]
_QWORD v35[2]; // [rsp+F0h] [rbp-50h] BYREF
int v36; // [rsp+100h] [rbp-40h]
int v37; // [rsp+104h] [rbp-3Ch]
char *v38; // [rsp+108h] [rbp-38h]
char *v39; // [rsp+110h] [rbp-30h]
long long v40; // [rsp+120h] [rbp-20h]
long long v41; // [rsp+128h] [rbp-18h]
long long v42; // [rsp+130h] [rbp-10h]
v24 = a7;
v25 = a8;
v26 = a9;
v27 = a10;
v28 = a11;
v29 = a12;
v30 = a13;
v31 = a14;
v23 = a6;
v22 = a5;
v21 = a4;
v20 = a3;
v42 = a1;
v41 = a2;
v40 = a1;
v39 = &v19;
v38 = &a15;
v37 = 48;
v36 = 16;
while ( v41 )
{
v35[0] = v41;
v35[1] = strlen(v41);
v34 = 0LL;
for ( i = 0LL; ; ++i )
{
v18 = i;
if ( v18 >= xml_node_children(v40) )
break;
v32 = xml_node_child(v40, i);
v15 = xml_node_name(v32);
if ( (xml_string_equals(v15, v35) & 1) != 0 )
{
if ( v34 )
return 0LL;
v34 = v32;
}
}
if ( !v34 )
return 0LL;
v40 = v34;
if ( (unsigned int)v36 > 0x28 )
{
v16 = v38;
v38 += 8;
}
else
{
v16 = &v39[v36];
v36 += 8;
}
v41 = *(_QWORD *)v16;
}
return v40;
}
|
xml_easy_child:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x140
TEST AL,AL
JZ 0x00118264
MOVAPS xmmword ptr [RBP + -0xf0],XMM0
MOVAPS xmmword ptr [RBP + -0xe0],XMM1
MOVAPS xmmword ptr [RBP + -0xd0],XMM2
MOVAPS xmmword ptr [RBP + -0xc0],XMM3
MOVAPS xmmword ptr [RBP + -0xb0],XMM4
MOVAPS xmmword ptr [RBP + -0xa0],XMM5
MOVAPS xmmword ptr [RBP + -0x90],XMM6
MOVAPS xmmword ptr [RBP + -0x80],XMM7
LAB_00118264:
MOV qword ptr [RBP + -0xf8],R9
MOV qword ptr [RBP + -0x100],R8
MOV qword ptr [RBP + -0x108],RCX
MOV qword ptr [RBP + -0x110],RDX
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[RBP + -0x40]
LEA RCX,[RBP + -0x120]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
LAB_001182b4:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001183f2
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x0010a270
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x58],0x0
MOV qword ptr [RBP + -0x60],0x0
LAB_001182e4:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x128],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x0010a6a0
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x128]
CMP RAX,RCX
JNC 0x0011836a
MOV RDI,qword ptr [RBP + -0x20]
MOV RSI,qword ptr [RBP + -0x60]
CALL 0x0010a630
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x68]
CALL 0x0010ab70
MOV RDI,RAX
LEA RSI,[RBP + -0x50]
CALL 0x00118410
TEST AL,0x1
JNZ 0x00118333
JMP 0x00118357
LAB_00118333:
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x00118344
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x58],RAX
JMP 0x00118355
LAB_00118344:
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001183fe
LAB_00118355:
JMP 0x00118357
LAB_00118357:
JMP 0x00118359
LAB_00118359:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001182e4
LAB_0011836a:
CMP qword ptr [RBP + -0x58],0x0
JNZ 0x0011837f
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001183fe
LAB_0011837f:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x20],RAX
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x138],RAX
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x12c],EAX
CMP EAX,0x28
JA 0x001183c2
MOV RCX,qword ptr [RBP + -0x138]
MOV EDX,dword ptr [RBP + -0x12c]
MOVSXD RAX,EDX
ADD RAX,qword ptr [RCX + 0x10]
ADD EDX,0x8
MOV dword ptr [RCX],EDX
MOV qword ptr [RBP + -0x140],RAX
JMP 0x001183df
LAB_001183c2:
MOV RCX,qword ptr [RBP + -0x138]
MOV RAX,qword ptr [RCX + 0x8]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RCX + 0x8],RDX
MOV qword ptr [RBP + -0x140],RAX
LAB_001183df:
MOV RAX,qword ptr [RBP + -0x140]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001182b4
LAB_001183f2:
LEA RAX,[RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x8],RAX
LAB_001183fe:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x140
POP RBP
RET
|
/* WARNING: Restarted to delay deadcode elimination for space: stack */
long xml_easy_child(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
long param_9,char *param_10,int8 param_11,int8 param_12,
int8 param_13,int8 param_14)
{
char in_AL;
ulong uVar1;
int8 uVar2;
ulong uVar3;
int8 *local_148;
int1 local_128 [16];
int8 local_118;
int8 local_110;
int8 local_108;
int8 local_100;
int8 local_f8;
int8 local_e8;
int8 local_d8;
int8 local_c8;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
long local_70;
ulong local_68;
long local_60;
char *local_58;
size_t local_50;
uint local_48;
int4 local_44;
int8 *local_40;
int1 *local_38;
long local_28;
char *local_20;
long local_18;
if (in_AL != '\0') {
local_f8 = param_1;
local_e8 = param_2;
local_d8 = param_3;
local_c8 = param_4;
local_b8 = param_5;
local_a8 = param_6;
local_98 = param_7;
local_88 = param_8;
}
local_38 = local_128;
local_40 = (int8 *)&stack0x00000008;
local_44 = 0x30;
local_48 = 0x10;
local_118 = param_11;
local_110 = param_12;
local_108 = param_13;
local_100 = param_14;
local_28 = param_9;
local_20 = param_10;
local_18 = param_9;
while( true ) {
if (local_20 == (char *)0x0) {
return local_28;
}
local_58 = local_20;
local_50 = strlen(local_20);
local_60 = 0;
for (local_68 = 0; uVar3 = local_68, uVar1 = xml_node_children(local_28), uVar3 < uVar1;
local_68 = local_68 + 1) {
local_70 = xml_node_child(local_28,local_68);
uVar2 = xml_node_name(local_70);
uVar3 = xml_string_equals(uVar2,&local_58);
if ((uVar3 & 1) != 0) {
if (local_60 != 0) {
return 0;
}
local_60 = local_70;
}
}
if (local_60 == 0) break;
local_28 = local_60;
if (local_48 < 0x29) {
local_148 = (int8 *)(local_38 + (int)local_48);
local_48 = local_48 + 8;
}
else {
local_148 = local_40;
local_40 = local_40 + 1;
}
local_20 = (char *)*local_148;
}
return 0;
}
|
|
7,780 |
bool fmt::v10::detail::check_char_specs<char>(fmt::v10::format_specs<char> const&)
|
AlayaLite/build_O0/_deps/spdlog-src/include/spdlog/fmt/bundled/core.h
|
FMT_CONSTEXPR auto check_char_specs(const format_specs<Char>& specs) -> bool {
if (specs.type != presentation_type::none &&
specs.type != presentation_type::chr &&
specs.type != presentation_type::debug) {
return false;
}
if (specs.align == align::numeric || specs.sign != sign::none || specs.alt)
throw_format_error("invalid format specifier for char");
return true;
}
|
O0
|
c
|
bool fmt::v10::detail::check_char_specs<char>(fmt::v10::format_specs<char> const&):
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0xe91a1
movq 0x8(%rsp), %rax
cmpb $0xf, 0x8(%rax)
je 0xe91a1
movq 0x8(%rsp), %rax
cmpb $0x12, 0x8(%rax)
je 0xe91a1
movb $0x0, 0x17(%rsp)
jmp 0xe91f7
movq 0x8(%rsp), %rax
movw 0x9(%rax), %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x4, %eax
je 0xe91e6
movq 0x8(%rsp), %rax
movw 0x9(%rax), %ax
shrw $0x4, %ax
andw $0x7, %ax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xe91e6
movq 0x8(%rsp), %rax
movw 0x9(%rax), %ax
shrw $0x7, %ax
andw $0x1, %ax
testw $0x1, %ax
je 0xe91f2
leaq 0x69556(%rip), %rdi # 0x152743
callq 0xc62f0
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
_ZN3fmt3v106detail16check_char_specsIcEEbRKNS0_12format_specsIT_EE:
sub rsp, 18h
mov [rsp+18h+var_10], rdi
mov rax, [rsp+18h+var_10]
cmp byte ptr [rax+8], 0
jz short loc_E91A1
mov rax, [rsp+18h+var_10]
cmp byte ptr [rax+8], 0Fh
jz short loc_E91A1
mov rax, [rsp+18h+var_10]
cmp byte ptr [rax+8], 12h
jz short loc_E91A1
mov [rsp+18h+var_1], 0
jmp short loc_E91F7
loc_E91A1:
mov rax, [rsp+18h+var_10]
mov ax, [rax+9]
and ax, 0Fh
movzx eax, al
cmp eax, 4
jz short loc_E91E6
mov rax, [rsp+18h+var_10]
mov ax, [rax+9]
shr ax, 4
and ax, 7
movzx eax, al
cmp eax, 0
jnz short loc_E91E6
mov rax, [rsp+18h+var_10]
mov ax, [rax+9]
shr ax, 7
and ax, 1
test ax, 1
jz short loc_E91F2
loc_E91E6:
lea rdi, aInvalidFormatS_1; "invalid format specifier for char"
call _ZN3fmt3v106detail18throw_format_errorEPKc; fmt::v10::detail::throw_format_error(char const*)
loc_E91F2:
mov [rsp+18h+var_1], 1
loc_E91F7:
mov al, [rsp+18h+var_1]
and al, 1
add rsp, 18h
retn
|
char fmt::v10::detail::check_char_specs<char>(long long a1, const char *a2)
{
if ( *(_BYTE *)(a1 + 8) && *(_BYTE *)(a1 + 8) != 15 && *(_BYTE *)(a1 + 8) != 18 )
return 0;
if ( (*(_WORD *)(a1 + 9) & 0xF) == 4 || ((*(_WORD *)(a1 + 9) >> 4) & 7) != 0 || ((*(_WORD *)(a1 + 9) >> 7) & 1) != 0 )
fmt::v10::detail::throw_format_error((fmt::v10::detail *)"invalid format specifier for char", a2);
return 1;
}
|
check_char_specs<char>:
SUB RSP,0x18
MOV qword ptr [RSP + 0x8],RDI
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x8],0x0
JZ 0x001e91a1
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x8],0xf
JZ 0x001e91a1
MOV RAX,qword ptr [RSP + 0x8]
CMP byte ptr [RAX + 0x8],0x12
JZ 0x001e91a1
MOV byte ptr [RSP + 0x17],0x0
JMP 0x001e91f7
LAB_001e91a1:
MOV RAX,qword ptr [RSP + 0x8]
MOV AX,word ptr [RAX + 0x9]
AND AX,0xf
MOVZX EAX,AL
CMP EAX,0x4
JZ 0x001e91e6
MOV RAX,qword ptr [RSP + 0x8]
MOV AX,word ptr [RAX + 0x9]
SHR AX,0x4
AND AX,0x7
MOVZX EAX,AL
CMP EAX,0x0
JNZ 0x001e91e6
MOV RAX,qword ptr [RSP + 0x8]
MOV AX,word ptr [RAX + 0x9]
SHR AX,0x7
AND AX,0x1
TEST AX,0x1
JZ 0x001e91f2
LAB_001e91e6:
LEA RDI,[0x252743]
CALL 0x001c62f0
LAB_001e91f2:
MOV byte ptr [RSP + 0x17],0x1
LAB_001e91f7:
MOV AL,byte ptr [RSP + 0x17]
AND AL,0x1
ADD RSP,0x18
RET
|
/* bool fmt::v10::detail::check_char_specs<char>(fmt::v10::format_specs<char> const&) */
bool fmt::v10::detail::check_char_specs<char>(format_specs *param_1)
{
bool local_1;
if (((param_1[8] == (format_specs)0x0) || (param_1[8] == (format_specs)0xf)) ||
(param_1[8] == (format_specs)0x12)) {
if (((((byte)*(int2 *)(param_1 + 9) & 0xf) == 4) ||
((*(ushort *)(param_1 + 9) >> 4 & 7) != 0)) || ((*(ushort *)(param_1 + 9) >> 7 & 1) != 0)) {
/* WARNING: Subroutine does not return */
throw_format_error("invalid format specifier for char");
}
local_1 = true;
}
else {
local_1 = false;
}
return local_1;
}
|
|
7,781 |
ftxui::operator|(std::shared_ptr<ftxui::Node>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>)
|
Andrewchistyakov[P]flashcards_lyc/build_O1/_deps/ftxui-src/src/ftxui/dom/util.cpp
|
Element operator|(Element element, Decorator decorator) { // NOLINT
return decorator(std::move(element));
}
|
O1
|
cpp
|
ftxui::operator|(std::shared_ptr<ftxui::Node>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>):
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rax
movq (%rsi), %rcx
movq %rcx, (%rsp)
xorl %ecx, %ecx
movq %rcx, 0x8(%rsp)
movq 0x8(%rsi), %rdx
movq %rcx, 0x8(%rsi)
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsi)
cmpq %rcx, 0x10(%rax)
je 0x25ee8
movq %rdi, %rbx
movq %rsp, %rdx
movq %rax, %rsi
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25edf
callq 0x14c7c
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0xb140
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25eff
callq 0x14c7c
movq %rbx, %rdi
callq 0xb780
|
_ZN5ftxuiorESt10shared_ptrINS_4NodeEESt8functionIFS2_S2_EE:
push rbx
sub rsp, 10h
mov rax, rdx
mov rcx, [rsi]
mov [rsp+18h+var_18], rcx
xor ecx, ecx
mov [rsp+18h+var_10], rcx
mov rdx, [rsi+8]
mov [rsi+8], rcx
mov [rsp+18h+var_10], rdx
mov [rsi], rcx
cmp [rax+10h], rcx
jz short loc_25EE8
mov rbx, rdi
mov rdx, rsp
mov rsi, rax
call qword ptr [rax+18h]
mov rdi, [rsp+18h+var_10]
test rdi, rdi
jz short loc_25EDF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25EDF:
mov rax, rbx
add rsp, 10h
pop rbx
retn
loc_25EE8:
call __ZSt25__throw_bad_function_callv; std::__throw_bad_function_call(void)
mov rbx, rax
mov rdi, [rsp+18h+var_10]
test rdi, rdi
jz short loc_25EFF
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25EFF:
mov rdi, rbx
call __Unwind_Resume
|
long long ftxui::operator|(long long a1, long long *a2, long long a3)
{
volatile signed __int32 *v4; // rdx
long long v6; // [rsp+0h] [rbp-18h] BYREF
volatile signed __int32 *v7; // [rsp+8h] [rbp-10h]
v6 = *a2;
v7 = 0LL;
v4 = (volatile signed __int32 *)a2[1];
a2[1] = 0LL;
v7 = v4;
*a2 = 0LL;
if ( !*(_QWORD *)(a3 + 16) )
std::__throw_bad_function_call();
(*(void ( **)(long long, long long, long long *))(a3 + 24))(a1, a3, &v6);
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
return a1;
}
|
operator|:
PUSH RBX
SUB RSP,0x10
MOV RAX,RDX
MOV RCX,qword ptr [RSI]
MOV qword ptr [RSP],RCX
XOR ECX,ECX
MOV qword ptr [RSP + 0x8],RCX
MOV RDX,qword ptr [RSI + 0x8]
MOV qword ptr [RSI + 0x8],RCX
MOV qword ptr [RSP + 0x8],RDX
MOV qword ptr [RSI],RCX
CMP qword ptr [RAX + 0x10],RCX
JZ 0x00125ee8
LAB_00125ec4:
MOV RBX,RDI
MOV RDX,RSP
MOV RSI,RAX
CALL qword ptr [RAX + 0x18]
MOV RDI,qword ptr [RSP + 0x8]
TEST RDI,RDI
JZ 0x00125edf
CALL 0x00114c7c
LAB_00125edf:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
LAB_00125ee8:
CALL 0x0010b140
|
/* ftxui::TEMPNAMEPLACEHOLDERVALUE(std::shared_ptr<ftxui::Node>,
std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>) */
ftxui * __thiscall ftxui::operator|(ftxui *this,int8 *param_2,long param_3)
{
int8 local_18;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_10;
local_18 = *param_2;
local_10 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)param_2[1];
param_2[1] = 0;
*param_2 = 0;
if (*(long *)(param_3 + 0x10) != 0) {
/* try { // try from 00125ec4 to 00125eec has its CatchHandler @ 00125eed */
(**(code **)(param_3 + 0x18))(this,param_3,&local_18);
if (local_10 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_10);
}
return this;
}
/* WARNING: Subroutine does not return */
std::__throw_bad_function_call();
}
|
|
7,782 |
mi_mmap_pwrite
|
eloqsql/storage/myisam/mi_dynrec.c
|
size_t mi_mmap_pwrite(MI_INFO *info, const uchar *Buffer,
size_t Count, my_off_t offset, myf MyFlags)
{
DBUG_PRINT("info", ("mi_write with mmap %d\n", info->dfile));
if (info->s->concurrent_insert)
mysql_rwlock_rdlock(&info->s->mmap_lock);
/*
The following test may fail in the following cases:
- We failed to remap a memory area (fragmented memory?)
- This thread has done some writes, but not yet extended the
memory mapped area.
*/
if (info->s->mmaped_length >= offset + Count)
{
memcpy(info->s->file_map + offset, Buffer, Count);
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return 0;
}
else
{
info->s->nonmmaped_inserts++;
if (info->s->concurrent_insert)
mysql_rwlock_unlock(&info->s->mmap_lock);
return mysql_file_pwrite(info->dfile, Buffer, Count, offset, MyFlags);
}
}
|
O0
|
c
|
mi_mmap_pwrite:
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 %r8, -0x30(%rbp)
jmp 0xa684e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa687d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
leaq 0xac049(%rip), %rsi # 0x1528bc
movl $0xe3, %edx
callq 0xa6b00
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x4d0(%rax), %rax
movq -0x28(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jb 0xa68e4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x270(%rax), %rdi
addq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2a0a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa68da
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
callq 0xa6b70
movq $0x0, -0x8(%rbp)
jmp 0xa6950
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4d8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4d8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpb $0x0, 0x384(%rax)
je 0xa691d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x4e0, %rdi # imm = 0x4E0
callq 0xa6b70
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %rax
leaq 0xabf7e(%rip), %rdi # 0x1528bc
movl $0xf8, %esi
movq %rax, (%rsp)
callq 0xa6d50
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
mi_mmap_pwrite:
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_30], r8
jmp short $+2
loc_A684E:
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A687D
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
lea rsi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov edx, 0E3h
call inline_mysql_rwlock_rdlock_3
loc_A687D:
mov rax, [rbp+var_10]
mov rax, [rax]
mov rax, [rax+4D0h]
mov rcx, [rbp+var_28]
add rcx, [rbp+var_20]
cmp rax, rcx
jb short loc_A68E4
mov rax, [rbp+var_10]
mov rax, [rax]
mov rdi, [rax+270h]
add rdi, [rbp+var_28]
mov rsi, [rbp+var_18]
mov rdx, [rbp+var_20]
call _memcpy
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A68DA
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
call inline_mysql_rwlock_unlock_5
loc_A68DA:
mov [rbp+var_8], 0
jmp short loc_A6950
loc_A68E4:
mov rax, [rbp+var_10]
mov rax, [rax]
mov ecx, [rax+4D8h]
add ecx, 1
mov [rax+4D8h], ecx
mov rax, [rbp+var_10]
mov rax, [rax]
cmp byte ptr [rax+384h], 0
jz short loc_A691D
mov rax, [rbp+var_10]
mov rdi, [rax]
add rdi, 4E0h
call inline_mysql_rwlock_unlock_5
loc_A691D:
mov rax, [rbp+var_10]
mov edx, [rax+1C0h]
mov rcx, [rbp+var_18]
mov r8, [rbp+var_20]
mov r9, [rbp+var_28]
mov rax, [rbp+var_30]
lea rdi, aWorkspaceLlm4b_24; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 0F8h
mov [rsp+40h+var_40], rax
call inline_mysql_file_pwrite_0
mov [rbp+var_8], rax
loc_A6950:
mov rax, [rbp+var_8]
add rsp, 40h
pop rbp
retn
|
long long mi_mmap_pwrite(_DWORD *a1, long long a2, long long a3, long long a4, long long a5)
{
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_rdlock_3(
*(_QWORD *)a1 + 1248LL,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
227LL);
if ( *(_QWORD *)(*(_QWORD *)a1 + 1232LL) < (unsigned long long)(a3 + a4) )
{
++*(_DWORD *)(*(_QWORD *)a1 + 1240LL);
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_unlock_5(*(_QWORD *)a1 + 1248LL);
return inline_mysql_file_pwrite_0(
(unsigned int)"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",
248,
a1[112],
a2,
a3,
a4,
a5);
}
else
{
memcpy(a4 + *(_QWORD *)(*(_QWORD *)a1 + 624LL), a2, a3);
if ( *(_BYTE *)(*(_QWORD *)a1 + 900LL) )
inline_mysql_rwlock_unlock_5(*(_QWORD *)a1 + 1248LL);
return 0LL;
}
}
|
mi_mmap_pwrite:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV qword ptr [RBP + -0x30],R8
JMP 0x001a684e
LAB_001a684e:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a687d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
LEA RSI,[0x2528bc]
MOV EDX,0xe3
CALL 0x001a6b00
LAB_001a687d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x4d0]
MOV RCX,qword ptr [RBP + -0x28]
ADD RCX,qword ptr [RBP + -0x20]
CMP RAX,RCX
JC 0x001a68e4
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RAX + 0x270]
ADD RDI,qword ptr [RBP + -0x28]
MOV RSI,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x20]
CALL 0x0012a0a0
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a68da
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
CALL 0x001a6b70
LAB_001a68da:
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001a6950
LAB_001a68e4:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV ECX,dword ptr [RAX + 0x4d8]
ADD ECX,0x1
MOV dword ptr [RAX + 0x4d8],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
CMP byte ptr [RAX + 0x384],0x0
JZ 0x001a691d
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX]
ADD RDI,0x4e0
CALL 0x001a6b70
LAB_001a691d:
MOV RAX,qword ptr [RBP + -0x10]
MOV EDX,dword ptr [RAX + 0x1c0]
MOV RCX,qword ptr [RBP + -0x18]
MOV R8,qword ptr [RBP + -0x20]
MOV R9,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RBP + -0x30]
LEA RDI,[0x2528bc]
MOV ESI,0xf8
MOV qword ptr [RSP],RAX
CALL 0x001a6d50
MOV qword ptr [RBP + -0x8],RAX
LAB_001a6950:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x40
POP RBP
RET
|
int8
mi_mmap_pwrite(long *param_1,void *param_2,size_t param_3,long param_4,int8 param_5)
{
int8 local_10;
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_rdlock
(*param_1 + 0x4e0,
"/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xe3);
}
if (*(ulong *)(*param_1 + 0x4d0) < param_4 + param_3) {
*(int *)(*param_1 + 0x4d8) = *(int *)(*param_1 + 0x4d8) + 1;
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_unlock(*param_1 + 0x4e0);
}
local_10 = inline_mysql_file_pwrite
("/workspace/llm4binary/github2025/eloqsql/storage/myisam/mi_dynrec.c",0xf8
,(int)param_1[0x38],param_2,param_3,param_4,param_5);
}
else {
memcpy((void *)(*(long *)(*param_1 + 0x270) + param_4),param_2,param_3);
if (*(char *)(*param_1 + 900) != '\0') {
inline_mysql_rwlock_unlock(*param_1 + 0x4e0);
}
local_10 = 0;
}
return local_10;
}
|
|
7,783 |
inline_mysql_cond_init
|
eloqsql/include/mysql/psi/mysql_thread.h
|
static inline int inline_mysql_cond_init(
#ifdef HAVE_PSI_COND_INTERFACE
PSI_cond_key key,
#endif
mysql_cond_t *that,
const pthread_condattr_t *attr)
{
#ifdef HAVE_PSI_COND_INTERFACE
that->m_psi= PSI_COND_CALL(init_cond)(key, &that->m_cond);
#else
that->m_psi= NULL;
#endif
return pthread_cond_init(&that->m_cond, attr);
}
|
O0
|
c
|
inline_mysql_cond_init:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x25b63e(%rip), %rax # 0x2c00b8
movq (%rax), %rax
movq 0x60(%rax), %rax
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2a370
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
inline_mysql_cond_init_2:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
mov [rbp+var_18], rdx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+60h]
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
call rax
mov rcx, rax
mov rax, [rbp+var_10]
mov [rax+30h], rcx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
call _pthread_cond_init
add rsp, 20h
pop rbp
retn
|
long long inline_mysql_cond_init_2(unsigned int a1, long long a2, long long a3)
{
*(_QWORD *)(a2 + 48) = ((long long ( *)(_QWORD, long long))PSI_server[12])(a1, a2);
return pthread_cond_init(a2, a3);
}
|
inline_mysql_cond_init:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
LEA RAX,[0x3c00b8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x60]
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
CALL RAX
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x30],RCX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
CALL 0x0012a370
ADD RSP,0x20
POP RBP
RET
|
void inline_mysql_cond_init(int4 param_1,pthread_cond_t *param_2,pthread_condattr_t *param_3)
{
longlong lVar1;
lVar1 = (**(code **)(PSI_server + 0x60))(param_1,param_2);
param_2[1].__align = lVar1;
pthread_cond_init(param_2,param_3);
return;
}
|
|
7,784 |
mysql_close_slow_part_cont
|
eloqsql/libmariadb/libmariadb/mariadb_async.c
|
MK_ASYNC_CONT_BODY_VOID_RETURN(sock)
}
int STDCALL
mysql_close_start(MYSQL *sock)
{
int res;
/* It is legitimate to have NULL sock argument, which will do nothing. */
if (sock && sock->net.pvio)
{
res= mysql_close_slow_part_start(sock);
/* If we need to block, return now and do the rest in mysql_close_cont(). */
if (res)
return res;
}
mysql_close(sock);
return 0;
}
|
O3
|
c
|
mysql_close_slow_part_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x480(%rdi), %rax
movq 0x28(%rax), %r14
cmpb $0x0, 0x15(%r14)
je 0x2ee2f
movb $0x1, 0x14(%r14)
movl %esi, 0x4(%r14)
leaq 0x38(%r14), %rdi
callq 0x32a07
movb $0x0, 0x14(%r14)
testl %eax, %eax
jle 0x2ee83
movl (%r14), %r14d
jmp 0x2ee8f
movl $0x7de, 0x90(%rbx) # imm = 0x7DE
leaq 0x297(%rbx), %rdi
leaq 0x22099(%rip), %rax # 0x50ee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x29c(%rbx)
leaq 0x97(%rbx), %rdi
leaq 0x22084(%rip), %rax # 0x50ef0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movb %r14b, 0x296(%rbx)
jmp 0x2ee8f
movb $0x0, 0x15(%r14)
xorl %r14d, %r14d
testl %eax, %eax
js 0x2ee97
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x7d8, 0x90(%rbx) # imm = 0x7D8
leaq 0x297(%rbx), %rdi
leaq 0x22031(%rip), %rax # 0x50ee0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
xorl %r14d, %r14d
movb %r14b, 0x29c(%rbx)
leaq 0x97(%rbx), %rdi
leaq 0x2201c(%rip), %rax # 0x50ef0
movq 0x40(%rax), %rsi
jmp 0x2ee70
|
mysql_close_slow_part_cont:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
mov rax, [rdi+480h]
mov r14, [rax+28h]
cmp byte ptr [r14+15h], 0
jz short loc_2EE2F
mov byte ptr [r14+14h], 1
mov [r14+4], esi
lea rdi, [r14+38h]
call my_context_continue
mov byte ptr [r14+14h], 0
test eax, eax
jle short loc_2EE83
mov r14d, [r14]
jmp short loc_2EE8F
loc_2EE2F:
mov dword ptr [rbx+90h], 7DEh
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+29Ch], r14b
lea rdi, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+70h]
loc_2EE70:
mov edx, 1FFh
call _strncpy
mov [rbx+296h], r14b
jmp short loc_2EE8F
loc_2EE83:
mov byte ptr [r14+15h], 0
xor r14d, r14d
test eax, eax
js short loc_2EE97
loc_2EE8F:
mov eax, r14d
pop rbx
pop r14
pop rbp
retn
loc_2EE97:
mov dword ptr [rbx+90h], 7D8h
lea rdi, [rbx+297h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
xor r14d, r14d
mov [rbx+29Ch], r14b
lea rdi, [rbx+97h]
lea rax, client_errors
mov rsi, [rax+40h]
jmp short loc_2EE70
|
long long mysql_close_slow_part_cont(long long a1, unsigned int a2)
{
unsigned int *v3; // r14
int v4; // eax
unsigned int v5; // r14d
long long v6; // rdi
char *v7; // rsi
v3 = *(unsigned int **)(*(_QWORD *)(a1 + 1152) + 40LL);
if ( !*((_BYTE *)v3 + 21) )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
v5 = 0;
*(_BYTE *)(a1 + 668) = 0;
v6 = a1 + 151;
v7 = client_errors[14];
LABEL_5:
strncpy(v6, v7, 511LL);
*(_BYTE *)(a1 + 662) = 0;
return v5;
}
*((_BYTE *)v3 + 20) = 1;
v3[1] = a2;
v4 = my_context_continue(v3 + 14);
*((_BYTE *)v3 + 20) = 0;
if ( v4 <= 0 )
{
*((_BYTE *)v3 + 21) = 0;
v5 = 0;
if ( v4 >= 0 )
return v5;
*(_DWORD *)(a1 + 144) = 2008;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
v5 = 0;
*(_BYTE *)(a1 + 668) = 0;
v6 = a1 + 151;
v7 = client_errors[8];
goto LABEL_5;
}
return *v3;
}
|
mysql_close_slow_part_cont:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
MOV RAX,qword ptr [RDI + 0x480]
MOV R14,qword ptr [RAX + 0x28]
CMP byte ptr [R14 + 0x15],0x0
JZ 0x0012ee2f
MOV byte ptr [R14 + 0x14],0x1
MOV dword ptr [R14 + 0x4],ESI
LEA RDI,[R14 + 0x38]
CALL 0x00132a07
MOV byte ptr [R14 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012ee83
MOV R14D,dword ptr [R14]
JMP 0x0012ee8f
LAB_0012ee2f:
MOV dword ptr [RBX + 0x90],0x7de
LEA RDI,[RBX + 0x297]
LEA RAX,[0x150ee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x29c],R14B
LEA RDI,[RBX + 0x97]
LEA RAX,[0x150ef0]
MOV RSI,qword ptr [RAX + 0x70]
LAB_0012ee70:
MOV EDX,0x1ff
CALL 0x00113220
MOV byte ptr [RBX + 0x296],R14B
JMP 0x0012ee8f
LAB_0012ee83:
MOV byte ptr [R14 + 0x15],0x0
XOR R14D,R14D
TEST EAX,EAX
JS 0x0012ee97
LAB_0012ee8f:
MOV EAX,R14D
POP RBX
POP R14
POP RBP
RET
LAB_0012ee97:
MOV dword ptr [RBX + 0x90],0x7d8
LEA RDI,[RBX + 0x297]
LEA RAX,[0x150ee0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
XOR R14D,R14D
MOV byte ptr [RBX + 0x29c],R14B
LEA RDI,[RBX + 0x97]
LEA RAX,[0x150ef0]
MOV RSI,qword ptr [RAX + 0x40]
JMP 0x0012ee70
|
int4 mysql_close_slow_part_cont(long param_1,int4 param_2)
{
int4 *puVar1;
int iVar2;
char *__src;
puVar1 = *(int4 **)(*(long *)(param_1 + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(param_1 + 0x90) = 0x7de;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
__src = PTR_s_Commands_out_of_sync__you_can_t_r_00150f60;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_2;
iVar2 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (0 < iVar2) {
return *puVar1;
}
*(int1 *)((long)puVar1 + 0x15) = 0;
if (-1 < iVar2) {
return 0;
}
*(int4 *)(param_1 + 0x90) = 0x7d8;
strncpy((char *)(param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x29c) = 0;
__src = PTR_s_Client_run_out_of_memory_00150f30;
}
strncpy((char *)(param_1 + 0x97),__src,0x1ff);
*(int1 *)(param_1 + 0x296) = 0;
return 0;
}
|
|
7,785 |
process_str_arg
|
eloqsql/strings/my_vsnprintf.c
|
static char *process_str_arg(CHARSET_INFO *cs, char *to, const char *end,
longlong length_arg, size_t width, char *par,
uint print_type, my_bool nice_cut)
{
int well_formed_error;
uint dots= 0;
size_t plen, left_len= (size_t) (end - to) + 1, slen=0;
my_bool left_fill= 1;
size_t length;
/*
The sign of the length argument specific the string should be right
or left adjusted
*/
if (length_arg < 0)
{
length= (size_t) -length_arg;
left_fill= 0;
}
else
length= (size_t) length_arg;
if (!par)
par = (char*) "(null)";
if (nice_cut)
{
plen= slen= strnlen(par, width + 1);
if (plen > width)
plen= width;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
if ((slen > plen))
{
if (plen < 3)
{
dots= (uint) plen;
plen= 0;
}
else
{
dots= 3;
plen-= 3;
}
}
}
else
{
plen= slen= strnlen(par, width);
dots= 0;
if (left_len <= plen)
{
plen = left_len - 1;
length= plen;
}
}
plen= my_well_formed_length(cs, par, par + plen, width, &well_formed_error);
if (print_type & ESCAPED_ARG)
{
const char *org_to= to;
to= backtick_string(cs, to, end, par, plen + dots, '`', MY_TEST(dots));
plen= (size_t) (to - org_to);
dots= 0;
}
else
{
if (left_fill)
{
if (plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
}
to= strnmov(to,par,plen);
if (dots)
to= strfill(to, dots, '.');
}
if (!left_fill && plen + dots < length)
to= strfill(to, length - plen - dots, ' ');
return to;
}
|
O0
|
c
|
process_str_arg:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb 0x18(%rbp), %al
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x1, -0x51(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0xd4e83
xorl %eax, %eax
subq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x51(%rbp)
jmp 0xd4e8b
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xd4e9d
leaq 0x773b(%rip), %rax # 0xdc5d4
movq %rax, -0x30(%rbp)
cmpb $0x0, 0x18(%rbp)
je 0xd4f29
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x28580
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0xd4ed2
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0xd4ef0
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x40(%rbp), %rax
jbe 0xd4f27
cmpq $0x3, -0x40(%rbp)
jae 0xd4f12
movq -0x40(%rbp), %rax
movl %eax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0xd4f25
movl $0x3, -0x38(%rbp)
movq -0x40(%rbp), %rax
subq $0x3, %rax
movq %rax, -0x40(%rbp)
jmp 0xd4f27
jmp 0xd4f65
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x28580
movq %rax, -0x50(%rbp)
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
ja 0xd4f63
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0xd4f65
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x30(%rbp), %rdx
addq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq -0x34(%rbp), %r8
callq 0xd5980
movq %rax, -0x40(%rbp)
movl 0x10(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd4ff4
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movl -0x38(%rbp), %eax
addq %rax, %r8
movl -0x38(%rbp), %r10d
xorl %eax, %eax
movl $0x1, %r9d
cmpl $0x0, %r10d
cmovnel %r9d, %eax
movl $0x60, %r9d
movsbl %al, %eax
movl %eax, (%rsp)
callq 0xd59e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x68(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
jmp 0xd5060
cmpb $0x0, -0x51(%rbp)
je 0xd502c
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
addq %rcx, %rax
cmpq -0x60(%rbp), %rax
jae 0xd502a
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq -0x40(%rbp), %rsi
movl -0x38(%rbp), %eax
subq %rax, %rsi
movl $0x20, %edx
callq 0xd60a0
movq %rax, -0x10(%rbp)
jmp 0xd502c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xd6160
movq %rax, -0x10(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0xd505e
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
movl $0x2e, %edx
callq 0xd60a0
movq %rax, -0x10(%rbp)
jmp 0xd5060
cmpb $0x0, -0x51(%rbp)
jne 0xd5096
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
addq %rcx, %rax
cmpq -0x60(%rbp), %rax
jae 0xd5096
movq -0x10(%rbp), %rdi
movq -0x60(%rbp), %rsi
subq -0x40(%rbp), %rsi
movl -0x38(%rbp), %eax
subq %rax, %rsi
movl $0x20, %edx
callq 0xd60a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
|
process_str_arg:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, [rbp+arg_8]
mov eax, [rbp+arg_0]
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 [rbp+var_30], r9
mov [rbp+var_38], 0
mov rax, [rbp+var_18]
mov rcx, [rbp+var_10]
sub rax, rcx
add rax, 1
mov [rbp+var_48], rax
mov [rbp+var_50], 0
mov [rbp+var_51], 1
cmp [rbp+var_20], 0
jge short loc_D4E83
xor eax, eax
sub rax, [rbp+var_20]
mov [rbp+var_60], rax
mov [rbp+var_51], 0
jmp short loc_D4E8B
loc_D4E83:
mov rax, [rbp+var_20]
mov [rbp+var_60], rax
loc_D4E8B:
cmp [rbp+var_30], 0
jnz short loc_D4E9D
lea rax, aNull; "(null)"
mov [rbp+var_30], rax
loc_D4E9D:
cmp [rbp+arg_8], 0
jz loc_D4F29
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
add rsi, 1
call _strnlen
mov [rbp+var_50], rax
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
cmp rax, [rbp+var_28]
jbe short loc_D4ED2
mov rax, [rbp+var_28]
mov [rbp+var_40], rax
loc_D4ED2:
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
ja short loc_D4EF0
mov rax, [rbp+var_48]
sub rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
loc_D4EF0:
mov rax, [rbp+var_50]
cmp rax, [rbp+var_40]
jbe short loc_D4F27
cmp [rbp+var_40], 3
jnb short loc_D4F12
mov rax, [rbp+var_40]
mov [rbp+var_38], eax
mov [rbp+var_40], 0
jmp short loc_D4F25
loc_D4F12:
mov [rbp+var_38], 3
mov rax, [rbp+var_40]
sub rax, 3
mov [rbp+var_40], rax
loc_D4F25:
jmp short $+2
loc_D4F27:
jmp short loc_D4F65
loc_D4F29:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
call _strnlen
mov [rbp+var_50], rax
mov [rbp+var_40], rax
mov [rbp+var_38], 0
mov rax, [rbp+var_48]
cmp rax, [rbp+var_40]
ja short loc_D4F63
mov rax, [rbp+var_48]
sub rax, 1
mov [rbp+var_40], rax
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
loc_D4F63:
jmp short $+2
loc_D4F65:
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_30]
add rdx, [rbp+var_40]
mov rcx, [rbp+var_28]
lea r8, [rbp+var_34]
call my_well_formed_length_0
mov [rbp+var_40], rax
mov eax, [rbp+arg_0]
and eax, 8
cmp eax, 0
jz short loc_D4FF4
mov rax, [rbp+var_10]
mov [rbp+var_68], rax
mov rdi, [rbp+var_8]
mov rsi, [rbp+var_10]
mov rdx, [rbp+var_18]
mov rcx, [rbp+var_30]
mov r8, [rbp+var_40]
mov eax, [rbp+var_38]
add r8, rax
mov r10d, [rbp+var_38]
xor eax, eax
mov r9d, 1
cmp r10d, 0
cmovnz eax, r9d
mov r9d, 60h ; '`'
movsx eax, al
mov [rsp+70h+var_70], eax
call backtick_string
mov [rbp+var_10], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_68]
sub rax, rcx
mov [rbp+var_40], rax
mov [rbp+var_38], 0
jmp short loc_D5060
loc_D4FF4:
cmp [rbp+var_51], 0
jz short loc_D502C
mov rax, [rbp+var_40]
mov ecx, [rbp+var_38]
add rax, rcx
cmp rax, [rbp+var_60]
jnb short loc_D502A
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_60]
sub rsi, [rbp+var_40]
mov eax, [rbp+var_38]
sub rsi, rax
mov edx, 20h ; ' '
call strfill
mov [rbp+var_10], rax
loc_D502A:
jmp short $+2
loc_D502C:
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_30]
mov rdx, [rbp+var_40]
call strnmov
mov [rbp+var_10], rax
cmp [rbp+var_38], 0
jz short loc_D505E
mov rdi, [rbp+var_10]
mov eax, [rbp+var_38]
mov esi, eax
mov edx, 2Eh ; '.'
call strfill
mov [rbp+var_10], rax
loc_D505E:
jmp short $+2
loc_D5060:
cmp [rbp+var_51], 0
jnz short loc_D5096
mov rax, [rbp+var_40]
mov ecx, [rbp+var_38]
add rax, rcx
cmp rax, [rbp+var_60]
jnb short loc_D5096
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_60]
sub rsi, [rbp+var_40]
mov eax, [rbp+var_38]
sub rsi, rax
mov edx, 20h ; ' '
call strfill
mov [rbp+var_10], rax
loc_D5096:
mov rax, [rbp+var_10]
add rsp, 70h
pop rbp
retn
|
long long process_str_arg(
long long a1,
long long a2,
long long a3,
long long a4,
unsigned long long a5,
const char *a6,
char a7,
char a8)
{
long long v9; // [rsp+8h] [rbp-68h]
unsigned long long v10; // [rsp+10h] [rbp-60h]
char v11; // [rsp+1Fh] [rbp-51h]
unsigned long long v12; // [rsp+20h] [rbp-50h]
unsigned long long v13; // [rsp+28h] [rbp-48h]
unsigned long long v14; // [rsp+30h] [rbp-40h]
long long v15; // [rsp+30h] [rbp-40h]
unsigned int v16; // [rsp+38h] [rbp-38h]
char v17[4]; // [rsp+3Ch] [rbp-34h] BYREF
const char *v18; // [rsp+40h] [rbp-30h]
unsigned long long v19; // [rsp+48h] [rbp-28h]
long long v20; // [rsp+50h] [rbp-20h]
long long v21; // [rsp+58h] [rbp-18h]
long long v22; // [rsp+60h] [rbp-10h]
long long v23; // [rsp+68h] [rbp-8h]
v23 = a1;
v22 = a2;
v21 = a3;
v20 = a4;
v19 = a5;
v18 = a6;
v16 = 0;
v13 = a3 - a2 + 1;
v11 = 1;
if ( a4 >= 0 )
{
v10 = v20;
}
else
{
v10 = -v20;
v11 = 0;
}
if ( !v18 )
v18 = "(null)";
if ( a8 )
{
v12 = strnlen(v18, v19 + 1);
v14 = v12;
if ( v12 > v19 )
v14 = v19;
if ( v13 <= v14 )
{
v14 = v13 - 1;
v10 = v13 - 1;
}
if ( v12 > v14 )
{
if ( v14 >= 3 )
{
v16 = 3;
v14 -= 3LL;
}
else
{
v16 = v14;
v14 = 0LL;
}
}
}
else
{
v14 = strnlen(v18, v19);
v16 = 0;
if ( v13 <= v14 )
{
v14 = v13 - 1;
v10 = v13 - 1;
}
}
v15 = my_well_formed_length_0(v23, v18, &v18[v14], v19, v17);
if ( (a7 & 8) != 0 )
{
v9 = v22;
v22 = backtick_string(v23, v22, v21, (_DWORD)v18, v16 + (unsigned int)v15, 96, v16 != 0);
v15 = v22 - v9;
v16 = 0;
}
else
{
if ( v11 && (unsigned long long)v16 + v15 < v10 )
v22 = strfill(v22, v10 - v15 - v16, 32LL);
v22 = strnmov(v22, v18, v15);
if ( v16 )
v22 = strfill(v22, v16, 46LL);
}
if ( !v11 && (unsigned long long)v16 + v15 < v10 )
return strfill(v22, v10 - v15 - v16, 32LL);
return v22;
}
|
process_str_arg:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,byte ptr [RBP + 0x18]
MOV EAX,dword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV qword ptr [RBP + -0x18],RDX
MOV qword ptr [RBP + -0x20],RCX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x10]
SUB RAX,RCX
ADD RAX,0x1
MOV qword ptr [RBP + -0x48],RAX
MOV qword ptr [RBP + -0x50],0x0
MOV byte ptr [RBP + -0x51],0x1
CMP qword ptr [RBP + -0x20],0x0
JGE 0x001d4e83
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
MOV byte ptr [RBP + -0x51],0x0
JMP 0x001d4e8b
LAB_001d4e83:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x60],RAX
LAB_001d4e8b:
CMP qword ptr [RBP + -0x30],0x0
JNZ 0x001d4e9d
LEA RAX,[0x1dc5d4]
MOV qword ptr [RBP + -0x30],RAX
LAB_001d4e9d:
CMP byte ptr [RBP + 0x18],0x0
JZ 0x001d4f29
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
ADD RSI,0x1
CALL 0x00128580
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x001d4ed2
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x40],RAX
LAB_001d4ed2:
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x001d4ef0
MOV RAX,qword ptr [RBP + -0x48]
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LAB_001d4ef0:
MOV RAX,qword ptr [RBP + -0x50]
CMP RAX,qword ptr [RBP + -0x40]
JBE 0x001d4f27
CMP qword ptr [RBP + -0x40],0x3
JNC 0x001d4f12
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x38],EAX
MOV qword ptr [RBP + -0x40],0x0
JMP 0x001d4f25
LAB_001d4f12:
MOV dword ptr [RBP + -0x38],0x3
MOV RAX,qword ptr [RBP + -0x40]
SUB RAX,0x3
MOV qword ptr [RBP + -0x40],RAX
LAB_001d4f25:
JMP 0x001d4f27
LAB_001d4f27:
JMP 0x001d4f65
LAB_001d4f29:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
CALL 0x00128580
MOV qword ptr [RBP + -0x50],RAX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x38],0x0
MOV RAX,qword ptr [RBP + -0x48]
CMP RAX,qword ptr [RBP + -0x40]
JA 0x001d4f63
MOV RAX,qword ptr [RBP + -0x48]
SUB RAX,0x1
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
LAB_001d4f63:
JMP 0x001d4f65
LAB_001d4f65:
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x30]
ADD RDX,qword ptr [RBP + -0x40]
MOV RCX,qword ptr [RBP + -0x28]
LEA R8,[RBP + -0x34]
CALL 0x001d5980
MOV qword ptr [RBP + -0x40],RAX
MOV EAX,dword ptr [RBP + 0x10]
AND EAX,0x8
CMP EAX,0x0
JZ 0x001d4ff4
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x68],RAX
MOV RDI,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x30]
MOV R8,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
ADD R8,RAX
MOV R10D,dword ptr [RBP + -0x38]
XOR EAX,EAX
MOV R9D,0x1
CMP R10D,0x0
CMOVNZ EAX,R9D
MOV R9D,0x60
MOVSX EAX,AL
MOV dword ptr [RSP],EAX
CALL 0x001d59e0
MOV qword ptr [RBP + -0x10],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x68]
SUB RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x38],0x0
JMP 0x001d5060
LAB_001d4ff4:
CMP byte ptr [RBP + -0x51],0x0
JZ 0x001d502c
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x38]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x60]
JNC 0x001d502a
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x60]
SUB RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
SUB RSI,RAX
MOV EDX,0x20
CALL 0x001d60a0
MOV qword ptr [RBP + -0x10],RAX
LAB_001d502a:
JMP 0x001d502c
LAB_001d502c:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x30]
MOV RDX,qword ptr [RBP + -0x40]
CALL 0x001d6160
MOV qword ptr [RBP + -0x10],RAX
CMP dword ptr [RBP + -0x38],0x0
JZ 0x001d505e
MOV RDI,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RBP + -0x38]
MOV ESI,EAX
MOV EDX,0x2e
CALL 0x001d60a0
MOV qword ptr [RBP + -0x10],RAX
LAB_001d505e:
JMP 0x001d5060
LAB_001d5060:
CMP byte ptr [RBP + -0x51],0x0
JNZ 0x001d5096
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x38]
ADD RAX,RCX
CMP RAX,qword ptr [RBP + -0x60]
JNC 0x001d5096
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x60]
SUB RSI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x38]
SUB RSI,RAX
MOV EDX,0x20
CALL 0x001d60a0
MOV qword ptr [RBP + -0x10],RAX
LAB_001d5096:
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x70
POP RBP
RET
|
long process_str_arg(int8 param_1,long param_2,long param_3,size_t param_4,size_t param_5,
char *param_6,uint param_7,char param_8)
{
long lVar1;
size_t sVar2;
size_t sVar3;
bool bVar4;
size_t local_68;
size_t local_48;
uint local_40;
int1 local_3c [4];
char *local_38;
ulong local_30;
size_t local_28;
long local_20;
long local_18;
int8 local_10;
local_40 = 0;
sVar2 = param_3 - param_2;
bVar4 = -1 < (long)param_4;
local_68 = param_4;
if (!bVar4) {
local_68 = -param_4;
}
local_38 = param_6;
if (param_6 == (char *)0x0) {
local_38 = "(null)";
}
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
if (param_8 == '\0') {
local_48 = strnlen(local_38,param_5);
local_40 = 0;
if (sVar2 + 1 <= local_48) {
local_68 = sVar2;
local_48 = sVar2;
}
}
else {
sVar3 = strnlen(local_38,param_5 + 1);
local_48 = sVar3;
if (local_30 < sVar3) {
local_48 = local_30;
}
if (sVar2 + 1 <= local_48) {
local_68 = sVar2;
local_48 = sVar2;
}
if (local_48 < sVar3) {
if (local_48 < 3) {
local_40 = (uint)local_48;
local_48 = 0;
}
else {
local_40 = 3;
local_48 = local_48 - 3;
}
}
}
local_48 = my_well_formed_length(local_10,local_38,local_38 + local_48,local_30,local_3c);
lVar1 = local_18;
if ((param_7 & 8) == 0) {
if ((bVar4) && (local_48 + local_40 < local_68)) {
local_18 = strfill(local_18,(local_68 - local_48) - (ulong)local_40,0x20);
}
local_18 = strnmov(local_18,local_38,local_48);
if (local_40 != 0) {
local_18 = strfill(local_18,local_40,0x2e);
}
}
else {
local_18 = backtick_string(local_10,local_18,local_20,local_38,local_48 + local_40,0x60,
local_40 != 0);
local_48 = local_18 - lVar1;
local_40 = 0;
}
if ((!bVar4) && (local_48 + local_40 < local_68)) {
local_18 = strfill(local_18,(local_68 - local_48) - (ulong)local_40,0x20);
}
return local_18;
}
|
|
7,786 |
fmt::v11::basic_appender<char> fmt::v11::detail::write_codepoint<2ul, char, fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>, char, unsigned int)
|
zkingston[P]unknot/build_O1/_deps/fmt-src/include/fmt/format.h
|
auto write_codepoint(OutputIt out, char prefix, uint32_t cp) -> OutputIt {
*out++ = static_cast<Char>('\\');
*out++ = static_cast<Char>(prefix);
Char buf[width];
fill_n(buf, width, static_cast<Char>('0'));
format_base2e(4, buf, cp, width);
return copy<Char>(buf, buf + width, out);
}
|
O1
|
c
|
fmt::v11::basic_appender<char> fmt::v11::detail::write_codepoint<2ul, char, fmt::v11::basic_appender<char>>(fmt::v11::basic_appender<char>, char, unsigned int):
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
incq %rsi
cmpq %rsi, 0x10(%rdi)
jae 0x40c9f
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb $0x5c, (%rax,%rcx)
movq 0x8(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x10(%rbx)
jae 0x40cc5
movq %rbx, %rdi
callq *0x18(%rbx)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
movb %r14b, (%rax,%rcx)
leaq 0x10(%rsp), %rdx
movw $0x3030, -0x2(%rdx) # imm = 0x3030
leaq 0xf(%rsp), %rax
leaq 0x252c2f(%rip), %rcx # 0x29391e
movl %ebp, %esi
movl %ebp, %edi
andl $0xf, %edi
movb (%rdi,%rcx), %dil
movb %dil, (%rax)
shrl $0x4, %esi
decq %rax
cmpl $0xf, %ebp
movl %esi, %ebp
ja 0x40cf1
leaq 0xe(%rsp), %rsi
movq %rbx, %rdi
callq 0x3f992
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
|
_ZN3fmt3v116detail15write_codepointILm2EcNS0_14basic_appenderIcEEEET1_S5_cj:
push rbp
push r14
push rbx
sub rsp, 10h
mov ebp, edx
mov r14d, esi
mov rbx, rdi
mov rsi, [rdi+8]
inc rsi
cmp [rdi+10h], rsi
jnb short loc_40C9F
mov rdi, rbx
call qword ptr [rbx+18h]
loc_40C9F:
mov rax, [rbx]
mov rcx, [rbx+8]
lea rdx, [rcx+1]
mov [rbx+8], rdx
mov byte ptr [rax+rcx], 5Ch ; '\'
mov rsi, [rbx+8]
inc rsi
cmp [rbx+10h], rsi
jnb short loc_40CC5
mov rdi, rbx
call qword ptr [rbx+18h]
loc_40CC5:
mov rax, [rbx]
mov rcx, [rbx+8]
lea rdx, [rcx+1]
mov [rbx+8], rdx
mov [rax+rcx], r14b
lea rdx, [rsp+28h+var_18]
mov word ptr [rdx-2], 3030h
lea rax, [rsp+28h+var_19]
lea rcx, a0123456789abcd_0; "0123456789abcdef"
mov esi, ebp
loc_40CF1:
mov edi, ebp
and edi, 0Fh
mov dil, [rdi+rcx]
mov [rax], dil
shr esi, 4
dec rax
cmp ebp, 0Fh
mov ebp, esi
ja short loc_40CF1
lea rsi, [rsp+28h+var_1A]
mov rdi, rbx
call _ZN3fmt3v116detail6bufferIcE6appendIcEEvPKT_S7_; fmt::v11::detail::buffer<char>::append<char>(char const*,char const*)
mov rax, rbx
add rsp, 10h
pop rbx
pop r14
pop rbp
retn
|
long long fmt::v11::detail::write_codepoint<2ul,char,fmt::v11::basic_appender<char>>(
long long a1,
char a2,
unsigned int a3)
{
long long v4; // rax
long long v5; // rcx
long long v6; // rax
long long v7; // rcx
_BYTE *v8; // rax
unsigned int v9; // esi
bool v10; // cc
__int16 v12; // [rsp+Eh] [rbp-1Ah] BYREF
_BYTE v13[24]; // [rsp+10h] [rbp-18h] BYREF
if ( *(_QWORD *)(a1 + 16) < (unsigned long long)(*(_QWORD *)(a1 + 8) + 1LL) )
(*(void ( **)(long long))(a1 + 24))(a1);
v4 = *(_QWORD *)a1;
v5 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v5 + 1;
*(_BYTE *)(v4 + v5) = 92;
if ( *(_QWORD *)(a1 + 16) < (unsigned long long)(*(_QWORD *)(a1 + 8) + 1LL) )
(*(void ( **)(long long))(a1 + 24))(a1);
v6 = *(_QWORD *)a1;
v7 = *(_QWORD *)(a1 + 8);
*(_QWORD *)(a1 + 8) = v7 + 1;
*(_BYTE *)(v6 + v7) = a2;
v12 = 12336;
v8 = (char *)&v12 + 1;
v9 = a3;
do
{
*v8 = a0123456789abcd_0[a3 & 0xF];
v9 >>= 4;
--v8;
v10 = a3 <= 0xF;
a3 = v9;
}
while ( !v10 );
fmt::v11::detail::buffer<char>::append<char>(a1, (long long)&v12, (long long)v13);
return a1;
}
|
write_codepoint<2ul,char,fmt::v11::basic_appender<char>>:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x10
MOV EBP,EDX
MOV R14D,ESI
MOV RBX,RDI
MOV RSI,qword ptr [RDI + 0x8]
INC RSI
CMP qword ptr [RDI + 0x10],RSI
JNC 0x00140c9f
MOV RDI,RBX
CALL qword ptr [RBX + 0x18]
LAB_00140c9f:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RBX + 0x8],RDX
MOV byte ptr [RAX + RCX*0x1],0x5c
MOV RSI,qword ptr [RBX + 0x8]
INC RSI
CMP qword ptr [RBX + 0x10],RSI
JNC 0x00140cc5
MOV RDI,RBX
CALL qword ptr [RBX + 0x18]
LAB_00140cc5:
MOV RAX,qword ptr [RBX]
MOV RCX,qword ptr [RBX + 0x8]
LEA RDX,[RCX + 0x1]
MOV qword ptr [RBX + 0x8],RDX
MOV byte ptr [RAX + RCX*0x1],R14B
LEA RDX,[RSP + 0x10]
MOV word ptr [RDX + -0x2],0x3030
LEA RAX,[RSP + 0xf]
LEA RCX,[0x39391e]
MOV ESI,EBP
LAB_00140cf1:
MOV EDI,EBP
AND EDI,0xf
MOV DIL,byte ptr [RDI + RCX*0x1]
MOV byte ptr [RAX],DIL
SHR ESI,0x4
DEC RAX
CMP EBP,0xf
MOV EBP,ESI
JA 0x00140cf1
LEA RSI,[RSP + 0xe]
MOV RDI,RBX
CALL 0x0013f992
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R14
POP RBP
RET
|
/* fmt::v11::basic_appender<char> fmt::v11::detail::write_codepoint<2ul, char,
fmt::v11::basic_appender<char> >(fmt::v11::basic_appender<char>, char, unsigned int) */
buffer<char> *
fmt::v11::detail::write_codepoint<2ul,char,fmt::v11::basic_appender<char>>
(buffer<char> *param_1,int1 param_2,ulong param_3)
{
long lVar1;
char *pcVar2;
uint uVar3;
char local_1a [2];
if (*(ulong *)(param_1 + 0x10) < *(long *)(param_1 + 8) + 1U) {
(**(code **)(param_1 + 0x18))(param_1);
}
lVar1 = *(long *)(param_1 + 8);
*(long *)(param_1 + 8) = lVar1 + 1;
*(int1 *)(*(long *)param_1 + lVar1) = 0x5c;
if (*(ulong *)(param_1 + 0x10) < *(long *)(param_1 + 8) + 1U) {
(**(code **)(param_1 + 0x18))(param_1);
}
lVar1 = *(long *)(param_1 + 8);
*(long *)(param_1 + 8) = lVar1 + 1;
*(int1 *)(*(long *)param_1 + lVar1) = param_2;
local_1a[0] = '0';
local_1a[1] = '0';
pcVar2 = local_1a + 1;
param_3 = param_3 & 0xffffffff;
do {
uVar3 = (uint)param_3;
*pcVar2 = "0123456789abcdef"[uVar3 & 0xf];
param_3 = param_3 >> 4;
pcVar2 = pcVar2 + -1;
} while (0xf < uVar3);
buffer<char>::append<char>(param_1,local_1a,&stack0xffffffffffffffe8);
return param_1;
}
|
|
7,787 |
heap_release_share
|
eloqsql/storage/heap/hp_open.c
|
void heap_release_share(HP_SHARE *share, my_bool internal_table)
{
/* Couldn't open table; Remove the newly created table */
if (internal_table)
hp_free(share);
else
{
mysql_mutex_lock(&THR_LOCK_heap);
if (--share->open_count == 0)
hp_free(share);
mysql_mutex_unlock(&THR_LOCK_heap);
}
}
|
O3
|
c
|
heap_release_share:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testb %sil, %sil
je 0x27ddf
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x26058
leaq 0x345aa2(%rip), %r14 # 0x36d888
cmpq $0x0, 0x40(%r14)
jne 0x27e22
leaq 0x345a94(%rip), %rdi # 0x36d888
callq 0x24420
decl 0x10c(%rbx)
jne 0x27e09
movq %rbx, %rdi
callq 0x26058
movq 0x40(%r14), %rdi
testq %rdi, %rdi
jne 0x27e29
leaq 0x345a6f(%rip), %rdi # 0x36d888
popq %rbx
popq %r14
popq %rbp
jmp 0x241e0
callq 0x24661
jmp 0x27df9
leaq 0x2cea78(%rip), %rax # 0x2f68a8
movq (%rax), %rax
callq *0x160(%rax)
jmp 0x27e12
|
heap_release_share:
push rbp
mov rbp, rsp
push r14
push rbx
mov rbx, rdi
test sil, sil
jz short loc_27DDF
mov rdi, rbx
pop rbx
pop r14
pop rbp
jmp hp_free
loc_27DDF:
lea r14, THR_LOCK_heap
cmp qword ptr [r14+40h], 0
jnz short loc_27E22
lea rdi, THR_LOCK_heap
call _pthread_mutex_lock
loc_27DF9:
dec dword ptr [rbx+10Ch]
jnz short loc_27E09
mov rdi, rbx
call hp_free
loc_27E09:
mov rdi, [r14+40h]
test rdi, rdi
jnz short loc_27E29
loc_27E12:
lea rdi, THR_LOCK_heap
pop rbx
pop r14
pop rbp
jmp _pthread_mutex_unlock
loc_27E22:
call heap_release_share_cold_1
jmp short loc_27DF9
loc_27E29:
lea rax, PSI_server
mov rax, [rax]
call qword ptr [rax+160h]
jmp short loc_27E12
|
long long heap_release_share(long long a1, char a2)
{
if ( a2 )
return hp_free(a1);
if ( THR_LOCK_heap[8] )
heap_release_share_cold_1();
else
pthread_mutex_lock(THR_LOCK_heap);
if ( (*(_DWORD *)(a1 + 268))-- == 1 )
hp_free(a1);
if ( THR_LOCK_heap[8] )
(*((void (**)(void))PSI_server[0] + 44))();
return pthread_mutex_unlock(THR_LOCK_heap);
}
|
heap_release_share:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
MOV RBX,RDI
TEST SIL,SIL
JZ 0x00127ddf
MOV RDI,RBX
POP RBX
POP R14
POP RBP
JMP 0x00126058
LAB_00127ddf:
LEA R14,[0x46d888]
CMP qword ptr [R14 + 0x40],0x0
JNZ 0x00127e22
LEA RDI,[0x46d888]
CALL 0x00124420
LAB_00127df9:
DEC dword ptr [RBX + 0x10c]
JNZ 0x00127e09
MOV RDI,RBX
CALL 0x00126058
LAB_00127e09:
MOV RDI,qword ptr [R14 + 0x40]
TEST RDI,RDI
JNZ 0x00127e29
LAB_00127e12:
LEA RDI,[0x46d888]
POP RBX
POP R14
POP RBP
JMP 0x001241e0
LAB_00127e22:
CALL 0x00124661
JMP 0x00127df9
LAB_00127e29:
LEA RAX,[0x3f68a8]
MOV RAX,qword ptr [RAX]
CALL qword ptr [RAX + 0x160]
JMP 0x00127e12
|
void heap_release_share(long param_1,char param_2)
{
int *piVar1;
if (param_2 != '\0') {
hp_free(param_1);
return;
}
if (THR_LOCK_heap._64_8_ == 0) {
pthread_mutex_lock((pthread_mutex_t *)THR_LOCK_heap);
}
else {
heap_release_share_cold_1();
}
piVar1 = (int *)(param_1 + 0x10c);
*piVar1 = *piVar1 + -1;
if (*piVar1 == 0) {
hp_free(param_1);
}
if (THR_LOCK_heap._64_8_ != 0) {
(**(code **)(PSI_server + 0x160))();
}
pthread_mutex_unlock((pthread_mutex_t *)THR_LOCK_heap);
return;
}
|
|
7,788 |
ok
|
eloqsql/unittest/mytap/tap.c
|
void
ok(int pass, char const *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
if (!pass && *g_test.todo == '\0')
++g_test.failed;
vemit_tap(pass, fmt, ap);
va_end(ap);
if (*g_test.todo != '\0')
emit_dir("todo", g_test.todo);
emit_endl();
}
|
O0
|
c
|
ok:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2c5d8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
cmpl $0x0, -0x4(%rbp)
jne 0x2c640
movsbl 0x3a1c18(%rip), %eax # 0x3ce244
cmpl $0x0, %eax
jne 0x2c640
movl 0x3a1c09(%rip), %eax # 0x3ce240
addl $0x1, %eax
movl %eax, 0x3a1c00(%rip) # 0x3ce240
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x2c690
leaq -0x30(%rbp), %rax
movsbl 0x3a1be9(%rip), %eax # 0x3ce244
cmpl $0x0, %eax
je 0x2c677
leaq 0x84354(%rip), %rdi # 0xb09bb
leaq 0x3a1bca(%rip), %rsi # 0x3ce238
addq $0xc, %rsi
callq 0x2c770
callq 0x2cbd0
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
ok:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_2C5D8
movaps [rbp+var_B0], xmm0
movaps [rbp+var_A0], xmm1
movaps [rbp+var_90], xmm2
movaps [rbp+var_80], xmm3
movaps [rbp+var_70], xmm4
movaps [rbp+var_60], xmm5
movaps [rbp+var_50], xmm6
movaps [rbp+var_40], xmm7
loc_2C5D8:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_4], edi
mov [rbp+var_10], rsi
lea rax, [rbp+var_30]
lea rcx, [rbp+var_E0]
mov [rax+10h], rcx
lea rcx, [rbp+arg_0]
mov [rax+8], rcx
mov dword ptr [rax+4], 30h ; '0'
mov dword ptr [rax], 10h
cmp [rbp+var_4], 0
jnz short loc_2C640
movsx eax, cs:byte_3CE244
cmp eax, 0
jnz short loc_2C640
mov eax, cs:dword_3CE240
add eax, 1
mov cs:dword_3CE240, eax
loc_2C640:
mov edi, [rbp+var_4]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call vemit_tap
lea rax, [rbp+var_30]
movsx eax, cs:byte_3CE244
cmp eax, 0
jz short loc_2C677
lea rdi, aTodo; "todo"
lea rsi, g_test
add rsi, 0Ch
call emit_dir
loc_2C677:
call emit_endl
add rsp, 0E0h
pop rbp
retn
|
long long ok(unsigned int a1, long long a2, ...)
{
va_list va; // [rsp+B0h] [rbp-30h] BYREF
long long v4; // [rsp+D0h] [rbp-10h]
unsigned int v5; // [rsp+DCh] [rbp-4h]
va_start(va, a2);
v5 = a1;
v4 = a2;
if ( !a1 && !byte_3CE244 )
++dword_3CE240;
vemit_tap(v5, v4, va);
if ( byte_3CE244 )
emit_dir("todo", &g_test + 3);
return emit_endl();
}
|
ok:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x0012c5d8
MOVAPS xmmword ptr [RBP + -0xb0],XMM0
MOVAPS xmmword ptr [RBP + -0xa0],XMM1
MOVAPS xmmword ptr [RBP + -0x90],XMM2
MOVAPS xmmword ptr [RBP + -0x80],XMM3
MOVAPS xmmword ptr [RBP + -0x70],XMM4
MOVAPS xmmword ptr [RBP + -0x60],XMM5
MOVAPS xmmword ptr [RBP + -0x50],XMM6
MOVAPS xmmword ptr [RBP + -0x40],XMM7
LAB_0012c5d8:
MOV qword ptr [RBP + -0xb8],R9
MOV qword ptr [RBP + -0xc0],R8
MOV qword ptr [RBP + -0xc8],RCX
MOV qword ptr [RBP + -0xd0],RDX
MOV dword ptr [RBP + -0x4],EDI
MOV qword ptr [RBP + -0x10],RSI
LEA RAX,[RBP + -0x30]
LEA RCX,[RBP + -0xe0]
MOV qword ptr [RAX + 0x10],RCX
LEA RCX,[RBP + 0x10]
MOV qword ptr [RAX + 0x8],RCX
MOV dword ptr [RAX + 0x4],0x30
MOV dword ptr [RAX],0x10
CMP dword ptr [RBP + -0x4],0x0
JNZ 0x0012c640
MOVSX EAX,byte ptr [0x004ce244]
CMP EAX,0x0
JNZ 0x0012c640
MOV EAX,dword ptr [0x004ce240]
ADD EAX,0x1
MOV dword ptr [0x004ce240],EAX
LAB_0012c640:
MOV EDI,dword ptr [RBP + -0x4]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x0012c690
LEA RAX,[RBP + -0x30]
MOVSX EAX,byte ptr [0x004ce244]
CMP EAX,0x0
JZ 0x0012c677
LEA RDI,[0x1b09bb]
LEA RSI,[0x4ce238]
ADD RSI,0xc
CALL 0x0012c770
LAB_0012c677:
CALL 0x0012cbd0
ADD RSP,0xe0
POP RBP
RET
|
void ok(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,int param_9,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14)
{
char in_AL;
int1 local_e8 [16];
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0;
int8 local_b8;
int8 local_a8;
int8 local_98;
int8 local_88;
int8 local_78;
int8 local_68;
int8 local_58;
int8 local_48;
int4 local_38;
int4 local_34;
int1 *local_30;
int1 *local_28;
int8 local_18;
int local_c;
if (in_AL != '\0') {
local_b8 = param_1;
local_a8 = param_2;
local_98 = param_3;
local_88 = param_4;
local_78 = param_5;
local_68 = param_6;
local_58 = param_7;
local_48 = param_8;
}
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
if ((param_9 == 0) && (DAT_004ce244 == '\0')) {
DAT_004ce240 = DAT_004ce240 + 1;
}
local_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_c = param_9;
vemit_tap(param_9,param_10,&local_38);
if (DAT_004ce244 != '\0') {
emit_dir(&DAT_001b09bb,&DAT_004ce244);
}
emit_endl();
return;
}
|
|
7,789 |
int10_to_str
|
eloqsql/strings/int2str.c
|
char *int10_to_str(long int val,char *dst,int radix)
{
char buffer[65];
register char *p;
long int new_val;
unsigned long int uval = (unsigned long int) val;
if (radix < 0) /* -10 */
{
if (val < 0)
{
*dst++ = '-';
/* Avoid integer overflow in (-val) for LONGLONG_MIN (BUG#31799). */
uval = (unsigned long int)0 - uval;
}
}
p = &buffer[sizeof(buffer)-1];
*p = '\0';
new_val= (long) (uval / 10);
*--p = '0'+ (char) (uval - (unsigned long) new_val * 10);
val = new_val;
while (val != 0)
{
new_val=val/10;
*--p = '0' + (char) (val-new_val*10);
val= new_val;
}
while ((*dst++ = *p++) != 0) ;
return dst-1;
}
|
O3
|
c
|
int10_to_str:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
testl %edx, %edx
setns %al
testq %rdi, %rdi
setns %cl
orb %al, %cl
jne 0xd60b3
movb $0x2d, (%rsi)
incq %rsi
negq %rdi
leaq -0x11(%rbp), %r8
movabsq $-0x3333333333333333, %r9 # imm = 0xCCCCCCCCCCCCCCCD
movq %rdi, %rax
mulq %r9
movq %rdx, %rcx
movb $0x0, 0x1(%r8)
shrq $0x3, %rcx
imull $0xf6, %ecx, %eax
addl %edi, %eax
addb $0x30, %al
movb %al, (%r8)
cmpq $0xa, %rdi
jb 0xd610a
movq %rcx, %rax
mulq %r9
shrq $0x3, %rdx
imull $0xf6, %edx, %eax
addl %ecx, %eax
addb $0x30, %al
movb %al, -0x1(%r8)
decq %r8
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0xd60e6
decq %rsi
movb (%r8), %al
incq %r8
movb %al, 0x1(%rsi)
incq %rsi
testb %al, %al
jne 0xd610d
movq %fs:0x28, %rax
cmpq -0x8(%rbp), %rax
jne 0xd6135
movq %rsi, %rax
addq $0x50, %rsp
popq %rbp
retq
callq 0x29260
nop
|
int10_to_str:
push rbp
mov rbp, rsp
sub rsp, 50h
mov rax, fs:28h
mov [rbp+var_8], rax
test edx, edx
setns al
test rdi, rdi
setns cl
or cl, al
jnz short loc_D60B3
mov byte ptr [rsi], 2Dh ; '-'
inc rsi
neg rdi
loc_D60B3:
lea r8, [rbp+var_11]
mov r9, 0CCCCCCCCCCCCCCCDh
mov rax, rdi
mul r9
mov rcx, rdx
mov byte ptr [r8+1], 0
shr rcx, 3
imul eax, ecx, 0F6h
add eax, edi
add al, 30h ; '0'
mov [r8], al
cmp rdi, 0Ah
jb short loc_D610A
loc_D60E6:
mov rax, rcx
mul r9
shr rdx, 3
imul eax, edx, 0F6h
add eax, ecx
add al, 30h ; '0'
mov [r8-1], al
dec r8
cmp rcx, 9
mov rcx, rdx
ja short loc_D60E6
loc_D610A:
dec rsi
loc_D610D:
mov al, [r8]
inc r8
mov [rsi+1], al
inc rsi
test al, al
jnz short loc_D610D
mov rax, fs:28h
cmp rax, [rbp+var_8]
jnz short loc_D6135
mov rax, rsi
add rsp, 50h
pop rbp
retn
loc_D6135:
call ___stack_chk_fail
|
_BYTE * int10_to_str(unsigned long long a1, _BYTE *a2, int a3)
{
char *v3; // r8
unsigned long long v4; // rcx
bool v5; // cc
_BYTE *v6; // rsi
char v7; // al
_BYTE v9[9]; // [rsp+3Fh] [rbp-11h] BYREF
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
if ( a3 < 0 && (a1 & 0x8000000000000000LL) != 0LL )
{
*a2++ = 45;
a1 = -(long long)a1;
}
v3 = v9;
v9[1] = 0;
v4 = a1 / 0xA;
v9[0] = a1 % 0xA + 48;
if ( a1 >= 0xA )
{
do
{
*--v3 = v4 % 0xA + 48;
v5 = v4 <= 9;
v4 /= 0xAuLL;
}
while ( !v5 );
}
v6 = a2 - 1;
do
{
v7 = *v3++;
*++v6 = v7;
}
while ( v7 );
return v6;
}
|
int10_to_str:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
TEST EDX,EDX
SETNS AL
TEST RDI,RDI
SETNS CL
OR CL,AL
JNZ 0x001d60b3
MOV byte ptr [RSI],0x2d
INC RSI
NEG RDI
LAB_001d60b3:
LEA R8,[RBP + -0x11]
MOV R9,-0x3333333333333333
MOV RAX,RDI
MUL R9
MOV RCX,RDX
MOV byte ptr [R8 + 0x1],0x0
SHR RCX,0x3
IMUL EAX,ECX,0xf6
ADD EAX,EDI
ADD AL,0x30
MOV byte ptr [R8],AL
CMP RDI,0xa
JC 0x001d610a
LAB_001d60e6:
MOV RAX,RCX
MUL R9
SHR RDX,0x3
IMUL EAX,EDX,0xf6
ADD EAX,ECX
ADD AL,0x30
MOV byte ptr [R8 + -0x1],AL
DEC R8
CMP RCX,0x9
MOV RCX,RDX
JA 0x001d60e6
LAB_001d610a:
DEC RSI
LAB_001d610d:
MOV AL,byte ptr [R8]
INC R8
MOV byte ptr [RSI + 0x1],AL
INC RSI
TEST AL,AL
JNZ 0x001d610d
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x8]
JNZ 0x001d6135
MOV RAX,RSI
ADD RSP,0x50
POP RBP
RET
LAB_001d6135:
CALL 0x00129260
|
int1 * int10_to_str(ulong param_1,int1 *param_2,int param_3)
{
char cVar1;
ulong uVar2;
ulong uVar3;
char *pcVar4;
long in_FS_OFFSET;
char local_1a [10];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
if ((long)param_1 < 0 && param_3 < 0) {
*param_2 = 0x2d;
param_2 = param_2 + 1;
param_1 = -param_1;
}
pcVar4 = local_1a + 1;
local_1a[2] = 0;
local_1a[1] = (char)(param_1 / 10) * -10 + (char)param_1 + '0';
uVar3 = param_1 / 10;
while (uVar2 = uVar3, 9 < param_1) {
pcVar4[-1] = (char)(uVar2 / 10) * -10 + (char)uVar2 + '0';
pcVar4 = pcVar4 + -1;
uVar3 = uVar2 / 10;
param_1 = uVar2;
}
param_2 = param_2 + -1;
do {
cVar1 = *pcVar4;
pcVar4 = pcVar4 + 1;
param_2[1] = cVar1;
param_2 = param_2 + 1;
} while (cVar1 != '\0');
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return param_2;
}
|
|
7,790 |
minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>)
|
monkey531[P]llama/common/./minja.hpp
|
static Value array(const std::vector<Value> values = {}) {
auto array = std::make_shared<ArrayType>();
for (const auto& item : values) {
array->push_back(item);
}
return Value(array);
}
|
O2
|
cpp
|
minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>):
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x4882b
movq (%r15), %r14
movq 0x8(%r15), %r15
cmpq %r15, %r14
je 0x4a03d
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x4a124
addq $0x50, %r14
jmp 0x4a026
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4a150
leaq 0x8(%rsp), %rdi
callq 0x2eeb2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2eeb2
movq %rbx, %rdi
callq 0x20b90
|
_ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE:
push r15
push r14
push rbx
sub rsp, 10h
mov r15, rsi
mov rbx, rdi
mov rdi, rsp
call _ZSt11make_sharedISt6vectorIN5minja5ValueESaIS2_EEJEESt10shared_ptrIT_EDpOT0_; std::make_shared<std::vector<minja::Value>>()
mov r14, [r15]
mov r15, [r15+8]
loc_4A026:
cmp r14, r15
jz short loc_4A03D
mov rdi, [rsp+28h+var_28]
mov rsi, r14
call _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
add r14, 50h ; 'P'
jmp short loc_4A026
loc_4A03D:
mov rsi, rsp
mov rdi, rbx
call _ZN5minja5ValueC2ERKSt10shared_ptrISt6vectorIS0_SaIS0_EEE; minja::Value::Value(std::shared_ptr<std::vector<minja::Value>> const&)
lea rdi, [rsp+28h+var_20]
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
pop r14
pop r15
retn
mov rbx, rax
lea rdi, [rsp+arg_0]
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 minja::Value::array(long long a1, long long *a2)
{
long long v2; // r14
long long v3; // r15
long long v5; // [rsp+0h] [rbp-28h] BYREF
_QWORD v6[4]; // [rsp+8h] [rbp-20h] BYREF
std::make_shared<std::vector<minja::Value>>((long long)&v5);
v2 = *a2;
v3 = a2[1];
while ( v2 != v3 )
{
std::vector<minja::Value>::push_back(v5, v2);
v2 += 80LL;
}
minja::Value::Value(a1, &v5);
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::~__shared_count(v6);
return a1;
}
| |||
7,791 |
minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>)
|
monkey531[P]llama/common/./minja.hpp
|
static Value array(const std::vector<Value> values = {}) {
auto array = std::make_shared<ArrayType>();
for (const auto& item : values) {
array->push_back(item);
}
return Value(array);
}
|
O3
|
cpp
|
minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value>>):
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movl $0x28, %edi
callq 0x18690
movq %rax, %r14
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x8(%r14)
leaq 0x9eda1(%rip), %rax # 0xee4a8
movq %rax, (%r14)
leaq 0x10(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, 0x8(%rsp)
movq %r15, (%rsp)
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x4f745
movq %r15, %rdi
movq %r12, %rsi
callq 0x4f876
addq $0x50, %r12
jmp 0x4f72f
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4f8a2
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x4f761
callq 0x2f80e
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f80e
movq %rbx, %rdi
callq 0x18b90
nop
|
_ZN5minja5Value5arrayESt6vectorIS0_SaIS0_EE:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 10h
mov r13, rsi
mov rbx, rdi
mov edi, 28h ; '('; unsigned __int64
call __Znwm; operator new(ulong)
mov r14, rax
mov rax, 100000001h
mov [r14+8], rax
lea rax, off_EE4A8
mov [r14], rax
lea r15, [r14+10h]
xorps xmm0, xmm0
movups xmmword ptr [r14+10h], xmm0
mov qword ptr [r14+20h], 0
mov [rsp+38h+var_30], r14
mov [rsp+38h+var_38], r15
mov r12, [r13+0]
mov r13, [r13+8]
loc_4F72F:
cmp r12, r13
jz short loc_4F745
mov rdi, r15
mov rsi, r12
call _ZNSt6vectorIN5minja5ValueESaIS1_EE9push_backERKS1_; std::vector<minja::Value>::push_back(minja::Value const&)
add r12, 50h ; 'P'
jmp short loc_4F72F
loc_4F745:
mov r14, rsp
mov rdi, rbx
mov rsi, r14
call _ZN5minja5ValueC2ERKSt10shared_ptrISt6vectorIS0_SaIS0_EEE; minja::Value::Value(std::shared_ptr<std::vector<minja::Value>> const&)
mov rdi, [r14+8]
test rdi, rdi
jz short loc_4F761
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_4F761:
mov rax, rbx
add rsp, 10h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
mov rbx, rax
mov rdi, r14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
mov rdi, rbx
call __Unwind_Resume
|
long long minja::Value::array(long long a1, long long *a2)
{
long long v2; // r14
long long v3; // r12
long long v4; // r13
long long v6; // [rsp+0h] [rbp-38h] BYREF
volatile signed __int32 *v7; // [rsp+8h] [rbp-30h]
v2 = operator new(0x28uLL);
*(_QWORD *)(v2 + 8) = 0x100000001LL;
*(_QWORD *)v2 = off_EE4A8;
*(_OWORD *)(v2 + 16) = 0LL;
*(_QWORD *)(v2 + 32) = 0LL;
v7 = (volatile signed __int32 *)v2;
v6 = v2 + 16;
v3 = *a2;
v4 = a2[1];
while ( v3 != v4 )
{
std::vector<minja::Value>::push_back(v2 + 16, v3);
v3 += 80LL;
}
minja::Value::Value(a1, &v6);
if ( v7 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v7);
return a1;
}
|
array:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R13,RSI
MOV RBX,RDI
MOV EDI,0x28
CALL 0x00118690
MOV R14,RAX
MOV RAX,0x100000001
MOV qword ptr [R14 + 0x8],RAX
LEA RAX,[0x1ee4a8]
MOV qword ptr [R14],RAX
LEA R15,[R14 + 0x10]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOV qword ptr [R14 + 0x20],0x0
MOV qword ptr [RSP + 0x8],R14
MOV qword ptr [RSP],R15
MOV R12,qword ptr [R13]
MOV R13,qword ptr [R13 + 0x8]
LAB_0014f72f:
CMP R12,R13
JZ 0x0014f745
LAB_0014f734:
MOV RDI,R15
MOV RSI,R12
CALL 0x0014f876
LAB_0014f73f:
ADD R12,0x50
JMP 0x0014f72f
LAB_0014f745:
MOV R14,RSP
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014f8a2
MOV RDI,qword ptr [R14 + 0x8]
TEST RDI,RDI
JZ 0x0014f761
CALL 0x0012f80e
LAB_0014f761:
MOV RAX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
|
/* minja::Value::array(std::vector<minja::Value, std::allocator<minja::Value> >) */
Value * __thiscall minja::Value::array(Value *this,int8 *param_2)
{
vector<minja::Value,std::allocator<minja::Value>> *this_00;
Value *pVVar1;
Value *pVVar2;
vector<minja::Value,std::allocator<minja::Value>> *local_38;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_30;
local_30 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)operator_new(0x28);
*(int8 *)(local_30 + 8) = 0x100000001;
*(int ***)local_30 = &PTR___Sp_counted_ptr_inplace_001ee4a8;
this_00 = (vector<minja::Value,std::allocator<minja::Value>> *)(local_30 + 0x10);
*(int8 *)(local_30 + 0x10) = 0;
*(int8 *)(local_30 + 0x18) = 0;
*(int8 *)(local_30 + 0x20) = 0;
pVVar1 = (Value *)param_2[1];
local_38 = this_00;
for (pVVar2 = (Value *)*param_2; pVVar2 != pVVar1; pVVar2 = pVVar2 + 0x50) {
/* try { // try from 0014f734 to 0014f73e has its CatchHandler @ 0014f772 */
std::vector<minja::Value,std::allocator<minja::Value>>::push_back(this_00,pVVar2);
}
Value(this,(shared_ptr *)&local_38);
if (local_30 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_30);
}
return this;
}
|
|
7,792 |
codegen_type_conversion_code
|
tsotchke[P]eshkol/src/backend/codegen/type_conversion.c
|
const char* codegen_type_conversion_code(CodegenContext* context, Type* from, Type* to) {
assert(context != NULL);
assert(from != NULL);
assert(to != NULL);
// Same type
if (type_equals(from, to)) {
return "";
}
// Get C types
const char* from_type = codegen_type_to_c_type(from);
const char* to_type = codegen_type_to_c_type(to);
// Generate conversion
if (from->kind == TYPE_INTEGER && to->kind == TYPE_FLOAT) {
return "(float)";
} else if (from->kind == TYPE_FLOAT && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_CHAR && to->kind == TYPE_INTEGER) {
return "(int)";
} else if (from->kind == TYPE_INTEGER && to->kind == TYPE_CHAR) {
return "(char)";
} else if (to->kind == TYPE_ANY) {
// Special case for string to void*
if (from->kind == TYPE_STRING) {
return "(void*)(char*)";
}
// Special case for numeric to void*
else if (from->kind == TYPE_INTEGER || from->kind == TYPE_FLOAT) {
// For scientific computing, we need to be careful with numeric conversions
// We'll use a more explicit cast to void*
Arena* arena = codegen_context_get_arena(context);
char* result = arena_alloc(arena, strlen(from_type) + 20);
sprintf(result, "({ %s temp = ", from_type);
return result;
}
return "(void*)";
} else {
// Default cast
char* result = arena_alloc(codegen_context_get_arena(context), strlen(to_type) + 3);
sprintf(result, "(%s)", to_type);
return result;
}
}
|
O0
|
c
|
codegen_type_conversion_code:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10e8d
jmp 0x10eac
leaq 0x522a(%rip), %rdi # 0x160be
leaq 0xa8b9(%rip), %rsi # 0x1b754
movl $0x9e, %edx
leaq 0xaa3c(%rip), %rcx # 0x1b8e3
callq 0x1120
cmpq $0x0, -0x18(%rbp)
je 0x10eb5
jmp 0x10ed4
leaq 0xa9e0(%rip), %rdi # 0x1b89c
leaq 0xa891(%rip), %rsi # 0x1b754
movl $0x9f, %edx
leaq 0xaa14(%rip), %rcx # 0x1b8e3
callq 0x1120
cmpq $0x0, -0x20(%rbp)
je 0x10edd
jmp 0x10efc
leaq 0xa9f4(%rip), %rdi # 0x1b8d8
leaq 0xa869(%rip), %rsi # 0x1b754
movl $0xa0, %edx
leaq 0xa9ec(%rip), %rcx # 0x1b8e3
callq 0x1120
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x150f0
testb $0x1, %al
jne 0x10f0f
jmp 0x10f1f
leaq 0x7304(%rip), %rax # 0x1821a
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x18(%rbp), %rdi
callq 0x10a20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10a20
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10f5b
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x10f5b
leaq 0xa9dc(%rip), %rax # 0x1b92e
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x10f7d
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10f7d
leaq 0xa9c2(%rip), %rax # 0x1b936
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x10f9f
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10f9f
leaq 0xa9a0(%rip), %rax # 0x1b936
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10fc1
movq -0x20(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x10fc1
leaq 0xa984(%rip), %rax # 0x1b93c
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x20(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x1105a
movq -0x18(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x10fe7
leaq 0xa965(%rip), %rax # 0x1b943
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x18(%rbp), %rax
cmpl $0x2, (%rax)
je 0x10ff9
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x1104b
movq -0x10(%rbp), %rdi
callq 0x6690
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq $0x14, %rsi
callq 0x1c30
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0xa918(%rip), %rsi # 0x1b952
movb $0x0, %al
callq 0x11e0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x110a2
jmp 0x1104d
leaq 0xa90c(%rip), %rax # 0x1b960
movq %rax, -0x8(%rbp)
jmp 0x110a2
movq -0x10(%rbp), %rdi
callq 0x6690
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x10b0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
addq $0x3, %rsi
callq 0x1c30
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0xa94f(%rip), %rsi # 0x1b9e2
movb $0x0, %al
callq 0x11e0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
codegen_type_conversion_code:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
cmp [rbp+var_10], 0
jz short loc_10E8D
jmp short loc_10EAC
loc_10E8D:
lea rdi, aTypeContextNul+5; "context != NULL"
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9Eh
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
call ___assert_fail
loc_10EAC:
cmp [rbp+var_18], 0
jz short loc_10EB5
jmp short loc_10ED4
loc_10EB5:
lea rdi, aFromNull; "from != NULL"
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
mov edx, 9Fh
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
call ___assert_fail
loc_10ED4:
cmp [rbp+var_20], 0
jz short loc_10EDD
jmp short loc_10EFC
loc_10EDD:
lea rdi, aToNull; "to != NULL"
lea rsi, aWorkspaceLlm4b_19; "/workspace/llm4binary/github/2025_star3"...
mov edx, 0A0h
lea rcx, aConstCharCodeg_1; "const char *codegen_type_conversion_cod"...
call ___assert_fail
loc_10EFC:
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call type_equals
test al, 1
jnz short loc_10F0F
jmp short loc_10F1F
loc_10F0F:
lea rax, aIncludeCoreAut+1Ch; ""
mov [rbp+var_8], rax
jmp loc_110A2
loc_10F1F:
mov rdi, [rbp+var_18]
call codegen_type_to_c_type
mov [rbp+var_28], rax
mov rdi, [rbp+var_20]
call codegen_type_to_c_type
mov [rbp+var_30], rax
mov rax, [rbp+var_18]
cmp dword ptr [rax], 2
jnz short loc_10F5B
mov rax, [rbp+var_20]
cmp dword ptr [rax], 3
jnz short loc_10F5B
lea rax, aFloat_0; "(float)"
mov [rbp+var_8], rax
jmp loc_110A2
loc_10F5B:
mov rax, [rbp+var_18]
cmp dword ptr [rax], 3
jnz short loc_10F7D
mov rax, [rbp+var_20]
cmp dword ptr [rax], 2
jnz short loc_10F7D
lea rax, aInt_1; "(int)"
mov [rbp+var_8], rax
jmp loc_110A2
loc_10F7D:
mov rax, [rbp+var_18]
cmp dword ptr [rax], 4
jnz short loc_10F9F
mov rax, [rbp+var_20]
cmp dword ptr [rax], 2
jnz short loc_10F9F
lea rax, aInt_1; "(int)"
mov [rbp+var_8], rax
jmp loc_110A2
loc_10F9F:
mov rax, [rbp+var_18]
cmp dword ptr [rax], 2
jnz short loc_10FC1
mov rax, [rbp+var_20]
cmp dword ptr [rax], 4
jnz short loc_10FC1
lea rax, aChar_1; "(char)"
mov [rbp+var_8], rax
jmp loc_110A2
loc_10FC1:
mov rax, [rbp+var_20]
cmp dword ptr [rax], 0Ch
jnz loc_1105A
mov rax, [rbp+var_18]
cmp dword ptr [rax], 5
jnz short loc_10FE7
lea rax, aVoidChar; "(void*)(char*)"
mov [rbp+var_8], rax
jmp loc_110A2
loc_10FE7:
mov rax, [rbp+var_18]
cmp dword ptr [rax], 2
jz short loc_10FF9
mov rax, [rbp+var_18]
cmp dword ptr [rax], 3
jnz short loc_1104B
loc_10FF9:
mov rdi, [rbp+var_10]
call codegen_context_get_arena
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov [rbp+var_50], rax
mov rdi, [rbp+var_28]
call _strlen
mov rdi, [rbp+var_50]
mov rsi, rax
add rsi, 14h
call arena_alloc
mov [rbp+var_40], rax
mov rdi, [rbp+var_40]
mov rdx, [rbp+var_28]
lea rsi, aSTemp; "({ %s temp = "
mov al, 0
call _sprintf
mov rax, [rbp+var_40]
mov [rbp+var_8], rax
jmp short loc_110A2
loc_1104B:
jmp short $+2
loc_1104D:
lea rax, aVoid_2; "(void*)"
mov [rbp+var_8], rax
jmp short loc_110A2
loc_1105A:
mov rdi, [rbp+var_10]
call codegen_context_get_arena
mov [rbp+var_58], rax
mov rdi, [rbp+var_30]
call _strlen
mov rdi, [rbp+var_58]
mov rsi, rax
add rsi, 3
call arena_alloc
mov [rbp+var_48], rax
mov rdi, [rbp+var_48]
mov rdx, [rbp+var_30]
lea rsi, aSS_0+2; "(%s)"
mov al, 0
call _sprintf
mov rax, [rbp+var_48]
mov [rbp+var_8], rax
loc_110A2:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
char * codegen_type_conversion_code(long long a1, _DWORD *a2, _DWORD *a3)
{
long long v3; // rax
long long v4; // rax
long long v6; // [rsp+8h] [rbp-58h]
long long arena; // [rsp+10h] [rbp-50h]
long long v8; // [rsp+18h] [rbp-48h]
long long v9; // [rsp+20h] [rbp-40h]
const char *v10; // [rsp+30h] [rbp-30h]
const char *v11; // [rsp+38h] [rbp-28h]
if ( !a1 )
__assert_fail(
"context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
158LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a2 )
__assert_fail(
"from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
159LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( !a3 )
__assert_fail(
"to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c",
160LL,
"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
if ( (type_equals(a2, a3) & 1) != 0 )
return "";
v11 = codegen_type_to_c_type(a2);
v10 = codegen_type_to_c_type(a3);
if ( *a2 == 2 && *a3 == 3 )
return "(float)";
if ( *a2 == 3 && *a3 == 2 )
return "(int)";
if ( *a2 == 4 && *a3 == 2 )
return "(int)";
if ( *a2 == 2 && *a3 == 4 )
return "(char)";
if ( *a3 == 12 )
{
if ( *a2 == 5 )
{
return "(void*)(char*)";
}
else if ( *a2 == 2 || *a2 == 3 )
{
arena = codegen_context_get_arena(a1);
v3 = strlen(v11);
v9 = arena_alloc(arena, v3 + 20);
sprintf(v9, "({ %s temp = ", v11);
return (char *)v9;
}
else
{
return "(void*)";
}
}
else
{
v6 = codegen_context_get_arena(a1);
v4 = strlen(v10);
v8 = arena_alloc(v6, v4 + 3);
sprintf(v8, "(%s)", v10);
return (char *)v8;
}
}
|
codegen_type_conversion_code:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
CMP qword ptr [RBP + -0x10],0x0
JZ 0x00110e8d
JMP 0x00110eac
LAB_00110e8d:
LEA RDI,[0x1160be]
LEA RSI,[0x11b754]
MOV EDX,0x9e
LEA RCX,[0x11b8e3]
CALL 0x00101120
LAB_00110eac:
CMP qword ptr [RBP + -0x18],0x0
JZ 0x00110eb5
JMP 0x00110ed4
LAB_00110eb5:
LEA RDI,[0x11b89c]
LEA RSI,[0x11b754]
MOV EDX,0x9f
LEA RCX,[0x11b8e3]
CALL 0x00101120
LAB_00110ed4:
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00110edd
JMP 0x00110efc
LAB_00110edd:
LEA RDI,[0x11b8d8]
LEA RSI,[0x11b754]
MOV EDX,0xa0
LEA RCX,[0x11b8e3]
CALL 0x00101120
LAB_00110efc:
MOV RDI,qword ptr [RBP + -0x18]
MOV RSI,qword ptr [RBP + -0x20]
CALL 0x001150f0
TEST AL,0x1
JNZ 0x00110f0f
JMP 0x00110f1f
LAB_00110f0f:
LEA RAX,[0x11821a]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110f1f:
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00110a20
MOV qword ptr [RBP + -0x28],RAX
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x00110a20
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x2
JNZ 0x00110f5b
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x3
JNZ 0x00110f5b
LEA RAX,[0x11b92e]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110f5b:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x3
JNZ 0x00110f7d
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x2
JNZ 0x00110f7d
LEA RAX,[0x11b936]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110f7d:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x4
JNZ 0x00110f9f
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x2
JNZ 0x00110f9f
LEA RAX,[0x11b936]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110f9f:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x2
JNZ 0x00110fc1
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x4
JNZ 0x00110fc1
LEA RAX,[0x11b93c]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110fc1:
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0xc
JNZ 0x0011105a
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x5
JNZ 0x00110fe7
LEA RAX,[0x11b943]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_00110fe7:
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x2
JZ 0x00110ff9
MOV RAX,qword ptr [RBP + -0x18]
CMP dword ptr [RAX],0x3
JNZ 0x0011104b
LAB_00110ff9:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106690
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x28]
CALL 0x001010b0
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,RAX
ADD RSI,0x14
CALL 0x00101c30
MOV qword ptr [RBP + -0x40],RAX
MOV RDI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x28]
LEA RSI,[0x11b952]
MOV AL,0x0
CALL 0x001011e0
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_0011104b:
JMP 0x0011104d
LAB_0011104d:
LEA RAX,[0x11b960]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001110a2
LAB_0011105a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00106690
MOV qword ptr [RBP + -0x58],RAX
MOV RDI,qword ptr [RBP + -0x30]
CALL 0x001010b0
MOV RDI,qword ptr [RBP + -0x58]
MOV RSI,RAX
ADD RSI,0x3
CALL 0x00101c30
MOV qword ptr [RBP + -0x48],RAX
MOV RDI,qword ptr [RBP + -0x48]
MOV RDX,qword ptr [RBP + -0x30]
LEA RSI,[0x11b9e2]
MOV AL,0x0
CALL 0x001011e0
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x8],RAX
LAB_001110a2:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
char * codegen_type_conversion_code(long param_1,int *param_2,int *param_3)
{
ulong uVar1;
char *__s;
char *__s_00;
int8 uVar2;
size_t sVar3;
char *local_10;
if (param_1 == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("context != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9e,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
if (param_2 != (int *)0x0) {
if (param_3 != (int *)0x0) {
uVar1 = type_equals(param_2,param_3);
if ((uVar1 & 1) == 0) {
__s = (char *)codegen_type_to_c_type(param_2);
__s_00 = (char *)codegen_type_to_c_type(param_3);
if ((*param_2 == 2) && (*param_3 == 3)) {
local_10 = "(float)";
}
else if ((*param_2 == 3) && (*param_3 == 2)) {
local_10 = "(int)";
}
else if ((*param_2 == 4) && (*param_3 == 2)) {
local_10 = "(int)";
}
else if ((*param_2 == 2) && (*param_3 == 4)) {
local_10 = "(char)";
}
else if (*param_3 == 0xc) {
if (*param_2 == 5) {
local_10 = "(void*)(char*)";
}
else if ((*param_2 == 2) || (*param_2 == 3)) {
uVar2 = codegen_context_get_arena(param_1);
sVar3 = strlen(__s);
local_10 = (char *)arena_alloc(uVar2,sVar3 + 0x14);
sprintf(local_10,"({ %s temp = ",__s);
}
else {
local_10 = "(void*)";
}
}
else {
uVar2 = codegen_context_get_arena(param_1);
sVar3 = strlen(__s_00);
local_10 = (char *)arena_alloc(uVar2,sVar3 + 3);
sprintf(local_10,"(%s)",__s_00);
}
}
else {
local_10 = "";
}
return local_10;
}
/* WARNING: Subroutine does not return */
__assert_fail("to != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0xa0,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)"
);
}
/* WARNING: Subroutine does not return */
__assert_fail("from != NULL",
"/workspace/llm4binary/github/2025_star3/tsotchke[P]eshkol/src/backend/codegen/type_conversion.c"
,0x9f,"const char *codegen_type_conversion_code(CodegenContext *, Type *, Type *)");
}
|
|
7,793 |
func_uni_gbk_onechar
|
eloqsql/strings/ctype-gbk.c
|
static int func_uni_gbk_onechar(int code){
if ((code>=0x00A4)&&(code<=0x0451))
return(tab_uni_gbk0[code-0x00A4]);
if ((code>=0x2010)&&(code<=0x2312))
return(tab_uni_gbk1[code-0x2010]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gbk2[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gbk3[code-0x3000]);
if ((code>=0x3220)&&(code<=0x32A3))
return(tab_uni_gbk4[code-0x3220]);
if ((code>=0x338E)&&(code<=0x33D5))
return(tab_uni_gbk5[code-0x338E]);
if ((code>=0x4E00)&&(code<=0x9FA5))
return(tab_uni_gbk6[code-0x4E00]);
if ((code>=0xF92C)&&(code<=0xFA29))
return(tab_uni_gbk7[code-0xF92C]);
if ((code>=0xFE30)&&(code<=0xFFE5))
return(tab_uni_gbk8[code-0xFE30]);
return(0);
}
|
O0
|
c
|
func_uni_gbk_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0x471d7
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x471d7
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xea1e5(%rip), %rax # 0x1313b0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x2010, -0x8(%rbp) # imm = 0x2010
jl 0x47207
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x47207
movl -0x8(%rbp), %eax
subl $0x2010, %eax # imm = 0x2010
movslq %eax, %rcx
leaq 0xea915(%rip), %rax # 0x131b10
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x47237
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x47237
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xeaef5(%rip), %rax # 0x132120
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x47267
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x47267
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xeb295(%rip), %rax # 0x1324f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0x47297
cmpl $0x32a3, -0x8(%rbp) # imm = 0x32A3
jg 0x47297
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xeb4c5(%rip), %rax # 0x132750
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x338e, -0x8(%rbp) # imm = 0x338E
jl 0x472c7
cmpl $0x33d5, -0x8(%rbp) # imm = 0x33D5
jg 0x472c7
movl -0x8(%rbp), %eax
subl $0x338e, %eax # imm = 0x338E
movslq %eax, %rcx
leaq 0xeb5a5(%rip), %rax # 0x132860
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x472f4
cmpl $0x9fa5, -0x8(%rbp) # imm = 0x9FA5
jg 0x472f4
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xeb605(%rip), %rax # 0x1328f0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0xf92c, -0x8(%rbp) # imm = 0xF92C
jl 0x47321
cmpl $0xfa29, -0x8(%rbp) # imm = 0xFA29
jg 0x47321
movl -0x8(%rbp), %eax
subl $0xf92c, %eax # imm = 0xF92C
movslq %eax, %rcx
leaq 0xf5928(%rip), %rax # 0x13cc40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
cmpl $0xfe30, -0x8(%rbp) # imm = 0xFE30
jl 0x4734e
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0x4734e
movl -0x8(%rbp), %eax
subl $0xfe30, %eax # imm = 0xFE30
movslq %eax, %rcx
leaq 0xf5afb(%rip), %rax # 0x13ce40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x47355
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
|
func_uni_gbk_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_471D7
cmp [rbp+var_8], 451h
jg short loc_471D7
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gbk0
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_471D7:
cmp [rbp+var_8], 2010h
jl short loc_47207
cmp [rbp+var_8], 2312h
jg short loc_47207
mov eax, [rbp+var_8]
sub eax, 2010h
movsxd rcx, eax
lea rax, tab_uni_gbk1
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_47207:
cmp [rbp+var_8], 2460h
jl short loc_47237
cmp [rbp+var_8], 2642h
jg short loc_47237
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gbk2
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_47237:
cmp [rbp+var_8], 3000h
jl short loc_47267
cmp [rbp+var_8], 3129h
jg short loc_47267
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gbk3
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_47267:
cmp [rbp+var_8], 3220h
jl short loc_47297
cmp [rbp+var_8], 32A3h
jg short loc_47297
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gbk4
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_47297:
cmp [rbp+var_8], 338Eh
jl short loc_472C7
cmp [rbp+var_8], 33D5h
jg short loc_472C7
mov eax, [rbp+var_8]
sub eax, 338Eh
movsxd rcx, eax
lea rax, tab_uni_gbk5
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_47355
loc_472C7:
cmp [rbp+var_8], 4E00h
jl short loc_472F4
cmp [rbp+var_8], 9FA5h
jg short loc_472F4
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gbk6
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_47355
loc_472F4:
cmp [rbp+var_8], 0F92Ch
jl short loc_47321
cmp [rbp+var_8], 0FA29h
jg short loc_47321
mov eax, [rbp+var_8]
sub eax, 0F92Ch
movsxd rcx, eax
lea rax, tab_uni_gbk7
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_47355
loc_47321:
cmp [rbp+var_8], 0FE30h
jl short loc_4734E
cmp [rbp+var_8], 0FFE5h
jg short loc_4734E
mov eax, [rbp+var_8]
sub eax, 0FE30h
movsxd rcx, eax
lea rax, tab_uni_gbk8
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_47355
loc_4734E:
mov [rbp+var_4], 0
loc_47355:
mov eax, [rbp+var_4]
pop rbp
retn
|
long long func_uni_gbk_onechar(int a1)
{
if ( a1 < 164 || a1 > 1105 )
{
if ( a1 < 8208 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12963 )
{
if ( a1 < 13198 || a1 > 13269 )
{
if ( a1 < 19968 || a1 > 40869 )
{
if ( a1 < 63788 || a1 > 64041 )
{
if ( a1 < 65072 || a1 > 65509 )
return 0;
else
return tab_uni_gbk8[a1 - 65072];
}
else
{
return tab_uni_gbk7[a1 - 63788];
}
}
else
{
return tab_uni_gbk6[a1 - 19968];
}
}
else
{
return tab_uni_gbk5[a1 - 13198];
}
}
else
{
return tab_uni_gbk4[a1 - 12832];
}
}
else
{
return tab_uni_gbk3[a1 - 12288];
}
}
else
{
return tab_uni_gbk2[a1 - 9312];
}
}
else
{
return tab_uni_gbk1[a1 - 8208];
}
}
else
{
return tab_uni_gbk0[a1 - 164];
}
}
|
func_uni_gbk_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x001471d7
CMP dword ptr [RBP + -0x8],0x451
JG 0x001471d7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x2313b0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_001471d7:
CMP dword ptr [RBP + -0x8],0x2010
JL 0x00147207
CMP dword ptr [RBP + -0x8],0x2312
JG 0x00147207
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2010
MOVSXD RCX,EAX
LEA RAX,[0x231b10]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_00147207:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x00147237
CMP dword ptr [RBP + -0x8],0x2642
JG 0x00147237
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x232120]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_00147237:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x00147267
CMP dword ptr [RBP + -0x8],0x3129
JG 0x00147267
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x2324f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_00147267:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x00147297
CMP dword ptr [RBP + -0x8],0x32a3
JG 0x00147297
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x232750]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_00147297:
CMP dword ptr [RBP + -0x8],0x338e
JL 0x001472c7
CMP dword ptr [RBP + -0x8],0x33d5
JG 0x001472c7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x338e
MOVSXD RCX,EAX
LEA RAX,[0x232860]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_001472c7:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x001472f4
CMP dword ptr [RBP + -0x8],0x9fa5
JG 0x001472f4
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x2328f0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_001472f4:
CMP dword ptr [RBP + -0x8],0xf92c
JL 0x00147321
CMP dword ptr [RBP + -0x8],0xfa29
JG 0x00147321
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xf92c
MOVSXD RCX,EAX
LEA RAX,[0x23cc40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_00147321:
CMP dword ptr [RBP + -0x8],0xfe30
JL 0x0014734e
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x0014734e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xfe30
MOVSXD RCX,EAX
LEA RAX,[0x23ce40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00147355
LAB_0014734e:
MOV dword ptr [RBP + -0x4],0x0
LAB_00147355:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gbk_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x451 < param_1)) {
if ((param_1 < 0x2010) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x32a3 < param_1)) {
if ((param_1 < 0x338e) || (0x33d5 < param_1)) {
if ((param_1 < 0x4e00) || (0x9fa5 < param_1)) {
if ((param_1 < 0xf92c) || (0xfa29 < param_1)) {
if ((param_1 < 0xfe30) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gbk8 + (long)(param_1 + -0xfe30) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk7 + (long)(param_1 + -0xf92c) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk6 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk5 + (long)(param_1 + -0x338e) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk4 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk3 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk2 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk1 + (long)(param_1 + -0x2010) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gbk0 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
|
|
7,794 |
my_hash_sort_ucs2_nopad_bin
|
eloqsql/strings/ctype-ucs2.c
|
static void
my_hash_sort_ucs2_nopad_bin(CHARSET_INFO *cs __attribute__((unused)),
const uchar *key, size_t len,
ulong *nr1, ulong *nr2)
{
const uchar *end= key + len;
register ulong m1= *nr1, m2= *nr2;
for ( ; key < end ; key++)
{
MY_HASH_ADD(m1, m2, (uint)*key);
}
*nr1= m1;
*nr2= m2;
}
|
O3
|
c
|
my_hash_sort_ucs2_nopad_bin:
movq (%rcx), %rax
movq (%r8), %rdi
testq %rdx, %rdx
jle 0x81a31
pushq %rbp
movq %rsp, %rbp
addq %rsi, %rdx
movl %eax, %r9d
andl $0x3f, %r9d
addq %rdi, %r9
movzbl (%rsi), %r10d
imulq %r9, %r10
movq %rax, %r9
shlq $0x8, %r9
addq %r10, %r9
xorq %r9, %rax
addq $0x3, %rdi
incq %rsi
cmpq %rdx, %rsi
jb 0x81a05
popq %rbp
movq %rax, (%rcx)
movq %rdi, (%r8)
retq
|
my_hash_sort_ucs2_nopad_bin:
mov rax, [rcx]
mov rdi, [r8]
test rdx, rdx
jle short loc_81A31
push rbp
mov rbp, rsp
add rdx, rsi
loc_81A05:
mov r9d, eax
and r9d, 3Fh
add r9, rdi
movzx r10d, byte ptr [rsi]
imul r10, r9
mov r9, rax
shl r9, 8
add r9, r10
xor rax, r9
add rdi, 3
inc rsi
cmp rsi, rdx
jb short loc_81A05
pop rbp
loc_81A31:
mov [rcx], rax
mov [r8], rdi
retn
|
long long my_hash_sort_ucs2_nopad_bin(long long a1, unsigned __int8 *a2, long long a3, long long *a4, long long *a5)
{
long long result; // rax
long long v6; // rdi
unsigned __int8 *v7; // rdx
result = *a4;
v6 = *a5;
if ( a3 > 0 )
{
v7 = &a2[a3];
do
{
result ^= (v6 + (result & 0x3F)) * *a2 + (result << 8);
v6 += 3LL;
++a2;
}
while ( a2 < v7 );
}
*a4 = result;
*a5 = v6;
return result;
}
|
my_hash_sort_ucs2_nopad_bin:
MOV RAX,qword ptr [RCX]
MOV RDI,qword ptr [R8]
TEST RDX,RDX
JLE 0x00181a31
PUSH RBP
MOV RBP,RSP
ADD RDX,RSI
LAB_00181a05:
MOV R9D,EAX
AND R9D,0x3f
ADD R9,RDI
MOVZX R10D,byte ptr [RSI]
IMUL R10,R9
MOV R9,RAX
SHL R9,0x8
ADD R9,R10
XOR RAX,R9
ADD RDI,0x3
INC RSI
CMP RSI,RDX
JC 0x00181a05
POP RBP
LAB_00181a31:
MOV qword ptr [RCX],RAX
MOV qword ptr [R8],RDI
RET
|
void my_hash_sort_ucs2_nopad_bin
(int8 param_1,byte *param_2,long param_3,ulong *param_4,long *param_5)
{
ulong uVar1;
byte *pbVar2;
long lVar3;
uVar1 = *param_4;
lVar3 = *param_5;
if (0 < param_3) {
pbVar2 = param_2 + param_3;
do {
uVar1 = uVar1 ^ uVar1 * 0x100 + (ulong)*param_2 * ((ulong)((uint)uVar1 & 0x3f) + lVar3);
lVar3 = lVar3 + 3;
param_2 = param_2 + 1;
} while (param_2 < pbVar2);
}
*param_4 = uVar1;
*param_5 = lVar3;
return;
}
|
|
7,795 |
tree_insert
|
eloqsql/mysys/tree.c
|
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size,
void* custom_arg)
{
int cmp;
TREE_ELEMENT *element,***parent;
parent= tree->parents;
*parent = &tree->root; element= tree->root;
for (;;)
{
if (element == &null_element ||
(cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
key)) == 0)
break;
if (cmp < 0)
{
*++parent= &element->right; element= element->right;
}
else
{
*++parent = &element->left; element= element->left;
}
}
if (element == &null_element)
{
uint alloc_size;
if (tree->flag & TREE_ONLY_DUPS)
return TREE_ELEMENT_UNIQUE;
alloc_size=sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
tree->allocated+=alloc_size;
if (tree->memory_limit && tree->elements_in_tree
&& tree->allocated > tree->memory_limit)
{
reset_tree(tree);
return tree_insert(tree, key, key_size, custom_arg);
}
key_size+=tree->size_of_element;
if (tree->with_delete)
element=(TREE_ELEMENT *) my_malloc(key_memory_TREE, alloc_size,
MYF(tree->my_flags | MY_WME));
else
element=(TREE_ELEMENT *) alloc_root(&tree->mem_root,alloc_size);
if (!element)
return(NULL);
**parent=element;
element->left=element->right= &null_element;
if (!tree->offset_to_key)
{
if (key_size == sizeof(void*)) /* no length, save pointer */
*((void**) (element+1))=key;
else
{
*((void**) (element+1))= (void*) ((void **) (element+1)+1);
memcpy((uchar*) *((void **) (element+1)),key,
(size_t) (key_size-sizeof(void*)));
}
}
else
memcpy((uchar*) element+tree->offset_to_key,key,(size_t) key_size);
element->count=1; /* May give warning in purify */
tree->elements_in_tree++;
rb_insert(tree,parent,element); /* rebalance tree */
}
else
{
if (tree->flag & TREE_NO_DUPS)
return(NULL);
element->count++;
/* Avoid a wrap over of the count. */
if (! element->count)
element->count--;
}
DBUG_EXECUTE("check_tree", test_rb_tree(tree->root););
return element;
}
|
O0
|
c
|
tree_insert:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq 0x1a83e8(%rip), %rax # 0x1dd468
cmpq %rax, -0x38(%rbp)
je 0x350e7
movq -0x10(%rbp), %rax
movq 0x228(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
je 0x350c1
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x208(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
jmp 0x350cd
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x350e9
jmp 0x3513f
cmpl $0x0, -0x2c(%rbp)
jge 0x35118
movq -0x38(%rbp), %rcx
addq $0x8, %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x3513a
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x35079
leaq 0x1a8322(%rip), %rax # 0x1dd468
cmpq %rax, -0x38(%rbp)
jne 0x35340
movq -0x10(%rbp), %rax
movl 0x290(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x35170
movl $0x1, %eax
movq %rax, -0x8(%rbp)
jmp 0x353c3
movl -0x1c(%rbp), %eax
addq $0x18, %rax
movq -0x10(%rbp), %rcx
movl 0x210(%rcx), %ecx
addq %rcx, %rax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x220(%rax), %rcx
movq %rcx, 0x220(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x218(%rax)
je 0x351f7
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20c(%rax)
je 0x351f7
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x218(%rcx), %rax
jbe 0x351f7
movq -0x10(%rbp), %rdi
callq 0x35010
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0x35040
movq %rax, -0x8(%rbp)
jmp 0x353c3
movq -0x10(%rbp), %rax
movl 0x210(%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x278(%rax)
je 0x3523c
leaq 0x378e31(%rip), %rax # 0x3ae04c
movl (%rax), %edi
movl -0x44(%rbp), %eax
movl %eax, %esi
movq -0x10(%rbp), %rax
movq 0x288(%rax), %rdx
orq $0x10, %rdx
callq 0x30750
movq %rax, -0x38(%rbp)
jmp 0x35255
movq -0x10(%rbp), %rdi
addq $0x238, %rdi # imm = 0x238
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x3cd70
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x35269
movq $0x0, -0x8(%rbp)
jmp 0x353c3
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
leaq 0x1a81e6(%rip), %rcx # 0x1dd468
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
leaq 0x1a81d7(%rip), %rcx # 0x1dd468
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x208(%rax)
jne 0x352e8
movl -0x1c(%rbp), %eax
cmpq $0x8, %rax
jne 0x352b8
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x352e6
movq -0x38(%rbp), %rcx
addq $0x18, %rcx
addq $0x8, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
subq $0x8, %rdx
callq 0x24200
jmp 0x35307
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x208(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x24200
movq -0x38(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0x80000000, %ecx # imm = 0x80000000
orl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x20c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20c(%rax)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x353d0
jmp 0x353b7
movq -0x10(%rbp), %rax
movl 0x290(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x3535c
movq $0x0, -0x8(%rbp)
jmp 0x353c3
movq -0x38(%rbp), %rax
movl 0x10(%rax), %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
addl $0x1, %edx
movl 0x10(%rax), %ecx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl $0x80000000, %ecx # imm = 0x80000000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x0, %eax
jne 0x353b5
movq -0x38(%rbp), %rax
movl 0x10(%rax), %edx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
addl $-0x1, %edx
movl 0x10(%rax), %ecx
andl $0x7fffffff, %edx # imm = 0x7FFFFFFF
andl $0x80000000, %ecx # imm = 0x80000000
orl %edx, %ecx
movl %ecx, 0x10(%rax)
jmp 0x353b7
jmp 0x353b9
jmp 0x353bb
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
|
tree_insert:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_28], rcx
mov rax, [rbp+var_10]
add rax, 8
mov [rbp+var_40], rax
mov rcx, [rbp+var_10]
mov rax, [rbp+var_40]
mov [rax], rcx
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_38], rax
loc_35079:
lea rax, null_element
cmp [rbp+var_38], rax
jz short loc_350E7
mov rax, [rbp+var_10]
mov rax, [rax+228h]
mov [rbp+var_58], rax
mov rax, [rbp+var_28]
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jz short loc_350C1
mov rax, [rbp+var_38]
mov rcx, [rbp+var_10]
mov ecx, [rcx+208h]
add rax, rcx
mov [rbp+var_60], rax
jmp short loc_350CD
loc_350C1:
mov rax, [rbp+var_38]
mov rax, [rax+18h]
mov [rbp+var_60], rax
loc_350CD:
mov rax, [rbp+var_58]
mov rdi, [rbp+var_50]
mov rsi, [rbp+var_60]
mov rdx, [rbp+var_18]
call rax
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_350E9
loc_350E7:
jmp short loc_3513F
loc_350E9:
cmp [rbp+var_2C], 0
jge short loc_35118
mov rcx, [rbp+var_38]
add rcx, 8
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 8
mov [rbp+var_40], rdx
mov [rax+8], rcx
mov rax, [rbp+var_38]
mov rax, [rax+8]
mov [rbp+var_38], rax
jmp short loc_3513A
loc_35118:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov rdx, rax
add rdx, 8
mov [rbp+var_40], rdx
mov [rax+8], rcx
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_38], rax
loc_3513A:
jmp loc_35079
loc_3513F:
lea rax, null_element
cmp [rbp+var_38], rax
jnz loc_35340
mov rax, [rbp+var_10]
mov eax, [rax+290h]
and eax, 2
cmp eax, 0
jz short loc_35170
mov eax, 1
mov [rbp+var_8], rax
jmp loc_353C3
loc_35170:
mov eax, [rbp+var_1C]
add rax, 18h
mov rcx, [rbp+var_10]
mov ecx, [rcx+210h]
add rax, rcx
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
mov ecx, eax
mov rax, [rbp+var_10]
add rcx, [rax+220h]
mov [rax+220h], rcx
mov rax, [rbp+var_10]
cmp qword ptr [rax+218h], 0
jz short loc_351F7
mov rax, [rbp+var_10]
cmp dword ptr [rax+20Ch], 0
jz short loc_351F7
mov rax, [rbp+var_10]
mov rax, [rax+220h]
mov rcx, [rbp+var_10]
cmp rax, [rcx+218h]
jbe short loc_351F7
mov rdi, [rbp+var_10]
call reset_tree
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_18]
mov edx, [rbp+var_1C]
mov rcx, [rbp+var_28]
call tree_insert
mov [rbp+var_8], rax
jmp loc_353C3
loc_351F7:
mov rax, [rbp+var_10]
mov eax, [rax+210h]
add eax, [rbp+var_1C]
mov [rbp+var_1C], eax
mov rax, [rbp+var_10]
cmp byte ptr [rax+278h], 0
jz short loc_3523C
lea rax, key_memory_TREE
mov edi, [rax]
mov eax, [rbp+var_44]
mov esi, eax
mov rax, [rbp+var_10]
mov rdx, [rax+288h]
or rdx, 10h
call my_malloc
mov [rbp+var_38], rax
jmp short loc_35255
loc_3523C:
mov rdi, [rbp+var_10]
add rdi, 238h
mov eax, [rbp+var_44]
mov esi, eax
call alloc_root
mov [rbp+var_38], rax
loc_35255:
cmp [rbp+var_38], 0
jnz short loc_35269
mov [rbp+var_8], 0
jmp loc_353C3
loc_35269:
mov rcx, [rbp+var_38]
mov rax, [rbp+var_40]
mov rax, [rax]
mov [rax], rcx
mov rax, [rbp+var_38]
lea rcx, null_element
mov [rax+8], rcx
mov rax, [rbp+var_38]
lea rcx, null_element
mov [rax], rcx
mov rax, [rbp+var_10]
cmp dword ptr [rax+208h], 0
jnz short loc_352E8
mov eax, [rbp+var_1C]
cmp rax, 8
jnz short loc_352B8
mov rcx, [rbp+var_18]
mov rax, [rbp+var_38]
mov [rax+18h], rcx
jmp short loc_352E6
loc_352B8:
mov rcx, [rbp+var_38]
add rcx, 18h
add rcx, 8
mov rax, [rbp+var_38]
mov [rax+18h], rcx
mov rax, [rbp+var_38]
mov rdi, [rax+18h]
mov rsi, [rbp+var_18]
mov eax, [rbp+var_1C]
mov edx, eax
sub rdx, 8
call _memcpy
loc_352E6:
jmp short loc_35307
loc_352E8:
mov rdi, [rbp+var_38]
mov rax, [rbp+var_10]
mov eax, [rax+208h]
add rdi, rax
mov rsi, [rbp+var_18]
mov eax, [rbp+var_1C]
mov edx, eax
call _memcpy
loc_35307:
mov rax, [rbp+var_38]
mov ecx, [rax+10h]
and ecx, 80000000h
or ecx, 1
mov [rax+10h], ecx
mov rax, [rbp+var_10]
mov ecx, [rax+20Ch]
add ecx, 1
mov [rax+20Ch], ecx
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_38]
call rb_insert
jmp short loc_353B7
loc_35340:
mov rax, [rbp+var_10]
mov eax, [rax+290h]
and eax, 1
cmp eax, 0
jz short loc_3535C
mov [rbp+var_8], 0
jmp short loc_353C3
loc_3535C:
mov rax, [rbp+var_38]
mov edx, [rax+10h]
and edx, 7FFFFFFFh
add edx, 1
mov ecx, [rax+10h]
and edx, 7FFFFFFFh
and ecx, 80000000h
or ecx, edx
mov [rax+10h], ecx
mov rax, [rbp+var_38]
mov eax, [rax+10h]
and eax, 7FFFFFFFh
cmp eax, 0
jnz short loc_353B5
mov rax, [rbp+var_38]
mov edx, [rax+10h]
and edx, 7FFFFFFFh
add edx, 0FFFFFFFFh
mov ecx, [rax+10h]
and edx, 7FFFFFFFh
and ecx, 80000000h
or ecx, edx
mov [rax+10h], ecx
loc_353B5:
jmp short $+2
loc_353B7:
jmp short $+2
loc_353B9:
jmp short $+2
loc_353BB:
mov rax, [rbp+var_38]
mov [rbp+var_8], rax
loc_353C3:
mov rax, [rbp+var_8]
add rsp, 60h
pop rbp
retn
|
long long tree_insert(long long a1, long long a2, unsigned int a3, long long a4)
{
int v4; // eax
long long **v5; // rax
long long **v6; // rax
long long ( *v8)(long long, long long, long long); // [rsp+8h] [rbp-58h]
unsigned int v9; // [rsp+1Ch] [rbp-44h]
long long **v10; // [rsp+20h] [rbp-40h]
long long v11; // [rsp+28h] [rbp-38h]
unsigned int v14; // [rsp+44h] [rbp-1Ch]
v10 = (long long **)(a1 + 8);
*(_QWORD *)(a1 + 8) = a1;
v11 = *(_QWORD *)a1;
while ( (_UNKNOWN *)v11 != &null_element )
{
v8 = *(long long ( **)(long long, long long, long long))(a1 + 552);
v4 = *(_DWORD *)(a1 + 520) ? v8(a4, *(unsigned int *)(a1 + 520) + v11, a2) : v8(a4, *(_QWORD *)(v11 + 24), a2);
if ( !v4 )
break;
if ( v4 >= 0 )
{
v6 = v10++;
v6[1] = (long long *)v11;
v11 = *(_QWORD *)v11;
}
else
{
v5 = v10++;
v5[1] = (long long *)(v11 + 8);
v11 = *(_QWORD *)(v11 + 8);
}
}
if ( (_UNKNOWN *)v11 != &null_element )
{
if ( (*(_DWORD *)(a1 + 656) & 1) != 0 )
return 0LL;
*(_DWORD *)(v11 + 16) = ((*(_DWORD *)(v11 + 16) & 0x7FFFFFFF) + 1) & 0x7FFFFFFF | *(_DWORD *)(v11 + 16) & 0x80000000;
if ( (*(_DWORD *)(v11 + 16) & 0x7FFFFFFF) == 0 )
*(_DWORD *)(v11 + 16) = ((*(_DWORD *)(v11 + 16) & 0x7FFFFFFF) - 1) & 0x7FFFFFFF | *(_DWORD *)(v11 + 16) & 0x80000000;
return v11;
}
if ( (*(_DWORD *)(a1 + 656) & 2) == 0 )
{
v9 = *(_DWORD *)(a1 + 528) + a3 + 24;
*(_QWORD *)(a1 + 544) += v9;
if ( *(_QWORD *)(a1 + 536) && *(_DWORD *)(a1 + 524) && *(_QWORD *)(a1 + 544) > *(_QWORD *)(a1 + 536) )
{
reset_tree((_QWORD *)a1);
return tree_insert(a1, a2, a3, a4);
}
v14 = a3 + *(_DWORD *)(a1 + 528);
if ( *(_BYTE *)(a1 + 632) )
v11 = my_malloc(key_memory_TREE, v9, *(_DWORD *)(a1 + 648) | 0x10u);
else
v11 = alloc_root(a1 + 568, v9);
if ( !v11 )
return 0LL;
**v10 = v11;
*(_QWORD *)(v11 + 8) = &null_element;
*(_QWORD *)v11 = &null_element;
if ( *(_DWORD *)(a1 + 520) )
{
memcpy(*(unsigned int *)(a1 + 520) + v11, a2, v14);
}
else if ( v14 == 8LL )
{
*(_QWORD *)(v11 + 24) = a2;
}
else
{
*(_QWORD *)(v11 + 24) = v11 + 32;
memcpy(*(_QWORD *)(v11 + 24), a2, v14 - 8LL);
}
*(_DWORD *)(v11 + 16) = *(_DWORD *)(v11 + 16) & 0x80000000 | 1;
++*(_DWORD *)(a1 + 524);
rb_insert(a1, v10, v11);
return v11;
}
return 1LL;
}
|
tree_insert:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x8
MOV qword ptr [RBP + -0x40],RAX
MOV RCX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_00135079:
LEA RAX,[0x2dd468]
CMP qword ptr [RBP + -0x38],RAX
JZ 0x001350e7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x228]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x208],0x0
JZ 0x001350c1
MOV RAX,qword ptr [RBP + -0x38]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x208]
ADD RAX,RCX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x001350cd
LAB_001350c1:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x18]
MOV qword ptr [RBP + -0x60],RAX
LAB_001350cd:
MOV RAX,qword ptr [RBP + -0x58]
MOV RDI,qword ptr [RBP + -0x50]
MOV RSI,qword ptr [RBP + -0x60]
MOV RDX,qword ptr [RBP + -0x18]
CALL RAX
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x001350e9
LAB_001350e7:
JMP 0x0013513f
LAB_001350e9:
CMP dword ptr [RBP + -0x2c],0x0
JGE 0x00135118
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x38],RAX
JMP 0x0013513a
LAB_00135118:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV RDX,RAX
ADD RDX,0x8
MOV qword ptr [RBP + -0x40],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x38],RAX
LAB_0013513a:
JMP 0x00135079
LAB_0013513f:
LEA RAX,[0x2dd468]
CMP qword ptr [RBP + -0x38],RAX
JNZ 0x00135340
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x290]
AND EAX,0x2
CMP EAX,0x0
JZ 0x00135170
MOV EAX,0x1
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001353c3
LAB_00135170:
MOV EAX,dword ptr [RBP + -0x1c]
ADD RAX,0x18
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x210]
ADD RAX,RCX
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RCX,qword ptr [RAX + 0x220]
MOV qword ptr [RAX + 0x220],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x218],0x0
JZ 0x001351f7
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x20c],0x0
JZ 0x001351f7
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x220]
MOV RCX,qword ptr [RBP + -0x10]
CMP RAX,qword ptr [RCX + 0x218]
JBE 0x001351f7
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00135010
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x18]
MOV EDX,dword ptr [RBP + -0x1c]
MOV RCX,qword ptr [RBP + -0x28]
CALL 0x00135040
MOV qword ptr [RBP + -0x8],RAX
JMP 0x001353c3
LAB_001351f7:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x210]
ADD EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x1c],EAX
MOV RAX,qword ptr [RBP + -0x10]
CMP byte ptr [RAX + 0x278],0x0
JZ 0x0013523c
LEA RAX,[0x4ae04c]
MOV EDI,dword ptr [RAX]
MOV EAX,dword ptr [RBP + -0x44]
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RDX,qword ptr [RAX + 0x288]
OR RDX,0x10
CALL 0x00130750
MOV qword ptr [RBP + -0x38],RAX
JMP 0x00135255
LAB_0013523c:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x238
MOV EAX,dword ptr [RBP + -0x44]
MOV ESI,EAX
CALL 0x0013cd70
MOV qword ptr [RBP + -0x38],RAX
LAB_00135255:
CMP qword ptr [RBP + -0x38],0x0
JNZ 0x00135269
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001353c3
LAB_00135269:
MOV RCX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x2dd468]
MOV qword ptr [RAX + 0x8],RCX
MOV RAX,qword ptr [RBP + -0x38]
LEA RCX,[0x2dd468]
MOV qword ptr [RAX],RCX
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x208],0x0
JNZ 0x001352e8
MOV EAX,dword ptr [RBP + -0x1c]
CMP RAX,0x8
JNZ 0x001352b8
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x18],RCX
JMP 0x001352e6
LAB_001352b8:
MOV RCX,qword ptr [RBP + -0x38]
ADD RCX,0x18
ADD RCX,0x8
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RAX + 0x18],RCX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,qword ptr [RAX + 0x18]
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
SUB RDX,0x8
CALL 0x00124200
LAB_001352e6:
JMP 0x00135307
LAB_001352e8:
MOV RDI,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x208]
ADD RDI,RAX
MOV RSI,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RBP + -0x1c]
MOV EDX,EAX
CALL 0x00124200
LAB_00135307:
MOV RAX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RAX + 0x10]
AND ECX,0x80000000
OR ECX,0x1
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RAX + 0x20c]
ADD ECX,0x1
MOV dword ptr [RAX + 0x20c],ECX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x38]
CALL 0x001353d0
JMP 0x001353b7
LAB_00135340:
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x290]
AND EAX,0x1
CMP EAX,0x0
JZ 0x0013535c
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001353c3
LAB_0013535c:
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RAX + 0x10]
AND EDX,0x7fffffff
ADD EDX,0x1
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x7fffffff
AND ECX,0x80000000
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX + 0x10]
AND EAX,0x7fffffff
CMP EAX,0x0
JNZ 0x001353b5
MOV RAX,qword ptr [RBP + -0x38]
MOV EDX,dword ptr [RAX + 0x10]
AND EDX,0x7fffffff
ADD EDX,-0x1
MOV ECX,dword ptr [RAX + 0x10]
AND EDX,0x7fffffff
AND ECX,0x80000000
OR ECX,EDX
MOV dword ptr [RAX + 0x10],ECX
LAB_001353b5:
JMP 0x001353b7
LAB_001353b7:
JMP 0x001353b9
LAB_001353b9:
JMP 0x001353bb
LAB_001353bb:
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x8],RAX
LAB_001353c3:
MOV RAX,qword ptr [RBP + -0x8]
ADD RSP,0x60
POP RBP
RET
|
int8 * tree_insert(int8 *param_1,void *param_2,int param_3,int8 param_4)
{
int iVar1;
uint uVar2;
uint uVar3;
int8 *puVar4;
long local_68;
int8 *local_48;
int8 *local_40;
local_48 = param_1 + 1;
*local_48 = param_1;
local_40 = (int8 *)*param_1;
while (local_40 != (int8 *)null_element) {
if (*(int *)(param_1 + 0x41) == 0) {
local_68 = local_40[3];
}
else {
local_68 = (long)local_40 + (ulong)*(uint *)(param_1 + 0x41);
}
iVar1 = (*(code *)param_1[0x45])(param_4,local_68,param_2);
if (iVar1 == 0) break;
if (iVar1 < 0) {
local_48[1] = local_40 + 1;
local_40 = (int8 *)local_40[1];
}
else {
local_48[1] = local_40;
local_40 = (int8 *)*local_40;
}
local_48 = local_48 + 1;
}
if (local_40 == (int8 *)null_element) {
if ((*(uint *)(param_1 + 0x52) & 2) != 0) {
return (int8 *)0x1;
}
uVar2 = param_3 + 0x18 + *(int *)(param_1 + 0x42);
param_1[0x44] = (ulong)uVar2 + param_1[0x44];
if (((param_1[0x43] != 0) && (*(int *)((long)param_1 + 0x20c) != 0)) &&
((ulong)param_1[0x43] < (ulong)param_1[0x44])) {
reset_tree(param_1);
puVar4 = (int8 *)tree_insert(param_1,param_2,param_3,param_4);
return puVar4;
}
uVar3 = *(int *)(param_1 + 0x42) + param_3;
if (*(char *)(param_1 + 0x4f) == '\0') {
local_40 = (int8 *)alloc_root(param_1 + 0x47,uVar2);
}
else {
local_40 = (int8 *)my_malloc(key_memory_TREE,uVar2,param_1[0x51] | 0x10);
}
if (local_40 == (int8 *)0x0) {
return (int8 *)0x0;
}
*(int8 **)*local_48 = local_40;
local_40[1] = null_element;
*local_40 = null_element;
if (*(int *)(param_1 + 0x41) == 0) {
if (uVar3 == 8) {
local_40[3] = param_2;
}
else {
local_40[3] = local_40 + 4;
memcpy((void *)local_40[3],param_2,(ulong)uVar3 - 8);
}
}
else {
memcpy((void *)((long)local_40 + (ulong)*(uint *)(param_1 + 0x41)),param_2,(ulong)uVar3);
}
*(uint *)(local_40 + 2) = *(uint *)(local_40 + 2) & 0x80000000 | 1;
*(int *)((long)param_1 + 0x20c) = *(int *)((long)param_1 + 0x20c) + 1;
rb_insert(param_1,local_48,local_40);
}
else {
if ((*(uint *)(param_1 + 0x52) & 1) != 0) {
return (int8 *)0x0;
}
*(uint *)(local_40 + 2) =
*(uint *)(local_40 + 2) & 0x80000000 |
(*(uint *)(local_40 + 2) & 0x7fffffff) + 1 & 0x7fffffff;
if ((*(uint *)(local_40 + 2) & 0x7fffffff) == 0) {
*(uint *)(local_40 + 2) =
*(uint *)(local_40 + 2) & 0x80000000 |
(*(uint *)(local_40 + 2) & 0x7fffffff) - 1 & 0x7fffffff;
}
}
return local_40;
}
|
|
7,796 |
tree_insert
|
eloqsql/mysys/tree.c
|
TREE_ELEMENT *tree_insert(TREE *tree, void *key, uint key_size,
void* custom_arg)
{
int cmp;
TREE_ELEMENT *element,***parent;
parent= tree->parents;
*parent = &tree->root; element= tree->root;
for (;;)
{
if (element == &null_element ||
(cmp = (*tree->compare)(custom_arg, ELEMENT_KEY(tree,element),
key)) == 0)
break;
if (cmp < 0)
{
*++parent= &element->right; element= element->right;
}
else
{
*++parent = &element->left; element= element->left;
}
}
if (element == &null_element)
{
uint alloc_size;
if (tree->flag & TREE_ONLY_DUPS)
return TREE_ELEMENT_UNIQUE;
alloc_size=sizeof(TREE_ELEMENT)+key_size+tree->size_of_element;
tree->allocated+=alloc_size;
if (tree->memory_limit && tree->elements_in_tree
&& tree->allocated > tree->memory_limit)
{
reset_tree(tree);
return tree_insert(tree, key, key_size, custom_arg);
}
key_size+=tree->size_of_element;
if (tree->with_delete)
element=(TREE_ELEMENT *) my_malloc(key_memory_TREE, alloc_size,
MYF(tree->my_flags | MY_WME));
else
element=(TREE_ELEMENT *) alloc_root(&tree->mem_root,alloc_size);
if (!element)
return(NULL);
**parent=element;
element->left=element->right= &null_element;
if (!tree->offset_to_key)
{
if (key_size == sizeof(void*)) /* no length, save pointer */
*((void**) (element+1))=key;
else
{
*((void**) (element+1))= (void*) ((void **) (element+1)+1);
memcpy((uchar*) *((void **) (element+1)),key,
(size_t) (key_size-sizeof(void*)));
}
}
else
memcpy((uchar*) element+tree->offset_to_key,key,(size_t) key_size);
element->count=1; /* May give warning in purify */
tree->elements_in_tree++;
rb_insert(tree,parent,element); /* rebalance tree */
}
else
{
if (tree->flag & TREE_NO_DUPS)
return(NULL);
element->count++;
/* Avoid a wrap over of the count. */
if (! element->count)
element->count--;
}
DBUG_EXECUTE("check_tree", test_rb_tree(tree->root););
return element;
}
|
O3
|
c
|
tree_insert:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq %rdx, -0x38(%rbp)
leal 0x18(%rdx), %eax
movq %rax, -0x40(%rbp)
leaq 0x2ca876(%rip), %rax # 0x2f9468
movq %r12, -0x30(%rbp)
movq %rbx, 0x8(%rbx)
movq (%rbx), %r14
cmpq %rax, %r14
je 0x2ec4d
movq -0x30(%rbp), %r12
movl 0x208(%rbx), %esi
testq %rsi, %rsi
je 0x2ec16
addq %r14, %rsi
jmp 0x2ec1a
movq 0x18(%r14), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq *0x228(%rbx)
testl %eax, %eax
je 0x2ecb1
shrl $0x1f, %eax
leaq (%r14,%rax,8), %rax
movq %rax, 0x8(%r12)
addq $0x8, %r12
movq (%rax), %r14
leaq 0x2ca820(%rip), %rax # 0x2f9468
cmpq %rax, %r14
jne 0x2ec06
testb $0x2, 0x290(%rbx)
jne 0x2ed0f
movl 0x210(%rbx), %edx
movq -0x40(%rbp), %rax
leal (%rax,%rdx), %esi
movq 0x220(%rbx), %rax
addq %rsi, %rax
movq %rax, 0x220(%rbx)
movq 0x218(%rbx), %rcx
testq %rcx, %rcx
je 0x2ece8
cmpl $0x0, 0x20c(%rbx)
je 0x2ece8
cmpq %rcx, %rax
jbe 0x2ece8
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2eae3
leaq 0x2ca7c0(%rip), %rax # 0x2f9468
movq -0x30(%rbp), %r12
jmp 0x2ebf6
testb $0x1, 0x290(%rbx)
jne 0x2ed57
movl 0x10(%r14), %eax
leal 0x1(%rax), %ecx
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl %eax, %edx
andl $0x80000000, %edx # imm = 0x80000000
orl %ecx, %edx
movl %edx, 0x10(%r14)
testl %ecx, %ecx
jne 0x2ed5a
orl $0x7fffffff, %eax # imm = 0x7FFFFFFF
movl %eax, 0x10(%r14)
jmp 0x2ed5a
movq %rdx, %r13
cmpb $0x0, 0x278(%rbx)
je 0x2ed17
leaq 0x35a801(%rip), %rax # 0x3894fc
movl (%rax), %edi
movq 0x288(%rbx), %rdx
orq $0x10, %rdx
callq 0x2b959
jmp 0x2ed23
movl $0x1, %r14d
jmp 0x2ed5a
leaq 0x238(%rbx), %rdi
callq 0x32edf
movq %rax, %r14
testq %rax, %rax
je 0x2ed57
addl -0x38(%rbp), %r13d
movq (%r12), %rax
movq %r14, (%rax)
leaq 0x2ca72b(%rip), %rax # 0x2f9468
movq %rax, 0x8(%r14)
movq %rax, (%r14)
movl 0x208(%rbx), %edi
testq %rdi, %rdi
je 0x2ed6c
addq %r14, %rdi
movl %r13d, %edx
jmp 0x2ed87
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x8, %r13d
jne 0x2ed78
movq %r15, 0x18(%r14)
jmp 0x2ed8f
movl %r13d, %edx
leaq 0x20(%r14), %rdi
movq %rdi, 0x18(%r14)
addq $-0x8, %rdx
movq %r15, %rsi
callq 0x24210
movl $0x80000000, %eax # imm = 0x80000000
andl 0x10(%r14), %eax
incl %eax
movl %eax, 0x10(%r14)
incl 0x20c(%rbx)
andb $0x7f, 0x13(%r14)
cmpq %r14, (%rbx)
je 0x2ee98
addq $-0x10, %r12
movq %r14, %rcx
movq 0x8(%r12), %rdi
movq (%rdi), %rsi
movl 0x10(%rsi), %edx
testl %edx, %edx
js 0x2ee98
movq (%r12), %rax
movq (%rax), %rax
movq (%rax), %r8
cmpq %r8, %rsi
je 0x2ede4
cmpl $0x0, 0x10(%r8)
jns 0x2edef
jmp 0x2ee16
movq 0x8(%rax), %r8
cmpl $0x0, 0x10(%r8)
js 0x2ee23
addq $0x10, %r8
orl $0x80000000, %edx # imm = 0x80000000
movl %edx, 0x10(%rsi)
orb $-0x80, 0x3(%r8)
andb $0x7f, 0x13(%rax)
addq $-0x10, %r12
movq %rax, %rcx
cmpq (%rbx), %rax
jne 0x2edb9
jmp 0x2ee98
movq (%rsi), %r8
cmpq %r8, %rcx
je 0x2ee31
movq %rsi, %rcx
jmp 0x2ee42
movq 0x8(%rsi), %r8
cmpq %r8, %rcx
je 0x2ee63
movq %rsi, %rcx
jmp 0x2ee73
movq 0x8(%r8), %rdx
movq %rdx, (%rsi)
movq %r8, (%rdi)
movq %rsi, 0x8(%r8)
movl 0x10(%rcx), %edx
orl $0x80000000, %edx # imm = 0x80000000
movl %edx, 0x10(%rcx)
andb $0x7f, 0x13(%rax)
movq (%r12), %rdx
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movq %rsi, 0x8(%rax)
movq %rcx, (%rdx)
jmp 0x2ee95
movq (%r8), %rdx
movq %rdx, 0x8(%rsi)
movq %r8, (%rdi)
movq %rsi, (%r8)
movl 0x10(%rcx), %edx
orl $0x80000000, %edx # imm = 0x80000000
movl %edx, 0x10(%rcx)
andb $0x7f, 0x13(%rax)
movq (%r12), %rdx
movq (%rax), %rsi
leaq 0x8(%rsi), %rcx
movq 0x8(%rsi), %rdi
movq %rdi, (%rax)
movq %rsi, (%rdx)
movq %rax, (%rcx)
movq (%rbx), %rax
orl $0x80000000, 0x10(%rax) # imm = 0x80000000
jmp 0x2ed5a
|
tree_insert:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r13, rcx
mov r15, rsi
mov rbx, rdi
lea r12, [rdi+8]
mov [rbp+var_38], rdx
lea eax, [rdx+18h]
mov [rbp+var_40], rax
lea rax, null_element
mov [rbp+var_30], r12
loc_2EBF6:
mov [rbx+8], rbx
mov r14, [rbx]
cmp r14, rax
jz short loc_2EC4D
mov r12, [rbp+var_30]
loc_2EC06:
mov esi, [rbx+208h]
test rsi, rsi
jz short loc_2EC16
add rsi, r14
jmp short loc_2EC1A
loc_2EC16:
mov rsi, [r14+18h]
loc_2EC1A:
mov rdi, r13
mov rdx, r15
call qword ptr [rbx+228h]
test eax, eax
jz loc_2ECB1
shr eax, 1Fh
lea rax, [r14+rax*8]
mov [r12+8], rax
add r12, 8
mov r14, [rax]
lea rax, null_element
cmp r14, rax
jnz short loc_2EC06
loc_2EC4D:
test byte ptr [rbx+290h], 2
jnz loc_2ED0F
mov edx, [rbx+210h]
mov rax, [rbp+var_40]
lea esi, [rax+rdx]
mov rax, [rbx+220h]
add rax, rsi
mov [rbx+220h], rax
mov rcx, [rbx+218h]
test rcx, rcx
jz short loc_2ECE8
cmp dword ptr [rbx+20Ch], 0
jz short loc_2ECE8
cmp rax, rcx
jbe short loc_2ECE8
mov edx, 2
mov rdi, rbx
xor esi, esi
call free_tree
lea rax, null_element
mov r12, [rbp+var_30]
jmp loc_2EBF6
loc_2ECB1:
test byte ptr [rbx+290h], 1
jnz loc_2ED57
mov eax, [r14+10h]
lea ecx, [rax+1]
and ecx, 7FFFFFFFh
mov edx, eax
and edx, 80000000h
or edx, ecx
mov [r14+10h], edx
test ecx, ecx
jnz short loc_2ED5A
or eax, 7FFFFFFFh
mov [r14+10h], eax
jmp short loc_2ED5A
loc_2ECE8:
mov r13, rdx
cmp byte ptr [rbx+278h], 0
jz short loc_2ED17
lea rax, key_memory_TREE
mov edi, [rax]
mov rdx, [rbx+288h]
or rdx, 10h
call my_malloc
jmp short loc_2ED23
loc_2ED0F:
mov r14d, 1
jmp short loc_2ED5A
loc_2ED17:
lea rdi, [rbx+238h]
call alloc_root
loc_2ED23:
mov r14, rax
test rax, rax
jz short loc_2ED57
add r13d, dword ptr [rbp+var_38]
mov rax, [r12]
mov [rax], r14
lea rax, null_element
mov [r14+8], rax
mov [r14], rax
mov edi, [rbx+208h]
test rdi, rdi
jz short loc_2ED6C
add rdi, r14
mov edx, r13d
jmp short loc_2ED87
loc_2ED57:
xor r14d, r14d
loc_2ED5A:
mov rax, r14
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2ED6C:
cmp r13d, 8
jnz short loc_2ED78
mov [r14+18h], r15
jmp short loc_2ED8F
loc_2ED78:
mov edx, r13d
lea rdi, [r14+20h]
mov [r14+18h], rdi
add rdx, 0FFFFFFFFFFFFFFF8h
loc_2ED87:
mov rsi, r15
call _memcpy
loc_2ED8F:
mov eax, 80000000h
and eax, [r14+10h]
inc eax
mov [r14+10h], eax
inc dword ptr [rbx+20Ch]
and byte ptr [r14+13h], 7Fh
cmp [rbx], r14
jz loc_2EE98
add r12, 0FFFFFFFFFFFFFFF0h
mov rcx, r14
loc_2EDB9:
mov rdi, [r12+8]
mov rsi, [rdi]
mov edx, [rsi+10h]
test edx, edx
js loc_2EE98
mov rax, [r12]
mov rax, [rax]
mov r8, [rax]
cmp rsi, r8
jz short loc_2EDE4
cmp dword ptr [r8+10h], 0
jns short loc_2EDEF
jmp short loc_2EE16
loc_2EDE4:
mov r8, [rax+8]
cmp dword ptr [r8+10h], 0
js short loc_2EE23
loc_2EDEF:
add r8, 10h
or edx, 80000000h
mov [rsi+10h], edx
or byte ptr [r8+3], 80h
and byte ptr [rax+13h], 7Fh
add r12, 0FFFFFFFFFFFFFFF0h
mov rcx, rax
cmp rax, [rbx]
jnz short loc_2EDB9
jmp loc_2EE98
loc_2EE16:
mov r8, [rsi]
cmp rcx, r8
jz short loc_2EE31
mov rcx, rsi
jmp short loc_2EE42
loc_2EE23:
mov r8, [rsi+8]
cmp rcx, r8
jz short loc_2EE63
mov rcx, rsi
jmp short loc_2EE73
loc_2EE31:
mov rdx, [r8+8]
mov [rsi], rdx
mov [rdi], r8
mov [r8+8], rsi
mov edx, [rcx+10h]
loc_2EE42:
or edx, 80000000h
mov [rcx+10h], edx
and byte ptr [rax+13h], 7Fh
mov rdx, [r12]
mov rcx, [rax+8]
mov rsi, [rcx]
mov [rax+8], rsi
mov [rdx], rcx
jmp short loc_2EE95
loc_2EE63:
mov rdx, [r8]
mov [rsi+8], rdx
mov [rdi], r8
mov [r8], rsi
mov edx, [rcx+10h]
loc_2EE73:
or edx, 80000000h
mov [rcx+10h], edx
and byte ptr [rax+13h], 7Fh
mov rdx, [r12]
mov rsi, [rax]
lea rcx, [rsi+8]
mov rdi, [rsi+8]
mov [rax], rdi
mov [rdx], rsi
loc_2EE95:
mov [rcx], rax
loc_2EE98:
mov rax, [rbx]
or dword ptr [rax+10h], 80000000h
jmp loc_2ED5A
|
long long tree_insert(long long a1, long long a2, int a3, long long a4)
{
long long v7; // r12
_QWORD *v8; // r14
char *v9; // rsi
unsigned int v10; // eax
_QWORD *v11; // rax
int v12; // edx
unsigned long long v13; // rsi
unsigned long long v14; // rax
unsigned long long v15; // rcx
int v16; // eax
int v17; // ecx
int v18; // r13d
_QWORD *v19; // rax
unsigned int v20; // r13d
long long v21; // rdi
_QWORD *v22; // rdi
long long v23; // rdx
long long v25; // r12
_QWORD *v26; // rcx
long long *v27; // rdi
long long v28; // rsi
int v29; // edx
_QWORD *v30; // rax
long long v31; // r8
_QWORD *v32; // r8
_QWORD *v33; // r8
_QWORD *v34; // rdx
_QWORD *v35; // rcx
_QWORD *v36; // rdx
long long v37; // rsi
int v38; // [rsp+0h] [rbp-40h]
v7 = a1 + 8;
v38 = a3 + 24;
while ( 1 )
{
*(_QWORD *)(a1 + 8) = a1;
v8 = *(_QWORD **)a1;
if ( *(_UNKNOWN **)a1 != &null_element )
{
v7 = a1 + 8;
while ( 1 )
{
v9 = *(_DWORD *)(a1 + 520) ? (char *)v8 + *(unsigned int *)(a1 + 520) : (char *)v8[3];
v10 = (*(long long ( **)(long long, char *, long long))(a1 + 552))(a4, v9, a2);
if ( !v10 )
break;
v11 = &v8[v10 >> 31];
*(_QWORD *)(v7 + 8) = v11;
v7 += 8LL;
v8 = (_QWORD *)*v11;
if ( (_UNKNOWN *)*v11 == &null_element )
goto LABEL_9;
}
if ( (*(_BYTE *)(a1 + 656) & 1) == 0 )
{
v16 = *((_DWORD *)v8 + 4);
v17 = (v16 + 1) & 0x7FFFFFFF;
*((_DWORD *)v8 + 4) = v17 | v16 & 0x80000000;
if ( !v17 )
*((_DWORD *)v8 + 4) = v16 | 0x7FFFFFFF;
return (long long)v8;
}
return 0LL;
}
LABEL_9:
if ( (*(_BYTE *)(a1 + 656) & 2) != 0 )
return 1LL;
v12 = *(_DWORD *)(a1 + 528);
v13 = (unsigned int)(v38 + v12);
v14 = v13 + *(_QWORD *)(a1 + 544);
*(_QWORD *)(a1 + 544) = v14;
v15 = *(_QWORD *)(a1 + 536);
if ( !v15 || !*(_DWORD *)(a1 + 524) || v14 <= v15 )
break;
free_tree((long long *)a1, 0, 2LL);
v7 = a1 + 8;
}
v18 = v12;
if ( *(_BYTE *)(a1 + 632) )
v19 = (_QWORD *)my_malloc(key_memory_TREE, v13, *(_DWORD *)(a1 + 648) | 0x10u);
else
v19 = (_QWORD *)alloc_root(a1 + 568);
v8 = v19;
if ( !v19 )
return 0LL;
v20 = a3 + v18;
**(_QWORD **)v7 = v19;
v19[1] = &null_element;
*v19 = &null_element;
v21 = *(unsigned int *)(a1 + 520);
if ( *(_DWORD *)(a1 + 520) )
{
v22 = (_QWORD *)((char *)v19 + v21);
v23 = v20;
goto LABEL_29;
}
if ( v20 == 8 )
{
v19[3] = a2;
}
else
{
v22 = v19 + 4;
v19[3] = v19 + 4;
v23 = v20 - 8LL;
LABEL_29:
memcpy(v22, a2, v23);
}
*((_DWORD *)v8 + 4) = (v8[2] & 0x80000000) + 1;
++*(_DWORD *)(a1 + 524);
*((_BYTE *)v8 + 19) &= ~0x80u;
if ( *(_QWORD **)a1 != v8 )
{
v25 = v7 - 16;
v26 = v8;
do
{
v27 = *(long long **)(v25 + 8);
v28 = *v27;
v29 = *(_DWORD *)(*v27 + 16);
if ( v29 < 0 )
break;
v30 = **(_QWORD ***)v25;
v31 = *v30;
if ( v28 == *v30 )
{
v31 = v30[1];
if ( *(int *)(v31 + 16) < 0 )
{
v33 = *(_QWORD **)(v28 + 8);
if ( v26 == v33 )
{
*(_QWORD *)(v28 + 8) = *v33;
*v27 = (long long)v33;
*v33 = v28;
v29 = *((_DWORD *)v26 + 4);
}
else
{
v26 = (_QWORD *)*v27;
}
*((_DWORD *)v26 + 4) = v29 | 0x80000000;
*((_BYTE *)v30 + 19) &= ~0x80u;
v36 = *(_QWORD **)v25;
v37 = *v30;
v35 = (_QWORD *)(*v30 + 8LL);
*v30 = *v35;
*v36 = v37;
goto LABEL_47;
}
}
else if ( *(int *)(v31 + 16) < 0 )
{
v32 = *(_QWORD **)v28;
if ( v26 == *(_QWORD **)v28 )
{
*(_QWORD *)v28 = v32[1];
*v27 = (long long)v32;
v32[1] = v28;
v29 = *((_DWORD *)v26 + 4);
}
else
{
v26 = (_QWORD *)*v27;
}
*((_DWORD *)v26 + 4) = v29 | 0x80000000;
*((_BYTE *)v30 + 19) &= ~0x80u;
v34 = *(_QWORD **)v25;
v35 = (_QWORD *)v30[1];
v30[1] = *v35;
*v34 = v35;
LABEL_47:
*v35 = v30;
break;
}
*(_DWORD *)(v28 + 16) = v29 | 0x80000000;
*(_BYTE *)(v31 + 19) |= 0x80u;
*((_BYTE *)v30 + 19) &= ~0x80u;
v25 -= 16LL;
v26 = v30;
}
while ( v30 != *(_QWORD **)a1 );
}
*(_DWORD *)(*(_QWORD *)a1 + 16LL) |= 0x80000000;
return (long long)v8;
}
|
tree_insert:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R13,RCX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x8]
MOV qword ptr [RBP + -0x38],RDX
LEA EAX,[RDX + 0x18]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[0x3f9468]
MOV qword ptr [RBP + -0x30],R12
LAB_0012ebf6:
MOV qword ptr [RBX + 0x8],RBX
MOV R14,qword ptr [RBX]
CMP R14,RAX
JZ 0x0012ec4d
MOV R12,qword ptr [RBP + -0x30]
LAB_0012ec06:
MOV ESI,dword ptr [RBX + 0x208]
TEST RSI,RSI
JZ 0x0012ec16
ADD RSI,R14
JMP 0x0012ec1a
LAB_0012ec16:
MOV RSI,qword ptr [R14 + 0x18]
LAB_0012ec1a:
MOV RDI,R13
MOV RDX,R15
CALL qword ptr [RBX + 0x228]
TEST EAX,EAX
JZ 0x0012ecb1
SHR EAX,0x1f
LEA RAX,[R14 + RAX*0x8]
MOV qword ptr [R12 + 0x8],RAX
ADD R12,0x8
MOV R14,qword ptr [RAX]
LEA RAX,[0x3f9468]
CMP R14,RAX
JNZ 0x0012ec06
LAB_0012ec4d:
TEST byte ptr [RBX + 0x290],0x2
JNZ 0x0012ed0f
MOV EDX,dword ptr [RBX + 0x210]
MOV RAX,qword ptr [RBP + -0x40]
LEA ESI,[RAX + RDX*0x1]
MOV RAX,qword ptr [RBX + 0x220]
ADD RAX,RSI
MOV qword ptr [RBX + 0x220],RAX
MOV RCX,qword ptr [RBX + 0x218]
TEST RCX,RCX
JZ 0x0012ece8
CMP dword ptr [RBX + 0x20c],0x0
JZ 0x0012ece8
CMP RAX,RCX
JBE 0x0012ece8
MOV EDX,0x2
MOV RDI,RBX
XOR ESI,ESI
CALL 0x0012eae3
LEA RAX,[0x3f9468]
MOV R12,qword ptr [RBP + -0x30]
JMP 0x0012ebf6
LAB_0012ecb1:
TEST byte ptr [RBX + 0x290],0x1
JNZ 0x0012ed57
MOV EAX,dword ptr [R14 + 0x10]
LEA ECX,[RAX + 0x1]
AND ECX,0x7fffffff
MOV EDX,EAX
AND EDX,0x80000000
OR EDX,ECX
MOV dword ptr [R14 + 0x10],EDX
TEST ECX,ECX
JNZ 0x0012ed5a
OR EAX,0x7fffffff
MOV dword ptr [R14 + 0x10],EAX
JMP 0x0012ed5a
LAB_0012ece8:
MOV R13,RDX
CMP byte ptr [RBX + 0x278],0x0
JZ 0x0012ed17
LEA RAX,[0x4894fc]
MOV EDI,dword ptr [RAX]
MOV RDX,qword ptr [RBX + 0x288]
OR RDX,0x10
CALL 0x0012b959
JMP 0x0012ed23
LAB_0012ed0f:
MOV R14D,0x1
JMP 0x0012ed5a
LAB_0012ed17:
LEA RDI,[RBX + 0x238]
CALL 0x00132edf
LAB_0012ed23:
MOV R14,RAX
TEST RAX,RAX
JZ 0x0012ed57
ADD R13D,dword ptr [RBP + -0x38]
MOV RAX,qword ptr [R12]
MOV qword ptr [RAX],R14
LEA RAX,[0x3f9468]
MOV qword ptr [R14 + 0x8],RAX
MOV qword ptr [R14],RAX
MOV EDI,dword ptr [RBX + 0x208]
TEST RDI,RDI
JZ 0x0012ed6c
ADD RDI,R14
MOV EDX,R13D
JMP 0x0012ed87
LAB_0012ed57:
XOR R14D,R14D
LAB_0012ed5a:
MOV RAX,R14
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012ed6c:
CMP R13D,0x8
JNZ 0x0012ed78
MOV qword ptr [R14 + 0x18],R15
JMP 0x0012ed8f
LAB_0012ed78:
MOV EDX,R13D
LEA RDI,[R14 + 0x20]
MOV qword ptr [R14 + 0x18],RDI
ADD RDX,-0x8
LAB_0012ed87:
MOV RSI,R15
CALL 0x00124210
LAB_0012ed8f:
MOV EAX,0x80000000
AND EAX,dword ptr [R14 + 0x10]
INC EAX
MOV dword ptr [R14 + 0x10],EAX
INC dword ptr [RBX + 0x20c]
AND byte ptr [R14 + 0x13],0x7f
CMP qword ptr [RBX],R14
JZ 0x0012ee98
ADD R12,-0x10
MOV RCX,R14
LAB_0012edb9:
MOV RDI,qword ptr [R12 + 0x8]
MOV RSI,qword ptr [RDI]
MOV EDX,dword ptr [RSI + 0x10]
TEST EDX,EDX
JS 0x0012ee98
MOV RAX,qword ptr [R12]
MOV RAX,qword ptr [RAX]
MOV R8,qword ptr [RAX]
CMP RSI,R8
JZ 0x0012ede4
CMP dword ptr [R8 + 0x10],0x0
JNS 0x0012edef
JMP 0x0012ee16
LAB_0012ede4:
MOV R8,qword ptr [RAX + 0x8]
CMP dword ptr [R8 + 0x10],0x0
JS 0x0012ee23
LAB_0012edef:
ADD R8,0x10
OR EDX,0x80000000
MOV dword ptr [RSI + 0x10],EDX
OR byte ptr [R8 + 0x3],0x80
AND byte ptr [RAX + 0x13],0x7f
ADD R12,-0x10
MOV RCX,RAX
CMP RAX,qword ptr [RBX]
JNZ 0x0012edb9
JMP 0x0012ee98
LAB_0012ee16:
MOV R8,qword ptr [RSI]
CMP RCX,R8
JZ 0x0012ee31
MOV RCX,RSI
JMP 0x0012ee42
LAB_0012ee23:
MOV R8,qword ptr [RSI + 0x8]
CMP RCX,R8
JZ 0x0012ee63
MOV RCX,RSI
JMP 0x0012ee73
LAB_0012ee31:
MOV RDX,qword ptr [R8 + 0x8]
MOV qword ptr [RSI],RDX
MOV qword ptr [RDI],R8
MOV qword ptr [R8 + 0x8],RSI
MOV EDX,dword ptr [RCX + 0x10]
LAB_0012ee42:
OR EDX,0x80000000
MOV dword ptr [RCX + 0x10],EDX
AND byte ptr [RAX + 0x13],0x7f
MOV RDX,qword ptr [R12]
MOV RCX,qword ptr [RAX + 0x8]
MOV RSI,qword ptr [RCX]
MOV qword ptr [RAX + 0x8],RSI
MOV qword ptr [RDX],RCX
JMP 0x0012ee95
LAB_0012ee63:
MOV RDX,qword ptr [R8]
MOV qword ptr [RSI + 0x8],RDX
MOV qword ptr [RDI],R8
MOV qword ptr [R8],RSI
MOV EDX,dword ptr [RCX + 0x10]
LAB_0012ee73:
OR EDX,0x80000000
MOV dword ptr [RCX + 0x10],EDX
AND byte ptr [RAX + 0x13],0x7f
MOV RDX,qword ptr [R12]
MOV RSI,qword ptr [RAX]
LEA RCX,[RSI + 0x8]
MOV RDI,qword ptr [RSI + 0x8]
MOV qword ptr [RAX],RDI
MOV qword ptr [RDX],RSI
LAB_0012ee95:
MOV qword ptr [RCX],RAX
LAB_0012ee98:
MOV RAX,qword ptr [RBX]
OR dword ptr [RAX + 0x10],0x80000000
JMP 0x0012ed5a
|
long * tree_insert(long *param_1,void *param_2,int param_3,int8 param_4)
{
int8 *puVar1;
long *plVar2;
long *plVar3;
uint uVar4;
ulong uVar5;
long *plVar6;
uint uVar7;
long *plVar8;
size_t __n;
int1 *puVar9;
ulong uVar10;
long *plVar11;
long lVar12;
long *plVar13;
while( true ) {
param_1[1] = (long)param_1;
plVar6 = (long *)*param_1;
plVar8 = param_1 + 1;
if (plVar6 != (long *)null_element) {
do {
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
puVar9 = (int1 *)plVar6[3];
}
else {
puVar9 = (int1 *)((ulong)*(uint *)(param_1 + 0x41) + (long)plVar6);
}
uVar4 = (*(code *)param_1[0x45])(param_4,puVar9,param_2);
if (uVar4 == 0) {
if ((*(byte *)(param_1 + 0x52) & 1) != 0) {
return (long *)0x0;
}
uVar4 = *(uint *)(plVar6 + 2);
uVar7 = uVar4 + 1 & 0x7fffffff;
*(uint *)(plVar6 + 2) = uVar4 & 0x80000000 | uVar7;
if (uVar7 == 0) {
*(uint *)(plVar6 + 2) = uVar4 | 0x7fffffff;
return plVar6;
}
return plVar6;
}
plVar8[1] = (long)(plVar6 + (uVar4 >> 0x1f));
plVar8 = plVar8 + 1;
plVar6 = (long *)plVar6[uVar4 >> 0x1f];
} while (plVar6 != (long *)null_element);
}
if ((*(byte *)(param_1 + 0x52) & 2) != 0) {
return (long *)0x1;
}
lVar12 = param_1[0x42];
uVar10 = (ulong)(uint)(param_3 + 0x18 + (int)lVar12);
uVar5 = param_1[0x44] + uVar10;
param_1[0x44] = uVar5;
if (((param_1[0x43] == 0) || (*(int *)((long)param_1 + 0x20c) == 0)) ||
(uVar5 <= (ulong)param_1[0x43])) break;
free_tree(param_1,0,2);
}
if ((char)param_1[0x4f] == '\0') {
plVar6 = (long *)alloc_root(param_1 + 0x47);
}
else {
plVar6 = (long *)my_malloc(key_memory_TREE,uVar10,param_1[0x51] | 0x10);
}
if (plVar6 == (long *)0x0) {
return (long *)0x0;
}
uVar4 = (int)lVar12 + param_3;
*(long **)*plVar8 = plVar6;
plVar6[1] = (long)null_element;
*plVar6 = (long)null_element;
if ((ulong)*(uint *)(param_1 + 0x41) == 0) {
if (uVar4 == 8) {
plVar6[3] = (long)param_2;
goto LAB_0012ed8f;
}
plVar11 = plVar6 + 4;
plVar6[3] = (long)plVar11;
__n = (ulong)uVar4 - 8;
}
else {
plVar11 = (long *)((ulong)*(uint *)(param_1 + 0x41) + (long)plVar6);
__n = (size_t)uVar4;
}
memcpy(plVar11,param_2,__n);
LAB_0012ed8f:
*(uint *)(plVar6 + 2) = (*(uint *)(plVar6 + 2) & 0x80000000) + 1;
*(int *)((long)param_1 + 0x20c) = *(int *)((long)param_1 + 0x20c) + 1;
*(byte *)((long)plVar6 + 0x13) = *(byte *)((long)plVar6 + 0x13) & 0x7f;
plVar11 = plVar6;
if ((long *)*param_1 != plVar6) {
do {
plVar13 = plVar8 + -2;
puVar1 = (int8 *)plVar8[-1];
plVar8 = (long *)*puVar1;
uVar4 = *(uint *)(plVar8 + 2);
if ((int)uVar4 < 0) break;
plVar2 = *(long **)*plVar13;
lVar12 = *plVar2;
if (plVar8 == (long *)lVar12) {
lVar12 = plVar2[1];
if (*(int *)(lVar12 + 0x10) < 0) {
plVar3 = (long *)plVar8[1];
if (plVar11 == plVar3) {
plVar8[1] = *plVar3;
*puVar1 = plVar3;
*plVar3 = (long)plVar8;
uVar4 = *(uint *)(plVar11 + 2);
plVar8 = plVar11;
}
*(uint *)(plVar8 + 2) = uVar4 | 0x80000000;
*(byte *)((long)plVar2 + 0x13) = *(byte *)((long)plVar2 + 0x13) & 0x7f;
plVar13 = (long *)*plVar13;
lVar12 = *plVar2;
plVar8 = (long *)(lVar12 + 8);
*plVar2 = *(long *)(lVar12 + 8);
*plVar13 = lVar12;
goto LAB_0012ee95;
}
}
else if (*(int *)(lVar12 + 0x10) < 0) {
plVar3 = (long *)*plVar8;
if (plVar11 == plVar3) {
*plVar8 = plVar3[1];
*puVar1 = plVar3;
plVar3[1] = (long)plVar8;
uVar4 = *(uint *)(plVar11 + 2);
plVar8 = plVar11;
}
*(uint *)(plVar8 + 2) = uVar4 | 0x80000000;
*(byte *)((long)plVar2 + 0x13) = *(byte *)((long)plVar2 + 0x13) & 0x7f;
plVar13 = (long *)*plVar13;
plVar8 = (long *)plVar2[1];
plVar2[1] = *plVar8;
*plVar13 = (long)plVar8;
LAB_0012ee95:
*plVar8 = (long)plVar2;
break;
}
*(uint *)(plVar8 + 2) = uVar4 | 0x80000000;
*(byte *)(lVar12 + 0x13) = *(byte *)(lVar12 + 0x13) | 0x80;
*(byte *)((long)plVar2 + 0x13) = *(byte *)((long)plVar2 + 0x13) & 0x7f;
plVar11 = plVar2;
plVar8 = plVar13;
} while (plVar2 != (long *)*param_1);
}
*(uint *)(*param_1 + 0x10) = *(uint *)(*param_1 + 0x10) | 0x80000000;
return plVar6;
}
|
|
7,797 |
lf_dynarray_value
|
eloqsql/mysys/lf_dynarray.c
|
void *lf_dynarray_value(LF_DYNARRAY *array, uint idx)
{
void * ptr, * volatile * ptr_ptr= 0;
int i;
for (i= LF_DYNARRAY_LEVELS-1; idx < dynarray_idxes_in_prev_levels[i]; i--)
/* no-op */;
ptr_ptr= &array->level[i];
idx-= dynarray_idxes_in_prev_levels[i];
for (; i > 0; i--)
{
if (!(ptr= *ptr_ptr))
return(NULL);
ptr_ptr= ((void **)ptr) + idx / dynarray_idxes_in_prev_level[i];
idx %= dynarray_idxes_in_prev_level[i];
}
if (!(ptr= *ptr_ptr))
return(NULL);
return ((uchar*)ptr) + array->size_of_element * idx;
}
|
O0
|
c
|
lf_dynarray_value:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x3, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movslq -0x2c(%rbp), %rdx
leaq 0x5ca48(%rip), %rcx # 0x15a9f0
cmpq (%rcx,%rdx,8), %rax
jae 0xfdfbb
jmp 0xfdfb0
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfdf9a
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x5ca17(%rip), %rax # 0x15a9f0
movq (%rax,%rcx,8), %rcx
movl -0x14(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0xfe05f
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xfe00a
movq $0x0, -0x8(%rbp)
jmp 0xfe092
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movslq -0x2c(%rbp), %rsi
leaq 0x5c9f0(%rip), %rcx # 0x15aa10
xorl %edx, %edx
divq (%rcx,%rsi,8)
movq %rax, %rcx
movq -0x38(%rbp), %rax
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x5c9cd(%rip), %rax # 0x15aa10
movq (%rax,%rcx,8), %rcx
movl -0x14(%rbp), %eax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xfdfe6
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xfe07a
movq $0x0, -0x8(%rbp)
jmp 0xfe092
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
imull -0x14(%rbp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
|
lf_dynarray_value:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_28], 0
mov [rbp+var_2C], 3
loc_FDF9A:
mov eax, [rbp+var_14]
movsxd rdx, [rbp+var_2C]
lea rcx, dynarray_idxes_in_prev_levels
cmp rax, [rcx+rdx*8]
jnb short loc_FDFBB
jmp short $+2
loc_FDFB0:
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_FDF9A
loc_FDFBB:
mov rax, [rbp+var_10]
movsxd rcx, [rbp+var_2C]
shl rcx, 3
add rax, rcx
mov [rbp+var_28], rax
movsxd rcx, [rbp+var_2C]
lea rax, dynarray_idxes_in_prev_levels
mov rcx, [rax+rcx*8]
mov eax, [rbp+var_14]
sub rax, rcx
mov [rbp+var_14], eax
loc_FDFE6:
cmp [rbp+var_2C], 0
jle short loc_FE05F
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_FE00A
mov [rbp+var_8], 0
jmp loc_FE092
loc_FE00A:
mov rax, [rbp+var_20]
mov [rbp+var_38], rax
mov eax, [rbp+var_14]
movsxd rsi, [rbp+var_2C]
lea rcx, dynarray_idxes_in_prev_level
xor edx, edx
div qword ptr [rcx+rsi*8]
mov rcx, rax
mov rax, [rbp+var_38]
shl rcx, 3
add rax, rcx
mov [rbp+var_28], rax
movsxd rcx, [rbp+var_2C]
lea rax, dynarray_idxes_in_prev_level
mov rcx, [rax+rcx*8]
mov eax, [rbp+var_14]
xor edx, edx
div rcx
mov eax, edx
mov [rbp+var_14], eax
mov eax, [rbp+var_2C]
add eax, 0FFFFFFFFh
mov [rbp+var_2C], eax
jmp short loc_FDFE6
loc_FE05F:
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_20], rax
cmp rax, 0
jnz short loc_FE07A
mov [rbp+var_8], 0
jmp short loc_FE092
loc_FE07A:
mov rax, [rbp+var_20]
mov rcx, [rbp+var_10]
mov ecx, [rcx+20h]
imul ecx, [rbp+var_14]
mov ecx, ecx
add rax, rcx
mov [rbp+var_8], rax
loc_FE092:
mov rax, [rbp+var_8]
pop rbp
retn
|
long long lf_dynarray_value(long long a1, unsigned int a2)
{
int i; // [rsp+Ch] [rbp-2Ch]
_QWORD *v4; // [rsp+10h] [rbp-28h]
unsigned int v5; // [rsp+24h] [rbp-14h]
for ( i = 3; (unsigned long long)a2 < dynarray_idxes_in_prev_levels[i]; --i )
;
v4 = (_QWORD *)(8LL * i + a1);
v5 = a2 - dynarray_idxes_in_prev_levels[i];
while ( i > 0 )
{
if ( !*v4 )
return 0LL;
v4 = (_QWORD *)(8 * ((unsigned long long)v5 / dynarray_idxes_in_prev_level[i]) + *v4);
v5 = (unsigned long long)v5 % dynarray_idxes_in_prev_level[i--];
}
if ( *v4 )
return v5 * *(_DWORD *)(a1 + 32) + *v4;
else
return 0LL;
}
|
lf_dynarray_value:
PUSH RBP
MOV RBP,RSP
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x28],0x0
MOV dword ptr [RBP + -0x2c],0x3
LAB_001fdf9a:
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RDX,dword ptr [RBP + -0x2c]
LEA RCX,[0x25a9f0]
CMP RAX,qword ptr [RCX + RDX*0x8]
JNC 0x001fdfbb
JMP 0x001fdfb0
LAB_001fdfb0:
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001fdf9a
LAB_001fdfbb:
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,dword ptr [RBP + -0x2c]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RCX,dword ptr [RBP + -0x2c]
LEA RAX,[0x25a9f0]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x14]
SUB RAX,RCX
MOV dword ptr [RBP + -0x14],EAX
LAB_001fdfe6:
CMP dword ptr [RBP + -0x2c],0x0
JLE 0x001fe05f
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001fe00a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fe092
LAB_001fe00a:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOVSXD RSI,dword ptr [RBP + -0x2c]
LEA RCX,[0x25aa10]
XOR EDX,EDX
DIV qword ptr [RCX + RSI*0x8]
MOV RCX,RAX
MOV RAX,qword ptr [RBP + -0x38]
SHL RCX,0x3
ADD RAX,RCX
MOV qword ptr [RBP + -0x28],RAX
MOVSXD RCX,dword ptr [RBP + -0x2c]
LEA RAX,[0x25aa10]
MOV RCX,qword ptr [RAX + RCX*0x8]
MOV EAX,dword ptr [RBP + -0x14]
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RBP + -0x14],EAX
MOV EAX,dword ptr [RBP + -0x2c]
ADD EAX,-0x1
MOV dword ptr [RBP + -0x2c],EAX
JMP 0x001fdfe6
LAB_001fe05f:
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
CMP RAX,0x0
JNZ 0x001fe07a
MOV qword ptr [RBP + -0x8],0x0
JMP 0x001fe092
LAB_001fe07a:
MOV RAX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x10]
MOV ECX,dword ptr [RCX + 0x20]
IMUL ECX,dword ptr [RBP + -0x14]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x8],RAX
LAB_001fe092:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
long lf_dynarray_value(long param_1,uint param_2)
{
int local_34;
long *local_30;
uint local_1c;
long local_10;
local_34 = 3;
while ((ulong)param_2 < *(ulong *)(dynarray_idxes_in_prev_levels + (long)local_34 * 8)) {
local_34 = local_34 + -1;
}
local_30 = (long *)(param_1 + (long)local_34 * 8);
local_1c = param_2 - (int)*(int8 *)(dynarray_idxes_in_prev_levels + (long)local_34 * 8);
while( true ) {
if (local_34 < 1) {
if (*local_30 == 0) {
local_10 = 0;
}
else {
local_10 = *local_30 + (ulong)(*(int *)(param_1 + 0x20) * local_1c);
}
return local_10;
}
if (*local_30 == 0) break;
local_30 = (long *)(*local_30 +
((ulong)local_1c /
*(ulong *)(dynarray_idxes_in_prev_level + (long)local_34 * 8)) * 8);
local_1c = (uint)((ulong)local_1c %
*(ulong *)(dynarray_idxes_in_prev_level + (long)local_34 * 8));
local_34 = local_34 + -1;
}
return 0;
}
|
|
7,798 |
js_typed_array_get_byteLength
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_get_byteLength(JSContext *ctx, JSValue this_val)
{
uint32_t size_log2;
JSTypedArray *ta;
JSObject *p;
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return js_int32(0);
ta = p->u.typed_array;
if (!ta->track_rab)
return js_uint32(ta->length);
size_log2 = typed_array_size_log2(p->class_id);
return js_int64((int64_t)p->u.array.count << size_log2);
}
|
O0
|
c
|
js_typed_array_get_byteLength:
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x58940
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xdf09a
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0xdf12e
movq 0x8(%rsp), %rdi
callq 0x589d0
cmpl $0x0, %eax
je 0xdf0bc
xorl %edi, %edi
callq 0x33cc0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0xdf12e
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0xdf0ee
movq 0x10(%rsp), %rax
movl 0x24(%rax), %edi
callq 0x33b60
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0xdf12e
movq 0x8(%rsp), %rax
movzwl 0x6(%rax), %eax
subl $0x15, %eax
movslq %eax, %rcx
leaq 0x2d8fb(%rip), %rax # 0x10c9ff
movzbl (%rax,%rcx), %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, %edi
movl 0x1c(%rsp), %eax
movl %eax, %ecx
shlq %cl, %rdi
callq 0x37480
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax)
|
js_typed_array_get_byteLength:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_20]
mov rdx, [rsp+48h+var_18]
call get_typed_array
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jnz short loc_DF09A
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp loc_DF12E
loc_DF09A:
mov rdi, [rsp+48h+var_40]
call typed_array_is_oob
cmp eax, 0
jz short loc_DF0BC
xor edi, edi
call js_int32
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
jmp short loc_DF12E
loc_DF0BC:
mov rax, [rsp+48h+var_40]
mov rax, [rax+30h]
mov [rsp+48h+var_38], rax
mov rax, [rsp+48h+var_38]
cmp dword ptr [rax+28h], 0
jnz short loc_DF0EE
mov rax, [rsp+48h+var_38]
mov edi, [rax+24h]
call js_uint32
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
jmp short loc_DF12E
loc_DF0EE:
mov rax, [rsp+48h+var_40]
movzx eax, word ptr [rax+6]
sub eax, 15h
movsxd rcx, eax
lea rax, typed_array_size_log2
movzx eax, byte ptr [rax+rcx]
mov [rsp+48h+var_2C], eax
mov rax, [rsp+48h+var_40]
mov eax, [rax+40h]
mov edi, eax
mov eax, [rsp+48h+var_2C]
mov ecx, eax
shl rdi, cl
call js_int64
mov [rsp+48h+var_10], rax
mov [rsp+48h+var_8], rdx
loc_DF12E:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
|
long long js_typed_array_get_byteLength(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long typed_array; // [rsp+8h] [rbp-40h]
long long v16; // [rsp+10h] [rbp-38h]
long long v17; // [rsp+38h] [rbp-10h]
typed_array = get_typed_array(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
if ( typed_array )
{
if ( typed_array_is_oob(typed_array) )
{
return js_int32(0);
}
else
{
v16 = *(_QWORD *)(typed_array + 48);
if ( *(_DWORD *)(v16 + 40) )
return js_int64((unsigned long long)*(unsigned int *)(typed_array + 64) << typed_array_size_log2[*(unsigned __int16 *)(typed_array + 6) - 21]);
else
return js_uint32(*(_DWORD *)(v16 + 36));
}
}
else
{
LODWORD(v17) = 0;
}
return v17;
}
|
js_typed_array_get_byteLength:
SUB RSP,0x48
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x28]
MOV RDX,qword ptr [RSP + 0x30]
CALL 0x00158940
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x001df09a
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x001df12e
LAB_001df09a:
MOV RDI,qword ptr [RSP + 0x8]
CALL 0x001589d0
CMP EAX,0x0
JZ 0x001df0bc
XOR EDI,EDI
CALL 0x00133cc0
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
JMP 0x001df12e
LAB_001df0bc:
MOV RAX,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RAX + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX + 0x28],0x0
JNZ 0x001df0ee
MOV RAX,qword ptr [RSP + 0x10]
MOV EDI,dword ptr [RAX + 0x24]
CALL 0x00133b60
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
JMP 0x001df12e
LAB_001df0ee:
MOV RAX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RAX + 0x6]
SUB EAX,0x15
MOVSXD RCX,EAX
LEA RAX,[0x20c9ff]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV dword ptr [RSP + 0x1c],EAX
MOV RAX,qword ptr [RSP + 0x8]
MOV EAX,dword ptr [RAX + 0x40]
MOV EDI,EAX
MOV EAX,dword ptr [RSP + 0x1c]
MOV ECX,EAX
SHL RDI,CL
CALL 0x00137480
MOV qword ptr [RSP + 0x38],RAX
MOV qword ptr [RSP + 0x40],RDX
LAB_001df12e:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16]
js_typed_array_get_byteLength(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
long lVar2;
int1 auVar3 [16];
int4 local_10;
int4 uStack_c;
int8 local_8;
lVar2 = get_typed_array(param_1,param_2,param_3);
if (lVar2 == 0) {
local_10 = 0;
local_8 = 6;
}
else {
iVar1 = typed_array_is_oob(lVar2);
if (iVar1 == 0) {
if (*(int *)(*(long *)(lVar2 + 0x30) + 0x28) == 0) {
auVar3 = js_uint32(*(int4 *)(*(long *)(lVar2 + 0x30) + 0x24));
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
else {
auVar3 = js_int64((ulong)*(uint *)(lVar2 + 0x40) <<
((&typed_array_size_log2)[(int)(*(ushort *)(lVar2 + 6) - 0x15)] & 0x3f));
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
}
else {
auVar3 = js_int32(0);
local_8 = auVar3._8_8_;
local_10 = auVar3._0_4_;
uStack_c = auVar3._4_4_;
}
}
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
|
|
7,799 |
js_typed_array_get_byteLength
|
bluesky950520[P]quickjs/quickjs.c
|
static JSValue js_typed_array_get_byteLength(JSContext *ctx, JSValue this_val)
{
uint32_t size_log2;
JSTypedArray *ta;
JSObject *p;
p = get_typed_array(ctx, this_val);
if (!p)
return JS_EXCEPTION;
if (typed_array_is_oob(p))
return js_int32(0);
ta = p->u.typed_array;
if (!ta->track_rab)
return js_uint32(ta->length);
size_log2 = typed_array_size_log2(p->class_id);
return js_int64((int64_t)p->u.array.count << size_log2);
}
|
O1
|
c
|
js_typed_array_get_byteLength:
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
cmpl $-0x1, %edx
jne 0x8089b
movq 0x8(%rsp), %rbx
movzwl 0x6(%rbx), %eax
addl $-0x15, %eax
cmpw $0xc, %ax
jb 0x808ab
leaq 0x21b6f(%rip), %rsi # 0xa2411
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x22567
testq %rbx, %rbx
je 0x808c7
movq %rbx, %rdi
callq 0x396c4
testl %eax, %eax
je 0x808d2
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
jmp 0x8094d
movl $0x6, %edx
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x8094d
movq 0x30(%rbx), %rax
cmpl $0x0, 0x28(%rax)
je 0x8091e
movzwl 0x6(%rbx), %eax
leaq 0x1cff8(%rip), %rcx # 0x9d8df
movb -0x15(%rax,%rcx), %cl
movl 0x40(%rbx), %eax
shlq %cl, %rax
movslq %eax, %rcx
xorl %esi, %esi
cmpq %rax, %rcx
movl %ecx, %ecx
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
cmoveq %rcx, %rax
movl $0x7, %edx
cmoveq %rsi, %rdx
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
jmp 0x8094a
movslq 0x24(%rax), %rcx
xorl %esi, %esi
testq %rcx, %rcx
movl %ecx, %eax
cvtsi2sd %rax, %xmm0
movq %xmm0, %rax
cmovnsq %rcx, %rax
movl $0x7, %edx
cmovnsq %rsi, %rdx
movabsq $0x7fffffff00000000, %rcx # imm = 0x7FFFFFFF00000000
andq %rax, %rcx
movl %eax, %eax
orq %rcx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
js_typed_array_get_byteLength:
push rbx
sub rsp, 10h
mov [rsp+18h+var_10], rsi
cmp edx, 0FFFFFFFFh
jnz short loc_8089B
mov rbx, [rsp+18h+var_10]
movzx eax, word ptr [rbx+6]
add eax, 0FFFFFFEBh
cmp ax, 0Ch
jb short loc_808AB
loc_8089B:
lea rsi, aNotATypedarray; "not a TypedArray"
xor ebx, ebx
xor eax, eax
call JS_ThrowTypeError
loc_808AB:
test rbx, rbx
jz short loc_808C7
mov rdi, rbx
call typed_array_is_oob
test eax, eax
jz short loc_808D2
xor eax, eax
xor ecx, ecx
xor edx, edx
jmp loc_8094D
loc_808C7:
mov edx, 6
xor eax, eax
xor ecx, ecx
jmp short loc_8094D
loc_808D2:
mov rax, [rbx+30h]
cmp dword ptr [rax+28h], 0
jz short loc_8091E
movzx eax, word ptr [rbx+6]
lea rcx, typed_array_size_log2
mov cl, [rax+rcx-15h]
mov eax, [rbx+40h]
shl rax, cl
movsxd rcx, eax
xor esi, esi
cmp rcx, rax
mov ecx, ecx
cvtsi2sd xmm0, rax
movq rax, xmm0
cmovz rax, rcx
mov edx, 7
cmovz rdx, rsi
mov rcx, 0FFFFFFFF00000000h
jmp short loc_8094A
loc_8091E:
movsxd rcx, dword ptr [rax+24h]
xor esi, esi
test rcx, rcx
mov eax, ecx
cvtsi2sd xmm0, rax
movq rax, xmm0
cmovns rax, rcx
mov edx, 7
cmovns rdx, rsi
mov rcx, 7FFFFFFF00000000h
loc_8094A:
and rcx, rax
loc_8094D:
mov eax, eax
or rax, rcx
add rsp, 10h
pop rbx
retn
|
unsigned long long js_typed_array_get_byteLength(
long long a1,
long long a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
long long v14; // rbx
double v15; // rax
unsigned long long v16; // rcx
long long v17; // rax
unsigned long long v18; // rax
bool v19; // zf
double v20; // rcx
unsigned long long v21; // rcx
long long v22; // rcx
char v24; // [rsp+0h] [rbp-18h]
if ( (_DWORD)a3 != -1 || (v14 = a2, (unsigned __int16)(*(_WORD *)(a2 + 6) - 21) >= 0xCu) )
{
v14 = 0LL;
JS_ThrowTypeError(a1, (long long)"not a TypedArray", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v24);
}
if ( v14 )
{
if ( typed_array_is_oob(v14) )
{
LODWORD(v15) = 0;
v16 = 0LL;
}
else
{
v17 = *(_QWORD *)(v14 + 48);
if ( *(_DWORD *)(v17 + 40) )
{
v18 = (unsigned long long)*(unsigned int *)(v14 + 64) << typed_array_size_log2[*(unsigned __int16 *)(v14 + 6) - 21];
v19 = (int)v18 == v18;
*(_QWORD *)&v20 = (unsigned int)v18;
v15 = (double)(int)v18;
if ( v19 )
v15 = v20;
v21 = 0xFFFFFFFF00000000LL;
}
else
{
v22 = *(int *)(v17 + 36);
v15 = (double)*(int *)(v17 + 36);
if ( v22 >= 0 )
v15 = *(double *)&v22;
v21 = 0x7FFFFFFF00000000LL;
}
v16 = *(_QWORD *)&v15 & v21;
}
}
else
{
LODWORD(v15) = 0;
v16 = 0LL;
}
return v16 | LODWORD(v15);
}
|
js_typed_array_get_byteLength:
PUSH RBX
SUB RSP,0x10
MOV qword ptr [RSP + 0x8],RSI
CMP EDX,-0x1
JNZ 0x0018089b
MOV RBX,qword ptr [RSP + 0x8]
MOVZX EAX,word ptr [RBX + 0x6]
ADD EAX,-0x15
CMP AX,0xc
JC 0x001808ab
LAB_0018089b:
LEA RSI,[0x1a2411]
XOR EBX,EBX
XOR EAX,EAX
CALL 0x00122567
LAB_001808ab:
TEST RBX,RBX
JZ 0x001808c7
MOV RDI,RBX
CALL 0x001396c4
TEST EAX,EAX
JZ 0x001808d2
XOR EAX,EAX
XOR ECX,ECX
XOR EDX,EDX
JMP 0x0018094d
LAB_001808c7:
MOV EDX,0x6
XOR EAX,EAX
XOR ECX,ECX
JMP 0x0018094d
LAB_001808d2:
MOV RAX,qword ptr [RBX + 0x30]
CMP dword ptr [RAX + 0x28],0x0
JZ 0x0018091e
MOVZX EAX,word ptr [RBX + 0x6]
LEA RCX,[0x19d8df]
MOV CL,byte ptr [RAX + RCX*0x1 + -0x15]
MOV EAX,dword ptr [RBX + 0x40]
SHL RAX,CL
MOVSXD RCX,EAX
XOR ESI,ESI
CMP RCX,RAX
MOV ECX,ECX
CVTSI2SD XMM0,RAX
MOVQ RAX,XMM0
CMOVZ RAX,RCX
MOV EDX,0x7
CMOVZ RDX,RSI
MOV RCX,-0x100000000
JMP 0x0018094a
LAB_0018091e:
MOVSXD RCX,dword ptr [RAX + 0x24]
XOR ESI,ESI
TEST RCX,RCX
MOV EAX,ECX
CVTSI2SD XMM0,RAX
MOVQ RAX,XMM0
CMOVNS RAX,RCX
MOV EDX,0x7
CMOVNS RDX,RSI
MOV RCX,0x7fffffff00000000
LAB_0018094a:
AND RCX,RAX
LAB_0018094d:
MOV EAX,EAX
OR RAX,RCX
ADD RSP,0x10
POP RBX
RET
|
int1 [16] js_typed_array_get_byteLength(int8 param_1,long param_2,int param_3)
{
uint uVar1;
int iVar2;
double dVar3;
ulong uVar4;
double dVar5;
int8 uVar6;
bool bVar7;
int1 auVar8 [16];
if ((param_3 != -1) || (0xb < (ushort)(*(short *)(param_2 + 6) - 0x15U))) {
param_2 = 0;
JS_ThrowTypeError(param_1,"not a TypedArray");
}
if (param_2 == 0) {
uVar6 = 6;
dVar3 = 0.0;
uVar4 = 0;
}
else {
iVar2 = typed_array_is_oob(param_2);
if (iVar2 == 0) {
if (*(int *)(*(long *)(param_2 + 0x30) + 0x28) == 0) {
uVar1 = *(uint *)(*(long *)(param_2 + 0x30) + 0x24);
dVar5 = (double)(long)(int)uVar1;
dVar3 = (double)uVar1;
if (-1 < (long)dVar5) {
dVar3 = dVar5;
}
uVar6 = 7;
if (-1 < (long)dVar5) {
uVar6 = 0;
}
uVar4 = 0x7fffffff00000000;
}
else {
uVar4 = (ulong)*(uint *)(param_2 + 0x40) <<
("toSorted"[(ulong)*(ushort *)(param_2 + 6) + 6] & 0x3fU);
bVar7 = (long)(int)uVar4 == uVar4;
dVar3 = (double)(long)uVar4;
if (bVar7) {
dVar3 = (double)(uVar4 & 0xffffffff);
}
uVar6 = 7;
if (bVar7) {
uVar6 = 0;
}
uVar4 = 0xffffffff00000000;
}
uVar4 = uVar4 & (ulong)dVar3;
}
else {
dVar3 = 0.0;
uVar4 = 0;
uVar6 = 0;
}
}
auVar8._0_8_ = (ulong)dVar3 & 0xffffffff | uVar4;
auVar8._8_8_ = uVar6;
return auVar8;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.