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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
43,400 | ma_check_print_warning | eloqsql/storage/maria/ma_check_standalone.h | void _ma_check_print_warning(HA_CHECK *param, const char *fmt,...)
{
va_list args;
DBUG_ENTER("_ma_check_print_warning");
DBUG_PRINT("enter", ("format: %s", fmt));
fflush(stdout);
if (!param->warning_printed && !param->error_printed)
{
if (param->testflag & T_SILENT)
fprintf(stderr,"%s: Aria file %s\n",my_progname_short,
param->isam_file_name);
param->out_flag|= O_DATA_LOST;
}
param->warning_printed++;
va_start(args,fmt);
fprintf(stderr,"%s: warning: ",my_progname_short);
vfprintf(stderr, fmt, args);
fputc('\n',stderr);
fflush(stderr);
va_end(args);
DBUG_VOID_RETURN;
} | O0 | c | ma_check_print_warning:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x28758
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)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x2877e
movq 0x25e84b(%rip), %rax # 0x286fd0
movq (%rax), %rdi
callq 0x27460
movq -0x8(%rbp), %rax
cmpb $0x0, 0x209a2(%rax)
jne 0x287fa
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2096c(%rax)
jne 0x287fa
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
andq $0x400000, %rax # imm = 0x400000
cmpq $0x0, %rax
je 0x287e7
movq 0x25e813(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xc22ef9(%rip), %rax # 0xc4b6c8
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0xf486e(%rip), %rsi # 0x11d04e
movb $0x0, %al
callq 0x271d0
movq -0x8(%rbp), %rax
movl 0x20968(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x20968(%rax)
movq -0x8(%rbp), %rax
movb 0x209a2(%rax), %cl
addb $0x1, %cl
movb %cl, 0x209a2(%rax)
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)
movq 0x25e7a0(%rip), %rax # 0x286fd8
movq (%rax), %rdi
leaq 0xc22e86(%rip), %rax # 0xc4b6c8
movq (%rax), %rdx
leaq 0xf4814(%rip), %rsi # 0x11d060
movb $0x0, %al
callq 0x271d0
movq 0x25e77e(%rip), %rax # 0x286fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x279d0
movq 0x25e767(%rip), %rax # 0x286fd8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x27790
movq 0x25e753(%rip), %rax # 0x286fd8
movq (%rax), %rdi
callq 0x27460
leaq -0x30(%rbp), %rax
jmp 0x28893
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
| _ma_check_print_warning:
push rbp
mov rbp, rsp
sub rsp, 0E0h
test al, al
jz short loc_28758
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_28758:
mov [rbp+var_B8], r9
mov [rbp+var_C0], r8
mov [rbp+var_C8], rcx
mov [rbp+var_D0], rdx
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
jmp short $+2
loc_2877E:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, [rbp+var_8]
cmp byte ptr [rax+209A2h], 0
jnz short loc_287FA
mov rax, [rbp+var_8]
cmp dword ptr [rax+2096Ch], 0
jnz short loc_287FA
mov rax, [rbp+var_8]
mov rax, [rax+0B10h]
and rax, 400000h
cmp rax, 0
jz short loc_287E7
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rax, my_progname_short
mov rdx, [rax]
mov rax, [rbp+var_8]
mov rcx, [rax]
lea rsi, aSAriaFileS; "%s: Aria file %s\n"
mov al, 0
call _fprintf
loc_287E7:
mov rax, [rbp+var_8]
mov ecx, dword ptr ds:stru_20968.r_offset[rax]
or ecx, 4
mov dword ptr ds:stru_20968.r_offset[rax], ecx
loc_287FA:
mov rax, [rbp+var_8]
mov cl, [rax+209A2h]
add cl, 1
mov [rax+209A2h], cl
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
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rax, my_progname_short
mov rdx, [rax]
lea rsi, aSWarning; "%s: warning: "
mov al, 0
call _fprintf
mov rax, cs:stderr_ptr
mov rdi, [rax]
mov rsi, [rbp+var_10]
lea rdx, [rbp+var_30]
call _vfprintf
mov rax, cs:stderr_ptr
mov rsi, [rax]
mov edi, 0Ah
call _fputc
mov rax, cs:stderr_ptr
mov rdi, [rax]
call _fflush
lea rax, [rbp+var_30]
jmp short $+2
loc_28893:
add rsp, 0E0h
pop rbp
retn
| _DWORD * ma_check_print_warning(
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)
{
char v16; // [rsp+0h] [rbp-E0h] BYREF
long long v17; // [rsp+10h] [rbp-D0h]
long long v18; // [rsp+18h] [rbp-C8h]
long long v19; // [rsp+20h] [rbp-C0h]
long long v20; // [rsp+28h] [rbp-B8h]
__m128 v21; // [rsp+30h] [rbp-B0h]
__m128 v22; // [rsp+40h] [rbp-A0h]
__m128 v23; // [rsp+50h] [rbp-90h]
__m128 v24; // [rsp+60h] [rbp-80h]
__m128 v25; // [rsp+70h] [rbp-70h]
__m128 v26; // [rsp+80h] [rbp-60h]
__m128 v27; // [rsp+90h] [rbp-50h]
__m128 v28; // [rsp+A0h] [rbp-40h]
_DWORD v29[2]; // [rsp+B0h] [rbp-30h] BYREF
char *v30; // [rsp+B8h] [rbp-28h]
char *v31; // [rsp+C0h] [rbp-20h]
long long v32; // [rsp+D0h] [rbp-10h]
long long v33; // [rsp+D8h] [rbp-8h]
v21 = a7;
v22 = a8;
v23 = a9;
v24 = a10;
v25 = a11;
v26 = a12;
v27 = a13;
v28 = a14;
v20 = a6;
v19 = a5;
v18 = a4;
v17 = a3;
v33 = a1;
v32 = a2;
fflush(stdout);
if ( !*(_BYTE *)(a1 + 133538) && !*(_DWORD *)(v33 + 133484) )
{
if ( (*(_QWORD *)(v33 + 2832) & 0x400000LL) != 0 )
fprintf(stderr, "%s: Aria file %s\n", my_progname_short, *(const char **)v33);
*(_DWORD *)((char *)&stru_20968.r_offset + v33) |= 4u;
}
++*(_BYTE *)(v33 + 133538);
v31 = &v16;
v30 = &a15;
v29[1] = 48;
v29[0] = 16;
fprintf(stderr, "%s: warning: ", my_progname_short);
vfprintf(stderr, v32, v29);
fputc(10LL, stderr);
fflush(stderr);
return v29;
}
| _ma_check_print_warning:
PUSH RBP
MOV RBP,RSP
SUB RSP,0xe0
TEST AL,AL
JZ 0x00128758
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_00128758:
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 qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
JMP 0x0012877e
LAB_0012877e:
MOV RAX,qword ptr [0x00386fd0]
MOV RDI,qword ptr [RAX]
CALL 0x00127460
MOV RAX,qword ptr [RBP + -0x8]
CMP byte ptr [RAX + 0x209a2],0x0
JNZ 0x001287fa
MOV RAX,qword ptr [RBP + -0x8]
CMP dword ptr [RAX + 0x2096c],0x0
JNZ 0x001287fa
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xb10]
AND RAX,0x400000
CMP RAX,0x0
JZ 0x001287e7
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RAX,[0xd4b6c8]
MOV RDX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x8]
MOV RCX,qword ptr [RAX]
LEA RSI,[0x21d04e]
MOV AL,0x0
CALL 0x001271d0
LAB_001287e7:
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RAX + 0x20968]
OR ECX,0x4
MOV dword ptr [RAX + 0x20968],ECX
LAB_001287fa:
MOV RAX,qword ptr [RBP + -0x8]
MOV CL,byte ptr [RAX + 0x209a2]
ADD CL,0x1
MOV byte ptr [RAX + 0x209a2],CL
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
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
LEA RAX,[0xd4b6c8]
MOV RDX,qword ptr [RAX]
LEA RSI,[0x21d060]
MOV AL,0x0
CALL 0x001271d0
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x10]
LEA RDX,[RBP + -0x30]
CALL 0x001279d0
MOV RAX,qword ptr [0x00386fd8]
MOV RSI,qword ptr [RAX]
MOV EDI,0xa
CALL 0x00127790
MOV RAX,qword ptr [0x00386fd8]
MOV RDI,qword ptr [RAX]
CALL 0x00127460
LEA RAX,[RBP + -0x30]
JMP 0x00128893
LAB_00128893:
ADD RSP,0xe0
POP RBP
RET
|
int4 *
_ma_check_print_warning
(int8 param_1,int8 param_2,int8 param_3,int8 param_4,
int8 param_5,int8 param_6,int8 param_7,int8 param_8,
int8 *param_9,char *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;
char *local_18;
int8 *local_10;
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_d8 = param_11;
local_d0 = param_12;
local_c8 = param_13;
local_c0 = param_14;
local_18 = param_10;
local_10 = param_9;
fflush(*(FILE **)PTR_stdout_00386fd0);
if ((*(char *)((long)local_10 + 0x209a2) == '\0') && (*(int *)((long)local_10 + 0x2096c) == 0)) {
if ((local_10[0x162] & 0x400000) != 0) {
fprintf(*(FILE **)PTR_stderr_00386fd8,"%s: Aria file %s\n",my_progname_short,*local_10);
}
*(uint *)(local_10 + 0x412d) = *(uint *)(local_10 + 0x412d) | 4;
}
*(char *)((long)local_10 + 0x209a2) = *(char *)((long)local_10 + 0x209a2) + '\x01';
local_28 = local_e8;
local_30 = &stack0x00000008;
local_34 = 0x30;
local_38 = 0x10;
fprintf(*(FILE **)PTR_stderr_00386fd8,"%s: warning: ",my_progname_short);
vfprintf(*(FILE **)PTR_stderr_00386fd8,local_18,&local_38);
fputc(10,*(FILE **)PTR_stderr_00386fd8);
fflush(*(FILE **)PTR_stderr_00386fd8);
return &local_38;
}
| |
43,401 | my_wildcmp_bin_impl | eloqsql/strings/ctype-bin.c | static
int my_wildcmp_bin_impl(CHARSET_INFO *cs,
const char *str,const char *str_end,
const char *wildstr,const char *wildend,
int escape, int w_one, int w_many, int recurse_level)
{
int result= -1; /* Not found, using wildcards */
if (my_string_stack_guard && my_string_stack_guard(recurse_level))
return 1;
while (wildstr != wildend)
{
while (*wildstr != w_many && *wildstr != w_one)
{
if (*wildstr == escape && wildstr+1 != wildend)
wildstr++;
if (str == str_end || likeconv(cs,*wildstr++) != likeconv(cs,*str++))
return(1); /* No match */
if (wildstr == wildend)
return(str != str_end); /* Match if both are at end */
result=1; /* Found an anchor char */
}
if (*wildstr == w_one)
{
do
{
if (str == str_end) /* Skip one char if possible */
return(result);
INC_PTR(cs,str,str_end);
} while (++wildstr < wildend && *wildstr == w_one);
if (wildstr == wildend)
break;
}
if (*wildstr == w_many)
{ /* Found w_many */
uchar cmp;
wildstr++;
/* Remove any '%' and '_' from the wild search string */
for (; wildstr != wildend ; wildstr++)
{
if (*wildstr == w_many)
continue;
if (*wildstr == w_one)
{
if (str == str_end)
return(-1);
INC_PTR(cs,str,str_end);
continue;
}
break; /* Not a wild character */
}
if (wildstr == wildend)
return(0); /* match if w_many is last */
if (str == str_end)
return(-1);
if ((cmp= *wildstr) == escape && wildstr+1 != wildend)
cmp= *++wildstr;
INC_PTR(cs,wildstr,wildend); /* This is compared through cmp */
cmp=likeconv(cs,cmp);
do
{
while (str != str_end && (uchar) likeconv(cs,*str) != cmp)
str++;
if (str++ == str_end)
return(-1);
{
int tmp=my_wildcmp_bin_impl(cs,str,str_end,wildstr,wildend,escape,w_one,
w_many, recurse_level + 1);
if (tmp <= 0)
return(tmp);
}
} while (str != str_end);
return(-1);
}
}
return(str != str_end ? 1 : 0);
} | O3 | c | my_wildcmp_bin_impl:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movq %rcx, %r13
movq %rdx, %rbx
movq %rdi, %r12
movl 0x18(%rbp), %r10d
leaq 0x33e47a(%rip), %rax # 0x36c960
movq (%rax), %rax
testq %rax, %rax
je 0x2e519
movl %r10d, %edi
movq %rsi, %r14
movl %r15d, -0x30(%rbp)
movl %r8d, %r15d
callq *%rax
movl 0x18(%rbp), %r10d
movl %r15d, %r8d
movl -0x30(%rbp), %r15d
movq %r14, %rsi
movl $0x1, %r14d
testl %eax, %eax
jne 0x2e625
movl 0x10(%rbp), %r11d
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %r13, %rbx
je 0x2e61b
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r11d, %ecx
sete %dil
cmpl %r15d, %ecx
sete %dl
orb %dl, %dil
je 0x2e58c
testb %dl, %dl
je 0x2e582
incq %rbx
movq %rbx, %rax
cmpq %rsi, %r12
je 0x2e625
movq %r12, %rcx
movq %rax, %rbx
cmpq %r13, %rax
jae 0x2e571
leaq 0x1(%rcx), %r12
movsbl (%rbx), %edx
leaq 0x1(%rbx), %rax
cmpl %r15d, %edx
je 0x2e54d
incq %rcx
cmpq %r13, %rbx
je 0x2e618
movb (%rbx), %al
movq %rcx, %r12
movsbl %al, %eax
cmpl %r11d, %eax
jne 0x2e523
jmp 0x2e5de
movl $0x1, %r14d
cmpq %rsi, %r12
je 0x2e625
leaq 0x1(%rbx), %rax
cmpq %r13, %rax
cmoveq %rbx, %rax
cmpl %r8d, %ecx
cmoveq %rax, %rbx
movb (%rbx), %al
cmpb (%r12), %al
jne 0x2e625
incq %r12
incq %rbx
cmpq %r13, %rbx
je 0x2e61b
movb (%rbx), %al
movsbl %al, %ecx
cmpl %r15d, %ecx
sete %dl
cmpl %r11d, %ecx
je 0x2e543
cmpl %r15d, %ecx
jne 0x2e58c
jmp 0x2e543
leaq 0x1(%rbx), %rax
xorl %r14d, %r14d
cmpq %r13, %rax
je 0x2e625
addq $0x2, %rbx
movb -0x1(%rbx), %cl
movsbl %cl, %eax
cmpl %r11d, %eax
je 0x2e60a
cmpl %r15d, %eax
jne 0x2e637
cmpq %rsi, %r12
je 0x2e6bd
incq %r12
leaq 0x1(%rbx), %rax
cmpq %r13, %rbx
movq %rax, %rbx
jne 0x2e5ee
jmp 0x2e625
movq %rcx, %r12
xorl %r14d, %r14d
cmpq %rsi, %r12
setne %r14b
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpq %rsi, %r12
je 0x2e625
movzbl %cl, %eax
leaq -0x1(%rbx), %rdx
cmpl %r8d, %eax
jne 0x2e658
cmpq %r13, %rbx
je 0x2e658
movb (%rbx), %cl
movq %rbx, %rdx
incq %rdx
incl %r10d
cmpq %rsi, %r12
je 0x2e625
cmpb %cl, (%r12)
je 0x2e66e
incq %r12
jmp 0x2e65e
movb %cl, -0x29(%rbp)
incq %r12
movq %r12, %rdi
movq %rdx, -0x38(%rbp)
movq %r13, %rcx
movq %rsi, %rbx
movl %r8d, -0x30(%rbp)
movl %r15d, %r9d
movq %r10, -0x40(%rbp)
pushq %r10
pushq %r11
callq 0x2e4be
addq $0x10, %rsp
testl %eax, %eax
jle 0x2e6c8
cmpq %rbx, %r12
movq %rbx, %rsi
movl -0x30(%rbp), %r8d
movq -0x40(%rbp), %r10
movl 0x10(%rbp), %r11d
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rdx
jne 0x2e65e
jmp 0x2e625
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jmp 0x2e625
movl %eax, %r14d
jmp 0x2e625
| my_wildcmp_bin_impl:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15d, r9d
mov r13, rcx
mov rbx, rdx
mov r12, rdi
mov r10d, [rbp+arg_8]
lea rax, my_string_stack_guard
mov rax, [rax]
test rax, rax
jz short loc_2E519
mov edi, r10d
mov r14, rsi
mov [rbp+var_30], r15d
mov r15d, r8d
call rax
mov r10d, [rbp+arg_8]
mov r8d, r15d
mov r15d, [rbp+var_30]
mov rsi, r14
mov r14d, 1
test eax, eax
jnz loc_2E625
loc_2E519:
mov r11d, [rbp+arg_0]
mov r14d, 0FFFFFFFFh
loc_2E523:
cmp rbx, r13
jz loc_2E61B
mov al, [rbx]
movsx ecx, al
cmp ecx, r11d
setz dil
cmp ecx, r15d
setz dl
or dil, dl
jz short loc_2E58C
loc_2E543:
test dl, dl
jz short loc_2E582
inc rbx
mov rax, rbx
loc_2E54D:
cmp r12, rsi
jz loc_2E625
mov rcx, r12
mov rbx, rax
cmp rax, r13
jnb short loc_2E571
lea r12, [rcx+1]
movsx edx, byte ptr [rbx]
lea rax, [rbx+1]
cmp edx, r15d
jz short loc_2E54D
loc_2E571:
inc rcx
cmp rbx, r13
jz loc_2E618
mov al, [rbx]
mov r12, rcx
loc_2E582:
movsx eax, al
cmp eax, r11d
jnz short loc_2E523
jmp short loc_2E5DE
loc_2E58C:
mov r14d, 1
cmp r12, rsi
jz loc_2E625
lea rax, [rbx+1]
cmp rax, r13
cmovz rax, rbx
cmp ecx, r8d
cmovz rbx, rax
mov al, [rbx]
cmp al, [r12]
jnz short loc_2E625
inc r12
inc rbx
cmp rbx, r13
jz short loc_2E61B
mov al, [rbx]
movsx ecx, al
cmp ecx, r15d
setz dl
cmp ecx, r11d
jz loc_2E543
cmp ecx, r15d
jnz short loc_2E58C
jmp loc_2E543
loc_2E5DE:
lea rax, [rbx+1]
xor r14d, r14d
cmp rax, r13
jz short loc_2E625
add rbx, 2
loc_2E5EE:
mov cl, [rbx-1]
movsx eax, cl
cmp eax, r11d
jz short loc_2E60A
cmp eax, r15d
jnz short loc_2E637
cmp r12, rsi
jz loc_2E6BD
inc r12
loc_2E60A:
lea rax, [rbx+1]
cmp rbx, r13
mov rbx, rax
jnz short loc_2E5EE
jmp short loc_2E625
loc_2E618:
mov r12, rcx
loc_2E61B:
xor r14d, r14d
cmp r12, rsi
setnz r14b
loc_2E625:
mov eax, r14d
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_2E637:
mov r14d, 0FFFFFFFFh
cmp r12, rsi
jz short loc_2E625
movzx eax, cl
lea rdx, [rbx-1]
cmp eax, r8d
jnz short loc_2E658
cmp rbx, r13
jz short loc_2E658
mov cl, [rbx]
mov rdx, rbx
loc_2E658:
inc rdx
inc r10d
loc_2E65E:
cmp r12, rsi
jz short loc_2E625
cmp [r12], cl
jz short loc_2E66E
inc r12
jmp short loc_2E65E
loc_2E66E:
mov [rbp+var_29], cl
inc r12
mov rdi, r12
mov [rbp+var_38], rdx
mov rcx, r13
mov rbx, rsi
mov [rbp+var_30], r8d
mov r9d, r15d
mov [rbp+var_40], r10
push r10
push r11
call my_wildcmp_bin_impl
add rsp, 10h
test eax, eax
jle short loc_2E6C8
cmp r12, rbx
mov rsi, rbx
mov r8d, [rbp+var_30]
mov r10, [rbp+var_40]
mov r11d, [rbp+arg_0]
mov cl, [rbp+var_29]
mov rdx, [rbp+var_38]
jnz short loc_2E65E
jmp loc_2E625
loc_2E6BD:
mov r14d, 0FFFFFFFFh
jmp loc_2E625
loc_2E6C8:
mov r14d, eax
jmp loc_2E625
| long long my_wildcmp_bin_impl(
_BYTE *a1,
_BYTE *a2,
char *a3,
char *a4,
int a5,
int a6,
int a7,
unsigned int a8)
{
int v8; // r15d
unsigned int v12; // r10d
int v13; // r15d
int v14; // eax
unsigned int v15; // r14d
int v16; // r11d
char v17; // al
int v18; // ecx
bool v19; // dl
char *v20; // rax
_BYTE *v21; // rcx
int v22; // edx
_BYTE *v23; // rcx
char *v24; // rax
char *v25; // rbx
unsigned __int8 v26; // cl
char *v29; // rdx
_BYTE *v30; // rdx
long long v31; // r10
int v32; // eax
long long v33; // [rsp+0h] [rbp-40h]
_BYTE *v34; // [rsp+8h] [rbp-38h]
int v36; // [rsp+10h] [rbp-30h]
unsigned __int8 v37; // [rsp+17h] [rbp-29h]
v8 = a6;
v12 = a8;
if ( my_string_stack_guard )
{
v13 = a5;
v14 = my_string_stack_guard(a8);
v12 = a8;
a5 = v13;
v8 = a6;
v15 = 1;
if ( v14 )
return v15;
}
v16 = a7;
v15 = -1;
do
{
if ( a3 == a4 )
return a1 != a2;
v17 = *a3;
v18 = *a3;
v19 = v18 == v8;
if ( v18 != v8 && v18 != a7 )
{
do
{
v15 = 1;
if ( a1 == a2 )
return v15;
v24 = a3 + 1;
if ( a3 + 1 == a4 )
v24 = a3;
if ( v18 == a5 )
a3 = v24;
if ( *a3 != *a1 )
return v15;
++a1;
if ( ++a3 == a4 )
return a1 != a2;
v17 = *a3;
v18 = *a3;
v19 = v18 == v8;
}
while ( v18 != a7 && v18 != v8 );
}
if ( v19 )
{
v20 = a3 + 1;
do
{
if ( a1 == a2 )
return v15;
v21 = a1;
a3 = v20;
if ( v20 >= a4 )
break;
++a1;
v22 = *v20++;
}
while ( v22 == v8 );
v23 = v21 + 1;
if ( a3 == a4 )
{
a1 = v23;
return a1 != a2;
}
v17 = *a3;
a1 = v23;
}
}
while ( v17 != a7 );
v15 = 0;
if ( a3 + 1 == a4 )
return v15;
v25 = a3 + 2;
while ( 1 )
{
v26 = *(v25 - 1);
if ( (char)v26 == a7 )
goto LABEL_31;
if ( (char)v26 != v8 )
break;
if ( a1 == a2 )
return (unsigned int)-1;
++a1;
LABEL_31:
if ( v25++ == a4 )
return v15;
}
v15 = -1;
if ( a1 != a2 )
{
v29 = v25 - 1;
if ( v26 == a5 && v25 != a4 )
{
v26 = *v25;
v29 = v25;
}
v30 = v29 + 1;
v31 = v12 + 1;
while ( a1 != a2 )
{
if ( *a1 == v26 )
{
v37 = v26;
++a1;
v34 = v30;
v36 = a5;
v33 = v31;
v32 = my_wildcmp_bin_impl((_DWORD)a1, (_DWORD)a2, (_DWORD)v30, (_DWORD)a4, a5, v8, v16, v31);
if ( v32 <= 0 )
return (unsigned int)v32;
a5 = v36;
v31 = v33;
v16 = a7;
v26 = v37;
v30 = v34;
if ( a1 == a2 )
return v15;
}
else
{
++a1;
}
}
}
return v15;
}
| my_wildcmp_bin_impl:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15D,R9D
MOV R13,RCX
MOV RBX,RDX
MOV R12,RDI
MOV R10D,dword ptr [RBP + 0x18]
LEA RAX,[0x46c960]
MOV RAX,qword ptr [RAX]
TEST RAX,RAX
JZ 0x0012e519
MOV EDI,R10D
MOV R14,RSI
MOV dword ptr [RBP + -0x30],R15D
MOV R15D,R8D
CALL RAX
MOV R10D,dword ptr [RBP + 0x18]
MOV R8D,R15D
MOV R15D,dword ptr [RBP + -0x30]
MOV RSI,R14
MOV R14D,0x1
TEST EAX,EAX
JNZ 0x0012e625
LAB_0012e519:
MOV R11D,dword ptr [RBP + 0x10]
MOV R14D,0xffffffff
LAB_0012e523:
CMP RBX,R13
JZ 0x0012e61b
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R11D
SETZ DIL
CMP ECX,R15D
SETZ DL
OR DIL,DL
JZ 0x0012e58c
LAB_0012e543:
TEST DL,DL
JZ 0x0012e582
INC RBX
MOV RAX,RBX
LAB_0012e54d:
CMP R12,RSI
JZ 0x0012e625
MOV RCX,R12
MOV RBX,RAX
CMP RAX,R13
JNC 0x0012e571
LEA R12,[RCX + 0x1]
MOVSX EDX,byte ptr [RBX]
LEA RAX,[RBX + 0x1]
CMP EDX,R15D
JZ 0x0012e54d
LAB_0012e571:
INC RCX
CMP RBX,R13
JZ 0x0012e618
MOV AL,byte ptr [RBX]
MOV R12,RCX
LAB_0012e582:
MOVSX EAX,AL
CMP EAX,R11D
JNZ 0x0012e523
JMP 0x0012e5de
LAB_0012e58c:
MOV R14D,0x1
CMP R12,RSI
JZ 0x0012e625
LEA RAX,[RBX + 0x1]
CMP RAX,R13
CMOVZ RAX,RBX
CMP ECX,R8D
CMOVZ RBX,RAX
MOV AL,byte ptr [RBX]
CMP AL,byte ptr [R12]
JNZ 0x0012e625
INC R12
INC RBX
CMP RBX,R13
JZ 0x0012e61b
MOV AL,byte ptr [RBX]
MOVSX ECX,AL
CMP ECX,R15D
SETZ DL
CMP ECX,R11D
JZ 0x0012e543
CMP ECX,R15D
JNZ 0x0012e58c
JMP 0x0012e543
LAB_0012e5de:
LEA RAX,[RBX + 0x1]
XOR R14D,R14D
CMP RAX,R13
JZ 0x0012e625
ADD RBX,0x2
LAB_0012e5ee:
MOV CL,byte ptr [RBX + -0x1]
MOVSX EAX,CL
CMP EAX,R11D
JZ 0x0012e60a
CMP EAX,R15D
JNZ 0x0012e637
CMP R12,RSI
JZ 0x0012e6bd
INC R12
LAB_0012e60a:
LEA RAX,[RBX + 0x1]
CMP RBX,R13
MOV RBX,RAX
JNZ 0x0012e5ee
JMP 0x0012e625
LAB_0012e618:
MOV R12,RCX
LAB_0012e61b:
XOR R14D,R14D
CMP R12,RSI
SETNZ R14B
LAB_0012e625:
MOV EAX,R14D
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0012e637:
MOV R14D,0xffffffff
CMP R12,RSI
JZ 0x0012e625
MOVZX EAX,CL
LEA RDX,[RBX + -0x1]
CMP EAX,R8D
JNZ 0x0012e658
CMP RBX,R13
JZ 0x0012e658
MOV CL,byte ptr [RBX]
MOV RDX,RBX
LAB_0012e658:
INC RDX
INC R10D
LAB_0012e65e:
CMP R12,RSI
JZ 0x0012e625
CMP byte ptr [R12],CL
JZ 0x0012e66e
INC R12
JMP 0x0012e65e
LAB_0012e66e:
MOV byte ptr [RBP + -0x29],CL
INC R12
MOV RDI,R12
MOV qword ptr [RBP + -0x38],RDX
MOV RCX,R13
MOV RBX,RSI
MOV dword ptr [RBP + -0x30],R8D
MOV R9D,R15D
MOV qword ptr [RBP + -0x40],R10
PUSH R10
PUSH R11
CALL 0x0012e4be
ADD RSP,0x10
TEST EAX,EAX
JLE 0x0012e6c8
CMP R12,RBX
MOV RSI,RBX
MOV R8D,dword ptr [RBP + -0x30]
MOV R10,qword ptr [RBP + -0x40]
MOV R11D,dword ptr [RBP + 0x10]
MOV CL,byte ptr [RBP + -0x29]
MOV RDX,qword ptr [RBP + -0x38]
JNZ 0x0012e65e
JMP 0x0012e625
LAB_0012e6bd:
MOV R14D,0xffffffff
JMP 0x0012e625
LAB_0012e6c8:
MOV R14D,EAX
JMP 0x0012e625
|
uint my_wildcmp_bin_impl(byte *param_1,byte *param_2,byte *param_3,byte *param_4,ulong param_5,
uint param_6,uint param_7,int param_8)
{
byte bVar1;
int iVar2;
uint uVar3;
byte *pbVar4;
uint uVar5;
byte *pbVar6;
ulong uVar7;
bool bVar8;
if (my_string_stack_guard != (code *)0x0) {
param_5 = param_5 & 0xffffffff;
iVar2 = (*my_string_stack_guard)(param_8);
if (iVar2 != 0) {
return 1;
}
}
uVar3 = 0xffffffff;
while (param_3 != param_4) {
bVar1 = *param_3;
uVar5 = (uint)(char)bVar1;
bVar8 = uVar5 == param_6;
if (uVar5 != param_7 && !bVar8) {
do {
uVar3 = 1;
if (param_1 == param_2) {
return 1;
}
pbVar4 = param_3 + 1;
if (param_3 + 1 == param_4) {
pbVar4 = param_3;
}
if (uVar5 == (uint)param_5) {
param_3 = pbVar4;
}
if (*param_3 != *param_1) {
return 1;
}
param_1 = param_1 + 1;
param_3 = param_3 + 1;
if (param_3 == param_4) goto LAB_0012e61b;
bVar1 = *param_3;
uVar5 = (uint)(char)bVar1;
bVar8 = uVar5 == param_6;
} while ((uVar5 != param_7) && (uVar5 != param_6));
}
if (bVar8) {
do {
pbVar4 = param_1;
param_3 = param_3 + 1;
if (pbVar4 == param_2) {
return uVar3;
}
} while ((param_3 < param_4) && (param_1 = pbVar4 + 1, (int)(char)*param_3 == param_6));
param_1 = pbVar4 + 1;
if (param_3 == param_4) break;
bVar1 = *param_3;
}
if ((int)(char)bVar1 == param_7) {
if (param_3 + 1 != param_4) {
pbVar4 = param_3 + 2;
do {
bVar1 = pbVar4[-1];
if ((int)(char)bVar1 != param_7) {
if ((int)(char)bVar1 != param_6) {
if (param_1 == param_2) {
return 0xffffffff;
}
pbVar6 = pbVar4 + -1;
if (((uint)bVar1 == (uint)param_5) && (pbVar4 != param_4)) {
bVar1 = *pbVar4;
pbVar6 = pbVar4;
}
pbVar6 = pbVar6 + 1;
uVar7 = (ulong)(param_8 + 1);
while( true ) {
while( true ) {
if (param_1 == param_2) {
return 0xffffffff;
}
if (*param_1 == bVar1) break;
param_1 = param_1 + 1;
}
param_1 = param_1 + 1;
uVar5 = (uint)param_5;
uVar3 = my_wildcmp_bin_impl(param_1,param_2,pbVar6,param_4,param_5,param_6,param_7,
uVar7,uVar7,pbVar6,uVar5);
if ((int)uVar3 < 1) break;
param_5 = (ulong)uVar5;
if (param_1 == param_2) {
return 0xffffffff;
}
}
return uVar3;
}
if (param_1 == param_2) {
return 0xffffffff;
}
param_1 = param_1 + 1;
}
bVar8 = pbVar4 != param_4;
pbVar4 = pbVar4 + 1;
} while (bVar8);
}
return 0;
}
}
LAB_0012e61b:
return (uint)(param_1 != param_2);
}
| |
43,402 | js_string_includes | bluesky950520[P]quickjs/quickjs.c | static JSValue js_string_includes(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv, int magic)
{
JSValue str, v = JS_UNDEFINED;
int i, len, v_len, pos, start, stop, ret;
JSString *p;
JSString *p1;
str = JS_ToStringCheckObject(ctx, this_val);
if (JS_IsException(str))
return str;
ret = js_is_regexp(ctx, argv[0]);
if (ret) {
if (ret > 0)
JS_ThrowTypeError(ctx, "regexp not supported");
goto fail;
}
v = JS_ToString(ctx, argv[0]);
if (JS_IsException(v))
goto fail;
p = JS_VALUE_GET_STRING(str);
p1 = JS_VALUE_GET_STRING(v);
len = p->len;
v_len = p1->len;
pos = (magic == 2) ? len : 0;
if (argc > 1 && !JS_IsUndefined(argv[1])) {
if (JS_ToInt32Clamp(ctx, &pos, argv[1], 0, len, 0))
goto fail;
}
len -= v_len;
ret = 0;
if (magic == 0) {
start = pos;
stop = len;
} else {
if (magic == 1) {
if (pos > len)
goto done;
} else {
pos -= v_len;
}
start = stop = pos;
}
if (start >= 0 && start <= stop) {
for (i = start;; i++) {
if (!string_cmp(p, p1, i, 0, v_len)) {
ret = 1;
break;
}
if (i == stop)
break;
}
}
done:
JS_FreeValue(ctx, str);
JS_FreeValue(ctx, v);
return js_bool(ret);
fail:
JS_FreeValue(ctx, str);
JS_FreeValue(ctx, v);
return JS_EXCEPTION;
} | O2 | c | js_string_includes:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movq %r8, %r13
movl %ecx, %r12d
movq %rdi, %rbx
callq 0x3de40
movq %rax, %r15
movq %rdx, %r14
cmpl $0x6, %r14d
je 0x6b6fe
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x45652
testl %eax, %eax
je 0x6b6b7
pushq $0x3
popq %rbp
jle 0x6b6d8
leaq 0x20ca8(%rip), %rsi # 0x8c350
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x201fd
jmp 0x6b6db
movl %ebp, 0x10(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %rbx, %rdi
callq 0x1ebec
movq %rdx, %rbp
cmpl $0x6, %ebp
jne 0x6b713
movq %rax, %r12
jmp 0x6b6db
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bbce
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x1bbce
pushq $0x6
popq %r14
xorl %r15d, %r15d
movq %r15, %rax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x20(%rsp)
movl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
movl 0x4(%r15), %ebp
andl %ecx, %ebp
movq %rax, 0x18(%rsp)
andl 0x4(%rax), %ecx
movl %ecx, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x2, 0x10(%rsp)
cmovel %ebp, %eax
movl %eax, 0x14(%rsp)
cmpl $0x2, %r12d
jl 0x6b77a
movq 0x18(%r13), %rcx
cmpl $0x3, %ecx
je 0x6b77a
movq 0x10(%r13), %rdx
andl $0x0, (%rsp)
leaq 0x14(%rsp), %rsi
movq %rbx, %rdi
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0x24f85
testl %eax, %eax
je 0x6b77a
movq 0x20(%rsp), %rbp
movq 0x18(%rsp), %r12
jmp 0x6b6db
subl 0xc(%rsp), %ebp
movl 0x14(%rsp), %r12d
movl 0x10(%rsp), %eax
testl %eax, %eax
je 0x6b7a2
cmpl $0x1, %eax
jne 0x6b79a
cmpl %ebp, %r12d
movl %r12d, %ebp
jle 0x6b7a2
jmp 0x6b7d8
subl 0xc(%rsp), %r12d
movl %r12d, %ebp
xorl %r13d, %r13d
testl %r12d, %r12d
js 0x6b7db
cmpl %ebp, %r12d
jg 0x6b7db
incl %ebp
pushq $0x1
popq %r13
movq %r15, %rdi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
xorl %ecx, %ecx
movl 0xc(%rsp), %r8d
callq 0x6d1ca
testl %eax, %eax
je 0x6b7db
incl %r12d
cmpl %r12d, %ebp
jne 0x6b7b5
xorl %r13d, %r13d
pushq $0x1
popq %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bbce
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x1bbce
movq %r13, %r15
movq %r12, %r14
jmp 0x6b6fe
| js_string_includes:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov ebp, r9d
mov r13, r8
mov r12d, ecx
mov rbx, rdi
call JS_ToStringCheckObject
mov r15, rax
mov r14, rdx
cmp r14d, 6
jz short loc_6B6FE
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
call js_is_regexp
test eax, eax
jz short loc_6B6B7
push 3
pop rbp
jle short loc_6B6D8
lea rsi, aRegexpNotSuppo; "regexp not supported"
xor r12d, r12d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
jmp short loc_6B6DB
loc_6B6B7:
mov [rsp+58h+var_48], ebp
mov rsi, [r13+0]
mov rdx, [r13+8]
mov rdi, rbx
call JS_ToString
mov rbp, rdx
cmp ebp, 6
jnz short loc_6B713
mov r12, rax
jmp short loc_6B6DB
loc_6B6D8:
xor r12d, r12d
loc_6B6DB:
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, r12
mov rdx, rbp
call JS_FreeValue
push 6
pop r14
xor r15d, r15d
loc_6B6FE:
mov rax, r15
mov rdx, r14
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6B713:
mov [rsp+58h+var_38], rbp
mov ecx, 7FFFFFFFh
mov ebp, [r15+4]
and ebp, ecx
mov [rsp+58h+var_40], rax
and ecx, [rax+4]
mov [rsp+58h+var_4C], ecx
xor eax, eax
cmp [rsp+58h+var_48], 2
cmovz eax, ebp
mov [rsp+58h+var_44], eax
cmp r12d, 2
jl short loc_6B77A
mov rcx, [r13+18h]
cmp ecx, 3
jz short loc_6B77A
mov rdx, [r13+10h]
and [rsp+58h+var_58], 0
lea rsi, [rsp+58h+var_44]
mov rdi, rbx
xor r8d, r8d
mov r9d, ebp
call JS_ToInt32Clamp
test eax, eax
jz short loc_6B77A
mov rbp, [rsp+58h+var_38]
mov r12, [rsp+58h+var_40]
jmp loc_6B6DB
loc_6B77A:
sub ebp, [rsp+58h+var_4C]
mov r12d, [rsp+58h+var_44]
mov eax, [rsp+58h+var_48]
test eax, eax
jz short loc_6B7A2
cmp eax, 1
jnz short loc_6B79A
cmp r12d, ebp
mov ebp, r12d
jle short loc_6B7A2
jmp short loc_6B7D8
loc_6B79A:
sub r12d, [rsp+58h+var_4C]
mov ebp, r12d
loc_6B7A2:
xor r13d, r13d
test r12d, r12d
js short loc_6B7DB
cmp r12d, ebp
jg short loc_6B7DB
inc ebp
push 1
pop r13
loc_6B7B5:
mov rdi, r15
mov rsi, [rsp+58h+var_40]
mov edx, r12d
xor ecx, ecx
mov r8d, [rsp+58h+var_4C]
call string_cmp
test eax, eax
jz short loc_6B7DB
inc r12d
cmp ebp, r12d
jnz short loc_6B7B5
loc_6B7D8:
xor r13d, r13d
loc_6B7DB:
push 1
pop r12
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_FreeValue
mov rdi, rbx
mov rsi, [rsp+58h+var_40]
mov rdx, [rsp+58h+var_38]
call JS_FreeValue
mov r15, r13
mov r14, r12
jmp loc_6B6FE
| long long js_string_includes(
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)
{
int v14; // ebp
int v16; // r12d
long long v17; // r15
long long v18; // rdx
long long v19; // r14
int is_regexp; // eax
long long v21; // rdx
long long v22; // rcx
long long v23; // r8
long long v24; // r9
__m128 v25; // xmm4
__m128 v26; // xmm5
long long v27; // rbp
long long v28; // r12
long long v29; // rax
long long v30; // rdx
int v32; // ebp
int v33; // eax
long long v34; // rcx
int v35; // ebp
int v36; // r12d
bool v37; // cc
long long v38; // r13
int v39; // ebp
char v40; // [rsp+0h] [rbp-58h]
int v41; // [rsp+Ch] [rbp-4Ch]
int v42; // [rsp+10h] [rbp-48h]
int v43; // [rsp+14h] [rbp-44h] BYREF
long long v44; // [rsp+18h] [rbp-40h]
long long v45; // [rsp+20h] [rbp-38h]
v14 = a6;
v16 = a4;
v17 = JS_ToStringCheckObject(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14);
v19 = v18;
if ( (_DWORD)v18 != 6 )
{
is_regexp = js_is_regexp(a1, *(_QWORD *)a5, *(_QWORD *)(a5 + 8));
if ( is_regexp )
{
v27 = 3LL;
v28 = 0LL;
if ( is_regexp > 0 )
JS_ThrowTypeError(
a1,
(long long)"regexp not supported",
v21,
v22,
v23,
v24,
a7,
a8,
a9,
a10,
v25,
v26,
a13,
a14,
v40);
goto LABEL_7;
}
v42 = v14;
v29 = JS_ToString(a1, *(_QWORD *)a5, *(_QWORD *)(a5 + 8));
v27 = v30;
if ( (_DWORD)v30 == 6 )
{
v28 = v29;
LABEL_7:
JS_FreeValue(a1, v17, v19);
JS_FreeValue(a1, v28, v27);
return 0LL;
}
v45 = v30;
v32 = *(_DWORD *)(v17 + 4) & 0x7FFFFFFF;
v44 = v29;
v41 = *(_DWORD *)(v29 + 4) & 0x7FFFFFFF;
v33 = 0;
if ( v42 == 2 )
v33 = v32;
v43 = v33;
if ( v16 >= 2 )
{
v34 = *(_QWORD *)(a5 + 24);
if ( (_DWORD)v34 != 3 )
{
if ( (unsigned int)JS_ToInt32Clamp(a1, &v43, *(_DWORD **)(a5 + 16), v34, 0, v32, 0) )
{
v27 = v45;
v28 = v44;
goto LABEL_7;
}
}
}
v35 = v32 - v41;
v36 = v43;
if ( v42 )
{
if ( v42 == 1 )
{
v37 = v43 <= v35;
v35 = v43;
if ( !v37 )
{
LABEL_25:
v38 = 0LL;
LABEL_26:
JS_FreeValue(a1, v17, v19);
JS_FreeValue(a1, v44, v45);
return v38;
}
}
else
{
v36 = v43 - v41;
v35 = v43 - v41;
}
}
v38 = 0LL;
if ( v36 >= 0 && v36 <= v35 )
{
v39 = v35 + 1;
v38 = 1LL;
while ( (unsigned int)string_cmp(v17, v44, (unsigned int)v36, 0LL) )
{
if ( v39 == ++v36 )
goto LABEL_25;
}
}
goto LABEL_26;
}
return v17;
}
| js_string_includes:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R9D
MOV R13,R8
MOV R12D,ECX
MOV RBX,RDI
CALL 0x0013de40
MOV R15,RAX
MOV R14,RDX
CMP R14D,0x6
JZ 0x0016b6fe
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x00145652
TEST EAX,EAX
JZ 0x0016b6b7
PUSH 0x3
POP RBP
JLE 0x0016b6d8
LEA RSI,[0x18c350]
XOR R12D,R12D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x001201fd
JMP 0x0016b6db
LAB_0016b6b7:
MOV dword ptr [RSP + 0x10],EBP
MOV RSI,qword ptr [R13]
MOV RDX,qword ptr [R13 + 0x8]
MOV RDI,RBX
CALL 0x0011ebec
MOV RBP,RDX
CMP EBP,0x6
JNZ 0x0016b713
MOV R12,RAX
JMP 0x0016b6db
LAB_0016b6d8:
XOR R12D,R12D
LAB_0016b6db:
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,R12
MOV RDX,RBP
CALL 0x0011bbce
PUSH 0x6
POP R14
XOR R15D,R15D
LAB_0016b6fe:
MOV RAX,R15
MOV RDX,R14
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016b713:
MOV qword ptr [RSP + 0x20],RBP
MOV ECX,0x7fffffff
MOV EBP,dword ptr [R15 + 0x4]
AND EBP,ECX
MOV qword ptr [RSP + 0x18],RAX
AND ECX,dword ptr [RAX + 0x4]
MOV dword ptr [RSP + 0xc],ECX
XOR EAX,EAX
CMP dword ptr [RSP + 0x10],0x2
CMOVZ EAX,EBP
MOV dword ptr [RSP + 0x14],EAX
CMP R12D,0x2
JL 0x0016b77a
MOV RCX,qword ptr [R13 + 0x18]
CMP ECX,0x3
JZ 0x0016b77a
MOV RDX,qword ptr [R13 + 0x10]
AND dword ptr [RSP],0x0
LEA RSI,[RSP + 0x14]
MOV RDI,RBX
XOR R8D,R8D
MOV R9D,EBP
CALL 0x00124f85
TEST EAX,EAX
JZ 0x0016b77a
MOV RBP,qword ptr [RSP + 0x20]
MOV R12,qword ptr [RSP + 0x18]
JMP 0x0016b6db
LAB_0016b77a:
SUB EBP,dword ptr [RSP + 0xc]
MOV R12D,dword ptr [RSP + 0x14]
MOV EAX,dword ptr [RSP + 0x10]
TEST EAX,EAX
JZ 0x0016b7a2
CMP EAX,0x1
JNZ 0x0016b79a
CMP R12D,EBP
MOV EBP,R12D
JLE 0x0016b7a2
JMP 0x0016b7d8
LAB_0016b79a:
SUB R12D,dword ptr [RSP + 0xc]
MOV EBP,R12D
LAB_0016b7a2:
XOR R13D,R13D
TEST R12D,R12D
JS 0x0016b7db
CMP R12D,EBP
JG 0x0016b7db
INC EBP
PUSH 0x1
POP R13
LAB_0016b7b5:
MOV RDI,R15
MOV RSI,qword ptr [RSP + 0x18]
MOV EDX,R12D
XOR ECX,ECX
MOV R8D,dword ptr [RSP + 0xc]
CALL 0x0016d1ca
TEST EAX,EAX
JZ 0x0016b7db
INC R12D
CMP EBP,R12D
JNZ 0x0016b7b5
LAB_0016b7d8:
XOR R13D,R13D
LAB_0016b7db:
PUSH 0x1
POP R12
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0011bbce
MOV RDI,RBX
MOV RSI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x20]
CALL 0x0011bbce
MOV R15,R13
MOV R14,R12
JMP 0x0016b6fe
|
int1 [16]
js_string_includes(int8 param_1,int8 param_2,int8 param_3,int param_4,
int8 *param_5,int param_6)
{
int iVar1;
long lVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
int8 uVar7;
int1 auVar8 [16];
int1 auVar9 [16];
uint local_44;
int1 local_40 [16];
auVar8 = JS_ToStringCheckObject();
lVar2 = auVar8._0_8_;
if (auVar8._8_4_ == 6) {
return auVar8;
}
iVar1 = js_is_regexp(param_1,*param_5,param_5[1]);
if (iVar1 != 0) {
if (iVar1 < 1) {
auVar9 = ZEXT816(3) << 0x40;
}
else {
JS_ThrowTypeError(param_1,"regexp not supported");
auVar9 = ZEXT816(3) << 0x40;
}
LAB_0016b6db:
JS_FreeValue(param_1,lVar2,auVar8._8_8_);
JS_FreeValue(param_1,auVar9._0_8_,auVar9._8_8_);
return ZEXT816(6) << 0x40;
}
auVar9 = JS_ToString(param_1,*param_5,param_5[1]);
if (auVar9._8_4_ == 6) goto LAB_0016b6db;
uVar4 = *(uint *)(lVar2 + 4) & 0x7fffffff;
uVar3 = *(uint *)(auVar9._0_8_ + 4) & 0x7fffffff;
local_44 = 0;
if (param_6 == 2) {
local_44 = uVar4;
}
local_40 = auVar9;
if ((1 < param_4) && ((int)param_5[3] != 3)) {
iVar1 = JS_ToInt32Clamp(param_1,&local_44,param_5[2],param_5[3],0,uVar4,0);
auVar9 = local_40;
if (iVar1 != 0) goto LAB_0016b6db;
}
uVar5 = uVar4 - uVar3;
uVar6 = local_44;
if (param_6 == 0) {
LAB_0016b7a2:
uVar7 = 0;
if (((int)uVar6 < 0) || ((int)uVar5 < (int)uVar6)) goto LAB_0016b7db;
uVar7 = 1;
do {
iVar1 = string_cmp(lVar2,local_40._0_8_,uVar6,0,uVar3);
if (iVar1 == 0) goto LAB_0016b7db;
uVar6 = uVar6 + 1;
} while (uVar5 + 1 != uVar6);
}
else {
if (param_6 != 1) {
uVar5 = local_44 - uVar3;
uVar6 = uVar5;
goto LAB_0016b7a2;
}
uVar5 = local_44;
if ((int)local_44 <= (int)(uVar4 - uVar3)) goto LAB_0016b7a2;
}
uVar7 = 0;
LAB_0016b7db:
auVar9._8_8_ = 1;
auVar9._0_8_ = uVar7;
JS_FreeValue(param_1,lVar2,auVar8._8_8_);
JS_FreeValue(param_1,local_40._0_8_,local_40._8_8_);
return auVar9;
}
| |
43,403 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
this->memory[addr] = val;
return true;
} | O1 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0xec32
movq (%rdi), %rax
movl %ebx, %ecx
movb %dl, (%rax,%rcx)
cmpl $-0x1, %ebx
setne %al
popq %rbx
retq
leaq 0x689e(%rip), %rdi # 0x154d7
movl %ebx, %esi
xorl %eax, %eax
callq 0xb3b0
jmp 0xec2a
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov ebx, esi
cmp esi, 0FFFFFFFFh
jz short loc_EC32
mov rax, [rdi]
mov ecx, ebx
mov [rax+rcx], dl
loc_EC2A:
cmp ebx, 0FFFFFFFFh
setnz al
pop rbx
retn
loc_EC32:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov esi, ebx
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_EC2A
| bool MemoryManager::setByteNoCache(
MemoryManager *this,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-8h]
if ( a2 == -1 )
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
0xFFFFFFFFLL,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v15);
else
*(_BYTE *)(*(_QWORD *)this + a2) = a3;
return a2 != -1;
}
| setByteNoCache:
PUSH RBX
MOV EBX,ESI
CMP ESI,-0x1
JZ 0x0010ec32
MOV RAX,qword ptr [RDI]
MOV ECX,EBX
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0010ec2a:
CMP EBX,-0x1
SETNZ AL
POP RBX
RET
LAB_0010ec32:
LEA RDI,[0x1154d7]
MOV ESI,EBX
XOR EAX,EAX
CALL 0x0010b3b0
JMP 0x0010ec2a
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
if (param_1 == 0xffffffff) {
dbgprintf("Byte write to invalid addr 0x%x!\n",(ulong)param_1);
}
else {
*(uchar *)(*(long *)this + (ulong)param_1) = param_2;
}
return param_1 != 0xffffffff;
}
| |
43,404 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
this->memory[addr] = val;
return true;
} | O2 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0xf7c4
movq (%rdi), %rax
movl %ebx, %ecx
movb %dl, (%rax,%rcx)
jmp 0xf7d5
leaq 0x5ce2(%rip), %rdi # 0x154ad
pushq $-0x1
popq %rsi
xorl %eax, %eax
callq 0xcefb
cmpl $-0x1, %ebx
setne %al
popq %rbx
retq
nop
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov ebx, esi
cmp esi, 0FFFFFFFFh
jz short loc_F7C4
mov rax, [rdi]
mov ecx, ebx
mov [rax+rcx], dl
jmp short loc_F7D5
loc_F7C4:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
push 0FFFFFFFFFFFFFFFFh
pop rsi
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
loc_F7D5:
cmp ebx, 0FFFFFFFFh
setnz al
pop rbx
retn
| bool MemoryManager::setByteNoCache(
MemoryManager *this,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-8h]
if ( a2 == -1 )
dbgprintf("Byte write to invalid addr 0x%x!\n", -1LL, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v15);
else
*(_BYTE *)(*(_QWORD *)this + a2) = a3;
return a2 != -1;
}
| setByteNoCache:
PUSH RBX
MOV EBX,ESI
CMP ESI,-0x1
JZ 0x0010f7c4
MOV RAX,qword ptr [RDI]
MOV ECX,EBX
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x0010f7d5
LAB_0010f7c4:
LEA RDI,[0x1154ad]
PUSH -0x1
POP RSI
XOR EAX,EAX
CALL 0x0010cefb
LAB_0010f7d5:
CMP EBX,-0x1
SETNZ AL
POP RBX
RET
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
if (param_1 == 0xffffffff) {
dbgprintf("Byte write to invalid addr 0x%x!\n",0xffffffffffffffff);
}
else {
*(uchar *)(*(long *)this + (ulong)param_1) = param_2;
}
return param_1 != 0xffffffff;
}
| |
43,405 | MemoryManager::setByteNoCache(unsigned int, unsigned char) | EnderturtleOrz[P]CSC3050-2025-Spring-Project-3/src/MemoryManager.cpp | bool MemoryManager::setByteNoCache(uint32_t addr, uint8_t val) {
if (!this->isAddrExist(addr)) {
dbgprintf("Byte write to invalid addr 0x%x!\n", addr);
return false;
}
this->memory[addr] = val;
return true;
} | O3 | cpp | MemoryManager::setByteNoCache(unsigned int, unsigned char):
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, %esi
je 0xebb2
movq (%rdi), %rax
movl %ebx, %ecx
movb %dl, (%rax,%rcx)
cmpl $-0x1, %ebx
setne %al
popq %rbx
retq
leaq 0x691e(%rip), %rdi # 0x154d7
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
callq 0xb3b0
jmp 0xebaa
nop
| _ZN13MemoryManager14setByteNoCacheEjh:
push rbx
mov ebx, esi
cmp esi, 0FFFFFFFFh
jz short loc_EBB2
mov rax, [rdi]
mov ecx, ebx
mov [rax+rcx], dl
loc_EBAA:
cmp ebx, 0FFFFFFFFh
setnz al
pop rbx
retn
loc_EBB2:
lea rdi, aByteWriteToInv; "Byte write to invalid addr 0x%x!\n"
mov esi, 0FFFFFFFFh
xor eax, eax
call _Z9dbgprintfPKcz; dbgprintf(char const*,...)
jmp short loc_EBAA
| bool MemoryManager::setByteNoCache(
MemoryManager *this,
unsigned int a2,
long long a3,
long long a4,
long long a5,
long long a6,
__m128 a7,
__m128 a8,
__m128 a9,
__m128 a10,
__m128 a11,
__m128 a12,
__m128 a13,
__m128 a14)
{
char v15; // [rsp+0h] [rbp-8h]
if ( a2 == -1 )
dbgprintf(
"Byte write to invalid addr 0x%x!\n",
0xFFFFFFFFLL,
a3,
a4,
a5,
a6,
a7,
a8,
a9,
a10,
a11,
a12,
a13,
a14,
v15);
else
*(_BYTE *)(*(_QWORD *)this + a2) = a3;
return a2 != -1;
}
| setByteNoCache:
PUSH RBX
MOV EBX,ESI
CMP ESI,-0x1
JZ 0x0010ebb2
MOV RAX,qword ptr [RDI]
MOV ECX,EBX
MOV byte ptr [RAX + RCX*0x1],DL
LAB_0010ebaa:
CMP EBX,-0x1
SETNZ AL
POP RBX
RET
LAB_0010ebb2:
LEA RDI,[0x1154d7]
MOV ESI,0xffffffff
XOR EAX,EAX
CALL 0x0010b3b0
JMP 0x0010ebaa
|
/* MemoryManager::setByteNoCache(unsigned int, unsigned char) */
bool __thiscall MemoryManager::setByteNoCache(MemoryManager *this,uint param_1,uchar param_2)
{
if (param_1 == 0xffffffff) {
dbgprintf("Byte write to invalid addr 0x%x!\n",0xffffffff);
}
else {
*(uchar *)(*(long *)this + (ulong)param_1) = param_2;
}
return param_1 != 0xffffffff;
}
| |
43,406 | my_strntod_mb2_or_mb4 | eloqsql/strings/ctype-ucs2.c | static double
my_strntod_mb2_or_mb4(CHARSET_INFO *cs,
char *nptr, size_t length,
char **endptr, int *err)
{
char buf[256];
double res;
register char *b= buf;
register const uchar *s= (const uchar*) nptr;
const uchar *end;
my_wc_t wc;
my_charset_conv_mb_wc mb_wc= cs->cset->mb_wc;
int cnv;
*err= 0;
/* Cut too long strings */
if (length >= sizeof(buf))
length= sizeof(buf) - 1;
end= s + length;
while ((cnv= mb_wc(cs, &wc, s, end)) > 0)
{
s+= cnv;
if (wc > (int) (uchar) 'e' || !wc)
break; /* Can't be part of double */
*b++= (char) wc;
}
*endptr= b;
res= my_strtod(buf, endptr, err);
*endptr= nptr + cs->mbminlen * (size_t) (*endptr - buf);
return res;
} | O3 | c | my_strntod_mb2_or_mb4:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, -0x150(%rbp)
movq %rsi, %rcx
movq %rdi, %r15
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq 0xb8(%rdi), %rax
movq 0x28(%rax), %rbx
movq %r8, -0x148(%rbp)
movl $0x0, (%r8)
movl $0xff, %r13d
cmpq %r13, %rdx
cmovbq %rdx, %r13
addq %rsi, %r13
leaq -0x140(%rbp), %rsi
movq %rcx, -0x138(%rbp)
movq %rcx, %rdx
movq %r13, %rcx
callq *%rbx
leaq -0x130(%rbp), %r12
testl %eax, %eax
jle 0xc3ea1
movq -0x138(%rbp), %r14
movq -0x140(%rbp), %rcx
leaq -0x1(%rcx), %rdx
cmpq $0x64, %rdx
ja 0xc3ea1
movl %eax, %eax
addq %rax, %r14
movb %cl, (%r12)
incq %r12
movq %r15, %rdi
leaq -0x140(%rbp), %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *%rbx
testl %eax, %eax
jg 0xc3e6e
movq -0x150(%rbp), %rbx
movq %r12, (%rbx)
leaq -0x130(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq -0x148(%rbp), %rdx
callq 0xd3a1c
movl 0x98(%r15), %eax
movq (%rbx), %rcx
subq %r14, %rcx
imulq %rax, %rcx
movq -0x138(%rbp), %rax
addq %rcx, %rax
movq %rax, (%rbx)
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0xc3f03
addq $0x128, %rsp # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x29250
| my_strntod_mb2_or_mb4:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 128h
mov [rbp+var_150], rcx
mov rcx, rsi
mov r15, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi+0B8h]
mov rbx, [rax+28h]
mov [rbp+var_148], r8
mov dword ptr [r8], 0
mov r13d, 0FFh
cmp rdx, r13
cmovb r13, rdx
add r13, rsi
lea rsi, [rbp+var_140]
mov [rbp+var_138], rcx
mov rdx, rcx
mov rcx, r13
call rbx
lea r12, [rbp+var_130]
test eax, eax
jle short loc_C3EA1
mov r14, [rbp+var_138]
loc_C3E6E:
mov rcx, [rbp+var_140]
lea rdx, [rcx-1]
cmp rdx, 64h ; 'd'
ja short loc_C3EA1
mov eax, eax
add r14, rax
mov [r12], cl
inc r12
mov rdi, r15
lea rsi, [rbp+var_140]
mov rdx, r14
mov rcx, r13
call rbx
test eax, eax
jg short loc_C3E6E
loc_C3EA1:
mov rbx, [rbp+var_150]
mov [rbx], r12
lea r14, [rbp+var_130]
mov rdi, r14
mov rsi, rbx
mov rdx, [rbp+var_148]
call my_strtod
mov eax, [r15+98h]
mov rcx, [rbx]
sub rcx, r14
imul rcx, rax
mov rax, [rbp+var_138]
add rax, rcx
mov [rbx], rax
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_C3F03
add rsp, 128h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_C3F03:
call ___stack_chk_fail
| unsigned long long my_strntod_mb2_or_mb4(long long a1, long long a2, unsigned long long a3, _QWORD *a4, _DWORD *a5)
{
long long ( *v5)(long long, long long *, long long, long long); // rbx
long long v6; // r13
long long v7; // r13
int v8; // eax
_BYTE *v9; // r12
long long v10; // r14
long long v14; // [rsp+10h] [rbp-140h] BYREF
long long v15; // [rsp+18h] [rbp-138h]
_BYTE v16[256]; // [rsp+20h] [rbp-130h] BYREF
unsigned long long v17; // [rsp+120h] [rbp-30h]
v17 = __readfsqword(0x28u);
v5 = *(long long ( **)(long long, long long *, long long, long long))(*(_QWORD *)(a1 + 184) + 40LL);
*a5 = 0;
v6 = 255LL;
if ( a3 < 0xFF )
v6 = a3;
v7 = a2 + v6;
v15 = a2;
v8 = v5(a1, &v14, a2, v7);
v9 = v16;
if ( v8 > 0 )
{
v10 = v15;
do
{
if ( (unsigned long long)(v14 - 1) > 0x64 )
break;
v10 += (unsigned int)v8;
*v9++ = v14;
v8 = v5(a1, &v14, v10, v7);
}
while ( v8 > 0 );
}
*a4 = v9;
my_strtod(v16, a4, a5);
*a4 = *(unsigned int *)(a1 + 152) * (*a4 - (_QWORD)v16) + v15;
return __readfsqword(0x28u);
}
| my_strntod_mb2_or_mb4:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x128
MOV qword ptr [RBP + -0x150],RCX
MOV RCX,RSI
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI + 0xb8]
MOV RBX,qword ptr [RAX + 0x28]
MOV qword ptr [RBP + -0x148],R8
MOV dword ptr [R8],0x0
MOV R13D,0xff
CMP RDX,R13
CMOVC R13,RDX
ADD R13,RSI
LEA RSI,[RBP + -0x140]
MOV qword ptr [RBP + -0x138],RCX
MOV RDX,RCX
MOV RCX,R13
CALL RBX
LEA R12,[RBP + -0x130]
TEST EAX,EAX
JLE 0x001c3ea1
MOV R14,qword ptr [RBP + -0x138]
LAB_001c3e6e:
MOV RCX,qword ptr [RBP + -0x140]
LEA RDX,[RCX + -0x1]
CMP RDX,0x64
JA 0x001c3ea1
MOV EAX,EAX
ADD R14,RAX
MOV byte ptr [R12],CL
INC R12
MOV RDI,R15
LEA RSI,[RBP + -0x140]
MOV RDX,R14
MOV RCX,R13
CALL RBX
TEST EAX,EAX
JG 0x001c3e6e
LAB_001c3ea1:
MOV RBX,qword ptr [RBP + -0x150]
MOV qword ptr [RBX],R12
LEA R14,[RBP + -0x130]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,qword ptr [RBP + -0x148]
CALL 0x001d3a1c
MOV EAX,dword ptr [R15 + 0x98]
MOV RCX,qword ptr [RBX]
SUB RCX,R14
IMUL RCX,RAX
MOV RAX,qword ptr [RBP + -0x138]
ADD RAX,RCX
MOV qword ptr [RBX],RAX
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001c3f03
ADD RSP,0x128
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001c3f03:
CALL 0x00129250
|
void my_strntod_mb2_or_mb4
(long param_1,long param_2,ulong param_3,long *param_4,int4 *param_5)
{
code *pcVar1;
uint uVar2;
int1 *puVar3;
ulong uVar4;
long lVar5;
long in_FS_OFFSET;
long local_148;
long local_140;
int1 local_138 [256];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
pcVar1 = *(code **)(*(long *)(param_1 + 0xb8) + 0x28);
*param_5 = 0;
uVar4 = 0xff;
if (param_3 < 0xff) {
uVar4 = param_3;
}
local_140 = param_2;
uVar2 = (*pcVar1)(param_1,&local_148,param_2,uVar4 + param_2);
puVar3 = local_138;
lVar5 = local_140;
while ((0 < (int)uVar2 && (local_148 - 1U < 0x65))) {
lVar5 = lVar5 + (ulong)uVar2;
*puVar3 = (char)local_148;
puVar3 = puVar3 + 1;
uVar2 = (*pcVar1)(param_1,&local_148,lVar5,uVar4 + param_2);
}
*param_4 = (long)puVar3;
my_strtod(local_138,param_4,param_5);
*param_4 = local_140 + (*param_4 - (long)local_138) * (ulong)*(uint *)(param_1 + 0x98);
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,407 | js_parse_template_part | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_template_part(JSParseState *s,
const uint8_t *p)
{
const uint8_t *p_next;
uint32_t c;
StringBuffer b_s, *b = &b_s;
/* p points to the first byte of the template part */
if (string_buffer_init(s->ctx, b, 32))
goto fail;
for(;;) {
if (p >= s->buf_end)
goto unexpected_eof;
c = *p++;
if (c == '`') {
/* template end part */
break;
}
if (c == '$' && *p == '{') {
/* template start or middle part */
p++;
break;
}
if (c == '\\') {
if (string_buffer_putc8(b, c))
goto fail;
if (p >= s->buf_end)
goto unexpected_eof;
c = *p++;
}
/* newline sequences are normalized as single '\n' bytes */
if (c == '\r') {
if (*p == '\n')
p++;
c = '\n';
}
if (c == '\n') {
s->line_num++;
s->eol = &p[-1];
s->mark = p;
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p) {
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
}
p = p_next;
}
if (string_buffer_putc(b, c))
goto fail;
}
s->token.val = TOK_TEMPLATE;
s->token.u.str.sep = c;
s->token.u.str.str = string_buffer_end(b);
s->buf_ptr = p;
return 0;
unexpected_eof:
js_parse_error(s, "unexpected end of string");
fail:
string_buffer_free(b);
return -1;
} | O1 | c | js_parse_template_part:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
movq %rdi, 0x8(%rsp)
movsd 0x3f6b6(%rip), %xmm0 # 0x9e780
movups %xmm0, 0x18(%rsp)
movl $0x20, %esi
xorl %edx, %edx
callq 0x20b73
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x5f233
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
cmpq 0x78(%rbx), %r12
jae 0x5f1c3
leaq 0x1(%r12), %r13
movzbl (%r12), %esi
cmpl $0x24, %esi
je 0x5f11b
cmpl $0x5c, %esi
je 0x5f12b
cmpl $0x60, %esi
jne 0x5f153
jmp 0x5f206
cmpb $0x7b, (%r13)
je 0x5f1ff
cmpl $0x5c, %esi
jne 0x5f153
movq %r14, %rdi
movl $0x5c, %esi
callq 0x4b861
testl %eax, %eax
jne 0x5f1d4
cmpq 0x78(%rbx), %r13
jae 0x5f1c3
movzbl 0x1(%r12), %esi
addq $0x2, %r12
movq %r12, %r13
cmpl $0xd, %esi
jne 0x5f16a
xorl %eax, %eax
cmpb $0xa, (%r13)
sete %al
addq %rax, %r13
movl $0xa, %esi
cmpl $0xa, %esi
jne 0x5f18b
incl 0x10(%rbx)
leaq -0x1(%r13), %rax
movq %rax, 0x80(%rbx)
movq %r13, 0x88(%rbx)
movl $0xa, %esi
jmp 0x5f1ae
cmpl $0x80, %esi
jb 0x5f1ae
leaq -0x1(%r13), %rdi
movq %r15, %rsi
callq 0x1b729
movl %eax, %esi
movq 0x28(%rsp), %rax
cmpq %r13, %rax
je 0x5f22a
movq %rax, %r13
movq %r14, %rdi
callq 0x333f0
movq %r13, %r12
testl %eax, %eax
je 0x5f0f3
jmp 0x5f1d4
leaq 0x4166d(%rip), %rsi # 0xa0837
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2fce9
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1cb99
movq $0x0, 0x10(%rsp)
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq $0x2, %r12
movq %r12, %r13
movl $0xffffff82, 0x20(%rbx) # imm = 0xFFFFFF82
movl %esi, 0x48(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x33444
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
movq %r13, 0x70(%rbx)
xorl %eax, %eax
jmp 0x5f1f1
leaq 0x415ef(%rip), %rsi # 0xa0820
jmp 0x5f1ca
movl $0x0, 0x1c(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5f1d4
| js_parse_template_part:
push r15
push r14
push r13
push r12
push rbx
sub rsp, 30h
mov r12, rsi
mov rbx, rdi
mov rdi, [rdi]
mov [rsp+58h+var_50], rdi
movsd xmm0, cs:qword_9E780
movups [rsp+58h+var_40], xmm0
mov esi, 20h ; ' '
xor edx, edx
call js_alloc_string
mov [rsp+58h+var_48], rax
test rax, rax
jz loc_5F233
lea r14, [rsp+58h+var_50]
lea r15, [rsp+58h+var_30]
loc_5F0F3:
cmp r12, [rbx+78h]
jnb loc_5F1C3
lea r13, [r12+1]
movzx esi, byte ptr [r12]
cmp esi, 24h ; '$'
jz short loc_5F11B
cmp esi, 5Ch ; '\'
jz short loc_5F12B
cmp esi, 60h ; '`'
jnz short loc_5F153
jmp loc_5F206
loc_5F11B:
cmp byte ptr [r13+0], 7Bh ; '{'
jz loc_5F1FF
cmp esi, 5Ch ; '\'
jnz short loc_5F153
loc_5F12B:
mov rdi, r14
mov esi, 5Ch ; '\'
call string_buffer_putc8
test eax, eax
jnz loc_5F1D4
cmp r13, [rbx+78h]
jnb short loc_5F1C3
movzx esi, byte ptr [r12+1]
add r12, 2
mov r13, r12
loc_5F153:
cmp esi, 0Dh
jnz short loc_5F16A
xor eax, eax
cmp byte ptr [r13+0], 0Ah
setz al
add r13, rax
mov esi, 0Ah
loc_5F16A:
cmp esi, 0Ah
jnz short loc_5F18B
inc dword ptr [rbx+10h]
lea rax, [r13-1]
mov [rbx+80h], rax
mov [rbx+88h], r13
mov esi, 0Ah
jmp short loc_5F1AE
loc_5F18B:
cmp esi, 80h
jb short loc_5F1AE
lea rdi, [r13-1]
mov rsi, r15
call utf8_decode
mov esi, eax
mov rax, [rsp+58h+var_30]
cmp rax, r13
jz short loc_5F22A
mov r13, rax
loc_5F1AE:
mov rdi, r14
call string_buffer_putc
mov r12, r13
test eax, eax
jz loc_5F0F3
jmp short loc_5F1D4
loc_5F1C3:
lea rsi, aUnexpectedEndO_1; "unexpected end of string"
loc_5F1CA:
mov rdi, rbx
xor eax, eax
call js_parse_error
loc_5F1D4:
mov rdi, [rsp+58h+var_50]
mov rsi, [rsp+58h+var_48]
call js_free
mov [rsp+58h+var_48], 0
mov eax, 0FFFFFFFFh
loc_5F1F1:
add rsp, 30h
pop rbx
pop r12
pop r13
pop r14
pop r15
retn
loc_5F1FF:
add r12, 2
mov r13, r12
loc_5F206:
mov dword ptr [rbx+20h], 0FFFFFF82h
mov [rbx+48h], esi
lea rdi, [rsp+58h+var_50]
call string_buffer_end
mov [rbx+38h], rax
mov [rbx+40h], rdx
mov [rbx+70h], r13
xor eax, eax
jmp short loc_5F1F1
loc_5F22A:
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
jmp short loc_5F1CA
loc_5F233:
mov dword ptr [rsp+58h+var_40+4], 0
mov dword ptr [rsp+58h+var_40+0Ch], 0FFFFFFFFh
jmp short loc_5F1D4
| long long js_parse_template_part(
long long a1,
char *a2,
double a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
char *v17; // r13
unsigned int v18; // esi
const char *v19; // rsi
long long v21; // rdx
char v22; // [rsp+0h] [rbp-58h]
long long v23; // [rsp+8h] [rbp-50h] BYREF
long long v24; // [rsp+10h] [rbp-48h]
__int128 v25; // [rsp+18h] [rbp-40h]
char *v26; // [rsp+28h] [rbp-30h] BYREF
v23 = *(_QWORD *)a1;
v25 = 0x2000000000uLL;
v24 = js_alloc_string(v23, 32LL, 0);
if ( !v24 )
{
DWORD1(v25) = 0;
HIDWORD(v25) = -1;
LABEL_23:
js_free(v23, v24);
v24 = 0LL;
return 0xFFFFFFFFLL;
}
while ( 1 )
{
if ( (unsigned long long)a2 >= *(_QWORD *)(a1 + 120) )
{
LABEL_21:
v19 = "unexpected end of string";
LABEL_22:
js_parse_error(
(long long *)a1,
(long long)v19,
v11,
v12,
v13,
v14,
(__m128)0x2000000000uLL,
a4,
a5,
a6,
v15,
v16,
a9,
a10,
v22);
goto LABEL_23;
}
v17 = a2 + 1;
v18 = (unsigned __int8)*a2;
if ( v18 == 36 )
break;
if ( v18 == 92 )
{
if ( (unsigned int)string_buffer_putc8(
(long long)&v23,
0x5Cu,
(__m128)0x2000000000uLL,
a4,
a5,
a6,
v15,
v16,
a9,
a10,
v11,
v12,
v13,
v14) )
goto LABEL_23;
if ( (unsigned long long)v17 >= *(_QWORD *)(a1 + 120) )
goto LABEL_21;
v18 = (unsigned __int8)a2[1];
v17 = a2 + 2;
}
else if ( v18 == 96 )
{
goto LABEL_25;
}
LABEL_12:
if ( v18 == 13 )
{
v17 += *v17 == 10;
v18 = 10;
}
if ( v18 == 10 )
{
++*(_DWORD *)(a1 + 16);
*(_QWORD *)(a1 + 128) = v17 - 1;
*(_QWORD *)(a1 + 136) = v17;
v18 = 10;
}
else if ( v18 >= 0x80 )
{
v18 = utf8_decode(v17 - 1, &v26);
if ( v26 == v17 )
{
v19 = "invalid UTF-8 sequence";
goto LABEL_22;
}
v17 = v26;
}
a2 = v17;
if ( (unsigned int)string_buffer_putc((long long)&v23, v18) )
goto LABEL_23;
}
if ( *v17 != 123 )
goto LABEL_12;
v17 = a2 + 2;
LABEL_25:
*(_DWORD *)(a1 + 32) = -126;
*(_DWORD *)(a1 + 72) = v18;
*(_QWORD *)(a1 + 56) = string_buffer_end((long long)&v23);
*(_QWORD *)(a1 + 64) = v21;
*(_QWORD *)(a1 + 112) = v17;
return 0LL;
}
| js_parse_template_part:
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV R12,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
MOV qword ptr [RSP + 0x8],RDI
MOVSD XMM0,qword ptr [0x0019e780]
MOVUPS xmmword ptr [RSP + 0x18],XMM0
MOV ESI,0x20
XOR EDX,EDX
CALL 0x00120b73
MOV qword ptr [RSP + 0x10],RAX
TEST RAX,RAX
JZ 0x0015f233
LEA R14,[RSP + 0x8]
LEA R15,[RSP + 0x28]
LAB_0015f0f3:
CMP R12,qword ptr [RBX + 0x78]
JNC 0x0015f1c3
LEA R13,[R12 + 0x1]
MOVZX ESI,byte ptr [R12]
CMP ESI,0x24
JZ 0x0015f11b
CMP ESI,0x5c
JZ 0x0015f12b
CMP ESI,0x60
JNZ 0x0015f153
JMP 0x0015f206
LAB_0015f11b:
CMP byte ptr [R13],0x7b
JZ 0x0015f1ff
CMP ESI,0x5c
JNZ 0x0015f153
LAB_0015f12b:
MOV RDI,R14
MOV ESI,0x5c
CALL 0x0014b861
TEST EAX,EAX
JNZ 0x0015f1d4
CMP R13,qword ptr [RBX + 0x78]
JNC 0x0015f1c3
MOVZX ESI,byte ptr [R12 + 0x1]
ADD R12,0x2
MOV R13,R12
LAB_0015f153:
CMP ESI,0xd
JNZ 0x0015f16a
XOR EAX,EAX
CMP byte ptr [R13],0xa
SETZ AL
ADD R13,RAX
MOV ESI,0xa
LAB_0015f16a:
CMP ESI,0xa
JNZ 0x0015f18b
INC dword ptr [RBX + 0x10]
LEA RAX,[R13 + -0x1]
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0x88],R13
MOV ESI,0xa
JMP 0x0015f1ae
LAB_0015f18b:
CMP ESI,0x80
JC 0x0015f1ae
LEA RDI,[R13 + -0x1]
MOV RSI,R15
CALL 0x0011b729
MOV ESI,EAX
MOV RAX,qword ptr [RSP + 0x28]
CMP RAX,R13
JZ 0x0015f22a
MOV R13,RAX
LAB_0015f1ae:
MOV RDI,R14
CALL 0x001333f0
MOV R12,R13
TEST EAX,EAX
JZ 0x0015f0f3
JMP 0x0015f1d4
LAB_0015f1c3:
LEA RSI,[0x1a0837]
LAB_0015f1ca:
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012fce9
LAB_0015f1d4:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP + 0x10]
CALL 0x0011cb99
MOV qword ptr [RSP + 0x10],0x0
MOV EAX,0xffffffff
LAB_0015f1f1:
ADD RSP,0x30
POP RBX
POP R12
POP R13
POP R14
POP R15
RET
LAB_0015f1ff:
ADD R12,0x2
MOV R13,R12
LAB_0015f206:
MOV dword ptr [RBX + 0x20],0xffffff82
MOV dword ptr [RBX + 0x48],ESI
LEA RDI,[RSP + 0x8]
CALL 0x00133444
MOV qword ptr [RBX + 0x38],RAX
MOV qword ptr [RBX + 0x40],RDX
MOV qword ptr [RBX + 0x70],R13
XOR EAX,EAX
JMP 0x0015f1f1
LAB_0015f22a:
LEA RSI,[0x1a0820]
JMP 0x0015f1ca
LAB_0015f233:
MOV dword ptr [RSP + 0x1c],0x0
MOV dword ptr [RSP + 0x24],0xffffffff
JMP 0x0015f1d4
|
int8 js_parse_template_part(int8 *param_1,byte *param_2)
{
byte bVar1;
uint uVar2;
int iVar3;
uint uVar4;
char *pcVar5;
byte *pbVar6;
bool bVar7;
int1 auVar8 [16];
int8 local_50;
long local_48;
ulong local_40;
int8 uStack_38;
byte *local_30;
local_50 = *param_1;
local_40 = DAT_0019e780;
uStack_38 = 0;
local_48 = js_alloc_string(local_50,0x20,0);
if (local_48 == 0) {
local_40 = local_40 & 0xffffffff;
uStack_38 = CONCAT44(0xffffffff,(int4)uStack_38);
}
else {
do {
if ((byte *)param_1[0xf] <= param_2) {
LAB_0015f1c3:
pcVar5 = "unexpected end of string";
LAB_0015f1ca:
js_parse_error(param_1,pcVar5);
break;
}
pbVar6 = param_2 + 1;
bVar1 = *param_2;
uVar2 = (uint)bVar1;
uVar4 = (uint)bVar1;
if (bVar1 == 0x24) {
if (*pbVar6 == 0x7b) {
pbVar6 = param_2 + 2;
LAB_0015f206:
*(int4 *)(param_1 + 4) = 0xffffff82;
*(uint *)(param_1 + 9) = uVar4;
auVar8 = string_buffer_end(&local_50);
*(int1 (*) [16])(param_1 + 7) = auVar8;
param_1[0xe] = pbVar6;
return 0;
}
}
else if (uVar4 == 0x5c) {
iVar3 = string_buffer_putc8(&local_50,0x5c);
if (iVar3 != 0) break;
if ((byte *)param_1[0xf] <= pbVar6) goto LAB_0015f1c3;
uVar2 = (uint)param_2[1];
pbVar6 = param_2 + 2;
}
else if (uVar4 == 0x60) goto LAB_0015f206;
param_2 = pbVar6;
if (uVar2 == 0xd) {
param_2 = pbVar6 + (*pbVar6 == 10);
uVar2 = 10;
}
if (uVar2 == 10) {
*(int *)(param_1 + 2) = *(int *)(param_1 + 2) + 1;
param_1[0x10] = param_2 + -1;
param_1[0x11] = param_2;
uVar2 = 10;
}
else if ((0x7f < uVar2) &&
(uVar2 = utf8_decode(param_2 + -1,&local_30), bVar7 = local_30 == param_2,
param_2 = local_30, bVar7)) {
pcVar5 = "invalid UTF-8 sequence";
goto LAB_0015f1ca;
}
iVar3 = string_buffer_putc(&local_50,uVar2);
} while (iVar3 == 0);
}
js_free(local_50,local_48);
return 0xffffffff;
}
| |
43,408 | js_parse_template_part | bluesky950520[P]quickjs/quickjs.c | static __exception int js_parse_template_part(JSParseState *s,
const uint8_t *p)
{
const uint8_t *p_next;
uint32_t c;
StringBuffer b_s, *b = &b_s;
/* p points to the first byte of the template part */
if (string_buffer_init(s->ctx, b, 32))
goto fail;
for(;;) {
if (p >= s->buf_end)
goto unexpected_eof;
c = *p++;
if (c == '`') {
/* template end part */
break;
}
if (c == '$' && *p == '{') {
/* template start or middle part */
p++;
break;
}
if (c == '\\') {
if (string_buffer_putc8(b, c))
goto fail;
if (p >= s->buf_end)
goto unexpected_eof;
c = *p++;
}
/* newline sequences are normalized as single '\n' bytes */
if (c == '\r') {
if (*p == '\n')
p++;
c = '\n';
}
if (c == '\n') {
s->line_num++;
s->eol = &p[-1];
s->mark = p;
} else if (c >= 0x80) {
c = utf8_decode(p - 1, &p_next);
if (p_next == p) {
js_parse_error(s, "invalid UTF-8 sequence");
goto fail;
}
p = p_next;
}
if (string_buffer_putc(b, c))
goto fail;
}
s->token.val = TOK_TEMPLATE;
s->token.u.str.sep = c;
s->token.u.str.str = string_buffer_end(b);
s->buf_ptr = p;
return 0;
unexpected_eof:
js_parse_error(s, "unexpected end of string");
fail:
string_buffer_free(b);
return -1;
} | O2 | c | js_parse_template_part:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x20
popq %rdx
callq 0x2e042
testl %eax, %eax
jne 0x5149c
leaq 0x8(%rsp), %r15
pushq $0x5c
popq %rbp
pushq $0xa
popq %r14
cmpq 0x78(%rbx), %r13
jae 0x5148b
leaq 0x1(%r13), %r12
movzbl (%r13), %eax
cmpl $0x24, %eax
je 0x51448
cmpl $0x5c, %eax
je 0x513ef
cmpl $0x60, %eax
je 0x514bf
movq %r12, %r13
jmp 0x51414
movq %r15, %rdi
movl %ebp, %esi
callq 0x41425
testl %eax, %eax
jne 0x5149c
cmpq 0x78(%rbx), %r12
jae 0x5148b
movzbl 0x1(%r13), %eax
addq $0x2, %r13
cmpl $0xa, %eax
je 0x5142b
cmpl $0xd, %eax
jne 0x51454
xorl %eax, %eax
cmpb $0xa, (%r13)
sete %al
addq %rax, %r13
incl 0x10(%rbx)
leaq -0x1(%r13), %rax
movq %rax, 0x80(%rbx)
movq %r13, 0x88(%rbx)
movl %r14d, %esi
movq %r13, %r12
jmp 0x51472
cmpb $0x7b, (%r12)
pushq $0x24
popq %rsi
jne 0x51472
jmp 0x514b8
cmpl $0x80, %eax
jb 0x51487
leaq -0x1(%r13), %rdi
movq %rsp, %rsi
callq 0x15f80
movq (%rsp), %r12
cmpq %r13, %r12
je 0x514e3
movl %eax, %esi
movq %r15, %rdi
callq 0x2ca82
movq %r12, %r13
testl %eax, %eax
je 0x513c4
jmp 0x5149c
movl %eax, %esi
jmp 0x51443
leaq 0x362df(%rip), %rsi # 0x87771
movq %rbx, %rdi
xorl %eax, %eax
callq 0x28457
leaq 0x8(%rsp), %rdi
callq 0x2ef01
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x2, %r13
movq %r13, %r12
movl $0xffffff82, 0x20(%rbx) # imm = 0xFFFFFF82
movl %eax, 0x48(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x2cad4
movq %rax, 0x38(%rbx)
movq %rdx, 0x40(%rbx)
movq %r12, 0x70(%rbx)
xorl %eax, %eax
jmp 0x514a9
leaq 0x36270(%rip), %rsi # 0x8775a
jmp 0x51492
| js_parse_template_part:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 28h
mov r13, rsi
mov rbx, rdi
mov rdi, [rdi]
lea rsi, [rsp+58h+var_50]
push 20h ; ' '
pop rdx
call string_buffer_init
test eax, eax
jnz loc_5149C
lea r15, [rsp+58h+var_50]
push 5Ch ; '\'
pop rbp
push 0Ah
pop r14
loc_513C4:
cmp r13, [rbx+78h]
jnb loc_5148B
lea r12, [r13+1]
movzx eax, byte ptr [r13+0]
cmp eax, 24h ; '$'
jz short loc_51448
cmp eax, 5Ch ; '\'
jz short loc_513EF
cmp eax, 60h ; '`'
jz loc_514BF
mov r13, r12
jmp short loc_51414
loc_513EF:
mov rdi, r15
mov esi, ebp
call string_buffer_putc8
test eax, eax
jnz loc_5149C
cmp r12, [rbx+78h]
jnb loc_5148B
movzx eax, byte ptr [r13+1]
add r13, 2
loc_51414:
cmp eax, 0Ah
jz short loc_5142B
cmp eax, 0Dh
jnz short loc_51454
xor eax, eax
cmp byte ptr [r13+0], 0Ah
setz al
add r13, rax
loc_5142B:
inc dword ptr [rbx+10h]
lea rax, [r13-1]
mov [rbx+80h], rax
mov [rbx+88h], r13
mov esi, r14d
loc_51443:
mov r12, r13
jmp short loc_51472
loc_51448:
cmp byte ptr [r12], 7Bh ; '{'
push 24h ; '$'
pop rsi
jnz short loc_51472
jmp short loc_514B8
loc_51454:
cmp eax, 80h
jb short loc_51487
lea rdi, [r13-1]
mov rsi, rsp
call utf8_decode
mov r12, [rsp+58h+var_58]
cmp r12, r13
jz short loc_514E3
mov esi, eax
loc_51472:
mov rdi, r15
call string_buffer_putc
mov r13, r12
test eax, eax
jz loc_513C4
jmp short loc_5149C
loc_51487:
mov esi, eax
jmp short loc_51443
loc_5148B:
lea rsi, aUnexpectedEndO_1; "unexpected end of string"
loc_51492:
mov rdi, rbx
xor eax, eax
call js_parse_error
loc_5149C:
lea rdi, [rsp+58h+var_50]
call string_buffer_free
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_514A9:
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_514B8:
add r13, 2
mov r12, r13
loc_514BF:
mov dword ptr [rbx+20h], 0FFFFFF82h
mov [rbx+48h], eax
lea rdi, [rsp+58h+var_50]
call string_buffer_end
mov [rbx+38h], rax
mov [rbx+40h], rdx
mov [rbx+70h], r12
xor eax, eax
jmp short loc_514A9
loc_514E3:
lea rsi, aInvalidUtf8Seq; "invalid UTF-8 sequence"
jmp short loc_51492
| long long js_parse_template_part(
long long a1,
char *a2,
__m128 a3,
__m128 a4,
__m128 a5,
__m128 a6,
double a7,
double a8,
__m128 a9,
__m128 a10)
{
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
long long v14; // r9
__m128 v15; // xmm4
__m128 v16; // xmm5
char *v17; // r12
unsigned int v18; // eax
char *v19; // r13
unsigned int v20; // esi
unsigned int v21; // eax
const char *v22; // rsi
long long v24; // rdx
char *v25; // [rsp+0h] [rbp-58h] BYREF
long long v26[10]; // [rsp+8h] [rbp-50h] BYREF
if ( (unsigned int)string_buffer_init(*(_QWORD *)a1, (long long)v26, 0x20u) )
{
LABEL_25:
string_buffer_free(v26);
return -1LL;
}
while ( 1 )
{
if ( (unsigned long long)a2 >= *(_QWORD *)(a1 + 120) )
{
LABEL_23:
v22 = "unexpected end of string";
LABEL_24:
js_parse_error((long long *)a1, (long long)v22, v11, v12, v13, v14, a3, a4, a5, a6, v15, v16, a9, a10, (char)v25);
goto LABEL_25;
}
v17 = a2 + 1;
v18 = (unsigned __int8)*a2;
if ( v18 == 36 )
break;
switch ( v18 )
{
case 0x5Cu:
if ( (unsigned int)string_buffer_putc8(
(long long)v26,
0x5Cu,
a3,
a4,
a5,
a6,
v15,
v16,
a9,
a10,
v11,
v12,
v13,
v14) )
goto LABEL_25;
if ( (unsigned long long)v17 >= *(_QWORD *)(a1 + 120) )
goto LABEL_23;
v18 = (unsigned __int8)a2[1];
v19 = a2 + 2;
break;
case 0x60u:
goto LABEL_26;
case 0xAu:
goto LABEL_13;
case 0xDu:
v19 += *v19 == 10;
LABEL_13:
++*(_DWORD *)(a1 + 16);
*(_QWORD *)(a1 + 128) = v19 - 1;
*(_QWORD *)(a1 + 136) = v19;
v20 = 10;
LABEL_14:
v17 = v19;
goto LABEL_20;
default:
v19 = a2 + 1;
break;
}
if ( v18 < 0x80 )
{
v20 = v18;
goto LABEL_14;
}
v21 = utf8_decode(v19 - 1, &v25);
v17 = v25;
if ( v25 == v19 )
{
v22 = "invalid UTF-8 sequence";
goto LABEL_24;
}
v20 = v21;
LABEL_20:
a2 = v17;
if ( (unsigned int)string_buffer_putc((long long)v26, v20) )
goto LABEL_25;
}
v20 = 36;
if ( *v17 != 123 )
goto LABEL_20;
v17 = a2 + 2;
LABEL_26:
*(_DWORD *)(a1 + 32) = -126;
*(_DWORD *)(a1 + 72) = v18;
*(_QWORD *)(a1 + 56) = string_buffer_end(v26);
*(_QWORD *)(a1 + 64) = v24;
*(_QWORD *)(a1 + 112) = v17;
return 0LL;
}
| js_parse_template_part:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV R13,RSI
MOV RBX,RDI
MOV RDI,qword ptr [RDI]
LEA RSI,[RSP + 0x8]
PUSH 0x20
POP RDX
CALL 0x0012e042
TEST EAX,EAX
JNZ 0x0015149c
LEA R15,[RSP + 0x8]
PUSH 0x5c
POP RBP
PUSH 0xa
POP R14
LAB_001513c4:
CMP R13,qword ptr [RBX + 0x78]
JNC 0x0015148b
LEA R12,[R13 + 0x1]
MOVZX EAX,byte ptr [R13]
CMP EAX,0x24
JZ 0x00151448
CMP EAX,0x5c
JZ 0x001513ef
CMP EAX,0x60
JZ 0x001514bf
MOV R13,R12
JMP 0x00151414
LAB_001513ef:
MOV RDI,R15
MOV ESI,EBP
CALL 0x00141425
TEST EAX,EAX
JNZ 0x0015149c
CMP R12,qword ptr [RBX + 0x78]
JNC 0x0015148b
MOVZX EAX,byte ptr [R13 + 0x1]
ADD R13,0x2
LAB_00151414:
CMP EAX,0xa
JZ 0x0015142b
CMP EAX,0xd
JNZ 0x00151454
XOR EAX,EAX
CMP byte ptr [R13],0xa
SETZ AL
ADD R13,RAX
LAB_0015142b:
INC dword ptr [RBX + 0x10]
LEA RAX,[R13 + -0x1]
MOV qword ptr [RBX + 0x80],RAX
MOV qword ptr [RBX + 0x88],R13
MOV ESI,R14D
LAB_00151443:
MOV R12,R13
JMP 0x00151472
LAB_00151448:
CMP byte ptr [R12],0x7b
PUSH 0x24
POP RSI
JNZ 0x00151472
JMP 0x001514b8
LAB_00151454:
CMP EAX,0x80
JC 0x00151487
LEA RDI,[R13 + -0x1]
MOV RSI,RSP
CALL 0x00115f80
MOV R12,qword ptr [RSP]
CMP R12,R13
JZ 0x001514e3
MOV ESI,EAX
LAB_00151472:
MOV RDI,R15
CALL 0x0012ca82
MOV R13,R12
TEST EAX,EAX
JZ 0x001513c4
JMP 0x0015149c
LAB_00151487:
MOV ESI,EAX
JMP 0x00151443
LAB_0015148b:
LEA RSI,[0x187771]
LAB_00151492:
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00128457
LAB_0015149c:
LEA RDI,[RSP + 0x8]
CALL 0x0012ef01
PUSH -0x1
POP RAX
LAB_001514a9:
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001514b8:
ADD R13,0x2
MOV R12,R13
LAB_001514bf:
MOV dword ptr [RBX + 0x20],0xffffff82
MOV dword ptr [RBX + 0x48],EAX
LEA RDI,[RSP + 0x8]
CALL 0x0012cad4
MOV qword ptr [RBX + 0x38],RAX
MOV qword ptr [RBX + 0x40],RDX
MOV qword ptr [RBX + 0x70],R12
XOR EAX,EAX
JMP 0x001514a9
LAB_001514e3:
LEA RSI,[0x18775a]
JMP 0x00151492
|
int8 js_parse_template_part(int8 *param_1,byte *param_2)
{
byte bVar1;
int iVar2;
uint uVar3;
char *pcVar4;
byte *pbVar5;
bool bVar6;
int1 auVar7 [16];
byte *local_58;
int1 local_50 [32];
iVar2 = string_buffer_init(*param_1,local_50,0x20);
if (iVar2 == 0) {
do {
if ((byte *)param_1[0xf] <= param_2) {
LAB_0015148b:
pcVar4 = "unexpected end of string";
LAB_00151492:
js_parse_error(param_1,pcVar4);
break;
}
pbVar5 = param_2 + 1;
bVar1 = *param_2;
if (bVar1 == 0x24) {
uVar3 = 0x24;
if (*pbVar5 == 0x7b) {
pbVar5 = param_2 + 2;
LAB_001514bf:
*(int4 *)(param_1 + 4) = 0xffffff82;
*(uint *)(param_1 + 9) = (uint)bVar1;
auVar7 = string_buffer_end(local_50);
*(int1 (*) [16])(param_1 + 7) = auVar7;
param_1[0xe] = pbVar5;
return 0;
}
}
else {
if (bVar1 == 0x5c) {
iVar2 = string_buffer_putc8(local_50,0x5c);
if (iVar2 != 0) break;
if ((byte *)param_1[0xf] <= pbVar5) goto LAB_0015148b;
bVar1 = param_2[1];
pbVar5 = param_2 + 2;
}
else if (bVar1 == 0x60) goto LAB_001514bf;
uVar3 = (uint)bVar1;
if (uVar3 != 10) {
if (uVar3 != 0xd) {
if ((0x7f < uVar3) &&
(uVar3 = utf8_decode(pbVar5 + -1,&local_58), bVar6 = local_58 == pbVar5,
pbVar5 = local_58, bVar6)) {
pcVar4 = "invalid UTF-8 sequence";
goto LAB_00151492;
}
goto LAB_00151472;
}
pbVar5 = pbVar5 + (*pbVar5 == 10);
}
*(int *)(param_1 + 2) = *(int *)(param_1 + 2) + 1;
param_1[0x10] = pbVar5 + -1;
param_1[0x11] = pbVar5;
uVar3 = 10;
}
LAB_00151472:
iVar2 = string_buffer_putc(local_50,uVar3);
param_2 = pbVar5;
} while (iVar2 == 0);
}
string_buffer_free(local_50);
return 0xffffffffffffffff;
}
| |
43,409 | my_fill_utf8mb3 | eloqsql/strings/ctype-utf8.c | static void
my_fill_utf8mb3(CHARSET_INFO *cs, char *str, size_t length, int fill)
{
if (fill < 0x80)
my_fill_8bit(cs, str, length, fill);
else
my_fill_utf8mb3_mb(cs, str, length, fill);
} | O3 | c | my_fill_utf8mb3:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
cmpl $0x7f, %ecx
jg 0x8702d
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x870b1
movq %rbx, %rsi
movq %r15, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x710f3
leaq (%rbx,%r15), %r14
movq 0xb8(%rdi), %rax
movl %ecx, %esi
leaq -0x30(%rbp), %rcx
leaq -0x3a(%rbp), %rdx
callq *0xd8(%rax)
movsbq %al, %r12
cmpq %r15, %r12
jle 0x87056
movq %rbx, %r13
jmp 0x8707b
movsbq %al, %r15
movq %rbx, %r13
movq %rbx, %rdi
leaq -0x3a(%rbp), %rsi
movq %r15, %rdx
callq 0x282c0
addq %r12, %rbx
addq %r12, %r13
leaq (%rbx,%r12), %rax
cmpq %r14, %rax
jbe 0x8705d
cmpq %r14, %rbx
jae 0x87093
subq %r13, %r14
movq %rbx, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x281d0
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x870b1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x28400
| my_fill_utf8mb3:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r15, rdx
mov rbx, rsi
mov rax, fs:28h
mov [rbp+var_30], rax
cmp ecx, 7Fh
jg short loc_8702D
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_870B1
mov rsi, rbx
mov rdx, r15
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp my_fill_8bit
loc_8702D:
lea r14, [rbx+r15]
mov rax, [rdi+0B8h]
mov esi, ecx
lea rcx, [rbp+var_30]
lea rdx, [rbp+var_3A]
call qword ptr [rax+0D8h]
movsx r12, al
cmp r12, r15
jle short loc_87056
mov r13, rbx
jmp short loc_8707B
loc_87056:
movsx r15, al
mov r13, rbx
loc_8705D:
mov rdi, rbx
lea rsi, [rbp+var_3A]
mov rdx, r15
call _memcpy
add rbx, r12
add r13, r12
lea rax, [rbx+r12]
cmp rax, r14
jbe short loc_8705D
loc_8707B:
cmp rbx, r14
jnb short loc_87093
sub r14, r13
mov rdi, rbx
mov esi, 20h ; ' '
mov rdx, r14
call _memset
loc_87093:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz short loc_870B1
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_870B1:
call ___stack_chk_fail
| long long my_fill_utf8mb3(long long a1, long long a2, long long a3, signed int a4)
{
unsigned long long v5; // rbx
unsigned long long v7; // r14
char v8; // al
long long v9; // r12
long long v10; // r13
long long v11; // r15
_BYTE v12[10]; // [rsp+6h] [rbp-3Ah] BYREF
unsigned long long v13[6]; // [rsp+10h] [rbp-30h] BYREF
v5 = a2;
v13[0] = __readfsqword(0x28u);
if ( a4 <= 127 )
return my_fill_8bit(a1, a2, a3, a4);
v7 = a2 + a3;
v8 = (*(long long ( **)(long long, _QWORD, _BYTE *, unsigned long long *))(*(_QWORD *)(a1 + 184) + 216LL))(
a1,
(unsigned int)a4,
v12,
v13);
v9 = v8;
if ( v8 <= a3 )
{
v11 = v8;
v10 = a2;
do
{
memcpy(v5, v12, v11);
v5 += v9;
v10 += v9;
}
while ( v5 + v9 <= v7 );
}
else
{
v10 = a2;
}
if ( v5 < v7 )
memset(v5, 32LL, v7 - v10);
return __readfsqword(0x28u);
}
| my_fill_utf8mb3:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R15,RDX
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
CMP ECX,0x7f
JG 0x0018702d
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001870b1
MOV RSI,RBX
MOV RDX,R15
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x001710f3
LAB_0018702d:
LEA R14,[RBX + R15*0x1]
MOV RAX,qword ptr [RDI + 0xb8]
MOV ESI,ECX
LEA RCX,[RBP + -0x30]
LEA RDX,[RBP + -0x3a]
CALL qword ptr [RAX + 0xd8]
MOVSX R12,AL
CMP R12,R15
JLE 0x00187056
MOV R13,RBX
JMP 0x0018707b
LAB_00187056:
MOVSX R15,AL
MOV R13,RBX
LAB_0018705d:
MOV RDI,RBX
LEA RSI,[RBP + -0x3a]
MOV RDX,R15
CALL 0x001282c0
ADD RBX,R12
ADD R13,R12
LEA RAX,[RBX + R12*0x1]
CMP RAX,R14
JBE 0x0018705d
LAB_0018707b:
CMP RBX,R14
JNC 0x00187093
SUB R14,R13
MOV RDI,RBX
MOV ESI,0x20
MOV RDX,R14
CALL 0x001281d0
LAB_00187093:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x001870b1
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001870b1:
CALL 0x00128400
|
void my_fill_utf8mb3(long param_1,void *param_2,long param_3,int param_4)
{
void *pvVar1;
char cVar2;
long lVar3;
void *pvVar4;
long in_FS_OFFSET;
int1 local_42 [10];
long local_38;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
if (param_4 < 0x80) {
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
my_fill_8bit(param_1,param_2,param_3);
return;
}
}
else {
pvVar1 = (void *)((long)param_2 + param_3);
cVar2 = (**(code **)(*(long *)(param_1 + 0xb8) + 0xd8))(param_1,param_4,local_42,&local_38);
lVar3 = (long)cVar2;
pvVar4 = param_2;
if (lVar3 <= param_3) {
do {
memcpy(param_2,local_42,(long)cVar2);
param_2 = (void *)((long)param_2 + lVar3);
pvVar4 = (void *)((long)pvVar4 + lVar3);
} while ((void *)((long)param_2 + lVar3) <= pvVar1);
}
if (param_2 < pvVar1) {
memset(param_2,0x20,(long)pvVar1 - (long)pvVar4);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return;
}
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,410 | ftxui::Container::Horizontal(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>) | Andrewchistyakov[P]flashcards_lyc/build_O3/_deps/ftxui-src/src/ftxui/component/container.cpp | Component Horizontal(Components children) {
return Horizontal(std::move(children), nullptr);
} | O3 | cpp | ftxui::Container::Horizontal(std::vector<std::shared_ptr<ftxui::ComponentBase>, std::allocator<std::shared_ptr<ftxui::ComponentBase>>>):
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
leaq 0x20(%rsp), %rcx
movaps %xmm0, (%rcx)
movq 0x10(%rsi), %rax
movq %rax, 0x10(%rcx)
xorl %eax, %eax
movq %rax, 0x10(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
leaq 0x38(%rsp), %r8
movq %rax, (%r8)
leaq 0x18(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x28384
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x149b2
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x149b2
movq %rbx, %rdi
callq 0xb780
| _ZN5ftxui9Container10HorizontalESt6vectorISt10shared_ptrINS_13ComponentBaseEESaIS4_EE:
push rbx
sub rsp, 40h
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
lea rcx, [rsp+48h+var_28]
movaps xmmword ptr [rcx], xmm0
mov rax, [rsi+10h]
mov [rcx+10h], rax
xor eax, eax
mov [rsi+10h], rax
xorps xmm0, xmm0
movups xmmword ptr [rsi], xmm0
lea r8, [rsp+48h+var_10]
mov [r8], rax
lea rdi, [rsp+48h+var_38+8]
mov [rdi-8], rax
lea rsi, [rsp+48h+var_38]
lea rdx, [rsp+48h+var_39]
call _ZNSt14__shared_countILN9__gnu_cxx12_Lock_policyE2EEC2IN5ftxui19HorizontalContainerESaIS5_EJSt6vectorISt10shared_ptrINS4_13ComponentBaseEESaISA_EERPiEEERPT_St20_Sp_alloc_shared_tagIT0_EDpOT1_; std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<ftxui::HorizontalContainer,std::allocator<ftxui::HorizontalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&>(ftxui::HorizontalContainer *&,std::_Sp_alloc_shared_tag<std::allocator<ftxui::HorizontalContainer>>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&)
movaps xmm0, [rsp+48h+var_38]
movups xmmword ptr [rbx], xmm0
lea rdi, [rsp+48h+var_28]
call _ZNSt6vectorISt10shared_ptrIN5ftxui13ComponentBaseEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::ComponentBase>>::~vector()
mov rax, rbx
add rsp, 40h
pop rbx
retn
mov rbx, rax
lea rdi, [rsp+arg_18]
call _ZNSt6vectorISt10shared_ptrIN5ftxui13ComponentBaseEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::ComponentBase>>::~vector()
mov rdi, rbx
call __Unwind_Resume
| _OWORD * ftxui::Container::Horizontal(_OWORD *a1, __int128 *a2)
{
char v3; // [rsp+Fh] [rbp-39h] BYREF
__int128 v4; // [rsp+10h] [rbp-38h] BYREF
__int128 v5; // [rsp+20h] [rbp-28h] BYREF
long long v6; // [rsp+30h] [rbp-18h]
long long v7; // [rsp+38h] [rbp-10h] BYREF
v5 = *a2;
v6 = *((_QWORD *)a2 + 2);
*((_QWORD *)a2 + 2) = 0LL;
*a2 = 0LL;
v7 = 0LL;
*(_QWORD *)&v4 = 0LL;
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::__shared_count<ftxui::HorizontalContainer,std::allocator<ftxui::HorizontalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>>,int *&>(
(char *)&v4 + 8,
&v4,
&v3,
&v5,
&v7);
*a1 = v4;
std::vector<std::shared_ptr<ftxui::ComponentBase>>::~vector((long long)&v5);
return a1;
}
| Horizontal:
PUSH RBX
SUB RSP,0x40
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
LEA RCX,[RSP + 0x20]
MOVAPS xmmword ptr [RCX],XMM0
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RCX + 0x10],RAX
XOR EAX,EAX
MOV qword ptr [RSI + 0x10],RAX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RSI],XMM0
LEA R8,[RSP + 0x38]
MOV qword ptr [R8],RAX
LEA RDI,[RSP + 0x18]
MOV qword ptr [RDI + -0x8],RAX
LAB_00127599:
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0xf]
CALL 0x00128384
LAB_001275a8:
MOVAPS XMM0,xmmword ptr [RSP + 0x10]
MOVUPS xmmword ptr [RBX],XMM0
LEA RDI,[RSP + 0x20]
CALL 0x001149b2
MOV RAX,RBX
ADD RSP,0x40
POP RBX
RET
|
/* ftxui::Container::Horizontal(std::vector<std::shared_ptr<ftxui::ComponentBase>,
std::allocator<std::shared_ptr<ftxui::ComponentBase> > >) */
Container * __thiscall ftxui::Container::Horizontal(Container *this,int8 *param_2)
{
int1 local_39;
int8 local_38;
int8 uStack_30;
int8 local_28;
int8 uStack_20;
int8 local_18;
int8 local_10;
local_28 = *param_2;
uStack_20 = param_2[1];
local_18 = param_2[2];
param_2[2] = 0;
*param_2 = 0;
param_2[1] = 0;
local_10 = 0;
local_38 = 0;
/* try { // try from 00127599 to 001275a7 has its CatchHandler @ 001275c3 */
std::__shared_count<(__gnu_cxx::_Lock_policy)2>::
__shared_count<ftxui::HorizontalContainer,std::allocator<ftxui::HorizontalContainer>,std::vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>,int*&>
((__shared_count<(__gnu_cxx::_Lock_policy)2> *)&uStack_30,&local_38,&local_39);
*(int8 *)this = local_38;
*(int8 *)(this + 8) = uStack_30;
std::
vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
::~vector((vector<std::shared_ptr<ftxui::ComponentBase>,std::allocator<std::shared_ptr<ftxui::ComponentBase>>>
*)&local_28);
return this;
}
| |
43,411 | js_date_Symbol_toPrimitive | bluesky950520[P]quickjs/quickjs.c | static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// Symbol_toPrimitive(hint)
JSValue obj = this_val;
JSAtom hint = JS_ATOM_NULL;
int hint_num;
if (!JS_IsObject(obj))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (JS_IsString(argv[0])) {
hint = JS_ValueToAtom(ctx, argv[0]);
if (hint == JS_ATOM_NULL)
return JS_EXCEPTION;
JS_FreeAtom(ctx, hint);
}
switch (hint) {
case JS_ATOM_number:
case JS_ATOM_integer:
hint_num = HINT_NUMBER;
break;
case JS_ATOM_string:
case JS_ATOM_default:
hint_num = HINT_STRING;
break;
default:
return JS_ThrowTypeError(ctx, "invalid hint");
}
return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
} | O1 | c | js_date_Symbol_toPrimitive:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x55775
movq %rsi, %r15
movq 0x8(%r8), %rdx
xorl %ebp, %ebp
cmpl $-0x7, %edx
jne 0x5575f
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x2347f
testl %eax, %eax
je 0x557d3
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x1fbc4
movl $0x11, %ecx
cmpl $0x48, %ebp
jg 0x55792
cmpl $0x16, %ebp
je 0x5579c
cmpl $0x47, %ebp
je 0x557a1
jmp 0x557dd
leaq 0x481a1(%rip), %rsi # 0x9d91d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21953
movl $0x6, %edx
xorl %ecx, %ecx
jmp 0x557c2
cmpl $0x4c, %ebp
je 0x557a1
cmpl $0x49, %ebp
jne 0x557dd
movl $0x10, %ecx
incl (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3d3c3
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x6, %edx
xorl %r14d, %r14d
jmp 0x5578e
leaq 0x49820(%rip), %rsi # 0x9f004
jmp 0x5577c
| js_date_Symbol_toPrimitive:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz short loc_55775
mov r15, rsi
mov rdx, [r8+8]
xor ebp, ebp
cmp edx, 0FFFFFFF9h
jnz short loc_5575F
mov rsi, [r8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz loc_557D3
mov ebp, eax
mov rdi, rbx
mov esi, eax
call JS_FreeAtom
loc_5575F:
mov ecx, 11h
cmp ebp, 48h ; 'H'
jg short loc_55792
cmp ebp, 16h
jz short loc_5579C
cmp ebp, 47h ; 'G'
jz short loc_557A1
jmp short loc_557DD
loc_55775:
lea rsi, aOperandPrototy+20h; "not an object"
loc_5577C:
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_5578E:
xor ecx, ecx
jmp short loc_557C2
loc_55792:
cmp ebp, 4Ch ; 'L'
jz short loc_557A1
cmp ebp, 49h ; 'I'
jnz short loc_557DD
loc_5579C:
mov ecx, 10h
loc_557A1:
inc dword ptr [r15]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_ToPrimitiveFree
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
loc_557C2:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
loc_557D3:
mov edx, 6
xor r14d, r14d
jmp short loc_5578E
loc_557DD:
lea rsi, aInvalidHint; "invalid hint"
jmp short loc_5577C
| unsigned long long js_date_Symbol_toPrimitive(
long long a1,
_DWORD *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 v15; // r14
int v16; // ebp
int v17; // eax
char *v18; // rsi
long long v19; // r14
unsigned long long v20; // rcx
unsigned long long v21; // rax
char v23; // [rsp-8h] [rbp-28h]
v23 = v14;
v15 = a3;
if ( (_DWORD)a3 == -1 )
{
a3 = a5[1];
v16 = 0;
if ( (_DWORD)a3 == -7 )
{
v17 = JS_ValueToAtom(a1, *a5, a3);
if ( !v17 )
{
v19 = 0LL;
goto LABEL_11;
}
v16 = v17;
JS_FreeAtom(a1, v17);
}
a4 = 17LL;
if ( v16 > 72 )
{
if ( v16 == 76 )
goto LABEL_15;
if ( v16 != 73 )
{
LABEL_18:
v18 = "invalid hint";
goto LABEL_10;
}
}
else if ( v16 != 22 )
{
if ( v16 != 71 )
goto LABEL_18;
LABEL_15:
++*a2;
v21 = JS_ToPrimitiveFree(
a1,
(unsigned long long)a2,
v15,
a4,
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v20 = v21 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v21;
return v20 | v19;
}
LODWORD(a4) = 16;
goto LABEL_15;
}
v18 = "not an object";
LABEL_10:
v19 = 0LL;
JS_ThrowTypeError(a1, (long long)v18, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v23);
LABEL_11:
v20 = 0LL;
return v20 | v19;
}
| js_date_Symbol_toPrimitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
CMP R14D,-0x1
JNZ 0x00155775
MOV R15,RSI
MOV RDX,qword ptr [R8 + 0x8]
XOR EBP,EBP
CMP EDX,-0x7
JNZ 0x0015575f
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x0012347f
TEST EAX,EAX
JZ 0x001557d3
MOV EBP,EAX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x0011fbc4
LAB_0015575f:
MOV ECX,0x11
CMP EBP,0x48
JG 0x00155792
CMP EBP,0x16
JZ 0x0015579c
CMP EBP,0x47
JZ 0x001557a1
JMP 0x001557dd
LAB_00155775:
LEA RSI,[0x19d91d]
LAB_0015577c:
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x00121953
MOV EDX,0x6
LAB_0015578e:
XOR ECX,ECX
JMP 0x001557c2
LAB_00155792:
CMP EBP,0x4c
JZ 0x001557a1
CMP EBP,0x49
JNZ 0x001557dd
LAB_0015579c:
MOV ECX,0x10
LAB_001557a1:
INC dword ptr [R15]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0013d3c3
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
LAB_001557c2:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
LAB_001557d3:
MOV EDX,0x6
XOR R14D,R14D
JMP 0x0015578e
LAB_001557dd:
LEA RSI,[0x19f004]
JMP 0x0015577c
|
ulong js_date_Symbol_toPrimitive
(int8 param_1,int *param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int8 uVar3;
ulong uVar4;
char *pcVar5;
if ((int)param_3 == -1) {
iVar1 = 0;
if ((int)param_5[1] != -7) {
LAB_0015575f:
uVar3 = 0x11;
if (iVar1 < 0x49) {
if (iVar1 == 0x16) {
LAB_0015579c:
uVar3 = 0x10;
}
else if (iVar1 != 0x47) {
LAB_001557dd:
pcVar5 = "invalid hint";
goto LAB_0015577c;
}
}
else if (iVar1 != 0x4c) {
if (iVar1 != 0x49) goto LAB_001557dd;
goto LAB_0015579c;
}
*param_2 = *param_2 + 1;
uVar2 = JS_ToPrimitiveFree(param_1,param_2,param_3,uVar3);
uVar4 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
goto LAB_001557c2;
}
iVar1 = JS_ValueToAtom(param_1,*param_5);
if (iVar1 != 0) {
JS_FreeAtom(param_1,iVar1);
goto LAB_0015575f;
}
}
else {
pcVar5 = "not an object";
LAB_0015577c:
JS_ThrowTypeError(param_1,pcVar5);
}
uVar2 = 0;
uVar4 = 0;
LAB_001557c2:
return uVar2 | uVar4;
}
| |
43,412 | js_date_Symbol_toPrimitive | bluesky950520[P]quickjs/quickjs.c | static JSValue js_date_Symbol_toPrimitive(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
// Symbol_toPrimitive(hint)
JSValue obj = this_val;
JSAtom hint = JS_ATOM_NULL;
int hint_num;
if (!JS_IsObject(obj))
return JS_ThrowTypeErrorNotAnObject(ctx);
if (JS_IsString(argv[0])) {
hint = JS_ValueToAtom(ctx, argv[0]);
if (hint == JS_ATOM_NULL)
return JS_EXCEPTION;
JS_FreeAtom(ctx, hint);
}
switch (hint) {
case JS_ATOM_number:
case JS_ATOM_integer:
hint_num = HINT_NUMBER;
break;
case JS_ATOM_string:
case JS_ATOM_default:
hint_num = HINT_STRING;
break;
default:
return JS_ThrowTypeError(ctx, "invalid hint");
}
return JS_ToPrimitive(ctx, obj, hint_num | HINT_FORCE_ORDINARY);
} | O3 | c | js_date_Symbol_toPrimitive:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
cmpl $-0x1, %r14d
jne 0x588bc
movq 0x8(%r8), %rdx
cmpl $-0x7, %edx
jne 0x58901
movq %rsi, %r15
movq (%r8), %rsi
movq %rbx, %rdi
callq 0x23ad1
testl %eax, %eax
je 0x588c5
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x202f5
movl $0x11, %ecx
cmpl $0x48, %ebp
jg 0x588cf
cmpl $0x16, %ebp
je 0x588d9
cmpl $0x47, %ebp
je 0x588de
jmp 0x58901
leaq 0x4802a(%rip), %rsi # 0xa08ed
jmp 0x58908
movl $0x6, %edx
xorl %r14d, %r14d
jmp 0x5891a
cmpl $0x4c, %ebp
je 0x588de
cmpl $0x49, %ebp
jne 0x58901
movl $0x10, %ecx
incl (%r15)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3e9e9
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
andq %rax, %rcx
movl %eax, %r14d
jmp 0x5891c
leaq 0x496b6(%rip), %rsi # 0xa1fbe
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2214f
movl $0x6, %edx
xorl %ecx, %ecx
orq %rcx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| js_date_Symbol_toPrimitive:
push rbp
push r15
push r14
push rbx
push rax
mov r14, rdx
mov rbx, rdi
cmp r14d, 0FFFFFFFFh
jnz short loc_588BC
mov rdx, [r8+8]
cmp edx, 0FFFFFFF9h
jnz short loc_58901
mov r15, rsi
mov rsi, [r8]
mov rdi, rbx
call JS_ValueToAtom
test eax, eax
jz short loc_588C5
mov ebp, eax
mov rdi, rbx
mov esi, eax
call JS_FreeAtom
mov ecx, 11h
cmp ebp, 48h ; 'H'
jg short loc_588CF
cmp ebp, 16h
jz short loc_588D9
cmp ebp, 47h ; 'G'
jz short loc_588DE
jmp short loc_58901
loc_588BC:
lea rsi, aOperandPrototy+20h; "not an object"
jmp short loc_58908
loc_588C5:
mov edx, 6
xor r14d, r14d
jmp short loc_5891A
loc_588CF:
cmp ebp, 4Ch ; 'L'
jz short loc_588DE
cmp ebp, 49h ; 'I'
jnz short loc_58901
loc_588D9:
mov ecx, 10h
loc_588DE:
inc dword ptr [r15]
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call JS_ToPrimitiveFree
mov rcx, 0FFFFFFFF00000000h
and rcx, rax
mov r14d, eax
jmp short loc_5891C
loc_58901:
lea rsi, aInvalidHint; "invalid hint"
loc_58908:
xor r14d, r14d
mov rdi, rbx
xor eax, eax
call JS_ThrowTypeError
mov edx, 6
loc_5891A:
xor ecx, ecx
loc_5891C:
or r14, rcx
mov rax, r14
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| unsigned long long js_date_Symbol_toPrimitive(
long long a1,
_DWORD *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 v15; // r14
int v16; // eax
int v17; // ebp
char *v18; // rsi
long long v19; // r14
unsigned long long v20; // rax
unsigned long long v21; // rcx
char v23; // [rsp-8h] [rbp-28h]
v23 = v14;
v15 = a3;
if ( (_DWORD)a3 != -1 )
{
v18 = "not an object";
LABEL_15:
v19 = 0LL;
JS_ThrowTypeError(a1, (long long)v18, a3, a4, (long long)a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v23);
goto LABEL_16;
}
a3 = a5[1];
if ( (_DWORD)a3 != -7 )
goto LABEL_14;
v16 = JS_ValueToAtom(a1, *a5, a3);
if ( !v16 )
{
v19 = 0LL;
LABEL_16:
v21 = 0LL;
return v21 | v19;
}
v17 = v16;
JS_FreeAtom(a1, v16);
a4 = 17LL;
if ( v17 > 72 )
{
if ( v17 == 76 )
goto LABEL_13;
if ( v17 == 73 )
{
LABEL_12:
LODWORD(a4) = 16;
goto LABEL_13;
}
LABEL_14:
v18 = "invalid hint";
goto LABEL_15;
}
if ( v17 == 22 )
goto LABEL_12;
if ( v17 != 71 )
goto LABEL_14;
LABEL_13:
++*a2;
v20 = JS_ToPrimitiveFree(
a1,
(long long)a2,
v15,
a4,
a7,
a8,
a9,
a10,
*(double *)a11.m128_u64,
*(double *)a12.m128_u64,
a13,
a14);
v21 = v20 & 0xFFFFFFFF00000000LL;
v19 = (unsigned int)v20;
return v21 | v19;
}
| js_date_Symbol_toPrimitive:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV RBX,RDI
CMP R14D,-0x1
JNZ 0x001588bc
MOV RDX,qword ptr [R8 + 0x8]
CMP EDX,-0x7
JNZ 0x00158901
MOV R15,RSI
MOV RSI,qword ptr [R8]
MOV RDI,RBX
CALL 0x00123ad1
TEST EAX,EAX
JZ 0x001588c5
MOV EBP,EAX
MOV RDI,RBX
MOV ESI,EAX
CALL 0x001202f5
MOV ECX,0x11
CMP EBP,0x48
JG 0x001588cf
CMP EBP,0x16
JZ 0x001588d9
CMP EBP,0x47
JZ 0x001588de
JMP 0x00158901
LAB_001588bc:
LEA RSI,[0x1a08ed]
JMP 0x00158908
LAB_001588c5:
MOV EDX,0x6
XOR R14D,R14D
JMP 0x0015891a
LAB_001588cf:
CMP EBP,0x4c
JZ 0x001588de
CMP EBP,0x49
JNZ 0x00158901
LAB_001588d9:
MOV ECX,0x10
LAB_001588de:
INC dword ptr [R15]
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0013e9e9
MOV RCX,-0x100000000
AND RCX,RAX
MOV R14D,EAX
JMP 0x0015891c
LAB_00158901:
LEA RSI,[0x1a1fbe]
LAB_00158908:
XOR R14D,R14D
MOV RDI,RBX
XOR EAX,EAX
CALL 0x0012214f
MOV EDX,0x6
LAB_0015891a:
XOR ECX,ECX
LAB_0015891c:
OR R14,RCX
MOV RAX,R14
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
ulong js_date_Symbol_toPrimitive
(int8 param_1,int *param_2,int8 param_3,int8 param_4,
int8 *param_5)
{
int iVar1;
ulong uVar2;
int8 uVar3;
ulong uVar4;
char *pcVar5;
if ((int)param_3 == -1) {
if ((int)param_5[1] != -7) {
LAB_00158901:
pcVar5 = "invalid hint";
goto LAB_00158908;
}
iVar1 = JS_ValueToAtom(param_1,*param_5);
if (iVar1 != 0) {
JS_FreeAtom(param_1,iVar1);
uVar3 = 0x11;
if (iVar1 < 0x49) {
if (iVar1 == 0x16) {
LAB_001588d9:
uVar3 = 0x10;
}
else if (iVar1 != 0x47) goto LAB_00158901;
}
else if (iVar1 != 0x4c) {
if (iVar1 != 0x49) goto LAB_00158901;
goto LAB_001588d9;
}
*param_2 = *param_2 + 1;
uVar2 = JS_ToPrimitiveFree(param_1,param_2,param_3,uVar3);
uVar4 = uVar2 & 0xffffffff00000000;
uVar2 = uVar2 & 0xffffffff;
goto LAB_0015891c;
}
}
else {
pcVar5 = "not an object";
LAB_00158908:
JS_ThrowTypeError(param_1,pcVar5);
}
uVar2 = 0;
uVar4 = 0;
LAB_0015891c:
return uVar2 | uVar4;
}
| |
43,413 | inline_mysql_cond_destroy | eloqsql/include/mysql/psi/mysql_thread.h | static inline int inline_mysql_cond_destroy(
mysql_cond_t *that)
{
#ifdef HAVE_PSI_COND_INTERFACE
if (psi_likely(that->m_psi != NULL))
{
PSI_COND_CALL(destroy_cond)(that->m_psi);
that->m_psi= NULL;
}
#endif
return pthread_cond_destroy(&that->m_cond);
} | O0 | c | inline_mysql_cond_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xe2d24
leaq 0x1de451(%rip), %rax # 0x2c1158
movq (%rax), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x2a280
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| inline_mysql_cond_destroy_3:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
cmp qword ptr [rax+30h], 0
setnz al
and al, 1
movzx eax, al
cmp eax, 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz short loc_E2D24
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+68h]
mov rcx, [rbp+var_8]
mov rdi, [rcx+30h]
call rax
mov rax, [rbp+var_8]
mov qword ptr [rax+30h], 0
loc_E2D24:
mov rdi, [rbp+var_8]
call _pthread_cond_destroy
add rsp, 10h
pop rbp
retn
| long long inline_mysql_cond_destroy_3(long long a1)
{
if ( *(_QWORD *)(a1 + 48) )
{
((void ( *)(_QWORD))PSI_server[13])(*(_QWORD *)(a1 + 48));
*(_QWORD *)(a1 + 48) = 0LL;
}
return pthread_cond_destroy(a1);
}
| inline_mysql_cond_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x30],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CMP EAX,0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001e2d24
LEA RAX,[0x3c1158]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x68]
MOV RCX,qword ptr [RBP + -0x8]
MOV RDI,qword ptr [RCX + 0x30]
CALL RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RAX + 0x30],0x0
LAB_001e2d24:
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0012a280
ADD RSP,0x10
POP RBP
RET
|
void inline_mysql_cond_destroy(pthread_cond_t *param_1)
{
if (param_1[1].__align != 0) {
(**(code **)(PSI_server + 0x68))(param_1[1].__align);
param_1[1].__align = 0;
}
pthread_cond_destroy(param_1);
return;
}
| |
43,414 | reset_root_defaults | eloqsql/mysys/my_alloc.c | void reset_root_defaults(MEM_ROOT *mem_root, size_t block_size,
size_t pre_alloc_size __attribute__((unused)))
{
DBUG_ENTER("reset_root_defaults");
DBUG_ASSERT(alloc_root_inited(mem_root));
mem_root->block_size= (((block_size - ALLOC_ROOT_MIN_BLOCK_SIZE) & ~1) |
(mem_root->block_size & 1));
#if !(defined(HAVE_valgrind) && defined(EXTRA_DEBUG))
if (pre_alloc_size)
{
size_t size= pre_alloc_size + ALIGN_SIZE(sizeof(USED_MEM));
if (!mem_root->pre_alloc || mem_root->pre_alloc->size != size)
{
USED_MEM *mem, **prev= &mem_root->free;
/*
Free unused blocks, so that consequent calls
to reset_root_defaults won't eat away memory.
*/
while (*prev)
{
mem= *prev;
if (mem->size == size)
{
/* We found a suitable block, no need to do anything else */
mem_root->pre_alloc= mem;
DBUG_VOID_RETURN;
}
if (mem->left + ALIGN_SIZE(sizeof(USED_MEM)) == mem->size)
{
/* remove block from the list and free it */
*prev= mem->next;
my_free(mem);
}
else
prev= &mem->next;
}
/* Allocate new prealloc block and add it to the end of free list */
if ((mem= (USED_MEM *) my_malloc(mem_root->m_psi_key, size,
MYF(MALLOC_FLAG(mem_root->
block_size)))))
{
mem->size= size;
mem->left= pre_alloc_size;
mem->next= *prev;
*prev= mem_root->pre_alloc= mem;
TRASH_MEM(mem);
}
else
{
mem_root->pre_alloc= 0;
}
}
}
else
#endif
mem_root->pre_alloc= 0;
DBUG_VOID_RETURN;
} | O3 | c | reset_root_defaults:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
andq $-0x2, %rsi
movq 0x20(%rdi), %rax
andl $0x1, %eax
leaq (%rsi,%rax), %rdx
addq $-0x28, %rdx
movq %rdx, 0x20(%rdi)
testq %r14, %r14
je 0x9c5b4
leaq 0x18(%r14), %r15
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x9c543
cmpq %r15, 0x10(%rax)
je 0x9c5c2
movq (%rbx), %rdi
movq %rbx, %r12
testq %rdi, %rdi
je 0x9c585
movq %rbx, %r12
movq 0x10(%rdi), %rax
cmpq %r15, %rax
je 0x9c5be
movq 0x8(%rdi), %rcx
addq $0x18, %rcx
cmpq %rax, %rcx
jne 0x9c575
movq (%rdi), %rax
movq %rax, (%r12)
callq 0x9f90e
jmp 0x9c578
movq %rdi, %r12
movq (%r12), %rdi
testq %rdi, %rdi
jne 0x9c551
movq 0x20(%rbx), %rdx
movl 0x38(%rbx), %edi
andl $0x1, %edx
shll $0x10, %edx
movq %r15, %rsi
callq 0x9f6e1
testq %rax, %rax
je 0x9c5b4
movq %r15, 0x10(%rax)
movq %r14, 0x8(%rax)
movq (%r12), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%rbx)
movq %rax, (%r12)
jmp 0x9c5c2
movq $0x0, 0x10(%rbx)
jmp 0x9c5c2
movq %rdi, 0x10(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| reset_root_defaults:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r14, rdx
mov rbx, rdi
and rsi, 0FFFFFFFFFFFFFFFEh
mov rax, [rdi+20h]
and eax, 1
lea rdx, [rsi+rax]
add rdx, 0FFFFFFFFFFFFFFD8h
mov [rdi+20h], rdx
test r14, r14
jz loc_9C5B4
lea r15, [r14+18h]
mov rax, [rbx+10h]
test rax, rax
jz short loc_9C543
cmp [rax+10h], r15
jz short loc_9C5C2
loc_9C543:
mov rdi, [rbx]
mov r12, rbx
test rdi, rdi
jz short loc_9C585
mov r12, rbx
loc_9C551:
mov rax, [rdi+10h]
cmp rax, r15
jz short loc_9C5BE
mov rcx, [rdi+8]
add rcx, 18h
cmp rcx, rax
jnz short loc_9C575
mov rax, [rdi]
mov [r12], rax
call my_free
jmp short loc_9C578
loc_9C575:
mov r12, rdi
loc_9C578:
mov rdi, [r12]
test rdi, rdi
jnz short loc_9C551
mov rdx, [rbx+20h]
loc_9C585:
mov edi, [rbx+38h]
and edx, 1
shl edx, 10h
mov rsi, r15
call my_malloc
test rax, rax
jz short loc_9C5B4
mov [rax+10h], r15
mov [rax+8], r14
mov rcx, [r12]
mov [rax], rcx
mov [rbx+10h], rax
mov [r12], rax
jmp short loc_9C5C2
loc_9C5B4:
mov qword ptr [rbx+10h], 0
jmp short loc_9C5C2
loc_9C5BE:
mov [rbx+10h], rdi
loc_9C5C2:
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| _QWORD * reset_root_defaults(long long a1, long long a2, long long a3)
{
_QWORD *result; // rax
unsigned long long v6; // rdx
_QWORD *v7; // r15
_QWORD *v8; // rdi
_QWORD *v9; // r12
result = (_QWORD *)(*(_QWORD *)(a1 + 32) & 1LL);
v6 = (unsigned long long)result + (a2 & 0xFFFFFFFFFFFFFFFELL) - 40;
*(_QWORD *)(a1 + 32) = v6;
if ( !a3 )
{
LABEL_14:
*(_QWORD *)(a1 + 16) = 0LL;
return result;
}
v7 = (_QWORD *)(a3 + 24);
result = *(_QWORD **)(a1 + 16);
if ( result && (_QWORD *)result[2] == v7 )
return result;
v8 = *(_QWORD **)a1;
v9 = (_QWORD *)a1;
if ( !*(_QWORD *)a1 )
{
LABEL_12:
result = (_QWORD *)my_malloc(*(unsigned int *)(a1 + 56), a3 + 24, (unsigned __int8)(v6 & 1) << 16);
if ( result )
{
result[2] = v7;
result[1] = a3;
*result = *v9;
*(_QWORD *)(a1 + 16) = result;
*v9 = result;
return result;
}
goto LABEL_14;
}
v9 = (_QWORD *)a1;
while ( 1 )
{
result = (_QWORD *)v8[2];
if ( result == v7 )
break;
if ( (_QWORD *)(v8[1] + 24LL) == result )
{
*v9 = *v8;
my_free(v8);
}
else
{
v9 = v8;
}
v8 = (_QWORD *)*v9;
if ( !*v9 )
{
v6 = *(_QWORD *)(a1 + 32);
goto LABEL_12;
}
}
*(_QWORD *)(a1 + 16) = v8;
return result;
}
| reset_root_defaults:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R14,RDX
MOV RBX,RDI
AND RSI,-0x2
MOV RAX,qword ptr [RDI + 0x20]
AND EAX,0x1
LEA RDX,[RSI + RAX*0x1]
ADD RDX,-0x28
MOV qword ptr [RDI + 0x20],RDX
TEST R14,R14
JZ 0x0019c5b4
LEA R15,[R14 + 0x18]
MOV RAX,qword ptr [RBX + 0x10]
TEST RAX,RAX
JZ 0x0019c543
CMP qword ptr [RAX + 0x10],R15
JZ 0x0019c5c2
LAB_0019c543:
MOV RDI,qword ptr [RBX]
MOV R12,RBX
TEST RDI,RDI
JZ 0x0019c585
MOV R12,RBX
LAB_0019c551:
MOV RAX,qword ptr [RDI + 0x10]
CMP RAX,R15
JZ 0x0019c5be
MOV RCX,qword ptr [RDI + 0x8]
ADD RCX,0x18
CMP RCX,RAX
JNZ 0x0019c575
MOV RAX,qword ptr [RDI]
MOV qword ptr [R12],RAX
CALL 0x0019f90e
JMP 0x0019c578
LAB_0019c575:
MOV R12,RDI
LAB_0019c578:
MOV RDI,qword ptr [R12]
TEST RDI,RDI
JNZ 0x0019c551
MOV RDX,qword ptr [RBX + 0x20]
LAB_0019c585:
MOV EDI,dword ptr [RBX + 0x38]
AND EDX,0x1
SHL EDX,0x10
MOV RSI,R15
CALL 0x0019f6e1
TEST RAX,RAX
JZ 0x0019c5b4
MOV qword ptr [RAX + 0x10],R15
MOV qword ptr [RAX + 0x8],R14
MOV RCX,qword ptr [R12]
MOV qword ptr [RAX],RCX
MOV qword ptr [RBX + 0x10],RAX
MOV qword ptr [R12],RAX
JMP 0x0019c5c2
LAB_0019c5b4:
MOV qword ptr [RBX + 0x10],0x0
JMP 0x0019c5c2
LAB_0019c5be:
MOV qword ptr [RBX + 0x10],RDI
LAB_0019c5c2:
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void reset_root_defaults(long *param_1,ulong param_2,long param_3)
{
long lVar1;
long *plVar2;
long lVar3;
long *plVar4;
long *plVar5;
lVar3 = (param_2 & 0xfffffffffffffffe) + (ulong)((uint)param_1[4] & 1) + -0x28;
param_1[4] = lVar3;
if (param_3 != 0) {
lVar1 = param_3 + 0x18;
if ((param_1[2] != 0) && (*(long *)(param_1[2] + 0x10) == lVar1)) {
return;
}
plVar2 = (long *)*param_1;
plVar4 = param_1;
plVar5 = param_1;
if (plVar2 != (long *)0x0) {
do {
if (plVar2[2] == lVar1) {
param_1[2] = (long)plVar2;
return;
}
plVar5 = plVar2;
if (plVar2[1] + 0x18 == plVar2[2]) {
*plVar4 = *plVar2;
my_free();
plVar5 = plVar4;
}
plVar2 = (long *)*plVar5;
plVar4 = plVar5;
} while (plVar2 != (long *)0x0);
lVar3 = param_1[4];
}
plVar2 = (long *)my_malloc((int)param_1[7],lVar1,((uint)lVar3 & 1) << 0x10);
if (plVar2 != (long *)0x0) {
plVar2[2] = lVar1;
plVar2[1] = param_3;
*plVar2 = *plVar5;
param_1[2] = (long)plVar2;
*plVar5 = (long)plVar2;
return;
}
}
param_1[2] = 0;
return;
}
| |
43,415 | gguf_set_kv | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void gguf_set_kv(struct gguf_context * ctx, struct gguf_context * src) {
for (uint32_t i = 0; i < src->header.n_kv; i++) {
switch (src->kv[i].type) {
case GGUF_TYPE_UINT8: gguf_set_val_u8 (ctx, src->kv[i].key.data, src->kv[i].value.uint8); break;
case GGUF_TYPE_INT8: gguf_set_val_i8 (ctx, src->kv[i].key.data, src->kv[i].value.int8); break;
case GGUF_TYPE_UINT16: gguf_set_val_u16 (ctx, src->kv[i].key.data, src->kv[i].value.uint16); break;
case GGUF_TYPE_INT16: gguf_set_val_i16 (ctx, src->kv[i].key.data, src->kv[i].value.int16); break;
case GGUF_TYPE_UINT32: gguf_set_val_u32 (ctx, src->kv[i].key.data, src->kv[i].value.uint32); break;
case GGUF_TYPE_INT32: gguf_set_val_i32 (ctx, src->kv[i].key.data, src->kv[i].value.int32); break;
case GGUF_TYPE_FLOAT32: gguf_set_val_f32 (ctx, src->kv[i].key.data, src->kv[i].value.float32); break;
case GGUF_TYPE_UINT64: gguf_set_val_u64 (ctx, src->kv[i].key.data, src->kv[i].value.uint64); break;
case GGUF_TYPE_INT64: gguf_set_val_i64 (ctx, src->kv[i].key.data, src->kv[i].value.int64); break;
case GGUF_TYPE_FLOAT64: gguf_set_val_f64 (ctx, src->kv[i].key.data, src->kv[i].value.float64); break;
case GGUF_TYPE_BOOL: gguf_set_val_bool(ctx, src->kv[i].key.data, src->kv[i].value.bool_); break;
case GGUF_TYPE_STRING: gguf_set_val_str (ctx, src->kv[i].key.data, src->kv[i].value.str.data); break;
case GGUF_TYPE_ARRAY:
{
if (src->kv[i].value.arr.type == GGUF_TYPE_STRING) {
const char ** data = malloc(src->kv[i].value.arr.n*sizeof(char *));
for (uint32_t j = 0; j < src->kv[i].value.arr.n; j++) {
data[j] = ((struct gguf_str *)src->kv[i].value.arr.data)[j].data;
}
gguf_set_arr_str(ctx, src->kv[i].key.data, data, src->kv[i].value.arr.n);
free((void *)data);
} else if (src->kv[i].value.arr.type == GGUF_TYPE_ARRAY) {
GGML_ASSERT(false && "nested arrays not supported");
} else {
gguf_set_arr_data(ctx, src->kv[i].key.data, src->kv[i].value.arr.type, src->kv[i].value.arr.data, src->kv[i].value.arr.n);
}
} break;
case GGUF_TYPE_COUNT: GGML_ASSERT(false && "invalid type"); break;
}
}
} | O1 | c | gguf_set_kv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rsi)
je 0x9e5f4
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x27358(%rip), %r12 # 0xc5674
movq 0x18(%rbx), %rbp
leaq (,%r13,2), %rax
addq %r13, %rax
shlq $0x4, %rax
movl 0x10(%rbp,%rax), %ecx
cmpq $0xd, %rcx
ja 0x9e5e7
addq %rax, %rbp
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x8(%rbp), %rsi
movb 0x18(%rbp), %bpl
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x0, 0x10(%rcx,%rax)
jmp 0x9e4d9
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %r15
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0xb, 0x10(%rcx,%rax)
jmp 0x9e573
movq 0x8(%rbp), %rsi
movl 0x18(%rbp), %ebp
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x4, 0x10(%rcx,%rax)
jmp 0x9e508
movq 0x8(%rbp), %rsi
vmovsd 0x18(%rbp), %xmm0
vmovsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0xc, 0x10(%rcx,%rax)
vmovsd (%rsp), %xmm0
vmovsd %xmm0, 0x18(%rcx,%rax)
jmp 0x9e5e7
movl 0x18(%rbp), %edx
cmpl $0x8, %edx
je 0x9e58c
cmpl $0x9, %edx
je 0x9e608
movq 0x8(%rbp), %rsi
movq 0x28(%rbp), %rcx
movl 0x20(%rbp), %r8d
movq %r14, %rdi
callq 0x9e1b7
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
movzwl 0x18(%rbp), %ebp
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x2, 0x10(%rcx,%rax)
jmp 0x9e481
movq 0x8(%rbp), %rsi
movzwl 0x18(%rbp), %ebp
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x3, 0x10(%rcx,%rax)
movw %bp, 0x18(%rcx,%rax)
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
movb 0x18(%rbp), %bpl
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x7, 0x10(%rcx,%rax)
jmp 0x9e4d9
movq 0x8(%rbp), %rsi
movb 0x18(%rbp), %bpl
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x1, 0x10(%rcx,%rax)
movb %bpl, 0x18(%rcx,%rax)
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
movl 0x18(%rbp), %ebp
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x5, 0x10(%rcx,%rax)
movl %ebp, 0x18(%rcx,%rax)
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
vmovss 0x18(%rbp), %xmm0
vmovss %xmm0, (%rsp)
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0x6, 0x10(%rcx,%rax)
vmovss (%rsp), %xmm0
vmovss %xmm0, 0x18(%rcx,%rax)
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %r15
movq %r14, %rdi
callq 0x9def5
movq 0x18(%r14), %rcx
cltq
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movl $0xa, 0x10(%rcx,%rax)
movq %r15, 0x18(%rcx,%rax)
jmp 0x9e5e7
movq 0x8(%rbp), %rsi
movq 0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x9e163
jmp 0x9e5e7
movq 0x20(%rbp), %r15
leaq (,%r15,8), %rdi
callq 0xa7c0
movq %rax, %r12
testq %r15, %r15
je 0x9e5c6
movq 0x28(%rbp), %rax
movl $0x1, %ecx
xorl %edx, %edx
movq 0x8(%rax,%rdx,2), %rsi
movq %rsi, (%r12,%rdx)
movl %ecx, %esi
addq $0x8, %rdx
incl %ecx
cmpq %rsi, %r15
ja 0x9e5b0
movq 0x8(%rbp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x9e23d
movq %r12, %rdi
callq 0xa700
leaq 0x2708d(%rip), %r12 # 0xc5674
incl %r13d
cmpq %r13, 0x10(%rbx)
ja 0x9e31c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x114ca
callq 0x1150f
| gguf_set_kv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
cmp qword ptr [rsi+10h], 0
jz loc_9E5F4
mov rbx, rsi
mov r14, rdi
xor r13d, r13d
lea r12, jpt_9E347
loc_9E31C:
mov rbp, [rbx+18h]
lea rax, ds:0[r13*2]
add rax, r13
shl rax, 4
mov ecx, [rbp+rax+10h]
cmp rcx, 0Dh; switch 14 cases
ja def_9E347; jumptable 000000000009E347 default case
add rbp, rax
movsxd rax, ds:(jpt_9E347 - 0C5674h)[r12+rcx*4]
add rax, r12
jmp rax; switch jump
loc_9E349:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 0
mov bpl, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 0
jmp loc_9E4D9
loc_9E374:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 11
mov r15, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 0Bh
jmp loc_9E573
loc_9E39F:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 4
mov ebp, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 4
jmp loc_9E508
loc_9E3C9:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 12
vmovsd xmm0, qword ptr [rbp+18h]
vmovsd [rsp+38h+var_38], xmm0
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 0Ch
vmovsd xmm0, [rsp+38h+var_38]
vmovsd qword ptr [rcx+rax+18h], xmm0
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E405:
mov edx, [rbp+18h]; jumptable 000000000009E347 case 9
cmp edx, 8
jz loc_9E58C
cmp edx, 9
jz loc_9E608
mov rsi, [rbp+8]
mov rcx, [rbp+28h]
mov r8d, [rbp+20h]
mov rdi, r14
call gguf_set_arr_data
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E433:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 2
movzx ebp, word ptr [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 2
jmp short loc_9E481
loc_9E45B:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 3
movzx ebp, word ptr [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 3
loc_9E481:
mov [rcx+rax+18h], bp
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E48B:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 7
mov bpl, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 7
jmp short loc_9E4D9
loc_9E4B3:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 1
mov bpl, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 1
loc_9E4D9:
mov [rcx+rax+18h], bpl
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E4E3:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 5
mov ebp, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 5
loc_9E508:
mov [rcx+rax+18h], ebp
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E511:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 6
vmovss xmm0, dword ptr [rbp+18h]
vmovss dword ptr [rsp+38h+var_38], xmm0
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 6
vmovss xmm0, dword ptr [rsp+38h+var_38]
vmovss dword ptr [rcx+rax+18h], xmm0
jmp def_9E347; jumptable 000000000009E347 default case
loc_9E54D:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 10
mov r15, [rbp+18h]
mov rdi, r14
call gguf_get_or_add_key
mov rcx, [r14+18h]
cdqe
lea rax, [rax+rax*2]
shl rax, 4
mov dword ptr [rcx+rax+10h], 0Ah
loc_9E573:
mov [rcx+rax+18h], r15
jmp short def_9E347; jumptable 000000000009E347 default case
loc_9E57A:
mov rsi, [rbp+8]; jumptable 000000000009E347 case 8
mov rdx, [rbp+20h]
mov rdi, r14
call gguf_set_val_str
jmp short def_9E347; jumptable 000000000009E347 default case
loc_9E58C:
mov r15, [rbp+20h]
lea rdi, ds:0[r15*8]
call _malloc
mov r12, rax
test r15, r15
jz short loc_9E5C6
mov rax, [rbp+28h]
mov ecx, 1
xor edx, edx
loc_9E5B0:
mov rsi, [rax+rdx*2+8]
mov [r12+rdx], rsi
mov esi, ecx
add rdx, 8
inc ecx
cmp r15, rsi
ja short loc_9E5B0
loc_9E5C6:
mov rsi, [rbp+8]
mov rdi, r14
mov rdx, r12
mov ecx, r15d
call gguf_set_arr_str
mov rdi, r12
call _free
lea r12, jpt_9E347
def_9E347:
inc r13d; jumptable 000000000009E347 default case
cmp [rbx+10h], r13
ja loc_9E31C
loc_9E5F4:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_9E603:
call gguf_set_kv_cold_1; jumptable 000000000009E347 case 13
loc_9E608:
call gguf_set_kv_cold_2
| long long gguf_set_kv(long long a1, long long a2)
{
long long result; // rax
unsigned long long v4; // r13
long long v5; // rbp
long long v6; // rcx
long long v8; // rsi
char v9; // bp
int v10; // eax
long long v11; // rcx
long long v12; // r15
int v13; // eax
long long v14; // rcx
long long v15; // rsi
int v16; // ebp
int v17; // eax
long long v18; // rcx
int v20; // eax
int v23; // edx
long long v24; // rsi
__int16 v25; // bp
int v26; // eax
long long v27; // rcx
long long v28; // rsi
int v29; // eax
long long v30; // rsi
int v31; // eax
long long v32; // rsi
int v33; // eax
long long v34; // rsi
int v35; // eax
int v37; // eax
int v40; // eax
unsigned long long v41; // r15
long long v42; // r12
long long v43; // rax
unsigned int v44; // ecx
long long v45; // rdx
unsigned long long v46; // rsi
if ( *(_QWORD *)(a2 + 16) )
{
v4 = 0LL;
do
{
v5 = *(_QWORD *)(a2 + 24);
result = 48 * v4;
v6 = *(unsigned int *)(v5 + 48 * v4 + 16);
_RBP = 48 * v4 + v5;
switch ( v6 )
{
case 0LL:
v8 = *(_QWORD *)(_RBP + 8);
v9 = *(_BYTE *)(_RBP + 24);
v10 = gguf_get_or_add_key(a1, v8);
v11 = *(_QWORD *)(a1 + 24);
result = 48LL * v10;
*(_DWORD *)(v11 + result + 16) = 0;
goto LABEL_16;
case 1LL:
v32 = *(_QWORD *)(_RBP + 8);
v9 = *(_BYTE *)(_RBP + 24);
v33 = gguf_get_or_add_key(a1, v32);
v11 = *(_QWORD *)(a1 + 24);
result = 48LL * v33;
*(_DWORD *)(v11 + result + 16) = 1;
goto LABEL_16;
case 2LL:
v24 = *(_QWORD *)(_RBP + 8);
v25 = *(_WORD *)(_RBP + 24);
v26 = gguf_get_or_add_key(a1, v24);
v27 = *(_QWORD *)(a1 + 24);
result = 48LL * v26;
*(_DWORD *)(v27 + result + 16) = 2;
goto LABEL_13;
case 3LL:
v28 = *(_QWORD *)(_RBP + 8);
v25 = *(_WORD *)(_RBP + 24);
v29 = gguf_get_or_add_key(a1, v28);
v27 = *(_QWORD *)(a1 + 24);
result = 48LL * v29;
*(_DWORD *)(v27 + result + 16) = 3;
LABEL_13:
*(_WORD *)(v27 + result + 24) = v25;
break;
case 4LL:
v15 = *(_QWORD *)(_RBP + 8);
v16 = *(_DWORD *)(_RBP + 24);
v17 = gguf_get_or_add_key(a1, v15);
v18 = *(_QWORD *)(a1 + 24);
result = 48LL * v17;
*(_DWORD *)(v18 + result + 16) = 4;
goto LABEL_18;
case 5LL:
v34 = *(_QWORD *)(_RBP + 8);
v16 = *(_DWORD *)(_RBP + 24);
v35 = gguf_get_or_add_key(a1, v34);
v18 = *(_QWORD *)(a1 + 24);
result = 48LL * v35;
*(_DWORD *)(v18 + result + 16) = 5;
LABEL_18:
*(_DWORD *)(v18 + result + 24) = v16;
break;
case 6LL:
__asm
{
vmovss xmm0, dword ptr [rbp+18h]
vmovss dword ptr [rsp+38h+var_38], xmm0
}
v37 = gguf_get_or_add_key(a1, *(_QWORD *)(_RBP + 8));
_RCX = *(_QWORD *)(a1 + 24);
result = 48LL * v37;
*(_DWORD *)(_RCX + result + 16) = 6;
__asm
{
vmovss xmm0, dword ptr [rsp+38h+var_38]
vmovss dword ptr [rcx+rax+18h], xmm0
}
break;
case 7LL:
v30 = *(_QWORD *)(_RBP + 8);
v9 = *(_BYTE *)(_RBP + 24);
v31 = gguf_get_or_add_key(a1, v30);
v11 = *(_QWORD *)(a1 + 24);
result = 48LL * v31;
*(_DWORD *)(v11 + result + 16) = 7;
LABEL_16:
*(_BYTE *)(v11 + result + 24) = v9;
break;
case 8LL:
result = gguf_set_val_str(a1, *(_QWORD *)(_RBP + 8), *(_QWORD *)(_RBP + 32));
break;
case 9LL:
v23 = *(_DWORD *)(_RBP + 24);
if ( v23 == 8 )
{
v41 = *(_QWORD *)(_RBP + 32);
v42 = malloc(8 * v41);
if ( v41 )
{
v43 = *(_QWORD *)(_RBP + 40);
v44 = 1;
v45 = 0LL;
do
{
*(_QWORD *)(v42 + v45) = *(_QWORD *)(v43 + 2 * v45 + 8);
v46 = v44;
v45 += 8LL;
++v44;
}
while ( v41 > v46 );
}
gguf_set_arr_str(a1, *(_QWORD *)(_RBP + 8), v42, v41);
result = free(v42);
}
else
{
if ( v23 == 9 )
gguf_set_kv_cold_2();
result = gguf_set_arr_data(a1, *(_QWORD *)(_RBP + 8), v23, *(_QWORD *)(_RBP + 40), *(_DWORD *)(_RBP + 32));
}
break;
case 10LL:
v12 = *(_QWORD *)(_RBP + 24);
v40 = gguf_get_or_add_key(a1, *(_QWORD *)(_RBP + 8));
v14 = *(_QWORD *)(a1 + 24);
result = 48LL * v40;
*(_DWORD *)(v14 + result + 16) = 10;
goto LABEL_21;
case 11LL:
v12 = *(_QWORD *)(_RBP + 24);
v13 = gguf_get_or_add_key(a1, *(_QWORD *)(_RBP + 8));
v14 = *(_QWORD *)(a1 + 24);
result = 48LL * v13;
*(_DWORD *)(v14 + result + 16) = 11;
LABEL_21:
*(_QWORD *)(v14 + result + 24) = v12;
break;
case 12LL:
__asm
{
vmovsd xmm0, qword ptr [rbp+18h]
vmovsd [rsp+38h+var_38], xmm0
}
v20 = gguf_get_or_add_key(a1, *(_QWORD *)(_RBP + 8));
_RCX = *(_QWORD *)(a1 + 24);
result = 48LL * v20;
*(_DWORD *)(_RCX + result + 16) = 12;
__asm
{
vmovsd xmm0, [rsp+38h+var_38]
vmovsd qword ptr [rcx+rax+18h], xmm0
}
break;
case 13LL:
gguf_set_kv_cold_1();
default:
break;
}
v4 = (unsigned int)(v4 + 1);
}
while ( *(_QWORD *)(a2 + 16) > v4 );
}
return result;
}
| |||
43,416 | gguf_set_kv | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void gguf_set_kv(struct gguf_context * ctx, struct gguf_context * src) {
for (uint32_t i = 0; i < src->header.n_kv; i++) {
switch (src->kv[i].type) {
case GGUF_TYPE_UINT8: gguf_set_val_u8 (ctx, src->kv[i].key.data, src->kv[i].value.uint8); break;
case GGUF_TYPE_INT8: gguf_set_val_i8 (ctx, src->kv[i].key.data, src->kv[i].value.int8); break;
case GGUF_TYPE_UINT16: gguf_set_val_u16 (ctx, src->kv[i].key.data, src->kv[i].value.uint16); break;
case GGUF_TYPE_INT16: gguf_set_val_i16 (ctx, src->kv[i].key.data, src->kv[i].value.int16); break;
case GGUF_TYPE_UINT32: gguf_set_val_u32 (ctx, src->kv[i].key.data, src->kv[i].value.uint32); break;
case GGUF_TYPE_INT32: gguf_set_val_i32 (ctx, src->kv[i].key.data, src->kv[i].value.int32); break;
case GGUF_TYPE_FLOAT32: gguf_set_val_f32 (ctx, src->kv[i].key.data, src->kv[i].value.float32); break;
case GGUF_TYPE_UINT64: gguf_set_val_u64 (ctx, src->kv[i].key.data, src->kv[i].value.uint64); break;
case GGUF_TYPE_INT64: gguf_set_val_i64 (ctx, src->kv[i].key.data, src->kv[i].value.int64); break;
case GGUF_TYPE_FLOAT64: gguf_set_val_f64 (ctx, src->kv[i].key.data, src->kv[i].value.float64); break;
case GGUF_TYPE_BOOL: gguf_set_val_bool(ctx, src->kv[i].key.data, src->kv[i].value.bool_); break;
case GGUF_TYPE_STRING: gguf_set_val_str (ctx, src->kv[i].key.data, src->kv[i].value.str.data); break;
case GGUF_TYPE_ARRAY:
{
if (src->kv[i].value.arr.type == GGUF_TYPE_STRING) {
const char ** data = malloc(src->kv[i].value.arr.n*sizeof(char *));
for (uint32_t j = 0; j < src->kv[i].value.arr.n; j++) {
data[j] = ((struct gguf_str *)src->kv[i].value.arr.data)[j].data;
}
gguf_set_arr_str(ctx, src->kv[i].key.data, data, src->kv[i].value.arr.n);
free((void *)data);
} else if (src->kv[i].value.arr.type == GGUF_TYPE_ARRAY) {
GGML_ASSERT(false && "nested arrays not supported");
} else {
gguf_set_arr_data(ctx, src->kv[i].key.data, src->kv[i].value.arr.type, src->kv[i].value.arr.data, src->kv[i].value.arr.n);
}
} break;
case GGUF_TYPE_COUNT: GGML_ASSERT(false && "invalid type"); break;
}
}
} | O2 | c | gguf_set_kv:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0x28da2(%rip), %r15 # 0xa1408
movl %r13d, %r13d
cmpq %r13, 0x10(%rbx)
jbe 0x78814
movq 0x18(%rbx), %rbp
imulq $0x30, %r13, %rcx
movl 0x10(%rbp,%rcx), %eax
cmpq $0xd, %rax
ja 0x7880c
addq %rcx, %rbp
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x8(%rbp), %rsi
movzbl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x7826b
jmp 0x7880c
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq %r14, %rdi
callq 0x78441
jmp 0x7880c
movq 0x8(%rbp), %rsi
movl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x78384
jmp 0x7880c
movq 0x8(%rbp), %rsi
vmovsd 0x18(%rbp), %xmm0
movq %r14, %rdi
callq 0x7846f
jmp 0x7880c
movl 0x18(%rbp), %edx
cmpl $0x8, %edx
je 0x787b6
cmpl $0x9, %edx
je 0x78858
movq 0x8(%rbp), %rsi
movq 0x28(%rbp), %rcx
movl 0x20(%rbp), %r8d
movq %r14, %rdi
callq 0x78522
jmp 0x7880c
movq 0x8(%rbp), %rsi
movzwl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x7832a
jmp 0x7880c
movq 0x8(%rbp), %rsi
movswl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x78357
jmp 0x7880c
movq 0x8(%rbp), %rsi
movzbl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x784a6
jmp 0x7880c
movq 0x8(%rbp), %rsi
movsbl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x782fe
jmp 0x7880c
movq 0x8(%rbp), %rsi
movl 0x18(%rbp), %edx
movq %r14, %rdi
callq 0x783b0
jmp 0x7880c
movq 0x8(%rbp), %rsi
vmovss 0x18(%rbp), %xmm0
movq %r14, %rdi
callq 0x783dc
jmp 0x7880c
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq %r14, %rdi
callq 0x78413
jmp 0x7880c
movq 0x8(%rbp), %rsi
movq 0x20(%rbp), %rdx
movq %r14, %rdi
callq 0x784d2
jmp 0x7880c
movq 0x20(%rbp), %r15
leaq (,%r15,8), %rdi
callq 0xa7e0
movq %rax, %r12
xorl %eax, %eax
movl %eax, %eax
cmpq %rax, %r15
jbe 0x787eb
movq 0x28(%rbp), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, (%r12,%rax,8)
incl %eax
jmp 0x787cc
movq 0x8(%rbp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x785a4
movq %r12, %rdi
callq 0xa710
leaq 0x28bfc(%rip), %r15 # 0xa1408
incl %r13d
jmp 0x78666
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5d71e(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x5d76f(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x219db(%rip), %rsi # 0x9a21e
leaq 0x29034(%rip), %rdx # 0xa187e
leaq 0x2a149(%rip), %r8 # 0xa299a
movl $0x4c3c, %ecx # imm = 0x4C3C
jmp 0x7888b
movq 0x5d6e9(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x5d73a(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x219a6(%rip), %rsi # 0x9a21e
leaq 0x28fff(%rip), %rdx # 0xa187e
leaq 0x2a49f(%rip), %r8 # 0xa2d25
movl $0x4c37, %ecx # imm = 0x4C37
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| gguf_set_kv:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov rbx, rsi
mov r14, rdi
xor r13d, r13d
lea r15, jpt_78693
loc_78666:
mov r13d, r13d
cmp [rbx+10h], r13
jbe loc_78814
mov rbp, [rbx+18h]
imul rcx, r13, 30h ; '0'
mov eax, [rbp+rcx+10h]
cmp rax, 0Dh; switch 14 cases
ja def_78693; jumptable 0000000000078693 default case
add rbp, rcx
movsxd rax, ds:(jpt_78693 - 0A1408h)[r15+rax*4]
add rax, r15
jmp rax; switch jump
loc_78695:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 0
movzx edx, byte ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_u8
jmp def_78693; jumptable 0000000000078693 default case
loc_786AA:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 11
mov rdx, [rbp+18h]
mov rdi, r14
call gguf_set_val_i64
jmp def_78693; jumptable 0000000000078693 default case
loc_786BF:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 4
mov edx, [rbp+18h]
mov rdi, r14
call gguf_set_val_u32
jmp def_78693; jumptable 0000000000078693 default case
loc_786D3:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 12
vmovsd xmm0, qword ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_f64
jmp def_78693; jumptable 0000000000078693 default case
loc_786E9:
mov edx, [rbp+18h]; jumptable 0000000000078693 case 9
cmp edx, 8
jz loc_787B6
cmp edx, 9
jz loc_78858
mov rsi, [rbp+8]
mov rcx, [rbp+28h]
mov r8d, [rbp+20h]
mov rdi, r14
call gguf_set_arr_data
jmp def_78693; jumptable 0000000000078693 default case
loc_78717:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 2
movzx edx, word ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_u16
jmp def_78693; jumptable 0000000000078693 default case
loc_7872C:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 3
movsx edx, word ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_i16
jmp def_78693; jumptable 0000000000078693 default case
loc_78741:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 7
movzx edx, byte ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_bool
jmp def_78693; jumptable 0000000000078693 default case
loc_78756:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 1
movsx edx, byte ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_i8
jmp def_78693; jumptable 0000000000078693 default case
loc_7876B:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 5
mov edx, [rbp+18h]
mov rdi, r14
call gguf_set_val_i32
jmp def_78693; jumptable 0000000000078693 default case
loc_7877F:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 6
vmovss xmm0, dword ptr [rbp+18h]
mov rdi, r14
call gguf_set_val_f32
jmp short def_78693; jumptable 0000000000078693 default case
loc_78792:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 10
mov rdx, [rbp+18h]
mov rdi, r14
call gguf_set_val_u64
jmp short def_78693; jumptable 0000000000078693 default case
loc_787A4:
mov rsi, [rbp+8]; jumptable 0000000000078693 case 8
mov rdx, [rbp+20h]
mov rdi, r14
call gguf_set_val_str
jmp short def_78693; jumptable 0000000000078693 default case
loc_787B6:
mov r15, [rbp+20h]
lea rdi, ds:0[r15*8]
call _malloc
mov r12, rax
xor eax, eax
loc_787CC:
mov eax, eax
cmp r15, rax
jbe short loc_787EB
mov rcx, [rbp+28h]
mov rdx, rax
shl rdx, 4
mov rcx, [rcx+rdx+8]
mov [r12+rax*8], rcx
inc eax
jmp short loc_787CC
loc_787EB:
mov rsi, [rbp+8]
mov rdi, r14
mov rdx, r12
mov ecx, r15d
call gguf_set_arr_str
mov rdi, r12
call _free
lea r15, jpt_78693
def_78693:
inc r13d; jumptable 0000000000078693 default case
jmp loc_78666
loc_78814:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_78823:
mov rax, cs:stdout_ptr; jumptable 0000000000078693 case 13
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalseInvalidTy; "false && \"invalid type\""
mov ecx, 4C3Ch
jmp short loc_7888B
loc_78858:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aFalseNestedArr; "false && \"nested arrays not supported"...
mov ecx, 4C37h
loc_7888B:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| long long gguf_set_kv(long long a1, long long a2)
{
long long result; // rax
unsigned int v3; // r13d
long long v4; // rbp
int v7; // edx
unsigned long long v9; // r15
long long v10; // r12
unsigned int i; // eax
long long v12; // rdi
v3 = 0;
while ( *(_QWORD *)(a2 + 16) > (unsigned long long)v3 )
{
v4 = *(_QWORD *)(a2 + 24);
result = *(unsigned int *)(v4 + 48LL * v3 + 16);
_RBP = 48LL * v3 + v4;
switch ( result )
{
case 0LL:
result = gguf_set_val_u8(a1, *(_QWORD *)(_RBP + 8), *(_BYTE *)(_RBP + 24));
goto LABEL_23;
case 1LL:
result = gguf_set_val_i8(a1, *(_QWORD *)(_RBP + 8), *(_BYTE *)(_RBP + 24));
goto LABEL_23;
case 2LL:
result = gguf_set_val_u16(a1, *(_QWORD *)(_RBP + 8), *(_WORD *)(_RBP + 24));
goto LABEL_23;
case 3LL:
result = gguf_set_val_i16(a1, *(_QWORD *)(_RBP + 8), *(_WORD *)(_RBP + 24));
goto LABEL_23;
case 4LL:
result = gguf_set_val_u32(a1, *(_QWORD *)(_RBP + 8), *(_DWORD *)(_RBP + 24));
goto LABEL_23;
case 5LL:
result = gguf_set_val_i32(a1, *(_QWORD *)(_RBP + 8), *(_DWORD *)(_RBP + 24));
goto LABEL_23;
case 6LL:
__asm { vmovss xmm0, dword ptr [rbp+18h] }
result = gguf_set_val_f32(a1, *(_QWORD *)(_RBP + 8), _XMM0);
goto LABEL_23;
case 7LL:
result = gguf_set_val_bool(a1, *(_QWORD *)(_RBP + 8), *(_BYTE *)(_RBP + 24));
goto LABEL_23;
case 8LL:
result = gguf_set_val_str(a1, *(_QWORD *)(_RBP + 8), *(_QWORD *)(_RBP + 32));
goto LABEL_23;
case 9LL:
v7 = *(_DWORD *)(_RBP + 24);
if ( v7 == 8 )
{
v9 = *(_QWORD *)(_RBP + 32);
v10 = malloc(8 * v9);
for ( i = 0; v9 > i; ++i )
*(_QWORD *)(v10 + 8LL * i) = *(_QWORD *)(*(_QWORD *)(_RBP + 40) + 16LL * i + 8);
gguf_set_arr_str(a1, *(_QWORD *)(_RBP + 8), v10, v9);
result = free(v10);
}
else
{
if ( v7 == 9 )
{
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19511LL,
"false && \"nested arrays not supported\"");
LABEL_27:
ggml_print_backtrace();
abort(v12);
}
result = gguf_set_arr_data(a1, *(_QWORD *)(_RBP + 8), v7, *(_QWORD *)(_RBP + 40), *(_DWORD *)(_RBP + 32));
}
LABEL_23:
++v3;
break;
case 10LL:
result = gguf_set_val_u64(a1, *(_QWORD *)(_RBP + 8), *(_QWORD *)(_RBP + 24));
goto LABEL_23;
case 11LL:
result = gguf_set_val_i64(a1, *(_QWORD *)(_RBP + 8), *(_QWORD *)(_RBP + 24));
goto LABEL_23;
case 12LL:
__asm { vmovsd xmm0, qword ptr [rbp+18h] }
result = gguf_set_val_f64(a1, *(_QWORD *)(_RBP + 8), _XMM0);
goto LABEL_23;
case 13LL:
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
19516LL,
"false && \"invalid type\"");
goto LABEL_27;
default:
goto LABEL_23;
}
}
return result;
}
| gguf_set_kv:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RSI
MOV R14,RDI
XOR R13D,R13D
LEA R15,[0x1a1408]
LAB_00178666:
MOV R13D,R13D
CMP qword ptr [RBX + 0x10],R13
JBE 0x00178814
MOV RBP,qword ptr [RBX + 0x18]
IMUL RCX,R13,0x30
MOV EAX,dword ptr [RBP + RCX*0x1 + 0x10]
CMP RAX,0xd
JA 0x0017880c
ADD RBP,RCX
MOVSXD RAX,dword ptr [R15 + RAX*0x4]
ADD RAX,R15
switchD:
JMP RAX
caseD_0:
MOV RSI,qword ptr [RBP + 0x8]
MOVZX EDX,byte ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x0017826b
JMP 0x0017880c
caseD_b:
MOV RSI,qword ptr [RBP + 0x8]
MOV RDX,qword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x00178441
JMP 0x0017880c
caseD_4:
MOV RSI,qword ptr [RBP + 0x8]
MOV EDX,dword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x00178384
JMP 0x0017880c
caseD_c:
MOV RSI,qword ptr [RBP + 0x8]
VMOVSD XMM0,qword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x0017846f
JMP 0x0017880c
caseD_9:
MOV EDX,dword ptr [RBP + 0x18]
CMP EDX,0x8
JZ 0x001787b6
CMP EDX,0x9
JZ 0x00178858
MOV RSI,qword ptr [RBP + 0x8]
MOV RCX,qword ptr [RBP + 0x28]
MOV R8D,dword ptr [RBP + 0x20]
MOV RDI,R14
CALL 0x00178522
JMP 0x0017880c
caseD_2:
MOV RSI,qword ptr [RBP + 0x8]
MOVZX EDX,word ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x0017832a
JMP 0x0017880c
caseD_3:
MOV RSI,qword ptr [RBP + 0x8]
MOVSX EDX,word ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x00178357
JMP 0x0017880c
caseD_7:
MOV RSI,qword ptr [RBP + 0x8]
MOVZX EDX,byte ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x001784a6
JMP 0x0017880c
caseD_1:
MOV RSI,qword ptr [RBP + 0x8]
MOVSX EDX,byte ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x001782fe
JMP 0x0017880c
caseD_5:
MOV RSI,qword ptr [RBP + 0x8]
MOV EDX,dword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x001783b0
JMP 0x0017880c
caseD_6:
MOV RSI,qword ptr [RBP + 0x8]
VMOVSS XMM0,dword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x001783dc
JMP 0x0017880c
caseD_a:
MOV RSI,qword ptr [RBP + 0x8]
MOV RDX,qword ptr [RBP + 0x18]
MOV RDI,R14
CALL 0x00178413
JMP 0x0017880c
caseD_8:
MOV RSI,qword ptr [RBP + 0x8]
MOV RDX,qword ptr [RBP + 0x20]
MOV RDI,R14
CALL 0x001784d2
JMP 0x0017880c
LAB_001787b6:
MOV R15,qword ptr [RBP + 0x20]
LEA RDI,[R15*0x8]
CALL 0x0010a7e0
MOV R12,RAX
XOR EAX,EAX
LAB_001787cc:
MOV EAX,EAX
CMP R15,RAX
JBE 0x001787eb
MOV RCX,qword ptr [RBP + 0x28]
MOV RDX,RAX
SHL RDX,0x4
MOV RCX,qword ptr [RCX + RDX*0x1 + 0x8]
MOV qword ptr [R12 + RAX*0x8],RCX
INC EAX
JMP 0x001787cc
LAB_001787eb:
MOV RSI,qword ptr [RBP + 0x8]
MOV RDI,R14
MOV RDX,R12
MOV ECX,R15D
CALL 0x001785a4
MOV RDI,R12
CALL 0x0010a710
LEA R15,[0x1a1408]
LAB_0017880c:
INC R13D
JMP 0x00178666
LAB_00178814:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
caseD_d:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a299a]
MOV ECX,0x4c3c
JMP 0x0017888b
LAB_00178858:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2d25]
MOV ECX,0x4c37
LAB_0017888b:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void gguf_set_kv(int8 param_1,long param_2)
{
int iVar1;
ulong uVar2;
uint uVar3;
void *__ptr;
ulong uVar4;
long lVar5;
int8 uVar6;
FILE *__stream;
char *pcVar7;
uint uVar8;
uVar8 = 0;
do {
if (*(ulong *)(param_2 + 0x10) <= (ulong)uVar8) {
return;
}
lVar5 = (ulong)uVar8 * 0x30;
uVar3 = *(uint *)(*(long *)(param_2 + 0x18) + 0x10 + lVar5);
if (uVar3 < 0xe) {
lVar5 = *(long *)(param_2 + 0x18) + lVar5;
switch(uVar3) {
case 0:
gguf_set_val_u8(param_1,*(int8 *)(lVar5 + 8),*(int1 *)(lVar5 + 0x18));
break;
case 1:
gguf_set_val_i8(param_1,*(int8 *)(lVar5 + 8),(int)*(char *)(lVar5 + 0x18));
break;
case 2:
gguf_set_val_u16(param_1,*(int8 *)(lVar5 + 8),*(int2 *)(lVar5 + 0x18));
break;
case 3:
gguf_set_val_i16(param_1,*(int8 *)(lVar5 + 8),(int)*(short *)(lVar5 + 0x18));
break;
case 4:
gguf_set_val_u32(param_1,*(int8 *)(lVar5 + 8),*(int4 *)(lVar5 + 0x18));
break;
case 5:
gguf_set_val_i32(param_1,*(int8 *)(lVar5 + 8),*(int4 *)(lVar5 + 0x18));
break;
case 6:
gguf_set_val_f32(*(int4 *)(lVar5 + 0x18),param_1,*(int8 *)(lVar5 + 8));
break;
case 7:
gguf_set_val_bool(param_1,*(int8 *)(lVar5 + 8),*(int1 *)(lVar5 + 0x18));
break;
case 8:
gguf_set_val_str(param_1,*(int8 *)(lVar5 + 8),*(int8 *)(lVar5 + 0x20));
break;
case 9:
iVar1 = *(int *)(lVar5 + 0x18);
if (iVar1 == 8) {
uVar2 = *(ulong *)(lVar5 + 0x20);
__ptr = malloc(uVar2 * 8);
for (uVar3 = 0; uVar4 = (ulong)uVar3, uVar4 < uVar2; uVar3 = uVar3 + 1) {
*(int8 *)((long)__ptr + uVar4 * 8) =
*(int8 *)(*(long *)(lVar5 + 0x28) + 8 + uVar4 * 0x10);
}
gguf_set_arr_str(param_1,*(int8 *)(lVar5 + 8),__ptr,uVar2 & 0xffffffff);
free(__ptr);
}
else {
if (iVar1 == 9) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar7 = "false && \"nested arrays not supported\"";
uVar6 = 0x4c37;
goto LAB_0017888b;
}
gguf_set_arr_data(param_1,*(int8 *)(lVar5 + 8),iVar1,*(int8 *)(lVar5 + 0x28),
*(int4 *)(lVar5 + 0x20));
}
break;
case 10:
gguf_set_val_u64(param_1,*(int8 *)(lVar5 + 8),*(int8 *)(lVar5 + 0x18));
break;
case 0xb:
gguf_set_val_i64(param_1,*(int8 *)(lVar5 + 8),*(int8 *)(lVar5 + 0x18));
break;
case 0xc:
gguf_set_val_f64(*(int8 *)(lVar5 + 0x18),param_1,*(int8 *)(lVar5 + 8));
break;
case 0xd:
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar7 = "false && \"invalid type\"";
uVar6 = 0x4c3c;
LAB_0017888b:
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c"
,uVar6,pcVar7);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
}
uVar8 = uVar8 + 1;
} while( true );
}
| |
43,417 | ma_checksum | eloqsql/storage/maria/ma_checksum.c | ha_checksum _ma_checksum(MARIA_HA *info, const uchar *record)
{
ha_checksum crc=0;
uint i,end;
MARIA_COLUMNDEF *base_column= info->s->columndef;
uint16 *column_nr= info->s->column_nr;
if (info->s->base.null_bytes)
crc= my_checksum(crc, record, info->s->base.null_bytes);
for (i= 0, end= info->s->base.fields ; i < end ; i++)
{
MARIA_COLUMNDEF *column= base_column + column_nr[i];
const uchar *pos;
ulong length;
if (record[column->null_pos] & column->null_bit)
continue; /* Null field */
pos= record + column->offset;
switch (column->type) {
case FIELD_BLOB:
{
uint blob_size_length= column->length- portable_sizeof_char_ptr;
length= _ma_calc_blob_length(blob_size_length, pos);
if (length)
{
memcpy((char**) &pos, pos + blob_size_length, sizeof(char*));
crc= my_checksum(crc, pos, length);
}
continue;
}
case FIELD_VARCHAR:
{
uint pack_length= column->fill_length;
if (pack_length == 1)
length= (ulong) *pos;
else
length= uint2korr(pos);
pos+= pack_length; /* Skip length information */
break;
}
default:
length= column->length;
break;
}
crc= my_checksum(crc, pos, length);
}
return crc;
} | O0 | c | ma_checksum:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x588(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x5a8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x3fc(%rax)
je 0x9d5e9
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x3fc(%rax), %eax
movl %eax, %edx
callq 0x103b10
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x3c8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x9d72d
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movl -0x18(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
movslq %ecx, %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movzbl 0x12(%rcx), %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x9d64d
jmp 0x9d71f
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x54(%rbp)
subl $0x4, %eax
je 0x9d67c
jmp 0x9d66f
movl -0x54(%rbp), %eax
subl $0x8, %eax
je 0x9d6c5
jmp 0x9d700
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
subl $0x8, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
movq -0x40(%rbp), %rsi
callq 0x53f70
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9d6c3
movq -0x40(%rbp), %rax
movl -0x4c(%rbp), %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x103b10
movl %eax, -0x14(%rbp)
jmp 0x9d71f
movq -0x38(%rbp), %rax
movzwl 0xc(%rax), %eax
movl %eax, -0x50(%rbp)
cmpl $0x1, -0x50(%rbp)
jne 0x9d6e3
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
movq %rax, -0x48(%rbp)
jmp 0x9d6ee
movq -0x40(%rbp), %rax
movzwl (%rax), %eax
movq %rax, -0x48(%rbp)
movl -0x50(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
jmp 0x9d70c
movq -0x38(%rbp), %rax
movzwl 0x8(%rax), %eax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %edi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x103b10
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9d600
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_checksum:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+588h]
mov [rbp+var_28], rax
mov rax, [rbp+var_8]
mov rax, [rax]
mov rax, [rax+5A8h]
mov [rbp+var_30], rax
mov rax, [rbp+var_8]
mov rax, [rax]
cmp dword ptr [rax+3FCh], 0
jz short loc_9D5E9
mov edi, [rbp+var_14]
mov rsi, [rbp+var_10]
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+3FCh]
mov edx, eax
call my_checksum
mov [rbp+var_14], eax
loc_9D5E9:
mov [rbp+var_18], 0
mov rax, [rbp+var_8]
mov rax, [rax]
mov eax, [rax+3C8h]
mov [rbp+var_1C], eax
loc_9D600:
mov eax, [rbp+var_18]
cmp eax, [rbp+var_1C]
jnb loc_9D72D
mov rax, [rbp+var_28]
mov rcx, [rbp+var_30]
mov edx, [rbp+var_18]
movzx ecx, word ptr [rcx+rdx*2]
movsxd rcx, ecx
imul rcx, 38h ; '8'
add rax, rcx
mov [rbp+var_38], rax
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
movzx ecx, word ptr [rcx+0Eh]
movzx eax, byte ptr [rax+rcx]
mov rcx, [rbp+var_38]
movzx ecx, byte ptr [rcx+12h]
and eax, ecx
cmp eax, 0
jz short loc_9D64D
jmp loc_9D71F
loc_9D64D:
mov rax, [rbp+var_10]
mov rcx, [rbp+var_38]
mov ecx, [rcx+4]
add rax, rcx
mov [rbp+var_40], rax
mov rax, [rbp+var_38]
mov eax, [rax]
mov [rbp+var_54], eax
sub eax, 4
jz short loc_9D67C
jmp short $+2
loc_9D66F:
mov eax, [rbp+var_54]
sub eax, 8
jz short loc_9D6C5
jmp loc_9D700
loc_9D67C:
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+8]
sub eax, 8
mov [rbp+var_4C], eax
mov edi, [rbp+var_4C]
mov rsi, [rbp+var_40]
call _ma_calc_blob_length
mov [rbp+var_48], rax
cmp [rbp+var_48], 0
jz short loc_9D6C3
mov rax, [rbp+var_40]
mov ecx, [rbp+var_4C]
mov rax, [rax+rcx]
mov [rbp+var_40], rax
mov edi, [rbp+var_14]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_48]
call my_checksum
mov [rbp+var_14], eax
loc_9D6C3:
jmp short loc_9D71F
loc_9D6C5:
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+0Ch]
mov [rbp+var_50], eax
cmp [rbp+var_50], 1
jnz short loc_9D6E3
mov rax, [rbp+var_40]
movzx eax, byte ptr [rax]
mov [rbp+var_48], rax
jmp short loc_9D6EE
loc_9D6E3:
mov rax, [rbp+var_40]
movzx eax, word ptr [rax]
mov [rbp+var_48], rax
loc_9D6EE:
mov ecx, [rbp+var_50]
mov rax, [rbp+var_40]
mov ecx, ecx
add rax, rcx
mov [rbp+var_40], rax
jmp short loc_9D70C
loc_9D700:
mov rax, [rbp+var_38]
movzx eax, word ptr [rax+8]
mov [rbp+var_48], rax
loc_9D70C:
mov edi, [rbp+var_14]
mov rsi, [rbp+var_40]
mov rdx, [rbp+var_48]
call my_checksum
mov [rbp+var_14], eax
loc_9D71F:
mov eax, [rbp+var_18]
add eax, 1
mov [rbp+var_18], eax
jmp loc_9D600
loc_9D72D:
mov eax, [rbp+var_14]
add rsp, 60h
pop rbp
retn
| long long ma_checksum(long long a1, long long a2)
{
unsigned int v3; // [rsp+14h] [rbp-4Ch]
long long v4; // [rsp+18h] [rbp-48h]
long long v5; // [rsp+18h] [rbp-48h]
unsigned __int8 *v6; // [rsp+20h] [rbp-40h]
long long v7; // [rsp+28h] [rbp-38h]
long long v8; // [rsp+30h] [rbp-30h]
long long v9; // [rsp+38h] [rbp-28h]
unsigned int v10; // [rsp+44h] [rbp-1Ch]
unsigned int v11; // [rsp+48h] [rbp-18h]
unsigned int v12; // [rsp+4Ch] [rbp-14h]
v12 = 0;
v9 = *(_QWORD *)(*(_QWORD *)a1 + 1416LL);
v8 = *(_QWORD *)(*(_QWORD *)a1 + 1448LL);
if ( *(_DWORD *)(*(_QWORD *)a1 + 1020LL) )
v12 = my_checksum(0LL, a2, *(unsigned int *)(*(_QWORD *)a1 + 1020LL));
v11 = 0;
v10 = *(_DWORD *)(*(_QWORD *)a1 + 968LL);
while ( v11 < v10 )
{
v7 = 56LL * *(unsigned __int16 *)(v8 + 2LL * v11) + v9;
if ( (*(_BYTE *)(v7 + 18) & *(_BYTE *)(a2 + *(unsigned __int16 *)(v7 + 14))) == 0 )
{
v6 = (unsigned __int8 *)(*(unsigned int *)(v7 + 4) + a2);
if ( *(_DWORD *)v7 == 4 )
{
v3 = *(unsigned __int16 *)(v7 + 8) - 8;
v4 = ma_calc_blob_length(v3, v6);
if ( v4 )
v12 = my_checksum(v12, *(_QWORD *)&v6[v3], v4);
}
else
{
if ( *(_DWORD *)v7 == 8 )
{
if ( *(_WORD *)(v7 + 12) == 1 )
v5 = *v6;
else
v5 = *(unsigned __int16 *)v6;
v6 += *(unsigned __int16 *)(v7 + 12);
}
else
{
v5 = *(unsigned __int16 *)(v7 + 8);
}
v12 = my_checksum(v12, v6, v5);
}
}
++v11;
}
return v12;
}
| _ma_checksum:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x588]
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x5a8]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
CMP dword ptr [RAX + 0x3fc],0x0
JZ 0x0019d5e9
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x3fc]
MOV EDX,EAX
CALL 0x00203b10
MOV dword ptr [RBP + -0x14],EAX
LAB_0019d5e9:
MOV dword ptr [RBP + -0x18],0x0
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x3c8]
MOV dword ptr [RBP + -0x1c],EAX
LAB_0019d600:
MOV EAX,dword ptr [RBP + -0x18]
CMP EAX,dword ptr [RBP + -0x1c]
JNC 0x0019d72d
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x30]
MOV EDX,dword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RCX + RDX*0x2]
MOVSXD RCX,ECX
IMUL RCX,RCX,0x38
ADD RAX,RCX
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,word ptr [RCX + 0xe]
MOVZX EAX,byte ptr [RAX + RCX*0x1]
MOV RCX,qword ptr [RBP + -0x38]
MOVZX ECX,byte ptr [RCX + 0x12]
AND EAX,ECX
CMP EAX,0x0
JZ 0x0019d64d
JMP 0x0019d71f
LAB_0019d64d:
MOV RAX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x38]
MOV ECX,dword ptr [RCX + 0x4]
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x54],EAX
SUB EAX,0x4
JZ 0x0019d67c
JMP 0x0019d66f
LAB_0019d66f:
MOV EAX,dword ptr [RBP + -0x54]
SUB EAX,0x8
JZ 0x0019d6c5
JMP 0x0019d700
LAB_0019d67c:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x8]
SUB EAX,0x8
MOV dword ptr [RBP + -0x4c],EAX
MOV EDI,dword ptr [RBP + -0x4c]
MOV RSI,qword ptr [RBP + -0x40]
CALL 0x00153f70
MOV qword ptr [RBP + -0x48],RAX
CMP qword ptr [RBP + -0x48],0x0
JZ 0x0019d6c3
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RBP + -0x4c]
MOV RAX,qword ptr [RAX + RCX*0x1]
MOV qword ptr [RBP + -0x40],RAX
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00203b10
MOV dword ptr [RBP + -0x14],EAX
LAB_0019d6c3:
JMP 0x0019d71f
LAB_0019d6c5:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x50],EAX
CMP dword ptr [RBP + -0x50],0x1
JNZ 0x0019d6e3
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
JMP 0x0019d6ee
LAB_0019d6e3:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX EAX,word ptr [RAX]
MOV qword ptr [RBP + -0x48],RAX
LAB_0019d6ee:
MOV ECX,dword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x40],RAX
JMP 0x0019d70c
LAB_0019d700:
MOV RAX,qword ptr [RBP + -0x38]
MOVZX EAX,word ptr [RAX + 0x8]
MOV qword ptr [RBP + -0x48],RAX
LAB_0019d70c:
MOV EDI,dword ptr [RBP + -0x14]
MOV RSI,qword ptr [RBP + -0x40]
MOV RDX,qword ptr [RBP + -0x48]
CALL 0x00203b10
MOV dword ptr [RBP + -0x14],EAX
LAB_0019d71f:
MOV EAX,dword ptr [RBP + -0x18]
ADD EAX,0x1
MOV dword ptr [RBP + -0x18],EAX
JMP 0x0019d600
LAB_0019d72d:
MOV EAX,dword ptr [RBP + -0x14]
ADD RSP,0x60
POP RBP
RET
|
int4 _ma_checksum(long *param_1,long param_2)
{
uint uVar1;
long lVar2;
long lVar3;
ushort uVar4;
int *piVar5;
long lVar6;
ushort *local_48;
uint local_20;
int4 local_1c;
local_1c = 0;
lVar2 = *(long *)(*param_1 + 0x588);
lVar3 = *(long *)(*param_1 + 0x5a8);
if (*(int *)(*param_1 + 0x3fc) != 0) {
local_1c = my_checksum(0,param_2,*(int4 *)(*param_1 + 0x3fc));
}
local_20 = 0;
uVar1 = *(uint *)(*param_1 + 0x3c8);
for (; local_20 < uVar1; local_20 = local_20 + 1) {
piVar5 = (int *)(lVar2 + (long)(int)(uint)*(ushort *)(lVar3 + (ulong)local_20 * 2) * 0x38);
if ((*(byte *)(param_2 + (ulong)*(ushort *)((long)piVar5 + 0xe)) &
*(byte *)((long)piVar5 + 0x12)) == 0) {
local_48 = (ushort *)(param_2 + (ulong)(uint)piVar5[1]);
if (*piVar5 == 4) {
uVar4 = *(ushort *)(piVar5 + 2);
lVar6 = _ma_calc_blob_length(uVar4 - 8,local_48);
if (lVar6 != 0) {
local_1c = my_checksum(local_1c,*(int8 *)((long)local_48 + (ulong)(uVar4 - 8)),lVar6
);
}
}
else {
if (*piVar5 == 8) {
if (*(ushort *)(piVar5 + 3) == 1) {
uVar4 = (ushort)(byte)*local_48;
}
else {
uVar4 = *local_48;
}
local_48 = (ushort *)((long)local_48 + (ulong)(uint)*(ushort *)(piVar5 + 3));
}
else {
uVar4 = *(ushort *)(piVar5 + 2);
}
local_1c = my_checksum(local_1c,local_48,uVar4);
}
}
}
return local_1c;
}
| |
43,418 | common_model_params_to_llama(common_params&) | monkey531[P]llama/common/common.cpp | struct llama_model_params common_model_params_to_llama(common_params & params) {
auto mparams = llama_model_default_params();
if (!params.devices.empty()) {
mparams.devices = params.devices.data();
}
if (params.n_gpu_layers != -1) {
mparams.n_gpu_layers = params.n_gpu_layers;
}
mparams.main_gpu = params.main_gpu;
mparams.split_mode = params.split_mode;
mparams.tensor_split = params.tensor_split;
mparams.use_mmap = params.use_mmap;
mparams.use_mlock = params.use_mlock;
mparams.check_tensors = params.check_tensors;
if (params.kv_overrides.empty()) {
mparams.kv_overrides = NULL;
} else {
GGML_ASSERT(params.kv_overrides.back().key[0] == 0 && "KV overrides not terminated with empty key");
mparams.kv_overrides = params.kv_overrides.data();
}
return mparams;
} | O2 | cpp | common_model_params_to_llama(common_params&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x24e70
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x56527
movq %rax, (%rbx)
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x56533
movl %eax, 0x8(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x270(%r14), %eax
movl %eax, 0xc(%rbx)
leaq 0x70(%r14), %rax
movq %rax, 0x18(%rbx)
movb 0xfe9(%r14), %al
movb %al, 0x39(%rbx)
movb 0xfea(%r14), %al
movb %al, 0x3a(%rbx)
movb 0xff0(%r14), %al
movb %al, 0x3b(%rbx)
movq 0xf48(%r14), %rax
movq 0xf50(%r14), %rcx
cmpq %rcx, %rax
je 0x565a7
cmpb $0x0, -0x104(%rcx)
je 0x565a9
leaq 0x5e514(%rip), %rdi # 0xb4aa1
leaq 0x5b6f2(%rip), %rdx # 0xb1c86
leaq 0x5ea0b(%rip), %rcx # 0xb4fa6
movl $0x44b, %esi # imm = 0x44B
xorl %eax, %eax
callq 0x24ea0
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z28common_model_params_to_llamaR13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_model_default_params
mov rax, [r14+50h]
cmp rax, [r14+58h]
jz short loc_56527
mov [rbx], rax
loc_56527:
mov eax, [r14+68h]
cmp eax, 0FFFFFFFFh
jz short loc_56533
mov [rbx+8], eax
loc_56533:
mov eax, [r14+6Ch]
mov [rbx+10h], eax
mov eax, [r14+270h]
mov [rbx+0Ch], eax
lea rax, [r14+70h]
mov [rbx+18h], rax
mov al, [r14+0FE9h]
mov [rbx+39h], al
mov al, [r14+0FEAh]
mov [rbx+3Ah], al
mov al, [r14+0FF0h]
mov [rbx+3Bh], al
mov rax, [r14+0F48h]
mov rcx, [r14+0F50h]
cmp rax, rcx
jz short loc_565A7
cmp byte ptr [rcx-104h], 0
jz short loc_565A9
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aParamsKvOverri; "params.kv_overrides.back().key[0] == 0 "...
mov esi, 44Bh
xor eax, eax
call _ggml_abort
loc_565A7:
xor eax, eax
loc_565A9:
mov [rbx+30h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| common_params * common_model_params_to_llama(common_params *a1, long long a2)
{
long long v2; // rax
int v3; // eax
long long v4; // rax
long long v5; // rcx
llama_model_default_params(a1);
v2 = *(_QWORD *)(a2 + 80);
if ( v2 != *(_QWORD *)(a2 + 88) )
*(_QWORD *)a1 = v2;
v3 = *(_DWORD *)(a2 + 104);
if ( v3 != -1 )
*((_DWORD *)a1 + 2) = v3;
*((_DWORD *)a1 + 4) = *(_DWORD *)(a2 + 108);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 624);
*((_QWORD *)a1 + 3) = a2 + 112;
*((_BYTE *)a1 + 57) = *(_BYTE *)(a2 + 4073);
*((_BYTE *)a1 + 58) = *(_BYTE *)(a2 + 4074);
*((_BYTE *)a1 + 59) = *(_BYTE *)(a2 + 4080);
v4 = *(_QWORD *)(a2 + 3912);
v5 = *(_QWORD *)(a2 + 3920);
if ( v4 == v5 )
goto LABEL_8;
if ( *(_BYTE *)(v5 - 260) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1099LL,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\"");
LABEL_8:
v4 = 0LL;
}
*((_QWORD *)a1 + 6) = v4;
return a1;
}
| common_model_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x00124e70
MOV RAX,qword ptr [R14 + 0x50]
CMP RAX,qword ptr [R14 + 0x58]
JZ 0x00156527
MOV qword ptr [RBX],RAX
LAB_00156527:
MOV EAX,dword ptr [R14 + 0x68]
CMP EAX,-0x1
JZ 0x00156533
MOV dword ptr [RBX + 0x8],EAX
LAB_00156533:
MOV EAX,dword ptr [R14 + 0x6c]
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R14 + 0x270]
MOV dword ptr [RBX + 0xc],EAX
LEA RAX,[R14 + 0x70]
MOV qword ptr [RBX + 0x18],RAX
MOV AL,byte ptr [R14 + 0xfe9]
MOV byte ptr [RBX + 0x39],AL
MOV AL,byte ptr [R14 + 0xfea]
MOV byte ptr [RBX + 0x3a],AL
MOV AL,byte ptr [R14 + 0xff0]
MOV byte ptr [RBX + 0x3b],AL
MOV RAX,qword ptr [R14 + 0xf48]
MOV RCX,qword ptr [R14 + 0xf50]
CMP RAX,RCX
JZ 0x001565a7
CMP byte ptr [RCX + -0x104],0x0
JZ 0x001565a9
LEA RDI,[0x1b4aa1]
LEA RDX,[0x1b1c86]
LEA RCX,[0x1b4fa6]
MOV ESI,0x44b
XOR EAX,EAX
CALL 0x00124ea0
LAB_001565a7:
XOR EAX,EAX
LAB_001565a9:
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_model_params_to_llama(common_params&) */
common_params * common_model_params_to_llama(common_params *param_1)
{
long lVar1;
long in_RSI;
llama_model_default_params();
if (*(long *)(in_RSI + 0x50) != *(long *)(in_RSI + 0x58)) {
*(long *)param_1 = *(long *)(in_RSI + 0x50);
}
if (*(int *)(in_RSI + 0x68) != -1) {
*(int *)(param_1 + 8) = *(int *)(in_RSI + 0x68);
}
*(int4 *)(param_1 + 0x10) = *(int4 *)(in_RSI + 0x6c);
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x270);
*(long *)(param_1 + 0x18) = in_RSI + 0x70;
param_1[0x39] = *(common_params *)(in_RSI + 0xfe9);
param_1[0x3a] = *(common_params *)(in_RSI + 0xfea);
param_1[0x3b] = *(common_params *)(in_RSI + 0xff0);
lVar1 = *(long *)(in_RSI + 0xf48);
if (lVar1 == *(long *)(in_RSI + 0xf50)) {
lVar1 = 0;
}
else if (*(char *)(*(long *)(in_RSI + 0xf50) + -0x104) != '\0') {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",1099,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\""
);
}
*(long *)(param_1 + 0x30) = lVar1;
return param_1;
}
| |
43,419 | common_model_params_to_llama(common_params&) | monkey531[P]llama/common/common.cpp | struct llama_model_params common_model_params_to_llama(common_params & params) {
auto mparams = llama_model_default_params();
if (!params.devices.empty()) {
mparams.devices = params.devices.data();
}
if (params.n_gpu_layers != -1) {
mparams.n_gpu_layers = params.n_gpu_layers;
}
mparams.main_gpu = params.main_gpu;
mparams.split_mode = params.split_mode;
mparams.tensor_split = params.tensor_split;
mparams.use_mmap = params.use_mmap;
mparams.use_mlock = params.use_mlock;
mparams.check_tensors = params.check_tensors;
if (params.kv_overrides.empty()) {
mparams.kv_overrides = NULL;
} else {
GGML_ASSERT(params.kv_overrides.back().key[0] == 0 && "KV overrides not terminated with empty key");
mparams.kv_overrides = params.kv_overrides.data();
}
return mparams;
} | O3 | cpp | common_model_params_to_llama(common_params&):
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1be70
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x75350
movq %rax, (%rbx)
movl 0x68(%r14), %eax
cmpl $-0x1, %eax
je 0x7535c
movl %eax, 0x8(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x10(%rbx)
movl 0x270(%r14), %eax
movl %eax, 0xc(%rbx)
leaq 0x70(%r14), %rax
movq %rax, 0x18(%rbx)
movb 0xfe9(%r14), %al
movb %al, 0x39(%rbx)
movb 0xfea(%r14), %al
movb %al, 0x3a(%rbx)
movb 0xff0(%r14), %al
movb %al, 0x3b(%rbx)
movq 0xf48(%r14), %rax
movq 0xf50(%r14), %rcx
cmpq %rcx, %rax
je 0x753d0
cmpb $0x0, -0x104(%rcx)
je 0x753d2
leaq 0x7b6fb(%rip), %rdi # 0xf0ab1
leaq 0x788c6(%rip), %rdx # 0xedc83
leaq 0x7bbf2(%rip), %rcx # 0xf0fb6
movl $0x44b, %esi # imm = 0x44B
xorl %eax, %eax
callq 0x1be90
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| _Z28common_model_params_to_llamaR13common_params:
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
call _llama_model_default_params
mov rax, [r14+50h]
cmp rax, [r14+58h]
jz short loc_75350
mov [rbx], rax
loc_75350:
mov eax, [r14+68h]
cmp eax, 0FFFFFFFFh
jz short loc_7535C
mov [rbx+8], eax
loc_7535C:
mov eax, [r14+6Ch]
mov [rbx+10h], eax
mov eax, [r14+270h]
mov [rbx+0Ch], eax
lea rax, [r14+70h]
mov [rbx+18h], rax
mov al, [r14+0FE9h]
mov [rbx+39h], al
mov al, [r14+0FEAh]
mov [rbx+3Ah], al
mov al, [r14+0FF0h]
mov [rbx+3Bh], al
mov rax, [r14+0F48h]
mov rcx, [r14+0F50h]
cmp rax, rcx
jz short loc_753D0
cmp byte ptr [rcx-104h], 0
jz short loc_753D2
lea rdi, aWorkspaceLlm4b_1; "/workspace/llm4binary/github/2025_star3"...
lea rdx, aGgmlAssertSFai; "GGML_ASSERT(%s) failed"
lea rcx, aParamsKvOverri; "params.kv_overrides.back().key[0] == 0 "...
mov esi, 44Bh
xor eax, eax
call _ggml_abort
loc_753D0:
xor eax, eax
loc_753D2:
mov [rbx+30h], rax
mov rax, rbx
add rsp, 8
pop rbx
pop r14
retn
| common_params * common_model_params_to_llama(common_params *a1, long long a2)
{
long long v2; // rax
int v3; // eax
long long v4; // rax
long long v5; // rcx
llama_model_default_params(a1);
v2 = *(_QWORD *)(a2 + 80);
if ( v2 != *(_QWORD *)(a2 + 88) )
*(_QWORD *)a1 = v2;
v3 = *(_DWORD *)(a2 + 104);
if ( v3 != -1 )
*((_DWORD *)a1 + 2) = v3;
*((_DWORD *)a1 + 4) = *(_DWORD *)(a2 + 108);
*((_DWORD *)a1 + 3) = *(_DWORD *)(a2 + 624);
*((_QWORD *)a1 + 3) = a2 + 112;
*((_BYTE *)a1 + 57) = *(_BYTE *)(a2 + 4073);
*((_BYTE *)a1 + 58) = *(_BYTE *)(a2 + 4074);
*((_BYTE *)a1 + 59) = *(_BYTE *)(a2 + 4080);
v4 = *(_QWORD *)(a2 + 3912);
v5 = *(_QWORD *)(a2 + 3920);
if ( v4 == v5 )
goto LABEL_8;
if ( *(_BYTE *)(v5 - 260) )
{
ggml_abort(
"/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",
1099LL,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\"");
LABEL_8:
v4 = 0LL;
}
*((_QWORD *)a1 + 6) = v4;
return a1;
}
| common_model_params_to_llama:
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
CALL 0x0011be70
MOV RAX,qword ptr [R14 + 0x50]
CMP RAX,qword ptr [R14 + 0x58]
JZ 0x00175350
MOV qword ptr [RBX],RAX
LAB_00175350:
MOV EAX,dword ptr [R14 + 0x68]
CMP EAX,-0x1
JZ 0x0017535c
MOV dword ptr [RBX + 0x8],EAX
LAB_0017535c:
MOV EAX,dword ptr [R14 + 0x6c]
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R14 + 0x270]
MOV dword ptr [RBX + 0xc],EAX
LEA RAX,[R14 + 0x70]
MOV qword ptr [RBX + 0x18],RAX
MOV AL,byte ptr [R14 + 0xfe9]
MOV byte ptr [RBX + 0x39],AL
MOV AL,byte ptr [R14 + 0xfea]
MOV byte ptr [RBX + 0x3a],AL
MOV AL,byte ptr [R14 + 0xff0]
MOV byte ptr [RBX + 0x3b],AL
MOV RAX,qword ptr [R14 + 0xf48]
MOV RCX,qword ptr [R14 + 0xf50]
CMP RAX,RCX
JZ 0x001753d0
CMP byte ptr [RCX + -0x104],0x0
JZ 0x001753d2
LEA RDI,[0x1f0ab1]
LEA RDX,[0x1edc83]
LEA RCX,[0x1f0fb6]
MOV ESI,0x44b
XOR EAX,EAX
CALL 0x0011be90
LAB_001753d0:
XOR EAX,EAX
LAB_001753d2:
MOV qword ptr [RBX + 0x30],RAX
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R14
RET
|
/* common_model_params_to_llama(common_params&) */
common_params * common_model_params_to_llama(common_params *param_1)
{
long lVar1;
long in_RSI;
llama_model_default_params();
if (*(long *)(in_RSI + 0x50) != *(long *)(in_RSI + 0x58)) {
*(long *)param_1 = *(long *)(in_RSI + 0x50);
}
if (*(int *)(in_RSI + 0x68) != -1) {
*(int *)(param_1 + 8) = *(int *)(in_RSI + 0x68);
}
*(int4 *)(param_1 + 0x10) = *(int4 *)(in_RSI + 0x6c);
*(int4 *)(param_1 + 0xc) = *(int4 *)(in_RSI + 0x270);
*(long *)(param_1 + 0x18) = in_RSI + 0x70;
param_1[0x39] = *(common_params *)(in_RSI + 0xfe9);
param_1[0x3a] = *(common_params *)(in_RSI + 0xfea);
param_1[0x3b] = *(common_params *)(in_RSI + 0xff0);
lVar1 = *(long *)(in_RSI + 0xf48);
if (lVar1 == *(long *)(in_RSI + 0xf50)) {
lVar1 = 0;
}
else if (*(char *)(*(long *)(in_RSI + 0xf50) + -0x104) != '\0') {
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/monkey531[P]llama/common/common.cpp",1099,
"GGML_ASSERT(%s) failed",
"params.kv_overrides.back().key[0] == 0 && \"KV overrides not terminated with empty key\""
);
}
*(long *)(param_1 + 0x30) = lVar1;
return param_1;
}
| |
43,420 | LefDefParser::defiRegion::addRect(int, int, int, int) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/def/def/defiRegion.cpp | void defiRegion::addRect(int xl, int yl, int xh, int yh) {
if (numRectangles_ == rectanglesAllocated_) {
int i;
int max = rectanglesAllocated_ = rectanglesAllocated_ * 2;
int* newxl = (int*)malloc(sizeof(int)*max);
int* newyl = (int*)malloc(sizeof(int)*max);
int* newxh = (int*)malloc(sizeof(int)*max);
int* newyh = (int*)malloc(sizeof(int)*max);
for (i = 0; i < numRectangles_; i++) {
newxl[i] = xl_[i];
newyl[i] = yl_[i];
newxh[i] = xh_[i];
newyh[i] = yh_[i];
}
free((char*)(xl_));
free((char*)(yl_));
free((char*)(xh_));
free((char*)(yh_));
xl_ = newxl;
yl_ = newyl;
xh_ = newxh;
yh_ = newyh;
}
xl_[numRectangles_] = xl;
yl_[numRectangles_] = yl;
xh_[numRectangles_] = xh;
yh_[numRectangles_] = yh;
numRectangles_ += 1;
} | O3 | cpp | LefDefParser::defiRegion::addRect(int, int, int, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movl 0xc(%rdi), %r12d
cmpl 0x10(%rdi), %r12d
jne 0x150c5
movl %esi, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0x14(%rsp)
movslq %r12d, %r15
leal (%r12,%r12), %eax
movl %eax, 0x10(%r14)
shlq $0x3, %r15
movq %r15, %rdi
callq 0x7270
movq %rax, %r13
movq %r15, %rdi
callq 0x7270
movq %rax, %rbx
movq %r15, %rdi
callq 0x7270
movq %rax, %rbp
movq %r15, %rdi
callq 0x7270
movq %rax, %r15
movq 0x18(%r14), %rdi
testl %r12d, %r12d
jle 0x1507e
movq 0x20(%r14), %rax
movq 0x28(%r14), %rcx
movq 0x30(%r14), %rdx
xorl %esi, %esi
movl (%rdi,%rsi,4), %r8d
movl %r8d, (%r13,%rsi,4)
movl (%rax,%rsi,4), %r8d
movl %r8d, (%rbx,%rsi,4)
movl (%rcx,%rsi,4), %r8d
movl %r8d, (%rbp,%rsi,4)
movl (%rdx,%rsi,4), %r8d
movl %r8d, (%r15,%rsi,4)
incq %rsi
cmpq %rsi, %r12
jne 0x15054
callq 0x7220
movq 0x20(%r14), %rdi
callq 0x7220
movq 0x28(%r14), %rdi
callq 0x7220
movq 0x30(%r14), %rdi
callq 0x7220
movq %r13, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq %rbp, 0x28(%r14)
movq %r15, 0x30(%r14)
movl 0xc(%r14), %r12d
movl 0x14(%rsp), %r8d
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %esi
jmp 0x150d5
movq 0x18(%r14), %r13
movq 0x20(%r14), %rbx
movq 0x28(%r14), %rbp
movq 0x30(%r14), %r15
movslq %r12d, %rax
movl %esi, (%r13,%rax,4)
movslq 0xc(%r14), %rax
movl %edx, (%rbx,%rax,4)
movslq 0xc(%r14), %rax
movl %ecx, (%rbp,%rax,4)
movslq 0xc(%r14), %rax
movl %r8d, (%r15,%rax,4)
incl 0xc(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| _ZN12LefDefParser10defiRegion7addRectEiiii:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov r14, rdi
mov r12d, [rdi+0Ch]
cmp r12d, [rdi+10h]
jnz loc_150C5
mov [rsp+48h+var_40], esi
mov [rsp+48h+var_3C], edx
mov [rsp+48h+var_38], ecx
mov [rsp+48h+var_34], r8d
movsxd r15, r12d
lea eax, [r12+r12]
mov [r14+10h], eax
shl r15, 3
mov rdi, r15
call _malloc
mov r13, rax
mov rdi, r15
call _malloc
mov rbx, rax
mov rdi, r15
call _malloc
mov rbp, rax
mov rdi, r15
call _malloc
mov r15, rax
mov rdi, [r14+18h]
test r12d, r12d
jle short loc_1507E
mov rax, [r14+20h]
mov rcx, [r14+28h]
mov rdx, [r14+30h]
xor esi, esi
loc_15054:
mov r8d, [rdi+rsi*4]
mov [r13+rsi*4+0], r8d
mov r8d, [rax+rsi*4]
mov [rbx+rsi*4], r8d
mov r8d, [rcx+rsi*4]
mov [rbp+rsi*4+0], r8d
mov r8d, [rdx+rsi*4]
mov [r15+rsi*4], r8d
inc rsi
cmp r12, rsi
jnz short loc_15054
loc_1507E:
call _free
mov rdi, [r14+20h]
call _free
mov rdi, [r14+28h]
call _free
mov rdi, [r14+30h]
call _free
mov [r14+18h], r13
mov [r14+20h], rbx
mov [r14+28h], rbp
mov [r14+30h], r15
mov r12d, [r14+0Ch]
mov r8d, [rsp+48h+var_34]
mov ecx, [rsp+48h+var_38]
mov edx, [rsp+48h+var_3C]
mov esi, [rsp+48h+var_40]
jmp short loc_150D5
loc_150C5:
mov r13, [r14+18h]
mov rbx, [r14+20h]
mov rbp, [r14+28h]
mov r15, [r14+30h]
loc_150D5:
movsxd rax, r12d
mov [r13+rax*4+0], esi
movsxd rax, dword ptr [r14+0Ch]
mov [rbx+rax*4], edx
movsxd rax, dword ptr [r14+0Ch]
mov [rbp+rax*4+0], ecx
movsxd rax, dword ptr [r14+0Ch]
mov [r15+rax*4], r8d
inc dword ptr [r14+0Ch]
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long LefDefParser::defiRegion::addRect(LefDefParser::defiRegion *this, int a2, int a3, int a4, int a5)
{
long long v6; // r12
long long v7; // r13
long long v8; // rbx
long long v9; // rbp
long long v10; // r15
_DWORD *v11; // rdi
long long v12; // rax
long long v13; // rcx
long long v14; // rdx
long long i; // rsi
long long result; // rax
int v17; // [rsp+8h] [rbp-40h]
int v18; // [rsp+Ch] [rbp-3Ch]
int v19; // [rsp+10h] [rbp-38h]
int v20; // [rsp+14h] [rbp-34h]
v6 = *((unsigned int *)this + 3);
if ( (_DWORD)v6 == *((_DWORD *)this + 4) )
{
v17 = a2;
v18 = a3;
v19 = a4;
v20 = a5;
*((_DWORD *)this + 4) = 2 * v6;
v7 = malloc(8LL * (int)v6);
v8 = malloc(8LL * (int)v6);
v9 = malloc(8LL * (int)v6);
v10 = malloc(8LL * (int)v6);
v11 = (_DWORD *)*((_QWORD *)this + 3);
if ( (int)v6 > 0 )
{
v12 = *((_QWORD *)this + 4);
v13 = *((_QWORD *)this + 5);
v14 = *((_QWORD *)this + 6);
for ( i = 0LL; i != v6; ++i )
{
*(_DWORD *)(v7 + 4 * i) = v11[i];
*(_DWORD *)(v8 + 4 * i) = *(_DWORD *)(v12 + 4 * i);
*(_DWORD *)(v9 + 4 * i) = *(_DWORD *)(v13 + 4 * i);
*(_DWORD *)(v10 + 4 * i) = *(_DWORD *)(v14 + 4 * i);
}
}
free(v11);
free(*((void **)this + 4));
free(*((void **)this + 5));
free(*((void **)this + 6));
*((_QWORD *)this + 3) = v7;
*((_QWORD *)this + 4) = v8;
*((_QWORD *)this + 5) = v9;
*((_QWORD *)this + 6) = v10;
LODWORD(v6) = *((_DWORD *)this + 3);
a5 = v20;
a4 = v19;
a3 = v18;
a2 = v17;
}
else
{
v7 = *((_QWORD *)this + 3);
v8 = *((_QWORD *)this + 4);
v9 = *((_QWORD *)this + 5);
v10 = *((_QWORD *)this + 6);
}
*(_DWORD *)(v7 + 4LL * (int)v6) = a2;
*(_DWORD *)(v8 + 4LL * *((int *)this + 3)) = a3;
*(_DWORD *)(v9 + 4LL * *((int *)this + 3)) = a4;
result = *((int *)this + 3);
*(_DWORD *)(v10 + 4 * result) = a5;
++*((_DWORD *)this + 3);
return result;
}
| addRect:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV R14,RDI
MOV R12D,dword ptr [RDI + 0xc]
CMP R12D,dword ptr [RDI + 0x10]
JNZ 0x001150c5
MOV dword ptr [RSP + 0x8],ESI
MOV dword ptr [RSP + 0xc],EDX
MOV dword ptr [RSP + 0x10],ECX
MOV dword ptr [RSP + 0x14],R8D
MOVSXD R15,R12D
LEA EAX,[R12 + R12*0x1]
MOV dword ptr [R14 + 0x10],EAX
SHL R15,0x3
MOV RDI,R15
CALL 0x00107270
MOV R13,RAX
MOV RDI,R15
CALL 0x00107270
MOV RBX,RAX
MOV RDI,R15
CALL 0x00107270
MOV RBP,RAX
MOV RDI,R15
CALL 0x00107270
MOV R15,RAX
MOV RDI,qword ptr [R14 + 0x18]
TEST R12D,R12D
JLE 0x0011507e
MOV RAX,qword ptr [R14 + 0x20]
MOV RCX,qword ptr [R14 + 0x28]
MOV RDX,qword ptr [R14 + 0x30]
XOR ESI,ESI
LAB_00115054:
MOV R8D,dword ptr [RDI + RSI*0x4]
MOV dword ptr [R13 + RSI*0x4],R8D
MOV R8D,dword ptr [RAX + RSI*0x4]
MOV dword ptr [RBX + RSI*0x4],R8D
MOV R8D,dword ptr [RCX + RSI*0x4]
MOV dword ptr [RBP + RSI*0x4],R8D
MOV R8D,dword ptr [RDX + RSI*0x4]
MOV dword ptr [R15 + RSI*0x4],R8D
INC RSI
CMP R12,RSI
JNZ 0x00115054
LAB_0011507e:
CALL 0x00107220
MOV RDI,qword ptr [R14 + 0x20]
CALL 0x00107220
MOV RDI,qword ptr [R14 + 0x28]
CALL 0x00107220
MOV RDI,qword ptr [R14 + 0x30]
CALL 0x00107220
MOV qword ptr [R14 + 0x18],R13
MOV qword ptr [R14 + 0x20],RBX
MOV qword ptr [R14 + 0x28],RBP
MOV qword ptr [R14 + 0x30],R15
MOV R12D,dword ptr [R14 + 0xc]
MOV R8D,dword ptr [RSP + 0x14]
MOV ECX,dword ptr [RSP + 0x10]
MOV EDX,dword ptr [RSP + 0xc]
MOV ESI,dword ptr [RSP + 0x8]
JMP 0x001150d5
LAB_001150c5:
MOV R13,qword ptr [R14 + 0x18]
MOV RBX,qword ptr [R14 + 0x20]
MOV RBP,qword ptr [R14 + 0x28]
MOV R15,qword ptr [R14 + 0x30]
LAB_001150d5:
MOVSXD RAX,R12D
MOV dword ptr [R13 + RAX*0x4],ESI
MOVSXD RAX,dword ptr [R14 + 0xc]
MOV dword ptr [RBX + RAX*0x4],EDX
MOVSXD RAX,dword ptr [R14 + 0xc]
MOV dword ptr [RBP + RAX*0x4],ECX
MOVSXD RAX,dword ptr [R14 + 0xc]
MOV dword ptr [R15 + RAX*0x4],R8D
INC dword ptr [R14 + 0xc]
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* LefDefParser::defiRegion::addRect(int, int, int, int) */
void __thiscall
LefDefParser::defiRegion::addRect(defiRegion *this,int param_1,int param_2,int param_3,int param_4)
{
void *__ptr;
long lVar1;
long lVar2;
long lVar3;
void *pvVar4;
void *pvVar5;
void *pvVar6;
void *pvVar7;
ulong uVar8;
uint uVar9;
size_t __size;
uVar9 = *(uint *)(this + 0xc);
if (uVar9 == *(uint *)(this + 0x10)) {
*(uint *)(this + 0x10) = uVar9 * 2;
__size = (long)(int)uVar9 << 3;
pvVar4 = malloc(__size);
pvVar5 = malloc(__size);
pvVar6 = malloc(__size);
pvVar7 = malloc(__size);
__ptr = *(void **)(this + 0x18);
if (0 < (int)uVar9) {
lVar1 = *(long *)(this + 0x20);
lVar2 = *(long *)(this + 0x28);
lVar3 = *(long *)(this + 0x30);
uVar8 = 0;
do {
*(int4 *)((long)pvVar4 + uVar8 * 4) = *(int4 *)((long)__ptr + uVar8 * 4);
*(int4 *)((long)pvVar5 + uVar8 * 4) = *(int4 *)(lVar1 + uVar8 * 4);
*(int4 *)((long)pvVar6 + uVar8 * 4) = *(int4 *)(lVar2 + uVar8 * 4);
*(int4 *)((long)pvVar7 + uVar8 * 4) = *(int4 *)(lVar3 + uVar8 * 4);
uVar8 = uVar8 + 1;
} while (uVar9 != uVar8);
}
free(__ptr);
free(*(void **)(this + 0x20));
free(*(void **)(this + 0x28));
free(*(void **)(this + 0x30));
*(void **)(this + 0x18) = pvVar4;
*(void **)(this + 0x20) = pvVar5;
*(void **)(this + 0x28) = pvVar6;
*(void **)(this + 0x30) = pvVar7;
uVar9 = *(uint *)(this + 0xc);
}
else {
pvVar4 = *(void **)(this + 0x18);
pvVar5 = *(void **)(this + 0x20);
pvVar6 = *(void **)(this + 0x28);
pvVar7 = *(void **)(this + 0x30);
}
*(int *)((long)pvVar4 + (long)(int)uVar9 * 4) = param_1;
*(int *)((long)pvVar5 + (long)*(int *)(this + 0xc) * 4) = param_2;
*(int *)((long)pvVar6 + (long)*(int *)(this + 0xc) * 4) = param_3;
*(int *)((long)pvVar7 + (long)*(int *)(this + 0xc) * 4) = param_4;
*(int *)(this + 0xc) = *(int *)(this + 0xc) + 1;
return;
}
| |
43,421 | stbi__is_16_main | opengl-water/include/stb_image.h | static int stbi__is_16_main(stbi__context *s)
{
#ifndef STBI_NO_PNG
if (stbi__png_is16(s)) return 1;
#endif
#ifndef STBI_NO_PSD
if (stbi__psd_is16(s)) return 1;
#endif
#ifndef STBI_NO_PNM
if (stbi__pnm_is16(s)) return 1;
#endif
return 0;
} | O3 | c | stbi__is_16_main:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
movq %rbx, (%rdi)
movl $0x2, %esi
xorl %edx, %edx
callq 0x45900
testl %eax, %eax
je 0x40c97
cmpl $0x10, -0x18(%rbp)
jne 0x40c97
movl $0x1, %eax
jmp 0x40d9b
movq -0x38(%rbp), %rax
movups 0xd0(%rax), %xmm0
movups %xmm0, 0xc0(%rax)
movq %rbx, %rdi
callq 0x46dd1
cmpl $0x38425053, %eax # imm = 0x38425053
jne 0x40d75
movq %rbx, %rdi
callq 0x45860
movzbl %al, %r14d
shll $0x8, %r14d
movq %rbx, %rdi
callq 0x45860
movzbl %al, %eax
orl %r14d, %eax
cmpl $0x1, %eax
jne 0x40d75
cmpq $0x0, 0x10(%rbx)
je 0x40d18
movq 0xc0(%rbx), %rax
movq 0xc8(%rbx), %rdx
movl %edx, %ecx
subl %eax, %ecx
cmpl $0x5, %ecx
jg 0x40d1f
movq %rdx, 0xc0(%rbx)
movq 0x28(%rbx), %rdi
movl $0x6, %esi
subl %ecx, %esi
callq *0x18(%rbx)
jmp 0x40d2a
movq 0xc0(%rbx), %rax
addq $0x6, %rax
movq %rax, 0xc0(%rbx)
movq %rbx, %rdi
callq 0x45860
movzbl %al, %r14d
shll $0x8, %r14d
movq %rbx, %rdi
callq 0x45860
movzbl %al, %eax
orl %r14d, %eax
cmpl $0x10, %eax
ja 0x40d75
movq %rbx, %rdi
callq 0x45860
movzbl %al, %r14d
shll $0x8, %r14d
movq %rbx, %rdi
callq 0x45860
movzbl %al, %ecx
orl %r14d, %ecx
movl $0x1, %eax
cmpl $0x10, %ecx
je 0x40d9b
movups 0xd0(%rbx), %xmm0
movups %xmm0, 0xc0(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x4ae2d
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x10, %ecx
sete %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
| stbi__is_16_main:
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 30h
mov rbx, rdi
lea rdi, [rbp+var_38]
mov [rdi], rbx
mov esi, 2
xor edx, edx
call stbi__parse_png_file
test eax, eax
jz short loc_40C97
cmp [rbp+var_18], 10h
jnz short loc_40C97
mov eax, 1
jmp loc_40D9B
loc_40C97:
mov rax, [rbp+var_38]
movups xmm0, xmmword ptr [rax+0D0h]
movups xmmword ptr [rax+0C0h], xmm0
mov rdi, rbx
call stbi__get32be
cmp eax, 38425053h
jnz loc_40D75
mov rdi, rbx
call stbi__get8
movzx r14d, al
shl r14d, 8
mov rdi, rbx
call stbi__get8
movzx eax, al
or eax, r14d
cmp eax, 1
jnz loc_40D75
cmp qword ptr [rbx+10h], 0
jz short loc_40D18
mov rax, [rbx+0C0h]
mov rdx, [rbx+0C8h]
mov ecx, edx
sub ecx, eax
cmp ecx, 5
jg short loc_40D1F
mov [rbx+0C0h], rdx
mov rdi, [rbx+28h]
mov esi, 6
sub esi, ecx
call qword ptr [rbx+18h]
jmp short loc_40D2A
loc_40D18:
mov rax, [rbx+0C0h]
loc_40D1F:
add rax, 6
mov [rbx+0C0h], rax
loc_40D2A:
mov rdi, rbx
call stbi__get8
movzx r14d, al
shl r14d, 8
mov rdi, rbx
call stbi__get8
movzx eax, al
or eax, r14d
cmp eax, 10h
ja short loc_40D75
mov rdi, rbx
call stbi__get8
movzx r14d, al
shl r14d, 8
mov rdi, rbx
call stbi__get8
movzx ecx, al
or ecx, r14d
mov eax, 1
cmp ecx, 10h
jz short loc_40D9B
loc_40D75:
movups xmm0, xmmword ptr [rbx+0D0h]
movups xmmword ptr [rbx+0C0h], xmm0
mov rdi, rbx
xor esi, esi
xor edx, edx
xor ecx, ecx
call stbi__pnm_info
mov ecx, eax
xor eax, eax
cmp ecx, 10h
setz al
loc_40D9B:
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
| _BOOL8 stbi__is_16_main(long long a1)
{
_BOOL8 result; // rax
int v2; // r14d
long long v3; // rax
int v4; // ecx
int v5; // r14d
int v6; // r14d
int v7; // ecx
_QWORD v8[4]; // [rsp+8h] [rbp-38h] BYREF
int v9; // [rsp+28h] [rbp-18h]
v8[0] = a1;
if ( (unsigned int)stbi__parse_png_file(v8, 2LL, 0LL) && v9 == 16 )
return 1LL;
*(_OWORD *)(v8[0] + 192LL) = *(_OWORD *)(v8[0] + 208LL);
if ( (unsigned int)stbi__get32be(a1) != 943870035 )
goto LABEL_13;
v2 = (unsigned __int8)stbi__get8(a1) << 8;
if ( (v2 | (unsigned __int8)stbi__get8(a1)) != 1 )
goto LABEL_13;
if ( !*(_QWORD *)(a1 + 16) )
{
v3 = *(_QWORD *)(a1 + 192);
goto LABEL_10;
}
v3 = *(_QWORD *)(a1 + 192);
v4 = *(_QWORD *)(a1 + 200) - v3;
if ( v4 > 5 )
{
LABEL_10:
*(_QWORD *)(a1 + 192) = v3 + 6;
goto LABEL_11;
}
*(_QWORD *)(a1 + 192) = *(_QWORD *)(a1 + 200);
(*(void ( **)(_QWORD, _QWORD))(a1 + 24))(*(_QWORD *)(a1 + 40), (unsigned int)(6 - v4));
LABEL_11:
v5 = (unsigned __int8)stbi__get8(a1) << 8;
if ( (v5 | (unsigned int)(unsigned __int8)stbi__get8(a1)) > 0x10
|| (v6 = (unsigned __int8)stbi__get8(a1) << 8, v7 = v6 | (unsigned __int8)stbi__get8(a1), result = 1LL, v7 != 16) )
{
LABEL_13:
*(_OWORD *)(a1 + 192) = *(_OWORD *)(a1 + 208);
return (unsigned int)stbi__pnm_info(a1, 0LL, 0LL, 0LL) == 16;
}
return result;
}
| stbi__is_16_main:
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA RDI,[RBP + -0x38]
MOV qword ptr [RDI],RBX
MOV ESI,0x2
XOR EDX,EDX
CALL 0x00145900
TEST EAX,EAX
JZ 0x00140c97
CMP dword ptr [RBP + -0x18],0x10
JNZ 0x00140c97
MOV EAX,0x1
JMP 0x00140d9b
LAB_00140c97:
MOV RAX,qword ptr [RBP + -0x38]
MOVUPS XMM0,xmmword ptr [RAX + 0xd0]
MOVUPS xmmword ptr [RAX + 0xc0],XMM0
MOV RDI,RBX
CALL 0x00146dd1
CMP EAX,0x38425053
JNZ 0x00140d75
MOV RDI,RBX
CALL 0x00145860
MOVZX R14D,AL
SHL R14D,0x8
MOV RDI,RBX
CALL 0x00145860
MOVZX EAX,AL
OR EAX,R14D
CMP EAX,0x1
JNZ 0x00140d75
CMP qword ptr [RBX + 0x10],0x0
JZ 0x00140d18
MOV RAX,qword ptr [RBX + 0xc0]
MOV RDX,qword ptr [RBX + 0xc8]
MOV ECX,EDX
SUB ECX,EAX
CMP ECX,0x5
JG 0x00140d1f
MOV qword ptr [RBX + 0xc0],RDX
MOV RDI,qword ptr [RBX + 0x28]
MOV ESI,0x6
SUB ESI,ECX
CALL qword ptr [RBX + 0x18]
JMP 0x00140d2a
LAB_00140d18:
MOV RAX,qword ptr [RBX + 0xc0]
LAB_00140d1f:
ADD RAX,0x6
MOV qword ptr [RBX + 0xc0],RAX
LAB_00140d2a:
MOV RDI,RBX
CALL 0x00145860
MOVZX R14D,AL
SHL R14D,0x8
MOV RDI,RBX
CALL 0x00145860
MOVZX EAX,AL
OR EAX,R14D
CMP EAX,0x10
JA 0x00140d75
MOV RDI,RBX
CALL 0x00145860
MOVZX R14D,AL
SHL R14D,0x8
MOV RDI,RBX
CALL 0x00145860
MOVZX ECX,AL
OR ECX,R14D
MOV EAX,0x1
CMP ECX,0x10
JZ 0x00140d9b
LAB_00140d75:
MOVUPS XMM0,xmmword ptr [RBX + 0xd0]
MOVUPS xmmword ptr [RBX + 0xc0],XMM0
MOV RDI,RBX
XOR ESI,ESI
XOR EDX,EDX
XOR ECX,ECX
CALL 0x0014ae2d
MOV ECX,EAX
XOR EAX,EAX
CMP ECX,0x10
SETZ AL
LAB_00140d9b:
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
|
bool stbi__is_16_main(long param_1)
{
int1 uVar1;
int1 uVar2;
int iVar3;
long lVar4;
long local_40 [4];
int local_20;
local_40[0] = param_1;
iVar3 = stbi__parse_png_file(local_40,2,0);
if ((iVar3 != 0) && (local_20 == 0x10)) {
return true;
}
*(int4 *)(local_40[0] + 0xc0) = *(int4 *)(local_40[0] + 0xd0);
*(int4 *)(local_40[0] + 0xc4) = *(int4 *)(local_40[0] + 0xd4);
*(int4 *)(local_40[0] + 200) = *(int4 *)(local_40[0] + 0xd8);
*(int4 *)(local_40[0] + 0xcc) = *(int4 *)(local_40[0] + 0xdc);
iVar3 = stbi__get32be(param_1);
if (iVar3 != 0x38425053) goto LAB_00140d75;
uVar1 = stbi__get8(param_1);
uVar2 = stbi__get8(param_1);
if (CONCAT11(uVar1,uVar2) != 1) goto LAB_00140d75;
if (*(long *)(param_1 + 0x10) == 0) {
lVar4 = *(long *)(param_1 + 0xc0);
LAB_00140d1f:
*(long *)(param_1 + 0xc0) = lVar4 + 6;
}
else {
lVar4 = *(long *)(param_1 + 0xc0);
iVar3 = (int)*(int8 *)(param_1 + 200) - (int)lVar4;
if (5 < iVar3) goto LAB_00140d1f;
*(int8 *)(param_1 + 0xc0) = *(int8 *)(param_1 + 200);
(**(code **)(param_1 + 0x18))(*(int8 *)(param_1 + 0x28),6 - iVar3);
}
uVar1 = stbi__get8(param_1);
uVar2 = stbi__get8(param_1);
if (CONCAT11(uVar1,uVar2) < 0x11) {
uVar1 = stbi__get8(param_1);
uVar2 = stbi__get8(param_1);
if (CONCAT11(uVar1,uVar2) == 0x10) {
return true;
}
}
LAB_00140d75:
*(int4 *)(param_1 + 0xc0) = *(int4 *)(param_1 + 0xd0);
*(int4 *)(param_1 + 0xc4) = *(int4 *)(param_1 + 0xd4);
*(int4 *)(param_1 + 200) = *(int4 *)(param_1 + 0xd8);
*(int4 *)(param_1 + 0xcc) = *(int4 *)(param_1 + 0xdc);
iVar3 = stbi__pnm_info(param_1,0,0,0);
return iVar3 == 0x10;
}
| |
43,422 | rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::~GenericValue() | mnn-tts/MNN/3rd_party/rapidjson/document.h | ~GenericValue() {
if (Allocator::kNeedFree) { // Shortcut by Allocator's trait
switch(data_.f.flags) {
case kArrayFlag:
{
GenericValue* e = GetElementsPointer();
for (GenericValue* v = e; v != e + data_.a.size; ++v)
v->~GenericValue();
Allocator::Free(e);
}
break;
case kObjectFlag:
for (MemberIterator m = MemberBegin(); m != MemberEnd(); ++m)
m->~Member();
Allocator::Free(GetMembersPointer());
break;
case kCopyStringFlag:
Allocator::Free(const_cast<Ch*>(GetStringPointer()));
break;
default:
break; // Do nothing for other types.
}
}
} | O0 | c | rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::~GenericValue():
movq %rdi, -0x8(%rsp)
retq
nopw %cs:(%rax,%rax)
| _ZN9rapidjson12GenericValueINS_4UTF8IcEENS_19MemoryPoolAllocatorINS_12CrtAllocatorEEEED2Ev:
mov [rsp+var_8], rdi
retn
| void rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::~GenericValue()
{
;
}
| ~GenericValue:
MOV qword ptr [RSP + -0x8],RDI
RET
|
/* rapidjson::GenericValue<rapidjson::UTF8<char>,
rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> >::~GenericValue() */
void __thiscall
rapidjson::
GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::
~GenericValue(GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>
*this)
{
return;
}
| |
43,423 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O2 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x4287d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x23d30
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8813c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24158
movq %r14, %rdi
callq 0x23f20
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA39_KcS8_EEET_DpOT0_:
push r15
push r14
push rbx
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
and qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
mov rsi, rdx
call _ZN8nlohmann16json_abi_v3_11_36detail13concat_lengthIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEEEmPKcDpRKT_; nlohmann::json_abi_v3_11_3::detail::concat_length<std::string>(char const*,std::string const&)
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_
mov rax, rbx
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov rdi, rbx; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[39],std::string>(
long long a1,
long long a2,
long long a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = nlohmann::json_abi_v3_11_3::detail::concat_length<std::string>(a2, a3);
std::string::reserve(a1, v4);
ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_(
a1,
a2,
a3);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH RBX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
AND qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
LAB_00188035:
MOV RDI,RSI
MOV RSI,RDX
CALL 0x0014287d
MOV RDI,RBX
MOV RSI,RAX
CALL 0x00123d30
MOV RDI,RBX
MOV RSI,R15
MOV RDX,R14
CALL 0x0018813c
LAB_00188059:
MOV RAX,RBX
POP RBX
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [39], std::__cxx11::string >(char const (&) [39], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[39],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
/* try { // try from 00188035 to 00188058 has its CatchHandler @ 00188062 */
concat_length<std::__cxx11::string>(param_1,param_2);
std::__cxx11::string::reserve((ulong)this);
_ZN8nlohmann16json_abi_v3_11_36detail11concat_intoINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERA39_KcJS8_ETnNSt9enable_ifIXsr24detect_string_can_appendIT_T0_EE5valueEiE4typeELi0EEEvRSD_OSE_DpOT1_
(this,param_1,param_2);
return this;
}
| |
43,424 | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&) | monkey531[P]llama/common/json.hpp | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | O3 | cpp | std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [52], char const*>(char const (&) [52], char const*&&):
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x1a3d0
addq 0x8(%r14), %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ad20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b070
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1a250
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x60518
movq (%r12), %rsi
incq %rsi
callq 0x1a890
movq %r14, %rdi
callq 0x1af20
| _ZN8nlohmann16json_abi_v3_11_36detail6concatINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEJRA23_KcS8_EEET_DpOT0_:
push r15
push r14
push r12
push rbx
push rax
mov r14, rdx
mov r15, rsi
mov rbx, rdi
lea r12, [rdi+10h]
mov [rdi], r12
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
mov rdi, rsi
call _strlen
add rax, [r14+8]
mov rdi, rbx
mov rsi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7reserveEm; std::string::reserve(ulong)
mov rdi, rbx
mov rsi, r15
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE6appendEPKc; std::string::append(char const*)
mov rsi, [r14]
mov rdx, [r14+8]
mov rdi, rbx
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE9_M_appendEPKcm; std::string::_M_append(char const*,ulong)
mov rax, rbx
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
mov r14, rax
mov rdi, [rbx]; void *
cmp rdi, r12
jz short loc_60518
mov rsi, [r12]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_60518:
mov rdi, r14
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::concat<std::string,char const(&)[23],std::string>(
long long a1,
long long a2,
_QWORD *a3)
{
long long v4; // rax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v4 = strlen(a2);
std::string::reserve(a1, a3[1] + v4);
std::string::append(a1, a2);
std::string::_M_append(a1, *a3, a3[1]);
return a1;
}
| concat<std::__cxx11::string,char_const(&)[23],std::__cxx11::string>:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDX
MOV R15,RSI
MOV RBX,RDI
LEA R12,[RDI + 0x10]
MOV qword ptr [RDI],R12
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
MOV RDI,RSI
CALL 0x0011a3d0
ADD RAX,qword ptr [R14 + 0x8]
LAB_001604cd:
MOV RDI,RBX
MOV RSI,RAX
CALL 0x0011ad20
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011b070
MOV RSI,qword ptr [R14]
MOV RDX,qword ptr [R14 + 0x8]
MOV RDI,RBX
CALL 0x0011a250
LAB_001604f2:
MOV RAX,RBX
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
/* std::__cxx11::string nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::string, char const
(&) [23], std::__cxx11::string >(char const (&) [23], std::__cxx11::string&&) */
detail * __thiscall
nlohmann::json_abi_v3_11_3::detail::
concat<std::__cxx11::string,char_const(&)[23],std::__cxx11::string>
(detail *this,char *param_1,string *param_2)
{
*(detail **)this = this + 0x10;
*(int8 *)(this + 8) = 0;
this[0x10] = (detail)0x0;
strlen(param_1);
/* try { // try from 001604cd to 001604f1 has its CatchHandler @ 00160501 */
std::__cxx11::string::reserve((ulong)this);
std::__cxx11::string::append((char *)this);
std::__cxx11::string::_M_append((char *)this,*(ulong *)param_2);
return this;
}
| |
43,425 | maria_rtree_delete_req | eloqsql/storage/maria/ma_rt_index.c | static int maria_rtree_delete_req(MARIA_HA *info, const MARIA_KEY *key,
my_off_t page_pos, uint *page_size,
stPageList *ReinsertList, int level)
{
ulong i;
uint nod_flag;
int res;
my_bool buff_alloced;
uchar *page_buf, *last, *k;
MARIA_SHARE *share= info->s;
MARIA_KEYDEF *keyinfo= key->keyinfo;
MARIA_PAGE page;
DBUG_ENTER("maria_rtree_delete_req");
alloc_on_stack(*info->stack_end_ptr, page_buf, buff_alloced,
keyinfo->block_length);
if (!page_buf)
{
my_errno= HA_ERR_OUT_OF_MEM;
DBUG_RETURN(-1);
}
if (_ma_fetch_keypage(&page, info, keyinfo, page_pos, PAGECACHE_LOCK_WRITE,
DFLT_INIT_HITS, page_buf, 0))
goto err;
nod_flag= page.node;
DBUG_PRINT("rtree", ("page: %lu level: %d nod_flag: %u",
(ulong) page_pos, level, nod_flag));
k= rt_PAGE_FIRST_KEY(share, page_buf, nod_flag);
last= rt_PAGE_END(&page);
for (i= 0;
k < last;
k= rt_PAGE_NEXT_KEY(share, k, key->data_length, nod_flag), i++)
{
if (nod_flag)
{
/* not leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, key->data, k, key->data_length,
MBR_WITHIN))
{
switch ((res= maria_rtree_delete_req(info, key,
_ma_kpos(nod_flag, k),
page_size, ReinsertList,
level + 1)))
{
case 0: /* deleted */
{
/* test page filling */
if (*page_size + key->data_length >=
rt_PAGE_MIN_SIZE(keyinfo->block_length))
{
/* OK */
/* Calculate a new key value (MBR) for the shrinked block. */
MARIA_KEY tmp_key;
tmp_key.keyinfo= keyinfo;
tmp_key.data= k;
tmp_key.data_length= key->data_length;
tmp_key.ref_length= key->ref_length;
tmp_key.flag= 0; /* Safety */
if (maria_rtree_set_key_mbr(info, &tmp_key,
_ma_kpos(nod_flag, k)))
goto err;
if (share->now_transactional &&
_ma_log_change(&page, k, key->data_length,
KEY_OP_DEBUG_RTREE_SET_KEY))
goto err;
page_mark_changed(info, &page)
if (_ma_write_keypage(&page,
PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
else
{
/*
Too small: delete key & add it descendant to reinsert list.
Store position and level of the block so that it can be
accessed later for inserting the remaining keys.
*/
DBUG_PRINT("rtree", ("too small. move block to reinsert list"));
if (maria_rtree_fill_reinsert_list(ReinsertList,
_ma_kpos(nod_flag, k),
level + 1))
goto err;
/*
Delete the key that references the block. This makes the
block disappear from the index. Hence we need to insert
its remaining keys later. Note: if the block is a branch
block, we do not only remove this block, but the whole
subtree. So we need to re-insert its keys on the same
level later to reintegrate the subtrees.
*/
if (maria_rtree_delete_key(&page, k, key->data_length))
goto err;
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
*page_size= page.size;
}
goto ok;
}
case 1: /* not found - continue searching */
{
break;
}
case 2: /* vacuous case: last key in the leaf */
{
if (maria_rtree_delete_key(&page, k, key->data_length))
goto err;
page_mark_changed(info, &page);
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
*page_size= page.size;
res= 0;
goto ok;
}
default: /* error */
case -1:
{
goto err;
}
}
}
}
else
{
/* leaf */
if (!maria_rtree_key_cmp(keyinfo->seg, key->data, k, key->data_length,
MBR_EQUAL | MBR_DATA))
{
page_mark_changed(info, &page);
if (maria_rtree_delete_key(&page, k, key->data_length))
goto err;
*page_size= page.size;
if (*page_size == info->s->keypage_header)
{
/* last key in the leaf */
res= 2;
if (_ma_dispose(info, page.pos, 0))
goto err;
}
else
{
res= 0;
if (_ma_write_keypage(&page, PAGECACHE_LOCK_LEFT_WRITELOCKED,
DFLT_INIT_HITS))
goto err;
}
goto ok;
}
}
}
res= 1;
ok:
stack_alloc_free(page_buf, buff_alloced);
DBUG_RETURN(res);
err:
stack_alloc_free(page_buf, buff_alloced);
DBUG_RETURN(-1); /* purecov: inspected */
} | O3 | c | maria_rtree_delete_req:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, -0x40(%rbp)
movq %r8, -0x60(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %fs:0x28, %rax
movq %rax, -0x30(%rbp)
movq (%rdi), %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rsi), %r15
movzwl 0xa6(%r15), %esi
leaq -0x98(%rbp), %rcx
movq %rsi, (%rcx)
movq 0x78(%rdi), %rax
movq (%rax), %rax
subq %rcx, %rax
subq %rsi, %rax
jbe 0x6c57a
cmpq $0x10000, %rax # imm = 0x10000
ja 0x6c564
cmpl $0x1000, %esi # imm = 0x1000
jb 0x6c57a
cmpq $0x8001, %rax # imm = 0x8001
jb 0x6c57a
movq %rsp, %rax
addl $0xf, %esi
andl $-0x10, %esi
subq %rsi, %rax
movq %rax, %rsp
movb $0x1, %cl
movl %ecx, -0x3c(%rbp)
jmp 0x6c596
movl $0x10010, %edx # imm = 0x10010
xorl %edi, %edi
callq 0x9fc95
testq %rax, %rax
je 0x6c6b2
movl $0x0, -0x3c(%rbp)
leaq -0x98(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x4, %r8d
movl $0x3, %r9d
pushq $0x0
movq %rax, -0x38(%rbp)
pushq %rax
callq 0x58de2
addq $0x10, %rsp
testb %al, %al
je 0x6c5de
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
cmpb $0x0, -0x3c(%rbp)
jne 0x6c6c2
movq -0x38(%rbp), %rdi
jmp 0x6c6ab
movq %r14, -0x48(%rbp)
movl -0x78(%rbp), %ebx
movl -0x70(%rbp), %r14d
movq -0x58(%rbp), %rax
movl 0x744(%rax), %r13d
addq %r14, %r13
movq -0x38(%rbp), %rdi
addq %rdi, %r13
addq -0x88(%rbp), %rbx
cmpq %rbx, %r13
jae 0x6c6a0
incl -0x40(%rbp)
movq 0xc0(%r15), %rdi
movq (%r12), %rsi
movl 0x10(%r12), %ecx
movq %r13, %rdx
testq %r14, %r14
je 0x6c66b
movl $0x800, %r8d # imm = 0x800
callq 0x6cf10
movq %r14, %rcx
testl %eax, %eax
jne 0x6c688
movl %r14d, %edi
movq %r13, %rsi
callq 0x56df3
movq -0x48(%rbp), %rdi
movq %r12, %rsi
movq %rax, %rdx
movq -0x50(%rbp), %rcx
movq -0x60(%rbp), %r8
movl -0x40(%rbp), %r9d
callq 0x6c4ea
movq %r14, %rcx
cmpl $0x1, %eax
je 0x6c688
jmp 0x6c6e6
movl $0x6000, %r8d # imm = 0x6000
callq 0x6cf10
testl %eax, %eax
je 0x6c772
movq -0x58(%rbp), %rax
movl 0x3e0(%rax), %ecx
movl 0x10(%r12), %eax
addq %rcx, %r13
addq %rax, %r13
cmpq %rbx, %r13
jb 0x6c611
movq -0x38(%rbp), %rdi
movl $0x1, %ebx
cmpb $0x0, -0x3c(%rbp)
jne 0x6c6c2
callq 0x9fec2
jmp 0x6c6c2
callq 0xa1a06
movl $0x80, (%rax)
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movq %fs:0x28, %rax
cmpq -0x30(%rbp), %rax
jne 0x6c8f4
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %eax
je 0x6c7dd
testl %eax, %eax
jne 0x6c5c6
movl 0x10(%r12), %eax
movq -0x50(%rbp), %rcx
movl (%rcx), %ecx
addl %eax, %ecx
movzwl 0xa6(%r15), %edx
addl $-0x4, %edx
movl $0xaaaaaaab, %esi # imm = 0xAAAAAAAB
imulq %rdx, %rsi
shrq $0x21, %rsi
cmpl %esi, %ecx
jae 0x6c83c
movl %r14d, %edi
movq %r13, %rsi
callq 0x56df3
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movl -0x40(%rbp), %edx
callq 0x6cc9c
testb %al, %al
movq -0x48(%rbp), %rbx
jne 0x6c5c6
movl 0x10(%r12), %edx
leaq -0x98(%rbp), %rdi
movq %r13, %rsi
callq 0x6cdfc
testl %eax, %eax
jne 0x6c5c6
movq 0x2e8(%rbx), %rax
jmp 0x6c804
movq -0x48(%rbp), %rbx
movq 0x2e8(%rbx), %rax
leaq -0x98(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl 0x10(%r12), %edx
movq %r13, %rsi
callq 0x6cdfc
testl %eax, %eax
jne 0x6c5c6
movl -0x78(%rbp), %eax
movq -0x50(%rbp), %rcx
movl %eax, (%rcx)
movq (%rbx), %rcx
cmpl 0x744(%rcx), %eax
jne 0x6c8cb
movq %rbx, %rdi
movq -0x80(%rbp), %rsi
xorl %edx, %edx
callq 0x58fe9
testl %eax, %eax
jne 0x6c5c6
movl $0x2, %ebx
jmp 0x6c8eb
movl 0x10(%r12), %edx
leaq -0x98(%rbp), %rdi
movq %r13, %rsi
callq 0x6cdfc
testl %eax, %eax
movq -0x48(%rbp), %rax
jne 0x6c5c6
movq 0x2e8(%rax), %rax
leaq -0x98(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
movl $0x2, %esi
movl $0x3, %edx
callq 0x58f21
testb %al, %al
jne 0x6c5c6
movl -0x78(%rbp), %eax
movq -0x50(%rbp), %rcx
movl %eax, (%rcx)
jmp 0x6c8e9
leaq -0xb8(%rbp), %rbx
movq %r15, 0x8(%rbx)
movq %r13, (%rbx)
movl %eax, 0x10(%rbx)
movl 0x14(%r12), %eax
movl %eax, 0x14(%rbx)
movl $0x0, 0x18(%rbx)
movl %r14d, %edi
movq %r13, %rsi
callq 0x56df3
movq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x6ceaf
testl %eax, %eax
jne 0x6c5c6
movq -0x58(%rbp), %rax
cmpb $0x0, 0x7e7(%rax)
je 0x6c8af
movl 0x10(%r12), %edx
leaq -0x98(%rbp), %rdi
movq %r13, %rsi
movl $0x2, %ecx
callq 0x66fb2
testb %al, %al
jne 0x6c5c6
movq 0x2e8(%r14), %rax
leaq -0x98(%rbp), %rdi
movl 0x30(%rdi), %ecx
leaq (%rcx,%rcx,2), %rcx
movb $0x1, 0x10(%rax,%rcx,8)
jmp 0x6c8d2
leaq -0x98(%rbp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x58f21
testb %al, %al
jne 0x6c5c6
xorl %ebx, %ebx
movq -0x38(%rbp), %rdi
jmp 0x6c6a5
callq 0x29270
| maria_rtree_delete_req:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 98h
mov [rbp+var_40], r9d
mov [rbp+var_60], r8
mov [rbp+var_50], rcx
mov rbx, rdx
mov r12, rsi
mov r14, rdi
mov rax, fs:28h
mov [rbp+var_30], rax
mov rax, [rdi]
mov [rbp+var_58], rax
mov r15, [rsi+8]
movzx esi, word ptr [r15+0A6h]
lea rcx, [rbp+var_98]
mov [rcx], rsi
mov rax, [rdi+78h]
mov rax, [rax]
sub rax, rcx
sub rax, rsi
jbe short loc_6C57A
cmp rax, offset stru_10000
ja short loc_6C564
cmp esi, 1000h
jb short loc_6C57A
cmp rax, 8001h
jb short loc_6C57A
loc_6C564:
mov rax, rsp
add esi, 0Fh
and esi, 0FFFFFFF0h
sub rax, rsi
mov rsp, rax
mov cl, 1
mov [rbp+var_3C], ecx
jmp short loc_6C596
loc_6C57A:
mov edx, 10010h
xor edi, edi
call my_malloc
test rax, rax
jz loc_6C6B2
mov [rbp+var_3C], 0
loc_6C596:
lea rdi, [rbp+var_98]
mov rsi, r14
mov rdx, r15
mov rcx, rbx
mov r8d, 4
mov r9d, 3
push 0
mov [rbp+var_38], rax
push rax
call _ma_fetch_keypage
add rsp, 10h
test al, al
jz short loc_6C5DE
loc_6C5C6:
mov ebx, 0FFFFFFFFh
cmp byte ptr [rbp+var_3C], 0
jnz loc_6C6C2
mov rdi, [rbp+var_38]
jmp loc_6C6AB
loc_6C5DE:
mov [rbp+var_48], r14
mov ebx, [rbp+var_78]
mov r14d, [rbp+var_70]
mov rax, [rbp+var_58]
mov r13d, [rax+744h]
add r13, r14
mov rdi, [rbp+var_38]
add r13, rdi
add rbx, [rbp+var_88]
cmp r13, rbx
jnb loc_6C6A0
inc [rbp+var_40]
loc_6C611:
mov rdi, [r15+0C0h]
mov rsi, [r12]
mov ecx, [r12+10h]
mov rdx, r13
test r14, r14
jz short loc_6C66B
mov r8d, 800h
call maria_rtree_key_cmp
mov rcx, r14
test eax, eax
jnz short loc_6C688
mov edi, r14d
mov rsi, r13
call _ma_kpos
mov rdi, [rbp+var_48]
mov rsi, r12
mov rdx, rax
mov rcx, [rbp+var_50]
mov r8, [rbp+var_60]
mov r9d, [rbp+var_40]
call maria_rtree_delete_req
mov rcx, r14
cmp eax, 1
jz short loc_6C688
jmp short loc_6C6E6
loc_6C66B:
mov r8d, 6000h
call maria_rtree_key_cmp
test eax, eax
jz loc_6C772
mov rax, [rbp+var_58]
mov ecx, [rax+3E0h]
loc_6C688:
mov eax, [r12+10h]
add r13, rcx
add r13, rax
cmp r13, rbx
jb loc_6C611
mov rdi, [rbp+var_38]
loc_6C6A0:
mov ebx, 1
loc_6C6A5:
cmp byte ptr [rbp+var_3C], 0
jnz short loc_6C6C2
loc_6C6AB:
call my_free
jmp short loc_6C6C2
loc_6C6B2:
call _my_thread_var
mov dword ptr [rax], 80h
mov ebx, 0FFFFFFFFh
loc_6C6C2:
mov rax, fs:28h
cmp rax, [rbp+var_30]
jnz loc_6C8F4
mov eax, ebx
lea rsp, [rbp-28h]
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_6C6E6:
cmp eax, 2
jz loc_6C7DD
test eax, eax
jnz loc_6C5C6
mov eax, [r12+10h]
mov rcx, [rbp+var_50]
mov ecx, [rcx]
add ecx, eax
movzx edx, word ptr [r15+0A6h]
add edx, 0FFFFFFFCh
mov esi, 0AAAAAAABh
imul rsi, rdx
shr rsi, 21h
cmp ecx, esi
jnb loc_6C83C
mov edi, r14d
mov rsi, r13
call _ma_kpos
mov rdi, [rbp+var_60]
mov rsi, rax
mov edx, [rbp+var_40]
call maria_rtree_fill_reinsert_list
test al, al
mov rbx, [rbp+var_48]
jnz loc_6C5C6
mov edx, [r12+10h]
lea rdi, [rbp+var_98]
mov rsi, r13
call maria_rtree_delete_key
test eax, eax
jnz loc_6C5C6
mov rax, [rbx+2E8h]
jmp loc_6C804
loc_6C772:
mov rbx, [rbp+var_48]
mov rax, [rbx+2E8h]
lea rdi, [rbp+var_98]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov edx, [r12+10h]
mov rsi, r13
call maria_rtree_delete_key
test eax, eax
jnz loc_6C5C6
mov eax, [rbp+var_78]
mov rcx, [rbp+var_50]
mov [rcx], eax
mov rcx, [rbx]
cmp eax, [rcx+744h]
jnz loc_6C8CB
mov rdi, rbx
mov rsi, [rbp+var_80]
xor edx, edx
call _ma_dispose
test eax, eax
jnz loc_6C5C6
mov ebx, 2
jmp loc_6C8EB
loc_6C7DD:
mov edx, [r12+10h]
lea rdi, [rbp+var_98]
mov rsi, r13
call maria_rtree_delete_key
test eax, eax
mov rax, [rbp+var_48]
jnz loc_6C5C6
mov rax, [rax+2E8h]
loc_6C804:
lea rdi, [rbp+var_98]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_6C5C6
mov eax, [rbp+var_78]
mov rcx, [rbp+var_50]
mov [rcx], eax
jmp loc_6C8E9
loc_6C83C:
lea rbx, [rbp+var_B8]
mov [rbx+8], r15
mov [rbx], r13
mov [rbx+10h], eax
mov eax, [r12+14h]
mov [rbx+14h], eax
mov dword ptr [rbx+18h], 0
mov edi, r14d
mov rsi, r13
call _ma_kpos
mov r14, [rbp+var_48]
mov rdi, r14
mov rsi, rbx
mov rdx, rax
call maria_rtree_set_key_mbr
test eax, eax
jnz loc_6C5C6
mov rax, [rbp+var_58]
cmp byte ptr [rax+7E7h], 0
jz short loc_6C8AF
mov edx, [r12+10h]
lea rdi, [rbp+var_98]
mov rsi, r13
mov ecx, 2
call _ma_log_change
test al, al
jnz loc_6C5C6
loc_6C8AF:
mov rax, [r14+2E8h]
lea rdi, [rbp+var_98]
mov ecx, [rdi+30h]
lea rcx, [rcx+rcx*2]
mov byte ptr [rax+rcx*8+10h], 1
jmp short loc_6C8D2
loc_6C8CB:
lea rdi, [rbp+var_98]
loc_6C8D2:
mov esi, 2
mov edx, 3
call _ma_write_keypage
test al, al
jnz loc_6C5C6
loc_6C8E9:
xor ebx, ebx
loc_6C8EB:
mov rdi, [rbp+var_38]
jmp loc_6C6A5
loc_6C8F4:
call ___stack_chk_fail
| long long maria_rtree_delete_req(
long long a1,
long long *a2,
unsigned long long a3,
unsigned int *a4,
long long a5,
unsigned int a6)
{
long long v8; // r15
long long *v9; // rsi
long long **v10; // rcx
unsigned long long v11; // rax
bool v12; // cc
unsigned long long v13; // rax
char *v14; // rax
unsigned int v15; // ebx
char *v16; // rdi
long long v17; // r14
unsigned long long v18; // r13
char *v19; // rbx
long long v20; // rdi
long long v21; // rsi
long long v22; // rcx
int v23; // eax
long long v24; // rcx
long long v25; // rax
int v26; // eax
int v28; // eax
long long v29; // rax
char v30; // al
_QWORD *v31; // rbx
long long v32; // rax
_QWORD *v33; // rbx
unsigned int v34; // eax
long long v35; // rax
_QWORD *v36; // r14
_QWORD v38[2]; // [rsp+8h] [rbp-B8h] BYREF
int v39; // [rsp+18h] [rbp-A8h]
long long v40; // [rsp+1Ch] [rbp-A4h]
long long *v41[4]; // [rsp+28h] [rbp-98h] BYREF
unsigned int v42; // [rsp+48h] [rbp-78h]
unsigned int v43; // [rsp+50h] [rbp-70h]
unsigned int v44; // [rsp+58h] [rbp-68h]
long long v45; // [rsp+60h] [rbp-60h]
long long v46; // [rsp+68h] [rbp-58h]
unsigned int *v47; // [rsp+70h] [rbp-50h]
_QWORD *v48; // [rsp+78h] [rbp-48h]
unsigned int v49; // [rsp+80h] [rbp-40h]
int v50; // [rsp+84h] [rbp-3Ch]
char *v51; // [rsp+88h] [rbp-38h]
unsigned long long v52; // [rsp+90h] [rbp-30h]
v49 = a6;
v45 = a5;
v47 = a4;
v52 = __readfsqword(0x28u);
v46 = *(_QWORD *)a1;
v8 = a2[1];
v9 = (long long *)*(unsigned __int16 *)(v8 + 166);
v10 = v41;
v41[0] = v9;
v11 = **(_QWORD **)(a1 + 120) - (_QWORD)v41;
v12 = v11 <= (unsigned long long)v9;
v13 = v11 - (_QWORD)v9;
if ( v12 || v13 <= (unsigned long long)&stru_10000 && ((unsigned int)v9 < 0x1000 || v13 < 0x8001) )
{
v14 = (char *)my_malloc(0LL, v9, 65552LL);
if ( !v14 )
{
*(_DWORD *)my_thread_var(0LL, (const char *)v9) = 128;
return (unsigned int)-1;
}
v50 = 0;
}
else
{
v14 = (char *)&v38[-1] - (((_DWORD)v9 + 15) & 0xFFFFFFF0);
LOBYTE(v10) = 1;
v50 = (int)v10;
}
v51 = v14;
if ( ma_fetch_keypage((long long)v41, a1, v8, a3, 4u, 3, (long long)v14) )
goto LABEL_9;
v48 = (_QWORD *)a1;
v17 = v43;
v16 = v51;
v18 = (unsigned long long)&v51[v43 + (unsigned long long)*(unsigned int *)(v46 + 1860)];
v19 = (char *)v41[2] + v42;
if ( v18 < (unsigned long long)v19 )
{
++v49;
while ( 1 )
{
v20 = *(_QWORD *)(v8 + 192);
v21 = *a2;
v22 = *((unsigned int *)a2 + 4);
if ( v17 )
{
v23 = maria_rtree_key_cmp(v20, v21, v18, v22, 2048LL);
v24 = v17;
if ( !v23 )
{
v25 = ma_kpos(v17, v18);
v26 = maria_rtree_delete_req(v48, a2, v25, v47, v45, v49);
v24 = v17;
if ( v26 != 1 )
{
if ( v26 == 2 )
{
if ( (unsigned int)maria_rtree_delete_key(v41, v18, *((unsigned int *)a2 + 4)) )
goto LABEL_9;
v32 = v48[93];
LABEL_38:
*(_BYTE *)(v32 + 24LL * v44 + 16) = 1;
if ( (unsigned __int8)ma_write_keypage(v41, 2u, 3) )
goto LABEL_9;
*v47 = v42;
}
else
{
if ( v26 )
goto LABEL_9;
v28 = *((_DWORD *)a2 + 4);
if ( v28 + *v47 < ((unsigned int)*(unsigned __int16 *)(v8 + 166) - 4) / 3 )
{
v29 = ma_kpos(v17, v18);
v30 = maria_rtree_fill_reinsert_list(v45, v29, v49);
v31 = v48;
if ( !v30 && !(unsigned int)maria_rtree_delete_key(v41, v18, *((unsigned int *)a2 + 4)) )
{
v32 = v31[93];
goto LABEL_38;
}
LABEL_9:
v15 = -1;
if ( !(_BYTE)v50 )
{
v16 = v51;
goto LABEL_23;
}
return v15;
}
v38[1] = v8;
v38[0] = v18;
v39 = v28;
v40 = *((unsigned int *)a2 + 5);
v35 = ma_kpos(v17, v18);
v36 = v48;
if ( (unsigned int)maria_rtree_set_key_mbr(v48, v38, v35)
|| *(_BYTE *)(v46 + 2023) && ma_log_change((long long)v41, v18, *((_DWORD *)a2 + 4)) )
{
goto LABEL_9;
}
*(_BYTE *)(v36[93] + 24LL * v44 + 16) = 1;
LABEL_44:
if ( (unsigned __int8)ma_write_keypage(v41, 2u, 3) )
goto LABEL_9;
}
v15 = 0;
LABEL_46:
v16 = v51;
goto LABEL_22;
}
}
}
else
{
if ( !(unsigned int)maria_rtree_key_cmp(v20, v21, v18, v22, 24576LL) )
{
v33 = v48;
*(_BYTE *)(v48[93] + 24LL * v44 + 16) = 1;
if ( (unsigned int)maria_rtree_delete_key(v41, v18, *((unsigned int *)a2 + 4)) )
goto LABEL_9;
v34 = v42;
*v47 = v42;
if ( v34 != *(_DWORD *)(*v33 + 1860LL) )
goto LABEL_44;
if ( (unsigned int)ma_dispose(v33, (unsigned long long)v41[3], 0) )
goto LABEL_9;
v15 = 2;
goto LABEL_46;
}
v24 = *(unsigned int *)(v46 + 992);
}
v18 += *((unsigned int *)a2 + 4) + v24;
if ( v18 >= (unsigned long long)v19 )
{
v16 = v51;
break;
}
}
}
v15 = 1;
LABEL_22:
if ( !(_BYTE)v50 )
LABEL_23:
my_free(v16);
return v15;
}
| maria_rtree_delete_req:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x98
MOV dword ptr [RBP + -0x40],R9D
MOV qword ptr [RBP + -0x60],R8
MOV qword ptr [RBP + -0x50],RCX
MOV RBX,RDX
MOV R12,RSI
MOV R14,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RDI]
MOV qword ptr [RBP + -0x58],RAX
MOV R15,qword ptr [RSI + 0x8]
MOVZX ESI,word ptr [R15 + 0xa6]
LEA RCX,[RBP + -0x98]
MOV qword ptr [RCX],RSI
MOV RAX,qword ptr [RDI + 0x78]
MOV RAX,qword ptr [RAX]
SUB RAX,RCX
SUB RAX,RSI
JBE 0x0016c57a
CMP RAX,0x10000
JA 0x0016c564
CMP ESI,0x1000
JC 0x0016c57a
CMP RAX,0x8001
JC 0x0016c57a
LAB_0016c564:
MOV RAX,RSP
ADD ESI,0xf
AND ESI,0xfffffff0
SUB RAX,RSI
MOV RSP,RAX
MOV CL,0x1
MOV dword ptr [RBP + -0x3c],ECX
JMP 0x0016c596
LAB_0016c57a:
MOV EDX,0x10010
XOR EDI,EDI
CALL 0x0019fc95
TEST RAX,RAX
JZ 0x0016c6b2
MOV dword ptr [RBP + -0x3c],0x0
LAB_0016c596:
LEA RDI,[RBP + -0x98]
MOV RSI,R14
MOV RDX,R15
MOV RCX,RBX
MOV R8D,0x4
MOV R9D,0x3
PUSH 0x0
MOV qword ptr [RBP + -0x38],RAX
PUSH RAX
CALL 0x00158de2
ADD RSP,0x10
TEST AL,AL
JZ 0x0016c5de
LAB_0016c5c6:
MOV EBX,0xffffffff
CMP byte ptr [RBP + -0x3c],0x0
JNZ 0x0016c6c2
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x0016c6ab
LAB_0016c5de:
MOV qword ptr [RBP + -0x48],R14
MOV EBX,dword ptr [RBP + -0x78]
MOV R14D,dword ptr [RBP + -0x70]
MOV RAX,qword ptr [RBP + -0x58]
MOV R13D,dword ptr [RAX + 0x744]
ADD R13,R14
MOV RDI,qword ptr [RBP + -0x38]
ADD R13,RDI
ADD RBX,qword ptr [RBP + -0x88]
CMP R13,RBX
JNC 0x0016c6a0
INC dword ptr [RBP + -0x40]
LAB_0016c611:
MOV RDI,qword ptr [R15 + 0xc0]
MOV RSI,qword ptr [R12]
MOV ECX,dword ptr [R12 + 0x10]
MOV RDX,R13
TEST R14,R14
JZ 0x0016c66b
MOV R8D,0x800
CALL 0x0016cf10
MOV RCX,R14
TEST EAX,EAX
JNZ 0x0016c688
MOV EDI,R14D
MOV RSI,R13
CALL 0x00156df3
MOV RDI,qword ptr [RBP + -0x48]
MOV RSI,R12
MOV RDX,RAX
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x60]
MOV R9D,dword ptr [RBP + -0x40]
CALL 0x0016c4ea
MOV RCX,R14
CMP EAX,0x1
JZ 0x0016c688
JMP 0x0016c6e6
LAB_0016c66b:
MOV R8D,0x6000
CALL 0x0016cf10
TEST EAX,EAX
JZ 0x0016c772
MOV RAX,qword ptr [RBP + -0x58]
MOV ECX,dword ptr [RAX + 0x3e0]
LAB_0016c688:
MOV EAX,dword ptr [R12 + 0x10]
ADD R13,RCX
ADD R13,RAX
CMP R13,RBX
JC 0x0016c611
MOV RDI,qword ptr [RBP + -0x38]
LAB_0016c6a0:
MOV EBX,0x1
LAB_0016c6a5:
CMP byte ptr [RBP + -0x3c],0x0
JNZ 0x0016c6c2
LAB_0016c6ab:
CALL 0x0019fec2
JMP 0x0016c6c2
LAB_0016c6b2:
CALL 0x001a1a06
MOV dword ptr [RAX],0x80
MOV EBX,0xffffffff
LAB_0016c6c2:
MOV RAX,qword ptr FS:[0x28]
CMP RAX,qword ptr [RBP + -0x30]
JNZ 0x0016c8f4
MOV EAX,EBX
LEA RSP,[RBP + -0x28]
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0016c6e6:
CMP EAX,0x2
JZ 0x0016c7dd
TEST EAX,EAX
JNZ 0x0016c5c6
MOV EAX,dword ptr [R12 + 0x10]
MOV RCX,qword ptr [RBP + -0x50]
MOV ECX,dword ptr [RCX]
ADD ECX,EAX
MOVZX EDX,word ptr [R15 + 0xa6]
ADD EDX,-0x4
MOV ESI,0xaaaaaaab
IMUL RSI,RDX
SHR RSI,0x21
CMP ECX,ESI
JNC 0x0016c83c
MOV EDI,R14D
MOV RSI,R13
CALL 0x00156df3
MOV RDI,qword ptr [RBP + -0x60]
MOV RSI,RAX
MOV EDX,dword ptr [RBP + -0x40]
CALL 0x0016cc9c
TEST AL,AL
MOV RBX,qword ptr [RBP + -0x48]
JNZ 0x0016c5c6
MOV EDX,dword ptr [R12 + 0x10]
LEA RDI,[RBP + -0x98]
MOV RSI,R13
CALL 0x0016cdfc
TEST EAX,EAX
JNZ 0x0016c5c6
MOV RAX,qword ptr [RBX + 0x2e8]
JMP 0x0016c804
LAB_0016c772:
MOV RBX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBX + 0x2e8]
LEA RDI,[RBP + -0x98]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV EDX,dword ptr [R12 + 0x10]
MOV RSI,R13
CALL 0x0016cdfc
TEST EAX,EAX
JNZ 0x0016c5c6
MOV EAX,dword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX],EAX
MOV RCX,qword ptr [RBX]
CMP EAX,dword ptr [RCX + 0x744]
JNZ 0x0016c8cb
MOV RDI,RBX
MOV RSI,qword ptr [RBP + -0x80]
XOR EDX,EDX
CALL 0x00158fe9
TEST EAX,EAX
JNZ 0x0016c5c6
MOV EBX,0x2
JMP 0x0016c8eb
LAB_0016c7dd:
MOV EDX,dword ptr [R12 + 0x10]
LEA RDI,[RBP + -0x98]
MOV RSI,R13
CALL 0x0016cdfc
TEST EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
JNZ 0x0016c5c6
MOV RAX,qword ptr [RAX + 0x2e8]
LAB_0016c804:
LEA RDI,[RBP + -0x98]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
MOV ESI,0x2
MOV EDX,0x3
CALL 0x00158f21
TEST AL,AL
JNZ 0x0016c5c6
MOV EAX,dword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x50]
MOV dword ptr [RCX],EAX
JMP 0x0016c8e9
LAB_0016c83c:
LEA RBX,[RBP + -0xb8]
MOV qword ptr [RBX + 0x8],R15
MOV qword ptr [RBX],R13
MOV dword ptr [RBX + 0x10],EAX
MOV EAX,dword ptr [R12 + 0x14]
MOV dword ptr [RBX + 0x14],EAX
MOV dword ptr [RBX + 0x18],0x0
MOV EDI,R14D
MOV RSI,R13
CALL 0x00156df3
MOV R14,qword ptr [RBP + -0x48]
MOV RDI,R14
MOV RSI,RBX
MOV RDX,RAX
CALL 0x0016ceaf
TEST EAX,EAX
JNZ 0x0016c5c6
MOV RAX,qword ptr [RBP + -0x58]
CMP byte ptr [RAX + 0x7e7],0x0
JZ 0x0016c8af
MOV EDX,dword ptr [R12 + 0x10]
LEA RDI,[RBP + -0x98]
MOV RSI,R13
MOV ECX,0x2
CALL 0x00166fb2
TEST AL,AL
JNZ 0x0016c5c6
LAB_0016c8af:
MOV RAX,qword ptr [R14 + 0x2e8]
LEA RDI,[RBP + -0x98]
MOV ECX,dword ptr [RDI + 0x30]
LEA RCX,[RCX + RCX*0x2]
MOV byte ptr [RAX + RCX*0x8 + 0x10],0x1
JMP 0x0016c8d2
LAB_0016c8cb:
LEA RDI,[RBP + -0x98]
LAB_0016c8d2:
MOV ESI,0x2
MOV EDX,0x3
CALL 0x00158f21
TEST AL,AL
JNZ 0x0016c5c6
LAB_0016c8e9:
XOR EBX,EBX
LAB_0016c8eb:
MOV RDI,qword ptr [RBP + -0x38]
JMP 0x0016c6a5
LAB_0016c8f4:
CALL 0x00129270
|
int8
maria_rtree_delete_req
(long *param_1,int8 *param_2,int8 param_3,uint *param_4,int8 param_5,
int param_6)
{
ushort uVar1;
int4 uVar2;
uint *puVar3;
long *plVar4;
char cVar5;
int iVar6;
ulong uVar7;
ulong uVar8;
int8 uVar9;
int4 *puVar10;
long lVar11;
ulong uVar12;
int8 uVar13;
int1 *puVar14;
int1 *puVar15;
long in_FS_OFFSET;
int1 auStack_c8 [8];
int1 *local_c0;
long local_b8;
int local_b0;
int4 local_ac;
int4 local_a8;
ulong local_a0 [2];
long local_90;
int8 local_88;
uint local_80;
uint local_78;
uint local_70;
int8 local_68;
long local_60;
uint *local_58;
long *local_50;
int local_48;
int4 local_44;
int1 *local_40;
long local_38;
puVar14 = auStack_c8;
local_38 = *(long *)(in_FS_OFFSET + 0x28);
local_60 = *param_1;
lVar11 = param_2[1];
uVar1 = *(ushort *)(lVar11 + 0xa6);
local_a0[0] = (ulong)uVar1;
uVar7 = *(long *)param_1[0xf] - (long)local_a0;
uVar8 = uVar7 - local_a0[0];
local_68 = param_5;
local_58 = param_4;
local_48 = param_6;
if ((local_a0[0] < uVar7) && ((0x10000 < uVar8 || ((0xfff < uVar1 && (0x8000 < uVar8)))))) {
puVar15 = auStack_c8 + -(ulong)(uVar1 + 0xf & 0xfffffff0);
local_44 = (int4)CONCAT71((int7)((ulong)local_a0 >> 8),1);
puVar14 = puVar15;
}
else {
puVar15 = (int1 *)my_malloc(0,local_a0[0],0x10010);
if (puVar15 == (int1 *)0x0) {
puVar10 = (int4 *)_my_thread_var();
*puVar10 = 0x80;
uVar13 = 0xffffffff;
goto LAB_0016c6c2;
}
local_44 = 0;
puVar14 = auStack_c8;
}
*(int8 *)(puVar14 + -8) = 0;
local_40 = puVar15;
*(int1 **)(puVar14 + -0x10) = puVar15;
*(int8 *)(puVar14 + -0x18) = 0x16c5be;
cVar5 = _ma_fetch_keypage(local_a0,param_1,lVar11,param_3,4,3);
if (cVar5 == '\0') {
uVar7 = (ulong)local_80;
uVar8 = (ulong)local_78;
puVar15 = local_40 + *(uint *)(local_60 + 0x744) + uVar8;
local_50 = param_1;
if (puVar15 < (int1 *)(uVar7 + local_90)) {
local_48 = local_48 + 1;
do {
uVar13 = *(int8 *)(lVar11 + 0xc0);
uVar9 = *param_2;
uVar2 = *(int4 *)(param_2 + 2);
if (uVar8 == 0) {
*(int8 *)(puVar14 + -8) = 0x16c676;
iVar6 = maria_rtree_key_cmp(uVar13,uVar9,puVar15,uVar2,0x6000);
plVar4 = local_50;
if (iVar6 == 0) {
*(int1 *)(local_50[0x5d] + 0x10 + (ulong)local_70 * 0x18) = 1;
uVar2 = *(int4 *)(param_2 + 2);
*(int8 *)(puVar14 + -8) = 0x16c79d;
iVar6 = maria_rtree_delete_key(local_a0,puVar15,uVar2);
if (iVar6 != 0) goto LAB_0016c5c6;
*local_58 = local_80;
if (local_80 == *(uint *)(*plVar4 + 0x744)) {
*(int8 *)(puVar14 + -8) = 0x16c7cb;
iVar6 = _ma_dispose(plVar4,local_88,0);
if (iVar6 != 0) goto LAB_0016c5c6;
uVar13 = 2;
goto LAB_0016c6a5;
}
LAB_0016c8d2:
*(int8 *)(puVar14 + -8) = 0x16c8e1;
cVar5 = _ma_write_keypage(local_a0,2,3);
if (cVar5 != '\0') goto LAB_0016c5c6;
LAB_0016c8e9:
uVar13 = 0;
goto LAB_0016c6a5;
}
uVar12 = (ulong)*(uint *)(local_60 + 0x3e0);
}
else {
*(int8 *)(puVar14 + -8) = 0x16c634;
iVar6 = maria_rtree_key_cmp(uVar13,uVar9,puVar15,uVar2,0x800);
uVar12 = uVar8;
if (iVar6 == 0) {
*(int8 *)(puVar14 + -8) = 0x16c646;
uVar9 = _ma_kpos(uVar8,puVar15);
iVar6 = local_48;
plVar4 = local_50;
puVar3 = local_58;
uVar13 = local_68;
*(int8 *)(puVar14 + -8) = 0x16c661;
iVar6 = maria_rtree_delete_req(plVar4,param_2,uVar9,puVar3,uVar13,iVar6);
if (iVar6 != 1) {
if (iVar6 == 2) {
uVar2 = *(int4 *)(param_2 + 2);
*(int8 *)(puVar14 + -8) = 0x16c7f1;
iVar6 = maria_rtree_delete_key(local_a0,puVar15,uVar2);
if (iVar6 != 0) goto LAB_0016c5c6;
lVar11 = local_50[0x5d];
}
else {
if (iVar6 != 0) goto LAB_0016c5c6;
if ((*(ushort *)(lVar11 + 0xa6) - 4) / 3 <= *local_58 + *(int *)(param_2 + 2)) {
local_ac = *(int4 *)((long)param_2 + 0x14);
local_a8 = 0;
local_c0 = puVar15;
local_b8 = lVar11;
local_b0 = *(int *)(param_2 + 2);
*(int8 *)(puVar14 + -8) = 0x16c867;
uVar13 = _ma_kpos(local_78,puVar15);
plVar4 = local_50;
*(int8 *)(puVar14 + -8) = 0x16c879;
iVar6 = maria_rtree_set_key_mbr(plVar4,&local_c0,uVar13);
if (iVar6 != 0) goto LAB_0016c5c6;
if (*(char *)(local_60 + 0x7e7) != '\0') {
uVar2 = *(int4 *)(param_2 + 2);
*(int8 *)(puVar14 + -8) = 0x16c8a7;
cVar5 = _ma_log_change(local_a0,puVar15,uVar2,2);
if (cVar5 != '\0') goto LAB_0016c5c6;
}
*(int1 *)(plVar4[0x5d] + 0x10 + (ulong)local_70 * 0x18) = 1;
goto LAB_0016c8d2;
}
*(int8 *)(puVar14 + -8) = 0x16c72f;
uVar9 = _ma_kpos(uVar8,puVar15);
iVar6 = local_48;
uVar13 = local_68;
*(int8 *)(puVar14 + -8) = 0x16c73e;
cVar5 = maria_rtree_fill_reinsert_list(uVar13,uVar9,iVar6);
plVar4 = local_50;
if (cVar5 != '\0') goto LAB_0016c5c6;
uVar2 = *(int4 *)(param_2 + 2);
*(int8 *)(puVar14 + -8) = 0x16c75e;
iVar6 = maria_rtree_delete_key(local_a0,puVar15,uVar2);
if (iVar6 != 0) goto LAB_0016c5c6;
lVar11 = plVar4[0x5d];
}
*(int1 *)(lVar11 + 0x10 + (ulong)local_70 * 0x18) = 1;
*(int8 *)(puVar14 + -8) = 0x16c826;
cVar5 = _ma_write_keypage(local_a0,2,3);
if (cVar5 == '\0') {
*local_58 = local_80;
goto LAB_0016c8e9;
}
goto LAB_0016c5c6;
}
}
}
puVar15 = puVar15 + *(uint *)(param_2 + 2) + uVar12;
} while (puVar15 < (int1 *)(uVar7 + local_90));
}
uVar13 = 1;
LAB_0016c6a5:
puVar15 = local_40;
}
else {
LAB_0016c5c6:
uVar13 = 0xffffffff;
puVar15 = local_40;
}
local_40 = puVar15;
if ((char)local_44 == '\0') {
*(int8 *)(puVar14 + -8) = 0x16c6b0;
my_free(puVar15);
}
LAB_0016c6c2:
if (*(long *)(in_FS_OFFSET + 0x28) == local_38) {
return uVar13;
}
/* WARNING: Subroutine does not return */
*(code **)(puVar14 + -8) = maria_rtree_estimate;
__stack_chk_fail();
}
| |
43,426 | convert_index_to_s3_format | eloqsql/storage/maria/s3_func.c | static void convert_index_to_s3_format(uchar *header, ulong block_size,
int compression)
{
MARIA_STATE_INFO state;
uchar *base_pos;
uint base_offset;
memcpy(state.header.file_version, header, sizeof(state.header));
base_offset= mi_uint2korr(state.header.base_pos);
base_pos= header + base_offset;
base_pos[107]= (uchar) compression;
mi_int3store(base_pos+119, block_size);
} | O0 | c | convert_index_to_s3_format:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1c8(%rbp)
movq %rsi, -0x1d0(%rbp)
movl %edx, -0x1d4(%rbp)
movq -0x1c8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x1b0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x1c0(%rbp)
movw -0x1b4(%rbp), %ax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, -0x1e4(%rbp)
movq -0x1c8(%rbp), %rax
movl -0x1e4(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x1e0(%rbp)
movb -0x1d4(%rbp), %cl
movq -0x1e0(%rbp), %rax
movb %cl, 0x6b(%rax)
movq -0x1d0(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movb -0x1f0(%rbp), %cl
movq -0x1e0(%rbp), %rax
movb %cl, 0x79(%rax)
movb -0x1ef(%rbp), %cl
movq -0x1e0(%rbp), %rax
movb %cl, 0x78(%rax)
movb -0x1ee(%rbp), %cl
movq -0x1e0(%rbp), %rax
movb %cl, 0x77(%rax)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x29c3c
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbp
retq
callq 0x272b0
nopw %cs:(%rax,%rax)
| convert_index_to_s3_format:
push rbp
mov rbp, rsp
sub rsp, 1F0h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1C8], rdi
mov [rbp+var_1D0], rsi
mov [rbp+var_1D4], edx
mov rax, [rbp+var_1C8]
mov rcx, [rax+10h]
mov [rbp+var_1B0], rcx
movups xmm0, xmmword ptr [rax]
movaps [rbp+var_1C0], xmm0
mov ax, word ptr [rbp+var_1C0+0Ch]
rol ax, 8
movzx eax, ax
mov [rbp+var_1E4], eax
mov rax, [rbp+var_1C8]
mov ecx, [rbp+var_1E4]
add rax, rcx
mov [rbp+var_1E0], rax
mov cl, byte ptr [rbp+var_1D4]
mov rax, [rbp+var_1E0]
mov [rax+6Bh], cl
mov rax, [rbp+var_1D0]
mov [rbp+var_1F0], rax
mov cl, byte ptr [rbp+var_1F0]
mov rax, [rbp+var_1E0]
mov [rax+79h], cl
mov cl, byte ptr [rbp+var_1F0+1]
mov rax, [rbp+var_1E0]
mov [rax+78h], cl
mov cl, byte ptr [rbp+var_1F0+2]
mov rax, [rbp+var_1E0]
mov [rax+77h], cl
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_29C3C
add rsp, 1F0h
pop rbp
retn
loc_29C3C:
call ___stack_chk_fail
| unsigned long long convert_index_to_s3_format(_OWORD *a1, int a2, char a3)
{
_BYTE *v4; // [rsp+10h] [rbp-1E0h]
v4 = (char *)a1 + (unsigned __int16)__ROL2__(WORD6(*a1), 8);
v4[107] = a3;
v4[121] = a2;
v4[120] = BYTE1(a2);
v4[119] = BYTE2(a2);
return __readfsqword(0x28u);
}
| convert_index_to_s3_format:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1f0
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x1c8],RDI
MOV qword ptr [RBP + -0x1d0],RSI
MOV dword ptr [RBP + -0x1d4],EDX
MOV RAX,qword ptr [RBP + -0x1c8]
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RBP + -0x1b0],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RBP + -0x1c0],XMM0
MOV AX,word ptr [RBP + -0x1b4]
ROL AX,0x8
MOVZX EAX,AX
MOV dword ptr [RBP + -0x1e4],EAX
MOV RAX,qword ptr [RBP + -0x1c8]
MOV ECX,dword ptr [RBP + -0x1e4]
ADD RAX,RCX
MOV qword ptr [RBP + -0x1e0],RAX
MOV CL,byte ptr [RBP + -0x1d4]
MOV RAX,qword ptr [RBP + -0x1e0]
MOV byte ptr [RAX + 0x6b],CL
MOV RAX,qword ptr [RBP + -0x1d0]
MOV qword ptr [RBP + -0x1f0],RAX
MOV CL,byte ptr [RBP + -0x1f0]
MOV RAX,qword ptr [RBP + -0x1e0]
MOV byte ptr [RAX + 0x79],CL
MOV CL,byte ptr [RBP + -0x1ef]
MOV RAX,qword ptr [RBP + -0x1e0]
MOV byte ptr [RAX + 0x78],CL
MOV CL,byte ptr [RBP + -0x1ee]
MOV RAX,qword ptr [RBP + -0x1e0]
MOV byte ptr [RAX + 0x77],CL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00129c3c
ADD RSP,0x1f0
POP RBP
RET
LAB_00129c3c:
CALL 0x001272b0
|
void convert_index_to_s3_format(long param_1,int8 param_2,int1 param_3)
{
long lVar1;
long in_FS_OFFSET;
int1 local_1f8;
int1 uStack_1f7;
int1 uStack_1f6;
int2 uStack_1bc;
lVar1 = *(long *)(in_FS_OFFSET + 0x28);
uStack_1bc = (ushort)*(int4 *)(param_1 + 0xc);
param_1 = param_1 + (ulong)(ushort)(uStack_1bc << 8 | uStack_1bc >> 8);
*(int1 *)(param_1 + 0x6b) = param_3;
local_1f8 = (int1)param_2;
*(int1 *)(param_1 + 0x79) = local_1f8;
uStack_1f7 = (int1)((ulong)param_2 >> 8);
*(int1 *)(param_1 + 0x78) = uStack_1f7;
uStack_1f6 = (int1)((ulong)param_2 >> 0x10);
*(int1 *)(param_1 + 0x77) = uStack_1f6;
if (*(long *)(in_FS_OFFSET + 0x28) == lVar1) {
return;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,427 | mthd_my_send_cmd | eloqsql/libmariadb/libmariadb/mariadb_lib.c | int
mthd_my_send_cmd(MYSQL *mysql,enum enum_server_command command, const char *arg,
size_t length, my_bool skip_check, void *opt_arg)
{
NET *net= &mysql->net;
int result= -1;
if (mysql->net.pvio == 0)
{
/* Do reconnect if possible */
if (mariadb_reconnect(mysql))
return(1);
}
if (mysql->status != MYSQL_STATUS_READY ||
mysql->server_status & SERVER_MORE_RESULTS_EXIST)
{
SET_CLIENT_ERROR(mysql, CR_COMMANDS_OUT_OF_SYNC, SQLSTATE_UNKNOWN, 0);
goto end;
}
if (IS_CONNHDLR_ACTIVE(mysql))
{
result= mysql->extension->conn_hdlr->plugin->set_connection(mysql, command, arg, length, skip_check, opt_arg);
if (result== -1)
return(result);
}
CLEAR_CLIENT_ERROR(mysql);
if (command == COM_QUERY ||
command == COM_STMT_PREPARE)
{
if ((mysql->options.client_flag & CLIENT_LOCAL_FILES) &&
mysql->options.extension && mysql->extension->auto_local_infile == WAIT_FOR_QUERY &&
arg && (*arg == 'l' || *arg == 'L'))
{
if (strncasecmp(arg, "load", 4) == 0)
mysql->extension->auto_local_infile= ACCEPT_FILE_REQUEST;
}
}
mysql->info=0;
mysql->affected_rows= ~(unsigned long long) 0;
ma_net_clear(net); /* Clear receive buffer */
if (!arg)
arg="";
if (net->extension->multi_status== COM_MULTI_ENABLED)
{
return net_add_multi_command(net, command, (const uchar *)arg, length);
}
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
if (net->last_errno == ER_NET_PACKET_TOO_LARGE)
{
my_set_error(mysql, CR_NET_PACKET_TOO_LARGE, SQLSTATE_UNKNOWN, 0);
goto end;
}
end_server(mysql);
if (mariadb_reconnect(mysql))
goto end;
if (ma_net_write_command(net,(uchar) command,arg,
length ? length : (ulong) strlen(arg), 0))
{
my_set_error(mysql, CR_SERVER_GONE_ERROR, SQLSTATE_UNKNOWN, 0);
goto end;
}
}
result=0;
if (net->extension->multi_status > COM_MULTI_OFF)
skip_check= 1;
if (!skip_check)
{
result= ((mysql->packet_length=ma_net_safe_read(mysql)) == packet_error ?
1 : 0);
}
end:
return(result);
} | O0 | c | mthd_my_send_cmd:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movb %al, -0x29(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x30cb8
movq -0x10(%rbp), %rdi
callq 0x31080
cmpb $0x0, %al
je 0x30cb6
movl $0x1, -0x4(%rbp)
jmp 0x31071
jmp 0x30cb8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x488(%rax)
jne 0x30cd7
movq -0x10(%rbp), %rax
movl 0x380(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x30d41
jmp 0x30cd9
movq -0x10(%rbp), %rax
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x501a7(%rip), %rax # 0x80ea0
movq (%rax), %rsi
movl $0x5, %edx
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x29c(%rax)
movq -0x10(%rbp), %rdi
addq $0x97, %rdi
leaq 0x5018d(%rip), %rax # 0x80eb0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x14220
movq -0x10(%rbp), %rax
movb $0x0, 0x296(%rax)
jmp 0x3106b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x4f0(%rax)
je 0x30da8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
cmpq $0x0, (%rax)
je 0x30da8
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movb -0x29(%rbp), %r8b
movq -0x38(%rbp), %r9
movsbl %r8b, %r8d
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $-0x1, -0x44(%rbp)
jne 0x30da6
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x31071
jmp 0x30da8
jmp 0x30daa
movq -0x10(%rbp), %rax
movl $0x0, 0x90(%rax)
movq -0x10(%rbp), %rdi
addq $0x297, %rdi # imm = 0x297
leaq 0x39de5(%rip), %rsi # 0x6abaf
callq 0x143d0
movq -0x10(%rbp), %rax
movb $0x0, 0x97(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x2a0(%rax)
je 0x30dfa
movq -0x10(%rbp), %rax
movq 0x2a0(%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x30dfc
cmpl $0x3, -0x14(%rbp)
je 0x30e0c
cmpl $0x16, -0x14(%rbp)
jne 0x30e91
movq -0x10(%rbp), %rax
movq 0x3a8(%rax), %rax
andq $0x80, %rax
cmpq $0x0, %rax
je 0x30e8f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x480(%rax)
je 0x30e8f
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movsbl 0x78(%rax), %eax
cmpl $0x1, %eax
jne 0x30e8f
cmpq $0x0, -0x20(%rbp)
je 0x30e8f
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6c, %eax
je 0x30e64
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4c, %eax
jne 0x30e8f
movq -0x20(%rbp), %rdi
leaq 0x39d46(%rip), %rsi # 0x6abb5
movl $0x4, %edx
callq 0x14580
cmpl $0x0, %eax
jne 0x30e8d
movq -0x10(%rbp), %rax
movq 0x4f0(%rax), %rax
movb $0x2, 0x78(%rax)
jmp 0x30e8f
jmp 0x30e91
movq -0x10(%rbp), %rax
movq $0x0, 0x2e0(%rax)
movq -0x10(%rbp), %rax
movq $-0x1, 0x338(%rax)
movq -0x40(%rbp), %rdi
callq 0x602e0
cmpq $0x0, -0x20(%rbp)
jne 0x30eca
leaq 0x354aa(%rip), %rax # 0x66370
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x2, (%rax)
jne 0x30ef9
movq -0x40(%rbp), %rdi
movl -0x14(%rbp), %eax
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movzbl %al, %esi
callq 0x61330
movl %eax, -0x4(%rbp)
jmp 0x31071
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x51(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30f20
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x30f2d
movq -0x20(%rbp), %rdi
callq 0x141a0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %rdx
movb -0x51(%rbp), %al
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x60a80
cmpl $0x0, %eax
je 0x3101c
movq -0x40(%rbp), %rax
cmpl $0x481, 0x90(%rax) # imm = 0x481
jne 0x30f83
movq -0x10(%rbp), %rdi
leaq 0x4ff35(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movl $0x7e4, %esi # imm = 0x7E4
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
jmp 0x3106b
movq -0x10(%rbp), %rdi
callq 0x30780
movq -0x10(%rbp), %rdi
callq 0x31080
cmpb $0x0, %al
je 0x30f9e
jmp 0x3106b
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x14(%rbp), %eax
movb %al, -0x71(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x30fc8
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
jmp 0x30fd8
movq -0x20(%rbp), %rdi
callq 0x141a0
movq %rax, -0x88(%rbp)
movq -0x70(%rbp), %rdx
movb -0x71(%rbp), %al
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rcx
xorl %r8d, %r8d
movzbl %al, %esi
callq 0x60a80
cmpl $0x0, %eax
je 0x3101a
movq -0x10(%rbp), %rdi
leaq 0x4fe9b(%rip), %rax # 0x80ea0
movq (%rax), %rdx
movl $0x7d6, %esi # imm = 0x7D6
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x307d0
jmp 0x3106b
jmp 0x3101c
movl $0x0, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq 0x2a0(%rax), %rax
cmpl $0x0, (%rax)
jbe 0x31037
movb $0x1, -0x29(%rbp)
cmpb $0x0, -0x29(%rbp)
jne 0x31069
movq -0x10(%rbp), %rdi
callq 0x304c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, 0x358(%rax)
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovel %ecx, %eax
movl %eax, -0x44(%rbp)
jmp 0x3106b
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| mthd_my_send_cmd:
push rbp
mov rbp, rsp
sub rsp, 90h
mov al, r8b
mov [rbp+var_10], rdi
mov [rbp+var_14], esi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov [rbp+var_29], al
mov [rbp+var_38], r9
mov rax, [rbp+var_10]
mov [rbp+var_40], rax
mov [rbp+var_44], 0FFFFFFFFh
mov rax, [rbp+var_10]
cmp qword ptr [rax], 0
jnz short loc_30CB8
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_30CB6
mov [rbp+var_4], 1
jmp loc_31071
loc_30CB6:
jmp short $+2
loc_30CB8:
mov rax, [rbp+var_10]
cmp dword ptr [rax+488h], 0
jnz short loc_30CD7
mov rax, [rbp+var_10]
mov eax, [rax+380h]
and eax, 8
cmp eax, 0
jz short loc_30D41
loc_30CD7:
jmp short $+2
loc_30CD9:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 7DEh
mov rdi, [rbp+var_10]
add rdi, 297h
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+29Ch], 0
mov rdi, [rbp+var_10]
add rdi, 97h
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+296h], 0
jmp loc_3106B
loc_30D41:
mov rax, [rbp+var_10]
cmp qword ptr [rax+4F0h], 0
jz short loc_30DA8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
cmp qword ptr [rax], 0
jz short loc_30DA8
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov rax, [rax]
mov rax, [rax]
mov rax, [rax+70h]
mov rdi, [rbp+var_10]
mov esi, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
mov r8b, [rbp+var_29]
mov r9, [rbp+var_38]
movsx r8d, r8b
call rax
mov [rbp+var_44], eax
cmp [rbp+var_44], 0FFFFFFFFh
jnz short loc_30DA6
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
jmp loc_31071
loc_30DA6:
jmp short $+2
loc_30DA8:
jmp short $+2
loc_30DAA:
mov rax, [rbp+var_10]
mov dword ptr [rax+90h], 0
mov rdi, [rbp+var_10]
add rdi, 297h
lea rsi, a00000; "00000"
call _strcpy
mov rax, [rbp+var_10]
mov byte ptr [rax+97h], 0
mov rax, [rbp+var_10]
cmp qword ptr [rax+2A0h], 0
jz short loc_30DFA
mov rax, [rbp+var_10]
mov rax, [rax+2A0h]
mov dword ptr [rax+4], 0
loc_30DFA:
jmp short $+2
loc_30DFC:
cmp [rbp+var_14], 3
jz short loc_30E0C
cmp [rbp+var_14], 16h
jnz loc_30E91
loc_30E0C:
mov rax, [rbp+var_10]
mov rax, [rax+3A8h]
and rax, 80h
cmp rax, 0
jz short loc_30E8F
mov rax, [rbp+var_10]
cmp qword ptr [rax+480h], 0
jz short loc_30E8F
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
movsx eax, byte ptr [rax+78h]
cmp eax, 1
jnz short loc_30E8F
cmp [rbp+var_20], 0
jz short loc_30E8F
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 6Ch ; 'l'
jz short loc_30E64
mov rax, [rbp+var_20]
movsx eax, byte ptr [rax]
cmp eax, 4Ch ; 'L'
jnz short loc_30E8F
loc_30E64:
mov rdi, [rbp+var_20]
lea rsi, aLoad; "load"
mov edx, 4
call _strncasecmp
cmp eax, 0
jnz short loc_30E8D
mov rax, [rbp+var_10]
mov rax, [rax+4F0h]
mov byte ptr [rax+78h], 2
loc_30E8D:
jmp short $+2
loc_30E8F:
jmp short $+2
loc_30E91:
mov rax, [rbp+var_10]
mov qword ptr [rax+2E0h], 0
mov rax, [rbp+var_10]
mov qword ptr [rax+338h], 0FFFFFFFFFFFFFFFFh
mov rdi, [rbp+var_40]
call ma_net_clear
cmp [rbp+var_20], 0
jnz short loc_30ECA
lea rax, a12+4; ""
mov [rbp+var_20], rax
loc_30ECA:
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 2
jnz short loc_30EF9
mov rdi, [rbp+var_40]
mov eax, [rbp+var_14]
mov rdx, [rbp+var_20]
mov rcx, [rbp+var_28]
movzx esi, al
call net_add_multi_command
mov [rbp+var_4], eax
jmp loc_31071
loc_30EF9:
mov rax, [rbp+var_40]
mov [rbp+var_60], rax
mov eax, [rbp+var_14]
mov [rbp+var_51], al
mov rax, [rbp+var_20]
mov [rbp+var_50], rax
cmp [rbp+var_28], 0
jz short loc_30F20
mov rax, [rbp+var_28]
mov [rbp+var_68], rax
jmp short loc_30F2D
loc_30F20:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_68], rax
loc_30F2D:
mov rdx, [rbp+var_50]
mov al, [rbp+var_51]
mov rdi, [rbp+var_60]
mov rcx, [rbp+var_68]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz loc_3101C
mov rax, [rbp+var_40]
cmp dword ptr [rax+90h], 481h
jnz short loc_30F83
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7E4h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp loc_3106B
loc_30F83:
mov rdi, [rbp+var_10]
call end_server
mov rdi, [rbp+var_10]
call mariadb_reconnect
cmp al, 0
jz short loc_30F9E
jmp loc_3106B
loc_30F9E:
mov rax, [rbp+var_40]
mov [rbp+var_80], rax
mov eax, [rbp+var_14]
mov [rbp+var_71], al
mov rax, [rbp+var_20]
mov [rbp+var_70], rax
cmp [rbp+var_28], 0
jz short loc_30FC8
mov rax, [rbp+var_28]
mov [rbp+var_88], rax
jmp short loc_30FD8
loc_30FC8:
mov rdi, [rbp+var_20]
call _strlen
mov [rbp+var_88], rax
loc_30FD8:
mov rdx, [rbp+var_70]
mov al, [rbp+var_71]
mov rdi, [rbp+var_80]
mov rcx, [rbp+var_88]
xor r8d, r8d
movzx esi, al
call ma_net_write_command
cmp eax, 0
jz short loc_3101A
mov rdi, [rbp+var_10]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D6h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
jmp short loc_3106B
loc_3101A:
jmp short $+2
loc_3101C:
mov [rbp+var_44], 0
mov rax, [rbp+var_40]
mov rax, [rax+2A0h]
cmp dword ptr [rax], 0
jbe short loc_31037
mov [rbp+var_29], 1
loc_31037:
cmp [rbp+var_29], 0
jnz short loc_31069
mov rdi, [rbp+var_10]
call ma_net_safe_read
mov rdx, rax
mov rax, [rbp+var_10]
mov [rax+358h], rdx
mov esi, 0FFFFFFFFh
xor eax, eax
mov ecx, 1
cmp rdx, rsi
cmovz eax, ecx
mov [rbp+var_44], eax
loc_31069:
jmp short $+2
loc_3106B:
mov eax, [rbp+var_44]
mov [rbp+var_4], eax
loc_31071:
mov eax, [rbp+var_4]
add rsp, 90h
pop rbp
retn
| long long mthd_my_send_cmd(long long a1, long long a2, char *a3, long long a4, char a5, long long a6)
{
long long v6; // rdx
long long v7; // rcx
int v8; // r8d
int v9; // r9d
long long v10; // rdx
long long v12; // [rsp+8h] [rbp-88h]
long long v13; // [rsp+28h] [rbp-68h]
unsigned int v14; // [rsp+4Ch] [rbp-44h]
v14 = -1;
if ( *(_QWORD *)a1 || !(unsigned __int8)mariadb_reconnect(a1) )
{
if ( *(_DWORD *)(a1 + 1160) || (*(_DWORD *)(a1 + 896) & 8) != 0 )
{
*(_DWORD *)(a1 + 144) = 2014;
strncpy(a1 + 663, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 668) = 0;
strncpy(a1 + 151, client_errors[14], 511LL);
*(_BYTE *)(a1 + 662) = 0;
return v14;
}
if ( *(_QWORD *)(a1 + 1264) )
{
if ( **(_QWORD **)(a1 + 1264) )
{
v14 = (*(long long ( **)(long long, _QWORD, char *, long long, _QWORD, long long))(***(_QWORD ***)(a1 + 1264)
+ 112LL))(
a1,
(unsigned int)a2,
a3,
a4,
(unsigned int)a5,
a6);
if ( v14 == -1 )
return (unsigned int)-1;
}
}
*(_DWORD *)(a1 + 144) = 0;
strcpy(a1 + 663, "00000");
*(_BYTE *)(a1 + 151) = 0;
if ( *(_QWORD *)(a1 + 672) )
*(_DWORD *)(*(_QWORD *)(a1 + 672) + 4LL) = 0;
if ( ((_DWORD)a2 == 3 || (_DWORD)a2 == 22)
&& (*(_QWORD *)(a1 + 936) & 0x80LL) != 0
&& *(_QWORD *)(a1 + 1152)
&& *(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) == 1
&& a3
&& (*a3 == 108 || *a3 == 76)
&& !(unsigned int)strncasecmp(a3, "load", 4LL) )
{
*(_BYTE *)(*(_QWORD *)(a1 + 1264) + 120LL) = 2;
}
*(_QWORD *)(a1 + 736) = 0LL;
*(_QWORD *)(a1 + 824) = -1LL;
ma_net_clear(a1);
if ( !a3 )
a3 = "";
if ( **(_DWORD **)(a1 + 672) == 2 )
return (unsigned int)net_add_multi_command(a1, (unsigned __int8)a2, a3, a4);
if ( a4 )
v13 = a4;
else
v13 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v13, 0LL) )
{
if ( *(_DWORD *)(a1 + 144) == 1153 )
{
my_set_error(a1, 0x7E4u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
end_server((_QWORD *)a1);
if ( (unsigned __int8)mariadb_reconnect(a1) )
return v14;
if ( a4 )
v12 = a4;
else
v12 = strlen(a3);
a2 = (unsigned __int8)a2;
if ( (unsigned int)ma_net_write_command(a1, (unsigned __int8)a2, a3, v12, 0LL) )
{
my_set_error(a1, 0x7D6u, (long long)SQLSTATE_UNKNOWN, 0LL);
return v14;
}
}
v14 = 0;
if ( **(_DWORD **)(a1 + 672) )
a5 = 1;
if ( !a5 )
{
v10 = ma_net_safe_read(a1, a2, v6, v7, v8, v9);
*(_QWORD *)(a1 + 856) = v10;
return v10 == 0xFFFFFFFFLL;
}
return v14;
}
return 1;
}
| mthd_my_send_cmd:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV AL,R8B
MOV qword ptr [RBP + -0x10],RDI
MOV dword ptr [RBP + -0x14],ESI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV byte ptr [RBP + -0x29],AL
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0x40],RAX
MOV dword ptr [RBP + -0x44],0xffffffff
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX],0x0
JNZ 0x00130cb8
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00131080
CMP AL,0x0
JZ 0x00130cb6
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00131071
LAB_00130cb6:
JMP 0x00130cb8
LAB_00130cb8:
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x488],0x0
JNZ 0x00130cd7
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x380]
AND EAX,0x8
CMP EAX,0x0
JZ 0x00130d41
LAB_00130cd7:
JMP 0x00130cd9
LAB_00130cd9:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x7de
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RAX,[0x180ea0]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x29c],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x97
LEA RAX,[0x180eb0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00114220
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x296],0x0
JMP 0x0013106b
LAB_00130d41:
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x4f0],0x0
JZ 0x00130da8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
CMP qword ptr [RAX],0x0
JZ 0x00130da8
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x70]
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOV R8B,byte ptr [RBP + -0x29]
MOV R9,qword ptr [RBP + -0x38]
MOVSX R8D,R8B
CALL RAX
MOV dword ptr [RBP + -0x44],EAX
CMP dword ptr [RBP + -0x44],-0x1
JNZ 0x00130da6
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00131071
LAB_00130da6:
JMP 0x00130da8
LAB_00130da8:
JMP 0x00130daa
LAB_00130daa:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x90],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x297
LEA RSI,[0x16abaf]
CALL 0x001143d0
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x97],0x0
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x2a0],0x0
JZ 0x00130dfa
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x2a0]
MOV dword ptr [RAX + 0x4],0x0
LAB_00130dfa:
JMP 0x00130dfc
LAB_00130dfc:
CMP dword ptr [RBP + -0x14],0x3
JZ 0x00130e0c
CMP dword ptr [RBP + -0x14],0x16
JNZ 0x00130e91
LAB_00130e0c:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x3a8]
AND RAX,0x80
CMP RAX,0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x10]
CMP qword ptr [RAX + 0x480],0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOVSX EAX,byte ptr [RAX + 0x78]
CMP EAX,0x1
JNZ 0x00130e8f
CMP qword ptr [RBP + -0x20],0x0
JZ 0x00130e8f
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x6c
JZ 0x00130e64
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x4c
JNZ 0x00130e8f
LAB_00130e64:
MOV RDI,qword ptr [RBP + -0x20]
LEA RSI,[0x16abb5]
MOV EDX,0x4
CALL 0x00114580
CMP EAX,0x0
JNZ 0x00130e8d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x4f0]
MOV byte ptr [RAX + 0x78],0x2
LAB_00130e8d:
JMP 0x00130e8f
LAB_00130e8f:
JMP 0x00130e91
LAB_00130e91:
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x2e0],0x0
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x338],-0x1
MOV RDI,qword ptr [RBP + -0x40]
CALL 0x001602e0
CMP qword ptr [RBP + -0x20],0x0
JNZ 0x00130eca
LEA RAX,[0x166370]
MOV qword ptr [RBP + -0x20],RAX
LAB_00130eca:
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x2
JNZ 0x00130ef9
MOV RDI,qword ptr [RBP + -0x40]
MOV EAX,dword ptr [RBP + -0x14]
MOV RDX,qword ptr [RBP + -0x20]
MOV RCX,qword ptr [RBP + -0x28]
MOVZX ESI,AL
CALL 0x00161330
MOV dword ptr [RBP + -0x4],EAX
JMP 0x00131071
LAB_00130ef9:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x60],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x51],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x50],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00130f20
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x68],RAX
JMP 0x00130f2d
LAB_00130f20:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001141a0
MOV qword ptr [RBP + -0x68],RAX
LAB_00130f2d:
MOV RDX,qword ptr [RBP + -0x50]
MOV AL,byte ptr [RBP + -0x51]
MOV RDI,qword ptr [RBP + -0x60]
MOV RCX,qword ptr [RBP + -0x68]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00160a80
CMP EAX,0x0
JZ 0x0013101c
MOV RAX,qword ptr [RBP + -0x40]
CMP dword ptr [RAX + 0x90],0x481
JNZ 0x00130f83
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7e4
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
JMP 0x0013106b
LAB_00130f83:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00130780
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x00131080
CMP AL,0x0
JZ 0x00130f9e
JMP 0x0013106b
LAB_00130f9e:
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x80],RAX
MOV EAX,dword ptr [RBP + -0x14]
MOV byte ptr [RBP + -0x71],AL
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x70],RAX
CMP qword ptr [RBP + -0x28],0x0
JZ 0x00130fc8
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x88],RAX
JMP 0x00130fd8
LAB_00130fc8:
MOV RDI,qword ptr [RBP + -0x20]
CALL 0x001141a0
MOV qword ptr [RBP + -0x88],RAX
LAB_00130fd8:
MOV RDX,qword ptr [RBP + -0x70]
MOV AL,byte ptr [RBP + -0x71]
MOV RDI,qword ptr [RBP + -0x80]
MOV RCX,qword ptr [RBP + -0x88]
XOR R8D,R8D
MOVZX ESI,AL
CALL 0x00160a80
CMP EAX,0x0
JZ 0x0013101a
MOV RDI,qword ptr [RBP + -0x10]
LEA RAX,[0x180ea0]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d6
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x001307d0
JMP 0x0013106b
LAB_0013101a:
JMP 0x0013101c
LAB_0013101c:
MOV dword ptr [RBP + -0x44],0x0
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x2a0]
CMP dword ptr [RAX],0x0
JBE 0x00131037
MOV byte ptr [RBP + -0x29],0x1
LAB_00131037:
CMP byte ptr [RBP + -0x29],0x0
JNZ 0x00131069
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001304c0
MOV RDX,RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RAX + 0x358],RDX
MOV ESI,0xffffffff
XOR EAX,EAX
MOV ECX,0x1
CMP RDX,RSI
CMOVZ EAX,ECX
MOV dword ptr [RBP + -0x44],EAX
LAB_00131069:
JMP 0x0013106b
LAB_0013106b:
MOV EAX,dword ptr [RBP + -0x44]
MOV dword ptr [RBP + -0x4],EAX
LAB_00131071:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x90
POP RBP
RET
|
uint mthd_my_send_cmd(long *param_1,uint param_2,char *param_3,size_t param_4,char param_5,
int8 param_6)
{
char cVar1;
int iVar2;
uint uVar3;
long lVar4;
size_t local_90;
size_t local_70;
uint local_4c;
char local_31;
char *local_28;
local_4c = 0xffffffff;
if ((*param_1 == 0) && (cVar1 = mariadb_reconnect(param_1), cVar1 != '\0')) {
return 1;
}
if (((int)param_1[0x91] != 0) || ((*(uint *)(param_1 + 0x70) & 8) != 0)) {
*(int4 *)(param_1 + 0x12) = 0x7de;
strncpy((char *)((long)param_1 + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)((long)param_1 + 0x29c) = 0;
strncpy((char *)((long)param_1 + 0x97),PTR_s_Commands_out_of_sync__you_can_t_r_00180f20,0x1ff);
*(int1 *)((long)param_1 + 0x296) = 0;
return 0xffffffff;
}
if (((param_1[0x9e] != 0) && (*(long *)param_1[0x9e] != 0)) &&
(local_4c = (**(code **)(**(long **)param_1[0x9e] + 0x70))
(param_1,param_2,param_3,param_4,(int)param_5,param_6),
local_4c == 0xffffffff)) {
return 0xffffffff;
}
*(int4 *)(param_1 + 0x12) = 0;
strcpy((char *)((long)param_1 + 0x297),"00000");
*(int1 *)((long)param_1 + 0x97) = 0;
if (param_1[0x54] != 0) {
*(int4 *)(param_1[0x54] + 4) = 0;
}
if (((((param_2 == 3) || (param_2 == 0x16)) &&
(((param_1[0x75] & 0x80U) != 0 &&
((param_1[0x90] != 0 && (*(char *)(param_1[0x9e] + 0x78) == '\x01')))))) &&
(param_3 != (char *)0x0)) &&
(((*param_3 == 'l' || (*param_3 == 'L')) && (iVar2 = strncasecmp(param_3,"load",4), iVar2 == 0)
))) {
*(int1 *)(param_1[0x9e] + 0x78) = 2;
}
param_1[0x5c] = 0;
param_1[0x67] = -1;
ma_net_clear(param_1);
local_28 = param_3;
if (param_3 == (char *)0x0) {
local_28 = "";
}
if (*(int *)param_1[0x54] != 2) {
local_70 = param_4;
if (param_4 == 0) {
local_70 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_70,0);
if (iVar2 != 0) {
if ((int)param_1[0x12] == 0x481) {
my_set_error(param_1,0x7e4,SQLSTATE_UNKNOWN,0);
return local_4c;
}
end_server(param_1);
cVar1 = mariadb_reconnect(param_1);
if (cVar1 != '\0') {
return local_4c;
}
local_90 = param_4;
if (param_4 == 0) {
local_90 = strlen(local_28);
}
iVar2 = ma_net_write_command(param_1,(char)param_2,local_28,local_90,0);
if (iVar2 != 0) {
my_set_error(param_1,0x7d6,SQLSTATE_UNKNOWN,0);
return local_4c;
}
}
local_4c = 0;
local_31 = param_5;
if (*(int *)param_1[0x54] != 0) {
local_31 = '\x01';
}
if (local_31 == '\0') {
lVar4 = ma_net_safe_read(param_1);
param_1[0x6b] = lVar4;
local_4c = (uint)(lVar4 == 0xffffffff);
}
return local_4c;
}
uVar3 = net_add_multi_command(param_1,param_2 & 0xff,local_28,param_4);
return uVar3;
}
| |
43,428 | ftxui::operator|(std::vector<std::shared_ptr<ftxui::Node>, std::allocator<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 | Elements operator|(Elements elements, Decorator decorator) { // NOLINT
Elements output;
output.reserve(elements.size());
for (auto& it : elements) {
output.push_back(std::move(it) | decorator);
}
return output;
} | O1 | cpp | ftxui::operator|(std::vector<std::shared_ptr<ftxui::Node>, std::allocator<std::shared_ptr<ftxui::Node>>>, std::function<std::shared_ptr<ftxui::Node> (std::shared_ptr<ftxui::Node>)>):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x4, %rsi
movq %rdi, (%rsp)
callq 0x2645e
movq (%r15), %rbp
movq 0x8(%r15), %r13
cmpq %r13, %rbp
je 0x25e21
xorl %ebx, %ebx
leaq 0x28(%rsp), %r15
leaq 0x18(%rsp), %r12
movq (%rbp), %rax
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq 0x8(%rbp), %rax
movq %rbx, 0x8(%rbp)
movq %rax, 0x10(%rsp)
movq %rbx, (%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x26520
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x25e98
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x1535e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x25dee
callq 0x14c7c
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x25e05
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25e14
callq 0x14c7c
addq $0x10, %rbp
cmpq %r13, %rbp
jne 0x25d99
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x25e7f
jmp 0x25e90
movq %rax, %r14
jmp 0x25e70
movq %rax, %r14
jmp 0x25e57
movq %rax, %r14
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x25e57
callq 0x14c7c
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x25e70
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x25e7f
callq 0x14c7c
movq (%rsp), %rdi
callq 0x151c0
movq %r14, %rdi
callq 0xb780
movq %rax, %rdi
callq 0x106a9
| _ZN5ftxuiorESt6vectorISt10shared_ptrINS_4NodeEESaIS3_EESt8functionIFS3_S3_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 48h
mov r14, rdx
mov r15, rsi
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
mov rsi, [rsi+8]
sub rsi, [r15]
sar rsi, 4
mov [rsp+78h+var_78], rdi
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE7reserveEm; std::vector<std::shared_ptr<ftxui::Node>>::reserve(ulong)
mov rbp, [r15]
mov r13, [r15+8]
cmp rbp, r13
jz loc_25E21
xor ebx, ebx
lea r15, [rsp+78h+var_50]
lea r12, [rsp+78h+var_60]
loc_25D99:
mov rax, [rbp+0]
mov [rsp+78h+var_70], rax
mov [rsp+78h+var_68], rbx
mov rax, [rbp+8]
mov [rbp+8], rbx
mov [rsp+78h+var_68], rax
mov [rbp+0], rbx
mov rdi, r15
mov rsi, r14
call _ZNSt8functionIFSt10shared_ptrIN5ftxui4NodeEES3_EEC2ERKS5_; std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>::function(std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)> const&)
mov rdi, r12
lea rsi, [rsp+78h+var_70]
mov rdx, r15
call _ZN5ftxuiorESt10shared_ptrINS_4NodeEESt8functionIFS2_S2_EE; ftxui::operator|(std::shared_ptr<ftxui::Node>,std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>)
mov rdi, [rsp+78h+var_78]
mov rsi, r12
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EE12emplace_backIJS3_EEERS3_DpOT_; std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(std::shared_ptr<ftxui::Node> &&)
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz short loc_25DEE
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25DEE:
mov rax, [rsp+78h+var_40]
test rax, rax
jz short loc_25E05
mov rdi, r15
mov rsi, r15
mov edx, 3
call rax
loc_25E05:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_25E14
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25E14:
add rbp, 10h
cmp rbp, r13
jnz loc_25D99
loc_25E21:
mov rax, [rsp+78h+var_78]
add rsp, 48h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
mov r14, rax
jmp short loc_25E7F
jmp short loc_25E90
mov r14, rax
jmp short loc_25E70
mov r14, rax
jmp short loc_25E57
mov r14, rax
mov rdi, [rsp+78h+var_58]
test rdi, rdi
jz short loc_25E57
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25E57:
mov rax, [rsp+78h+var_40]
test rax, rax
jz short loc_25E70
lea rdi, [rsp+78h+var_50]
mov rsi, rdi
mov edx, 3
call rax
loc_25E70:
mov rdi, [rsp+78h+var_68]
test rdi, rdi
jz short loc_25E7F
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_25E7F:
mov rdi, [rsp+78h+var_78]
call _ZNSt6vectorISt10shared_ptrIN5ftxui4NodeEESaIS3_EED2Ev; std::vector<std::shared_ptr<ftxui::Node>>::~vector()
mov rdi, r14
call __Unwind_Resume
loc_25E90:
mov rdi, rax
call __clang_call_terminate
| long long ftxui::operator|(long long a1, long long **a2, long long a3)
{
long long *v4; // rbp
long long *v5; // r13
volatile signed __int32 *v6; // rax
long long v8; // [rsp+8h] [rbp-70h] BYREF
volatile signed __int32 *v9; // [rsp+10h] [rbp-68h]
long long v10; // [rsp+18h] [rbp-60h] BYREF
volatile signed __int32 *v11; // [rsp+20h] [rbp-58h]
_BYTE v12[16]; // [rsp+28h] [rbp-50h] BYREF
void ( *v13)(_BYTE *, _BYTE *, long long); // [rsp+38h] [rbp-40h]
*(_OWORD *)a1 = 0LL;
*(_QWORD *)(a1 + 16) = 0LL;
std::vector<std::shared_ptr<ftxui::Node>>::reserve(a1, ((char *)a2[1] - (char *)*a2) >> 4);
v4 = *a2;
v5 = a2[1];
if ( *a2 != v5 )
{
do
{
v8 = *v4;
v9 = 0LL;
v6 = (volatile signed __int32 *)v4[1];
v4[1] = 0LL;
v9 = v6;
*v4 = 0LL;
std::function<std::shared_ptr<ftxui::Node> ()(std::shared_ptr<ftxui::Node>)>::function(v12, a3);
ftxui::operator|(&v10, &v8);
std::vector<std::shared_ptr<ftxui::Node>>::emplace_back<std::shared_ptr<ftxui::Node>>(a1, &v10);
if ( v11 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v11);
if ( v13 )
v13(v12, v12, 3LL);
if ( v9 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v9);
v4 += 2;
}
while ( v4 != v5 );
}
return a1;
}
| operator|:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x48
MOV R14,RDX
MOV R15,RSI
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
MOV RSI,qword ptr [RSI + 0x8]
SUB RSI,qword ptr [R15]
SAR RSI,0x4
LAB_00125d74:
MOV qword ptr [RSP],RDI
CALL 0x0012645e
MOV RBP,qword ptr [R15]
MOV R13,qword ptr [R15 + 0x8]
CMP RBP,R13
JZ 0x00125e21
XOR EBX,EBX
LEA R15,[RSP + 0x28]
LEA R12,[RSP + 0x18]
LAB_00125d99:
MOV RAX,qword ptr [RBP]
MOV qword ptr [RSP + 0x8],RAX
MOV qword ptr [RSP + 0x10],RBX
MOV RAX,qword ptr [RBP + 0x8]
MOV qword ptr [RBP + 0x8],RBX
MOV qword ptr [RSP + 0x10],RAX
MOV qword ptr [RBP],RBX
LAB_00125db8:
MOV RDI,R15
MOV RSI,R14
CALL 0x00126520
LAB_00125dc3:
MOV RDI,R12
LEA RSI,[RSP + 0x8]
MOV RDX,R15
CALL 0x00125e98
LAB_00125dd3:
MOV RDI,qword ptr [RSP]
MOV RSI,R12
CALL 0x0011535e
MOV RDI,qword ptr [RSP + 0x20]
TEST RDI,RDI
JZ 0x00125dee
CALL 0x00114c7c
LAB_00125dee:
MOV RAX,qword ptr [RSP + 0x38]
TEST RAX,RAX
JZ 0x00125e05
LAB_00125df8:
MOV RDI,R15
MOV RSI,R15
MOV EDX,0x3
CALL RAX
LAB_00125e05:
MOV RDI,qword ptr [RSP + 0x10]
TEST RDI,RDI
JZ 0x00125e14
CALL 0x00114c7c
LAB_00125e14:
ADD RBP,0x10
CMP RBP,R13
JNZ 0x00125d99
LAB_00125e21:
MOV RAX,qword ptr [RSP]
ADD RSP,0x48
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* ftxui::TEMPNAMEPLACEHOLDERVALUE(std::vector<std::shared_ptr<ftxui::Node>,
std::allocator<std::shared_ptr<ftxui::Node> > >, std::function<std::shared_ptr<ftxui::Node>
(std::shared_ptr<ftxui::Node>)>) */
ftxui * __thiscall ftxui::operator|(ftxui *this,long *param_2,function *param_3)
{
int8 *puVar1;
int8 *puVar2;
int8 local_70;
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_68;
shared_ptr local_60 [8];
_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *local_58;
function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)> local_50 [16];
code *local_40;
*(int8 *)this = 0;
*(int8 *)(this + 8) = 0;
*(int8 *)(this + 0x10) = 0;
/* try { // try from 00125d74 to 00125d7c has its CatchHandler @ 00125e34 */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::reserve
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>> *)
this,param_2[1] - *param_2 >> 4);
puVar2 = (int8 *)*param_2;
puVar1 = (int8 *)param_2[1];
if (puVar2 != puVar1) {
do {
local_70 = *puVar2;
local_68 = (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)puVar2[1];
puVar2[1] = 0;
*puVar2 = 0;
/* try { // try from 00125db8 to 00125dc2 has its CatchHandler @ 00125e3b */
std::function<std::shared_ptr<ftxui::Node>(std::shared_ptr<ftxui::Node>)>::function
(local_50,param_3);
/* try { // try from 00125dc3 to 00125dd2 has its CatchHandler @ 00125e40 */
operator|((ftxui *)local_60,&local_70,local_50);
/* try { // try from 00125dd3 to 00125dde has its CatchHandler @ 00125e45 */
std::vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>::
emplace_back<std::shared_ptr<ftxui::Node>>
((vector<std::shared_ptr<ftxui::Node>,std::allocator<std::shared_ptr<ftxui::Node>>>
*)this,local_60);
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_40 != (code *)0x0) {
/* try { // try from 00125df8 to 00125e04 has its CatchHandler @ 00125e39 */
(*local_40)(local_50,local_50,3);
}
if (local_68 != (_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(local_68);
}
puVar2 = puVar2 + 2;
} while (puVar2 != puVar1);
}
return this;
}
| |
43,429 | translog_fixed_length_header | eloqsql/storage/maria/ma_loghandler.c | static int translog_fixed_length_header(uchar *page,
translog_size_t page_offset,
TRANSLOG_HEADER_BUFFER *buff)
{
struct st_log_record_type_descriptor *desc=
log_record_type_descriptor + buff->type;
uchar *src= page + page_offset + 3;
uchar *dst= buff->header;
uchar *start= src;
int lsns= desc->compressed_LSN;
uint length= desc->fixed_length;
DBUG_ENTER("translog_fixed_length_header");
buff->record_length= length;
if (desc->rclass == LOGRECTYPE_PSEUDOFIXEDLENGTH)
{
DBUG_ASSERT(lsns > 0);
src= translog_relative_LSN_decode(buff->lsn, src, dst, lsns);
lsns*= LSN_STORE_SIZE;
dst+= lsns;
length-= lsns;
buff->compressed_LSN_economy= (lsns - (int) (src - start));
}
else
buff->compressed_LSN_economy= 0;
memcpy(dst, src, length);
buff->non_header_data_start_offset= (uint16) (page_offset +
((src + length) -
(page + page_offset)));
buff->non_header_data_len= 0;
DBUG_RETURN(buff->record_length);
} | O0 | c | translog_fixed_length_header:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x420(%rax), %eax
movl %eax, %ecx
leaq 0x4442fa(%rip), %rax # 0x477a70
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movswl 0x20(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x33832
jmp 0x337d2
jmp 0x337d4
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x3a470
movq %rax, -0x28(%rbp)
imull $0x7, -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rdx
subq %rdx, %rcx
subl %ecx, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x430(%rax)
jmp 0x3383f
movq -0x18(%rbp), %rax
movw $0x0, 0x430(%rax)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x40(%rbp), %eax
movl %eax, %edx
callq 0x2a090
movl -0xc(%rbp), %eax
movq -0x28(%rbp), %rcx
movl -0x40(%rbp), %edx
addq %rdx, %rcx
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %esi
addq %rsi, %rdx
subq %rdx, %rcx
addq %rcx, %rax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x432(%rax)
movq -0x18(%rbp), %rax
movw $0x0, 0x434(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| translog_fixed_length_header:
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
mov [rbp+var_18], rdx
mov rax, [rbp+var_18]
mov eax, [rax+420h]
mov ecx, eax
lea rax, log_record_type_descriptor
imul rcx, 48h ; 'H'
add rax, rcx
mov [rbp+var_20], rax
mov rax, [rbp+var_8]
mov ecx, [rbp+var_C]
add rax, rcx
add rax, 3
mov [rbp+var_28], rax
mov rax, [rbp+var_18]
add rax, 18h
mov [rbp+var_30], rax
mov rax, [rbp+var_28]
mov [rbp+var_38], rax
mov rax, [rbp+var_20]
movsx eax, word ptr [rax+20h]
mov [rbp+var_3C], eax
mov rax, [rbp+var_20]
movzx eax, word ptr [rax+4]
mov [rbp+var_40], eax
mov ecx, [rbp+var_40]
mov rax, [rbp+var_18]
mov [rax+14h], ecx
mov rax, [rbp+var_20]
cmp dword ptr [rax], 2
jnz short loc_33832
jmp short $+2
loc_337D2:
jmp short $+2
loc_337D4:
mov rax, [rbp+var_18]
mov rdi, [rax]
mov rsi, [rbp+var_28]
mov rdx, [rbp+var_30]
mov ecx, [rbp+var_3C]
call translog_relative_LSN_decode
mov [rbp+var_28], rax
imul eax, [rbp+var_3C], 7
mov [rbp+var_3C], eax
mov ecx, [rbp+var_3C]
mov rax, [rbp+var_30]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_30], rax
mov ecx, [rbp+var_3C]
mov eax, [rbp+var_40]
sub eax, ecx
mov [rbp+var_40], eax
mov eax, [rbp+var_3C]
mov rcx, [rbp+var_28]
mov rdx, [rbp+var_38]
sub rcx, rdx
sub eax, ecx
mov cx, ax
mov rax, [rbp+var_18]
mov [rax+430h], cx
jmp short loc_3383F
loc_33832:
mov rax, [rbp+var_18]
mov word ptr [rax+430h], 0
loc_3383F:
mov rdi, [rbp+var_30]
mov rsi, [rbp+var_28]
mov eax, [rbp+var_40]
mov edx, eax
call _memcpy
mov eax, [rbp+var_C]
mov rcx, [rbp+var_28]
mov edx, [rbp+var_40]
add rcx, rdx
mov rdx, [rbp+var_8]
mov esi, [rbp+var_C]
add rdx, rsi
sub rcx, rdx
add rax, rcx
mov cx, ax
mov rax, [rbp+var_18]
mov [rax+432h], cx
mov rax, [rbp+var_18]
mov word ptr [rax+434h], 0
mov rax, [rbp+var_18]
mov eax, [rax+14h]
mov [rbp+var_44], eax
mov eax, [rbp+var_44]
add rsp, 50h
pop rbp
retn
| long long translog_fixed_length_header(long long a1, unsigned int a2, long long a3)
{
unsigned int v4; // [rsp+10h] [rbp-40h]
unsigned int v5; // [rsp+14h] [rbp-3Ch]
int v6; // [rsp+14h] [rbp-3Ch]
long long v7; // [rsp+20h] [rbp-30h]
long long v8; // [rsp+28h] [rbp-28h]
_DWORD *v9; // [rsp+30h] [rbp-20h]
v9 = &log_record_type_descriptor[18 * *(unsigned int *)(a3 + 1056)];
v8 = a2 + a1 + 3;
v7 = a3 + 24;
v5 = *((__int16 *)v9 + 16);
v4 = *((unsigned __int16 *)v9 + 2);
*(_DWORD *)(a3 + 20) = v4;
if ( *v9 == 2 )
{
v8 = translog_relative_LSN_decode(*(_QWORD *)a3, v8, v7, v5);
v6 = 7 * v5;
v7 += v6;
v4 -= v6;
*(_WORD *)(a3 + 1072) = v6 - (v8 - (a2 + a1 + 3));
}
else
{
*(_WORD *)(a3 + 1072) = 0;
}
memcpy(v7, v8, v4);
*(_WORD *)(a3 + 1074) = v4 + v8 - a1;
*(_WORD *)(a3 + 1076) = 0;
return *(unsigned int *)(a3 + 20);
}
| translog_fixed_length_header:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
MOV qword ptr [RBP + -0x18],RDX
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x420]
MOV ECX,EAX
LEA RAX,[0x577a70]
IMUL RCX,RCX,0x48
ADD RAX,RCX
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x8]
MOV ECX,dword ptr [RBP + -0xc]
ADD RAX,RCX
ADD RAX,0x3
MOV qword ptr [RBP + -0x28],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,0x18
MOV qword ptr [RBP + -0x30],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOVSX EAX,word ptr [RAX + 0x20]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x20]
MOVZX EAX,word ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x40],EAX
MOV ECX,dword ptr [RBP + -0x40]
MOV RAX,qword ptr [RBP + -0x18]
MOV dword ptr [RAX + 0x14],ECX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX],0x2
JNZ 0x00133832
JMP 0x001337d2
LAB_001337d2:
JMP 0x001337d4
LAB_001337d4:
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,qword ptr [RAX]
MOV RSI,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RBP + -0x3c]
CALL 0x0013a470
MOV qword ptr [RBP + -0x28],RAX
IMUL EAX,dword ptr [RBP + -0x3c],0x7
MOV dword ptr [RBP + -0x3c],EAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV RAX,qword ptr [RBP + -0x30]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x30],RAX
MOV ECX,dword ptr [RBP + -0x3c]
MOV EAX,dword ptr [RBP + -0x40]
SUB EAX,ECX
MOV dword ptr [RBP + -0x40],EAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV RCX,qword ptr [RBP + -0x28]
MOV RDX,qword ptr [RBP + -0x38]
SUB RCX,RDX
SUB EAX,ECX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x430],CX
JMP 0x0013383f
LAB_00133832:
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x430],0x0
LAB_0013383f:
MOV RDI,qword ptr [RBP + -0x30]
MOV RSI,qword ptr [RBP + -0x28]
MOV EAX,dword ptr [RBP + -0x40]
MOV EDX,EAX
CALL 0x0012a090
MOV EAX,dword ptr [RBP + -0xc]
MOV RCX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RBP + -0x40]
ADD RCX,RDX
MOV RDX,qword ptr [RBP + -0x8]
MOV ESI,dword ptr [RBP + -0xc]
ADD RDX,RSI
SUB RCX,RDX
ADD RAX,RCX
MOV CX,AX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x432],CX
MOV RAX,qword ptr [RBP + -0x18]
MOV word ptr [RAX + 0x434],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV EAX,dword ptr [RAX + 0x14]
MOV dword ptr [RBP + -0x44],EAX
MOV EAX,dword ptr [RBP + -0x44]
ADD RSP,0x50
POP RBP
RET
|
int4 translog_fixed_length_header(long param_1,uint param_2,int8 *param_3)
{
int iVar1;
void *pvVar2;
long lVar3;
uint local_48;
int8 *local_38;
void *local_30;
lVar3 = (ulong)*(uint *)(param_3 + 0x84) * 0x48;
local_30 = (void *)(param_1 + (ulong)param_2 + 3);
local_38 = param_3 + 3;
iVar1 = (int)*(short *)(log_record_type_descriptor + lVar3 + 0x20);
local_48 = (uint)*(ushort *)(log_record_type_descriptor + lVar3 + 4);
*(uint *)((long)param_3 + 0x14) = local_48;
if (*(int *)(log_record_type_descriptor + lVar3) == 2) {
pvVar2 = (void *)translog_relative_LSN_decode(*param_3,local_30,local_38,iVar1);
local_38 = (int8 *)((long)local_38 + (long)(iVar1 * 7));
local_48 = local_48 + iVar1 * -7;
*(short *)(param_3 + 0x86) = (short)(iVar1 * 7) - ((short)pvVar2 - (short)local_30);
local_30 = pvVar2;
}
else {
*(int2 *)(param_3 + 0x86) = 0;
}
memcpy(local_38,local_30,(ulong)local_48);
*(short *)((long)param_3 + 0x432) = ((short)local_30 + (short)local_48) - (short)param_1;
*(int2 *)((long)param_3 + 0x434) = 0;
return *(int4 *)((long)param_3 + 0x14);
}
| |
43,430 | lf_hash_destroy | eloqsql/mysys/lf_hash.cc | void lf_hash_destroy(LF_HASH *hash)
{
LF_SLIST *el, **head= (LF_SLIST **)lf_dynarray_value(&hash->array, 0);
if (head)
{
el= *head;
while (el)
{
intptr next= el->link;
if (el->hashnr & 1)
lf_alloc_direct_free(&hash->alloc, el); /* normal node */
else
my_free(el); /* dummy node */
el= (LF_SLIST *)next;
}
}
lf_alloc_destroy(&hash->alloc);
lf_dynarray_destroy(&hash->array);
} | O0 | cpp | lf_hash_destroy:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xfd0d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xfd53f
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfd53d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfd52a
jmp 0xfd500
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0xfd51f
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0xf3be0
jmp 0xfd533
movq -0x10(%rbp), %rdi
callq 0xf3be0
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xfd4dd
jmp 0xfd53f
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xfc8f0
movq -0x8(%rbp), %rdi
callq 0xfcd10
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| lf_hash_destroy:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rdi, [rbp+var_8]
xor esi, esi
call lf_dynarray_value
mov [rbp+var_18], rax
cmp [rbp+var_18], 0
jz short loc_FD53F
mov rax, [rbp+var_18]
mov rax, [rax]
mov [rbp+var_10], rax
loc_FD4DD:
cmp [rbp+var_10], 0
jz short loc_FD53D
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_20], rax
mov rax, [rbp+var_10]
mov eax, [rax+18h]
and eax, 1
cmp eax, 0
jz short loc_FD52A
jmp short $+2
loc_FD500:
mov rax, [rbp+var_8]
cmp qword ptr [rax+88h], 0
jz short loc_FD51F
mov rax, [rbp+var_8]
mov rax, [rax+88h]
mov rdi, [rbp+var_10]
call rax
loc_FD51F:
mov rdi, [rbp+var_10]
call my_free
jmp short loc_FD533
loc_FD52A:
mov rdi, [rbp+var_10]
call my_free
loc_FD533:
mov rax, [rbp+var_20]
mov [rbp+var_10], rax
jmp short loc_FD4DD
loc_FD53D:
jmp short $+2
loc_FD53F:
mov rdi, [rbp+var_8]
add rdi, 28h ; '('
call lf_alloc_destroy
mov rdi, [rbp+var_8]
call lf_dynarray_destroy
add rsp, 20h
pop rbp
retn
| long long lf_hash_destroy(long long a1)
{
long long v2; // [rsp+0h] [rbp-20h]
long long *v3; // [rsp+8h] [rbp-18h]
long long i; // [rsp+10h] [rbp-10h]
v3 = (long long *)lf_dynarray_value(a1, 0);
if ( v3 )
{
for ( i = *v3; i; i = v2 )
{
v2 = *(_QWORD *)i;
if ( (*(_DWORD *)(i + 24) & 1) != 0 )
{
if ( *(_QWORD *)(a1 + 136) )
(*(void ( **)(long long))(a1 + 136))(i);
}
my_free(i);
}
}
lf_alloc_destroy(a1 + 40);
return lf_dynarray_destroy(a1);
}
| lf_hash_destroy:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RDI,qword ptr [RBP + -0x8]
XOR ESI,ESI
CALL 0x001fd0d0
MOV qword ptr [RBP + -0x18],RAX
CMP qword ptr [RBP + -0x18],0x0
JZ 0x001fd53f
MOV RAX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x10],RAX
LAB_001fd4dd:
CMP qword ptr [RBP + -0x10],0x0
JZ 0x001fd53d
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x18]
AND EAX,0x1
CMP EAX,0x0
JZ 0x001fd52a
JMP 0x001fd500
LAB_001fd500:
MOV RAX,qword ptr [RBP + -0x8]
CMP qword ptr [RAX + 0x88],0x0
JZ 0x001fd51f
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0x88]
MOV RDI,qword ptr [RBP + -0x10]
CALL RAX
LAB_001fd51f:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001f3be0
JMP 0x001fd533
LAB_001fd52a:
MOV RDI,qword ptr [RBP + -0x10]
CALL 0x001f3be0
LAB_001fd533:
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001fd4dd
LAB_001fd53d:
JMP 0x001fd53f
LAB_001fd53f:
MOV RDI,qword ptr [RBP + -0x8]
ADD RDI,0x28
CALL 0x001fc8f0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x001fcd10
ADD RSP,0x20
POP RBP
RET
|
void lf_hash_destroy(long param_1)
{
int8 *puVar1;
int8 *local_18;
puVar1 = (int8 *)lf_dynarray_value(param_1,0);
if (puVar1 != (int8 *)0x0) {
local_18 = (int8 *)*puVar1;
while (local_18 != (int8 *)0x0) {
puVar1 = (int8 *)*local_18;
if ((*(uint *)(local_18 + 3) & 1) == 0) {
my_free(local_18);
local_18 = puVar1;
}
else {
if (*(long *)(param_1 + 0x88) != 0) {
(**(code **)(param_1 + 0x88))(local_18);
}
my_free(local_18);
local_18 = puVar1;
}
}
}
lf_alloc_destroy(param_1 + 0x28);
lf_dynarray_destroy(param_1);
return;
}
| |
43,431 | testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int) | seiftnesse[P]memoryallocator/build_O3/_deps/googletest-src/googletest/src/gtest.cc | void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG_GET(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
std::string f = GTEST_FLAG_GET(filter);
const char* const filter = f.c_str();
// Prints the filter if it's not *. This reminds the user that some
// tests may be skipped.
if (!String::CStringEquals(filter, kUniversalFilter)) {
ColoredPrintf(GTestColor::kYellow, "Note: %s filter = %s\n", GTEST_NAME_,
filter);
}
if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
const int32_t shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
ColoredPrintf(GTestColor::kYellow, "Note: This is test shard %d of %s.\n",
static_cast<int>(shard_index) + 1,
internal::posix::GetEnv(kTestTotalShards));
}
if (GTEST_FLAG_GET(shuffle)) {
ColoredPrintf(GTestColor::kYellow,
"Note: Randomizing tests' orders with a seed of %d .\n",
unit_test.random_seed());
}
ColoredPrintf(GTestColor::kGreen, "[==========] ");
printf("Running %s from %s.\n",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
fflush(stdout);
} | O3 | cpp | testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
cmpl $0x1, 0x4138214(%rip) # 0x415dea8
je 0x25ca8
incl %edx
leaq 0x1d863(%rip), %rdi # 0x43502
movl %edx, %esi
xorl %eax, %eax
callq 0x9080
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x41381a0(%rip), %rsi # 0x415de58
movq 0x41381a1(%rip), %rdx # 0x415de60
addq %rsi, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xf4a8
movq (%r14), %rcx
testq %rcx, %rcx
je 0x25ce2
cmpb $0x2a, (%rcx)
jne 0x25ce2
cmpb $0x0, 0x1(%rcx)
je 0x25cfc
leaq 0x1d845(%rip), %rsi # 0x4352e
leaq 0x1d854(%rip), %rdx # 0x43544
movl $0x3, %edi
xorl %eax, %eax
callq 0x25eb1
leaq 0x1b42d(%rip), %rdi # 0x41130
leaq 0x1b446(%rip), %rsi # 0x41150
xorl %edx, %edx
callq 0x26015
testb %al, %al
je 0x25d4e
leaq 0x1b434(%rip), %rdi # 0x41150
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x2640d
movl %eax, %ebp
incl %ebp
leaq 0x1b3ff(%rip), %rdi # 0x41130
callq 0x9660
leaq 0x1d813(%rip), %rsi # 0x43550
movl $0x3, %edi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x25eb1
cmpb $0x1, 0x4138159(%rip) # 0x415deae
jne 0x25d74
movq 0x40(%rbx), %rax
movl 0x21c(%rax), %edx
leaq 0x1d80c(%rip), %rsi # 0x43574
movl $0x3, %edi
xorl %eax, %eax
callq 0x25eb1
leaq 0x1d82e(%rip), %rsi # 0x435a9
movl $0x2, %edi
xorl %eax, %eax
callq 0x25eb1
movq 0x40(%rbx), %rdi
callq 0x20770
leaq 0x1c7ce(%rip), %rdx # 0x42565
leaq 0x1cbda(%rip), %rcx # 0x42978
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x2663a
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x25dd2
movq (%rax), %rdx
movzbl 0x70(%rdx), %edx
addl %edx, %esi
addq $0x8, %rax
jmp 0x25dbe
movq 0x8(%rsp), %rbx
leaq 0x1e7c7(%rip), %rdx # 0x445a5
leaq 0x1e7cb(%rip), %rcx # 0x445b0
leaq 0x48(%rsp), %rdi
callq 0x2663a
leaq 0x58(%rsp), %r14
movq -0x10(%r14), %rdx
leaq 0x1d7b8(%rip), %rdi # 0x435b7
movq %rbx, %rsi
xorl %eax, %eax
callq 0x9080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x25e1f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x94c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25e3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
movq 0x3413f(%rip), %rax # 0x59f80
movq (%rax), %rdi
callq 0x95f0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x25e60
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x94c0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25e92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x94c0
jmp 0x25e92
jmp 0x25e8f
jmp 0x25e8f
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x25ea9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x94c0
movq %rbx, %rdi
callq 0x99a0
| _ZN7testing8internal27PrettyUnitTestResultPrinter20OnTestIterationStartERKNS_8UnitTestEi:
push rbp
push r15
push r14
push rbx
sub rsp, 68h
mov rbx, rsi
cmp cs:_ZN7testing18FLAGS_gtest_repeatE, 1; testing::FLAGS_gtest_repeat
jz short loc_25CA8
inc edx
lea rdi, aRepeatingAllTe; "\nRepeating all tests (iteration %d) . "...
mov esi, edx
xor eax, eax
call _printf
loc_25CA8:
lea r15, [rsp+88h+var_50]
mov [r15-10h], r15
mov rsi, cs:_ZN7testing18FLAGS_gtest_filterB5cxx11E; testing::FLAGS_gtest_filter
mov rdx, cs:qword_415DE60
add rdx, rsi
lea r14, [rsp+88h+var_60]
mov rdi, r14
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPcEEvT_S7_St20forward_iterator_tag; std::string::_M_construct<char *>(char *,char *,std::forward_iterator_tag)
mov rcx, [r14]
test rcx, rcx
jz short loc_25CE2
cmp byte ptr [rcx], 2Ah ; '*'
jnz short loc_25CE2
cmp byte ptr [rcx+1], 0
jz short loc_25CFC
loc_25CE2:
lea rsi, aNoteSFilterS; "Note: %s filter = %s\n"
lea rdx, aGoogleTest; "Google Test"
mov edi, 3
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_25CFC:
lea rdi, _ZN7testingL16kTestTotalShardsE; "GTEST_TOTAL_SHARDS"
lea rsi, _ZN7testingL15kTestShardIndexE; "GTEST_SHARD_INDEX"
xor edx, edx; char *
call _ZN7testing8internal11ShouldShardEPKcS2_b; testing::internal::ShouldShard(char const*,char const*,bool)
test al, al
jz short loc_25D4E
lea rdi, _ZN7testingL15kTestShardIndexE; "GTEST_SHARD_INDEX"
mov esi, 0FFFFFFFFh; char *
call _ZN7testing8internal17Int32FromEnvOrDieEPKci; testing::internal::Int32FromEnvOrDie(char const*,int)
mov ebp, eax
inc ebp
lea rdi, _ZN7testingL16kTestTotalShardsE; "GTEST_TOTAL_SHARDS"
call _getenv
lea rsi, aNoteThisIsTest; "Note: This is test shard %d of %s.\n"
mov edi, 3
mov edx, ebp
mov rcx, rax
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_25D4E:
cmp cs:_ZN7testing19FLAGS_gtest_shuffleE, 1; testing::FLAGS_gtest_shuffle
jnz short loc_25D74
mov rax, [rbx+40h]
mov edx, [rax+21Ch]
lea rsi, aNoteRandomizin; "Note: Randomizing tests' orders with a "...
mov edi, 3
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
loc_25D74:
lea rsi, asc_435A9; "[==========] "
mov edi, 2
xor eax, eax
call _ZN7testing8internalL13ColoredPrintfENS0_12_GLOBAL__N_110GTestColorEPKcz; testing::internal::ColoredPrintf(testing::internal::`anonymous namespace'::GTestColor,char const*,...)
mov rdi, [rbx+40h]; this
call _ZNK7testing8internal12UnitTestImpl17test_to_run_countEv; testing::internal::UnitTestImpl::test_to_run_count(void)
lea rdx, aDeathtestPasse+36h; int
lea rcx, aAlsoRunDisable+12h; int
lea rdi, [rsp+88h+var_80]; int
mov esi, eax; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
mov rcx, [rbx+40h]
mov rax, [rcx+0B8h]
mov rcx, [rcx+0C0h]
xor esi, esi; int
loc_25DBE:
cmp rax, rcx
jz short loc_25DD2
mov rdx, [rax]
movzx edx, byte ptr [rdx+70h]
add esi, edx
add rax, 8
jmp short loc_25DBE
loc_25DD2:
mov rbx, qword ptr [rsp+88h+var_80]
lea rdx, aTestSuite; "test suite"
lea rcx, aTestSuites; "test suites"
lea rdi, [rsp+88h+var_40]; int
call _ZN7testingL19FormatCountableNounB5cxx11EiPKcS1_; testing::FormatCountableNoun(int,char const*,char const*)
lea r14, [rsp+88h+var_30]
mov rdx, [r14-10h]
lea rdi, aRunningSFromS; "Running %s from %s.\n"
mov rsi, rbx
xor eax, eax
call _printf
mov rdi, [r14-10h]; void *
cmp rdi, r14
jz short loc_25E1F
mov rsi, [rsp+88h+var_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25E1F:
lea rax, [rsp+88h+var_70]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_25E3A
mov rsi, [rsp+88h+var_70]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25E3A:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rdi, [rsp+88h+var_60]; void *
cmp rdi, r15
jz short loc_25E60
mov rsi, [rsp+88h+var_50]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25E60:
add rsp, 68h
pop rbx
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rax, [rsp+arg_10]
mov rdi, [rax-10h]; void *
cmp rdi, rax
jz short loc_25E92
mov rsi, [rsp+arg_10]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
jmp short loc_25E92
jmp short loc_25E8F
jmp short $+2
loc_25E8F:
mov rbx, rax
loc_25E92:
mov rdi, [rsp+arg_20]; void *
cmp rdi, r15
jz short loc_25EA9
mov rsi, [rsp+arg_30]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_25EA9:
mov rdi, rbx
call __Unwind_Resume
| void testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(
testing::internal::PrettyUnitTestResultPrinter *this,
const testing::UnitTest *a2,
int a3)
{
int v3; // r8d
int v4; // r9d
char v5; // cl
int v6; // edx
int v7; // ecx
int v8; // r8d
int v9; // r9d
int v10; // ebp
int v11; // eax
int v12; // r8d
int v13; // r9d
int v14; // eax
int v15; // r8d
int v16; // r9d
int v17; // r8d
int v18; // r9d
long long v19; // rcx
long long v20; // rax
long long v21; // rcx
int v22; // esi
const char *v23; // rbx
void *v24; // [rsp+0h] [rbp-88h]
void *v25; // [rsp+0h] [rbp-88h]
int v26[2]; // [rsp+8h] [rbp-80h] BYREF
long long v27; // [rsp+10h] [rbp-78h]
long long v28; // [rsp+18h] [rbp-70h] BYREF
int v29; // [rsp+20h] [rbp-68h]
void *v30; // [rsp+28h] [rbp-60h] BYREF
long long v31; // [rsp+30h] [rbp-58h]
_QWORD v32[2]; // [rsp+38h] [rbp-50h] BYREF
char *v33; // [rsp+48h] [rbp-40h] BYREF
long long v34; // [rsp+58h] [rbp-30h] BYREF
if ( testing::FLAGS_gtest_repeat != 1 )
printf("\nRepeating all tests (iteration %d) . . .\n\n", a3 + 1);
v30 = v32;
std::string::_M_construct<char *>(
(long long)&v30,
(_BYTE *)testing::FLAGS_gtest_filter[abi:cxx11],
testing::FLAGS_gtest_filter[abi:cxx11] + qword_415DE60);
v5 = (char)v30;
if ( !v30 || *(_BYTE *)v30 != 42 || *((_BYTE *)v30 + 1) )
testing::internal::ColoredPrintf(
3,
(unsigned int)"Note: %s filter = %s\n",
(unsigned int)"Google Test",
(_DWORD)v30,
v3,
v4);
if ( (unsigned __int8)testing::internal::ShouldShard(
(testing::internal *)"GTEST_TOTAL_SHARDS",
"GTEST_SHARD_INDEX",
0LL,
v5) )
{
v10 = testing::internal::Int32FromEnvOrDie((testing::internal *)"GTEST_SHARD_INDEX", (const char *)0xFFFFFFFFLL, v6)
+ 1;
v11 = getenv("GTEST_TOTAL_SHARDS");
testing::internal::ColoredPrintf(3, (unsigned int)"Note: This is test shard %d of %s.\n", v10, v11, v12, v13);
}
if ( testing::FLAGS_gtest_shuffle == 1 )
testing::internal::ColoredPrintf(
3,
(unsigned int)"Note: Randomizing tests' orders with a seed of %d .\n",
*(_DWORD *)(*((_QWORD *)a2 + 8) + 540LL),
v7,
v8,
v9);
testing::internal::ColoredPrintf(2, (unsigned int)"[==========] ", v6, v7, v8, v9);
v14 = testing::internal::UnitTestImpl::test_to_run_count(*((testing::internal::UnitTestImpl **)a2 + 8));
testing::FormatCountableNoun[abi:cxx11](
(int)v26,
v14,
(int)"test",
(int)"tests",
v15,
v16,
v24,
v26[0],
v27,
v28,
v29,
(int)v30,
v31);
v19 = *((_QWORD *)a2 + 8);
v20 = *(_QWORD *)(v19 + 184);
v21 = *(_QWORD *)(v19 + 192);
v22 = 0;
while ( v20 != v21 )
{
v22 += *(unsigned __int8 *)(*(_QWORD *)v20 + 112LL);
v20 += 8LL;
}
v23 = *(const char **)v26;
testing::FormatCountableNoun[abi:cxx11](
(int)&v33,
v22,
(int)"test suite",
(int)"test suites",
v17,
v18,
v25,
v26[0],
v27,
v28,
v29,
(int)v30,
v31);
printf("Running %s from %s.\n", v23, v33);
if ( v33 != (char *)&v34 )
operator delete(v33, v34 + 1);
if ( *(long long **)v26 != &v28 )
operator delete(*(void **)v26, v28 + 1);
fflush(stdout);
if ( v30 != v32 )
operator delete(v30, v32[0] + 1LL);
}
| OnTestIterationStart:
PUSH RBP
PUSH R15
PUSH R14
PUSH RBX
SUB RSP,0x68
MOV RBX,RSI
CMP dword ptr [0x0425dea8],0x1
JZ 0x00125ca8
INC EDX
LEA RDI,[0x143502]
MOV ESI,EDX
XOR EAX,EAX
CALL 0x00109080
LAB_00125ca8:
LEA R15,[RSP + 0x38]
MOV qword ptr [R15 + -0x10],R15
MOV RSI,qword ptr [0x0425de58]
MOV RDX,qword ptr [0x0425de60]
ADD RDX,RSI
LEA R14,[RSP + 0x28]
MOV RDI,R14
CALL 0x0010f4a8
MOV RCX,qword ptr [R14]
TEST RCX,RCX
JZ 0x00125ce2
CMP byte ptr [RCX],0x2a
JNZ 0x00125ce2
CMP byte ptr [RCX + 0x1],0x0
JZ 0x00125cfc
LAB_00125ce2:
LEA RSI,[0x14352e]
LEA RDX,[0x143544]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x00125eb1
LAB_00125cfc:
LEA RDI,[0x141130]
LEA RSI,[0x141150]
XOR EDX,EDX
CALL 0x00126015
TEST AL,AL
JZ 0x00125d4e
LAB_00125d15:
LEA RDI,[0x141150]
MOV ESI,0xffffffff
CALL 0x0012640d
MOV EBP,EAX
INC EBP
LEA RDI,[0x141130]
CALL 0x00109660
LEA RSI,[0x143550]
MOV EDI,0x3
MOV EDX,EBP
MOV RCX,RAX
XOR EAX,EAX
CALL 0x00125eb1
LAB_00125d4e:
CMP byte ptr [0x0425deae],0x1
JNZ 0x00125d74
MOV RAX,qword ptr [RBX + 0x40]
MOV EDX,dword ptr [RAX + 0x21c]
LAB_00125d61:
LEA RSI,[0x143574]
MOV EDI,0x3
XOR EAX,EAX
CALL 0x00125eb1
LAB_00125d74:
LEA RSI,[0x1435a9]
MOV EDI,0x2
XOR EAX,EAX
CALL 0x00125eb1
MOV RDI,qword ptr [RBX + 0x40]
CALL 0x00120770
LAB_00125d90:
LEA RDX,[0x142565]
LEA RCX,[0x142978]
LEA RDI,[RSP + 0x8]
MOV ESI,EAX
CALL 0x0012663a
MOV RCX,qword ptr [RBX + 0x40]
MOV RAX,qword ptr [RCX + 0xb8]
MOV RCX,qword ptr [RCX + 0xc0]
XOR ESI,ESI
LAB_00125dbe:
CMP RAX,RCX
JZ 0x00125dd2
MOV RDX,qword ptr [RAX]
MOVZX EDX,byte ptr [RDX + 0x70]
ADD ESI,EDX
ADD RAX,0x8
JMP 0x00125dbe
LAB_00125dd2:
MOV RBX,qword ptr [RSP + 0x8]
LAB_00125dd7:
LEA RDX,[0x1445a5]
LEA RCX,[0x1445b0]
LEA RDI,[RSP + 0x48]
CALL 0x0012663a
LAB_00125def:
LEA R14,[RSP + 0x58]
MOV RDX,qword ptr [R14 + -0x10]
LEA RDI,[0x1435b7]
MOV RSI,RBX
XOR EAX,EAX
CALL 0x00109080
MOV RDI,qword ptr [R14 + -0x10]
CMP RDI,R14
JZ 0x00125e1f
MOV RSI,qword ptr [RSP + 0x58]
INC RSI
CALL 0x001094c0
LAB_00125e1f:
LEA RAX,[RSP + 0x18]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x00125e3a
MOV RSI,qword ptr [RSP + 0x18]
INC RSI
CALL 0x001094c0
LAB_00125e3a:
MOV RAX,qword ptr [0x00159f80]
MOV RDI,qword ptr [RAX]
CALL 0x001095f0
MOV RDI,qword ptr [RSP + 0x28]
CMP RDI,R15
JZ 0x00125e60
MOV RSI,qword ptr [RSP + 0x38]
INC RSI
CALL 0x001094c0
LAB_00125e60:
ADD RSP,0x68
POP RBX
POP R14
POP R15
POP RBP
RET
|
/* testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&,
int) */
void __thiscall
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart
(PrettyUnitTestResultPrinter *this,UnitTest *param_1,int param_2)
{
long *plVar1;
char cVar2;
int iVar3;
uint uVar4;
char *pcVar5;
long *plVar6;
long *local_80 [2];
long local_70 [2];
long *local_60 [2];
long local_50 [2];
long *local_40 [2];
long local_30 [2];
if (FLAGS_gtest_repeat != 1) {
printf("\nRepeating all tests (iteration %d) . . .\n\n",(ulong)(param_2 + 1));
}
local_60[0] = local_50;
std::__cxx11::string::_M_construct<char*>
(local_60,FLAGS_gtest_filter_abi_cxx11_,DAT_0425de60 + FLAGS_gtest_filter_abi_cxx11_);
if (((local_60[0] == (long *)0x0) || ((char)*local_60[0] != '*')) ||
(*(char *)((long)local_60[0] + 1) != '\0')) {
/* try { // try from 00125ce2 to 00125d10 has its CatchHandler @ 00125e8f */
ColoredPrintf(3,"Note: %s filter = %s\n","Google Test");
}
cVar2 = ShouldShard("GTEST_TOTAL_SHARDS","GTEST_SHARD_INDEX",false);
if (cVar2 != '\0') {
/* try { // try from 00125d15 to 00125d4d has its CatchHandler @ 00125e8d */
iVar3 = Int32FromEnvOrDie("GTEST_SHARD_INDEX",-1);
pcVar5 = getenv("GTEST_TOTAL_SHARDS");
ColoredPrintf(3,"Note: This is test shard %d of %s.\n",iVar3 + 1,pcVar5);
}
if (FLAGS_gtest_shuffle == '\x01') {
/* try { // try from 00125d61 to 00125d86 has its CatchHandler @ 00125e8f */
ColoredPrintf(3,"Note: Randomizing tests\' orders with a seed of %d .\n",
*(int4 *)(*(long *)(param_1 + 0x40) + 0x21c));
}
ColoredPrintf(2,"[==========] ");
uVar4 = UnitTestImpl::test_to_run_count(*(UnitTestImpl **)(param_1 + 0x40));
/* try { // try from 00125d90 to 00125da9 has its CatchHandler @ 00125e8b */
FormatCountableNoun_abi_cxx11_((int)local_80,(char *)(ulong)uVar4,"test");
plVar1 = local_80[0];
pcVar5 = (char *)0x0;
for (plVar6 = *(long **)(*(long *)(param_1 + 0x40) + 0xb8);
plVar6 != *(long **)(*(long *)(param_1 + 0x40) + 0xc0); plVar6 = plVar6 + 1) {
pcVar5 = (char *)(ulong)((int)pcVar5 + (uint)*(byte *)(*plVar6 + 0x70));
}
/* try { // try from 00125dd7 to 00125dee has its CatchHandler @ 00125e6b */
FormatCountableNoun_abi_cxx11_((int)local_40,pcVar5,"test suite");
printf("Running %s from %s.\n",plVar1,local_40[0]);
if (local_40[0] != local_30) {
operator_delete(local_40[0],local_30[0] + 1);
}
if (local_80[0] != local_70) {
operator_delete(local_80[0],local_70[0] + 1);
}
fflush(*(FILE **)PTR_stdout_00159f80);
if (local_60[0] != local_50) {
operator_delete(local_60[0],local_50[0] + 1);
}
return;
}
| |
43,432 | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [10], 0>(char const (&) [10]) const | monkey531[P]llama/common/json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [10], 0>(char const (&) [10]) const:
cmpb $0x1, (%rdi)
jne 0xc576d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xc5770
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a230
testl %eax, %eax
je 0xc5760
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xc5746
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xc5773
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_C576D
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_C5770
mov r15, rsi
loc_C5746:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_C5760
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_C5746
loc_C5760:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_C5773
loc_C576D:
xor eax, eax
retn
loc_C5770:
mov rax, rbx
loc_C5773:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001c576d
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001c5770
MOV R15,RSI
LAB_001c5746:
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a230
TEST EAX,EAX
JZ 0x001c5760
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001c5746
LAB_001c5760:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001c5773
LAB_001c576d:
XOR EAX,EAX
RET
LAB_001c5770:
MOV RAX,RBX
LAB_001c5773:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA10_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
| |
43,433 | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const | monkey531[P]llama/common/json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O1 | cpp | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const:
cmpb $0x1, (%rdi)
jne 0x690c0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r12
movq (%r12), %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
je 0x690c6
movq %rsi, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x181a0
testl %eax, %eax
je 0x690c3
addq $0x30, %r15
movq 0x8(%r12), %rax
cmpq %rax, %r15
jne 0x690a1
jmp 0x690c6
xorl %eax, %eax
retq
movq %r15, %rax
movq 0x8(%rbx), %rcx
cmpq 0x8(%rcx), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_690C0
push r15
push r14
push r12
push rbx
push rax
mov rbx, rdi
mov r12, [rdi+8]
mov r15, [r12]
mov rax, [r12+8]
cmp r15, rax
jz short loc_690C6
mov r14, rsi
loc_690A1:
mov rdi, r15
mov rsi, r14
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_690C3
add r15, 30h ; '0'
mov rax, [r12+8]
cmp r15, rax
jnz short loc_690A1
jmp short loc_690C6
loc_690C0:
xor eax, eax
retn
loc_690C3:
mov rax, r15
loc_690C6:
mov rcx, [rbx+8]
cmp rax, [rcx+8]
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // r15
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
v4 = v2[1];
if ( *v2 != v4 )
{
while ( (unsigned int)std::string::compare(v3, a2) )
{
v3 += 48LL;
v4 = v2[1];
if ( v3 == v4 )
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
v4 = v3;
}
return v4 != *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001690c0
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV R15,qword ptr [R12]
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JZ 0x001690c6
MOV R14,RSI
LAB_001690a1:
MOV RDI,R15
MOV RSI,R14
CALL 0x001181a0
TEST EAX,EAX
JZ 0x001690c3
ADD R15,0x30
MOV RAX,qword ptr [R12 + 0x8]
CMP R15,RAX
JNZ 0x001690a1
JMP 0x001690c6
LAB_001690c0:
XOR EAX,EAX
RET
LAB_001690c3:
MOV RAX,R15
LAB_001690c6:
MOV RCX,qword ptr [RBX + 0x8]
CMP RAX,qword ptr [RCX + 0x8]
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)plVar1[1];
pcVar4 = (char *)*plVar1;
if ((char *)*plVar1 != pcVar3) {
do {
pcVar3 = pcVar4;
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar4 = pcVar3 + 0x30;
pcVar3 = (char *)plVar1[1];
} while (pcVar4 != pcVar3);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != *(char **)(*(long *)(param_1 + 8) + 8));
}
| |
43,434 | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const | monkey531[P]llama/common/json.hpp | constexpr bool is_object() const noexcept
{
return m_data.m_type == value_t::object;
} | O3 | cpp | bool nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::contains<char const (&) [5], 0>(char const (&) [5]) const:
cmpb $0x1, (%rdi)
jne 0xa0919
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq (%r12), %rbx
cmpq 0x8(%r12), %rbx
je 0xa091c
movq %rsi, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x181a0
testl %eax, %eax
je 0xa090c
addq $0x30, %rbx
cmpq 0x8(%r12), %rbx
jne 0xa08f2
movq %rbx, %rax
movq 0x8(%r14), %rcx
movq 0x8(%rcx), %rbx
jmp 0xa091f
xorl %eax, %eax
retq
movq %rbx, %rax
cmpq %rbx, %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
cmp byte ptr [rdi], 1
jnz short loc_A0919
push r15
push r14
push r12
push rbx
push rax
mov r14, rdi
mov r12, [rdi+8]
mov rbx, [r12]
cmp rbx, [r12+8]
jz short loc_A091C
mov r15, rsi
loc_A08F2:
mov rdi, rbx
mov rsi, r15
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE7compareEPKc; std::string::compare(char const*)
test eax, eax
jz short loc_A090C
add rbx, 30h ; '0'
cmp rbx, [r12+8]
jnz short loc_A08F2
loc_A090C:
mov rax, rbx
mov rcx, [r14+8]
mov rbx, [rcx+8]
jmp short loc_A091F
loc_A0919:
xor eax, eax
retn
loc_A091C:
mov rax, rbx
loc_A091F:
cmp rax, rbx
setnz al
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| bool ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
long long a1,
long long a2)
{
long long *v2; // r12
long long v3; // rbx
long long v4; // rax
if ( *(_BYTE *)a1 != 1 )
return 0;
v2 = *(long long **)(a1 + 8);
v3 = *v2;
if ( *v2 == v2[1] )
{
v4 = *v2;
}
else
{
do
{
if ( !(unsigned int)std::string::compare(v3, a2) )
break;
v3 += 48LL;
}
while ( v3 != v2[1] );
v4 = v3;
v3 = *(_QWORD *)(*(_QWORD *)(a1 + 8) + 8LL);
}
return v4 != v3;
}
| _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_:
CMP byte ptr [RDI],0x1
JNZ 0x001a0919
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,RDI
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [R12]
CMP RBX,qword ptr [R12 + 0x8]
JZ 0x001a091c
MOV R15,RSI
LAB_001a08f2:
MOV RDI,RBX
MOV RSI,R15
CALL 0x001181a0
TEST EAX,EAX
JZ 0x001a090c
ADD RBX,0x30
CMP RBX,qword ptr [R12 + 0x8]
JNZ 0x001a08f2
LAB_001a090c:
MOV RAX,RBX
MOV RCX,qword ptr [R14 + 0x8]
MOV RBX,qword ptr [RCX + 0x8]
JMP 0x001a091f
LAB_001a0919:
XOR EAX,EAX
RET
LAB_001a091c:
MOV RAX,RBX
LAB_001a091f:
CMP RAX,RBX
SETNZ AL
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int8
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA17_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(char *param_1)
{
long *plVar1;
int iVar2;
char *pcVar3;
char *pcVar4;
if (*param_1 != '\x01') {
return 0;
}
plVar1 = *(long **)(param_1 + 8);
pcVar3 = (char *)*plVar1;
pcVar4 = pcVar3;
if (pcVar3 != (char *)plVar1[1]) {
do {
iVar2 = std::__cxx11::string::compare(pcVar3);
if (iVar2 == 0) break;
pcVar3 = pcVar3 + 0x30;
} while (pcVar3 != (char *)plVar1[1]);
pcVar4 = *(char **)(*(long *)(param_1 + 8) + 8);
}
return CONCAT71((int7)((ulong)pcVar3 >> 8),pcVar3 != pcVar4);
}
| |
43,435 | json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool) | monkey531[P]llama/common/json-schema-to-grammar.cpp | std::string json_schema_to_grammar(const json & schema, bool force_gbnf) {
#ifdef LLAMA_USE_LLGUIDANCE
if (!force_gbnf) {
return "%llguidance {}\nstart: %json " + schema.dump();
}
#else
(void)force_gbnf;
#endif // LLAMA_USE_LLGUIDANCE
return build_grammar([&](const common_grammar_builder & callbacks) {
auto copy = schema;
callbacks.resolve_refs(copy);
callbacks.add_schema("", copy);
});
} | O3 | cpp | json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, bool):
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rsi, (%rax)
leaq 0x267(%rip), %rcx # 0xc8f7a
movq %rcx, 0x18(%rax)
leaq 0x356(%rip), %rcx # 0xc9074
movq %rcx, 0x10(%rax)
leaq 0xe(%rsp), %rdx
movw $0x0, (%rdx)
movq %rax, %rsi
callq 0xc8d84
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xc8d4d
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
jmp 0xc8d7c
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0xc8d74
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x1c020
movq %rax, %rdi
callq 0x2d431
| _Z22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEEb:
push rbx
sub rsp, 30h
mov rbx, rdi
lea rax, [rsp+38h+var_28]
mov qword ptr [rax+8], 0
mov [rax], rsi
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E9_M_invokeERKSt9_Any_dataS2_; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)::$_0>::_M_invoke(std::_Any_data const&,common_grammar_builder const&)
mov [rax+18h], rcx
lea rcx, _ZNSt17_Function_handlerIFvRK22common_grammar_builderEZ22json_schema_to_grammarRKN8nlohmann16json_abi_v3_11_310basic_jsonINS5_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS5_14adl_serializerES8_IhSaIhEEvEEbE3$_0E10_M_managerERSt9_Any_dataRKSN_St18_Manager_operation; std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&,bool)::$_0>::_M_manager(std::_Any_data &,std::_Any_data const&,std::_Manager_operation)
mov [rax+10h], rcx
lea rdx, [rsp+38h+var_2A]
mov word ptr [rdx], 0
mov rsi, rax
call _Z13build_grammarB5cxx11RKSt8functionIFvRK22common_grammar_builderEERK22common_grammar_options; build_grammar(std::function<void ()(common_grammar_builder const&)> const&,common_grammar_options const&)
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_C8D4D
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_C8D4D:
mov rax, rbx
add rsp, 30h
pop rbx
retn
jmp short loc_C8D7C
mov rbx, rax
mov rax, [rsp+38h+var_18]
test rax, rax
jz short loc_C8D74
lea rdi, [rsp+38h+var_28]
mov rsi, rdi
mov edx, 3
call rax
loc_C8D74:
mov rdi, rbx
call __Unwind_Resume
loc_C8D7C:
mov rdi, rax
call __clang_call_terminate
| long long json_schema_to_grammar(long long a1, long long a2)
{
__int16 v3; // [rsp+Eh] [rbp-2Ah] BYREF
_QWORD v4[2]; // [rsp+10h] [rbp-28h] BYREF
long long ( *v5)(); // [rsp+20h] [rbp-18h]
long long ( *v6)(); // [rsp+28h] [rbp-10h]
v4[1] = 0LL;
v4[0] = a2;
v6 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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&,bool)::$_0>::_M_invoke;
v5 = std::_Function_handler<void ()(common_grammar_builder const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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&,bool)::$_0>::_M_manager;
v3 = 0;
build_grammar[abi:cxx11](a1, v4, &v3);
if ( v5 )
((void ( *)(_QWORD *, _QWORD *, long long))v5)(v4, v4, 3LL);
return a1;
}
| json_schema_to_grammar:
PUSH RBX
SUB RSP,0x30
MOV RBX,RDI
LEA RAX,[RSP + 0x10]
MOV qword ptr [RAX + 0x8],0x0
MOV qword ptr [RAX],RSI
LEA RCX,[0x1c8f7a]
MOV qword ptr [RAX + 0x18],RCX
LEA RCX,[0x1c9074]
MOV qword ptr [RAX + 0x10],RCX
LEA RDX,[RSP + 0xe]
MOV word ptr [RDX],0x0
LAB_001c8d2c:
MOV RSI,RAX
CALL 0x001c8d84
MOV RAX,qword ptr [RSP + 0x20]
TEST RAX,RAX
JZ 0x001c8d4d
LAB_001c8d3e:
LEA RDI,[RSP + 0x10]
MOV RSI,RDI
MOV EDX,0x3
CALL RAX
LAB_001c8d4d:
MOV RAX,RBX
ADD RSP,0x30
POP RBX
RET
|
/* json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, bool) */
basic_json * json_schema_to_grammar(basic_json *param_1,bool param_2)
{
int7 in_register_00000031;
int8 local_28;
int8 local_20;
code *local_18;
code *local_10;
local_28 = CONCAT71(in_register_00000031,param_2);
local_20 = 0;
local_10 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,bool)::$_0>
::_M_invoke;
local_18 = std::
_Function_handler<void(common_grammar_builder_const&),json_schema_to_grammar(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const&,bool)::$_0>
::_M_manager;
/* try { // try from 001c8d2c to 001c8d33 has its CatchHandler @ 001c8d58 */
build_grammar_abi_cxx11_(param_1,(common_grammar_options *)&local_28);
if (local_18 != (code *)0x0) {
/* try { // try from 001c8d3e to 001c8d4c has its CatchHandler @ 001c8d56 */
(*local_18)(&local_28,&local_28,3);
}
return param_1;
}
| |
43,436 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O0 | c | js_iterator_proto_toArray:
subq $0xe8, %rsp
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc0(%rsp)
movl %ecx, 0xbc(%rsp)
movq %r8, 0xb0(%rsp)
movl $0x0, 0x60(%rsp)
movq $0x3, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
callq 0xc54b0
cmpl $0x0, %eax
jge 0xc4fe7
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movl $0x6b, %ecx
callq 0x29d80
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc5063
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
callq 0x2a520
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc50b3
jmp 0xc5236
movq $0x0, 0x78(%rsp)
movq 0xc0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
leaq 0x74(%rsp), %rax
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x6eeb0
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x23cc0
cmpl $0x0, %eax
je 0xc5143
jmp 0xc5236
cmpl $0x0, 0x74(%rsp)
je 0xc514c
jmp 0xc51a4
movq 0xc0(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0xa0(%rsp), %r8
movq 0xa8(%rsp), %r9
movl $0x4007, (%rsp) # imm = 0x4007
callq 0x373f0
cmpl $0x0, %eax
jge 0xc518f
jmp 0xc5236
jmp 0xc5191
movq 0x78(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x78(%rsp)
jmp 0xc50bc
movq 0xc0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rax
movl %eax, %edi
callq 0x33b60
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
movl $0x32, %ecx
callq 0x31f00
cmpl $0x0, %eax
jge 0xc51f7
jmp 0xc5236
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movq 0x80(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0xe0(%rsp)
jmp 0xc5287
movq 0xc0(%rsp), %rdi
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x23c90
movq 0xc0(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x23c90
movl $0x0, 0xd8(%rsp)
movq $0x6, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq 0xe0(%rsp), %rdx
addq $0xe8, %rsp
retq
nop
| js_iterator_proto_toArray:
sub rsp, 0E8h
mov [rsp+0E8h+var_20], rsi
mov [rsp+0E8h+var_18], rdx
mov [rsp+0E8h+var_28], rdi
mov [rsp+0E8h+var_2C], ecx
mov [rsp+0E8h+var_38], r8
mov dword ptr [rsp+0E8h+var_88], 0
mov [rsp+0E8h+var_80], 3
mov rax, [rsp+0E8h+var_88]
mov [rsp+0E8h+var_68], rax
mov rax, [rsp+0E8h+var_80]
mov [rsp+0E8h+var_60], rax
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
call check_iterator
cmp eax, 0
jge short loc_C4FE7
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
jmp loc_C5287
loc_C4FE7:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
mov ecx, 6Bh ; 'k'
call JS_GetProperty
mov [rsp+0E8h+var_98], rax
mov [rsp+0E8h+var_90], rdx
mov rax, [rsp+0E8h+var_98]
mov [rsp+0E8h+var_58], rax
mov rax, [rsp+0E8h+var_90]
mov [rsp+0E8h+var_50], rax
mov rdi, [rsp+0E8h+var_58]
mov rsi, [rsp+0E8h+var_50]
call JS_IsException_1
cmp eax, 0
jz short loc_C5063
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
jmp loc_C5287
loc_C5063:
mov rdi, [rsp+0E8h+var_28]
call JS_NewArray
mov [rsp+0E8h+var_A8], rax
mov [rsp+0E8h+var_A0], rdx
mov rax, [rsp+0E8h+var_A8]
mov [rsp+0E8h+var_68], rax
mov rax, [rsp+0E8h+var_A0]
mov [rsp+0E8h+var_60], rax
mov rdi, [rsp+0E8h+var_68]
mov rsi, [rsp+0E8h+var_60]
call JS_IsException_1
cmp eax, 0
jz short loc_C50B3
jmp loc_C5236
loc_C50B3:
mov [rsp+0E8h+var_70], 0
loc_C50BC:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_20]
mov rdx, [rsp+0E8h+var_18]
mov rcx, [rsp+0E8h+var_58]
mov r8, [rsp+0E8h+var_50]
xor r9d, r9d
xor eax, eax
lea rax, [rsp+0E8h+var_74]
mov [rsp+0E8h+var_E8], 0
mov [rsp+0E8h+var_E0], rax
call JS_IteratorNext
mov [rsp+0E8h+var_B8], rax
mov [rsp+0E8h+var_B0], rdx
mov rax, [rsp+0E8h+var_B8]
mov [rsp+0E8h+var_48], rax
mov rax, [rsp+0E8h+var_B0]
mov [rsp+0E8h+var_40], rax
mov rdi, [rsp+0E8h+var_48]
mov rsi, [rsp+0E8h+var_40]
call JS_IsException_1
cmp eax, 0
jz short loc_C5143
jmp loc_C5236
loc_C5143:
cmp [rsp+0E8h+var_74], 0
jz short loc_C514C
jmp short loc_C51A4
loc_C514C:
mov rdi, [rsp+0E8h+var_28]
mov rcx, [rsp+0E8h+var_70]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
mov r8, [rsp+0E8h+var_48]
mov r9, [rsp+0E8h+var_40]
mov dword ptr [rsp+0E8h+var_E8], 4007h
call JS_DefinePropertyValueInt64
cmp eax, 0
jge short loc_C518F
jmp loc_C5236
loc_C518F:
jmp short $+2
loc_C5191:
mov rax, [rsp+0E8h+var_70]
add rax, 1
mov [rsp+0E8h+var_70], rax
jmp loc_C50BC
loc_C51A4:
mov rax, [rsp+0E8h+var_28]
mov [rsp+0E8h+var_D0], rax
mov rax, [rsp+0E8h+var_70]
mov edi, eax
call js_uint32
mov rdi, [rsp+0E8h+var_D0]
mov [rsp+0E8h+var_C8], rax
mov [rsp+0E8h+var_C0], rdx
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
mov r8, [rsp+0E8h+var_C8]
mov r9, [rsp+0E8h+var_C0]
mov ecx, 32h ; '2'
call JS_SetProperty
cmp eax, 0
jge short loc_C51F7
jmp short loc_C5236
loc_C51F7:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov rax, [rsp+0E8h+var_68]
mov [rsp+0E8h+var_10], rax
mov rax, [rsp+0E8h+var_60]
mov [rsp+0E8h+var_8], rax
jmp short loc_C5287
loc_C5236:
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_68]
mov rdx, [rsp+0E8h+var_60]
call JS_FreeValue
mov rdi, [rsp+0E8h+var_28]
mov rsi, [rsp+0E8h+var_58]
mov rdx, [rsp+0E8h+var_50]
call JS_FreeValue
mov dword ptr [rsp+0E8h+var_10], 0
mov [rsp+0E8h+var_8], 6
loc_C5287:
mov rax, [rsp+0E8h+var_10]
mov rdx, [rsp+0E8h+var_8]
add rsp, 0E8h
retn
| long long js_iterator_proto_toArray(
long long a1,
long long a2,
long long a3,
int a4,
long long a5,
__m128 a6,
__m128 a7,
__m128 a8,
__m128 a9,
double a10,
double a11,
__m128 a12,
__m128 a13)
{
long long v13; // rdx
long long v14; // rdx
long long v15; // rdx
double v16; // xmm4_8
double v17; // xmm5_8
int v18; // edx
int v20; // [rsp+18h] [rbp-D0h]
int v21; // [rsp+20h] [rbp-C8h]
long long v22; // [rsp+60h] [rbp-88h]
int v23; // [rsp+74h] [rbp-74h] BYREF
long long i; // [rsp+78h] [rbp-70h]
long long v25; // [rsp+80h] [rbp-68h]
long long v26; // [rsp+88h] [rbp-60h]
long long Property; // [rsp+90h] [rbp-58h]
long long v28; // [rsp+98h] [rbp-50h]
_DWORD *v29; // [rsp+A0h] [rbp-48h]
long long v30; // [rsp+A8h] [rbp-40h]
long long v31; // [rsp+B0h] [rbp-38h]
int v32; // [rsp+BCh] [rbp-2Ch]
long long v33; // [rsp+C0h] [rbp-28h]
long long v34; // [rsp+C8h] [rbp-20h]
long long v35; // [rsp+D0h] [rbp-18h]
long long v36; // [rsp+D8h] [rbp-10h]
long long v37; // [rsp+E0h] [rbp-8h]
v34 = a2;
v35 = a3;
v33 = a1;
v32 = a4;
v31 = a5;
LODWORD(v22) = 0;
v25 = v22;
v26 = 3LL;
if ( (int)check_iterator(a1, a2, a3) >= 0 )
{
Property = JS_GetProperty(v33, v34, v35, 107);
v28 = v13;
if ( JS_IsException_1(Property, v13) )
{
LODWORD(v36) = 0;
v37 = 6LL;
}
else
{
v25 = JS_NewArray(v33);
v26 = v14;
if ( !JS_IsException_1(v25, v14) )
{
for ( i = 0LL; ; ++i )
{
v29 = (_DWORD *)JS_IteratorNext(v33, v34, v35, Property, v28, 0, 0LL, &v23);
v30 = v15;
if ( JS_IsException_1((long long)v29, v15) )
break;
if ( v23 )
{
v20 = v33;
v21 = js_uint32(i);
if ( (int)JS_SetProperty(v20, v25, v26, 50, v21, v18) < 0 )
break;
JS_FreeValue(v33, Property, v28);
v36 = v25;
v37 = v26;
return v36;
}
if ( (int)JS_DefinePropertyValueInt64(v33, v25, v26, i, v29, v30, a6, a7, a8, a9, v16, v17, a12, a13, 16391) < 0 )
break;
}
}
JS_FreeValue(v33, v25, v26);
JS_FreeValue(v33, Property, v28);
LODWORD(v36) = 0;
v37 = 6LL;
}
}
else
{
LODWORD(v36) = 0;
v37 = 6LL;
}
return v36;
}
| js_iterator_proto_toArray:
SUB RSP,0xe8
MOV qword ptr [RSP + 0xc8],RSI
MOV qword ptr [RSP + 0xd0],RDX
MOV qword ptr [RSP + 0xc0],RDI
MOV dword ptr [RSP + 0xbc],ECX
MOV qword ptr [RSP + 0xb0],R8
MOV dword ptr [RSP + 0x60],0x0
MOV qword ptr [RSP + 0x68],0x3
MOV RAX,qword ptr [RSP + 0x60]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x68]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
CALL 0x001c54b0
CMP EAX,0x0
JGE 0x001c4fe7
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
JMP 0x001c5287
LAB_001c4fe7:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
MOV ECX,0x6b
CALL 0x00129d80
MOV qword ptr [RSP + 0x50],RAX
MOV qword ptr [RSP + 0x58],RDX
MOV RAX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x90],RAX
MOV RAX,qword ptr [RSP + 0x58]
MOV qword ptr [RSP + 0x98],RAX
MOV RDI,qword ptr [RSP + 0x90]
MOV RSI,qword ptr [RSP + 0x98]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c5063
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
JMP 0x001c5287
LAB_001c5063:
MOV RDI,qword ptr [RSP + 0xc0]
CALL 0x0012a520
MOV qword ptr [RSP + 0x40],RAX
MOV qword ptr [RSP + 0x48],RDX
MOV RAX,qword ptr [RSP + 0x40]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x48]
MOV qword ptr [RSP + 0x88],RAX
MOV RDI,qword ptr [RSP + 0x80]
MOV RSI,qword ptr [RSP + 0x88]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c50b3
JMP 0x001c5236
LAB_001c50b3:
MOV qword ptr [RSP + 0x78],0x0
LAB_001c50bc:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0xc8]
MOV RDX,qword ptr [RSP + 0xd0]
MOV RCX,qword ptr [RSP + 0x90]
MOV R8,qword ptr [RSP + 0x98]
XOR R9D,R9D
XOR EAX,EAX
LEA RAX,[RSP + 0x74]
MOV qword ptr [RSP],0x0
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0016eeb0
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],RDX
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0xa0],RAX
MOV RAX,qword ptr [RSP + 0x38]
MOV qword ptr [RSP + 0xa8],RAX
MOV RDI,qword ptr [RSP + 0xa0]
MOV RSI,qword ptr [RSP + 0xa8]
CALL 0x00123cc0
CMP EAX,0x0
JZ 0x001c5143
JMP 0x001c5236
LAB_001c5143:
CMP dword ptr [RSP + 0x74],0x0
JZ 0x001c514c
JMP 0x001c51a4
LAB_001c514c:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RCX,qword ptr [RSP + 0x78]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0xa0]
MOV R9,qword ptr [RSP + 0xa8]
MOV dword ptr [RSP],0x4007
CALL 0x001373f0
CMP EAX,0x0
JGE 0x001c518f
JMP 0x001c5236
LAB_001c518f:
JMP 0x001c5191
LAB_001c5191:
MOV RAX,qword ptr [RSP + 0x78]
ADD RAX,0x1
MOV qword ptr [RSP + 0x78],RAX
JMP 0x001c50bc
LAB_001c51a4:
MOV RAX,qword ptr [RSP + 0xc0]
MOV qword ptr [RSP + 0x18],RAX
MOV RAX,qword ptr [RSP + 0x78]
MOV EDI,EAX
CALL 0x00133b60
MOV RDI,qword ptr [RSP + 0x18]
MOV qword ptr [RSP + 0x20],RAX
MOV qword ptr [RSP + 0x28],RDX
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
MOV R8,qword ptr [RSP + 0x20]
MOV R9,qword ptr [RSP + 0x28]
MOV ECX,0x32
CALL 0x00131f00
CMP EAX,0x0
JGE 0x001c51f7
JMP 0x001c5236
LAB_001c51f7:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV RAX,qword ptr [RSP + 0x80]
MOV qword ptr [RSP + 0xd8],RAX
MOV RAX,qword ptr [RSP + 0x88]
MOV qword ptr [RSP + 0xe0],RAX
JMP 0x001c5287
LAB_001c5236:
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x80]
MOV RDX,qword ptr [RSP + 0x88]
CALL 0x00123c90
MOV RDI,qword ptr [RSP + 0xc0]
MOV RSI,qword ptr [RSP + 0x90]
MOV RDX,qword ptr [RSP + 0x98]
CALL 0x00123c90
MOV dword ptr [RSP + 0xd8],0x0
MOV qword ptr [RSP + 0xe0],0x6
LAB_001c5287:
MOV RAX,qword ptr [RSP + 0xd8]
MOV RDX,qword ptr [RSP + 0xe0]
ADD RSP,0xe8
RET
|
int1 [16]
js_iterator_proto_toArray
(int8 param_1,int8 param_2,int8 param_3,int4 param_4,
int8 param_5)
{
int8 uVar1;
int iVar2;
int1 auVar3 [16];
int4 uVar4;
uint uStack_84;
int local_74;
ulong local_70;
int1 local_68 [16];
int1 local_58 [16];
int1 local_48 [16];
int8 local_38;
int4 local_2c;
int8 local_28;
int8 local_20;
int8 local_18;
int4 local_10;
int4 uStack_c;
int8 local_8;
local_68._0_8_ = (ulong)uStack_84 << 0x20;
local_68._8_8_ = 3;
local_38 = param_5;
local_2c = param_4;
local_28 = param_1;
local_20 = param_2;
local_18 = param_3;
iVar2 = check_iterator(param_1,param_2,param_3);
if (iVar2 < 0) {
local_10 = 0;
local_8 = 6;
}
else {
local_58 = JS_GetProperty(local_28,local_20,local_18,0x6b);
iVar2 = JS_IsException(local_58._0_8_,local_58._8_8_);
if (iVar2 == 0) {
local_68 = JS_NewArray(local_28);
iVar2 = JS_IsException(local_68._0_8_,local_68._8_8_);
if (iVar2 == 0) {
local_70 = 0;
while( true ) {
uVar4 = 0;
auVar3 = JS_IteratorNext(local_28,local_20,local_18,local_58._0_8_,local_58._8_8_,0,0,
&local_74);
local_48 = auVar3;
iVar2 = JS_IsException(auVar3._0_8_,auVar3._8_8_);
uVar1 = local_28;
if (iVar2 != 0) break;
if (local_74 != 0) {
auVar3 = js_uint32(local_70 & 0xffffffff);
iVar2 = JS_SetProperty(uVar1,local_68._0_8_,local_68._8_8_,0x32,auVar3._0_8_,
auVar3._8_8_);
if (-1 < iVar2) {
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = local_68._0_4_;
uStack_c = local_68._4_4_;
local_8 = local_68._8_8_;
goto LAB_001c5287;
}
break;
}
iVar2 = JS_DefinePropertyValueInt64
(local_28,local_68._0_8_,local_68._8_8_,local_70,local_48._0_8_,
local_48._8_8_,CONCAT44(uVar4,0x4007));
if (iVar2 < 0) break;
local_70 = local_70 + 1;
}
}
JS_FreeValue(local_28,local_68._0_8_,local_68._8_8_);
JS_FreeValue(local_28,local_58._0_8_,local_58._8_8_);
local_10 = 0;
local_8 = 6;
}
else {
local_10 = 0;
local_8 = 6;
}
}
LAB_001c5287:
auVar3._4_4_ = uStack_c;
auVar3._0_4_ = local_10;
auVar3._8_8_ = local_8;
return auVar3;
}
| |
43,437 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O1 | c | js_iterator_proto_toArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbp
movq %rdi, %r14
cmpl $-0x1, %ebp
jne 0x72e83
movq %rsi, %r13
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %rbp, %rdx
movl $0x6b, %ecx
movq %rsi, %r8
movq %rbp, %r9
callq 0x22fa3
movq %rdx, %r15
movl $0x6, %ebx
cmpl $0x6, %r15d
jne 0x72eb6
xorl %r15d, %r15d
jmp 0x72e9c
leaq 0x2c19b(%rip), %rsi # 0x9f025
xorl %r15d, %r15d
movq %r14, %rdi
xorl %eax, %eax
callq 0x22567
movl $0x6, %ebx
xorl %eax, %eax
orq %rax, %r15
movq %r15, %rax
movq %rbx, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x40(%rsp)
movq 0x38(%r14), %rsi
incl (%rsi)
movq %r14, %rdi
movl $0x2, %edx
callq 0xf516
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
cmpl $0x6, %edx
je 0x7304b
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x40(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x41afc
cmpl $0x6, %edx
je 0x7304b
xorl %r12d, %r12d
cmpl $0x0, 0x2c(%rsp)
jne 0x72fb6
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %r12, %r8
shrq $0x1f, %r8
movl %r12d, %eax
xorps %xmm0, %xmm0
cvtsi2sd %r12, %xmm0
movq %xmm0, %rcx
cmoveq %rax, %rcx
movl $0x7, %eax
cmovneq %rax, %r8
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl $0x4007, %r9d # imm = 0x4007
callq 0x26b2d
testl %eax, %eax
js 0x7304b
incq %r12
leaq 0x2c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq 0x40(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x41afc
cmpl $0x6, %edx
jne 0x72f18
jmp 0x7304b
xorl %eax, %eax
testl %r12d, %r12d
movl %r12d, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
movq %xmm0, %r8
cmovnsq %rcx, %r8
movl $0x7, %r9d
cmovnsq %rax, %r9
movq 0x30(%rsp), %rsi
movq %rsi, 0x48(%rsp)
movq 0x38(%rsp), %rdx
movq %rdx, 0x50(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, (%rsp)
movq $0x0, 0x18(%rsp)
movl $0x4000, 0x10(%rsp) # imm = 0x4000
movq %r14, %rdi
movl $0x32, %ecx
callq 0x24388
testl %eax, %eax
js 0x7304b
movq 0x18(%r14), %rdi
movq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
movabsq $-0x100000000, %rcx # imm = 0xFFFFFFFF00000000
movq 0x30(%rsp), %rdx
movq %rdx, %rax
andq %rcx, %rax
movl %edx, %r15d
movq 0x38(%rsp), %rbx
jmp 0x72e9e
movq 0x18(%r14), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x1d8c6
movq 0x18(%r14), %rdi
movq 0x40(%rsp), %rsi
movq %r15, %rdx
callq 0x1d8c6
jmp 0x72e7e
| js_iterator_proto_toArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbp, rdx
mov r14, rdi
cmp ebp, 0FFFFFFFFh
jnz short loc_72E83
mov r13, rsi
mov dword ptr [rsp+88h+var_88+8], 0
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rdx, rbp
mov ecx, 6Bh ; 'k'
mov r8, rsi
mov r9, rbp
call JS_GetPropertyInternal2
mov r15, rdx
mov ebx, 6
cmp r15d, 6
jnz short loc_72EB6
loc_72E7E:
xor r15d, r15d
jmp short loc_72E9C
loc_72E83:
lea rsi, aOperandPrototy+20h; "not an object"
xor r15d, r15d
mov rdi, r14
xor eax, eax
call JS_ThrowTypeError
mov ebx, 6
loc_72E9C:
xor eax, eax
loc_72E9E:
or r15, rax
mov rax, r15
mov rdx, rbx
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_72EB6:
mov [rsp+88h+var_48], rax
mov rsi, [r14+38h]
inc dword ptr [rsi]
mov rdi, r14
mov edx, 2
call JS_NewObjectFromShape
mov [rsp+88h+var_58], rax
mov [rsp+88h+var_50], rdx
cmp edx, 6
jz loc_7304B
lea rax, [rsp+88h+var_5C]
mov qword ptr [rsp+88h+var_88+8], rax
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rsi, r13
mov rdx, rbp
mov rcx, [rsp+88h+var_48]
mov r8, r15
xor r9d, r9d
call JS_IteratorNext
cmp edx, 6
jz loc_7304B
xor r12d, r12d
loc_72F18:
cmp [rsp+88h+var_5C], 0
jnz loc_72FB6
mov qword ptr [rsp+88h+var_40], rax
mov qword ptr [rsp+88h+var_40+8], rdx
mov r8, r12
shr r8, 1Fh
mov eax, r12d
xorps xmm0, xmm0
cvtsi2sd xmm0, r12
movq rcx, xmm0
cmovz rcx, rax
mov eax, 7
cmovnz r8, rax
movups xmm0, [rsp+88h+var_40]
movups [rsp+88h+var_88], xmm0
mov rdi, r14
mov rsi, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_50]
mov r9d, 4007h
call JS_DefinePropertyValueValue
test eax, eax
js loc_7304B
inc r12
lea rax, [rsp+88h+var_5C]
mov qword ptr [rsp+88h+var_88+8], rax
mov qword ptr [rsp+88h+var_88], 0
mov rdi, r14
mov rsi, r13
mov rdx, rbp
mov rcx, [rsp+88h+var_48]
mov r8, r15
xor r9d, r9d
call JS_IteratorNext
cmp edx, 6
jnz loc_72F18
jmp loc_7304B
loc_72FB6:
xor eax, eax
test r12d, r12d
mov ecx, r12d
xorps xmm0, xmm0
cvtsi2sd xmm0, rcx
movq r8, xmm0
cmovns r8, rcx
mov r9d, 7
cmovns r9, rax
mov rsi, [rsp+88h+var_58]
mov qword ptr [rsp+88h+var_40], rsi
mov rdx, [rsp+88h+var_50]
mov qword ptr [rsp+88h+var_40+8], rdx
movups xmm0, [rsp+88h+var_40]
movups [rsp+88h+var_88], xmm0
mov [rsp+88h+var_70], 0
mov [rsp+88h+var_78], 4000h
mov rdi, r14
mov ecx, 32h ; '2'
call JS_SetPropertyInternal2
test eax, eax
js short loc_7304B
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_48]
mov rdx, r15
call JS_FreeValueRT
mov rcx, 0FFFFFFFF00000000h
mov rdx, [rsp+88h+var_58]
mov rax, rdx
and rax, rcx
mov r15d, edx
mov rbx, [rsp+88h+var_50]
jmp loc_72E9E
loc_7304B:
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_58]
mov rdx, [rsp+88h+var_50]
call JS_FreeValueRT
mov rdi, [r14+18h]
mov rsi, [rsp+88h+var_48]
mov rdx, r15
call JS_FreeValueRT
jmp loc_72E7E
| unsigned long long js_iterator_proto_toArray(
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)
{
int v14; // r13d
_DWORD *PropertyInternal2; // rax
long long v16; // rdx
long long v17; // r15
long long v18; // r15
unsigned long long v19; // rax
_DWORD *v21; // rsi
__m128 v22; // rax
__m128 v23; // rax
double v24; // xmm4_8
double v25; // xmm5_8
unsigned long long v26; // r12
long long v27; // r8
double v28; // rcx
double v29; // r8
long long v30; // r9
char v31; // [rsp+0h] [rbp-88h]
int v32; // [rsp+2Ch] [rbp-5Ch] BYREF
__m128 v33; // [rsp+30h] [rbp-58h]
_DWORD *v34; // [rsp+40h] [rbp-48h]
__m128 v35; // [rsp+48h] [rbp-40h]
if ( (_DWORD)a3 == -1 )
{
v14 = a2;
PropertyInternal2 = (_DWORD *)JS_GetPropertyInternal2(a1, a2, a3, 0x6Bu, a2, a3, 0LL, 0);
v17 = v16;
if ( (_DWORD)v16 != 6 )
{
v34 = PropertyInternal2;
v21 = *(_DWORD **)(a1 + 56);
++*v21;
v22.m128_u64[0] = JS_NewObjectFromShape(a1, v21, 2u);
v33 = v22;
if ( v22.m128_i32[2] != 6 )
{
v23.m128_u64[0] = JS_IteratorNext(a1, v14, -1, (int)v34, v17, 0, 0LL, &v32);
if ( v23.m128_i32[2] != 6 )
{
v26 = 0LL;
while ( !v32 )
{
v35 = v23;
v27 = v26 >> 31;
v28 = (double)(int)v26;
if ( v26 >> 31 )
v27 = 7LL;
else
*(_QWORD *)&v28 = (unsigned int)v26;
if ( (int)JS_DefinePropertyValueValue(
a1,
v33.m128_u64[0],
v33.m128_i64[1],
*(_DWORD **)&v28,
v27,
16391,
*(double *)v35.m128_u64,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v35.m128_u64[0],
v35.m128_i64[1]) >= 0 )
{
++v26;
v23.m128_u64[0] = JS_IteratorNext(a1, v14, -1, (int)v34, v17, 0, 0LL, &v32);
if ( v23.m128_i32[2] != 6 )
continue;
}
goto LABEL_23;
}
v29 = (double)(int)v26;
if ( (v26 & 0x80000000) == 0LL )
*(_QWORD *)&v29 = (unsigned int)v26;
v30 = 7LL;
if ( (v26 & 0x80000000) == 0LL )
v30 = 0LL;
v35 = v33;
if ( (int)JS_SetPropertyInternal2(
a1,
v33.m128_i64[0],
v33.m128_i64[1],
0x32u,
*(_DWORD **)&v29,
v30,
v33,
a8,
a9,
a10,
v24,
v25,
a13,
a14,
v33.m128_i64[0],
v33.m128_i32[2],
0x4000u,
0LL) >= 0 )
{
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v34, v17);
v19 = v33.m128_u64[0] & 0xFFFFFFFF00000000LL;
v18 = v33.m128_u32[0];
return v19 | v18;
}
}
}
LABEL_23:
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v33.m128_u64[0], v33.m128_i64[1]);
JS_FreeValueRT(*(_QWORD *)(a1 + 24), v34, v17);
}
v18 = 0LL;
}
else
{
v18 = 0LL;
JS_ThrowTypeError(a1, (long long)"not an object", a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, v31);
}
v19 = 0LL;
return v19 | v18;
}
| |||
43,438 | js_iterator_proto_toArray | bluesky950520[P]quickjs/quickjs.c | static JSValue js_iterator_proto_toArray(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
JSValue item, method, result;
int64_t idx;
BOOL done;
result = JS_UNDEFINED;
if (check_iterator(ctx, this_val) < 0)
return JS_EXCEPTION;
method = JS_GetProperty(ctx, this_val, JS_ATOM_next);
if (JS_IsException(method))
return JS_EXCEPTION;
result = JS_NewArray(ctx);
if (JS_IsException(result))
goto exception;
for (idx = 0; /*empty*/; idx++) {
item = JS_IteratorNext(ctx, this_val, method, 0, NULL, &done);
if (JS_IsException(item))
goto exception;
if (done)
break;
if (JS_DefinePropertyValueInt64(ctx, result, idx, item,
JS_PROP_C_W_E | JS_PROP_THROW) < 0)
goto exception;
}
if (JS_SetProperty(ctx, result, JS_ATOM_length, js_uint32(idx)) < 0)
goto exception;
JS_FreeValue(ctx, method);
return result;
exception:
JS_FreeValue(ctx, result);
JS_FreeValue(ctx, method);
return JS_EXCEPTION;
} | O2 | c | js_iterator_proto_toArray:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rbp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x60e07
pushq $0x6
popq %r13
testl %eax, %eax
js 0x60bf2
pushq $0x6b
popq %rcx
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x1b043
movq %rax, 0x8(%rsp)
movq %rdx, %r15
cmpl $0x6, %r15d
jne 0x60bf8
xorl %eax, %eax
xorl %ecx, %ecx
jmp 0x60c34
movq %r14, %rdi
callq 0x1b2bb
movq %rax, (%rsp)
movq %rdx, %r13
cmpl $0x6, %r13d
jne 0x60c49
movq %r14, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x1801e
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1801e
xorl %eax, %eax
xorl %ecx, %ecx
pushq $0x6
popq %r13
orq %rcx, %rax
movq %r13, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq 0x8(%rsp), %rcx
movq %r15, %r8
xorl %r9d, %r9d
leaq 0x14(%rsp), %rax
pushq %rax
pushq $0x0
callq 0x398cc
addq $0x10, %rsp
movq %rdx, %r9
cmpl $0x6, %r9d
je 0x60c0d
cmpl $0x0, 0x14(%rsp)
jne 0x60caf
subq $0x8, %rsp
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
pushq $0x4007 # imm = 0x4007
callq 0x209b7
popq %rcx
popq %rdx
testl %eax, %eax
js 0x60c0d
incq %r12
jmp 0x60c4c
xorl %eax, %eax
movl %r12d, %ecx
cvtsi2sd %rcx, %xmm0
testl %r12d, %r12d
movq %xmm0, %r8
cmovnsq %rcx, %r8
pushq $0x7
popq %r9
cmovnsq %rax, %r9
pushq $0x32
popq %rcx
movq %r14, %rdi
movq (%rsp), %rsi
movq %r13, %rdx
callq 0x1e446
testl %eax, %eax
js 0x60c0d
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
callq 0x1801e
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq (%rsp), %rdx
movq %rdx, %rcx
andq %rax, %rcx
movl %edx, %eax
jmp 0x60c34
| js_iterator_proto_toArray:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdx
mov rbp, rsi
mov r14, rdi
mov rsi, rdx
call check_iterator
push 6
pop r13
test eax, eax
js short loc_60BF2
push 6Bh ; 'k'
pop rcx
mov rdi, r14
mov rsi, rbp
mov rdx, rbx
call JS_GetProperty
mov [rsp+48h+var_40], rax
mov r15, rdx
cmp r15d, 6
jnz short loc_60BF8
loc_60BF2:
xor eax, eax
xor ecx, ecx
jmp short loc_60C34
loc_60BF8:
mov rdi, r14
call JS_NewArray
mov [rsp+48h+var_48], rax
mov r13, rdx
cmp r13d, 6
jnz short loc_60C49
loc_60C0D:
mov rdi, r14
mov rsi, [rsp+48h+var_48]
mov rdx, r13
call JS_FreeValue
mov rdi, r14
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call JS_FreeValue
xor eax, eax
xor ecx, ecx
push 6
pop r13
loc_60C34:
or rax, rcx
mov rdx, r13
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_60C49:
xor r12d, r12d
loc_60C4C:
mov rdi, r14
mov rsi, rbp
mov rdx, rbx
mov rcx, [rsp+48h+var_40]
mov r8, r15
xor r9d, r9d
lea rax, [rsp+48h+var_34]
push rax
push 0
call JS_IteratorNext
add rsp, 10h
mov r9, rdx
cmp r9d, 6
jz short loc_60C0D
cmp [rsp+48h+var_34], 0
jnz short loc_60CAF
sub rsp, 8
mov rdi, r14
mov rsi, [rsp+50h+var_48]
mov rdx, r13
mov rcx, r12
mov r8, rax
push 4007h
call JS_DefinePropertyValueInt64
pop rcx
pop rdx
test eax, eax
js loc_60C0D
inc r12
jmp short loc_60C4C
loc_60CAF:
xor eax, eax
mov ecx, r12d
cvtsi2sd xmm0, rcx
test r12d, r12d
movq r8, xmm0
cmovns r8, rcx
push 7
pop r9
cmovns r9, rax
push 32h ; '2'
pop rcx
mov rdi, r14
mov rsi, [rsp+48h+var_48]
mov rdx, r13
call JS_SetProperty
test eax, eax
js loc_60C0D
mov rdi, r14
mov rsi, [rsp+48h+var_40]
mov rdx, r15
call JS_FreeValue
mov rax, 0FFFFFFFF00000000h
mov rdx, [rsp+48h+var_48]
mov rcx, rdx
and rcx, rax
mov eax, edx
jmp loc_60C34
| unsigned long long js_iterator_proto_toArray(
long long a1,
int a2,
long long a3,
double a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11)
{
int v11; // ebx
long long v12; // rdx
long long v13; // r15
long long v14; // rax
unsigned long long v15; // rcx
long long v16; // rdx
long long v17; // r13
long long i; // r12
_DWORD *v20; // rax
long long v21; // rdx
double v22; // xmm4_8
double v23; // xmm5_8
double v24; // r8
int v25; // r9d
long long v26; // [rsp+0h] [rbp-48h]
long long Property; // [rsp+8h] [rbp-40h]
_DWORD v28[13]; // [rsp+14h] [rbp-34h] BYREF
v11 = a3;
if ( (int)check_iterator(a1, a3) < 0 || (Property = JS_GetProperty(a1, a2, v11, 107), v13 = v12, (_DWORD)v12 == 6) )
{
v14 = 0LL;
v15 = 0LL;
}
else
{
v26 = JS_NewArray(a1);
v17 = v16;
if ( (_DWORD)v16 != 6 )
{
for ( i = 0LL; ; ++i )
{
v20 = (_DWORD *)JS_IteratorNext(a1, a2, v11, Property, v13, 0, 0LL, v28);
if ( (_DWORD)v21 == 6 )
break;
if ( v28[0] )
{
v24 = (double)(int)i;
if ( (int)i >= 0 )
LODWORD(v24) = i;
v25 = 7;
if ( (int)i >= 0 )
v25 = 0;
if ( (int)JS_SetProperty(a1, v26, v17, 50, SLODWORD(v24), v25) >= 0 )
{
JS_FreeValue(a1, Property, v13);
v15 = v26 & 0xFFFFFFFF00000000LL;
v14 = (unsigned int)v26;
return v15 | v14;
}
break;
}
if ( (int)JS_DefinePropertyValueInt64(a1, v26, v17, i, v20, v21, a4, a5, a6, a7, v22, v23, a10, a11, 16391) < 0 )
break;
}
}
JS_FreeValue(a1, v26, v17);
JS_FreeValue(a1, Property, v13);
v14 = 0LL;
v15 = 0LL;
}
return v15 | v14;
}
| js_iterator_proto_toArray:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDX
MOV RBP,RSI
MOV R14,RDI
MOV RSI,RDX
CALL 0x00160e07
PUSH 0x6
POP R13
TEST EAX,EAX
JS 0x00160bf2
PUSH 0x6b
POP RCX
MOV RDI,R14
MOV RSI,RBP
MOV RDX,RBX
CALL 0x0011b043
MOV qword ptr [RSP + 0x8],RAX
MOV R15,RDX
CMP R15D,0x6
JNZ 0x00160bf8
LAB_00160bf2:
XOR EAX,EAX
XOR ECX,ECX
JMP 0x00160c34
LAB_00160bf8:
MOV RDI,R14
CALL 0x0011b2bb
MOV qword ptr [RSP],RAX
MOV R13,RDX
CMP R13D,0x6
JNZ 0x00160c49
LAB_00160c0d:
MOV RDI,R14
MOV RSI,qword ptr [RSP]
MOV RDX,R13
CALL 0x0011801e
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0011801e
XOR EAX,EAX
XOR ECX,ECX
PUSH 0x6
POP R13
LAB_00160c34:
OR RAX,RCX
MOV RDX,R13
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00160c49:
XOR R12D,R12D
LAB_00160c4c:
MOV RDI,R14
MOV RSI,RBP
MOV RDX,RBX
MOV RCX,qword ptr [RSP + 0x8]
MOV R8,R15
XOR R9D,R9D
LEA RAX,[RSP + 0x14]
PUSH RAX
PUSH 0x0
CALL 0x001398cc
ADD RSP,0x10
MOV R9,RDX
CMP R9D,0x6
JZ 0x00160c0d
CMP dword ptr [RSP + 0x14],0x0
JNZ 0x00160caf
SUB RSP,0x8
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R13
MOV RCX,R12
MOV R8,RAX
PUSH 0x4007
CALL 0x001209b7
POP RCX
POP RDX
TEST EAX,EAX
JS 0x00160c0d
INC R12
JMP 0x00160c4c
LAB_00160caf:
XOR EAX,EAX
MOV ECX,R12D
CVTSI2SD XMM0,RCX
TEST R12D,R12D
MOVQ R8,XMM0
CMOVNS R8,RCX
PUSH 0x7
POP R9
CMOVNS R9,RAX
PUSH 0x32
POP RCX
MOV RDI,R14
MOV RSI,qword ptr [RSP]
MOV RDX,R13
CALL 0x0011e446
TEST EAX,EAX
JS 0x00160c0d
MOV RDI,R14
MOV RSI,qword ptr [RSP + 0x8]
MOV RDX,R15
CALL 0x0011801e
MOV RAX,-0x100000000
MOV RDX,qword ptr [RSP]
MOV RCX,RDX
AND RCX,RAX
MOV EAX,EDX
JMP 0x00160c34
|
int1 [16] js_iterator_proto_toArray(int8 param_1,int8 param_2,int8 param_3)
{
int iVar1;
int8 uVar2;
ulong uVar3;
double dVar5;
int8 uVar6;
ulong uVar7;
int8 uVar8;
bool bVar9;
int1 auVar10 [16];
int local_34;
int8 uVar4;
iVar1 = check_iterator(param_1,param_3);
uVar8 = 6;
if (-1 < iVar1) {
auVar10 = JS_GetProperty(param_1,param_2,param_3,0x6b);
uVar4 = auVar10._8_8_;
uVar2 = auVar10._0_8_;
if (auVar10._8_4_ != 6) {
auVar10 = JS_NewArray(param_1);
uVar8 = auVar10._8_8_;
uVar3 = auVar10._0_8_;
if (auVar10._8_4_ != 6) {
uVar7 = 0;
while( true ) {
auVar10 = JS_IteratorNext(param_1,param_2,param_3,uVar2,uVar4,0,0,&local_34);
if (auVar10._8_4_ == 6) break;
if (local_34 != 0) {
bVar9 = -1 < (int)uVar7;
dVar5 = (double)(uVar7 & 0xffffffff);
if (bVar9) {
dVar5 = (double)(uVar7 & 0xffffffff);
}
uVar6 = 7;
if (bVar9) {
uVar6 = 0;
}
iVar1 = JS_SetProperty(param_1,uVar3,uVar8,0x32,dVar5,uVar6);
if (-1 < iVar1) {
JS_FreeValue(param_1,uVar2,uVar4);
uVar7 = uVar3 & 0xffffffff00000000;
uVar3 = uVar3 & 0xffffffff;
goto LAB_00160c34;
}
break;
}
iVar1 = JS_DefinePropertyValueInt64
(param_1,uVar3,uVar8,uVar7,auVar10._0_8_,auVar10._8_8_,0x4007);
if (iVar1 < 0) break;
uVar7 = uVar7 + 1;
}
}
JS_FreeValue(param_1,uVar3,uVar8);
JS_FreeValue(param_1,uVar2,uVar4);
uVar3 = 0;
uVar7 = 0;
uVar8 = 6;
goto LAB_00160c34;
}
}
uVar3 = 0;
uVar7 = 0;
LAB_00160c34:
auVar10._0_8_ = uVar3 | uVar7;
auVar10._8_8_ = uVar8;
return auVar10;
}
| |
43,439 | my_realpath | eloqsql/mysys/my_symlink.c | int my_realpath(char *to, const char *filename, myf MyFlags)
{
#if defined(HAVE_REALPATH) && !defined(HAVE_BROKEN_REALPATH)
int result=0;
char buff[BUFF_LEN];
char *ptr;
DBUG_ENTER("my_realpath");
DBUG_PRINT("info",("executing realpath"));
if ((ptr=realpath(filename,buff)))
strmake(to, ptr, FN_REFLEN-1);
else
{
/*
Realpath didn't work; Use my_load_path() which is a poor substitute
original name but will at least be able to resolve paths that starts
with '.'.
*/
if (MyFlags)
DBUG_PRINT("error",("realpath failed with errno: %d", errno));
my_errno=errno;
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
my_load_path(to, filename, NullS);
if (my_errno == ENOENT)
result= 1;
else
result= -1;
}
DBUG_RETURN(result);
#elif defined(_WIN32)
int ret= GetFullPathName(filename,FN_REFLEN, to, NULL);
if (ret == 0 || ret > FN_REFLEN)
{
my_errno= (ret > FN_REFLEN) ? ENAMETOOLONG : GetLastError();
if (MyFlags & MY_WME)
my_error(EE_REALPATH, MYF(0), filename, my_errno);
/*
GetFullPathName didn't work : use my_load_path() which is a poor
substitute original name but will at least be able to resolve
paths that starts with '.'.
*/
my_load_path(to, filename, NullS);
return -1;
}
#else
my_load_path(to, filename, NullS);
#endif
return 0;
} | O0 | c | my_realpath:
pushq %rbp
movq %rsp, %rbp
subq $0x1060, %rsp # imm = 0x1060
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x1020(%rbp)
movq %rsi, -0x1028(%rbp)
movq %rdx, -0x1030(%rbp)
movl $0x0, -0x1034(%rbp)
jmp 0x2f999
movq -0x1028(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
callq 0x240f0
movq %rax, -0x1040(%rbp)
cmpq $0x0, %rax
je 0x2f9d6
movq -0x1020(%rbp), %rdi
movq -0x1040(%rbp), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x76b70
jmp 0x2fa76
cmpq $0x0, -0x1030(%rbp)
je 0x2f9e6
jmp 0x2f9e2
jmp 0x2f9e4
jmp 0x2f9e6
callq 0x24050
movl (%rax), %eax
movl %eax, -0x1044(%rbp)
callq 0x26970
movl -0x1044(%rbp), %ecx
movl %ecx, (%rax)
movq -0x1030(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x2fa3d
movq -0x1028(%rbp), %rax
movq %rax, -0x1050(%rbp)
callq 0x26970
movq -0x1050(%rbp), %rdx
movl (%rax), %ecx
movl $0x1a, %edi
xorl %eax, %eax
movl %eax, %esi
movb $0x0, %al
callq 0x2dd60
movq -0x1020(%rbp), %rdi
movq -0x1028(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x31290
callq 0x26970
cmpl $0x2, (%rax)
jne 0x2fa6a
movl $0x1, -0x1034(%rbp)
jmp 0x2fa74
movl $0xffffffff, -0x1034(%rbp) # imm = 0xFFFFFFFF
jmp 0x2fa76
jmp 0x2fa78
movl -0x1034(%rbp), %eax
movl %eax, -0x1014(%rbp)
movl -0x1014(%rbp), %eax
movl %eax, -0x1054(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x2fab1
movl -0x1054(%rbp), %eax
addq $0x1060, %rsp # imm = 0x1060
popq %rbp
retq
callq 0x242f0
nopw %cs:(%rax,%rax)
| my_realpath:
push rbp
mov rbp, rsp
sub rsp, 1060h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_1020], rdi
mov [rbp+var_1028], rsi
mov [rbp+var_1030], rdx
mov [rbp+var_1034], 0
jmp short $+2
loc_2F999:
mov rdi, [rbp+var_1028]
lea rsi, [rbp+var_1010]
call _realpath
mov [rbp+var_1040], rax
cmp rax, 0
jz short loc_2F9D6
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1040]
mov edx, 1FFh
call strmake
jmp loc_2FA76
loc_2F9D6:
cmp [rbp+var_1030], 0
jz short loc_2F9E6
jmp short $+2
loc_2F9E2:
jmp short $+2
loc_2F9E4:
jmp short $+2
loc_2F9E6:
call ___errno_location
mov eax, [rax]
mov [rbp+var_1044], eax
call _my_thread_var
mov ecx, [rbp+var_1044]
mov [rax], ecx
mov rax, [rbp+var_1030]
and rax, 10h
cmp rax, 0
jz short loc_2FA3D
mov rax, [rbp+var_1028]
mov [rbp+var_1050], rax
call _my_thread_var
mov rdx, [rbp+var_1050]
mov ecx, [rax]
mov edi, 1Ah
xor eax, eax
mov esi, eax
mov al, 0
call my_error
loc_2FA3D:
mov rdi, [rbp+var_1020]
mov rsi, [rbp+var_1028]
xor eax, eax
mov edx, eax
call my_load_path
call _my_thread_var
cmp dword ptr [rax], 2
jnz short loc_2FA6A
mov [rbp+var_1034], 1
jmp short loc_2FA74
loc_2FA6A:
mov [rbp+var_1034], 0FFFFFFFFh
loc_2FA74:
jmp short $+2
loc_2FA76:
jmp short $+2
loc_2FA78:
mov eax, [rbp+var_1034]
mov [rbp+var_1014], eax
mov eax, [rbp+var_1014]
mov [rbp+var_1054], eax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_2FAB1
mov eax, [rbp+var_1054]
add rsp, 1060h
pop rbp
retn
loc_2FAB1:
call ___stack_chk_fail
| long long my_realpath(long long a1, long long a2, char a3)
{
unsigned int *v3; // rax
long long v5; // [rsp+1Ch] [rbp-1044h]
long long v6; // [rsp+20h] [rbp-1040h]
unsigned int v7; // [rsp+2Ch] [rbp-1034h]
_BYTE v9[4104]; // [rsp+50h] [rbp-1010h] BYREF
unsigned long long v10; // [rsp+1058h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7 = 0;
v6 = realpath(a2, v9);
if ( v6 )
{
strmake(a1, v6, 511LL);
}
else
{
v5 = *(unsigned int *)__errno_location();
*(_DWORD *)my_thread_var() = v5;
if ( (a3 & 0x10) != 0 )
{
v3 = (unsigned int *)my_thread_var();
my_error(0x1Au, 0LL, a2, *v3);
}
my_load_path(a1, a2, 0LL);
if ( *(_DWORD *)my_thread_var() == 2 )
return 1;
else
return (unsigned int)-1;
}
return v7;
}
| my_realpath:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x1060
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x1020],RDI
MOV qword ptr [RBP + -0x1028],RSI
MOV qword ptr [RBP + -0x1030],RDX
MOV dword ptr [RBP + -0x1034],0x0
JMP 0x0012f999
LAB_0012f999:
MOV RDI,qword ptr [RBP + -0x1028]
LEA RSI,[RBP + -0x1010]
CALL 0x001240f0
MOV qword ptr [RBP + -0x1040],RAX
CMP RAX,0x0
JZ 0x0012f9d6
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1040]
MOV EDX,0x1ff
CALL 0x00176b70
JMP 0x0012fa76
LAB_0012f9d6:
CMP qword ptr [RBP + -0x1030],0x0
JZ 0x0012f9e6
JMP 0x0012f9e2
LAB_0012f9e2:
JMP 0x0012f9e4
LAB_0012f9e4:
JMP 0x0012f9e6
LAB_0012f9e6:
CALL 0x00124050
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x1044],EAX
CALL 0x00126970
MOV ECX,dword ptr [RBP + -0x1044]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x1030]
AND RAX,0x10
CMP RAX,0x0
JZ 0x0012fa3d
MOV RAX,qword ptr [RBP + -0x1028]
MOV qword ptr [RBP + -0x1050],RAX
CALL 0x00126970
MOV RDX,qword ptr [RBP + -0x1050]
MOV ECX,dword ptr [RAX]
MOV EDI,0x1a
XOR EAX,EAX
MOV ESI,EAX
MOV AL,0x0
CALL 0x0012dd60
LAB_0012fa3d:
MOV RDI,qword ptr [RBP + -0x1020]
MOV RSI,qword ptr [RBP + -0x1028]
XOR EAX,EAX
MOV EDX,EAX
CALL 0x00131290
CALL 0x00126970
CMP dword ptr [RAX],0x2
JNZ 0x0012fa6a
MOV dword ptr [RBP + -0x1034],0x1
JMP 0x0012fa74
LAB_0012fa6a:
MOV dword ptr [RBP + -0x1034],0xffffffff
LAB_0012fa74:
JMP 0x0012fa76
LAB_0012fa76:
JMP 0x0012fa78
LAB_0012fa78:
MOV EAX,dword ptr [RBP + -0x1034]
MOV dword ptr [RBP + -0x1014],EAX
MOV EAX,dword ptr [RBP + -0x1014]
MOV dword ptr [RBP + -0x1054],EAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x0012fab1
MOV EAX,dword ptr [RBP + -0x1054]
ADD RSP,0x1060
POP RBP
RET
LAB_0012fab1:
CALL 0x001242f0
|
int4 my_realpath(int8 param_1,char *param_2,ulong param_3)
{
int iVar1;
char *pcVar2;
int *piVar3;
int4 *puVar4;
long in_FS_OFFSET;
int4 local_103c;
char local_1018 [4104];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_103c = 0;
pcVar2 = realpath(param_2,local_1018);
if (pcVar2 == (char *)0x0) {
piVar3 = __errno_location();
iVar1 = *piVar3;
piVar3 = (int *)_my_thread_var();
*piVar3 = iVar1;
if ((param_3 & 0x10) != 0) {
puVar4 = (int4 *)_my_thread_var();
my_error(0x1a,0,param_2,*puVar4);
}
my_load_path(param_1,param_2,0);
piVar3 = (int *)_my_thread_var();
if (*piVar3 == 2) {
local_103c = 1;
}
else {
local_103c = 0xffffffff;
}
}
else {
strmake(param_1,pcVar2,0x1ff);
}
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return local_103c;
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,440 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O0 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x669ac
jmp 0x669cb
leaq 0x26a51(%rip), %rdi # 0x8d404
leaq 0x26549(%rip), %rsi # 0x8cf03
movl $0x3671, %edx # imm = 0x3671
leaq 0x26c05(%rip), %rcx # 0x8d5cb
callq 0x5d1f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0x66a21
movq -0x18(%rbp), %rax
leaq 0x2563e(%rip), %rcx # 0x8c028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x60410
jmp 0x66a32
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movl $0x1, %esi
callq 0x5c6d0
jmp 0x66a32
jmp 0x66a21
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
addq $0x10, %rdi
callq 0x5d690
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov rax, [rbp+var_8]
mov [rbp+var_10], rax
cmp qword ptr [rax], 0
jz short loc_669AC
jmp short loc_669CB
loc_669AC:
lea rdi, aMObjectNullptr; "m_object != nullptr"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
mov edx, 3671h
lea rcx, aIterImplBasicj; "iter_impl<BasicJsonType> &nlohmann::det"...
call ___assert_fail
loc_669CB:
mov rax, [rbp+var_10]
mov rax, [rax]
movzx eax, byte ptr [rax]
mov [rbp+var_18], rax
sub rax, 9; switch 10 cases
ja short def_669F1; jumptable 00000000000669F1 default case
mov rax, [rbp+var_18]
lea rcx, jpt_669F1
movsxd rax, ds:(jpt_669F1 - 8C028h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_669F3:
mov rdi, [rbp+var_10]; jumptable 00000000000669F1 case 1
add rdi, 8
mov esi, 1
call __ZSt7advanceISt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEEEiEvRT_T0_; std::advance<std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,int>(std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>> &,int)
jmp short loc_66A32
loc_66A07:
mov rdi, [rbp+var_10]; jumptable 00000000000669F1 case 2
add rdi, 8
add rdi, 8
mov esi, 1
call __ZSt7advanceIN9__gnu_cxx17__normal_iteratorIPN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS3_14adl_serializerES6_IhSaIhEEvEES6_ISG_SaISG_EEEEiEvRT_T0_; std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,int>(__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>> &,int)
jmp short loc_66A32
loc_66A1F:
jmp short $+2; jumptable 00000000000669F1 cases 0,3-9
def_669F1:
mov rdi, [rbp+var_10]; jumptable 00000000000669F1 default case
add rdi, 8
add rdi, 10h
call __ZN8nlohmann16json_abi_v3_11_36detail20primitive_iterator_tppEv; nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(void)
loc_66A32:
mov rax, [rbp+var_10]
add rsp, 20h
pop rbp
retn
| _QWORD * nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>::operator++(
_QWORD *a1)
{
if ( !*a1 )
__assert_fail(
"m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
13937LL,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<const nlohmann::basic_json<>>::operator++() [BasicJsonType ="
" const nlohmann::basic_json<>]");
switch ( *(_BYTE *)*a1 )
{
case 1:
std::advance<std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,int>(
a1 + 1,
1LL);
break;
case 2:
std::advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,int>(
a1 + 2,
1LL);
break;
default:
nlohmann::json_abi_v3_11_3::detail::primitive_iterator_t::operator++(a1 + 3);
break;
}
return a1;
}
| operator++:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV qword ptr [RBP + -0x10],RAX
CMP qword ptr [RAX],0x0
JZ 0x001669ac
JMP 0x001669cb
LAB_001669ac:
LEA RDI,[0x18d404]
LEA RSI,[0x18cf03]
MOV EDX,0x3671
LEA RCX,[0x18d5cb]
CALL 0x0015d1f0
LAB_001669cb:
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOVZX EAX,byte ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
SUB RAX,0x9
JA 0x00166a21
MOV RAX,qword ptr [RBP + -0x18]
LEA RCX,[0x18c028]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_1:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x8
MOV ESI,0x1
CALL 0x00160410
JMP 0x00166a32
caseD_2:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x8
ADD RDI,0x8
MOV ESI,0x1
CALL 0x0015c6d0
JMP 0x00166a32
caseD_0:
JMP 0x00166a21
default:
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x8
ADD RDI,0x10
CALL 0x0015d690
LAB_00166a32:
MOV RAX,qword ptr [RBP + -0x10]
ADD RSP,0x20
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const>::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>
*this)
{
if (*(long *)this == 0) {
/* WARNING: Subroutine does not return */
__assert_fail("m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x3671,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<const nlohmann::basic_json<>>::operator++() [BasicJsonType = const nlohmann::basic_json<>]"
);
}
switch(**(int1 **)this) {
case 0:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
default:
primitive_iterator_t::operator++((primitive_iterator_t *)(this + 0x18));
break;
case 1:
std::
advance<std::_Rb_tree_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,int>
((_Rb_tree_iterator *)(this + 8),1);
break;
case 2:
std::
advance<__gnu_cxx::__normal_iterator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>,int>
((__normal_iterator *)(this + 0x10),1);
}
return this;
}
| |
43,441 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O1 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x157d0
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x157c0
cmpl $0x1, %eax
jne 0x157c7
movq 0x8(%rbx), %rdi
callq 0x11690
movq %rax, 0x8(%rbx)
jmp 0x157cb
addq $0x10, 0x10(%rbx)
jmp 0x157cb
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xd5a1(%rip), %rdi # 0x22d78
leaq 0xd099(%rip), %rsi # 0x22877
leaq 0x116ec(%rip), %rcx # 0x26ed1
movl $0x3671, %edx # imm = 0x3671
callq 0x11620
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
push rbx
mov rax, [rdi]
test rax, rax
jz short loc_157D0
mov rbx, rdi
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_157C0
cmp eax, 1
jnz short loc_157C7
mov rdi, [rbx+8]
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov [rbx+8], rax
jmp short loc_157CB
loc_157C0:
add qword ptr [rbx+10h], 10h
jmp short loc_157CB
loc_157C7:
inc qword ptr [rbx+18h]
loc_157CB:
mov rax, rbx
pop rbx
retn
loc_157D0:
lea rdi, aMObjectNullptr; "m_object != nullptr"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIterImplBasicj_0; "iter_impl<BasicJsonType> &nlohmann::det"...
mov edx, 3671h
call ___assert_fail
| unsigned __int8 ** nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( !*a1 )
__assert_fail(
"m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
13937LL,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohm"
"ann::basic_json<>]");
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] = (unsigned __int8 *)std::_Rb_tree_increment(a1[1]);
}
else
{
++a1[3];
}
return a1;
}
| operator++:
PUSH RBX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001157d0
MOV RBX,RDI
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x001157c0
CMP EAX,0x1
JNZ 0x001157c7
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x00111690
MOV qword ptr [RBX + 0x8],RAX
JMP 0x001157cb
LAB_001157c0:
ADD qword ptr [RBX + 0x10],0x10
JMP 0x001157cb
LAB_001157c7:
INC qword ptr [RBX + 0x18]
LAB_001157cb:
MOV RAX,RBX
POP RBX
RET
LAB_001157d0:
LEA RDI,[0x122d78]
LEA RSI,[0x122877]
LEA RCX,[0x126ed1]
MOV EDX,0x3671
CALL 0x00111620
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
char cVar1;
int8 uVar2;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
uVar2 = std::_Rb_tree_increment(*(_Rb_tree_node_base **)(this + 8));
*(int8 *)(this + 8) = uVar2;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
__assert_fail("m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x3671,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohmann::basic_json<>]"
);
}
| |
43,442 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x2075b
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x2074b
cmpl $0x1, %eax
jne 0x20752
leaq 0x8(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0x1c9b0
jmp 0x20756
addq $0x10, 0x10(%rbx)
jmp 0x20756
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xb606(%rip), %rdi # 0x2bd68
leaq 0xb0fe(%rip), %rsi # 0x2b867
leaq 0xfadc(%rip), %rcx # 0x3024c
movl $0x3671, %edx # imm = 0x3671
callq 0x1cb30
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
push rbx
mov rax, [rdi]
test rax, rax
jz short loc_2075B
mov rbx, rdi
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_2074B
cmp eax, 1
jnz short loc_20752
lea rdi, [rbx+8]
push 1
pop rsi
call __ZSt9__advanceISt17_Rb_tree_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorS7_blmdSaNSA_14adl_serializerESD_IhSaIhEEvEEEElEvRT_T0_St26bidirectional_iterator_tag; std::__advance<std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,long>(std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>> &,long,std::bidirectional_iterator_tag)
jmp short loc_20756
loc_2074B:
add qword ptr [rbx+10h], 10h
jmp short loc_20756
loc_20752:
inc qword ptr [rbx+18h]
loc_20756:
mov rax, rbx
pop rbx
retn
loc_2075B:
lea rdi, aMObjectNullptr; "m_object != nullptr"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIterImplBasicj_0; "iter_impl<BasicJsonType> &nlohmann::det"...
mov edx, 3671h
call ___assert_fail
| unsigned __int8 ** nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( !*a1 )
__assert_fail(
"m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
13937LL,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohm"
"ann::basic_json<>]");
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
std::__advance<std::_Rb_tree_iterator<std::pair<std::string const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,long>(
a1 + 1,
1LL);
}
else
{
++a1[3];
}
return a1;
}
| operator++:
PUSH RBX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x0012075b
MOV RBX,RDI
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x0012074b
CMP EAX,0x1
JNZ 0x00120752
LEA RDI,[RBX + 0x8]
PUSH 0x1
POP RSI
CALL 0x0011c9b0
JMP 0x00120756
LAB_0012074b:
ADD qword ptr [RBX + 0x10],0x10
JMP 0x00120756
LAB_00120752:
INC qword ptr [RBX + 0x18]
LAB_00120756:
MOV RAX,RBX
POP RBX
RET
LAB_0012075b:
LEA RDI,[0x12bd68]
LEA RSI,[0x12b867]
LEA RCX,[0x13024c]
MOV EDX,0x3671
CALL 0x0011cb30
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
char cVar1;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
std::
__advance<std::_Rb_tree_iterator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,long>
(this + 8,1);
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
__assert_fail("m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x3671,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohmann::basic_json<>]"
);
}
| |
43,443 | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++() | 11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp | iter_impl& operator++()
{
JSON_ASSERT(m_object != nullptr);
switch (m_object->m_data.m_type)
{
case value_t::object:
{
std::advance(m_it.object_iterator, 1);
break;
}
case value_t::array:
{
std::advance(m_it.array_iterator, 1);
break;
}
case value_t::null:
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:
{
++m_it.primitive_iterator;
break;
}
}
return *this;
} | O3 | cpp | nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const>::operator++():
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x156f6
movq %rdi, %rbx
movzbl (%rax), %eax
cmpl $0x2, %eax
je 0x156e6
cmpl $0x1, %eax
jne 0x156ed
movq 0x8(%rbx), %rdi
callq 0x11680
movq %rax, 0x8(%rbx)
jmp 0x156f1
addq $0x10, 0x10(%rbx)
jmp 0x156f1
incq 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
leaq 0xc67b(%rip), %rdi # 0x21d78
leaq 0xc173(%rip), %rsi # 0x21877
leaq 0x107c6(%rip), %rcx # 0x25ed1
movl $0x3671, %edx # imm = 0x3671
callq 0x11610
nop
| _ZN8nlohmann16json_abi_v3_11_36detail9iter_implINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEppEv:
push rbx
mov rax, [rdi]
test rax, rax
jz short loc_156F6
mov rbx, rdi
movzx eax, byte ptr [rax]
cmp eax, 2
jz short loc_156E6
cmp eax, 1
jnz short loc_156ED
mov rdi, [rbx+8]
call __ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base; std::_Rb_tree_increment(std::_Rb_tree_node_base *)
mov [rbx+8], rax
jmp short loc_156F1
loc_156E6:
add qword ptr [rbx+10h], 10h
jmp short loc_156F1
loc_156ED:
inc qword ptr [rbx+18h]
loc_156F1:
mov rax, rbx
pop rbx
retn
loc_156F6:
lea rdi, aMObjectNullptr; "m_object != nullptr"
lea rsi, aWorkspaceLlm4b_0; "/workspace/llm4binary/github/2025_star3"...
lea rcx, aIterImplBasicj_0; "iter_impl<BasicJsonType> &nlohmann::det"...
mov edx, 3671h
call ___assert_fail
| unsigned __int8 ** nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::operator++(
unsigned __int8 **a1)
{
int v1; // eax
if ( !*a1 )
__assert_fail(
"m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp",
13937LL,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohm"
"ann::basic_json<>]");
v1 = **a1;
if ( v1 == 2 )
{
a1[2] += 16;
}
else if ( v1 == 1 )
{
a1[1] = (unsigned __int8 *)std::_Rb_tree_increment(a1[1]);
}
else
{
++a1[3];
}
return a1;
}
| operator++:
PUSH RBX
MOV RAX,qword ptr [RDI]
TEST RAX,RAX
JZ 0x001156f6
MOV RBX,RDI
MOVZX EAX,byte ptr [RAX]
CMP EAX,0x2
JZ 0x001156e6
CMP EAX,0x1
JNZ 0x001156ed
MOV RDI,qword ptr [RBX + 0x8]
CALL 0x00111680
MOV qword ptr [RBX + 0x8],RAX
JMP 0x001156f1
LAB_001156e6:
ADD qword ptr [RBX + 0x10],0x10
JMP 0x001156f1
LAB_001156ed:
INC qword ptr [RBX + 0x18]
LAB_001156f1:
MOV RAX,RBX
POP RBX
RET
LAB_001156f6:
LEA RDI,[0x121d78]
LEA RSI,[0x121877]
LEA RCX,[0x125ed1]
MOV EDX,0x3671
CALL 0x00111610
|
/* nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >::TEMPNAMEPLACEHOLDERVALUE() */
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
* __thiscall
nlohmann::json_abi_v3_11_3::detail::
iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::operator++(iter_impl<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*this)
{
char cVar1;
int8 uVar2;
if (*(char **)this != (char *)0x0) {
cVar1 = **(char **)this;
if (cVar1 == '\x02') {
*(long *)(this + 0x10) = *(long *)(this + 0x10) + 0x10;
}
else if (cVar1 == '\x01') {
uVar2 = std::_Rb_tree_increment(*(_Rb_tree_node_base **)(this + 8));
*(int8 *)(this + 8) = uVar2;
}
else {
*(long *)(this + 0x18) = *(long *)(this + 0x18) + 1;
}
return this;
}
/* WARNING: Subroutine does not return */
__assert_fail("m_object != nullptr",
"/workspace/llm4binary/github/2025_star3/11AgReS1SoR11[P]Graph/Common/FiguresStorage/src/json.hpp"
,0x3671,
"iter_impl<BasicJsonType> &nlohmann::detail::iter_impl<nlohmann::basic_json<>>::operator++() [BasicJsonType = nlohmann::basic_json<>]"
);
}
| |
43,444 | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parse(bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&) | monkey531[P]llama/common/json.hpp | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
// in strict mode, input must be completely read
if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
parse_error::create(101, m_lexer.get_position(),
exception_message(token_type::end_of_input, "value"), nullptr));
}
// in case of an error, return discarded value
if (sdp.is_errored())
{
result = value_t::discarded;
return;
}
// set top-level value to null if it was discarded by the callback
// function
if (result.is_discarded())
{
result = nullptr;
}
}
else
{
json_sax_dom_parser<BasicJsonType> sdp(result, allow_exceptions);
sax_parse_internal(&sdp);
// in strict mode, input must be completely read
if (strict && (get_token() != token_type::end_of_input))
{
sdp.parse_error(m_lexer.get_position(),
m_lexer.get_token_string(),
parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
}
// in case of an error, return discarded value
if (sdp.is_errored())
{
result = value_t::discarded;
return;
}
}
result.assert_invariant();
} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::parse(bool, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x40018
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fe6a
movzbl 0xc0(%r15), %ecx
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x419a8
leaq 0xc8(%rsp), %rdi
callq 0x4a6e6
leaq 0x108(%rsp), %rsi
movq %r15, %rdi
callq 0x41a6c
testb %bpl, %bpl
je 0x3ffee
movq %r15, %rdi
callq 0x40b0e
cmpl $0xf, %eax
je 0x3ffee
leaq 0x28(%r15), %rsi
movq 0x48(%r15), %r14
leaq 0x70(%rsp), %rdi
callq 0x42588
leaq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x720a7(%rip), %rsi # 0xb200c
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x283ac
leaq 0x50(%rsp), %rdi
pushq $0xf
popq %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rsi
callq 0x42766
leaq 0x90(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
xorl %r8d, %r8d
callq 0x42630
leaq 0x108(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r14, %rsi
callq 0x42544
leaq 0x90(%rsp), %rdi
callq 0x42902
leaq 0x50(%rsp), %rdi
callq 0x25478
leaq 0x30(%rsp), %rdi
callq 0x25478
leaq 0x70(%rsp), %rdi
callq 0x25478
movb 0x180(%rsp), %bpl
cmpb $0x1, %bpl
jne 0x40160
leaq 0xf8(%rsp), %r14
pushq $0x9
popq %rsi
movq %r14, %rdi
callq 0x42926
jmp 0x40177
movb 0xc0(%r15), %al
leaq 0x110(%rsp), %r14
movq %rbx, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movups %xmm0, 0x10(%r14)
movb $0x0, 0x20(%r14)
movb %al, 0x21(%r14)
leaq 0x108(%rsp), %rsi
movq %r15, %rdi
callq 0x429bc
testb %bpl, %bpl
je 0x40121
movq %r15, %rdi
callq 0x40b0e
cmpl $0xf, %eax
je 0x40121
leaq 0x28(%r15), %rsi
movq 0x48(%r15), %r12
leaq 0x70(%rsp), %rdi
callq 0x42588
leaq 0x48(%r15), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x71f74(%rip), %rsi # 0xb200c
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x283ac
leaq 0x50(%rsp), %rdi
pushq $0xf
popq %rdx
leaq 0x30(%rsp), %rcx
movq %r15, %rsi
callq 0x42766
leaq 0x90(%rsp), %rdi
pushq $0x65
popq %rsi
leaq 0x10(%rsp), %rdx
leaq 0x50(%rsp), %rcx
xorl %r8d, %r8d
callq 0x42630
leaq 0x108(%rsp), %rdi
leaq 0x70(%rsp), %rdx
leaq 0x90(%rsp), %rcx
movq %r12, %rsi
callq 0x43494
leaq 0x90(%rsp), %rdi
callq 0x42902
leaq 0x50(%rsp), %rdi
callq 0x25478
leaq 0x30(%rsp), %rdi
callq 0x25478
leaq 0x70(%rsp), %rdi
callq 0x25478
cmpb $0x1, 0x130(%rsp)
jne 0x4019e
leaq 0xb8(%rsp), %rdi
pushq $0x9
popq %rsi
callq 0x42926
leaq 0xb8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4293c
movq %r15, %rdi
callq 0x3fdb6
movq %r14, %rdi
callq 0x43a40
jmp 0x401b1
cmpb $0x9, (%rbx)
jne 0x4018a
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3fdca
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4293c
movq %r14, %rdi
callq 0x3fdb6
leaq 0x108(%rsp), %rdi
callq 0x42980
testb %bpl, %bpl
je 0x401a6
jmp 0x401b1
movq %r14, %rdi
callq 0x43a40
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x40290
addq $0x1c0, %rsp # imm = 0x1C0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x42902
jmp 0x401d6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25478
jmp 0x401e5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x25478
jmp 0x401f4
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x25478
jmp 0x40258
jmp 0x40255
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x42902
jmp 0x40217
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25478
jmp 0x40226
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x25478
jmp 0x40235
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x25478
jmp 0x40265
jmp 0x40262
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x4a6e6
jmp 0x40272
movq %rax, %rbx
movq %r14, %rdi
callq 0x43a40
jmp 0x40272
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x42980
movq %rbx, %rdi
callq 0x251e0
| _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE5parseEbRSF_:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 1C0h
mov rbx, rdx
mov ebp, esi
mov r15, rdi
cmp qword ptr [rdi+10h], 0
jz loc_40018
lea r14, [rsp+1E8h+var_120]
mov rdi, r14
mov rsi, r15
call _ZNSt8functionIFbiN8nlohmann16json_abi_v3_11_36detail13parse_event_tERNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEC2ERKSJ_; std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)>::function(std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &)> const&)
movzx ecx, byte ptr [r15+0C0h]
lea rdi, [rsp+1E8h+var_E0]
mov rsi, rbx
mov rdx, r14
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEC2ERSF_St8functionIFbiNS1_13parse_event_tESH_EEb; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::json_sax_dom_callback_parser(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&,std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>&)>,bool)
lea rdi, [rsp+1E8h+var_120]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
lea rsi, [rsp+1E8h+var_E0]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18sax_parse_internalINS1_28json_sax_dom_callback_parserISF_EEEEbPT_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>(nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *)
test bpl, bpl
jz loc_3FFEE
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE9get_tokenEv; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token(void)
cmp eax, 0Fh
jz loc_3FFEE
lea rsi, [r15+28h]
mov r14, [r15+48h]
lea rdi, [rsp+1E8h+var_178]
call _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(void)
lea rax, [r15+48h]
mov rcx, [rax+10h]
mov qword ptr [rsp+1E8h+var_1C8], rcx; int
movups xmm0, xmmword ptr [rax]
movaps xmmword ptr [rsp+1E8h+var_1D8], xmm0; char
lea rsi, aInvalidValue+8; "value"
lea rdi, [rsp+1E8h+var_1B8]
lea rdx, [rsp+1E8h+var_1D9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+1E8h+var_198]
push 0Fh
pop rdx
lea rcx, [rsp+1E8h+var_1B8]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE17exception_messageENS1_10lexer_baseISF_E10token_typeERKSB_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type,std::string const&)
lea rdi, [rsp+1E8h+var_158]; this
push 65h ; 'e'
pop rsi; int
lea rdx, [rsp+1E8h+var_1D8]
lea rcx, [rsp+1E8h+var_198]
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
lea rdi, [rsp+1E8h+var_E0]
lea rdx, [rsp+1E8h+var_178]
lea rcx, [rsp+1E8h+var_158]
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11parse_errorINS1_11parse_errorEEEbmRKSB_RKT_; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>(ulong,std::string const&,nlohmann::json_abi_v3_11_3::detail::parse_error const&)
lea rdi, [rsp+1E8h+var_158]; void *
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; nlohmann::json_abi_v3_11_3::detail::exception::~exception()
lea rdi, [rsp+1E8h+var_198]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1E8h+var_1B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1E8h+var_178]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_3FFEE:
mov bpl, [rsp+1E8h+var_68]
cmp bpl, 1
jnz loc_40160
loc_40000:
lea r14, [rsp+1E8h+var_F0]
push 9
pop rsi
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::detail::value_t)
jmp loc_40177
loc_40018:
mov al, [r15+0C0h]
lea r14, [rsp+1E8h+var_D8]
mov [r14-8], rbx
xorps xmm0, xmm0
movups xmmword ptr [r14], xmm0
movups xmmword ptr [r14+10h], xmm0
mov byte ptr [r14+20h], 0
mov [r14+21h], al
lea rsi, [rsp+1E8h+var_E0]
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE18sax_parse_internalINS1_19json_sax_dom_parserISF_EEEEbPT_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>(nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> *)
test bpl, bpl
jz loc_40121
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE9get_tokenEv; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token(void)
cmp eax, 0Fh
jz loc_40121
lea rsi, [r15+28h]
mov r12, [r15+48h]
lea rdi, [rsp+1E8h+var_178]
call _ZNK8nlohmann16json_abi_v3_11_36detail5lexerINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE16get_token_stringEv; nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(void)
lea rax, [r15+48h]
mov rcx, [rax+10h]
mov qword ptr [rsp+1E8h+var_1C8], rcx; int
movups xmm0, xmmword ptr [rax]
movaps xmmword ptr [rsp+1E8h+var_1D8], xmm0; char
lea rsi, aInvalidValue+8; "value"
lea rdi, [rsp+1E8h+var_1B8]
lea rdx, [rsp+1E8h+var_1D9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+1E8h+var_198]
push 0Fh
pop rdx
lea rcx, [rsp+1E8h+var_1B8]
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_36detail6parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEENS1_22iterator_input_adapterIN9__gnu_cxx17__normal_iteratorIPKcSB_EEEEE17exception_messageENS1_10lexer_baseISF_E10token_typeERKSB_; nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::exception_message(nlohmann::json_abi_v3_11_3::detail::lexer_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::token_type,std::string const&)
lea rdi, [rsp+1E8h+var_158]; this
push 65h ; 'e'
pop rsi; int
lea rdx, [rsp+1E8h+var_1D8]
lea rcx, [rsp+1E8h+var_198]
xor r8d, r8d
call _ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
lea rdi, [rsp+1E8h+var_E0]
lea rdx, [rsp+1E8h+var_178]
lea rcx, [rsp+1E8h+var_158]
mov rsi, r12
call _ZN8nlohmann16json_abi_v3_11_36detail19json_sax_dom_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE11parse_errorINS1_11parse_errorEEEbmRKSB_RKT_; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>(ulong,std::string const&,nlohmann::json_abi_v3_11_3::detail::parse_error const&)
lea rdi, [rsp+1E8h+var_158]; void *
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; nlohmann::json_abi_v3_11_3::detail::exception::~exception()
lea rdi, [rsp+1E8h+var_198]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1E8h+var_1B8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+1E8h+var_178]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_40121:
cmp [rsp+1E8h+var_B8], 1
jnz short loc_4019E
lea rdi, [rsp+1E8h+var_130]
push 9
pop rsi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ENS0_6detail7value_tE; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(nlohmann::json_abi_v3_11_3::detail::value_t)
lea r15, [rsp+1E8h+var_130]
mov rdi, rbx
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
mov rdi, r14
call _ZNSt12_Vector_baseIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEESaISF_EED2Ev; std::_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::~_Vector_base()
jmp short loc_401B1
loc_40160:
cmp byte ptr [rbx], 9
jnz short loc_4018A
lea r14, [rsp+1E8h+var_100]
mov rdi, r14
xor esi, esi
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2EDn; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::basic_json(decltype(nullptr))
loc_40177:
mov rdi, rbx
mov rsi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEaSESD_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::operator=(nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvED2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::~basic_json()
loc_4018A:
lea rdi, [rsp+1E8h+var_E0]
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEED2Ev; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~json_sax_dom_callback_parser()
test bpl, bpl
jz short loc_401A6
jmp short loc_401B1
loc_4019E:
mov rdi, r14
call _ZNSt12_Vector_baseIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEESaISF_EED2Ev; std::_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::~_Vector_base()
loc_401A6:
push 1
pop rsi
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
loc_401B1:
add rsp, 1C0h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
mov rbx, rax
lea rdi, [rsp+arg_88]; void *
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; nlohmann::json_abi_v3_11_3::detail::exception::~exception()
jmp short loc_401D6
mov rbx, rax
loc_401D6:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_401E5
mov rbx, rax
loc_401E5:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_401F4
mov rbx, rax
loc_401F4:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_40258
jmp short loc_40255
mov rbx, rax
lea rdi, [rsp+arg_88]; void *
call _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; nlohmann::json_abi_v3_11_3::detail::exception::~exception()
jmp short loc_40217
mov rbx, rax
loc_40217:
lea rdi, [rsp+arg_48]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_40226
mov rbx, rax
loc_40226:
lea rdi, [rsp+arg_28]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_40235
mov rbx, rax
loc_40235:
lea rdi, [rsp+arg_68]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_40265
jmp short loc_40262
mov rbx, rax
lea rdi, [rsp+arg_C0]; this
call _ZNSt14_Function_baseD2Ev; std::_Function_base::~_Function_base()
jmp short loc_40272
loc_40255:
mov rbx, rax
loc_40258:
mov rdi, r14
call _ZNSt12_Vector_baseIPN8nlohmann16json_abi_v3_11_310basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES4_IhSaIhEEvEESaISF_EED2Ev; std::_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> *>>::~_Vector_base()
jmp short loc_40272
loc_40262:
mov rbx, rax
loc_40265:
lea rdi, [rsp+arg_100]
call _ZN8nlohmann16json_abi_v3_11_36detail28json_sax_dom_callback_parserINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEED2Ev; nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::~json_sax_dom_callback_parser()
loc_40272:
mov rdi, rbx
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::parse(
long long a1,
char a2,
_BYTE *a3,
int a4,
int a5,
int a6)
{
int v7; // edx
int v8; // ecx
int v9; // r8d
int v10; // r9d
long long v11; // r14
int v12; // r8d
int v13; // r9d
char v14; // bp
_BYTE *v15; // r14
char v16; // al
long long v17; // r12
int v18; // r8d
int v19; // r9d
long long result; // rax
int v21; // [rsp+0h] [rbp-1E8h]
int v22; // [rsp+8h] [rbp-1E0h]
char v23[16]; // [rsp+10h] [rbp-1D8h]
char v24[16]; // [rsp+10h] [rbp-1D8h]
int v25[2]; // [rsp+20h] [rbp-1C8h]
int v26[2]; // [rsp+20h] [rbp-1C8h]
int v27; // [rsp+28h] [rbp-1C0h]
long long v28; // [rsp+30h] [rbp-1B8h] BYREF
int v29; // [rsp+38h] [rbp-1B0h]
int v30; // [rsp+40h] [rbp-1A8h]
int v31; // [rsp+48h] [rbp-1A0h]
char v32[8]; // [rsp+50h] [rbp-198h] BYREF
int v33; // [rsp+58h] [rbp-190h]
int v34; // [rsp+60h] [rbp-188h]
int v35; // [rsp+68h] [rbp-180h]
char v36[8]; // [rsp+70h] [rbp-178h] BYREF
int v37; // [rsp+78h] [rbp-170h]
int v38; // [rsp+80h] [rbp-168h]
int v39; // [rsp+88h] [rbp-160h]
char v40[40]; // [rsp+90h] [rbp-158h] BYREF
_BYTE v41[16]; // [rsp+B8h] [rbp-130h] BYREF
_OWORD v42[2]; // [rsp+C8h] [rbp-120h] BYREF
_BYTE v43[16]; // [rsp+E8h] [rbp-100h] BYREF
_BYTE v44[16]; // [rsp+F8h] [rbp-F0h] BYREF
_BYTE *v45; // [rsp+108h] [rbp-E0h] BYREF
_BYTE v46[32]; // [rsp+110h] [rbp-D8h] BYREF
char v47; // [rsp+130h] [rbp-B8h]
char v48; // [rsp+131h] [rbp-B7h]
char v49; // [rsp+180h] [rbp-68h]
if ( !*(_QWORD *)(a1 + 16) )
{
v16 = *(_BYTE *)(a1 + 192);
v45 = a3;
memset(v46, 0, sizeof(v46));
v47 = 0;
v48 = v16;
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>(
a1,
(unsigned int)&v45,
(_DWORD)a3,
a4,
a5,
a6);
if ( a2
&& (unsigned int)nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token(a1) != 15 )
{
v17 = *(_QWORD *)(a1 + 72);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
v36,
a1 + 40);
*(_QWORD *)v26 = *(_QWORD *)(a1 + 88);
*(_OWORD *)v24 = *(_OWORD *)(a1 + 72);
std::string::basic_string<std::allocator<char>>(&v28, (long long)"value");
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::exception_message(
(unsigned int)v32,
a1,
15,
(unsigned int)&v28,
v18,
v19);
ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
(nlohmann::json_abi_v3_11_3::detail::parse_error *)v40,
101,
v21,
v22,
v24[0],
*(int *)&v24[8],
v26[0],
v27,
v28,
v29,
v30,
v31,
v32[0],
v33,
v34,
v35,
v36[0],
v37,
v38,
v39,
v40[0]);
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>(
&v45,
v17,
v36,
v40);
nlohmann::json_abi_v3_11_3::detail::exception::~exception(v40);
std::string::~string(v32);
std::string::~string(&v28);
std::string::~string(v36);
}
if ( v47 == 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(
v41,
9LL);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
a3,
v41);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v41);
return std::_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::~_Vector_base(v46);
}
std::_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> *>>::~_Vector_base(v46);
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a3,
1LL);
}
std::function<bool ()(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> &)>::function(
v42,
a1);
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::json_sax_dom_callback_parser(
&v45,
a3,
v42,
*(unsigned __int8 *)(a1 + 192));
std::_Function_base::~_Function_base((std::_Function_base *)v42);
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>(
a1,
(unsigned int)&v45,
v7,
v8,
v9,
v10);
if ( a2 )
{
if ( (unsigned int)nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token(a1) != 15 )
{
v11 = *(_QWORD *)(a1 + 72);
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::get_token_string(
v36,
a1 + 40);
*(_QWORD *)v25 = *(_QWORD *)(a1 + 88);
*(_OWORD *)v23 = *(_OWORD *)(a1 + 72);
std::string::basic_string<std::allocator<char>>(&v28, (long long)"value");
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char const*,std::string>>>::exception_message(
(unsigned int)v32,
a1,
15,
(unsigned int)&v28,
v12,
v13);
ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
(nlohmann::json_abi_v3_11_3::detail::parse_error *)v40,
101,
v21,
v22,
v23[0],
*(int *)&v23[8],
v25[0],
v27,
v28,
v29,
v30,
v31,
v32[0],
v33,
v34,
v35,
v36[0],
v37,
v38,
v39,
v40[0]);
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>(
&v45,
v11,
v36,
v40);
nlohmann::json_abi_v3_11_3::detail::exception::~exception(v40);
std::string::~string(v32);
std::string::~string(&v28);
std::string::~string(v36);
}
}
v14 = v49;
if ( v49 == 1 )
{
v15 = v44;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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(
v44,
9LL);
}
else
{
if ( *a3 != 9 )
goto LABEL_15;
v15 = v43;
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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)v43);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,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=(
a3,
v15);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::~basic_json((long long)v15);
LABEL_15:
result = nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::~json_sax_dom_callback_parser(&v45);
if ( !v14 )
return nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a3,
1LL);
return result;
}
| parse:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1c0
MOV RBX,RDX
MOV EBP,ESI
MOV R15,RDI
CMP qword ptr [RDI + 0x10],0x0
JZ 0x00140018
LEA R14,[RSP + 0xc8]
MOV RDI,R14
MOV RSI,R15
CALL 0x0013fe6a
MOVZX ECX,byte ptr [R15 + 0xc0]
LAB_0013feed:
LEA RDI,[RSP + 0x108]
MOV RSI,RBX
MOV RDX,R14
CALL 0x001419a8
LEA RDI,[RSP + 0xc8]
CALL 0x0014a6e6
LAB_0013ff0d:
LEA RSI,[RSP + 0x108]
MOV RDI,R15
CALL 0x00141a6c
TEST BPL,BPL
JZ 0x0013ffee
MOV RDI,R15
CALL 0x00140b0e
CMP EAX,0xf
JZ 0x0013ffee
LEA RSI,[R15 + 0x28]
MOV R14,qword ptr [R15 + 0x48]
LAB_0013ff3f:
LEA RDI,[RSP + 0x70]
CALL 0x00142588
LEA RAX,[R15 + 0x48]
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_0013ff5e:
LEA RSI,[0x1b200c]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0xf]
CALL 0x001283ac
LAB_0013ff74:
LEA RDI,[RSP + 0x50]
PUSH 0xf
POP RDX
LEA RCX,[RSP + 0x30]
MOV RSI,R15
CALL 0x00142766
LAB_0013ff89:
LEA RDI,[RSP + 0x90]
PUSH 0x65
POP RSI
LEA RDX,[RSP + 0x10]
LEA RCX,[RSP + 0x50]
XOR R8D,R8D
CALL 0x00142630
LAB_0013ffa6:
LEA RDI,[RSP + 0x108]
LEA RDX,[RSP + 0x70]
LEA RCX,[RSP + 0x90]
MOV RSI,R14
CALL 0x00142544
LEA RDI,[RSP + 0x90]
CALL 0x00142902
LEA RDI,[RSP + 0x50]
CALL 0x00125478
LEA RDI,[RSP + 0x30]
CALL 0x00125478
LEA RDI,[RSP + 0x70]
CALL 0x00125478
LAB_0013ffee:
MOV BPL,byte ptr [RSP + 0x180]
CMP BPL,0x1
JNZ 0x00140160
LEA R14,[RSP + 0xf8]
LAB_00140008:
PUSH 0x9
POP RSI
MOV RDI,R14
CALL 0x00142926
JMP 0x00140177
LAB_00140018:
MOV AL,byte ptr [R15 + 0xc0]
LEA R14,[RSP + 0x110]
MOV qword ptr [R14 + -0x8],RBX
XORPS XMM0,XMM0
MOVUPS xmmword ptr [R14],XMM0
MOVUPS xmmword ptr [R14 + 0x10],XMM0
MOV byte ptr [R14 + 0x20],0x0
MOV byte ptr [R14 + 0x21],AL
LAB_00140040:
LEA RSI,[RSP + 0x108]
MOV RDI,R15
CALL 0x001429bc
TEST BPL,BPL
JZ 0x00140121
MOV RDI,R15
CALL 0x00140b0e
CMP EAX,0xf
JZ 0x00140121
LEA RSI,[R15 + 0x28]
MOV R12,qword ptr [R15 + 0x48]
LAB_00140072:
LEA RDI,[RSP + 0x70]
CALL 0x00142588
LEA RAX,[R15 + 0x48]
MOV RCX,qword ptr [RAX + 0x10]
MOV qword ptr [RSP + 0x20],RCX
MOVUPS XMM0,xmmword ptr [RAX]
MOVAPS xmmword ptr [RSP + 0x10],XMM0
LAB_00140091:
LEA RSI,[0x1b200c]
LEA RDI,[RSP + 0x30]
LEA RDX,[RSP + 0xf]
CALL 0x001283ac
LAB_001400a7:
LEA RDI,[RSP + 0x50]
PUSH 0xf
POP RDX
LEA RCX,[RSP + 0x30]
MOV RSI,R15
CALL 0x00142766
LAB_001400bc:
LEA RDI,[RSP + 0x90]
PUSH 0x65
POP RSI
LEA RDX,[RSP + 0x10]
LEA RCX,[RSP + 0x50]
XOR R8D,R8D
CALL 0x00142630
LAB_001400d9:
LEA RDI,[RSP + 0x108]
LEA RDX,[RSP + 0x70]
LEA RCX,[RSP + 0x90]
MOV RSI,R12
CALL 0x00143494
LEA RDI,[RSP + 0x90]
CALL 0x00142902
LEA RDI,[RSP + 0x50]
CALL 0x00125478
LEA RDI,[RSP + 0x30]
CALL 0x00125478
LEA RDI,[RSP + 0x70]
CALL 0x00125478
LAB_00140121:
CMP byte ptr [RSP + 0x130],0x1
JNZ 0x0014019e
LAB_0014012b:
LEA RDI,[RSP + 0xb8]
PUSH 0x9
POP RSI
CALL 0x00142926
LAB_0014013b:
LEA R15,[RSP + 0xb8]
MOV RDI,RBX
MOV RSI,R15
CALL 0x0014293c
MOV RDI,R15
CALL 0x0013fdb6
MOV RDI,R14
CALL 0x00143a40
JMP 0x001401b1
LAB_00140160:
CMP byte ptr [RBX],0x9
JNZ 0x0014018a
LEA R14,[RSP + 0xe8]
MOV RDI,R14
XOR ESI,ESI
CALL 0x0013fdca
LAB_00140177:
MOV RDI,RBX
MOV RSI,R14
CALL 0x0014293c
MOV RDI,R14
CALL 0x0013fdb6
LAB_0014018a:
LEA RDI,[RSP + 0x108]
CALL 0x00142980
TEST BPL,BPL
JZ 0x001401a6
JMP 0x001401b1
LAB_0014019e:
MOV RDI,R14
CALL 0x00143a40
LAB_001401a6:
PUSH 0x1
POP RSI
MOV RDI,RBX
CALL 0x00140290
LAB_001401b1:
ADD RSP,0x1c0
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
/* nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>,
nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char
const*, std::__cxx11::string > > >::parse(bool,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void>&) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::parse(parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
*this,bool param_1,basic_json *param_2)
{
ulong uVar1;
int iVar2;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*this_00;
allocator local_1d9;
int8 local_1d8;
int8 uStack_1d0;
int8 local_1c8;
string local_1b8 [32];
string local_198 [32];
string local_178 [32];
parse_error local_158 [40];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_130 [16];
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
local_120 [32];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_100 [16];
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
local_f0 [16];
basic_json *local_e0;
int8 local_d8;
int8 uStack_d0;
int8 local_c8;
int8 uStack_c0;
char local_b8;
parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
local_b7;
char local_68;
if (*(long *)(this + 0x10) == 0) {
local_b7 = this[0xc0];
local_d8 = 0;
uStack_d0 = 0;
local_c8 = 0;
uStack_c0 = 0;
local_b8 = '\0';
/* try { // try from 00140040 to 00140060 has its CatchHandler @ 00140255 */
local_e0 = param_2;
sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
(this,(json_sax_dom_parser *)&local_e0);
if ((param_1) && (iVar2 = get_token(this), iVar2 != 0xf)) {
uVar1 = *(ulong *)(this + 0x48);
/* try { // try from 00140072 to 0014007b has its CatchHandler @ 00140200 */
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get_token_string();
local_1c8 = *(int8 *)(this + 0x58);
local_1d8 = *(int8 *)(this + 0x48);
uStack_1d0 = *(int8 *)(this + 0x50);
/* try { // try from 00140091 to 001400a6 has its CatchHandler @ 001401f1 */
std::__cxx11::string::string<std::allocator<char>>(local_1b8,"value",&local_1d9);
/* try { // try from 001400a7 to 001400bb has its CatchHandler @ 001401e2 */
exception_message(local_198,this,0xf,local_1b8);
/* try { // try from 001400bc to 001400d8 has its CatchHandler @ 001401d3 */
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(local_158,0x65,&local_1d8,local_198,0);
/* try { // try from 001400d9 to 001400f5 has its CatchHandler @ 001401c1 */
json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>
((json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_e0,uVar1,local_178,local_158);
exception::~exception((exception *)local_158);
std::__cxx11::string::~string(local_198);
std::__cxx11::string::~string(local_1b8);
std::__cxx11::string::~string(local_178);
}
if (local_b8 == '\x01') {
/* try { // try from 0014012b to 0014013a has its CatchHandler @ 00140255 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(local_130,9);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_2,local_130);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(local_130);
std::
_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,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_base((_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,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_d8);
return;
}
std::
_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,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_base((_Vector_base<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>*,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_d8);
goto LAB_001401a6;
}
std::
function<bool(int,nlohmann::json_abi_v3_11_3::detail::parse_event_t,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>&)>
::function(local_120,this);
/* try { // try from 0013feed to 0013feff has its CatchHandler @ 00140243 */
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::json_sax_dom_callback_parser
((json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_e0,param_2,local_120,this[0xc0]);
std::_Function_base::~_Function_base((_Function_base *)local_120);
/* try { // try from 0013ff0d to 0013ff2d has its CatchHandler @ 00140262 */
sax_parse_internal<nlohmann::json_abi_v3_11_3::detail::json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
(this,(json_sax_dom_callback_parser *)&local_e0);
if ((param_1) && (iVar2 = get_token(this), iVar2 != 0xf)) {
uVar1 = *(ulong *)(this + 0x48);
/* try { // try from 0013ff3f to 0013ff48 has its CatchHandler @ 00140241 */
lexer<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,nlohmann::json_abi_v3_11_3::detail::iterator_input_adapter<__gnu_cxx::__normal_iterator<char_const*,std::__cxx11::string>>>
::get_token_string();
local_1c8 = *(int8 *)(this + 0x58);
local_1d8 = *(int8 *)(this + 0x48);
uStack_1d0 = *(int8 *)(this + 0x50);
/* try { // try from 0013ff5e to 0013ff73 has its CatchHandler @ 00140232 */
std::__cxx11::string::string<std::allocator<char>>(local_1b8,"value",&local_1d9);
/* try { // try from 0013ff74 to 0013ff88 has its CatchHandler @ 00140223 */
exception_message(local_198,this,0xf,local_1b8);
/* try { // try from 0013ff89 to 0013ffa5 has its CatchHandler @ 00140214 */
_ZN8nlohmann16json_abi_v3_11_36detail11parse_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNS1_10position_tERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(local_158,0x65,&local_1d8,local_198,0);
/* try { // try from 0013ffa6 to 0013ffc2 has its CatchHandler @ 00140202 */
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::parse_error<nlohmann::json_abi_v3_11_3::detail::parse_error>
((json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_e0,uVar1,local_178,local_158);
exception::~exception((exception *)local_158);
std::__cxx11::string::~string(local_198);
std::__cxx11::string::~string(local_1b8);
std::__cxx11::string::~string(local_178);
}
if (local_68 == '\x01') {
this_00 = local_f0;
/* try { // try from 00140008 to 00140012 has its CatchHandler @ 00140262 */
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(this_00,9);
LAB_00140177:
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::operator=((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_2,this_00);
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::~basic_json(this_00);
}
else if (*param_2 == '\t') {
this_00 = local_100;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json((_func_decltype_nullptr *)this_00);
goto LAB_00140177;
}
json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::~json_sax_dom_callback_parser
((json_sax_dom_callback_parser<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
*)&local_e0);
if (local_68 != '\0') {
return;
}
LAB_001401a6:
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::assert_invariant(SUB81(param_2,0));
return;
}
| |
43,445 | madb_alloc_stmt_fields | eloqsql/libmariadb/libmariadb/mariadb_stmt.c | static int madb_alloc_stmt_fields(MYSQL_STMT *stmt)
{
MA_MEM_ROOT *fields_ma_alloc_root= &((MADB_STMT_EXTENSION *)stmt->extension)->fields_ma_alloc_root;
MYSQL *mysql= stmt->mysql;
if (!mysql->field_count)
return 0;
stmt->field_count= mysql->field_count;
if (mysql->fields)
{
/* Column info was sent by server */
ma_free_root(fields_ma_alloc_root, MYF(0));
if (!(stmt->fields= ma_duplicate_resultset_metadata(
mysql->fields, mysql->field_count,
fields_ma_alloc_root)))
{
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return(1);
}
if (!(stmt->bind= (MYSQL_BIND *) ma_alloc_root(
fields_ma_alloc_root, stmt->field_count * sizeof(MYSQL_BIND))))
{
SET_CLIENT_STMT_ERROR(stmt, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return (1);
}
}
memset(stmt->bind, 0, stmt->field_count * sizeof(MYSQL_BIND));
stmt->bind_result_done= 0;
return(0);
} | O0 | c | madb_alloc_stmt_fields:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x340(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x37c(%rax)
jne 0x30d40
movl $0x0, -0x4(%rbp)
jmp 0x30ecb
movq -0x20(%rbp), %rax
movl 0x37c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x60(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x2f8(%rax)
je 0x30e9f
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x28d20
movq -0x20(%rbp), %rax
movq 0x2f8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x37c(%rax), %eax
movl %eax, %esi
movq -0x18(%rbp), %rdx
callq 0x230e0
movq -0x10(%rbp), %rcx
movq %rax, 0x58(%rcx)
cmpq $0x0, %rax
jne 0x30e0d
jmp 0x30d9e
movq -0x10(%rbp), %rax
movl $0x7d8, 0x108(%rax) # imm = 0x7D8
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x34472(%rip), %rax # 0x65230
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x34458(%rip), %rax # 0x65240
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x30ecb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
imulq $0x70, %rax, %rsi
callq 0x28ac0
movq -0x10(%rbp), %rcx
movq %rax, 0x78(%rcx)
cmpq $0x0, %rax
jne 0x30e9d
jmp 0x30e31
movq -0x10(%rbp), %rax
movl $0x7d8, 0x108(%rax) # imm = 0x7D8
movq -0x10(%rbp), %rdi
addq $0x30d, %rdi # imm = 0x30D
leaq 0x343df(%rip), %rax # 0x65230
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x312(%rax)
movq -0x10(%rbp), %rdi
addq $0x10c, %rdi # imm = 0x10C
leaq 0x343c5(%rip), %rax # 0x65240
movq 0x40(%rax), %rsi
movl $0x200, %edx # imm = 0x200
callq 0x13210
movq -0x10(%rbp), %rax
movb $0x0, 0x30b(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x30ecb
jmp 0x30e9f
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
imulq $0x70, %rax, %rdx
xorl %esi, %esi
callq 0x13250
movq -0x10(%rbp), %rax
movb $0x0, 0xe8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| madb_alloc_stmt_fields:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_10], rdi
mov rax, [rbp+var_10]
mov rax, [rax+340h]
mov [rbp+var_18], rax
mov rax, [rbp+var_10]
mov rax, [rax+38h]
mov [rbp+var_20], rax
mov rax, [rbp+var_20]
cmp dword ptr [rax+37Ch], 0
jnz short loc_30D40
mov [rbp+var_4], 0
jmp loc_30ECB
loc_30D40:
mov rax, [rbp+var_20]
mov ecx, [rax+37Ch]
mov rax, [rbp+var_10]
mov [rax+60h], ecx
mov rax, [rbp+var_20]
cmp qword ptr [rax+2F8h], 0
jz loc_30E9F
mov rdi, [rbp+var_18]
xor esi, esi
call ma_free_root
mov rax, [rbp+var_20]
mov rdi, [rax+2F8h]
mov rax, [rbp+var_20]
mov eax, [rax+37Ch]
mov esi, eax
mov rdx, [rbp+var_18]
call ma_duplicate_resultset_metadata
mov rcx, [rbp+var_10]
mov [rcx+58h], rax
cmp rax, 0
jnz short loc_30E0D
jmp short $+2
loc_30D9E:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7D8h
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+40h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp loc_30ECB
loc_30E0D:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_10]
mov eax, [rax+60h]
imul rsi, rax, 70h ; 'p'
call ma_alloc_root
mov rcx, [rbp+var_10]
mov [rcx+78h], rax
cmp rax, 0
jnz short loc_30E9D
jmp short $+2
loc_30E31:
mov rax, [rbp+var_10]
mov dword ptr [rax+108h], 7D8h
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+40h]
mov edx, 200h
call _strncpy
mov rax, [rbp+var_10]
mov byte ptr [rax+30Bh], 0
mov [rbp+var_4], 1
jmp short loc_30ECB
loc_30E9D:
jmp short $+2
loc_30E9F:
mov rax, [rbp+var_10]
mov rdi, [rax+78h]
mov rax, [rbp+var_10]
mov eax, [rax+60h]
imul rdx, rax, 70h ; 'p'
xor esi, esi
call _memset
mov rax, [rbp+var_10]
mov byte ptr [rax+0E8h], 0
mov [rbp+var_4], 0
loc_30ECB:
mov eax, [rbp+var_4]
add rsp, 20h
pop rbp
retn
| long long madb_alloc_stmt_fields(long long a1)
{
long long v1; // rax
char *v2; // rax
long long v4; // [rsp+0h] [rbp-20h]
_QWORD *v5; // [rsp+8h] [rbp-18h]
v5 = *(_QWORD **)(a1 + 832);
v4 = *(_QWORD *)(a1 + 56);
if ( *(_DWORD *)(v4 + 892) )
{
*(_DWORD *)(a1 + 96) = *(_DWORD *)(v4 + 892);
if ( !*(_QWORD *)(v4 + 760)
|| (ma_free_root(v5, 0),
v1 = ma_duplicate_resultset_metadata(*(_QWORD *)(v4 + 760), *(unsigned int *)(v4 + 892), (long long)v5),
(*(_QWORD *)(a1 + 88) = v1) != 0LL)
&& (v2 = ma_alloc_root((_QWORD **)v5, 112LL * *(unsigned int *)(a1 + 96)), (*(_QWORD *)(a1 + 120) = v2) != 0LL) )
{
memset(*(_QWORD *)(a1 + 120), 0LL, 112LL * *(unsigned int *)(a1 + 96));
*(_BYTE *)(a1 + 232) = 0;
return 0;
}
else
{
*(_DWORD *)(a1 + 264) = 2008;
strncpy(a1 + 781, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(a1 + 786) = 0;
strncpy(a1 + 268, client_errors[8], 512LL);
*(_BYTE *)(a1 + 779) = 0;
return 1;
}
}
else
{
return 0;
}
}
| madb_alloc_stmt_fields:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV qword ptr [RBP + -0x10],RDI
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x340]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x38]
MOV qword ptr [RBP + -0x20],RAX
MOV RAX,qword ptr [RBP + -0x20]
CMP dword ptr [RAX + 0x37c],0x0
JNZ 0x00130d40
MOV dword ptr [RBP + -0x4],0x0
JMP 0x00130ecb
LAB_00130d40:
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,dword ptr [RAX + 0x37c]
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x60],ECX
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX + 0x2f8],0x0
JZ 0x00130e9f
MOV RDI,qword ptr [RBP + -0x18]
XOR ESI,ESI
CALL 0x00128d20
MOV RAX,qword ptr [RBP + -0x20]
MOV RDI,qword ptr [RAX + 0x2f8]
MOV RAX,qword ptr [RBP + -0x20]
MOV EAX,dword ptr [RAX + 0x37c]
MOV ESI,EAX
MOV RDX,qword ptr [RBP + -0x18]
CALL 0x001230e0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x58],RAX
CMP RAX,0x0
JNZ 0x00130e0d
JMP 0x00130d9e
LAB_00130d9e:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7d8
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x165230]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x165240]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00130ecb
LAB_00130e0d:
MOV RDI,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x60]
IMUL RSI,RAX,0x70
CALL 0x00128ac0
MOV RCX,qword ptr [RBP + -0x10]
MOV qword ptr [RCX + 0x78],RAX
CMP RAX,0x0
JNZ 0x00130e9d
JMP 0x00130e31
LAB_00130e31:
MOV RAX,qword ptr [RBP + -0x10]
MOV dword ptr [RAX + 0x108],0x7d8
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x30d
LEA RAX,[0x165230]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x312],0x0
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x10c
LEA RAX,[0x165240]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x200
CALL 0x00113210
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0x30b],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00130ecb
LAB_00130e9d:
JMP 0x00130e9f
LAB_00130e9f:
MOV RAX,qword ptr [RBP + -0x10]
MOV RDI,qword ptr [RAX + 0x78]
MOV RAX,qword ptr [RBP + -0x10]
MOV EAX,dword ptr [RAX + 0x60]
IMUL RDX,RAX,0x70
XOR ESI,ESI
CALL 0x00113250
MOV RAX,qword ptr [RBP + -0x10]
MOV byte ptr [RAX + 0xe8],0x0
MOV dword ptr [RBP + -0x4],0x0
LAB_00130ecb:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x20
POP RBP
RET
|
int4 madb_alloc_stmt_fields(long param_1)
{
int8 uVar1;
long lVar2;
uVar1 = *(int8 *)(param_1 + 0x340);
lVar2 = *(long *)(param_1 + 0x38);
if (*(int *)(lVar2 + 0x37c) == 0) {
return 0;
}
*(int4 *)(param_1 + 0x60) = *(int4 *)(lVar2 + 0x37c);
if (*(long *)(lVar2 + 0x2f8) != 0) {
ma_free_root(uVar1,0);
lVar2 = ma_duplicate_resultset_metadata
(*(int8 *)(lVar2 + 0x2f8),*(int4 *)(lVar2 + 0x37c),uVar1);
*(long *)(param_1 + 0x58) = lVar2;
if (lVar2 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Client_run_out_of_memory_00165280,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
lVar2 = ma_alloc_root(uVar1);
*(long *)(param_1 + 0x78) = lVar2;
if (lVar2 == 0) {
*(int4 *)(param_1 + 0x108) = 0x7d8;
strncpy((char *)(param_1 + 0x30d),SQLSTATE_UNKNOWN,5);
*(int1 *)(param_1 + 0x312) = 0;
strncpy((char *)(param_1 + 0x10c),PTR_s_Client_run_out_of_memory_00165280,0x200);
*(int1 *)(param_1 + 0x30b) = 0;
return 1;
}
}
memset(*(void **)(param_1 + 0x78),0,(ulong)*(uint *)(param_1 + 0x60) * 0x70);
*(int1 *)(param_1 + 0xe8) = 0;
return 0;
}
| |
43,446 | make_space_for_directory | eloqsql/storage/maria/ma_blockrec.c | static inline my_bool
make_space_for_directory(MARIA_HA *info,
uchar *buff, uint max_entry,
uint count, uchar *first_dir, uint *empty_space,
uint *first_pos,
my_bool head_page)
{
uint length_needed= DIR_ENTRY_SIZE * count;
MARIA_SHARE *share= info->s;
/*
The following is not true only in the case and UNDO is used to reinsert
a row on a previously not used page
*/
if (likely(max_entry))
{
/* Check if there is place for the directory entry on the page */
*first_pos= uint2korr(first_dir) + uint2korr(first_dir + 2);
if ((uint) (first_dir - buff) < *first_pos + length_needed)
{
/* Create place for directory */
_ma_compact_block_page(share,
buff, max_entry - 1, 0,
head_page ? info->trn->min_read_from : 0,
head_page ? share->base.min_block_length : 0);
*first_pos= (uint2korr(first_dir) + uint2korr(first_dir + 2));
*empty_space= uint2korr(buff + EMPTY_SPACE_OFFSET);
if (*empty_space < length_needed)
{
/*
We should always have space, as we only come here for
UNDO of DELETE (in which case we know the row was on the
page before) or if the bitmap told us there was space on page
*/
DBUG_ASSERT(!maria_assert_if_crashed_table);
return(1);
}
}
}
else
*first_pos= PAGE_HEADER_SIZE(share);
/* Reduce directory entry size from free space size */
(*empty_space)-= length_needed;
buff[DIR_COUNT_OFFSET]= (uchar) (max_entry + count);
return(0);
} | O0 | c | make_space_for_directory:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb 0x18(%rbp), %al
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x20(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpl $0x0, -0x1c(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x803e8
movq -0x28(%rbp), %rax
movzwl (%rax), %ecx
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
addl %eax, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq 0x10(%rbp), %rcx
movl (%rcx), %ecx
addl -0x34(%rbp), %ecx
cmpl %ecx, %eax
jae 0x803e6
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movsbl 0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x8035b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x80(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x80363
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x80363
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movsbl 0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x80385
movq -0x40(%rbp), %rax
movq 0x3b8(%rax), %rax
movq %rax, -0x70(%rbp)
jmp 0x8038d
xorl %eax, %eax
movq %rax, -0x70(%rbp)
jmp 0x8038d
movq -0x68(%rbp), %r8
movl -0x44(%rbp), %edx
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rax
movl %eax, %r9d
xorl %ecx, %ecx
callq 0x748d0
movq -0x28(%rbp), %rax
movzwl (%rax), %ecx
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
addl %eax, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movzwl 0xa(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl (%rax), %eax
cmpl -0x34(%rbp), %eax
jae 0x803e4
jmp 0x803dc
jmp 0x803de
movb $0x1, -0x1(%rbp)
jmp 0x8041b
jmp 0x803e6
jmp 0x803fb
movq -0x40(%rbp), %rax
movl 0xc18(%rax), %ecx
addl $0xc, %ecx
movq 0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x34(%rbp), %edx
movq -0x30(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| make_space_for_directory:
push rbp
mov rbp, rsp
sub rsp, 70h
mov al, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov [rbp+var_28], r8
mov [rbp+var_30], r9
mov eax, [rbp+var_20]
shl eax, 2
mov [rbp+var_34], eax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_40], rax
cmp [rbp+var_1C], 0
setnz al
and al, 1
movzx eax, al
cdqe
cmp rax, 0
jz loc_803E8
mov rax, [rbp+var_28]
movzx ecx, word ptr [rax]
mov rax, [rbp+var_28]
movzx eax, word ptr [rax+2]
add ecx, eax
mov rax, [rbp+arg_0]
mov [rax], ecx
mov rax, [rbp+var_28]
mov rcx, [rbp+var_18]
sub rax, rcx
mov rcx, [rbp+arg_0]
mov ecx, [rcx]
add ecx, [rbp+var_34]
cmp eax, ecx
jnb loc_803E6
mov rax, [rbp+var_40]
mov [rbp+var_58], rax
mov rax, [rbp+var_18]
mov [rbp+var_50], rax
mov eax, [rbp+var_1C]
sub eax, 1
mov [rbp+var_44], eax
movsx eax, [rbp+arg_8]
cmp eax, 0
jz short loc_8035B
mov rax, [rbp+var_10]
mov rax, [rax+8]
mov rax, [rax+80h]
mov [rbp+var_60], rax
jmp short loc_80363
loc_8035B:
xor eax, eax
mov [rbp+var_60], rax
jmp short $+2
loc_80363:
mov rax, [rbp+var_60]
mov [rbp+var_68], rax
movsx eax, [rbp+arg_8]
cmp eax, 0
jz short loc_80385
mov rax, [rbp+var_40]
mov rax, [rax+3B8h]
mov [rbp+var_70], rax
jmp short loc_8038D
loc_80385:
xor eax, eax
mov [rbp+var_70], rax
jmp short $+2
loc_8038D:
mov r8, [rbp+var_68]
mov edx, [rbp+var_44]
mov rsi, [rbp+var_50]
mov rdi, [rbp+var_58]
mov rax, [rbp+var_70]
mov r9d, eax
xor ecx, ecx
call _ma_compact_block_page
mov rax, [rbp+var_28]
movzx ecx, word ptr [rax]
mov rax, [rbp+var_28]
movzx eax, word ptr [rax+2]
add ecx, eax
mov rax, [rbp+arg_0]
mov [rax], ecx
mov rax, [rbp+var_18]
movzx ecx, word ptr [rax+0Ah]
mov rax, [rbp+var_30]
mov [rax], ecx
mov rax, [rbp+var_30]
mov eax, [rax]
cmp eax, [rbp+var_34]
jnb short loc_803E4
jmp short $+2
loc_803DC:
jmp short $+2
loc_803DE:
mov [rbp+var_1], 1
jmp short loc_8041B
loc_803E4:
jmp short $+2
loc_803E6:
jmp short loc_803FB
loc_803E8:
mov rax, [rbp+var_40]
mov ecx, [rax+0C18h]
add ecx, 0Ch
mov rax, [rbp+arg_0]
mov [rax], ecx
loc_803FB:
mov edx, [rbp+var_34]
mov rax, [rbp+var_30]
mov ecx, [rax]
sub ecx, edx
mov [rax], ecx
mov eax, [rbp+var_1C]
add eax, [rbp+var_20]
mov cl, al
mov rax, [rbp+var_18]
mov [rax+8], cl
mov [rbp+var_1], 0
loc_8041B:
mov al, [rbp+var_1]
add rsp, 70h
pop rbp
retn
| char make_space_for_directory(
long long *a1,
long long a2,
int a3,
int a4,
unsigned __int16 *a5,
unsigned int *a6,
_DWORD *a7,
char a8)
{
unsigned long long v9; // [rsp+10h] [rbp-60h]
unsigned int v10; // [rsp+2Ch] [rbp-44h]
long long v11; // [rsp+30h] [rbp-40h]
unsigned int v12; // [rsp+3Ch] [rbp-34h]
char v15; // [rsp+50h] [rbp-20h]
char v16; // [rsp+54h] [rbp-1Ch]
v16 = a3;
v15 = a4;
v12 = 4 * a4;
v11 = *a1;
if ( !a3 )
{
*a7 = *(_DWORD *)(v11 + 3096) + 12;
LABEL_13:
*a6 -= v12;
*(_BYTE *)(a2 + 8) = v15 + v16;
return 0;
}
*a7 = a5[1] + *a5;
if ( (int)a5 - (int)a2 >= v12 + *a7 )
goto LABEL_13;
v10 = a3 - 1;
v9 = a8 ? *(_QWORD *)(a1[1] + 128) : 0LL;
if ( a8 )
ma_compact_block_page(v11, a2, v10, 0, v9, *(_QWORD *)(v11 + 952));
else
ma_compact_block_page(v11, a2, v10, 0, v9, 0);
*a7 = a5[1] + *a5;
*a6 = *(unsigned __int16 *)(a2 + 10);
if ( *a6 >= v12 )
goto LABEL_13;
return 1;
}
| make_space_for_directory:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV AL,byte ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV qword ptr [RBP + -0x28],R8
MOV qword ptr [RBP + -0x30],R9
MOV EAX,dword ptr [RBP + -0x20]
SHL EAX,0x2
MOV dword ptr [RBP + -0x34],EAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
CMP dword ptr [RBP + -0x1c],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
CDQE
CMP RAX,0x0
JZ 0x001803e8
MOV RAX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX + 0x2]
ADD ECX,EAX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x28]
MOV RCX,qword ptr [RBP + -0x18]
SUB RAX,RCX
MOV RCX,qword ptr [RBP + 0x10]
MOV ECX,dword ptr [RCX]
ADD ECX,dword ptr [RBP + -0x34]
CMP EAX,ECX
JNC 0x001803e6
MOV RAX,qword ptr [RBP + -0x40]
MOV qword ptr [RBP + -0x58],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x50],RAX
MOV EAX,dword ptr [RBP + -0x1c]
SUB EAX,0x1
MOV dword ptr [RBP + -0x44],EAX
MOVSX EAX,byte ptr [RBP + 0x18]
CMP EAX,0x0
JZ 0x0018035b
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x8]
MOV RAX,qword ptr [RAX + 0x80]
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00180363
LAB_0018035b:
XOR EAX,EAX
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00180363
LAB_00180363:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x68],RAX
MOVSX EAX,byte ptr [RBP + 0x18]
CMP EAX,0x0
JZ 0x00180385
MOV RAX,qword ptr [RBP + -0x40]
MOV RAX,qword ptr [RAX + 0x3b8]
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0018038d
LAB_00180385:
XOR EAX,EAX
MOV qword ptr [RBP + -0x70],RAX
JMP 0x0018038d
LAB_0018038d:
MOV R8,qword ptr [RBP + -0x68]
MOV EDX,dword ptr [RBP + -0x44]
MOV RSI,qword ptr [RBP + -0x50]
MOV RDI,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x70]
MOV R9D,EAX
XOR ECX,ECX
CALL 0x001748d0
MOV RAX,qword ptr [RBP + -0x28]
MOVZX ECX,word ptr [RAX]
MOV RAX,qword ptr [RBP + -0x28]
MOVZX EAX,word ptr [RAX + 0x2]
ADD ECX,EAX
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x18]
MOVZX ECX,word ptr [RAX + 0xa]
MOV RAX,qword ptr [RBP + -0x30]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
CMP EAX,dword ptr [RBP + -0x34]
JNC 0x001803e4
JMP 0x001803dc
LAB_001803dc:
JMP 0x001803de
LAB_001803de:
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0018041b
LAB_001803e4:
JMP 0x001803e6
LAB_001803e6:
JMP 0x001803fb
LAB_001803e8:
MOV RAX,qword ptr [RBP + -0x40]
MOV ECX,dword ptr [RAX + 0xc18]
ADD ECX,0xc
MOV RAX,qword ptr [RBP + 0x10]
MOV dword ptr [RAX],ECX
LAB_001803fb:
MOV EDX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [RAX]
SUB ECX,EDX
MOV dword ptr [RAX],ECX
MOV EAX,dword ptr [RBP + -0x1c]
ADD EAX,dword ptr [RBP + -0x20]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x18]
MOV byte ptr [RAX + 0x8],CL
MOV byte ptr [RBP + -0x1],0x0
LAB_0018041b:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x70
POP RBP
RET
|
int1
make_space_for_directory
(long *param_1,long param_2,int param_3,int param_4,ushort *param_5,uint *param_6,
int *param_7,char param_8)
{
long lVar1;
ulong local_78;
int8 local_68;
lVar1 = *param_1;
if (param_3 == 0) {
*param_7 = *(int *)(lVar1 + 0xc18) + 0xc;
}
else {
*param_7 = (uint)*param_5 + (uint)param_5[1];
if ((uint)((int)param_5 - (int)param_2) < (uint)(*param_7 + param_4 * 4)) {
if (param_8 == '\0') {
local_68 = 0;
local_78 = 0;
}
else {
local_68 = *(int8 *)(param_1[1] + 0x80);
local_78 = *(ulong *)(lVar1 + 0x3b8);
}
_ma_compact_block_page(lVar1,param_2,param_3 + -1,0,local_68,local_78 & 0xffffffff);
*param_7 = (uint)*param_5 + (uint)param_5[1];
*param_6 = (uint)*(ushort *)(param_2 + 10);
if (*param_6 < (uint)(param_4 * 4)) {
return 1;
}
}
}
*param_6 = *param_6 + param_4 * -4;
*(char *)(param_2 + 8) = (char)param_3 + (char)param_4;
return 0;
}
| |
43,447 | js_std_setenv | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_setenv(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *name, *value;
name = JS_ToCString(ctx, argv[0]);
if (!name)
return JS_EXCEPTION;
value = JS_ToCString(ctx, argv[1]);
if (!value) {
JS_FreeCString(ctx, name);
return JS_EXCEPTION;
}
setenv(name, value, TRUE);
JS_FreeCString(ctx, name);
JS_FreeCString(ctx, value);
return JS_UNDEFINED;
} | O0 | c | js_std_setenv:
subq $0x48, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x13520
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x13e25
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x13eaa
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
callq 0x13520
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x13e69
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x28b90
movl $0x0, 0x38(%rsp)
movq $0x6, 0x40(%rsp)
jmp 0x13eaa
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl $0x1, %edx
callq 0xe1c0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x28b90
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x28b90
movl $0x0, 0x38(%rsp)
movq $0x3, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nopl (%rax)
| js_std_setenv:
sub rsp, 48h
mov [rsp+48h+var_20], rsi
mov [rsp+48h+var_18], rdx
mov [rsp+48h+var_28], rdi
mov [rsp+48h+var_2C], ecx
mov [rsp+48h+var_38], r8
mov rdi, [rsp+48h+var_28]
mov rax, [rsp+48h+var_38]
mov rsi, [rax]
mov rdx, [rax+8]
call JS_ToCString
mov [rsp+48h+var_40], rax
cmp [rsp+48h+var_40], 0
jnz short loc_13E25
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp loc_13EAA
loc_13E25:
mov rdi, [rsp+48h+var_28]
mov rax, [rsp+48h+var_38]
mov rsi, [rax+10h]
mov rdx, [rax+18h]
call JS_ToCString
mov [rsp+48h+var_48], rax
cmp [rsp+48h+var_48], 0
jnz short loc_13E69
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_40]
call JS_FreeCString
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 6
jmp short loc_13EAA
loc_13E69:
mov rdi, [rsp+48h+var_40]
mov rsi, [rsp+48h+var_48]
mov edx, 1
call _setenv
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_40]
call JS_FreeCString
mov rdi, [rsp+48h+var_28]
mov rsi, [rsp+48h+var_48]
call JS_FreeCString
mov dword ptr [rsp+48h+var_10], 0
mov [rsp+48h+var_8], 3
loc_13EAA:
mov rax, [rsp+48h+var_10]
mov rdx, [rsp+48h+var_8]
add rsp, 48h
retn
| long long js_std_setenv(long long a1, long long a2, long long a3, long long a4, long long *a5)
{
long long v6; // [rsp+0h] [rbp-48h]
long long v7; // [rsp+8h] [rbp-40h]
long long v9; // [rsp+38h] [rbp-10h]
v7 = JS_ToCString(a1, *a5, a5[1]);
if ( v7 )
{
v6 = JS_ToCString(a1, a5[2], a5[3]);
if ( v6 )
{
setenv(v7, v6, 1LL);
JS_FreeCString(a1, v7);
JS_FreeCString(a1, v6);
}
else
{
JS_FreeCString(a1, v7);
}
LODWORD(v9) = 0;
}
else
{
LODWORD(v9) = 0;
}
return v9;
}
| js_std_setenv:
SUB RSP,0x48
MOV qword ptr [RSP + 0x28],RSI
MOV qword ptr [RSP + 0x30],RDX
MOV qword ptr [RSP + 0x20],RDI
MOV dword ptr [RSP + 0x1c],ECX
MOV qword ptr [RSP + 0x10],R8
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX]
MOV RDX,qword ptr [RAX + 0x8]
CALL 0x00113520
MOV qword ptr [RSP + 0x8],RAX
CMP qword ptr [RSP + 0x8],0x0
JNZ 0x00113e25
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00113eaa
LAB_00113e25:
MOV RDI,qword ptr [RSP + 0x20]
MOV RAX,qword ptr [RSP + 0x10]
MOV RSI,qword ptr [RAX + 0x10]
MOV RDX,qword ptr [RAX + 0x18]
CALL 0x00113520
MOV qword ptr [RSP],RAX
CMP qword ptr [RSP],0x0
JNZ 0x00113e69
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00128b90
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x6
JMP 0x00113eaa
LAB_00113e69:
MOV RDI,qword ptr [RSP + 0x8]
MOV RSI,qword ptr [RSP]
MOV EDX,0x1
CALL 0x0010e1c0
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP + 0x8]
CALL 0x00128b90
MOV RDI,qword ptr [RSP + 0x20]
MOV RSI,qword ptr [RSP]
CALL 0x00128b90
MOV dword ptr [RSP + 0x38],0x0
MOV qword ptr [RSP + 0x40],0x3
LAB_00113eaa:
MOV RAX,qword ptr [RSP + 0x38]
MOV RDX,qword ptr [RSP + 0x40]
ADD RSP,0x48
RET
|
int1 [16] js_std_setenv(int8 param_1)
{
int1 auVar1 [16];
char *__name;
char *__value;
int8 *in_R8;
int4 uStack_c;
int8 local_8;
__name = (char *)JS_ToCString(param_1,*in_R8,in_R8[1]);
if (__name == (char *)0x0) {
local_8 = 6;
}
else {
__value = (char *)JS_ToCString(param_1,in_R8[2],in_R8[3]);
if (__value == (char *)0x0) {
JS_FreeCString(param_1,__name);
local_8 = 6;
}
else {
setenv(__name,__value,1);
JS_FreeCString(param_1,__name);
JS_FreeCString(param_1,__value);
local_8 = 3;
}
}
auVar1._4_8_ = local_8;
auVar1._0_4_ = uStack_c;
auVar1._12_4_ = 0;
return auVar1 << 0x20;
}
| |
43,448 | js_std_setenv | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_std_setenv(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
const char *name, *value;
name = JS_ToCString(ctx, argv[0]);
if (!name)
return JS_EXCEPTION;
value = JS_ToCString(ctx, argv[1]);
if (!value) {
JS_FreeCString(ctx, name);
return JS_EXCEPTION;
}
setenv(name, value, TRUE);
JS_FreeCString(ctx, name);
JS_FreeCString(ctx, value);
return JS_UNDEFINED;
} | O1 | c | js_std_setenv:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdi, %rbx
movq (%r8), %rdx
movq 0x8(%r8), %rcx
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1ffe3
testq %rax, %rax
je 0x16542
movq %rax, %r14
movq 0x10(%r15), %rdx
movq 0x18(%r15), %rcx
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x1ffe3
testq %rax, %rax
je 0x1654a
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xe1c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x202c9
movl $0x3, %r15d
movq %r12, %r14
jmp 0x16550
movl $0x6, %r15d
jmp 0x1655b
movl $0x6, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x202c9
xorl %eax, %eax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| js_std_setenv:
push r15
push r14
push r12
push rbx
push rax
mov r15, r8
mov rbx, rdi
mov rdx, [r8]
mov rcx, [r8+8]
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_16542
mov r14, rax
mov rdx, [r15+10h]
mov rcx, [r15+18h]
mov rdi, rbx
xor esi, esi
xor r8d, r8d
call JS_ToCStringLen2
test rax, rax
jz short loc_1654A
mov r12, rax
mov rdi, r14
mov rsi, rax
mov edx, 1
call _setenv
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
mov r15d, 3
mov r14, r12
jmp short loc_16550
loc_16542:
mov r15d, 6
jmp short loc_1655B
loc_1654A:
mov r15d, 6
loc_16550:
mov rdi, rbx
mov rsi, r14
call JS_FreeCString
loc_1655B:
xor eax, eax
mov rdx, r15
add rsp, 8
pop rbx
pop r12
pop r14
pop r15
retn
| long long js_std_setenv(long long a1, long long a2, long long a3, long long a4, _QWORD *a5)
{
long long v6; // rax
long long v7; // r14
long long v8; // rax
long long v9; // r12
v6 = JS_ToCStringLen2(a1, 0LL, *a5, a5[1], 0LL);
if ( v6 )
{
v7 = v6;
v8 = JS_ToCStringLen2(a1, 0LL, a5[2], a5[3], 0LL);
if ( v8 )
{
v9 = v8;
setenv(v7, v8, 1LL);
JS_FreeCString(a1, v7);
v7 = v9;
}
JS_FreeCString(a1, v7);
}
return 0LL;
}
| js_std_setenv:
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
PUSH RAX
MOV R15,R8
MOV RBX,RDI
MOV RDX,qword ptr [R8]
MOV RCX,qword ptr [R8 + 0x8]
XOR ESI,ESI
XOR R8D,R8D
CALL 0x0011ffe3
TEST RAX,RAX
JZ 0x00116542
MOV R14,RAX
MOV RDX,qword ptr [R15 + 0x10]
MOV RCX,qword ptr [R15 + 0x18]
MOV RDI,RBX
XOR ESI,ESI
XOR R8D,R8D
CALL 0x0011ffe3
TEST RAX,RAX
JZ 0x0011654a
MOV R12,RAX
MOV RDI,R14
MOV RSI,RAX
MOV EDX,0x1
CALL 0x0010e1c0
MOV RDI,RBX
MOV RSI,R14
CALL 0x001202c9
MOV R15D,0x3
MOV R14,R12
JMP 0x00116550
LAB_00116542:
MOV R15D,0x6
JMP 0x0011655b
LAB_0011654a:
MOV R15D,0x6
LAB_00116550:
MOV RDI,RBX
MOV RSI,R14
CALL 0x001202c9
LAB_0011655b:
XOR EAX,EAX
MOV RDX,R15
ADD RSP,0x8
POP RBX
POP R12
POP R14
POP R15
RET
|
int1 [16] js_std_setenv(int8 param_1)
{
int1 auVar1 [16];
char *__name;
char *__value;
int8 *in_R8;
ulong uVar2;
__name = (char *)JS_ToCStringLen2(param_1,0,*in_R8,in_R8[1],0);
if (__name == (char *)0x0) {
uVar2 = 6;
}
else {
__value = (char *)JS_ToCStringLen2(param_1,0,in_R8[2],in_R8[3],0);
if (__value == (char *)0x0) {
uVar2 = 6;
}
else {
setenv(__name,__value,1);
JS_FreeCString(param_1,__name);
uVar2 = 3;
__name = __value;
}
JS_FreeCString(param_1,__name);
}
auVar1._8_8_ = 0;
auVar1._0_8_ = uVar2;
return auVar1 << 0x40;
}
| |
43,449 | google::protobuf::internal::LogMessage::Finish() | aimrt_mujoco_sim/_deps/protobuf-src/src/google/protobuf/stubs/common.cc | void LogMessage::Finish() {
bool suppress = false;
if (level_ != LOGLEVEL_FATAL) {
suppress = log_silencer_count_ > 0;
}
if (!suppress) {
log_handler_(level_, filename_, line_, message_);
}
if (level_ == LOGLEVEL_FATAL) {
#if PROTOBUF_USE_EXCEPTIONS
throw FatalException(filename_, line_, message_);
#else
abort();
#endif
}
} | O0 | cpp | google::protobuf::internal::LogMessage::Finish():
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x2f(%rsp)
cmpl $0x3, (%rax)
je 0x23875
leaq 0x2598bc(%rip), %rdi # 0x27d120
callq 0x23ea0
cmpl $0x0, %eax
setg %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x23897
movq 0x10(%rsp), %rcx
movq 0x258bd8(%rip), %rax # 0x27c460
movl (%rcx), %edi
movq 0x8(%rcx), %rsi
movl 0x10(%rcx), %edx
addq $0x18, %rcx
callq *%rax
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x238ff
movl $0x38, %edi
callq 0x131d0
movq 0x10(%rsp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rcx), %rsi
movl 0x10(%rcx), %edx
addq $0x18, %rcx
callq 0x23f40
jmp 0x238cd
movq 0x8(%rsp), %rdi
leaq 0x25412f(%rip), %rsi # 0x277a08
leaq 0x190(%rip), %rdx # 0x23a70
callq 0x13720
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x13340
jmp 0x23904
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x13750
nop
| _ZN6google8protobuf8internal10LogMessage6FinishEv:
sub rsp, 38h
mov [rsp+38h+var_8], rdi
mov rax, [rsp+38h+var_8]
mov [rsp+38h+var_28], rax
mov [rsp+38h+var_9], 0
cmp dword ptr [rax], 3
jz short loc_23875
lea rdi, _ZN6google8protobuf8internalL19log_silencer_count_E; google::protobuf::internal::log_silencer_count_
call _ZNKSt13__atomic_baseIiEcviEv; std::__atomic_base<int>::operator int(void)
cmp eax, 0
setnle al
and al, 1
mov [rsp+38h+var_9], al
loc_23875:
test [rsp+38h+var_9], 1
jnz short loc_23897
mov rcx, [rsp+38h+var_28]
mov rax, cs:_ZN6google8protobuf8internalL12log_handler_B5cxx11E; google::protobuf::internal::log_handler_
mov edi, [rcx]
mov rsi, [rcx+8]
mov edx, [rcx+10h]
add rcx, 18h
call rax ; google::protobuf::internal::DefaultLogHandler(google::protobuf::LogLevel,char const*,int,std::string const&); google::protobuf::internal::DefaultLogHandler(google::protobuf::LogLevel,char const*,int,std::string const&)
loc_23897:
mov rax, [rsp+38h+var_28]
cmp dword ptr [rax], 3
jnz short loc_238FF
mov edi, 38h ; '8'; thrown_size
call ___cxa_allocate_exception
mov rcx, [rsp+38h+var_28]
mov rdi, rax
mov rax, rdi
mov [rsp+38h+var_30], rax
mov rsi, [rcx+8]
mov edx, [rcx+10h]
add rcx, 18h
call _ZN6google8protobuf14FatalExceptionC2EPKciRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; google::protobuf::FatalException::FatalException(char const*,int,std::string const&)
jmp short $+2
loc_238CD:
mov rdi, [rsp+38h+var_30]; void *
lea rsi, _ZTIN6google8protobuf14FatalExceptionE; lptinfo
lea rdx, _ZN6google8protobuf14FatalExceptionD2Ev; void (*)(void *)
call ___cxa_throw
mov rdi, [rsp+38h+var_30]; void *
mov rcx, rax
mov eax, edx
mov [rsp+38h+var_18], rcx
mov [rsp+38h+var_1C], eax
call ___cxa_free_exception
jmp short loc_23904
loc_238FF:
add rsp, 38h
retn
loc_23904:
mov rdi, [rsp+38h+var_18]
call __Unwind_Resume
| google::protobuf::internal::LogMessage * google::protobuf::internal::LogMessage::Finish(
google::protobuf::internal::LogMessage *this)
{
google::protobuf::internal::LogMessage *result; // rax
int v2; // r8d
int v3; // r9d
void *exception; // [rsp+8h] [rbp-30h]
bool v5; // [rsp+2Fh] [rbp-9h]
v5 = 0;
if ( *(_DWORD *)this != 3 )
v5 = (int)std::__atomic_base<int>::operator int(&google::protobuf::internal::log_silencer_count_) > 0;
if ( !v5 )
google::protobuf::internal::log_handler_[abi:cxx11](
*(_DWORD *)this,
*((const char **)this + 1),
*((_DWORD *)this + 4),
(long long)this + 24);
result = this;
if ( *(_DWORD *)this == 3 )
{
exception = __cxa_allocate_exception(0x38uLL);
google::protobuf::FatalException::FatalException(
(_DWORD)exception,
*((_QWORD *)this + 1),
*((_DWORD *)this + 4),
(_DWORD)this + 24,
v2,
v3);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'google::protobuf::FatalException,
google::protobuf::FatalException::~FatalException);
}
return result;
}
| Finish:
SUB RSP,0x38
MOV qword ptr [RSP + 0x30],RDI
MOV RAX,qword ptr [RSP + 0x30]
MOV qword ptr [RSP + 0x10],RAX
MOV byte ptr [RSP + 0x2f],0x0
CMP dword ptr [RAX],0x3
JZ 0x00123875
LEA RDI,[0x37d120]
CALL 0x00123ea0
CMP EAX,0x0
SETG AL
AND AL,0x1
MOV byte ptr [RSP + 0x2f],AL
LAB_00123875:
TEST byte ptr [RSP + 0x2f],0x1
JNZ 0x00123897
MOV RCX,qword ptr [RSP + 0x10]
MOV RAX,qword ptr [0x0037c460]
MOV EDI,dword ptr [RCX]
MOV RSI,qword ptr [RCX + 0x8]
MOV EDX,dword ptr [RCX + 0x10]
ADD RCX,0x18
CALL RAX
LAB_00123897:
MOV RAX,qword ptr [RSP + 0x10]
CMP dword ptr [RAX],0x3
JNZ 0x001238ff
MOV EDI,0x38
CALL 0x001131d0
MOV RCX,qword ptr [RSP + 0x10]
MOV RDI,RAX
MOV RAX,RDI
MOV qword ptr [RSP + 0x8],RAX
MOV RSI,qword ptr [RCX + 0x8]
MOV EDX,dword ptr [RCX + 0x10]
ADD RCX,0x18
LAB_001238c6:
CALL 0x00123f40
LAB_001238cb:
JMP 0x001238cd
LAB_001238cd:
MOV RDI,qword ptr [RSP + 0x8]
LEA RSI,[0x377a08]
LEA RDX,[0x123a70]
CALL 0x00113720
LAB_001238ff:
ADD RSP,0x38
RET
|
/* google::protobuf::internal::LogMessage::Finish() */
void __thiscall google::protobuf::internal::LogMessage::Finish(LogMessage *this)
{
bool bVar1;
int iVar2;
FatalException *this_00;
bVar1 = false;
if (*(int *)this != 3) {
iVar2 = std::__atomic_base::operator_cast_to_int((__atomic_base *)&log_silencer_count_);
bVar1 = 0 < iVar2;
}
if (!bVar1) {
(*(code *)log_handler__abi_cxx11_)
(*(int4 *)this,*(int8 *)(this + 8),*(int4 *)(this + 0x10),
this + 0x18);
}
if (*(int *)this == 3) {
this_00 = (FatalException *)__cxa_allocate_exception(0x38);
/* try { // try from 001238c6 to 001238ca has its CatchHandler @ 001238e5 */
FatalException::FatalException
(this_00,*(char **)(this + 8),*(int *)(this + 0x10),(string *)(this + 0x18));
/* WARNING: Subroutine does not return */
__cxa_throw(this_00,&FatalException::typeinfo,FatalException::~FatalException);
}
return;
}
| |
43,450 | boss_bug_trio::JustDied(Unit*) | SylCore-WoTLK/src/server/scripts/Kalimdor/TempleOfAhnQiraj/boss_bug_trio.cpp | void JustDied(Unit* killer) override
{
instance->SetData(DATA_BUG_TRIO_DEATH, 1);
if (instance->GetData(DATA_BUG_TRIO_DEATH) < 3)
{
me->RemoveDynamicFlag(UNIT_DYNFLAG_LOOTABLE);
DoFinalSpell();
Talk(EMOTE_DEVOURED);
me->DespawnOrUnsummon(3000);
return;
}
BossAI::JustDied(killer);
} | O3 | cpp | boss_bug_trio::JustDied(Unit*):
pushq %rbx
movq %rdi, %rbx
movq 0x170(%rdi), %rdi
movq (%rdi), %rax
movl $0xd, %esi
movl $0x1, %edx
callq *0x78(%rax)
movq 0x170(%rbx), %rdi
movq (%rdi), %rax
movl $0xd, %esi
callq *0x70(%rax)
cmpl $0x2, %eax
ja 0x5c5a02
movq 0x120(%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0x5c61e2
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x91ea54
movq 0x120(%rbx), %rdi
movl $0xbb8, %esi # imm = 0xBB8
xorl %edx, %edx
popq %rbx
jmp 0xa6369c
movq %rbx, %rdi
popq %rbx
jmp 0x926656
nop
| _ZN13boss_bug_trio8JustDiedEP4Unit:
push rbx
mov rbx, rdi
mov rdi, [rdi+170h]
mov rax, [rdi]
mov esi, 0Dh
mov edx, 1
call qword ptr [rax+78h]
mov rdi, [rbx+170h]
mov rax, [rdi]
mov esi, 0Dh
call qword ptr [rax+70h]
cmp eax, 2
ja short loc_5C5A02
mov rdi, [rbx+120h]
mov rax, [rdi]
mov esi, 1
call qword ptr [rax+38h]
mov rdi, rbx; this
call _ZN13boss_bug_trio12DoFinalSpellEv; boss_bug_trio::DoFinalSpell(void)
mov rdi, rbx
xor esi, esi
xor edx, edx
xor ecx, ecx
call _ZN10CreatureAI4TalkEhPK11WorldObjectNSt6chrono8durationIlSt5ratioILl1ELl1000EEEE; CreatureAI::Talk(uchar,WorldObject const*,std::chrono::duration<long,std::ratio<1l,1000l>>)
mov rdi, [rbx+120h]
mov esi, 0BB8h
xor edx, edx
pop rbx
jmp _ZN8Creature17DespawnOrUnsummonENSt6chrono8durationIlSt5ratioILl1ELl1000EEEENS1_IlS2_ILl1ELl1EEEE; Creature::DespawnOrUnsummon(std::chrono::duration<long,std::ratio<1l,1000l>>,std::chrono::duration<long,std::ratio<1l,1l>>)
loc_5C5A02:
mov rdi, rbx; this
pop rbx
jmp _ZN6BossAI9_JustDiedEv; BossAI::_JustDied(void)
| void boss_bug_trio::JustDied(boss_bug_trio *this, Unit *a2, double a3)
{
(*(void ( **)(_QWORD, long long, long long))(**((_QWORD **)this + 46) + 120LL))(
*((_QWORD *)this + 46),
13LL,
1LL);
if ( (*(unsigned int ( **)(_QWORD, long long))(**((_QWORD **)this + 46) + 112LL))(
*((_QWORD *)this + 46),
13LL) > 2 )
{
BossAI::_JustDied(this);
}
else
{
(*(void ( **)(_QWORD, long long))(**((_QWORD **)this + 36) + 56LL))(*((_QWORD *)this + 36), 1LL);
boss_bug_trio::DoFinalSpell(this);
CreatureAI::Talk(this, 0LL, 0LL, 0LL);
Creature::DespawnOrUnsummon(*((_QWORD *)this + 36), 3000LL, 0LL, a3);
}
}
| PSendSysMessage<char_const(&)[11],char_const(&)[44],unsigned_int&>:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV RBP,R8
MOV R12,RCX
MOV R13,RDX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RDI]
CALL qword ptr [RAX + 0x50]
TEST AL,AL
JZ 0x005c5a1b
MOV RDI,R14
CALL 0x0055c4b0
MOV R15,RAX
MOV EAX,dword ptr [RBP]
LEA R8,[RSP + 0x40]
MOV qword ptr [R8],R13
MOV qword ptr [R8 + 0x10],R12
MOV qword ptr [R8 + 0x20],RAX
LAB_005c59d9:
MOV RDI,RSP
MOV ECX,0x2cc
MOV RSI,R14
MOV RDX,R15
CALL 0x011b97cb
LAB_005c59ec:
MOV RDX,qword ptr [RSP]
MOV RSI,qword ptr [RSP + 0x8]
MOV RAX,qword ptr [RBX]
LAB_005c59f8:
MOV RDI,RBX
XOR ECX,ECX
CALL qword ptr [RAX + 0x18]
LAB_005c5a00:
LEA RAX,[RSP + 0x10]
MOV RDI,qword ptr [RAX + -0x10]
CMP RDI,RAX
JZ 0x005c5a1b
MOV RSI,qword ptr [RSP + 0x10]
INC RSI
CALL 0x011a22f0
LAB_005c5a1b:
ADD RSP,0x78
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
/* void ChatHandler::PSendSysMessage<char const (&) [11], char const (&) [44], unsigned int&>(char
const*, char const (&) [11], char const (&) [44], unsigned int&) */
void __thiscall
ChatHandler::PSendSysMessage<char_const(&)[11],char_const(&)[44],unsigned_int&>
(ChatHandler *this,char *param_1,char *param_2,char *param_3,uint *param_4)
{
char cVar1;
size_t sVar2;
long *local_a8;
int8 local_a0;
long local_98 [6];
char *local_68;
char *local_58;
ulong local_48;
cVar1 = (**(code **)(*(long *)this + 0x50))();
if (cVar1 != '\0') {
sVar2 = strlen(param_1);
local_48 = (ulong)*param_4;
local_68 = param_2;
local_58 = param_3;
/* try { // try from 005c59d9 to 005c59eb has its CatchHandler @ 005c5a50 */
fmt::v10::vformat_abi_cxx11_(&local_a8,param_1,sVar2,0x2cc);
/* try { // try from 005c59f8 to 005c59ff has its CatchHandler @ 005c5a2a */
(**(code **)(*(long *)this + 0x18))(this,local_a0,local_a8,0);
if (local_a8 != local_98) {
/* WARNING: Subroutine does not return */
operator_delete(local_a8,local_98[0] + 1);
}
}
return;
}
| |
43,451 | my_open_parent_dir_nosymlinks | eloqsql/mysys/my_symlink.c | const char *my_open_parent_dir_nosymlinks(const char *pathname, int *pdfd)
{
char buf[FN_REFLEN + 1];
char *s= buf, *e= buf+1, *end= strnmov(buf, pathname, sizeof(buf));
int fd, dfd= -1;
if (*end)
{
errno= ENAMETOOLONG;
return NULL;
}
if (*s != '/') /* not an absolute path */
{
errno= ENOENT;
return NULL;
}
for (;;)
{
if (*e == '/') /* '//' in the path */
{
errno= ENOENT;
goto err;
}
while (*e && *e != '/')
e++;
*e= 0;
if (!memcmp(s, ".", 2) || !memcmp(s, "..", 3))
{
errno= ENOENT;
goto err;
}
if (++e >= end)
{
*pdfd= dfd;
return pathname + (s - buf);
}
fd = openat(dfd, s, O_NOFOLLOW | O_PATH | O_CLOEXEC);
if (fd < 0)
goto err;
if (dfd >= 0)
close(dfd);
dfd= fd;
s= e;
}
err:
if (dfd >= 0)
close(dfd);
return NULL;
} | O0 | c | my_open_parent_dir_nosymlinks:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x220(%rbp)
movq %rsi, -0x228(%rbp)
leaq -0x210(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
leaq -0x210(%rbp), %rdi
movq -0x220(%rbp), %rsi
movl $0x201, %edx # imm = 0x201
callq 0x12b6a0
movq %rax, -0x240(%rbp)
movl $0xffffffff, -0x248(%rbp) # imm = 0xFFFFFFFF
movq -0x240(%rbp), %rax
cmpb $0x0, (%rax)
je 0xe24c6
callq 0x3a9f0
movl $0x24, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0xe267a
movq -0x230(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0xe24f0
callq 0x3a9f0
movl $0x2, (%rax)
movq $0x0, -0x218(%rbp)
jmp 0xe267a
jmp 0xe24f2
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0xe2511
callq 0x3a9f0
movl $0x2, (%rax)
jmp 0xe265b
jmp 0xe2513
movq -0x238(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x249(%rbp)
je 0xe2540
movq -0x238(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x249(%rbp)
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0xe254c
jmp 0xe2560
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
jmp 0xe2513
movq -0x238(%rbp), %rax
movb $0x0, (%rax)
movq -0x230(%rbp), %rax
movw (%rax), %ax
subw $0x2e, %ax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xe25a0
movq -0x230(%rbp), %rdi
leaq 0x4bea2(%rip), %rsi # 0x12e433
movl $0x3, %edx
callq 0x3ab20
cmpl $0x0, %eax
jne 0xe25b0
callq 0x3a9f0
movl $0x2, (%rax)
jmp 0xe265b
movq -0x238(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x238(%rbp)
cmpq -0x240(%rbp), %rax
jb 0xe25fe
movl -0x248(%rbp), %ecx
movq -0x228(%rbp), %rax
movl %ecx, (%rax)
movq -0x220(%rbp), %rax
movq -0x230(%rbp), %rcx
leaq -0x210(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x218(%rbp)
jmp 0xe267a
movl -0x248(%rbp), %edi
movq -0x230(%rbp), %rsi
movl $0x2a0000, %edx # imm = 0x2A0000
movb $0x0, %al
callq 0x3a6d0
movl %eax, -0x244(%rbp)
cmpl $0x0, -0x244(%rbp)
jge 0xe2628
jmp 0xe265b
cmpl $0x0, -0x248(%rbp)
jl 0xe263c
movl -0x248(%rbp), %edi
callq 0x3a210
movl -0x244(%rbp), %eax
movl %eax, -0x248(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0x230(%rbp)
jmp 0xe24f2
cmpl $0x0, -0x248(%rbp)
jl 0xe266f
movl -0x248(%rbp), %edi
callq 0x3a210
movq $0x0, -0x218(%rbp)
movq -0x218(%rbp), %rax
movq %rax, -0x258(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xe26aa
movq -0x258(%rbp), %rax
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
callq 0x3a2a0
nop
| my_open_parent_dir_nosymlinks:
push rbp
mov rbp, rsp
sub rsp, 260h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_220], rdi
mov [rbp+var_228], rsi
lea rax, [rbp+var_210]
mov [rbp+var_230], rax
lea rax, [rbp+var_210]
add rax, 1
mov [rbp+var_238], rax
lea rdi, [rbp+var_210]
mov rsi, [rbp+var_220]
mov edx, 201h
call strnmov
mov [rbp+var_240], rax
mov [rbp+var_248], 0FFFFFFFFh
mov rax, [rbp+var_240]
cmp byte ptr [rax], 0
jz short loc_E24C6
call ___errno_location
mov dword ptr [rax], 24h ; '$'
mov [rbp+var_218], 0
jmp loc_E267A
loc_E24C6:
mov rax, [rbp+var_230]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jz short loc_E24F0
call ___errno_location
mov dword ptr [rax], 2
mov [rbp+var_218], 0
jmp loc_E267A
loc_E24F0:
jmp short $+2
loc_E24F2:
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
jnz short loc_E2511
call ___errno_location
mov dword ptr [rax], 2
jmp loc_E265B
loc_E2511:
jmp short $+2
loc_E2513:
mov rax, [rbp+var_238]
movsx ecx, byte ptr [rax]
xor eax, eax
cmp ecx, 0
mov [rbp+var_249], al
jz short loc_E2540
mov rax, [rbp+var_238]
movsx eax, byte ptr [rax]
cmp eax, 2Fh ; '/'
setnz al
mov [rbp+var_249], al
loc_E2540:
mov al, [rbp+var_249]
test al, 1
jnz short loc_E254C
jmp short loc_E2560
loc_E254C:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
jmp short loc_E2513
loc_E2560:
mov rax, [rbp+var_238]
mov byte ptr [rax], 0
mov rax, [rbp+var_230]
mov ax, [rax]
sub ax, 2Eh ; '.'
setnz al
movzx eax, al
cmp eax, 0
jz short loc_E25A0
mov rdi, [rbp+var_230]
lea rsi, aCreatingATestD+21h; ".."
mov edx, 3
call _memcmp
cmp eax, 0
jnz short loc_E25B0
loc_E25A0:
call ___errno_location
mov dword ptr [rax], 2
jmp loc_E265B
loc_E25B0:
mov rax, [rbp+var_238]
add rax, 1
mov [rbp+var_238], rax
cmp rax, [rbp+var_240]
jb short loc_E25FE
mov ecx, [rbp+var_248]
mov rax, [rbp+var_228]
mov [rax], ecx
mov rax, [rbp+var_220]
mov rcx, [rbp+var_230]
lea rdx, [rbp+var_210]
sub rcx, rdx
add rax, rcx
mov [rbp+var_218], rax
jmp short loc_E267A
loc_E25FE:
mov edi, [rbp+var_248]
mov rsi, [rbp+var_230]
mov edx, offset unk_2A0000
mov al, 0
call _openat64
mov [rbp+var_244], eax
cmp [rbp+var_244], 0
jge short loc_E2628
jmp short loc_E265B
loc_E2628:
cmp [rbp+var_248], 0
jl short loc_E263C
mov edi, [rbp+var_248]
call _close
loc_E263C:
mov eax, [rbp+var_244]
mov [rbp+var_248], eax
mov rax, [rbp+var_238]
mov [rbp+var_230], rax
jmp loc_E24F2
loc_E265B:
cmp [rbp+var_248], 0
jl short loc_E266F
mov edi, [rbp+var_248]
call _close
loc_E266F:
mov [rbp+var_218], 0
loc_E267A:
mov rax, [rbp+var_218]
mov [rbp+var_258], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_E26AA
mov rax, [rbp+var_258]
add rsp, 260h
pop rbp
retn
loc_E26AA:
call ___stack_chk_fail
| long long my_open_parent_dir_nosymlinks(long long a1, unsigned int *a2)
{
const char *v2; // rdi
long long v3; // rcx
bool v5; // [rsp+17h] [rbp-249h]
unsigned int v6; // [rsp+18h] [rbp-248h]
int v7; // [rsp+1Ch] [rbp-244h]
const char *v8; // [rsp+20h] [rbp-240h]
const char *v9; // [rsp+28h] [rbp-238h]
const char *v10; // [rsp+30h] [rbp-230h]
char v13; // [rsp+50h] [rbp-210h] BYREF
_BYTE v14[527]; // [rsp+51h] [rbp-20Fh] BYREF
*(_QWORD *)&v14[519] = __readfsqword(0x28u);
v10 = &v13;
v9 = v14;
v2 = &v13;
v8 = (const char *)strnmov(&v13, a1, 513LL);
v6 = -1;
if ( *v8 )
{
*(_DWORD *)__errno_location(&v13) = 36;
return 0LL;
}
else if ( v13 == 47 )
{
while ( *v9 != 47 )
{
while ( 1 )
{
v3 = (unsigned int)*v9;
v5 = 0;
if ( *v9 )
v5 = *v9 != 47;
if ( !v5 )
break;
++v9;
}
*v9 = 0;
if ( *(_WORD *)v10 == 46 )
break;
v2 = v10;
if ( !(unsigned int)strcmp(v10, "..") )
break;
if ( ++v9 >= v8 )
{
*a2 = v6;
return v10 - &v13 + a1;
}
v2 = (const char *)v6;
v7 = openat64(v6, v10, &unk_2A0000, v3);
if ( v7 < 0 )
goto LABEL_20;
if ( (v6 & 0x80000000) == 0 )
{
v2 = (const char *)v6;
close(v6);
}
v6 = v7;
v10 = v9;
}
*(_DWORD *)__errno_location(v2) = 2;
LABEL_20:
if ( (v6 & 0x80000000) == 0 )
close(v6);
return 0LL;
}
else
{
*(_DWORD *)__errno_location(&v13) = 2;
return 0LL;
}
}
| my_open_parent_dir_nosymlinks:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x260
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x220],RDI
MOV qword ptr [RBP + -0x228],RSI
LEA RAX,[RBP + -0x210]
MOV qword ptr [RBP + -0x230],RAX
LEA RAX,[RBP + -0x210]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
LEA RDI,[RBP + -0x210]
MOV RSI,qword ptr [RBP + -0x220]
MOV EDX,0x201
CALL 0x0022b6a0
MOV qword ptr [RBP + -0x240],RAX
MOV dword ptr [RBP + -0x248],0xffffffff
MOV RAX,qword ptr [RBP + -0x240]
CMP byte ptr [RAX],0x0
JZ 0x001e24c6
CALL 0x0013a9f0
MOV dword ptr [RAX],0x24
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001e267a
LAB_001e24c6:
MOV RAX,qword ptr [RBP + -0x230]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JZ 0x001e24f0
CALL 0x0013a9f0
MOV dword ptr [RAX],0x2
MOV qword ptr [RBP + -0x218],0x0
JMP 0x001e267a
LAB_001e24f0:
JMP 0x001e24f2
LAB_001e24f2:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
JNZ 0x001e2511
CALL 0x0013a9f0
MOV dword ptr [RAX],0x2
JMP 0x001e265b
LAB_001e2511:
JMP 0x001e2513
LAB_001e2513:
MOV RAX,qword ptr [RBP + -0x238]
MOVSX ECX,byte ptr [RAX]
XOR EAX,EAX
CMP ECX,0x0
MOV byte ptr [RBP + -0x249],AL
JZ 0x001e2540
MOV RAX,qword ptr [RBP + -0x238]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2f
SETNZ AL
MOV byte ptr [RBP + -0x249],AL
LAB_001e2540:
MOV AL,byte ptr [RBP + -0x249]
TEST AL,0x1
JNZ 0x001e254c
JMP 0x001e2560
LAB_001e254c:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
JMP 0x001e2513
LAB_001e2560:
MOV RAX,qword ptr [RBP + -0x238]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x230]
MOV AX,word ptr [RAX]
SUB AX,0x2e
SETNZ AL
MOVZX EAX,AL
CMP EAX,0x0
JZ 0x001e25a0
MOV RDI,qword ptr [RBP + -0x230]
LEA RSI,[0x22e433]
MOV EDX,0x3
CALL 0x0013ab20
CMP EAX,0x0
JNZ 0x001e25b0
LAB_001e25a0:
CALL 0x0013a9f0
MOV dword ptr [RAX],0x2
JMP 0x001e265b
LAB_001e25b0:
MOV RAX,qword ptr [RBP + -0x238]
ADD RAX,0x1
MOV qword ptr [RBP + -0x238],RAX
CMP RAX,qword ptr [RBP + -0x240]
JC 0x001e25fe
MOV ECX,dword ptr [RBP + -0x248]
MOV RAX,qword ptr [RBP + -0x228]
MOV dword ptr [RAX],ECX
MOV RAX,qword ptr [RBP + -0x220]
MOV RCX,qword ptr [RBP + -0x230]
LEA RDX,[RBP + -0x210]
SUB RCX,RDX
ADD RAX,RCX
MOV qword ptr [RBP + -0x218],RAX
JMP 0x001e267a
LAB_001e25fe:
MOV EDI,dword ptr [RBP + -0x248]
MOV RSI,qword ptr [RBP + -0x230]
MOV EDX,0x2a0000
MOV AL,0x0
CALL 0x0013a6d0
MOV dword ptr [RBP + -0x244],EAX
CMP dword ptr [RBP + -0x244],0x0
JGE 0x001e2628
JMP 0x001e265b
LAB_001e2628:
CMP dword ptr [RBP + -0x248],0x0
JL 0x001e263c
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x0013a210
LAB_001e263c:
MOV EAX,dword ptr [RBP + -0x244]
MOV dword ptr [RBP + -0x248],EAX
MOV RAX,qword ptr [RBP + -0x238]
MOV qword ptr [RBP + -0x230],RAX
JMP 0x001e24f2
LAB_001e265b:
CMP dword ptr [RBP + -0x248],0x0
JL 0x001e266f
MOV EDI,dword ptr [RBP + -0x248]
CALL 0x0013a210
LAB_001e266f:
MOV qword ptr [RBP + -0x218],0x0
LAB_001e267a:
MOV RAX,qword ptr [RBP + -0x218]
MOV qword ptr [RBP + -0x258],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x001e26aa
MOV RAX,qword ptr [RBP + -0x258]
ADD RSP,0x260
POP RBP
RET
LAB_001e26aa:
CALL 0x0013a2a0
|
long my_open_parent_dir_nosymlinks(long param_1,int *param_2)
{
int iVar1;
short *psVar2;
int *piVar3;
long in_FS_OFFSET;
bool bVar4;
int local_250;
short *local_240;
short *local_238;
long local_220;
int1 local_218 [520];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_238 = (short *)local_218;
local_240 = (short *)(local_218 + 1);
psVar2 = (short *)strnmov(local_218,param_1,0x201);
local_250 = -1;
if ((char)*psVar2 == '\0') {
iVar1 = local_250;
if (local_218[0] == '/') {
while (local_250 = iVar1, (char)*local_240 != '/') {
while( true ) {
bVar4 = false;
if ((char)*local_240 != '\0') {
bVar4 = (char)*local_240 != '/';
}
if (!bVar4) break;
local_240 = (short *)((long)local_240 + 1);
}
*(char *)local_240 = '\0';
if ((*local_238 == 0x2e) || (iVar1 = memcmp(local_238,"..",3), iVar1 == 0)) {
piVar3 = __errno_location();
*piVar3 = 2;
goto LAB_001e265b;
}
local_240 = (short *)((long)local_240 + 1);
if (psVar2 <= local_240) {
*param_2 = local_250;
local_220 = (long)local_238 + (param_1 - (long)local_218);
goto LAB_001e267a;
}
iVar1 = openat64(local_250,(char *)local_238,0x2a0000);
if (iVar1 < 0) goto LAB_001e265b;
local_238 = local_240;
if (-1 < local_250) {
close(local_250);
}
}
piVar3 = __errno_location();
*piVar3 = 2;
LAB_001e265b:
if (-1 < local_250) {
close(local_250);
}
local_220 = 0;
}
else {
piVar3 = __errno_location();
*piVar3 = 2;
local_220 = 0;
}
}
else {
piVar3 = __errno_location();
*piVar3 = 0x24;
local_220 = 0;
}
LAB_001e267a:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_220;
}
| |
43,452 | ggml_set_f32_1d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_BF16:
{
((ggml_bf16_t *)(tensor->data))[i] = GGML_FP32_TO_BF16(value);
} break;
case GGML_TYPE_F32:
{
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O0 | c | ggml_set_f32_1d:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
vmovss %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd280
testb $0x1, %al
jne 0x10246
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0xd560
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
leaq -0x30(%rbp), %rdx
leaq -0x30(%rbp), %rcx
addq $0x8, %rcx
leaq -0x30(%rbp), %r8
addq $0x10, %r8
leaq -0x30(%rbp), %r9
addq $0x18, %r9
callq 0xd850
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %eax, %r8d
vmovss -0x10(%rbp), %xmm0
callq 0xd470
jmp 0x10375
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x60(%rbp)
subq $0x1e, %rax
ja 0x1035b
movq -0x60(%rbp), %rax
leaq 0x6317b(%rip), %rcx # 0x733e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
vmovss -0x10(%rbp), %xmm0
vcvttss2si %xmm0, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x10375
vmovss -0x10(%rbp), %xmm0
vcvttss2si %xmm0, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x10375
vcvttss2si -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x10375
vmovss -0x10(%rbp), %xmm0
vmovaps %xmm0, -0x50(%rbp)
vmovaps -0x50(%rbp), %xmm0
vcvtps2ph $0x0, %xmm0, %xmm0
vmovd %xmm0, %eax
movw %ax, -0x32(%rbp)
movw -0x32(%rbp), %dx
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0xc(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x10375
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movq %rax, -0x68(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x70(%rbp)
vmovss -0x10(%rbp), %xmm0
callq 0xf680
movq -0x70(%rbp), %rcx
movw %ax, %dx
movq -0x68(%rbp), %rax
movw %dx, -0x52(%rbp)
movw -0x52(%rbp), %dx
movw %dx, (%rax,%rcx,2)
jmp 0x10375
vmovss -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0xf8(%rax), %rax
movslq -0xc(%rbp), %rcx
vmovss %xmm0, (%rax,%rcx,4)
jmp 0x10375
leaq 0x63800(%rip), %rdi # 0x73b62
movl $0xaf3, %esi # imm = 0xAF3
leaq 0x63a4f(%rip), %rdx # 0x73dbd
movb $0x0, %al
callq 0xe270
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| ggml_set_f32_1d:
push rbp
mov rbp, rsp
sub rsp, 70h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
vmovss [rbp+var_10], xmm0
mov rdi, [rbp+var_8]
call _ggml_is_contiguous
test al, 1
jnz short loc_10246
lea rdi, [rbp+var_30]
xor esi, esi
mov edx, 20h ; ' '
call _memset
mov rdi, [rbp+var_8]
movsxd rsi, [rbp+var_C]
lea rdx, [rbp+var_30]
lea rcx, [rbp+var_30]
add rcx, 8
lea r8, [rbp+var_30]
add r8, 10h
lea r9, [rbp+var_30]
add r9, 18h
call _ggml_unravel_index
mov rdi, [rbp+var_8]
mov rax, [rbp+var_30]
mov esi, eax
mov rax, [rbp+var_28]
mov edx, eax
mov rax, [rbp+var_20]
mov ecx, eax
mov rax, [rbp+var_18]
mov r8d, eax
vmovss xmm0, [rbp+var_10]
call _ggml_set_f32_nd
jmp loc_10375
loc_10246:
mov rax, [rbp+var_8]
mov eax, [rax]
mov [rbp+var_60], rax
sub rax, 1Eh; switch 31 cases
ja def_1026C; jumptable 000000000001026C default case, cases 2-23,27-29
mov rax, [rbp+var_60]
lea rcx, jpt_1026C
movsxd rax, ds:(jpt_1026C - 733E0h)[rcx+rax*4]
add rax, rcx
jmp rax; switch jump
loc_1026E:
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 24
vcvttss2si eax, xmm0
mov dl, al
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_C]
mov [rax+rcx], dl
jmp loc_10375
loc_10290:
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 25
vcvttss2si eax, xmm0
mov dx, ax
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_C]
mov [rax+rcx*2], dx
jmp loc_10375
loc_102B4:
vcvttss2si edx, [rbp+var_10]; jumptable 000000000001026C case 26
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_C]
mov [rax+rcx*4], edx
jmp loc_10375
loc_102D0:
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 1
vmovaps [rbp+var_50], xmm0
vmovaps xmm0, [rbp+var_50]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
mov [rbp+var_32], ax
mov dx, [rbp+var_32]
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_C]
mov [rax+rcx*2], dx
jmp short loc_10375
loc_10306:
mov rax, [rbp+var_8]; jumptable 000000000001026C case 30
mov rax, [rax+0F8h]
mov [rbp+var_68], rax
movsxd rax, [rbp+var_C]
mov [rbp+var_70], rax
vmovss xmm0, [rbp+var_10]
call ggml_compute_fp32_to_bf16
mov rcx, [rbp+var_70]
mov dx, ax
mov rax, [rbp+var_68]
mov [rbp+var_52], dx
mov dx, [rbp+var_52]
mov [rax+rcx*2], dx
jmp short loc_10375
loc_10340:
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 0
mov rax, [rbp+var_8]
mov rax, [rax+0F8h]
movsxd rcx, [rbp+var_C]
vmovss dword ptr [rax+rcx*4], xmm0
jmp short loc_10375
def_1026C:
lea rdi, aWorkspaceLlm4b_0; jumptable 000000000001026C default case, cases 2-23,27-29
mov esi, 0AF3h
lea rdx, aFatalError; "fatal error"
mov al, 0
call _ggml_abort
loc_10375:
add rsp, 70h
pop rbp
retn
| double ggml_set_f32_1d(long long a1, int a2, __m128 _XMM0)
{
long long v12; // [rsp+8h] [rbp-68h]
long long v14; // [rsp+40h] [rbp-30h] BYREF
long long v15; // [rsp+48h] [rbp-28h] BYREF
long long v16; // [rsp+50h] [rbp-20h] BYREF
long long v17; // [rsp+58h] [rbp-18h] BYREF
int v19; // [rsp+64h] [rbp-Ch]
long long v20; // [rsp+68h] [rbp-8h]
v20 = a1;
v19 = a2;
__asm { vmovss [rbp+var_10], xmm0 }
if ( (ggml_is_contiguous(a1) & 1) != 0 )
{
switch ( *(_DWORD *)v20 )
{
case 0:
__asm { vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 0 }
_RAX = *(_QWORD *)(v20 + 248);
_RCX = v19;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
break;
case 1:
__asm
{
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 1
vmovaps [rbp+var_50], xmm0
vmovaps xmm0, [rbp+var_50]
vcvtps2ph xmm0, xmm0, 0
vmovd eax, xmm0
}
*(_WORD *)(*(_QWORD *)(v20 + 248) + 2LL * v19) = _EAX;
break;
case 0x18:
__asm
{
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 24
vcvttss2si eax, xmm0
}
*(_BYTE *)(*(_QWORD *)(v20 + 248) + v19) = _EAX;
break;
case 0x19:
__asm
{
vmovss xmm0, [rbp+var_10]; jumptable 000000000001026C case 25
vcvttss2si eax, xmm0
}
*(_WORD *)(*(_QWORD *)(v20 + 248) + 2LL * v19) = _EAX;
break;
case 0x1A:
__asm { vcvttss2si edx, [rbp+var_10]; jumptable 000000000001026C case 26 }
*(_DWORD *)(*(_QWORD *)(v20 + 248) + 4LL * v19) = _EDX;
break;
case 0x1E:
v12 = *(_QWORD *)(v20 + 248);
__asm { vmovss xmm0, [rbp+var_10] }
*(_WORD *)(v12 + 2LL * v19) = ggml_compute_fp32_to_bf16(_XMM0);
break;
default:
*(double *)_XMM0.m128_u64 = ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2803LL,
"fatal error");
break;
}
}
else
{
memset(&v14, 0LL, 32LL);
ggml_unravel_index(v20, v19, &v14, &v15, &v16, &v17);
__asm { vmovss xmm0, [rbp+var_10] }
ggml_set_f32_nd(
v20,
(unsigned int)v14,
(unsigned int)v15,
(unsigned int)v16,
(unsigned int)v17,
*(double *)_XMM0.m128_u64);
}
return *(double *)_XMM0.m128_u64;
}
| ggml_set_f32_1d:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
VMOVSS dword ptr [RBP + -0x10],XMM0
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x0010d280
TEST AL,0x1
JNZ 0x00110246
LEA RDI,[RBP + -0x30]
XOR ESI,ESI
MOV EDX,0x20
CALL 0x0010d560
MOV RDI,qword ptr [RBP + -0x8]
MOVSXD RSI,dword ptr [RBP + -0xc]
LEA RDX,[RBP + -0x30]
LEA RCX,[RBP + -0x30]
ADD RCX,0x8
LEA R8,[RBP + -0x30]
ADD R8,0x10
LEA R9,[RBP + -0x30]
ADD R9,0x18
CALL 0x0010d850
MOV RDI,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RBP + -0x30]
MOV ESI,EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV EDX,EAX
MOV RAX,qword ptr [RBP + -0x20]
MOV ECX,EAX
MOV RAX,qword ptr [RBP + -0x18]
MOV R8D,EAX
VMOVSS XMM0,dword ptr [RBP + -0x10]
CALL 0x0010d470
JMP 0x00110375
LAB_00110246:
MOV RAX,qword ptr [RBP + -0x8]
MOV EAX,dword ptr [RAX]
MOV qword ptr [RBP + -0x60],RAX
SUB RAX,0x1e
JA 0x0011035b
MOV RAX,qword ptr [RBP + -0x60]
LEA RCX,[0x1733e0]
MOVSXD RAX,dword ptr [RCX + RAX*0x4]
ADD RAX,RCX
switchD:
JMP RAX
caseD_18:
VMOVSS XMM0,dword ptr [RBP + -0x10]
VCVTTSS2SI EAX,XMM0
MOV DL,AL
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0xc]
MOV byte ptr [RAX + RCX*0x1],DL
JMP 0x00110375
caseD_19:
VMOVSS XMM0,dword ptr [RBP + -0x10]
VCVTTSS2SI EAX,XMM0
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],DX
JMP 0x00110375
caseD_1a:
VCVTTSS2SI EDX,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0xc]
MOV dword ptr [RAX + RCX*0x4],EDX
JMP 0x00110375
caseD_1:
VMOVSS XMM0,dword ptr [RBP + -0x10]
VMOVAPS xmmword ptr [RBP + -0x50],XMM0
VMOVAPS XMM0,xmmword ptr [RBP + -0x50]
VCVTPS2PH XMM0,XMM0,0x0
VMOVD EAX,XMM0
MOV word ptr [RBP + -0x32],AX
MOV DX,word ptr [RBP + -0x32]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0xc]
MOV word ptr [RAX + RCX*0x2],DX
JMP 0x00110375
caseD_1e:
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOV qword ptr [RBP + -0x68],RAX
MOVSXD RAX,dword ptr [RBP + -0xc]
MOV qword ptr [RBP + -0x70],RAX
VMOVSS XMM0,dword ptr [RBP + -0x10]
CALL 0x0010f680
MOV RCX,qword ptr [RBP + -0x70]
MOV DX,AX
MOV RAX,qword ptr [RBP + -0x68]
MOV word ptr [RBP + -0x52],DX
MOV DX,word ptr [RBP + -0x52]
MOV word ptr [RAX + RCX*0x2],DX
JMP 0x00110375
caseD_0:
VMOVSS XMM0,dword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x8]
MOV RAX,qword ptr [RAX + 0xf8]
MOVSXD RCX,dword ptr [RBP + -0xc]
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
JMP 0x00110375
caseD_2:
LEA RDI,[0x173b62]
MOV ESI,0xaf3
LEA RDX,[0x173dbd]
MOV AL,0x0
CALL 0x0010e270
LAB_00110375:
ADD RSP,0x70
POP RBP
RET
|
void ggml_set_f32_1d(float param_1,int4 *param_2,int param_3)
{
long lVar1;
int2 uVar2;
ulong uVar3;
long lVar4;
int1 auVar5 [16];
ulong local_38;
ulong local_30;
ulong local_28;
ulong local_20;
float local_18;
int local_14;
int4 *local_10;
local_18 = param_1;
local_14 = param_3;
local_10 = param_2;
uVar3 = ggml_is_contiguous(param_2);
if ((uVar3 & 1) == 0) {
memset(&local_38,0,0x20);
ggml_unravel_index(local_10,(long)local_14,&local_38,&local_30,&local_28,&local_20);
ggml_set_f32_nd(local_18,local_10,local_38 & 0xffffffff,local_30 & 0xffffffff,
local_28 & 0xffffffff,local_20 & 0xffffffff);
}
else {
switch(*local_10) {
case 0:
*(float *)(*(long *)(local_10 + 0x3e) + (long)local_14 * 4) = local_18;
break;
case 1:
auVar5 = vcvtps2ph_f16c(ZEXT416((uint)local_18),0);
*(short *)(*(long *)(local_10 + 0x3e) + (long)local_14 * 2) = auVar5._0_2_;
break;
default:
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0xaf3,"fatal error");
break;
case 0x18:
*(char *)(*(long *)(local_10 + 0x3e) + (long)local_14) = (char)(int)local_18;
break;
case 0x19:
*(short *)(*(long *)(local_10 + 0x3e) + (long)local_14 * 2) = (short)(int)local_18;
break;
case 0x1a:
*(int *)(*(long *)(local_10 + 0x3e) + (long)local_14 * 4) = (int)local_18;
break;
case 0x1e:
lVar1 = *(long *)(local_10 + 0x3e);
lVar4 = (long)local_14;
uVar2 = ggml_compute_fp32_to_bf16(local_18);
*(int2 *)(lVar1 + lVar4 * 2) = uVar2;
}
}
return;
}
| |
43,453 | ggml_set_f32_1d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_BF16:
{
((ggml_bf16_t *)(tensor->data))[i] = GGML_FP32_TO_BF16(value);
} break;
case GGML_TYPE_F32:
{
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O2 | c | ggml_set_f32_1d:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x81e0
testb %al, %al
je 0xa0e2
vmovaps (%rsp), %xmm0
movl (%rbx), %eax
leal -0x18(%rax), %ecx
cmpl $0x6, %ecx
ja 0xa135
leaq 0x2901a(%rip), %rax # 0x330e0
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movb %al, (%rcx,%rdx)
jmp 0xa12c
vxorps %xmm0, %xmm0, %xmm0
leaq 0x18(%rsp), %rcx
vmovups %ymm0, -0x8(%rcx)
movslq %ebp, %rsi
leaq 0x20(%rsp), %r8
leaq 0x28(%rsp), %r9
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
vzeroupper
callq 0x8570
movl (%r14), %esi
movl 0x8(%r14), %edx
movl 0x10(%r14), %ecx
movl 0x18(%r14), %r8d
movq %rbx, %rdi
vmovaps (%rsp), %xmm0
callq 0x8330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
je 0xa194
cmpl $0x1, %eax
jne 0xa1a5
vcvtps2ph $0x0, %xmm0, %xmm0
movq 0xf8(%rbx), %rax
movslq %ebp, %rcx
vpextrw $0x0, %xmm0, (%rax,%rcx,2)
jmp 0xa12c
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movw %ax, (%rcx,%rdx,2)
jmp 0xa12c
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0xa12c
movq 0xf8(%rbx), %rbx
movslq %ebp, %r14
callq 0x9901
movw %ax, (%rbx,%r14,2)
jmp 0xa12c
movq 0xf8(%rbx), %rax
movslq %ebp, %rcx
vmovss %xmm0, (%rax,%rcx,4)
jmp 0xa12c
leaq 0x295ae(%rip), %rdi # 0x3375a
leaq 0x29802(%rip), %rdx # 0x339b5
movl $0xaf3, %esi # imm = 0xAF3
xorl %eax, %eax
callq 0x8b10
| ggml_set_f32_1d:
push rbp
push r14
push rbx
sub rsp, 30h
vmovaps [rsp+48h+var_48], xmm0
mov ebp, esi
mov rbx, rdi
call _ggml_is_contiguous
test al, al
jz short loc_A0E2
vmovaps xmm0, [rsp+48h+var_48]
mov eax, [rbx]
lea ecx, [rax-18h]; switch 7 cases
cmp ecx, 6
ja short def_A0CD; jumptable 000000000000A0CD default case
lea rax, jpt_A0CD
movsxd rcx, ds:(jpt_A0CD - 330E0h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_A0CF:
vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 24
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx], al
jmp short loc_A12C
loc_A0E2:
vxorps xmm0, xmm0, xmm0
lea rcx, [rsp+48h+var_30]
vmovups ymmword ptr [rcx-8], ymm0
movsxd rsi, ebp
lea r8, [rsp+48h+var_28]
lea r9, [rsp+48h+var_20]
lea r14, [rsp+48h+var_38]
mov rdi, rbx
mov rdx, r14
vzeroupper
call _ggml_unravel_index
mov esi, [r14]
mov edx, [r14+8]
mov ecx, [r14+10h]
mov r8d, [r14+18h]
mov rdi, rbx
vmovaps xmm0, [rsp+48h+var_48]
call _ggml_set_f32_nd
loc_A12C:
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
def_A0CD:
test eax, eax; jumptable 000000000000A0CD default case
jz short loc_A194
cmp eax, 1
jnz short loc_A1A5; jumptable 000000000000A0CD cases 27-29
vcvtps2ph xmm0, xmm0, 0
mov rax, [rbx+0F8h]
movsxd rcx, ebp
vpextrw word ptr [rax+rcx*2], xmm0, 0
jmp short loc_A12C
loc_A157:
vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 25
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx*2], ax
jmp short loc_A12C
loc_A16B:
vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 26
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx*4], eax
jmp short loc_A12C
loc_A17E:
mov rbx, [rbx+0F8h]; jumptable 000000000000A0CD case 30
movsxd r14, ebp
call ggml_compute_fp32_to_bf16
mov [rbx+r14*2], ax
jmp short loc_A12C
loc_A194:
mov rax, [rbx+0F8h]
movsxd rcx, ebp
vmovss dword ptr [rax+rcx*4], xmm0
jmp short loc_A12C
loc_A1A5:
lea rdi, aWorkspaceLlm4b_0; jumptable 000000000000A0CD cases 27-29
lea rdx, aFatalError; "fatal error"
mov esi, 0AF3h
xor eax, eax
call _ggml_abort
| int ggml_set_f32_1d(int *a1, int a2, __m128 _XMM0)
{
int v5; // eax
long long v12; // rbx
unsigned int v16; // [rsp+10h] [rbp-38h] BYREF
unsigned int v17; // [rsp+18h] [rbp-30h] BYREF
unsigned int v18; // [rsp+20h] [rbp-28h] BYREF
_DWORD v19[8]; // [rsp+28h] [rbp-20h] BYREF
__asm { vmovaps [rsp+48h+var_48], xmm0 }
if ( (unsigned __int8)ggml_is_contiguous() )
{
__asm { vmovaps xmm0, [rsp+48h+var_48] }
v5 = *a1;
switch ( *a1 )
{
case 24:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 24 }
*(_BYTE *)(*((_QWORD *)a1 + 31) + a2) = _RAX;
break;
case 25:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 25 }
*(_WORD *)(*((_QWORD *)a1 + 31) + 2LL * a2) = _RAX;
break;
case 26:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A0CD case 26 }
*(_DWORD *)(*((_QWORD *)a1 + 31) + 4LL * a2) = _RAX;
break;
case 27:
case 28:
case 29:
goto LABEL_13;
case 30:
v12 = *((_QWORD *)a1 + 31);
LODWORD(_RAX) = ggml_compute_fp32_to_bf16(_XMM0);
*(_WORD *)(v12 + 2LL * a2) = _RAX;
break;
default:
if ( v5 )
{
if ( v5 == 1 )
{
__asm { vcvtps2ph xmm0, xmm0, 0 }
_RAX = *((_QWORD *)a1 + 31);
_RCX = a2;
__asm { vpextrw word ptr [rax+rcx*2], xmm0, 0 }
}
else
{
LABEL_13:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2803LL,
"fatal error",
*(double *)_XMM0.m128_u64);
LODWORD(_RAX) = ggml_set_f32_nd();
}
}
else
{
_RAX = *((_QWORD *)a1 + 31);
_RCX = a2;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
break;
}
}
else
{
__asm { vxorps xmm0, xmm0, xmm0 }
_RCX = &v17;
__asm
{
vmovups ymmword ptr [rcx-8], ymm0
vzeroupper
}
ggml_unravel_index(a1, a2, &v16, &v17, &v18, v19, *(double *)&_XMM0);
__asm { vmovaps xmm0, [rsp+48h+var_48] }
LODWORD(_RAX) = ggml_set_f32_nd(a1, v16, v17, v18, v19[0], *(double *)&_XMM0);
}
return _RAX;
}
| ggml_set_f32_1d:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
VMOVAPS xmmword ptr [RSP],XMM0
MOV EBP,ESI
MOV RBX,RDI
CALL 0x001081e0
TEST AL,AL
JZ 0x0010a0e2
VMOVAPS XMM0,xmmword ptr [RSP]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x18]
CMP ECX,0x6
JA 0x0010a135
LEA RAX,[0x1330e0]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_18:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV byte ptr [RCX + RDX*0x1],AL
JMP 0x0010a12c
LAB_0010a0e2:
VXORPS XMM0,XMM0,XMM0
LEA RCX,[RSP + 0x18]
VMOVUPS ymmword ptr [RCX + -0x8],YMM0
MOVSXD RSI,EBP
LEA R8,[RSP + 0x20]
LEA R9,[RSP + 0x28]
LEA R14,[RSP + 0x10]
MOV RDI,RBX
MOV RDX,R14
VZEROUPPER
CALL 0x00108570
MOV ESI,dword ptr [R14]
MOV EDX,dword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x10]
MOV R8D,dword ptr [R14 + 0x18]
MOV RDI,RBX
VMOVAPS XMM0,xmmword ptr [RSP]
CALL 0x00108330
LAB_0010a12c:
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
default:
TEST EAX,EAX
JZ 0x0010a194
CMP EAX,0x1
JNZ 0x0010a1a5
VCVTPS2PH XMM0,XMM0,0x0
MOV RAX,qword ptr [RBX + 0xf8]
MOVSXD RCX,EBP
VPEXTRW word ptr [RAX + RCX*0x2],XMM0,0x0
JMP 0x0010a12c
caseD_19:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV word ptr [RCX + RDX*0x2],AX
JMP 0x0010a12c
caseD_1a:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV dword ptr [RCX + RDX*0x4],EAX
JMP 0x0010a12c
caseD_1e:
MOV RBX,qword ptr [RBX + 0xf8]
MOVSXD R14,EBP
CALL 0x00109901
MOV word ptr [RBX + R14*0x2],AX
JMP 0x0010a12c
LAB_0010a194:
MOV RAX,qword ptr [RBX + 0xf8]
MOVSXD RCX,EBP
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
JMP 0x0010a12c
caseD_1b:
LEA RDI,[0x13375a]
LEA RDX,[0x1339b5]
MOV ESI,0xaf3
XOR EAX,EAX
CALL 0x00108b10
|
void ggml_set_f32_1d(int8 param_1,int *param_2,int param_3)
{
int iVar1;
long lVar2;
char cVar3;
int2 uVar4;
float fVar5;
int8 in_XMM0_Qb;
int1 auVar6 [16];
ulong local_38;
ulong uStack_30;
ulong uStack_28;
ulong uStack_20;
cVar3 = ggml_is_contiguous();
if (cVar3 == '\0') {
local_38 = 0;
uStack_30 = 0;
uStack_28 = 0;
uStack_20 = 0;
ggml_unravel_index(param_2,(long)param_3,&local_38,&uStack_30,&uStack_28,&uStack_20);
ggml_set_f32_nd(param_1,param_2,local_38 & 0xffffffff,uStack_30 & 0xffffffff,
uStack_28 & 0xffffffff,uStack_20 & 0xffffffff);
}
else {
auVar6._8_8_ = in_XMM0_Qb;
auVar6._0_8_ = param_1;
iVar1 = *param_2;
fVar5 = (float)param_1;
switch(iVar1) {
case 0x18:
*(char *)(*(long *)(param_2 + 0x3e) + (long)param_3) = (char)(int)fVar5;
break;
case 0x19:
*(short *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 2) = (short)(int)fVar5;
break;
case 0x1a:
*(int *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 4) = (int)fVar5;
break;
case 0x1b:
case 0x1c:
case 0x1d:
switchD_0010a0cd_caseD_1b:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0xaf3,"fatal error");
case 0x1e:
lVar2 = *(long *)(param_2 + 0x3e);
uVar4 = ggml_compute_fp32_to_bf16();
*(int2 *)(lVar2 + (long)param_3 * 2) = uVar4;
break;
default:
if (iVar1 == 0) {
*(float *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 4) = fVar5;
}
else {
if (iVar1 != 1) goto switchD_0010a0cd_caseD_1b;
auVar6 = vcvtps2ph_f16c(auVar6,0);
vpextrw_avx(auVar6,0);
}
}
}
return;
}
| |
43,454 | ggml_set_f32_1d | Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c | void ggml_set_f32_1d(const struct ggml_tensor * tensor, int i, float value) {
if (!ggml_is_contiguous(tensor)) {
int64_t id[4] = { 0, 0, 0, 0 };
ggml_unravel_index(tensor, i, &id[0], &id[1], &id[2], &id[3]);
ggml_set_f32_nd(tensor, id[0], id[1], id[2], id[3], value);
return;
}
switch (tensor->type) {
case GGML_TYPE_I8:
{
((int8_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I16:
{
((int16_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_I32:
{
((int32_t *)(tensor->data))[i] = value;
} break;
case GGML_TYPE_F16:
{
((ggml_fp16_t *)(tensor->data))[i] = GGML_FP32_TO_FP16(value);
} break;
case GGML_TYPE_BF16:
{
((ggml_bf16_t *)(tensor->data))[i] = GGML_FP32_TO_BF16(value);
} break;
case GGML_TYPE_F32:
{
((float *)(tensor->data))[i] = value;
} break;
default:
{
GGML_ABORT("fatal error");
}
}
} | O3 | c | ggml_set_f32_1d:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
vmovaps %xmm0, (%rsp)
movl %esi, %ebp
movq %rdi, %rbx
callq 0x81a0
testb %al, %al
je 0xa6a2
vmovdqa (%rsp), %xmm0
movl (%rbx), %eax
leal -0x18(%rax), %ecx
cmpl $0x6, %ecx
ja 0xa6f5
leaq 0x2bbda(%rip), %rax # 0x36260
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movb %al, (%rcx,%rdx)
jmp 0xa6ec
vxorps %xmm0, %xmm0, %xmm0
leaq 0x18(%rsp), %rcx
vmovups %ymm0, -0x8(%rcx)
movslq %ebp, %rsi
leaq 0x20(%rsp), %r8
leaq 0x28(%rsp), %r9
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
vzeroupper
callq 0x84b0
movl (%r14), %esi
movl 0x8(%r14), %edx
movl 0x10(%r14), %ecx
movl 0x18(%r14), %r8d
movq %rbx, %rdi
vmovaps (%rsp), %xmm0
callq 0x82c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %eax, %eax
je 0xa76a
cmpl $0x1, %eax
jne 0xa795
vcvtps2ph $0x0, %xmm0, %xmm0
movq 0xf8(%rbx), %rax
movslq %ebp, %rcx
vpextrw $0x0, %xmm0, (%rax,%rcx,2)
jmp 0xa6ec
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movw %ax, (%rcx,%rdx,2)
jmp 0xa6ec
vcvttss2si %xmm0, %eax
movq 0xf8(%rbx), %rcx
movslq %ebp, %rdx
movl %eax, (%rcx,%rdx,4)
jmp 0xa6ec
movq 0xf8(%rbx), %rax
movslq %ebp, %rcx
vmovd %xmm0, %esi
movl %esi, %edi
andl $0x7fffffff, %edi # imm = 0x7FFFFFFF
movl %esi, %edx
shrl $0x10, %edx
cmpl $0x7f800001, %edi # imm = 0x7F800001
jb 0xa77e
orl $0x40, %edx
jmp 0xa78c
movq 0xf8(%rbx), %rax
movslq %ebp, %rcx
vmovss %xmm0, (%rax,%rcx,4)
jmp 0xa6ec
andl $0x1, %edx
addl %esi, %edx
addl $0x7fff, %edx # imm = 0x7FFF
shrl $0x10, %edx
movw %dx, (%rax,%rcx,2)
jmp 0xa6ec
leaq 0x2c0ce(%rip), %rdi # 0x3686a
leaq 0x2c322(%rip), %rdx # 0x36ac5
movl $0xaf3, %esi # imm = 0xAF3
xorl %eax, %eax
callq 0x89c0
| ggml_set_f32_1d:
push rbp
push r14
push rbx
sub rsp, 30h
vmovaps [rsp+48h+var_48], xmm0
mov ebp, esi
mov rbx, rdi
call _ggml_is_contiguous
test al, al
jz short loc_A6A2
vmovdqa xmm0, [rsp+48h+var_48]
mov eax, [rbx]
lea ecx, [rax-18h]; switch 7 cases
cmp ecx, 6
ja short def_A68D; jumptable 000000000000A68D default case
lea rax, jpt_A68D
movsxd rcx, ds:(jpt_A68D - 36260h)[rax+rcx*4]
add rcx, rax
jmp rcx; switch jump
loc_A68F:
vcvttss2si eax, xmm0; jumptable 000000000000A68D case 24
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx], al
jmp short loc_A6EC
loc_A6A2:
vxorps xmm0, xmm0, xmm0
lea rcx, [rsp+48h+var_30]
vmovups ymmword ptr [rcx-8], ymm0
movsxd rsi, ebp
lea r8, [rsp+48h+var_28]
lea r9, [rsp+48h+var_20]
lea r14, [rsp+48h+var_38]
mov rdi, rbx
mov rdx, r14
vzeroupper
call _ggml_unravel_index
mov esi, [r14]
mov edx, [r14+8]
mov ecx, [r14+10h]
mov r8d, [r14+18h]
mov rdi, rbx
vmovaps xmm0, [rsp+48h+var_48]
call _ggml_set_f32_nd
loc_A6EC:
add rsp, 30h
pop rbx
pop r14
pop rbp
retn
def_A68D:
test eax, eax; jumptable 000000000000A68D default case
jz short loc_A76A
cmp eax, 1
jnz loc_A795; jumptable 000000000000A68D cases 27-29
vcvtps2ph xmm0, xmm0, 0
mov rax, [rbx+0F8h]
movsxd rcx, ebp
vpextrw word ptr [rax+rcx*2], xmm0, 0
jmp short loc_A6EC
loc_A71B:
vcvttss2si eax, xmm0; jumptable 000000000000A68D case 25
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx*2], ax
jmp short loc_A6EC
loc_A72F:
vcvttss2si eax, xmm0; jumptable 000000000000A68D case 26
mov rcx, [rbx+0F8h]
movsxd rdx, ebp
mov [rcx+rdx*4], eax
jmp short loc_A6EC
loc_A742:
mov rax, [rbx+0F8h]; jumptable 000000000000A68D case 30
movsxd rcx, ebp
vmovd esi, xmm0
mov edi, esi
and edi, 7FFFFFFFh
mov edx, esi
shr edx, 10h
cmp edi, 7F800001h
jb short loc_A77E
or edx, 40h
jmp short loc_A78C
loc_A76A:
mov rax, [rbx+0F8h]
movsxd rcx, ebp
vmovss dword ptr [rax+rcx*4], xmm0
jmp loc_A6EC
loc_A77E:
and edx, 1
add edx, esi
add edx, 7FFFh
shr edx, 10h
loc_A78C:
mov [rax+rcx*2], dx
jmp loc_A6EC
loc_A795:
lea rdi, aWorkspaceLlm4b_0; jumptable 000000000000A68D cases 27-29
lea rdx, aFatalError; "fatal error"
mov esi, 0AF3h
xor eax, eax
call _ggml_abort
| int ggml_set_f32_1d(int *a1, int a2, __m128 _XMM0)
{
int v6; // eax
unsigned int v14; // edx
unsigned int v18; // [rsp+10h] [rbp-38h] BYREF
unsigned int v19; // [rsp+18h] [rbp-30h] BYREF
unsigned int v20; // [rsp+20h] [rbp-28h] BYREF
_DWORD v21[8]; // [rsp+28h] [rbp-20h] BYREF
__asm { vmovaps [rsp+48h+var_48], xmm0 }
if ( (unsigned __int8)ggml_is_contiguous() )
{
__asm { vmovdqa xmm0, [rsp+48h+var_48] }
v6 = *a1;
switch ( *a1 )
{
case 24:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A68D case 24 }
*(_BYTE *)(*((_QWORD *)a1 + 31) + a2) = _RAX;
break;
case 25:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A68D case 25 }
*(_WORD *)(*((_QWORD *)a1 + 31) + 2LL * a2) = _RAX;
break;
case 26:
__asm { vcvttss2si eax, xmm0; jumptable 000000000000A68D case 26 }
*(_DWORD *)(*((_QWORD *)a1 + 31) + 4LL * a2) = _RAX;
break;
case 27:
case 28:
case 29:
goto LABEL_16;
case 30:
_RAX = *((_QWORD *)a1 + 31);
__asm { vmovd esi, xmm0 }
if ( (_ESI & 0x7FFFFFFF) < 0x7F800001 )
v14 = (_ESI + (HIWORD(_ESI) & 1) + 0x7FFF) >> 16;
else
LOWORD(v14) = HIWORD(_ESI) | 0x40;
*(_WORD *)(_RAX + 2LL * a2) = v14;
break;
default:
if ( v6 )
{
if ( v6 == 1 )
{
__asm { vcvtps2ph xmm0, xmm0, 0 }
_RAX = *((_QWORD *)a1 + 31);
_RCX = a2;
__asm { vpextrw word ptr [rax+rcx*2], xmm0, 0 }
}
else
{
LABEL_16:
ggml_abort(
"/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c",
2803LL,
"fatal error",
*(double *)&_XMM0);
LODWORD(_RAX) = ggml_set_f32_nd();
}
}
else
{
_RAX = *((_QWORD *)a1 + 31);
_RCX = a2;
__asm { vmovss dword ptr [rax+rcx*4], xmm0 }
}
break;
}
}
else
{
__asm { vxorps xmm0, xmm0, xmm0 }
_RCX = &v19;
__asm
{
vmovups ymmword ptr [rcx-8], ymm0
vzeroupper
}
ggml_unravel_index(a1, a2, &v18, &v19, &v20, v21, *(double *)&_XMM0);
__asm { vmovaps xmm0, [rsp+48h+var_48] }
LODWORD(_RAX) = ggml_set_f32_nd(a1, v18, v19, v20, v21[0], *(double *)&_XMM0);
}
return _RAX;
}
| ggml_set_f32_1d:
PUSH RBP
PUSH R14
PUSH RBX
SUB RSP,0x30
VMOVAPS xmmword ptr [RSP],XMM0
MOV EBP,ESI
MOV RBX,RDI
CALL 0x001081a0
TEST AL,AL
JZ 0x0010a6a2
VMOVDQA XMM0,xmmword ptr [RSP]
MOV EAX,dword ptr [RBX]
LEA ECX,[RAX + -0x18]
CMP ECX,0x6
JA 0x0010a6f5
LEA RAX,[0x136260]
MOVSXD RCX,dword ptr [RAX + RCX*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_18:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV byte ptr [RCX + RDX*0x1],AL
JMP 0x0010a6ec
LAB_0010a6a2:
VXORPS XMM0,XMM0,XMM0
LEA RCX,[RSP + 0x18]
VMOVUPS ymmword ptr [RCX + -0x8],YMM0
MOVSXD RSI,EBP
LEA R8,[RSP + 0x20]
LEA R9,[RSP + 0x28]
LEA R14,[RSP + 0x10]
MOV RDI,RBX
MOV RDX,R14
VZEROUPPER
CALL 0x001084b0
MOV ESI,dword ptr [R14]
MOV EDX,dword ptr [R14 + 0x8]
MOV ECX,dword ptr [R14 + 0x10]
MOV R8D,dword ptr [R14 + 0x18]
MOV RDI,RBX
VMOVAPS XMM0,xmmword ptr [RSP]
CALL 0x001082c0
LAB_0010a6ec:
ADD RSP,0x30
POP RBX
POP R14
POP RBP
RET
default:
TEST EAX,EAX
JZ 0x0010a76a
CMP EAX,0x1
JNZ 0x0010a795
VCVTPS2PH XMM0,XMM0,0x0
MOV RAX,qword ptr [RBX + 0xf8]
MOVSXD RCX,EBP
VPEXTRW word ptr [RAX + RCX*0x2],XMM0,0x0
JMP 0x0010a6ec
caseD_19:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV word ptr [RCX + RDX*0x2],AX
JMP 0x0010a6ec
caseD_1a:
VCVTTSS2SI EAX,XMM0
MOV RCX,qword ptr [RBX + 0xf8]
MOVSXD RDX,EBP
MOV dword ptr [RCX + RDX*0x4],EAX
JMP 0x0010a6ec
caseD_1e:
MOV RAX,qword ptr [RBX + 0xf8]
MOVSXD RCX,EBP
VMOVD ESI,XMM0
MOV EDI,ESI
AND EDI,0x7fffffff
MOV EDX,ESI
SHR EDX,0x10
CMP EDI,0x7f800001
JC 0x0010a77e
OR EDX,0x40
JMP 0x0010a78c
LAB_0010a76a:
MOV RAX,qword ptr [RBX + 0xf8]
MOVSXD RCX,EBP
VMOVSS dword ptr [RAX + RCX*0x4],XMM0
JMP 0x0010a6ec
LAB_0010a77e:
AND EDX,0x1
ADD EDX,ESI
ADD EDX,0x7fff
SHR EDX,0x10
LAB_0010a78c:
MOV word ptr [RAX + RCX*0x2],DX
JMP 0x0010a6ec
caseD_1b:
LEA RDI,[0x13686a]
LEA RDX,[0x136ac5]
MOV ESI,0xaf3
XOR EAX,EAX
CALL 0x001089c0
|
void ggml_set_f32_1d(int8 param_1,int *param_2,int param_3)
{
int iVar1;
char cVar2;
ushort uVar3;
float fVar4;
int8 in_XMM0_Qb;
int1 auVar5 [16];
ulong local_38;
ulong uStack_30;
ulong uStack_28;
ulong uStack_20;
cVar2 = ggml_is_contiguous();
if (cVar2 == '\0') {
local_38 = 0;
uStack_30 = 0;
uStack_28 = 0;
uStack_20 = 0;
ggml_unravel_index(param_2,(long)param_3,&local_38,&uStack_30,&uStack_28,&uStack_20);
ggml_set_f32_nd(param_1,param_2,local_38 & 0xffffffff,uStack_30 & 0xffffffff,
uStack_28 & 0xffffffff,uStack_20 & 0xffffffff);
}
else {
auVar5._8_8_ = in_XMM0_Qb;
auVar5._0_8_ = param_1;
iVar1 = *param_2;
fVar4 = (float)param_1;
switch(iVar1) {
case 0x18:
*(char *)(*(long *)(param_2 + 0x3e) + (long)param_3) = (char)(int)fVar4;
break;
case 0x19:
*(short *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 2) = (short)(int)fVar4;
break;
case 0x1a:
*(int *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 4) = (int)fVar4;
break;
case 0x1b:
case 0x1c:
case 0x1d:
switchD_0010a68d_caseD_1b:
/* WARNING: Subroutine does not return */
ggml_abort("/workspace/llm4binary/github/2025_star3/Yangxiaoz[P]GGML-Tutorial/ggml/src/ggml-cpu/ggml-cpu.c"
,0xaf3,"fatal error");
case 0x1e:
if ((uint)ABS(fVar4) < 0x7f800001) {
uVar3 = (ushort)(((uint)fVar4 >> 0x10 & 1) + (int)fVar4 + 0x7fff >> 0x10);
}
else {
uVar3 = (ushort)((ulong)param_1 >> 0x10) | 0x40;
}
*(ushort *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 2) = uVar3;
break;
default:
if (iVar1 == 0) {
*(float *)(*(long *)(param_2 + 0x3e) + (long)param_3 * 4) = fVar4;
}
else {
if (iVar1 != 1) goto switchD_0010a68d_caseD_1b;
auVar5 = vcvtps2ph_f16c(auVar5,0);
vpextrw_avx(auVar5,0);
}
}
}
return;
}
| |
43,455 | minja::LiteralExpr::LiteralExpr(minja::Location const&, minja::Value const&) | monkey531[P]llama/common/minja.hpp | LiteralExpr(const Location & location, const Value& v)
: Expression(location), value(v) {} | O3 | cpp | minja::LiteralExpr::LiteralExpr(minja::Location const&, minja::Value const&):
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x8d22f(%rip), %r15 # 0xe1288
addq $0x10, %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x54089
movq 0x8ef1d(%rip), %rcx # 0xe2f98
cmpb $0x0, (%rcx)
je 0x54085
incl 0x8(%rax)
jmp 0x54089
lock
incl 0x8(%rax)
movq 0x10(%rsi), %rax
movq %rax, 0x18(%rbx)
leaq 0x8d4b0(%rip), %rax # 0xe1548
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rdi
movq %rdx, %rsi
callq 0x53ab2
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x540c5
callq 0x348da
movq %r14, %rdi
callq 0x1ad30
nop
| _ZN5minja11LiteralExprC2ERKNS_8LocationERKNS_5ValueE:
push r15
push r14
push rbx
mov rbx, rdi
lea r15, _ZTVN5minja10ExpressionE; `vtable for'minja::Expression
add r15, 10h
mov [rdi], r15
mov rax, [rsi]
mov [rdi+8], rax
mov rax, [rsi+8]
mov [rdi+10h], rax
test rax, rax
jz short loc_54089
mov rcx, cs:__libc_single_threaded_ptr
cmp byte ptr [rcx], 0
jz short loc_54085
inc dword ptr [rax+8]
jmp short loc_54089
loc_54085:
lock inc dword ptr [rax+8]
loc_54089:
mov rax, [rsi+10h]
mov [rbx+18h], rax
lea rax, _ZTVN5minja11LiteralExprE; `vtable for'minja::LiteralExpr
add rax, 10h
mov [rbx], rax
lea rdi, [rbx+20h]; this
mov rsi, rdx; minja::Value *
call _ZN5minja5ValueC2ERKS0_; minja::Value::Value(minja::Value const&)
pop rbx
pop r14
pop r15
retn
mov r14, rax
mov [rbx], r15
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_540C5
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_540C5:
mov rdi, r14
call __Unwind_Resume
| long long minja::LiteralExpr::LiteralExpr(_QWORD *a1, _QWORD *a2, const minja::Value *a3)
{
long long v3; // rax
*a1 = &`vtable for'minja::Expression + 2;
a1[1] = *a2;
v3 = a2[1];
a1[2] = v3;
if ( v3 )
{
if ( _libc_single_threaded )
++*(_DWORD *)(v3 + 8);
else
_InterlockedIncrement((volatile signed __int32 *)(v3 + 8));
}
a1[3] = a2[2];
*a1 = &`vtable for'minja::LiteralExpr + 2;
return minja::Value::Value((minja::Value *)(a1 + 4), a3);
}
| LiteralExpr:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RDI
LEA R15,[0x1e1288]
ADD R15,0x10
MOV qword ptr [RDI],R15
MOV RAX,qword ptr [RSI]
MOV qword ptr [RDI + 0x8],RAX
MOV RAX,qword ptr [RSI + 0x8]
MOV qword ptr [RDI + 0x10],RAX
TEST RAX,RAX
JZ 0x00154089
MOV RCX,qword ptr [0x001e2f98]
CMP byte ptr [RCX],0x0
JZ 0x00154085
INC dword ptr [RAX + 0x8]
JMP 0x00154089
LAB_00154085:
INC.LOCK dword ptr [RAX + 0x8]
LAB_00154089:
MOV RAX,qword ptr [RSI + 0x10]
MOV qword ptr [RBX + 0x18],RAX
LEA RAX,[0x1e1548]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
LEA RDI,[RBX + 0x20]
LAB_001540a3:
MOV RSI,RDX
CALL 0x00153ab2
LAB_001540ab:
POP RBX
POP R14
POP R15
RET
|
/* minja::LiteralExpr::LiteralExpr(minja::Location const&, minja::Value const&) */
void __thiscall minja::LiteralExpr::LiteralExpr(LiteralExpr *this,Location *param_1,Value *param_2)
{
long lVar1;
*(int ***)this = &PTR___cxa_pure_virtual_001e1298;
*(int8 *)(this + 8) = *(int8 *)param_1;
lVar1 = *(long *)(param_1 + 8);
*(long *)(this + 0x10) = lVar1;
if (lVar1 != 0) {
if (*PTR___libc_single_threaded_001e2f98 == '\0') {
LOCK();
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
UNLOCK();
}
else {
*(int *)(lVar1 + 8) = *(int *)(lVar1 + 8) + 1;
}
}
*(int8 *)(this + 0x18) = *(int8 *)(param_1 + 0x10);
*(int ***)this = &PTR_do_evaluate_001e1558;
/* try { // try from 001540a3 to 001540aa has its CatchHandler @ 001540b1 */
Value::Value((Value *)(this + 0x20),param_2);
return;
}
| |
43,456 | my_utf16_uni | eloqsql/strings/ctype-ucs2.c | int
my_utf16_uni(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t *pwc, const uchar *s, const uchar *e)
{
return my_mb_wc_utf16_quick(pwc, s, e);
} | O3 | c | my_utf16_uni:
pushq %rbp
movq %rsp, %rbp
leaq 0x2(%rdx), %r8
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %r8
ja 0xc99d4
movzbl (%rdx), %edi
movl %edi, %r9d
andl $-0x4, %r9d
xorl %eax, %eax
cmpl $0xdc, %r9d
je 0xc99d4
cmpl $0xd8, %r9d
jne 0xc99c1
leaq 0x4(%rdx), %r9
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rcx, %r9
ja 0xc99d4
movzbl (%r8), %ecx
movl %ecx, %r8d
andl $-0x4, %r8d
movl $0x0, %eax
cmpl $0xdc, %r8d
jne 0xc99d4
shll $0x12, %edi
shll $0x8, %ecx
orl %edi, %ecx
movzbl 0x1(%rdx), %eax
shll $0xa, %eax
movzbl 0x3(%rdx), %edx
andl $0xc0300, %ecx # imm = 0xC0300
orl %edx, %ecx
addl %eax, %ecx
addl $0x10000, %ecx # imm = 0x10000
movl $0x4, %eax
jmp 0xc99cf
shll $0x8, %edi
movzbl 0x1(%rdx), %ecx
orl %edi, %ecx
movl $0x2, %eax
movl %ecx, %ecx
movq %rcx, (%rsi)
popq %rbp
retq
| my_utf16_uni:
push rbp
mov rbp, rsp
lea r8, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp r8, rcx
ja loc_C99D4
movzx edi, byte ptr [rdx]
mov r9d, edi
and r9d, 0FFFFFFFCh
xor eax, eax
cmp r9d, 0DCh
jz short loc_C99D4
cmp r9d, 0D8h
jnz short loc_C99C1
lea r9, [rdx+4]
mov eax, 0FFFFFF98h
cmp r9, rcx
ja short loc_C99D4
movzx ecx, byte ptr [r8]
mov r8d, ecx
and r8d, 0FFFFFFFCh
mov eax, 0
cmp r8d, 0DCh
jnz short loc_C99D4
shl edi, 12h
shl ecx, 8
or ecx, edi
movzx eax, byte ptr [rdx+1]
shl eax, 0Ah
movzx edx, byte ptr [rdx+3]
and ecx, 0C0300h
or ecx, edx
add ecx, eax
add ecx, 10000h
mov eax, 4
jmp short loc_C99CF
loc_C99C1:
shl edi, 8
movzx ecx, byte ptr [rdx+1]
or ecx, edi
mov eax, 2
loc_C99CF:
mov ecx, ecx
mov [rsi], rcx
loc_C99D4:
pop rbp
retn
| long long my_utf16_uni(long long a1, _QWORD *a2, unsigned __int8 *a3, unsigned long long a4)
{
_BYTE *v4; // r8
long long result; // rax
int v6; // edi
int v7; // r9d
unsigned int v8; // ecx
v4 = a3 + 2;
result = 4294967194LL;
if ( (unsigned long long)(a3 + 2) <= a4 )
{
v6 = *a3;
v7 = v6 & 0xFC;
result = 0LL;
if ( v7 != 220 )
{
if ( v7 != 216 )
{
v8 = (v6 << 8) | a3[1];
result = 2LL;
goto LABEL_8;
}
result = 4294967192LL;
if ( (unsigned long long)(a3 + 4) <= a4 )
{
result = 0LL;
if ( (*v4 & 0xFC) == 0xDC )
{
v8 = (a3[1] << 10) + (a3[3] | ((v6 << 18) | ((unsigned __int8)*v4 << 8)) & 0xC0300) + 0x10000;
result = 4LL;
LABEL_8:
*a2 = v8;
}
}
}
}
return result;
}
| my_utf16_uni:
PUSH RBP
MOV RBP,RSP
LEA R8,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP R8,RCX
JA 0x001c99d4
MOVZX EDI,byte ptr [RDX]
MOV R9D,EDI
AND R9D,0xfffffffc
XOR EAX,EAX
CMP R9D,0xdc
JZ 0x001c99d4
CMP R9D,0xd8
JNZ 0x001c99c1
LEA R9,[RDX + 0x4]
MOV EAX,0xffffff98
CMP R9,RCX
JA 0x001c99d4
MOVZX ECX,byte ptr [R8]
MOV R8D,ECX
AND R8D,0xfffffffc
MOV EAX,0x0
CMP R8D,0xdc
JNZ 0x001c99d4
SHL EDI,0x12
SHL ECX,0x8
OR ECX,EDI
MOVZX EAX,byte ptr [RDX + 0x1]
SHL EAX,0xa
MOVZX EDX,byte ptr [RDX + 0x3]
AND ECX,0xc0300
OR ECX,EDX
ADD ECX,EAX
ADD ECX,0x10000
MOV EAX,0x4
JMP 0x001c99cf
LAB_001c99c1:
SHL EDI,0x8
MOVZX ECX,byte ptr [RDX + 0x1]
OR ECX,EDI
MOV EAX,0x2
LAB_001c99cf:
MOV ECX,ECX
MOV qword ptr [RSI],RCX
LAB_001c99d4:
POP RBP
RET
|
int8 my_utf16_uni(int8 param_1,ulong *param_2,byte *param_3,byte *param_4)
{
byte bVar1;
byte bVar2;
int8 uVar3;
uint uVar4;
uVar3 = 0xffffff9a;
if (param_3 + 2 <= param_4) {
bVar1 = *param_3;
uVar3 = 0;
if ((bVar1 & 0xfc) != 0xdc) {
if ((bVar1 & 0xfc) == 0xd8) {
if (param_4 < param_3 + 4) {
return 0xffffff98;
}
bVar2 = param_3[2];
if ((bVar2 & 0xfc) != 0xdc) {
return 0;
}
uVar4 = (((uint)bVar2 << 8 | (uint)bVar1 << 0x12) & 0xc0300 | (uint)param_3[3]) +
(uint)param_3[1] * 0x400 + 0x10000;
uVar3 = 4;
}
else {
uVar4 = (uint)CONCAT11(bVar1,param_3[1]);
uVar3 = 2;
}
*param_2 = (ulong)uVar4;
}
}
return uVar3;
}
| |
43,457 | typed_array_init | bluesky950520[P]quickjs/quickjs.c | static int typed_array_init(JSContext *ctx, JSValue obj, JSValue buffer,
uint64_t offset, uint64_t len, BOOL track_rab)
{
JSTypedArray *ta;
JSObject *p, *pbuffer;
JSArrayBuffer *abuf;
int size_log2;
p = JS_VALUE_GET_OBJ(obj);
size_log2 = typed_array_size_log2(p->class_id);
ta = js_malloc(ctx, sizeof(*ta));
if (!ta) {
JS_FreeValue(ctx, buffer);
return -1;
}
pbuffer = JS_VALUE_GET_OBJ(buffer);
abuf = pbuffer->u.array_buffer;
ta->obj = p;
ta->buffer = pbuffer;
ta->offset = offset;
ta->length = len << size_log2;
ta->track_rab = track_rab;
list_add_tail(&ta->link, &abuf->array_list);
p->u.typed_array = ta;
p->u.array.count = len;
p->u.array.u.ptr = abuf->data + offset;
return 0;
} | O2 | c | typed_array_init:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbp
movzwl 0x6(%rsi), %eax
leaq 0x195c6(%rip), %rcx # 0x87aef
movzbl -0x15(%rax,%rcx), %r13d
pushq $0x30
popq %rsi
callq 0x1adc4
testq %rax, %rax
je 0x6e58a
movl 0x40(%rsp), %edx
movq 0x30(%r12), %rsi
movq %r15, 0x10(%rax)
movq %r14, %rdi
movl %r13d, %ecx
shlq %cl, %rdi
movq %r12, 0x18(%rax)
movl %ebx, 0x20(%rax)
movl %edi, 0x24(%rax)
movl %edx, 0x28(%rax)
leaq 0x18(%rsi), %rcx
movq 0x18(%rsi), %rdx
movq %rax, 0x8(%rdx)
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rax, 0x18(%rsi)
movq %rax, 0x30(%r15)
movl %r14d, 0x40(%r15)
addq 0x10(%rsi), %rbx
movq %rbx, 0x38(%r15)
xorl %eax, %eax
jmp 0x6e59c
movq %rbp, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x1bbce
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| typed_array_init:
push rbp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov rbx, r8
mov [rsp+38h+var_38], rcx
mov r12, rdx
mov r15, rsi
mov rbp, rdi
movzx eax, word ptr [rsi+6]
lea rcx, typed_array_size_log2
movzx r13d, byte ptr [rax+rcx-15h]
push 30h ; '0'
pop rsi
call js_malloc
test rax, rax
jz short loc_6E58A
mov edx, [rsp+38h+arg_0]
mov rsi, [r12+30h]
mov [rax+10h], r15
mov rdi, r14
mov ecx, r13d
shl rdi, cl
mov [rax+18h], r12
mov [rax+20h], ebx
mov [rax+24h], edi
mov [rax+28h], edx
lea rcx, [rsi+18h]
mov rdx, [rsi+18h]
mov [rdx+8], rax
mov [rax], rdx
mov [rax+8], rcx
mov [rsi+18h], rax
mov [r15+30h], rax
mov [r15+40h], r14d
add rbx, [rsi+10h]
mov [r15+38h], rbx
xor eax, eax
jmp short loc_6E59C
loc_6E58A:
mov rdi, rbp
mov rsi, r12
mov rdx, [rsp+38h+var_38]
call JS_FreeValue
push 0FFFFFFFFFFFFFFFFh
pop rax
loc_6E59C:
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long typed_array_init(long long a1, long long a2, long long a3, long long a4, long long a5, long long a6, int a7)
{
char v11; // r13
long long v12; // rax
long long v13; // rsi
long long v14; // rdx
v11 = typed_array_size_log2[*(unsigned __int16 *)(a2 + 6) - 21];
v12 = js_malloc(a1, 48LL);
if ( v12 )
{
v13 = *(_QWORD *)(a3 + 48);
*(_QWORD *)(v12 + 16) = a2;
*(_QWORD *)(v12 + 24) = a3;
*(_DWORD *)(v12 + 32) = a5;
*(_DWORD *)(v12 + 36) = a6 << v11;
*(_DWORD *)(v12 + 40) = a7;
v14 = *(_QWORD *)(v13 + 24);
*(_QWORD *)(v14 + 8) = v12;
*(_QWORD *)v12 = v14;
*(_QWORD *)(v12 + 8) = v13 + 24;
*(_QWORD *)(v13 + 24) = v12;
*(_QWORD *)(a2 + 48) = v12;
*(_DWORD *)(a2 + 64) = a6;
*(_QWORD *)(a2 + 56) = *(_QWORD *)(v13 + 16) + a5;
return 0LL;
}
else
{
JS_FreeValue(a1, a3, a4);
return -1LL;
}
}
| typed_array_init:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV RBX,R8
MOV qword ptr [RSP],RCX
MOV R12,RDX
MOV R15,RSI
MOV RBP,RDI
MOVZX EAX,word ptr [RSI + 0x6]
LEA RCX,[0x187aef]
MOVZX R13D,byte ptr [RAX + RCX*0x1 + -0x15]
PUSH 0x30
POP RSI
CALL 0x0011adc4
TEST RAX,RAX
JZ 0x0016e58a
MOV EDX,dword ptr [RSP + 0x40]
MOV RSI,qword ptr [R12 + 0x30]
MOV qword ptr [RAX + 0x10],R15
MOV RDI,R14
MOV ECX,R13D
SHL RDI,CL
MOV qword ptr [RAX + 0x18],R12
MOV dword ptr [RAX + 0x20],EBX
MOV dword ptr [RAX + 0x24],EDI
MOV dword ptr [RAX + 0x28],EDX
LEA RCX,[RSI + 0x18]
MOV RDX,qword ptr [RSI + 0x18]
MOV qword ptr [RDX + 0x8],RAX
MOV qword ptr [RAX],RDX
MOV qword ptr [RAX + 0x8],RCX
MOV qword ptr [RSI + 0x18],RAX
MOV qword ptr [R15 + 0x30],RAX
MOV dword ptr [R15 + 0x40],R14D
ADD RBX,qword ptr [RSI + 0x10]
MOV qword ptr [R15 + 0x38],RBX
XOR EAX,EAX
JMP 0x0016e59c
LAB_0016e58a:
MOV RDI,RBP
MOV RSI,R12
MOV RDX,qword ptr [RSP]
CALL 0x0011bbce
PUSH -0x1
POP RAX
LAB_0016e59c:
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
int8
typed_array_init(int8 param_1,long param_2,long param_3,int8 param_4,long param_5,
long param_6,int4 param_7)
{
byte bVar1;
long lVar2;
long lVar3;
long *plVar4;
int8 uVar5;
bVar1 = "toSorted"[(ulong)*(ushort *)(param_2 + 6) + 6];
plVar4 = (long *)js_malloc(param_1,0x30);
if (plVar4 == (long *)0x0) {
JS_FreeValue(param_1,param_3,param_4);
uVar5 = 0xffffffffffffffff;
}
else {
lVar2 = *(long *)(param_3 + 0x30);
plVar4[2] = param_2;
plVar4[3] = param_3;
*(int *)(plVar4 + 4) = (int)param_5;
*(int *)((long)plVar4 + 0x24) = (int)(param_6 << (bVar1 & 0x3f));
*(int4 *)(plVar4 + 5) = param_7;
lVar3 = *(long *)(lVar2 + 0x18);
*(long **)(lVar3 + 8) = plVar4;
*plVar4 = lVar3;
plVar4[1] = lVar2 + 0x18;
*(long **)(lVar2 + 0x18) = plVar4;
*(long **)(param_2 + 0x30) = plVar4;
*(int *)(param_2 + 0x40) = (int)param_6;
*(long *)(param_2 + 0x38) = param_5 + *(long *)(lVar2 + 0x10);
uVar5 = 0;
}
return uVar5;
}
| |
43,458 | mysql_client_find_plugin | eloqsql/build_O3/libmariadb/libmariadb/ma_client_plugin.c | struct st_mysql_client_plugin * STDCALL
mysql_client_find_plugin(MYSQL *mysql, const char *name, int type)
{
struct st_mysql_client_plugin *p;
int plugin_nr= get_plugin_nr(type);
if (is_not_initialized(mysql, name))
return NULL;
if (plugin_nr == -1)
{
my_set_error(mysql, CR_AUTH_PLUGIN_CANNOT_LOAD, SQLSTATE_UNKNOWN,
ER(CR_AUTH_PLUGIN_CANNOT_LOAD), name, "invalid type");
}
if ((p= find_plugin(name, type)))
return p;
/* not found, load it */
return mysql_load_plugin(mysql, name, type, 0);
} | O3 | c | mysql_client_find_plugin:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
leaq 0x10b5b(%rip), %rcx # 0x383d0
cmpl %r15d, (%rax,%rcx)
je 0x278c1
addq $0x8, %rax
cmpq $0x30, %rax
jne 0x27875
cmpb $0x0, 0x22ee4(%rip) # 0x4a770
je 0x278f7
leaq 0x2119b(%rip), %rax # 0x48a30
movq (%rax), %rdx
leaq 0x211a1(%rip), %rax # 0x48a40
movq 0x1d8(%rax), %rcx
leaq 0xd659(%rip), %r9 # 0x34f06
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
xorl %eax, %eax
callq 0x15589
jmp 0x278ca
cmpb $0x0, 0x22ea8(%rip) # 0x4a770
je 0x278f7
movq %rbx, %rdi
movl %r15d, %esi
callq 0x274d3
movq %rax, %r12
testq %rax, %rax
jne 0x2792b
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %edx
xorl %ecx, %ecx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x277e9
leaq 0x21132(%rip), %rax # 0x48a30
movq (%rax), %rdx
leaq 0x21138(%rip), %rax # 0x48a40
movq 0x1d8(%rax), %rcx
leaq 0xd65c(%rip), %r9 # 0x34f72
xorl %r12d, %r12d
movq %r14, %rdi
movl $0x80b, %esi # imm = 0x80B
movq %rbx, %r8
xorl %eax, %eax
callq 0x15589
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| mysql_client_find_plugin:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
mov r15d, edx
mov rbx, rsi
mov r14, rdi
xor eax, eax
lea rcx, valid_plugins
loc_27875:
cmp [rax+rcx], r15d
jz short loc_278C1
add rax, 8
cmp rax, 30h ; '0'
jnz short loc_27875
cmp cs:initialized, 0
jz short loc_278F7
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aInvalidType; "invalid type"
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
xor eax, eax
call my_set_error
jmp short loc_278CA
loc_278C1:
cmp cs:initialized, 0
jz short loc_278F7
loc_278CA:
mov rdi, rbx
mov esi, r15d
call find_plugin
mov r12, rax
test rax, rax
jnz short loc_2792B
mov rdi, r14
mov rsi, rbx
mov edx, r15d
xor ecx, ecx
xor eax, eax
pop rbx
pop r12
pop r14
pop r15
pop rbp
jmp mysql_load_plugin
loc_278F7:
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
lea rax, client_errors
mov rcx, [rax+1D8h]
lea r9, aNotInitialized; "not initialized"
xor r12d, r12d
mov rdi, r14
mov esi, 80Bh
mov r8, rbx
xor eax, eax
call my_set_error
loc_2792B:
mov rax, r12
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long mysql_client_find_plugin(
long long a1,
const char *a2,
int a3,
__m128 a4,
__m128 a5,
__m128 a6,
__m128 a7,
double a8,
double a9,
__m128 a10,
__m128 a11,
long long a12,
long long a13,
long long a14,
char a15)
{
long long v16; // rax
long long v17; // r8
long long v18; // r9
long long plugin; // r12
__m128 v20; // xmm4
__m128 v21; // xmm5
v16 = 0LL;
while ( valid_plugins[v16] != a3 )
{
v16 += 2LL;
if ( v16 == 12 )
{
if ( initialized )
{
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "invalid type");
goto LABEL_7;
}
LABEL_9:
plugin = 0LL;
my_set_error(a1, 2059, (long long)SQLSTATE_UNKNOWN, client_errors[59], a2, "not initialized");
return plugin;
}
}
if ( !initialized )
goto LABEL_9;
LABEL_7:
plugin = find_plugin((long long)a2, a3);
if ( !plugin )
return mysql_load_plugin(a1, a2, a3, 0, v17, v18, a4, a5, a6, a7, v20, v21, a10, a11, a15);
return plugin;
}
| mysql_client_find_plugin:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
MOV R15D,EDX
MOV RBX,RSI
MOV R14,RDI
XOR EAX,EAX
LEA RCX,[0x1383d0]
LAB_00127875:
CMP dword ptr [RAX + RCX*0x1],R15D
JZ 0x001278c1
ADD RAX,0x8
CMP RAX,0x30
JNZ 0x00127875
CMP byte ptr [0x0014a770],0x0
JZ 0x001278f7
LEA RAX,[0x148a30]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x148a40]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x134f06]
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
XOR EAX,EAX
CALL 0x00115589
JMP 0x001278ca
LAB_001278c1:
CMP byte ptr [0x0014a770],0x0
JZ 0x001278f7
LAB_001278ca:
MOV RDI,RBX
MOV ESI,R15D
CALL 0x001274d3
MOV R12,RAX
TEST RAX,RAX
JNZ 0x0012792b
MOV RDI,R14
MOV RSI,RBX
MOV EDX,R15D
XOR ECX,ECX
XOR EAX,EAX
POP RBX
POP R12
POP R14
POP R15
POP RBP
JMP 0x001277e9
LAB_001278f7:
LEA RAX,[0x148a30]
MOV RDX,qword ptr [RAX]
LEA RAX,[0x148a40]
MOV RCX,qword ptr [RAX + 0x1d8]
LEA R9,[0x134f72]
XOR R12D,R12D
MOV RDI,R14
MOV ESI,0x80b
MOV R8,RBX
XOR EAX,EAX
CALL 0x00115589
LAB_0012792b:
MOV RAX,R12
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
long mysql_client_find_plugin(int8 param_1,int8 param_2,int param_3)
{
long lVar1;
lVar1 = 0;
do {
if (*(int *)((long)&valid_plugins + lVar1) == param_3) {
if (initialized != '\0') goto LAB_001278ca;
goto LAB_001278f7;
}
lVar1 = lVar1 + 8;
} while (lVar1 != 0x30);
if (initialized == '\0') {
LAB_001278f7:
lVar1 = 0;
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____00148c18,
param_2,"not initialized");
}
else {
my_set_error(param_1,0x80b,SQLSTATE_UNKNOWN,PTR_s_Plugin__s_could_not_be_loaded____00148c18,
param_2,"invalid type");
LAB_001278ca:
lVar1 = find_plugin(param_2,param_3);
if (lVar1 == 0) {
lVar1 = mysql_load_plugin(param_1,param_2,param_3,0);
return lVar1;
}
}
return lVar1;
}
| |
43,459 | psi_rwlock_wrlock | eloqsql/mysys/my_thr_init.c | ATTRIBUTE_COLD
int psi_rwlock_wrlock(mysql_rwlock_t *that, const char *file, uint line)
{
PSI_rwlock_locker_state state;
PSI_rwlock_locker *locker= PSI_RWLOCK_CALL(start_rwlock_wrwait)
(&state, that->m_psi, PSI_RWLOCK_WRITELOCK, file, line);
int result= rw_wrlock(&that->m_rwlock);
if (locker)
PSI_RWLOCK_CALL(end_rwlock_wrwait)(locker, result);
return result;
} | O0 | c | psi_rwlock_wrlock:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0x1c99be(%rip), %rax # 0x2c8038
movq (%rax), %rax
movq 0x1b0(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x90(%rcx), %rsi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
leaq -0x48(%rbp), %rdi
movl $0x1, %edx
callq *%rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x101ce0
movl %eax, -0x54(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xfe6d3
leaq 0x1c9978(%rip), %rax # 0x2c8038
movq (%rax), %rax
movq 0x1b8(%rax), %rax
movq -0x50(%rbp), %rdi
movl -0x54(%rbp), %esi
callq *%rax
movl -0x54(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| psi_rwlock_wrlock:
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_8], rdi
mov [rbp+var_10], rsi
mov [rbp+var_14], edx
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B0h]
mov rcx, [rbp+var_8]
mov rsi, [rcx+90h]
mov rcx, [rbp+var_10]
mov r8d, [rbp+var_14]
lea rdi, [rbp+var_48]
mov edx, 1
call rax
mov [rbp+var_50], rax
mov rdi, [rbp+var_8]
call my_rw_wrlock
mov [rbp+var_54], eax
cmp [rbp+var_50], 0
jz short loc_FE6D3
lea rax, PSI_server
mov rax, [rax]
mov rax, [rax+1B8h]
mov rdi, [rbp+var_50]
mov esi, [rbp+var_54]
call rax
loc_FE6D3:
mov eax, [rbp+var_54]
add rsp, 60h
pop rbp
retn
| long long psi_rwlock_wrlock(long long a1, long long a2, unsigned int a3)
{
unsigned int v4; // [rsp+Ch] [rbp-54h]
long long v5; // [rsp+10h] [rbp-50h]
_BYTE v6[52]; // [rsp+18h] [rbp-48h] BYREF
unsigned int v7; // [rsp+4Ch] [rbp-14h]
long long v8; // [rsp+50h] [rbp-10h]
long long v9; // [rsp+58h] [rbp-8h]
v9 = a1;
v8 = a2;
v7 = a3;
v5 = ((long long ( *)(_BYTE *, _QWORD, long long, long long, _QWORD))PSI_server[54])(
v6,
*(_QWORD *)(a1 + 144),
1LL,
a2,
a3);
v4 = my_rw_wrlock(v9);
if ( v5 )
((void ( *)(long long, _QWORD))PSI_server[55])(v5, v4);
return v4;
}
| psi_rwlock_wrlock:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x8],RDI
MOV qword ptr [RBP + -0x10],RSI
MOV dword ptr [RBP + -0x14],EDX
LEA RAX,[0x3c8038]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b0]
MOV RCX,qword ptr [RBP + -0x8]
MOV RSI,qword ptr [RCX + 0x90]
MOV RCX,qword ptr [RBP + -0x10]
MOV R8D,dword ptr [RBP + -0x14]
LEA RDI,[RBP + -0x48]
MOV EDX,0x1
CALL RAX
MOV qword ptr [RBP + -0x50],RAX
MOV RDI,qword ptr [RBP + -0x8]
CALL 0x00201ce0
MOV dword ptr [RBP + -0x54],EAX
CMP qword ptr [RBP + -0x50],0x0
JZ 0x001fe6d3
LEA RAX,[0x3c8038]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x1b8]
MOV RDI,qword ptr [RBP + -0x50]
MOV ESI,dword ptr [RBP + -0x54]
CALL RAX
LAB_001fe6d3:
MOV EAX,dword ptr [RBP + -0x54]
ADD RSP,0x60
POP RBP
RET
|
int4 psi_rwlock_wrlock(long param_1,int8 param_2,int4 param_3)
{
int4 uVar1;
long lVar2;
int1 local_50 [52];
int4 local_1c;
int8 local_18;
long local_10;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
lVar2 = (**(code **)(PSI_server + 0x1b0))
(local_50,*(int8 *)(param_1 + 0x90),1,param_2,param_3);
uVar1 = my_rw_wrlock(local_10);
if (lVar2 != 0) {
(**(code **)(PSI_server + 0x1b8))(lVar2,uVar1);
}
return uVar1;
}
| |
43,460 | ma_columndef_write | eloqsql/storage/maria/ma_open.c | my_bool _ma_columndef_write(File file, MARIA_COLUMNDEF *columndef)
{
uchar buff[MARIA_COLUMNDEF_SIZE];
uchar *ptr=buff;
uint low_offset= (uint) (columndef->offset & 0xffff);
uint high_offset= (uint) (columndef->offset >> 16);
mi_int2store(ptr,(ulong) columndef->column_nr); ptr+= 2;
mi_int2store(ptr, low_offset); ptr+= 2;
mi_int2store(ptr,columndef->type); ptr+= 2;
mi_int2store(ptr,columndef->length); ptr+= 2;
mi_int2store(ptr,columndef->fill_length); ptr+= 2;
mi_int2store(ptr,columndef->null_pos); ptr+= 2;
mi_int2store(ptr,columndef->empty_pos); ptr+= 2;
(*ptr++)= columndef->null_bit;
(*ptr++)= columndef->empty_bit;
mi_int2store(ptr, high_offset); ptr+= 2;
ptr[0]= ptr[1]= 0; ptr+= 2; /* For future */
return mysql_file_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
} | O0 | c | ma_columndef_write:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl %edi, -0x24(%rbp)
movq %rsi, -0x30(%rbp)
leaq -0x20(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0x4(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movzwl 0x6(%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x44(%rbp)
movb -0x44(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x43(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x48(%rbp)
movb -0x48(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x47(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movb -0x4c(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x4b(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movb -0x50(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x4f(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xc(%rax), %eax
movl %eax, -0x54(%rbp)
movb -0x54(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x53(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0xe(%rax), %eax
movl %eax, -0x58(%rbp)
movb -0x58(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x57(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movzwl 0x10(%rax), %eax
movl %eax, -0x5c(%rbp)
movb -0x5c(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x5b(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movb 0x12(%rax), %dl
movq -0x38(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x38(%rbp)
movb %dl, (%rax)
movq -0x30(%rbp), %rax
movb 0x13(%rax), %dl
movq -0x38(%rbp), %rax
movq %rax, %rsi
incq %rsi
movq %rsi, -0x38(%rbp)
movb %dl, (%rax)
movl -0x40(%rbp), %eax
movl %eax, -0x60(%rbp)
movb -0x60(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, 0x1(%rax)
movb -0x5f(%rbp), %dl
movq -0x38(%rbp), %rax
movb %dl, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, 0x1(%rax)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movl -0x24(%rbp), %edx
movq -0x38(%rbp), %r8
subq %rcx, %r8
leaq 0xc59da(%rip), %rdi # 0x1589a2
movl $0x77b, %esi # imm = 0x77B
movl $0x4, %r9d
callq 0x918f0
testq %rax, %rax
setne %al
movb %al, -0x61(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x92ffc
movb -0x61(%rbp), %al
addq $0x70, %rsp
popq %rbp
retq
callq 0x2a250
nopw %cs:(%rax,%rax)
| _ma_columndef_write:
push rbp
mov rbp, rsp
sub rsp, 70h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_24], edi
mov [rbp+var_30], rsi
lea rcx, [rbp+var_20]
mov [rbp+var_38], rcx
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+4]
mov [rbp+var_3C], eax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+6]
mov [rbp+var_40], eax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Ah]
mov [rbp+var_44], eax
mov dl, byte ptr [rbp+var_44]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_44+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov eax, [rbp+var_3C]
mov [rbp+var_48], eax
mov dl, byte ptr [rbp+var_48]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_48+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov eax, [rax]
mov [rbp+var_4C], eax
mov dl, byte ptr [rbp+var_4C]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_4C+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+8]
mov [rbp+var_50], eax
mov dl, byte ptr [rbp+var_50]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_50+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Ch]
mov [rbp+var_54], eax
mov dl, byte ptr [rbp+var_54]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_54+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+0Eh]
mov [rbp+var_58], eax
mov dl, byte ptr [rbp+var_58]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_58+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
movzx eax, word ptr [rax+10h]
mov [rbp+var_5C], eax
mov dl, byte ptr [rbp+var_5C]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_5C+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_30]
mov dl, [rax+12h]
mov rax, [rbp+var_38]
mov rsi, rax
inc rsi
mov [rbp+var_38], rsi
mov [rax], dl
mov rax, [rbp+var_30]
mov dl, [rax+13h]
mov rax, [rbp+var_38]
mov rsi, rax
inc rsi
mov [rbp+var_38], rsi
mov [rax], dl
mov eax, [rbp+var_40]
mov [rbp+var_60], eax
mov dl, byte ptr [rbp+var_60]
mov rax, [rbp+var_38]
mov [rax+1], dl
mov dl, byte ptr [rbp+var_60+1]
mov rax, [rbp+var_38]
mov [rax], dl
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov rax, [rbp+var_38]
mov byte ptr [rax+1], 0
mov rax, [rbp+var_38]
mov byte ptr [rax], 0
mov rax, [rbp+var_38]
add rax, 2
mov [rbp+var_38], rax
mov edx, [rbp+var_24]
mov r8, [rbp+var_38]
sub r8, rcx
lea rdi, aWorkspaceLlm4b_18; "/workspace/llm4binary/github2025/eloqsq"...
mov esi, 77Bh
mov r9d, 4
call inline_mysql_file_write_0
test rax, rax
setnz al
mov [rbp+var_61], al
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_92FFC
mov al, [rbp+var_61]
add rsp, 70h
pop rbp
retn
loc_92FFC:
call ___stack_chk_fail
| bool ma_columndef_write(unsigned int a1, long long a2)
{
__int16 v2; // kr00_2
__int16 v3; // kr04_2
__int16 v4; // kr06_2
__int16 v5; // kr08_2
__int16 v6; // kr0A_2
__int16 v7; // kr0C_2
__int16 v9; // [rsp+30h] [rbp-40h]
__int16 v10; // [rsp+34h] [rbp-3Ch]
_BYTE v11[24]; // [rsp+50h] [rbp-20h] BYREF
unsigned long long v12; // [rsp+68h] [rbp-8h]
v12 = __readfsqword(0x28u);
v10 = *(_WORD *)(a2 + 4);
v9 = *(_WORD *)(a2 + 6);
v2 = *(_WORD *)(a2 + 10);
v11[0] = HIBYTE(v2);
v11[1] = v2;
v11[2] = HIBYTE(v10);
v11[3] = v10;
v3 = *(_DWORD *)a2;
v11[4] = HIBYTE(v3);
v11[5] = v3;
v4 = *(_WORD *)(a2 + 8);
v11[6] = HIBYTE(v4);
v11[7] = v4;
v5 = *(_WORD *)(a2 + 12);
v11[8] = HIBYTE(v5);
v11[9] = v5;
v6 = *(_WORD *)(a2 + 14);
v11[10] = HIBYTE(v6);
v11[11] = v6;
v7 = *(_WORD *)(a2 + 16);
v11[12] = HIBYTE(v7);
v11[13] = v7;
v11[14] = *(_BYTE *)(a2 + 18);
v11[15] = *(_BYTE *)(a2 + 19);
v11[16] = HIBYTE(v9);
v11[17] = v9;
v11[19] = 0;
v11[18] = 0;
return inline_mysql_file_write_0(
(long long)"/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",
0x77Bu,
a1,
(long long)v11,
20LL,
4LL) != 0;
}
| _ma_columndef_write:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x70
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV dword ptr [RBP + -0x24],EDI
MOV qword ptr [RBP + -0x30],RSI
LEA RCX,[RBP + -0x20]
MOV qword ptr [RBP + -0x38],RCX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x4]
MOV dword ptr [RBP + -0x3c],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x6]
MOV dword ptr [RBP + -0x40],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x44],EAX
MOV DL,byte ptr [RBP + -0x44]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x43]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x48],EAX
MOV DL,byte ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x47]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV EAX,dword ptr [RAX]
MOV dword ptr [RBP + -0x4c],EAX
MOV DL,byte ptr [RBP + -0x4c]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x4b]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x8]
MOV dword ptr [RBP + -0x50],EAX
MOV DL,byte ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x4f]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xc]
MOV dword ptr [RBP + -0x54],EAX
MOV DL,byte ptr [RBP + -0x54]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x53]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0xe]
MOV dword ptr [RBP + -0x58],EAX
MOV DL,byte ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x57]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOVZX EAX,word ptr [RAX + 0x10]
MOV dword ptr [RBP + -0x5c],EAX
MOV DL,byte ptr [RBP + -0x5c]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x5b]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x30]
MOV DL,byte ptr [RAX + 0x12]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RAX
INC RSI
MOV qword ptr [RBP + -0x38],RSI
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x30]
MOV DL,byte ptr [RAX + 0x13]
MOV RAX,qword ptr [RBP + -0x38]
MOV RSI,RAX
INC RSI
MOV qword ptr [RBP + -0x38],RSI
MOV byte ptr [RAX],DL
MOV EAX,dword ptr [RBP + -0x40]
MOV dword ptr [RBP + -0x60],EAX
MOV DL,byte ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],DL
MOV DL,byte ptr [RBP + -0x5f]
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],DL
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX + 0x1],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV byte ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x38]
ADD RAX,0x2
MOV qword ptr [RBP + -0x38],RAX
MOV EDX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x38]
SUB R8,RCX
LEA RDI,[0x2589a2]
MOV ESI,0x77b
MOV R9D,0x4
CALL 0x001918f0
TEST RAX,RAX
SETNZ AL
MOV byte ptr [RBP + -0x61],AL
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00192ffc
MOV AL,byte ptr [RBP + -0x61]
ADD RSP,0x70
POP RBP
RET
LAB_00192ffc:
CALL 0x0012a250
|
int8 _ma_columndef_write(int4 param_1,int4 *param_2)
{
long lVar1;
long in_FS_OFFSET;
int1 local_68;
int1 uStack_67;
int1 local_64;
int1 uStack_63;
int1 local_60;
int1 uStack_5f;
int1 local_5c;
int1 uStack_5b;
int1 local_58;
int1 uStack_57;
int1 local_54;
int1 uStack_53;
int1 local_50;
int1 uStack_4f;
int1 local_4c;
int1 uStack_4b;
int1 local_28;
int1 local_27;
int1 local_26;
int1 local_25;
int1 local_24;
int1 local_23;
int1 local_22;
int1 local_21;
int1 local_20;
int1 local_1f;
int1 local_1e;
int1 local_1d;
int1 local_1c;
int1 local_1b;
int1 local_1a;
int1 local_19;
int1 local_18;
int1 local_17;
int1 local_16;
int1 local_15;
int1 auStack_14 [4];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_4c = (int1)*(int2 *)((long)param_2 + 10);
local_27 = local_4c;
uStack_4b = (int1)((ushort)*(int2 *)((long)param_2 + 10) >> 8);
local_28 = uStack_4b;
local_50 = (int1)*(int2 *)(param_2 + 1);
local_25 = local_50;
uStack_4f = (int1)((ushort)*(int2 *)(param_2 + 1) >> 8);
local_26 = uStack_4f;
local_54 = (int1)*param_2;
local_23 = local_54;
uStack_53 = (int1)((uint)*param_2 >> 8);
local_24 = uStack_53;
local_58 = (int1)*(int2 *)(param_2 + 2);
local_21 = local_58;
uStack_57 = (int1)((ushort)*(int2 *)(param_2 + 2) >> 8);
local_22 = uStack_57;
local_5c = (int1)*(int2 *)(param_2 + 3);
local_1f = local_5c;
uStack_5b = (int1)((ushort)*(int2 *)(param_2 + 3) >> 8);
local_20 = uStack_5b;
local_60 = (int1)*(int2 *)((long)param_2 + 0xe);
local_1d = local_60;
uStack_5f = (int1)((ushort)*(int2 *)((long)param_2 + 0xe) >> 8);
local_1e = uStack_5f;
local_64 = (int1)*(int2 *)(param_2 + 4);
local_1b = local_64;
uStack_63 = (int1)((ushort)*(int2 *)(param_2 + 4) >> 8);
local_1c = uStack_63;
local_1a = *(int1 *)((long)param_2 + 0x12);
local_19 = *(int1 *)((long)param_2 + 0x13);
local_68 = (int1)*(int2 *)((long)param_2 + 6);
local_17 = local_68;
uStack_67 = (int1)((ushort)*(int2 *)((long)param_2 + 6) >> 8);
local_18 = uStack_67;
local_15 = 0;
local_16 = 0;
lVar1 = inline_mysql_file_write
("/workspace/llm4binary/github2025/eloqsql/storage/maria/ma_open.c",0x77b,
param_1,&local_28,auStack_14 + -(long)&local_28,4);
if (*(long *)(in_FS_OFFSET + 0x28) == local_10) {
return CONCAT71((int7)((ulong)*(long *)(in_FS_OFFSET + 0x28) >> 8),lVar1 != 0);
}
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
| |
43,461 | LefDefParser::lefiLayer::addSpParallelWidthSpacing() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiLayer.cpp | void
lefiLayer::addSpParallelWidthSpacing()
{
lefiSpacingTable *sp;
sp = spacingTable_[numSpacingTable_ - 1];
sp->addParallelWidthSpacing(numNums_, nums_);
// Since inside addParallelWidthSpacing copy the nums_, we can free it
// here
lefFree((char*) (nums_));
numNums_ = 0;
numAllocated_ = 0;
nums_ = 0;
} | O0 | cpp | LefDefParser::lefiLayer::addSpParallelWidthSpacing():
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x4b0(%rax), %rcx
movl 0x4a8(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl 0x398(%rax), %esi
movq 0x3a0(%rax), %rdx
callq 0x1c030
movq (%rsp), %rax
movq 0x3a0(%rax), %rdi
callq 0x38c90
movq (%rsp), %rax
movl $0x0, 0x398(%rax)
movl $0x0, 0x39c(%rax)
movq $0x0, 0x3a0(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
| _ZN12LefDefParser9lefiLayer25addSpParallelWidthSpacingEv:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov rax, [rsp+18h+var_8]
mov [rsp+18h+var_18], rax
mov rcx, [rax+4B0h]
mov edx, [rax+4A8h]
sub edx, 1
movsxd rdx, edx
mov rcx, [rcx+rdx*8]
mov [rsp+18h+var_10], rcx
mov rdi, [rsp+18h+var_10]; this
mov esi, [rax+398h]; void *
mov rdx, [rax+3A0h]; double *
call _ZN12LefDefParser16lefiSpacingTable23addParallelWidthSpacingEiPd; LefDefParser::lefiSpacingTable::addParallelWidthSpacing(int,double *)
mov rax, [rsp+18h+var_18]
mov rdi, [rax+3A0h]; this
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
mov rax, [rsp+18h+var_18]
mov dword ptr [rax+398h], 0
mov dword ptr [rax+39Ch], 0
mov qword ptr [rax+3A0h], 0
add rsp, 18h
retn
| LefDefParser::lefiLayer * LefDefParser::lefiLayer::addSpParallelWidthSpacing(LefDefParser::lefiLayer *this)
{
void *v1; // rsi
LefDefParser::lefiLayer *result; // rax
v1 = (void *)*((unsigned int *)this + 230);
LefDefParser::lefiSpacingTable::addParallelWidthSpacing(
*(LefDefParser::lefiParallel ***)(*((_QWORD *)this + 150) + 8LL * (*((_DWORD *)this + 298) - 1)),
(int)v1,
*((double **)this + 116));
LefDefParser::lefFree(*((LefDefParser **)this + 116), v1);
result = this;
*((_DWORD *)this + 230) = 0;
*((_DWORD *)this + 231) = 0;
*((_QWORD *)this + 116) = 0LL;
return result;
}
| addSpParallelWidthSpacing:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV RAX,qword ptr [RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV RCX,qword ptr [RAX + 0x4b0]
MOV EDX,dword ptr [RAX + 0x4a8]
SUB EDX,0x1
MOVSXD RDX,EDX
MOV RCX,qword ptr [RCX + RDX*0x8]
MOV qword ptr [RSP + 0x8],RCX
MOV RDI,qword ptr [RSP + 0x8]
MOV ESI,dword ptr [RAX + 0x398]
MOV RDX,qword ptr [RAX + 0x3a0]
CALL 0x0011c030
MOV RAX,qword ptr [RSP]
MOV RDI,qword ptr [RAX + 0x3a0]
CALL 0x00138c90
MOV RAX,qword ptr [RSP]
MOV dword ptr [RAX + 0x398],0x0
MOV dword ptr [RAX + 0x39c],0x0
MOV qword ptr [RAX + 0x3a0],0x0
ADD RSP,0x18
RET
|
/* LefDefParser::lefiLayer::addSpParallelWidthSpacing() */
void __thiscall LefDefParser::lefiLayer::addSpParallelWidthSpacing(lefiLayer *this)
{
lefiSpacingTable::addParallelWidthSpacing
(*(lefiSpacingTable **)
(*(long *)(this + 0x4b0) + (long)(*(int *)(this + 0x4a8) + -1) * 8),
*(int *)(this + 0x398),*(double **)(this + 0x3a0));
lefFree(*(void **)(this + 0x3a0));
*(int4 *)(this + 0x398) = 0;
*(int4 *)(this + 0x39c) = 0;
*(int8 *)(this + 0x3a0) = 0;
return;
}
| |
43,462 | LefDefParser::lefiLayer::addSpParallelWidthSpacing() | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiLayer.cpp | void
lefiLayer::addSpParallelWidthSpacing()
{
lefiSpacingTable *sp;
sp = spacingTable_[numSpacingTable_ - 1];
sp->addParallelWidthSpacing(numNums_, nums_);
// Since inside addParallelWidthSpacing copy the nums_, we can free it
// here
lefFree((char*) (nums_));
numNums_ = 0;
numAllocated_ = 0;
nums_ = 0;
} | O3 | cpp | LefDefParser::lefiLayer::addSpParallelWidthSpacing():
pushq %rbx
movq %rdi, %rax
leaq 0x398(%rdi), %rbx
movslq 0x398(%rdi), %rcx
movq 0x3a0(%rdi), %rdi
testq %rcx, %rcx
jle 0x1c4b1
movq 0x4b0(%rax), %rdx
movslq 0x4a8(%rax), %rax
movq -0x8(%rdx,%rax,8), %rax
movq 0x10(%rax), %rdx
movslq 0x4(%rdx), %rsi
decq %rsi
movslq (%rdx), %rax
imulq %rsi, %rax
shlq $0x3, %rax
addq 0x20(%rdx), %rax
xorl %edx, %edx
movsd (%rdi,%rdx,8), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x1c49f
callq 0x26040
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
| _ZN12LefDefParser9lefiLayer25addSpParallelWidthSpacingEv:
push rbx
mov rax, rdi
lea rbx, [rdi+398h]
movsxd rcx, dword ptr [rdi+398h]
mov rdi, [rdi+3A0h]; this
test rcx, rcx
jle short loc_1C4B1
mov rdx, [rax+4B0h]
movsxd rax, dword ptr [rax+4A8h]
mov rax, [rdx+rax*8-8]
mov rdx, [rax+10h]
movsxd rsi, dword ptr [rdx+4]
dec rsi; void *
movsxd rax, dword ptr [rdx]
imul rax, rsi
shl rax, 3
add rax, [rdx+20h]
xor edx, edx
loc_1C49F:
movsd xmm0, qword ptr [rdi+rdx*8]
movsd qword ptr [rax+rdx*8], xmm0
inc rdx
cmp rcx, rdx
jnz short loc_1C49F
loc_1C4B1:
call _ZN12LefDefParser7lefFreeEPv; LefDefParser::lefFree(void *)
xorps xmm0, xmm0
movups xmmword ptr [rbx], xmm0
pop rbx
retn
| long long LefDefParser::lefiLayer::addSpParallelWidthSpacing(LefDefParser::lefiLayer *this, long long a2)
{
_OWORD *v3; // rbx
long long v4; // rcx
LefDefParser *v5; // rdi
int *v6; // rdx
long long v7; // rax
long long i; // rdx
long long result; // rax
v3 = (_OWORD *)((char *)this + 920);
v4 = *((int *)this + 230);
v5 = (LefDefParser *)*((_QWORD *)this + 116);
if ( v4 > 0 )
{
v6 = *(int **)(*(_QWORD *)(*((_QWORD *)this + 150) + 8LL * *((int *)this + 298) - 8) + 16LL);
a2 = v6[1] - 1LL;
v7 = *((_QWORD *)v6 + 4) + 8 * a2 * *v6;
for ( i = 0LL; i != v4; ++i )
*(_QWORD *)(v7 + 8 * i) = *((_QWORD *)v5 + i);
}
result = LefDefParser::lefFree(v5, (void *)a2);
*v3 = 0LL;
return result;
}
| addSpParallelWidthSpacing:
PUSH RBX
MOV RAX,RDI
LEA RBX,[RDI + 0x398]
MOVSXD RCX,dword ptr [RDI + 0x398]
MOV RDI,qword ptr [RDI + 0x3a0]
TEST RCX,RCX
JLE 0x0011c4b1
MOV RDX,qword ptr [RAX + 0x4b0]
MOVSXD RAX,dword ptr [RAX + 0x4a8]
MOV RAX,qword ptr [RDX + RAX*0x8 + -0x8]
MOV RDX,qword ptr [RAX + 0x10]
MOVSXD RSI,dword ptr [RDX + 0x4]
DEC RSI
MOVSXD RAX,dword ptr [RDX]
IMUL RAX,RSI
SHL RAX,0x3
ADD RAX,qword ptr [RDX + 0x20]
XOR EDX,EDX
LAB_0011c49f:
MOVSD XMM0,qword ptr [RDI + RDX*0x8]
MOVSD qword ptr [RAX + RDX*0x8],XMM0
INC RDX
CMP RCX,RDX
JNZ 0x0011c49f
LAB_0011c4b1:
CALL 0x00126040
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RBX],XMM0
POP RBX
RET
|
/* LefDefParser::lefiLayer::addSpParallelWidthSpacing() */
void __thiscall LefDefParser::lefiLayer::addSpParallelWidthSpacing(lefiLayer *this)
{
int iVar1;
int iVar2;
int iVar3;
void *pvVar4;
int *piVar5;
long lVar6;
long lVar7;
iVar1 = *(int *)(this + 0x398);
pvVar4 = *(void **)(this + 0x3a0);
if (0 < (long)iVar1) {
piVar5 = *(int **)(*(long *)(*(long *)(this + 0x4b0) + -8 + (long)*(int *)(this + 0x4a8) * 8) +
0x10);
iVar2 = piVar5[1];
iVar3 = *piVar5;
lVar6 = *(long *)(piVar5 + 8);
lVar7 = 0;
do {
*(int8 *)((long)iVar3 * ((long)iVar2 + -1) * 8 + lVar6 + lVar7 * 8) =
*(int8 *)((long)pvVar4 + lVar7 * 8);
lVar7 = lVar7 + 1;
} while (iVar1 != lVar7);
}
lefFree(pvVar4);
*(int8 *)(this + 0x398) = 0;
*(int8 *)(this + 0x3a0) = 0;
return;
}
| |
43,463 | minja::ExpressionNode::~ExpressionNode() | monkey531[P]llama/common/minja.hpp | ExpressionNode(const Location & location, std::shared_ptr<Expression> && e) : TemplateNode(location), expr(std::move(e)) {} | O3 | cpp | minja::ExpressionNode::~ExpressionNode():
pushq %rbx
movq %rdi, %rbx
leaq 0x8d533(%rip), %rax # 0x12b2b8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x9dd9a
callq 0x6d59a
leaq 0x8d237(%rip), %rax # 0x12afd8
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x9ddb6
callq 0x6d59a
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1a8d0
| _ZN5minja14ExpressionNodeD0Ev:
push rbx
mov rbx, rdi
lea rax, _ZTVN5minja14ExpressionNodeE; `vtable for'minja::ExpressionNode
add rax, 10h
mov [rdi], rax
mov rdi, [rdi+28h]
test rdi, rdi
jz short loc_9DD9A
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DD9A:
lea rax, _ZTVN5minja12TemplateNodeE; `vtable for'minja::TemplateNode
add rax, 10h
mov [rbx], rax
mov rdi, [rbx+10h]
test rdi, rdi
jz short loc_9DDB6
call _ZNSt16_Sp_counted_baseILN9__gnu_cxx12_Lock_policyE2EE10_M_releaseEv; std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(void)
loc_9DDB6:
mov esi, 30h ; '0'; unsigned __int64
mov rdi, rbx; void *
pop rbx
jmp __ZdlPvm; operator delete(void *,ulong)
| void minja::ExpressionNode::~ExpressionNode(minja::ExpressionNode *this)
{
volatile signed __int32 *v2; // rdi
volatile signed __int32 *v3; // rdi
*(_QWORD *)this = &`vtable for'minja::ExpressionNode + 2;
v2 = (volatile signed __int32 *)*((_QWORD *)this + 5);
if ( v2 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v2);
*(_QWORD *)this = &`vtable for'minja::TemplateNode + 2;
v3 = (volatile signed __int32 *)*((_QWORD *)this + 2);
if ( v3 )
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release(v3);
operator delete(this, 0x30uLL);
}
| ~ExpressionNode:
PUSH RBX
MOV RBX,RDI
LEA RAX,[0x22b2b8]
ADD RAX,0x10
MOV qword ptr [RDI],RAX
MOV RDI,qword ptr [RDI + 0x28]
TEST RDI,RDI
JZ 0x0019dd9a
CALL 0x0016d59a
LAB_0019dd9a:
LEA RAX,[0x22afd8]
ADD RAX,0x10
MOV qword ptr [RBX],RAX
MOV RDI,qword ptr [RBX + 0x10]
TEST RDI,RDI
JZ 0x0019ddb6
CALL 0x0016d59a
LAB_0019ddb6:
MOV ESI,0x30
MOV RDI,RBX
POP RBX
JMP 0x0011a8d0
|
/* minja::ExpressionNode::~ExpressionNode() */
void __thiscall minja::ExpressionNode::~ExpressionNode(ExpressionNode *this)
{
*(int ***)this = &PTR_do_render_0022b2c8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x28));
}
*(int ***)this = &PTR___cxa_pure_virtual_0022afe8;
if (*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10) !=
(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> *)0x0) {
std::_Sp_counted_base<(__gnu_cxx::_Lock_policy)2>::_M_release
(*(_Sp_counted_base<(__gnu_cxx::_Lock_policy)2> **)(this + 0x10));
}
operator_delete(this,0x30);
return;
}
| |
43,464 | LefDefParser::lefiTiming::addSDF2Pins(char const*, char const*, char const*, double, double, double) | Efficient-TDP/thirdparty/Limbo/limbo/thirdparty/lefdef/5.8/lef/lef/lefiMacro.cpp | void
lefiTiming::addSDF2Pins(const char *trigType,
const char *fromTrig,
const char *toTrig,
double one,
double two,
double three)
{
hasSDFtwoPinTrigger_ = 1;
SDFtriggerType_ = (char*) trigType;
SDFfromTrigger_ = (char*) fromTrig;
SDFtoTrigger_ = (char*) toTrig;
SDFtriggerTableOne_ = one;
SDFtriggerTableTwo_ = two;
SDFtriggerTableThree_ = three;
} | O3 | cpp | LefDefParser::lefiTiming::addSDF2Pins(char const*, char const*, char const*, double, double, double):
movl $0x1, 0x70(%rdi)
movq %rsi, 0x248(%rdi)
movq %rdx, 0x250(%rdi)
movq %rcx, 0x258(%rdi)
movsd %xmm0, 0x260(%rdi)
movsd %xmm1, 0x268(%rdi)
movsd %xmm2, 0x270(%rdi)
retq
nop
| _ZN12LefDefParser10lefiTiming11addSDF2PinsEPKcS2_S2_ddd:
mov dword ptr [rdi+70h], 1
mov [rdi+248h], rsi
mov [rdi+250h], rdx
mov [rdi+258h], rcx
movsd qword ptr [rdi+260h], xmm0
movsd qword ptr [rdi+268h], xmm1
movsd qword ptr [rdi+270h], xmm2
retn
| void LefDefParser::lefiTiming::addSDF2Pins(
LefDefParser::lefiTiming *this,
const char *a2,
const char *a3,
const char *a4,
double a5,
double a6,
double a7)
{
*((_DWORD *)this + 28) = 1;
*((_QWORD *)this + 73) = a2;
*((_QWORD *)this + 74) = a3;
*((_QWORD *)this + 75) = a4;
*((double *)this + 76) = a5;
*((double *)this + 77) = a6;
*((double *)this + 78) = a7;
}
| addSDF2Pins:
MOV dword ptr [RDI + 0x70],0x1
MOV qword ptr [RDI + 0x248],RSI
MOV qword ptr [RDI + 0x250],RDX
MOV qword ptr [RDI + 0x258],RCX
MOVSD qword ptr [RDI + 0x260],XMM0
MOVSD qword ptr [RDI + 0x268],XMM1
MOVSD qword ptr [RDI + 0x270],XMM2
RET
|
/* LefDefParser::lefiTiming::addSDF2Pins(char const*, char const*, char const*, double, double,
double) */
void __thiscall
LefDefParser::lefiTiming::addSDF2Pins
(lefiTiming *this,char *param_1,char *param_2,char *param_3,double param_4,double param_5,
double param_6)
{
*(int4 *)(this + 0x70) = 1;
*(char **)(this + 0x248) = param_1;
*(char **)(this + 0x250) = param_2;
*(char **)(this + 600) = param_3;
*(double *)(this + 0x260) = param_4;
*(double *)(this + 0x268) = param_5;
*(double *)(this + 0x270) = param_6;
return;
}
| |
43,465 | ma_open | eloqsql/libmariadb/libmariadb/ma_io.c | MA_FILE *ma_open(const char *location, const char *mode, MYSQL *mysql)
{
int CodePage= -1;
FILE *fp= NULL;
MA_FILE *ma_file= NULL;
if (!location || !location[0])
return NULL;
#ifdef HAVE_REMOTEIO
if (strstr(location, "://"))
goto remote;
#endif
#ifdef _WIN32
if (mysql && mysql->charset)
CodePage= madb_get_windows_cp(mysql->charset->csname);
#endif
if (CodePage == -1)
{
if (!(fp= fopen(location, mode)))
{
return NULL;
}
}
#ifdef _WIN32
/* See CONC-44: we need to support non ascii filenames too, so we convert
current character set to wchar_t and try to open the file via _wsopen */
else
{
wchar_t *w_filename= NULL;
wchar_t *w_mode= NULL;
int len;
DWORD Length;
len= MultiByteToWideChar(CodePage, 0, location, (int)strlen(location), NULL, 0);
if (!len)
return NULL;
if (!(w_filename= (wchar_t *)calloc(1, (len + 1) * sizeof(wchar_t))))
{
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return NULL;
}
Length= len;
len= MultiByteToWideChar(CodePage, 0, location, (int)strlen(location), w_filename, (int)Length);
if (!len)
{
/* todo: error handling */
free(w_filename);
return NULL;
}
len= (int)strlen(mode);
if (!(w_mode= (wchar_t *)calloc(1, (len + 1) * sizeof(wchar_t))))
{
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
free(w_filename);
return NULL;
}
Length= len;
len= MultiByteToWideChar(CodePage, 0, mode, (int)strlen(mode), w_mode, (int)Length);
if (!len)
{
/* todo: error handling */
free(w_filename);
free(w_mode);
return NULL;
}
fp= _wfopen(w_filename, w_mode);
free(w_filename);
free(w_mode);
}
#endif
if (fp)
{
ma_file= (MA_FILE *)malloc(sizeof(MA_FILE));
if (!ma_file)
{
fclose(fp);
my_set_error(mysql, CR_OUT_OF_MEMORY, SQLSTATE_UNKNOWN, 0);
return NULL;
}
ma_file->type= MA_FILE_LOCAL;
ma_file->ptr= (void *)fp;
}
return ma_file;
#ifdef HAVE_REMOTEIO
remote:
/* check if plugin for remote io is available and try
* to open location */
{
MYSQL mysql;
if (rio_plugin ||(rio_plugin= (struct st_mysql_client_plugin_REMOTEIO *)
mysql_client_find_plugin(&mysql, NULL, MARIADB_CLIENT_REMOTEIO_PLUGIN)))
return rio_plugin->methods->mopen(location, mode);
return NULL;
}
#endif
} | O0 | c | ma_open:
pushq %rbp
movq %rsp, %rbp
subq $0x540, %rsp # imm = 0x540
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x510(%rbp)
movq %rsi, -0x518(%rbp)
movq %rdx, -0x520(%rbp)
movl $0xffffffff, -0x524(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x530(%rbp)
movq $0x0, -0x538(%rbp)
cmpq $0x0, -0x510(%rbp)
je 0x377e3
movq -0x510(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x377f3
movq $0x0, -0x508(%rbp)
jmp 0x37944
movq -0x510(%rbp), %rdi
leaq 0x15648(%rip), %rsi # 0x4ce49
callq 0x13100
cmpq $0x0, %rax
je 0x37811
jmp 0x378dd
cmpl $-0x1, -0x524(%rbp)
jne 0x3784c
movq -0x510(%rbp), %rdi
movq -0x518(%rbp), %rsi
callq 0x134d0
movq %rax, -0x530(%rbp)
cmpq $0x0, %rax
jne 0x3784a
movq $0x0, -0x508(%rbp)
jmp 0x37944
jmp 0x3784c
cmpq $0x0, -0x530(%rbp)
je 0x378cd
movl $0x10, %edi
callq 0x135b0
movq %rax, -0x538(%rbp)
cmpq $0x0, -0x538(%rbp)
jne 0x378ae
movq -0x530(%rbp), %rdi
callq 0x13420
movq -0x520(%rbp), %rdi
leaq 0x297d5(%rip), %rax # 0x61060
movq (%rax), %rdx
movl $0x7d8, %esi # imm = 0x7D8
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x17370
movq $0x0, -0x508(%rbp)
jmp 0x37944
movq -0x538(%rbp), %rax
movl $0x1, (%rax)
movq -0x530(%rbp), %rcx
movq -0x538(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x538(%rbp), %rax
movq %rax, -0x508(%rbp)
jmp 0x37944
leaq 0x2b5ac(%rip), %rax # 0x62e90
cmpq $0x0, (%rax)
jne 0x3790f
leaq -0x500(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x64, %edx
callq 0x375b0
leaq 0x2b58a(%rip), %rcx # 0x62e90
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x37939
leaq 0x2b57a(%rip), %rax # 0x62e90
movq (%rax), %rax
movq 0x58(%rax), %rax
movq (%rax), %rax
movq -0x510(%rbp), %rdi
movq -0x518(%rbp), %rsi
callq *%rax
movq %rax, -0x508(%rbp)
jmp 0x37944
movq $0x0, -0x508(%rbp)
movq -0x508(%rbp), %rax
movq %rax, -0x540(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x37974
movq -0x540(%rbp), %rax
addq $0x540, %rsp # imm = 0x540
popq %rbp
retq
callq 0x134b0
nopl (%rax)
| ma_open:
push rbp
mov rbp, rsp
sub rsp, 540h
mov rax, fs:28h
mov [rbp+var_8], rax
mov [rbp+var_510], rdi
mov [rbp+var_518], rsi
mov [rbp+var_520], rdx
mov [rbp+var_524], 0FFFFFFFFh
mov [rbp+var_530], 0
mov [rbp+var_538], 0
cmp [rbp+var_510], 0
jz short loc_377E3
mov rax, [rbp+var_510]
cmp byte ptr [rax], 0
jnz short loc_377F3
loc_377E3:
mov [rbp+var_508], 0
jmp loc_37944
loc_377F3:
mov rdi, [rbp+var_510]
lea rsi, asc_4CE49; "://"
call _strstr
cmp rax, 0
jz short loc_37811
jmp loc_378DD
loc_37811:
cmp [rbp+var_524], 0FFFFFFFFh
jnz short loc_3784C
mov rdi, [rbp+var_510]
mov rsi, [rbp+var_518]
call _fopen64
mov [rbp+var_530], rax
cmp rax, 0
jnz short loc_3784A
mov [rbp+var_508], 0
jmp loc_37944
loc_3784A:
jmp short $+2
loc_3784C:
cmp [rbp+var_530], 0
jz short loc_378CD
mov edi, 10h
call _malloc
mov [rbp+var_538], rax
cmp [rbp+var_538], 0
jnz short loc_378AE
mov rdi, [rbp+var_530]
call _fclose
mov rdi, [rbp+var_520]
lea rax, SQLSTATE_UNKNOWN
mov rdx, [rax]
mov esi, 7D8h
xor eax, eax
mov ecx, eax
mov al, 0
call my_set_error
mov [rbp+var_508], 0
jmp loc_37944
loc_378AE:
mov rax, [rbp+var_538]
mov dword ptr [rax], 1
mov rcx, [rbp+var_530]
mov rax, [rbp+var_538]
mov [rax+8], rcx
loc_378CD:
mov rax, [rbp+var_538]
mov [rbp+var_508], rax
jmp short loc_37944
loc_378DD:
lea rax, rio_plugin
cmp qword ptr [rax], 0
jnz short loc_3790F
lea rdi, [rbp+var_500]
xor eax, eax
mov esi, eax
mov edx, 64h ; 'd'
call mysql_client_find_plugin
lea rcx, rio_plugin
mov [rcx], rax
cmp rax, 0
jz short loc_37939
loc_3790F:
lea rax, rio_plugin
mov rax, [rax]
mov rax, [rax+58h]
mov rax, [rax]
mov rdi, [rbp+var_510]
mov rsi, [rbp+var_518]
call rax
mov [rbp+var_508], rax
jmp short loc_37944
loc_37939:
mov [rbp+var_508], 0
loc_37944:
mov rax, [rbp+var_508]
mov [rbp+var_540], rax
mov rax, fs:28h
mov rcx, [rbp+var_8]
cmp rax, rcx
jnz short loc_37974
mov rax, [rbp+var_540]
add rsp, 540h
pop rbp
retn
loc_37974:
call ___stack_chk_fail
| long long ma_open(_BYTE *a1, long long a2, long long a3)
{
long long v4; // [rsp+8h] [rbp-538h]
long long v5; // [rsp+10h] [rbp-530h]
_BYTE v8[1272]; // [rsp+40h] [rbp-500h] BYREF
unsigned long long v9; // [rsp+538h] [rbp-8h]
v9 = __readfsqword(0x28u);
if ( !a1 || !*a1 )
return 0LL;
if ( strstr(a1, "://") )
{
if ( rio_plugin )
return (**(long long ( ***)(_BYTE *, long long))(rio_plugin + 88LL))(a1, a2);
rio_plugin = mysql_client_find_plugin((long long)v8, 0LL, 0x64u);
if ( rio_plugin )
return (**(long long ( ***)(_BYTE *, long long))(rio_plugin + 88LL))(a1, a2);
else
return 0LL;
}
else
{
v5 = fopen64(a1, a2);
if ( v5 )
{
v4 = malloc(16LL);
if ( v4 )
{
*(_DWORD *)v4 = 1;
*(_QWORD *)(v4 + 8) = v5;
return v4;
}
else
{
fclose(v5);
my_set_error(a3, 0x7D8u, (long long)SQLSTATE_UNKNOWN, 0LL);
return 0LL;
}
}
else
{
return 0LL;
}
}
}
| ma_open:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x540
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
MOV qword ptr [RBP + -0x510],RDI
MOV qword ptr [RBP + -0x518],RSI
MOV qword ptr [RBP + -0x520],RDX
MOV dword ptr [RBP + -0x524],0xffffffff
MOV qword ptr [RBP + -0x530],0x0
MOV qword ptr [RBP + -0x538],0x0
CMP qword ptr [RBP + -0x510],0x0
JZ 0x001377e3
MOV RAX,qword ptr [RBP + -0x510]
CMP byte ptr [RAX],0x0
JNZ 0x001377f3
LAB_001377e3:
MOV qword ptr [RBP + -0x508],0x0
JMP 0x00137944
LAB_001377f3:
MOV RDI,qword ptr [RBP + -0x510]
LEA RSI,[0x14ce49]
CALL 0x00113100
CMP RAX,0x0
JZ 0x00137811
JMP 0x001378dd
LAB_00137811:
CMP dword ptr [RBP + -0x524],-0x1
JNZ 0x0013784c
MOV RDI,qword ptr [RBP + -0x510]
MOV RSI,qword ptr [RBP + -0x518]
CALL 0x001134d0
MOV qword ptr [RBP + -0x530],RAX
CMP RAX,0x0
JNZ 0x0013784a
MOV qword ptr [RBP + -0x508],0x0
JMP 0x00137944
LAB_0013784a:
JMP 0x0013784c
LAB_0013784c:
CMP qword ptr [RBP + -0x530],0x0
JZ 0x001378cd
MOV EDI,0x10
CALL 0x001135b0
MOV qword ptr [RBP + -0x538],RAX
CMP qword ptr [RBP + -0x538],0x0
JNZ 0x001378ae
MOV RDI,qword ptr [RBP + -0x530]
CALL 0x00113420
MOV RDI,qword ptr [RBP + -0x520]
LEA RAX,[0x161060]
MOV RDX,qword ptr [RAX]
MOV ESI,0x7d8
XOR EAX,EAX
MOV ECX,EAX
MOV AL,0x0
CALL 0x00117370
MOV qword ptr [RBP + -0x508],0x0
JMP 0x00137944
LAB_001378ae:
MOV RAX,qword ptr [RBP + -0x538]
MOV dword ptr [RAX],0x1
MOV RCX,qword ptr [RBP + -0x530]
MOV RAX,qword ptr [RBP + -0x538]
MOV qword ptr [RAX + 0x8],RCX
LAB_001378cd:
MOV RAX,qword ptr [RBP + -0x538]
MOV qword ptr [RBP + -0x508],RAX
JMP 0x00137944
LAB_001378dd:
LEA RAX,[0x162e90]
CMP qword ptr [RAX],0x0
JNZ 0x0013790f
LEA RDI,[RBP + -0x500]
XOR EAX,EAX
MOV ESI,EAX
MOV EDX,0x64
CALL 0x001375b0
LEA RCX,[0x162e90]
MOV qword ptr [RCX],RAX
CMP RAX,0x0
JZ 0x00137939
LAB_0013790f:
LEA RAX,[0x162e90]
MOV RAX,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x58]
MOV RAX,qword ptr [RAX]
MOV RDI,qword ptr [RBP + -0x510]
MOV RSI,qword ptr [RBP + -0x518]
CALL RAX
MOV qword ptr [RBP + -0x508],RAX
JMP 0x00137944
LAB_00137939:
MOV qword ptr [RBP + -0x508],0x0
LAB_00137944:
MOV RAX,qword ptr [RBP + -0x508]
MOV qword ptr [RBP + -0x540],RAX
MOV RAX,qword ptr FS:[0x28]
MOV RCX,qword ptr [RBP + -0x8]
CMP RAX,RCX
JNZ 0x00137974
MOV RAX,qword ptr [RBP + -0x540]
ADD RSP,0x540
POP RBP
RET
LAB_00137974:
CALL 0x001134b0
|
int4 * ma_open(char *param_1,char *param_2,int8 param_3)
{
char *pcVar1;
FILE *__stream;
long in_FS_OFFSET;
int4 *local_540;
int4 *local_510;
int1 local_508 [1272];
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_540 = (int4 *)0x0;
if ((param_1 == (char *)0x0) || (*param_1 == '\0')) {
local_510 = (int4 *)0x0;
}
else {
pcVar1 = strstr(param_1,"://");
if (pcVar1 == (char *)0x0) {
__stream = fopen64(param_1,param_2);
if (__stream == (FILE *)0x0) {
local_510 = (int4 *)0x0;
}
else {
if (__stream != (FILE *)0x0) {
local_540 = (int4 *)malloc(0x10);
if (local_540 == (int4 *)0x0) {
fclose(__stream);
my_set_error(param_3,0x7d8,SQLSTATE_UNKNOWN,0);
local_510 = (int4 *)0x0;
goto LAB_00137944;
}
*local_540 = 1;
*(FILE **)(local_540 + 2) = __stream;
}
local_510 = local_540;
}
}
else if ((rio_plugin == 0) &&
(rio_plugin = mysql_client_find_plugin(local_508,0,100), rio_plugin == 0)) {
local_510 = (int4 *)0x0;
}
else {
local_510 = (int4 *)(*(code *)**(int8 **)(rio_plugin + 0x58))(param_1,param_2);
}
}
LAB_00137944:
if (*(long *)(in_FS_OFFSET + 0x28) != local_10) {
/* WARNING: Subroutine does not return */
__stack_chk_fail();
}
return local_510;
}
| |
43,466 | js_os_pipe | bluesky950520[P]quickjs/quickjs-libc.c | static JSValue js_os_pipe(JSContext *ctx, JSValue this_val,
int argc, JSValue *argv)
{
int pipe_fds[2], ret;
JSValue obj;
ret = pipe(pipe_fds);
if (ret < 0)
return JS_NULL;
obj = JS_NewArray(ctx);
if (JS_IsException(obj))
return obj;
JS_DefinePropertyValueUint32(ctx, obj, 0, JS_NewInt32(ctx, pipe_fds[0]),
JS_PROP_C_W_E);
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, pipe_fds[1]),
JS_PROP_C_W_E);
return obj;
} | O2 | c | js_os_pipe:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0xe3d0
testl %eax, %eax
js 0x1562e
movabsq $-0x100000000, %r12 # imm = 0xFFFFFFFF00000000
movq %r15, %rdi
callq 0x1b2bb
movq %rax, %r14
movq %rdx, %rbx
cmpl $0x6, %ebx
je 0x15626
movl 0x8(%rsp), %r8d
pushq $0x7
popq %rbp
movl %ebp, (%rsp)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x20972
movl 0xc(%rsp), %r8d
movl %ebp, (%rsp)
pushq $0x1
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %r9d, %r9d
callq 0x20972
movq %r14, %rcx
andq %r12, %rcx
jmp 0x15636
pushq $0x2
popq %rbx
xorl %r14d, %r14d
xorl %ecx, %ecx
movl %r14d, %eax
orq %rcx, %rax
movq %rbx, %rdx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| js_os_pipe:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15, rdi
lea rdi, [rsp+38h+var_30]
call _pipe
test eax, eax
js short loc_1562E
mov r12, 0FFFFFFFF00000000h
mov rdi, r15
call JS_NewArray
mov r14, rax
mov rbx, rdx
cmp ebx, 6
jz short loc_15626
mov r8d, [rsp+38h+var_30]
push 7
pop rbp
mov [rsp+38h+var_38], ebp
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor ecx, ecx
xor r9d, r9d
call JS_DefinePropertyValueUint32
mov r8d, [rsp+38h+var_2C]
mov [rsp+38h+var_38], ebp
push 1
pop rcx
mov rdi, r15
mov rsi, r14
mov rdx, rbx
xor r9d, r9d
call JS_DefinePropertyValueUint32
loc_15626:
mov rcx, r14
and rcx, r12
jmp short loc_15636
loc_1562E:
push 2
pop rbx
xor r14d, r14d
xor ecx, ecx
loc_15636:
mov eax, r14d
or rax, rcx
mov rdx, rbx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| unsigned long long js_os_pipe(long long a1)
{
long long v1; // rax
int v2; // edx
long long v3; // r14
int v4; // ebx
unsigned long long v5; // rcx
_DWORD v7[12]; // [rsp+8h] [rbp-30h] BYREF
if ( (int)pipe(v7) < 0 )
{
LODWORD(v3) = 0;
v5 = 0LL;
}
else
{
v1 = JS_NewArray(a1);
v3 = v1;
v4 = v2;
if ( v2 != 6 )
{
JS_DefinePropertyValueUint32(a1, v1, v2, 0, v7[0], 0, 7);
JS_DefinePropertyValueUint32(a1, v3, v4, 1, v7[1], 0, 7);
}
v5 = v3 & 0xFFFFFFFF00000000LL;
}
return v5 | (unsigned int)v3;
}
| js_os_pipe:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15,RDI
LEA RDI,[RSP + 0x8]
CALL 0x0010e3d0
TEST EAX,EAX
JS 0x0011562e
MOV R12,-0x100000000
MOV RDI,R15
CALL 0x0011b2bb
MOV R14,RAX
MOV RBX,RDX
CMP EBX,0x6
JZ 0x00115626
MOV R8D,dword ptr [RSP + 0x8]
PUSH 0x7
POP RBP
MOV dword ptr [RSP],EBP
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR ECX,ECX
XOR R9D,R9D
CALL 0x00120972
MOV R8D,dword ptr [RSP + 0xc]
MOV dword ptr [RSP],EBP
PUSH 0x1
POP RCX
MOV RDI,R15
MOV RSI,R14
MOV RDX,RBX
XOR R9D,R9D
CALL 0x00120972
LAB_00115626:
MOV RCX,R14
AND RCX,R12
JMP 0x00115636
LAB_0011562e:
PUSH 0x2
POP RBX
XOR R14D,R14D
XOR ECX,ECX
LAB_00115636:
MOV EAX,R14D
OR RAX,RCX
MOV RDX,RBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
int1 [16] js_os_pipe(int8 param_1)
{
int iVar1;
ulong uVar2;
int1 auVar3 [16];
int1 auVar4 [16];
int local_30;
int4 local_2c;
iVar1 = pipe(&local_30);
if (iVar1 < 0) {
auVar3 = ZEXT816(2) << 0x40;
uVar2 = 0;
}
else {
auVar3 = JS_NewArray(param_1);
uVar2 = auVar3._0_8_;
if (auVar3._8_4_ != 6) {
JS_DefinePropertyValueUint32(param_1,uVar2,auVar3._8_8_,0,local_30,0,7);
JS_DefinePropertyValueUint32(param_1,uVar2,auVar3._8_8_,1,local_2c,0,7);
}
uVar2 = uVar2 & 0xffffffff00000000;
}
auVar4._0_8_ = auVar3._0_8_ & 0xffffffff | uVar2;
auVar4._8_8_ = auVar3._8_8_;
return auVar4;
}
| |
43,467 | my_hash_sort_utf8mb4_nopad | eloqsql/strings/ctype-utf8.c | static void
my_hash_sort_utf8mb4_nopad(CHARSET_INFO *cs, const uchar *s, size_t slen,
ulong *nr1, ulong *nr2)
{
my_wc_t wc;
int res;
const uchar *e= s + slen;
MY_UNICASE_INFO *uni_plane= cs->caseinfo;
register ulong m1= *nr1, m2= *nr2;
while ((res= my_mb_wc_utf8mb4(cs, &wc, (uchar*) s, (uchar*) e)) > 0)
{
my_tosort_unicode(uni_plane, &wc, cs->state);
MY_HASH_ADD_16(m1, m2, (uint) (wc & 0xFFFF));
if (wc > 0xFFFF)
{
/*
Put the highest byte only if it is non-zero,
to make hash functions for utf8mb3 and utf8mb4
compatible for BMP characters.
This is useful to keep order of records in
test results, e.g. for "SHOW GRANTS".
*/
MY_HASH_ADD(m1, m2, (uint) ((wc >> 16) & 0xFF));
}
s+= res;
}
*nr1= m1;
*nr2= m2;
} | O0 | c | my_hash_sort_utf8mb4_nopad:
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 -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x40(%rbp), %rcx
leaq -0x30(%rbp), %rsi
callq 0xfad60
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jle 0xffdda
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
leaq -0x30(%rbp), %rsi
callq 0xfb480
jmp 0xffcf1
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
andl $0xff, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0xffd35
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
andq $0xffff, %rcx # imm = 0xFFFF
shrl $0x8, %ecx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0xffd76
cmpq $0xffff, -0x30(%rbp) # imm = 0xFFFF
jbe 0xffdc4
jmp 0xffd82
movq -0x50(%rbp), %rax
andq $0x3f, %rax
addq -0x58(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x10, %rcx
andq $0xff, %rcx
movl %ecx, %ecx
imulq %rcx, %rax
movq -0x50(%rbp), %rcx
shlq $0x8, %rcx
addq %rcx, %rax
xorq -0x50(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x58(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x58(%rbp)
jmp 0xffdc4
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0xffcba
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_hash_sort_utf8mb4_nopad:
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_8]
mov rax, [rax+78h]
mov [rbp+var_48], rax
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_50], rax
mov rax, [rbp+var_28]
mov rax, [rax]
mov [rbp+var_58], rax
loc_FFCBA:
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
jle loc_FFDDA
mov rdi, [rbp+var_48]
mov rax, [rbp+var_8]
mov edx, [rax+0Ch]
lea rsi, [rbp+var_30]
call my_tosort_unicode
jmp short $+2
loc_FFCF1:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
and ecx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_FFD35:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
and rcx, 0FFFFh
shr ecx, 8
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_FFD76:
cmp [rbp+var_30], 0FFFFh
jbe short loc_FFDC4
jmp short $+2
loc_FFD82:
mov rax, [rbp+var_50]
and rax, 3Fh
add rax, [rbp+var_58]
mov rcx, [rbp+var_30]
shr rcx, 10h
and rcx, 0FFh
mov ecx, ecx
imul rax, rcx
mov rcx, [rbp+var_50]
shl rcx, 8
add rax, rcx
xor rax, [rbp+var_50]
mov [rbp+var_50], rax
mov rax, [rbp+var_58]
add rax, 3
mov [rbp+var_58], rax
jmp short $+2
loc_FFDC4:
mov ecx, [rbp+var_34]
mov rax, [rbp+var_10]
movsxd rcx, ecx
add rax, rcx
mov [rbp+var_10], rax
jmp loc_FFCBA
loc_FFDDA:
mov rcx, [rbp+var_50]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rcx, [rbp+var_58]
mov rax, [rbp+var_28]
mov [rax], rcx
add rsp, 60h
pop rbp
retn
| _QWORD * my_hash_sort_utf8mb4_nopad(long long a1, long long a2, long long a3, long long *a4, _QWORD *a5, long long a6)
{
_QWORD *result; // rax
long long v7; // [rsp+8h] [rbp-58h]
long long v8; // [rsp+8h] [rbp-58h]
long long v9; // [rsp+10h] [rbp-50h]
long long v10; // [rsp+10h] [rbp-50h]
_QWORD *v11; // [rsp+18h] [rbp-48h]
long long v12; // [rsp+20h] [rbp-40h]
int v13; // [rsp+2Ch] [rbp-34h]
unsigned long long v14; // [rsp+30h] [rbp-30h] BYREF
_QWORD *v15; // [rsp+38h] [rbp-28h]
long long *v16; // [rsp+40h] [rbp-20h]
long long v17; // [rsp+48h] [rbp-18h]
long long v18; // [rsp+50h] [rbp-10h]
long long v19; // [rsp+58h] [rbp-8h]
v19 = a1;
v18 = a2;
v17 = a3;
v16 = a4;
v15 = a5;
v12 = a3 + a2;
v11 = *(_QWORD **)(a1 + 120);
v9 = *a4;
v7 = *a5;
while ( 1 )
{
v13 = my_mb_wc_utf8mb4(v19, (long long)&v14, v18, v12, (long long)a5, a6);
if ( v13 <= 0 )
break;
my_tosort_unicode(v11, &v14, *(_DWORD *)(v19 + 12));
v10 = v9 ^ ((v9 << 8) + (unsigned __int8)v14 * (v7 + (v9 & 0x3F)));
v8 = v7 + 3;
v9 = v10 ^ ((v10 << 8) + BYTE1(v14) * (v8 + (v10 & 0x3F)));
v7 = v8 + 3;
if ( v14 > 0xFFFF )
{
v9 ^= (v9 << 8) + BYTE2(v14) * (v7 + (v9 & 0x3F));
v7 += 3LL;
}
v18 += v13;
}
*v16 = v9;
result = v15;
*v15 = v7;
return result;
}
| my_hash_sort_utf8mb4_nopad:
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 + -0x8]
MOV RAX,qword ptr [RAX + 0x78]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x58],RAX
LAB_001ffcba:
MOV RDI,qword ptr [RBP + -0x8]
MOV RDX,qword ptr [RBP + -0x10]
MOV RCX,qword ptr [RBP + -0x40]
LEA RSI,[RBP + -0x30]
CALL 0x001fad60
MOV dword ptr [RBP + -0x34],EAX
CMP EAX,0x0
JLE 0x001ffdda
MOV RDI,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RBP + -0x8]
MOV EDX,dword ptr [RAX + 0xc]
LEA RSI,[RBP + -0x30]
CALL 0x001fb480
JMP 0x001ffcf1
LAB_001ffcf1:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
AND ECX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001ffd35
LAB_001ffd35:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
AND RCX,0xffff
SHR ECX,0x8
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001ffd76
LAB_001ffd76:
CMP qword ptr [RBP + -0x30],0xffff
JBE 0x001ffdc4
JMP 0x001ffd82
LAB_001ffd82:
MOV RAX,qword ptr [RBP + -0x50]
AND RAX,0x3f
ADD RAX,qword ptr [RBP + -0x58]
MOV RCX,qword ptr [RBP + -0x30]
SHR RCX,0x10
AND RCX,0xff
MOV ECX,ECX
IMUL RAX,RCX
MOV RCX,qword ptr [RBP + -0x50]
SHL RCX,0x8
ADD RAX,RCX
XOR RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x58]
ADD RAX,0x3
MOV qword ptr [RBP + -0x58],RAX
JMP 0x001ffdc4
LAB_001ffdc4:
MOV ECX,dword ptr [RBP + -0x34]
MOV RAX,qword ptr [RBP + -0x10]
MOVSXD RCX,ECX
ADD RAX,RCX
MOV qword ptr [RBP + -0x10],RAX
JMP 0x001ffcba
LAB_001ffdda:
MOV RCX,qword ptr [RBP + -0x50]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RCX,qword ptr [RBP + -0x58]
MOV RAX,qword ptr [RBP + -0x28]
MOV qword ptr [RAX],RCX
ADD RSP,0x60
POP RBP
RET
|
void my_hash_sort_utf8mb4_nopad(long param_1,long param_2,long param_3,ulong *param_4,long *param_5)
{
int8 uVar1;
long lVar2;
int iVar3;
long local_60;
ulong local_58;
ulong local_38;
long *local_30;
ulong *local_28;
long local_20;
long local_18;
long local_10;
uVar1 = *(int8 *)(param_1 + 0x78);
local_58 = *param_4;
local_60 = *param_5;
local_30 = param_5;
local_28 = param_4;
local_20 = param_3;
local_18 = param_2;
local_10 = param_1;
while( true ) {
iVar3 = my_mb_wc_utf8mb4(local_10,&local_38,local_18,param_2 + param_3);
if (iVar3 < 1) break;
my_tosort_unicode(uVar1,&local_38,*(int4 *)(local_10 + 0xc));
local_58 = ((local_58 & 0x3f) + local_60) * (ulong)((uint)local_38 & 0xff) + local_58 * 0x100 ^
local_58;
local_58 = ((local_58 & 0x3f) + local_60 + 3) * (ulong)(((uint)local_38 & 0xffff) >> 8) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 6;
if (0xffff < local_38) {
local_58 = ((local_58 & 0x3f) + local_60 + 6) * (ulong)((uint)(local_38 >> 0x10) & 0xff) +
local_58 * 0x100 ^ local_58;
lVar2 = local_60 + 9;
}
local_60 = lVar2;
local_18 = local_18 + iVar3;
}
*local_28 = local_58;
*local_30 = local_60;
return;
}
| |
43,468 | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]) | monkey531[P]llama/common/json.hpp | iterator find(KeyType && key) // NOLINT(cppcoreguidelines-missing-std-forward)
{
for (auto it = this->begin(); it != this->end(); ++it)
{
if (m_compare(it->first, key))
{
return it;
}
}
return Container::end();
} | O2 | cpp | _gnu_cxx::__normal_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>*, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>> nlohmann::json_abi_v3_11_3::ordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::less<void>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>>::find<char const (&) [8], 0>(char const (&) [8]):
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r14
movq 0x8(%r15), %rax
cmpq %rax, %r14
je 0x8268d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28d1d
testb %al, %al
jne 0x8268a
addq $0x30, %r14
jmp 0x8266c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
push r15
push r14
push rbx
mov rbx, rsi
mov r15, rdi
mov r14, [rdi]
loc_8266C:
mov rax, [r15+8]
cmp r14, rax
jz short loc_8268D
mov rdi, r14
mov rsi, rbx
call _ZSteqIcSt11char_traitsIcESaIcEEbRKNSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_; std::operator==<char>(std::string const&,char const*)
test al, al
jnz short loc_8268A
add r14, 30h ; '0'
jmp short loc_8266C
loc_8268A:
mov rax, r14
loc_8268D:
pop rbx
pop r14
pop r15
retn
| long long ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_(
long long *a1)
{
long long i; // r14
long long result; // rax
for ( i = *a1; ; i += 48LL )
{
result = a1[1];
if ( i == result )
break;
if ( std::operator==<char>(i) )
return i;
}
return result;
}
| _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_:
PUSH R15
PUSH R14
PUSH RBX
MOV RBX,RSI
MOV R15,RDI
MOV R14,qword ptr [RDI]
LAB_0018266c:
MOV RAX,qword ptr [R15 + 0x8]
CMP R14,RAX
JZ 0x0018268d
MOV RDI,R14
MOV RSI,RBX
CALL 0x00128d1d
TEST AL,AL
JNZ 0x0018268a
ADD R14,0x30
JMP 0x0018266c
LAB_0018268a:
MOV RAX,R14
LAB_0018268d:
POP RBX
POP R14
POP R15
RET
|
string * _ZN8nlohmann16json_abi_v3_11_311ordered_mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEENS0_10basic_jsonIS1_St6vectorS7_blmdSaNS0_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS7_SD_EEE4findIRA8_KcTnNSt9enable_ifIXsr6detail21is_usable_as_key_typeISt8equal_toIvES7_T_EE5valueEiE4typeELi0EEEN9__gnu_cxx17__normal_iteratorIPSI_S9_ISI_SJ_EEEOSS_
(int8 *param_1,char *param_2)
{
bool bVar1;
string *psVar2;
string *psVar3;
psVar3 = (string *)*param_1;
while ((psVar2 = (string *)param_1[1], psVar3 != (string *)param_1[1] &&
(bVar1 = std::operator==(psVar3,param_2), psVar2 = psVar3, !bVar1))) {
psVar3 = psVar3 + 0x30;
}
return psVar2;
}
| |
43,469 | my_wc_mb_gbk | eloqsql/strings/ctype-gbk.c | static int
my_wc_mb_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gbk_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O0 | c | my_wc_mb_gbk:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x3dd9b
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x3de14
movq -0x18(%rbp), %rax
cmpl $0x80, %eax
jae 0x3ddbb
movq -0x18(%rbp), %rax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3de14
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x3e0e0
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
jne 0x3ddd7
movl $0x0, -0x4(%rbp)
jmp 0x3de14
movq -0x20(%rbp), %rax
addq $0x2, %rax
cmpq -0x28(%rbp), %rax
jbe 0x3ddee
movl $0xffffff9a, -0x4(%rbp) # imm = 0xFFFFFF9A
jmp 0x3de14
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| my_wc_mb_gbk:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_28], rcx
mov rax, [rbp+var_20]
cmp rax, [rbp+var_28]
jb short loc_3DD9B
mov [rbp+var_4], 0FFFFFF9Bh
jmp short loc_3DE14
loc_3DD9B:
mov rax, [rbp+var_18]
cmp eax, 80h
jnb short loc_3DDBB
mov rax, [rbp+var_18]
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov [rbp+var_4], 1
jmp short loc_3DE14
loc_3DDBB:
mov rax, [rbp+var_18]
mov edi, eax
call func_uni_gbk_onechar
mov [rbp+var_2C], eax
cmp eax, 0
jnz short loc_3DDD7
mov [rbp+var_4], 0
jmp short loc_3DE14
loc_3DDD7:
mov rax, [rbp+var_20]
add rax, 2
cmp rax, [rbp+var_28]
jbe short loc_3DDEE
mov [rbp+var_4], 0FFFFFF9Ah
jmp short loc_3DE14
loc_3DDEE:
mov eax, [rbp+var_2C]
sar eax, 8
mov cl, al
mov rax, [rbp+var_20]
mov [rax], cl
mov eax, [rbp+var_2C]
and eax, 0FFh
mov cl, al
mov rax, [rbp+var_20]
mov [rax+1], cl
mov [rbp+var_4], 2
loc_3DE14:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_wc_mb_gbk(long long a1, unsigned int a2, _BYTE *a3, unsigned long long a4)
{
int v5; // [rsp+4h] [rbp-2Ch]
if ( (unsigned long long)a3 < a4 )
{
if ( a2 >= 0x80 )
{
v5 = func_uni_gbk_onechar(a2);
if ( v5 )
{
if ( (unsigned long long)(a3 + 2) <= a4 )
{
*a3 = BYTE1(v5);
a3[1] = v5;
return 2;
}
else
{
return (unsigned int)-102;
}
}
else
{
return 0;
}
}
else
{
*a3 = a2;
return 1;
}
}
else
{
return (unsigned int)-101;
}
}
| my_wc_mb_gbk:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV qword ptr [RBP + -0x20],RDX
MOV qword ptr [RBP + -0x28],RCX
MOV RAX,qword ptr [RBP + -0x20]
CMP RAX,qword ptr [RBP + -0x28]
JC 0x0013dd9b
MOV dword ptr [RBP + -0x4],0xffffff9b
JMP 0x0013de14
LAB_0013dd9b:
MOV RAX,qword ptr [RBP + -0x18]
CMP EAX,0x80
JNC 0x0013ddbb
MOV RAX,qword ptr [RBP + -0x18]
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV dword ptr [RBP + -0x4],0x1
JMP 0x0013de14
LAB_0013ddbb:
MOV RAX,qword ptr [RBP + -0x18]
MOV EDI,EAX
CALL 0x0013e0e0
MOV dword ptr [RBP + -0x2c],EAX
CMP EAX,0x0
JNZ 0x0013ddd7
MOV dword ptr [RBP + -0x4],0x0
JMP 0x0013de14
LAB_0013ddd7:
MOV RAX,qword ptr [RBP + -0x20]
ADD RAX,0x2
CMP RAX,qword ptr [RBP + -0x28]
JBE 0x0013ddee
MOV dword ptr [RBP + -0x4],0xffffff9a
JMP 0x0013de14
LAB_0013ddee:
MOV EAX,dword ptr [RBP + -0x2c]
SAR EAX,0x8
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX],CL
MOV EAX,dword ptr [RBP + -0x2c]
AND EAX,0xff
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x20]
MOV byte ptr [RAX + 0x1],CL
MOV dword ptr [RBP + -0x4],0x2
LAB_0013de14:
MOV EAX,dword ptr [RBP + -0x4]
ADD RSP,0x30
POP RBP
RET
|
int4 my_wc_mb_gbk(int8 param_1,uint param_2,int1 *param_3,int1 *param_4)
{
int iVar1;
int4 local_c;
if (param_3 < param_4) {
if (param_2 < 0x80) {
*param_3 = (char)param_2;
local_c = 1;
}
else {
iVar1 = func_uni_gbk_onechar(param_2);
if (iVar1 == 0) {
local_c = 0;
}
else if (param_4 < param_3 + 2) {
local_c = 0xffffff9a;
}
else {
*param_3 = (char)((uint)iVar1 >> 8);
param_3[1] = (char)iVar1;
local_c = 2;
}
}
}
else {
local_c = 0xffffff9b;
}
return local_c;
}
| |
43,470 | my_wc_mb_gbk | eloqsql/strings/ctype-gbk.c | static int
my_wc_mb_gbk(CHARSET_INFO *cs __attribute__((unused)),
my_wc_t wc, uchar *s, uchar *e)
{
int code;
if (s >= e)
return MY_CS_TOOSMALL;
if ((uint) wc < 0x80)
{
s[0]= (uchar) wc;
return 1;
}
if (!(code=func_uni_gbk_onechar(wc)))
return MY_CS_ILUNI;
if (s+2>e)
return MY_CS_TOOSMALL2;
s[0]=code>>8;
s[1]=code&0xFF;
return 2;
} | O3 | c | my_wc_mb_gbk:
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rcx, %rdx
jae 0x34f02
cmpl $0x7f, %esi
ja 0x34f03
movb %sil, (%rdx)
movl $0x1, %eax
retq
leal -0xa4(%rsi), %eax
cmpl $0x3ad, %eax # imm = 0x3AD
ja 0x34f1e
movl %eax, %eax
leaq 0x154ba7(%rip), %rsi # 0x189ac0
jmp 0x34fe0
leal -0x2010(%rsi), %eax
cmpl $0x302, %eax # imm = 0x302
ja 0x34f39
movl %eax, %eax
leaq 0x1552ec(%rip), %rsi # 0x18a220
jmp 0x34fe0
leal -0x2460(%rsi), %eax
cmpl $0x1e2, %eax # imm = 0x1E2
ja 0x34f54
movl %eax, %eax
leaq 0x1558e1(%rip), %rsi # 0x18a830
jmp 0x34fe0
leal -0x3000(%rsi), %eax
cmpl $0x129, %eax # imm = 0x129
ja 0x34f6c
movl %eax, %eax
leaq 0x155c96(%rip), %rsi # 0x18ac00
jmp 0x34fe0
leal -0x3220(%rsi), %eax
cmpl $0x83, %eax
ja 0x34f84
movl %eax, %eax
leaq 0x155ede(%rip), %rsi # 0x18ae60
jmp 0x34fe0
leal -0x338e(%rsi), %eax
cmpl $0x47, %eax
ja 0x34f9a
movl %eax, %eax
leaq 0x155fd8(%rip), %rsi # 0x18af70
jmp 0x34fe0
leal -0x4e00(%rsi), %eax
cmpl $0x51a5, %eax # imm = 0x51A5
ja 0x34fb2
movl %eax, %eax
leaq 0x156050(%rip), %rsi # 0x18b000
jmp 0x34fe0
leal -0xf92c(%rsi), %eax
cmpl $0xfd, %eax
ja 0x34fca
movl %eax, %eax
leaq 0x160388(%rip), %rsi # 0x195350
jmp 0x34fe0
leal -0xfe30(%rsi), %eax
cmpl $0x1b5, %eax # imm = 0x1B5
ja 0x35010
movl %eax, %eax
leaq 0x160570(%rip), %rsi # 0x195550
leaq (%rsi,%rax,2), %rax
pushq %rbp
movq %rsp, %rbp
movzwl (%rax), %esi
testw %si, %si
je 0x3500c
leaq 0x2(%rdx), %rdi
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rcx, %rdi
ja 0x3500e
rolw $0x8, %si
movw %si, (%rdx)
movl $0x2, %eax
jmp 0x3500e
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
retq
| my_wc_mb_gbk:
mov eax, 0FFFFFF9Bh
cmp rdx, rcx
jnb short locret_34F02
cmp esi, 7Fh
ja short loc_34F03
mov [rdx], sil
mov eax, 1
locret_34F02:
retn
loc_34F03:
lea eax, [rsi-0A4h]
cmp eax, 3ADh
ja short loc_34F1E
mov eax, eax
lea rsi, tab_uni_gbk0
jmp loc_34FE0
loc_34F1E:
lea eax, [rsi-2010h]
cmp eax, 302h
ja short loc_34F39
mov eax, eax
lea rsi, tab_uni_gbk1
jmp loc_34FE0
loc_34F39:
lea eax, [rsi-2460h]
cmp eax, 1E2h
ja short loc_34F54
mov eax, eax
lea rsi, tab_uni_gbk2
jmp loc_34FE0
loc_34F54:
lea eax, [rsi-3000h]
cmp eax, 129h
ja short loc_34F6C
mov eax, eax
lea rsi, tab_uni_gbk3
jmp short loc_34FE0
loc_34F6C:
lea eax, [rsi-3220h]
cmp eax, 83h
ja short loc_34F84
mov eax, eax
lea rsi, tab_uni_gbk4
jmp short loc_34FE0
loc_34F84:
lea eax, [rsi-338Eh]
cmp eax, 47h ; 'G'
ja short loc_34F9A
mov eax, eax
lea rsi, tab_uni_gbk5
jmp short loc_34FE0
loc_34F9A:
lea eax, [rsi-4E00h]
cmp eax, 51A5h
ja short loc_34FB2
mov eax, eax
lea rsi, tab_uni_gbk6
jmp short loc_34FE0
loc_34FB2:
lea eax, [rsi-0F92Ch]
cmp eax, 0FDh
ja short loc_34FCA
mov eax, eax
lea rsi, tab_uni_gbk7
jmp short loc_34FE0
loc_34FCA:
lea eax, [rsi-0FE30h]
cmp eax, 1B5h
ja short loc_35010
mov eax, eax
lea rsi, tab_uni_gbk8
loc_34FE0:
lea rax, [rsi+rax*2]
push rbp
mov rbp, rsp
movzx esi, word ptr [rax]
test si, si
jz short loc_3500C
lea rdi, [rdx+2]
mov eax, 0FFFFFF9Ah
cmp rdi, rcx
ja short loc_3500E
rol si, 8
mov [rdx], si
mov eax, 2
jmp short loc_3500E
loc_3500C:
xor eax, eax
loc_3500E:
pop rbp
retn
loc_35010:
xor eax, eax
retn
| long long my_wc_mb_gbk(long long a1, unsigned int a2, _WORD *a3, unsigned long long a4)
{
long long result; // rax
long long v5; // rax
_WORD *v6; // rsi
__int16 v7; // si
result = 4294967195LL;
if ( (unsigned long long)a3 < a4 )
{
if ( a2 > 0x7F )
{
LODWORD(v5) = a2 - 164;
if ( a2 - 164 > 0x3AD )
{
LODWORD(v5) = a2 - 8208;
if ( a2 - 8208 > 0x302 )
{
LODWORD(v5) = a2 - 9312;
if ( a2 - 9312 > 0x1E2 )
{
LODWORD(v5) = a2 - 12288;
if ( a2 - 12288 > 0x129 )
{
LODWORD(v5) = a2 - 12832;
if ( a2 - 12832 > 0x83 )
{
LODWORD(v5) = a2 - 13198;
if ( a2 - 13198 > 0x47 )
{
LODWORD(v5) = a2 - 19968;
if ( a2 - 19968 > 0x51A5 )
{
LODWORD(v5) = a2 - 63788;
if ( a2 - 63788 > 0xFD )
{
LODWORD(v5) = a2 - 65072;
if ( a2 - 65072 > 0x1B5 )
return 0LL;
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk8;
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk7;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk6;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk5;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk4;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk3;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk2;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk1;
}
}
else
{
v5 = (unsigned int)v5;
v6 = &tab_uni_gbk0;
}
v7 = v6[v5];
if ( v7 )
{
result = 4294967194LL;
if ( (unsigned long long)(a3 + 1) <= a4 )
{
*a3 = __ROL2__(v7, 8);
return 2LL;
}
}
else
{
return 0LL;
}
}
else
{
*(_BYTE *)a3 = a2;
return 1LL;
}
}
return result;
}
| my_wc_mb_gbk:
MOV EAX,0xffffff9b
CMP RDX,RCX
JNC 0x00134f02
CMP ESI,0x7f
JA 0x00134f03
MOV byte ptr [RDX],SIL
MOV EAX,0x1
LAB_00134f02:
RET
LAB_00134f03:
LEA EAX,[RSI + -0xa4]
CMP EAX,0x3ad
JA 0x00134f1e
MOV EAX,EAX
LEA RSI,[0x289ac0]
JMP 0x00134fe0
LAB_00134f1e:
LEA EAX,[RSI + -0x2010]
CMP EAX,0x302
JA 0x00134f39
MOV EAX,EAX
LEA RSI,[0x28a220]
JMP 0x00134fe0
LAB_00134f39:
LEA EAX,[RSI + -0x2460]
CMP EAX,0x1e2
JA 0x00134f54
MOV EAX,EAX
LEA RSI,[0x28a830]
JMP 0x00134fe0
LAB_00134f54:
LEA EAX,[RSI + -0x3000]
CMP EAX,0x129
JA 0x00134f6c
MOV EAX,EAX
LEA RSI,[0x28ac00]
JMP 0x00134fe0
LAB_00134f6c:
LEA EAX,[RSI + -0x3220]
CMP EAX,0x83
JA 0x00134f84
MOV EAX,EAX
LEA RSI,[0x28ae60]
JMP 0x00134fe0
LAB_00134f84:
LEA EAX,[RSI + -0x338e]
CMP EAX,0x47
JA 0x00134f9a
MOV EAX,EAX
LEA RSI,[0x28af70]
JMP 0x00134fe0
LAB_00134f9a:
LEA EAX,[RSI + -0x4e00]
CMP EAX,0x51a5
JA 0x00134fb2
MOV EAX,EAX
LEA RSI,[0x28b000]
JMP 0x00134fe0
LAB_00134fb2:
LEA EAX,[RSI + -0xf92c]
CMP EAX,0xfd
JA 0x00134fca
MOV EAX,EAX
LEA RSI,[0x295350]
JMP 0x00134fe0
LAB_00134fca:
LEA EAX,[RSI + -0xfe30]
CMP EAX,0x1b5
JA 0x00135010
MOV EAX,EAX
LEA RSI,[0x295550]
LAB_00134fe0:
LEA RAX,[RSI + RAX*0x2]
PUSH RBP
MOV RBP,RSP
MOVZX ESI,word ptr [RAX]
TEST SI,SI
JZ 0x0013500c
LEA RDI,[RDX + 0x2]
MOV EAX,0xffffff9a
CMP RDI,RCX
JA 0x0013500e
ROL SI,0x8
MOV word ptr [RDX],SI
MOV EAX,0x2
JMP 0x0013500e
LAB_0013500c:
XOR EAX,EAX
LAB_0013500e:
POP RBP
RET
LAB_00135010:
XOR EAX,EAX
RET
|
int8 my_wc_mb_gbk(int8 param_1,uint param_2,ushort *param_3,ushort *param_4)
{
ushort uVar1;
int8 uVar2;
ulong uVar3;
int1 *puVar4;
uVar2 = 0xffffff9b;
if (param_3 < param_4) {
if (0x7f < param_2) {
if (param_2 - 0xa4 < 0x3ae) {
uVar3 = (ulong)(param_2 - 0xa4);
puVar4 = tab_uni_gbk0;
}
else if (param_2 - 0x2010 < 0x303) {
uVar3 = (ulong)(param_2 - 0x2010);
puVar4 = tab_uni_gbk1;
}
else if (param_2 - 0x2460 < 0x1e3) {
uVar3 = (ulong)(param_2 - 0x2460);
puVar4 = tab_uni_gbk2;
}
else if (param_2 - 0x3000 < 0x12a) {
uVar3 = (ulong)(param_2 - 0x3000);
puVar4 = tab_uni_gbk3;
}
else if (param_2 - 0x3220 < 0x84) {
uVar3 = (ulong)(param_2 - 0x3220);
puVar4 = tab_uni_gbk4;
}
else if (param_2 - 0x338e < 0x48) {
uVar3 = (ulong)(param_2 - 0x338e);
puVar4 = tab_uni_gbk5;
}
else if (param_2 - 0x4e00 < 0x51a6) {
uVar3 = (ulong)(param_2 - 0x4e00);
puVar4 = tab_uni_gbk6;
}
else if (param_2 - 0xf92c < 0xfe) {
uVar3 = (ulong)(param_2 - 0xf92c);
puVar4 = tab_uni_gbk7;
}
else {
uVar3 = (ulong)(param_2 - 0xfe30);
if (0x1b5 < param_2 - 0xfe30) {
return 0;
}
puVar4 = tab_uni_gbk8;
}
uVar1 = *(ushort *)(puVar4 + uVar3 * 2);
if (uVar1 == 0) {
uVar2 = 0;
}
else {
uVar2 = 0xffffff9a;
if (param_3 + 1 <= param_4) {
*param_3 = uVar1 << 8 | uVar1 >> 8;
uVar2 = 2;
}
}
return uVar2;
}
*(char *)param_3 = (char)param_2;
uVar2 = 1;
}
return uVar2;
}
| |
43,471 | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long) | monkey531[P]llama/common/json.hpp | explicit iteration_proxy_value(IteratorType it, std::size_t array_index_ = 0)
noexcept(std::is_nothrow_move_constructible<IteratorType>::value
&& std::is_nothrow_default_constructible<string_type>::value)
: anchor(std::move(it))
, array_index(array_index_)
{} | O2 | cpp | nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>, unsigned long):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rdx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x34fe1(%rip), %rsi # 0xb798f
leaq 0xf(%rsp), %rdx
callq 0x283ac
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
movb $0x0, 0x60(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x2864b
| _ZN8nlohmann16json_abi_v3_11_36detail21iteration_proxy_valueINS1_9iter_implINS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES6_IhSaIhEEvEEEEEC2ESH_m:
push rbx
sub rsp, 10h
mov rbx, rdi
movups xmm0, xmmword ptr [rsi]
movups xmm1, xmmword ptr [rsi+10h]
movups xmmword ptr [rdi+10h], xmm1
movups xmmword ptr [rdi], xmm0
mov [rdi+20h], rdx
and qword ptr [rdi+28h], 0
add rdi, 30h ; '0'
lea rsi, aMinExp0+0Ah; "0"
lea rdx, [rsp+18h+var_9]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rax, [rbx+60h]
mov [rbx+50h], rax
and qword ptr [rbx+58h], 0
mov byte ptr [rbx+60h], 0
add rsp, 10h
pop rbx
retn
mov rdi, rax
call __clang_call_terminate
| long long nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>::iteration_proxy_value(
long long a1,
__int128 *a2,
long long a3)
{
__int128 v3; // xmm0
long long result; // rax
v3 = *a2;
*(_OWORD *)(a1 + 16) = a2[1];
*(_OWORD *)a1 = v3;
*(_QWORD *)(a1 + 32) = a3;
*(_QWORD *)(a1 + 40) = 0LL;
std::string::basic_string<std::allocator<char>>((_QWORD *)(a1 + 48), (long long)"0");
result = a1 + 96;
*(_QWORD *)(a1 + 80) = a1 + 96;
*(_QWORD *)(a1 + 88) = 0LL;
*(_BYTE *)(a1 + 96) = 0;
return result;
}
| iteration_proxy_value:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOVUPS XMM0,xmmword ptr [RSI]
MOVUPS XMM1,xmmword ptr [RSI + 0x10]
MOVUPS xmmword ptr [RDI + 0x10],XMM1
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x20],RDX
AND qword ptr [RDI + 0x28],0x0
ADD RDI,0x30
LAB_001829a7:
LEA RSI,[0x1b798f]
LEA RDX,[RSP + 0xf]
CALL 0x001283ac
LEA RAX,[RBX + 0x60]
MOV qword ptr [RBX + 0x50],RAX
AND qword ptr [RBX + 0x58],0x0
MOV byte ptr [RBX + 0x60],0x0
ADD RSP,0x10
POP RBX
RET
|
/* nlohmann::json_abi_v3_11_3::detail::iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >
>::iteration_proxy_value(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> >, unsigned long) */
void __thiscall
nlohmann::json_abi_v3_11_3::detail::
iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
::iteration_proxy_value
(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
*this,int8 *param_2,int8 param_3)
{
int8 uVar1;
int8 uVar2;
int8 uVar3;
allocator local_9;
uVar1 = *param_2;
uVar2 = param_2[1];
uVar3 = param_2[3];
*(int8 *)(this + 0x10) = param_2[2];
*(int8 *)(this + 0x18) = uVar3;
*(int8 *)this = uVar1;
*(int8 *)(this + 8) = uVar2;
*(int8 *)(this + 0x20) = param_3;
*(int8 *)(this + 0x28) = 0;
/* try { // try from 001829a7 to 001829b7 has its CatchHandler @ 001829cf */
std::__cxx11::string::string<std::allocator<char>>((string *)(this + 0x30),"0",&local_9);
*(iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
**)(this + 0x50) = this + 0x60;
*(int8 *)(this + 0x58) = 0;
this[0x60] = (iteration_proxy_value<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>
)0x0;
return;
}
| |
43,472 | common_sampler_type_to_str[abi:cxx11](common_sampler_type) | monkey531[P]llama/common/sampling.cpp | std::string common_sampler_type_to_str(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return "dry";
case COMMON_SAMPLER_TYPE_TOP_K: return "top_k";
case COMMON_SAMPLER_TYPE_TYPICAL_P: return "typ_p";
case COMMON_SAMPLER_TYPE_TOP_P: return "top_p";
case COMMON_SAMPLER_TYPE_MIN_P: return "min_p";
case COMMON_SAMPLER_TYPE_TEMPERATURE: return "temperature";
case COMMON_SAMPLER_TYPE_XTC: return "xtc";
case COMMON_SAMPLER_TYPE_INFILL: return "infill";
case COMMON_SAMPLER_TYPE_PENALTIES: return "penalties";
default : return "";
}
} | O2 | cpp | common_sampler_type_to_str[abi:cxx11](common_sampler_type):
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
decl %esi
cmpl $0x9, %esi
ja 0x97845
leaq 0x20716(%rip), %rax # 0xb7ed4
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x20add(%rip), %rsi # 0xb82ab
leaq 0xf(%rsp), %rdx
jmp 0x97851
leaq 0x20adf(%rip), %rsi # 0xb82bb
leaq 0xc(%rsp), %rdx
jmp 0x97851
leaq 0x20add(%rip), %rsi # 0xb82c7
leaq 0xa(%rsp), %rdx
jmp 0x97851
leaq 0x20ab7(%rip), %rsi # 0xb82af
leaq 0xe(%rsp), %rdx
jmp 0x97851
leaq 0x20acd(%rip), %rsi # 0xb82d3
leaq 0x9(%rsp), %rdx
jmp 0x97851
leaq 0x13095(%rip), %rsi # 0xaa8a9
leaq 0x8(%rsp), %rdx
jmp 0x97851
leaq 0x20a9f(%rip), %rsi # 0xb82c1
leaq 0xb(%rsp), %rdx
jmp 0x97851
leaq 0x20a85(%rip), %rsi # 0xb82b5
leaq 0xd(%rsp), %rdx
jmp 0x97851
leaq 0x20a99(%rip), %rsi # 0xb82d7
leaq 0x7(%rsp), %rdx
jmp 0x97851
leaq 0x11905(%rip), %rsi # 0xa9151
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
callq 0x25c26
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| _Z26common_sampler_type_to_strB5cxx1119common_sampler_type:
push rbx
sub rsp, 10h
mov rbx, rdi
dec esi; switch 10 cases
cmp esi, 9
ja def_977C5; jumptable 00000000000977C5 default case, case 5
lea rax, jpt_977C5
movsxd rcx, ds:(jpt_977C5 - 0B7ED4h)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_977C7:
lea rsi, aDry; jumptable 00000000000977C5 case 1
lea rdx, [rsp+18h+var_9]
jmp short loc_97851
loc_977D5:
lea rsi, aTopP_0; jumptable 00000000000977C5 case 3
lea rdx, [rsp+18h+var_C]
jmp short loc_97851
loc_977E3:
lea rsi, aTemperature; jumptable 00000000000977C5 case 7
lea rdx, [rsp+18h+var_E]
jmp short loc_97851
loc_977F1:
lea rsi, aTopK_0; jumptable 00000000000977C5 case 2
lea rdx, [rsp+18h+var_A]
jmp short loc_97851
loc_977FF:
lea rsi, aXtc; jumptable 00000000000977C5 case 8
lea rdx, [rsp+18h+var_F]
jmp short loc_97851
loc_9780D:
lea rsi, aSpmInfill+6; jumptable 00000000000977C5 case 9
lea rdx, [rsp+18h+var_10]
jmp short loc_97851
loc_9781B:
lea rsi, aMinP_0; jumptable 00000000000977C5 case 4
lea rdx, [rsp+18h+var_D]
jmp short loc_97851
loc_97829:
lea rsi, aTypP; jumptable 00000000000977C5 case 6
lea rdx, [rsp+18h+var_B]
jmp short loc_97851
loc_97837:
lea rsi, aPenalties; jumptable 00000000000977C5 case 10
lea rdx, [rsp+18h+var_11]
jmp short loc_97851
def_977C5:
lea rsi, aExampleSpecifi+1Fh; jumptable 00000000000977C5 default case, case 5
lea rdx, [rsp+18h+var_12]
loc_97851:
mov rdi, rbx
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
mov rax, rbx
add rsp, 10h
pop rbx
retn
| _QWORD * common_sampler_type_to_str[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
switch ( a2 )
{
case 1:
v2 = "dry";
break;
case 2:
v2 = "top_k";
break;
case 3:
v2 = "top_p";
break;
case 4:
v2 = "min_p";
break;
case 6:
v2 = "typ_p";
break;
case 7:
v2 = "temperature";
break;
case 8:
v2 = "xtc";
break;
case 9:
v2 = "infill";
break;
case 10:
v2 = "penalties";
break;
default:
v2 = "";
break;
}
std::string::basic_string<std::allocator<char>>(a1, (long long)v2);
return a1;
}
| common_sampler_type_to_str[abi:cxx11]:
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
DEC ESI
CMP ESI,0x9
JA 0x00197845
LEA RAX,[0x1b7ed4]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
LEA RSI,[0x1b82ab]
LEA RDX,[RSP + 0xf]
JMP 0x00197851
caseD_3:
LEA RSI,[0x1b82bb]
LEA RDX,[RSP + 0xc]
JMP 0x00197851
caseD_7:
LEA RSI,[0x1b82c7]
LEA RDX,[RSP + 0xa]
JMP 0x00197851
caseD_2:
LEA RSI,[0x1b82af]
LEA RDX,[RSP + 0xe]
JMP 0x00197851
caseD_8:
LEA RSI,[0x1b82d3]
LEA RDX,[RSP + 0x9]
JMP 0x00197851
caseD_9:
LEA RSI,[0x1aa8a9]
LEA RDX,[RSP + 0x8]
JMP 0x00197851
caseD_4:
LEA RSI,[0x1b82c1]
LEA RDX,[RSP + 0xb]
JMP 0x00197851
caseD_6:
LEA RSI,[0x1b82b5]
LEA RDX,[RSP + 0xd]
JMP 0x00197851
caseD_a:
LEA RSI,[0x1b82d7]
LEA RDX,[RSP + 0x7]
JMP 0x00197851
caseD_5:
LEA RSI,[0x1a9151]
LEA RDX,[RSP + 0x6]
LAB_00197851:
MOV RDI,RBX
CALL 0x00125c26
MOV RAX,RBX
ADD RSP,0x10
POP RBX
RET
|
/* common_sampler_type_to_str[abi:cxx11](common_sampler_type) */
string * common_sampler_type_to_str_abi_cxx11_(string *param_1,int4 param_2)
{
allocator *paVar1;
char *pcVar2;
allocator local_12;
allocator local_11;
allocator local_10;
allocator local_f;
allocator local_e;
allocator local_d;
allocator local_c;
allocator local_b;
allocator local_a;
allocator local_9;
switch(param_2) {
case 1:
pcVar2 = "dry";
paVar1 = &local_9;
break;
case 2:
pcVar2 = "top_k";
paVar1 = &local_a;
break;
case 3:
pcVar2 = "top_p";
paVar1 = &local_c;
break;
case 4:
pcVar2 = "min_p";
paVar1 = &local_d;
break;
default:
pcVar2 = "";
paVar1 = &local_12;
break;
case 6:
pcVar2 = "typ_p";
paVar1 = &local_b;
break;
case 7:
pcVar2 = "temperature";
paVar1 = &local_e;
break;
case 8:
pcVar2 = "xtc";
paVar1 = &local_f;
break;
case 9:
pcVar2 = "infill";
paVar1 = &local_10;
break;
case 10:
pcVar2 = "penalties";
paVar1 = &local_11;
}
std::__cxx11::string::string<std::allocator<char>>(param_1,pcVar2,paVar1);
return param_1;
}
| |
43,473 | common_sampler_type_to_str[abi:cxx11](common_sampler_type) | monkey531[P]llama/common/sampling.cpp | std::string common_sampler_type_to_str(enum common_sampler_type cnstr) {
switch (cnstr) {
case COMMON_SAMPLER_TYPE_DRY: return "dry";
case COMMON_SAMPLER_TYPE_TOP_K: return "top_k";
case COMMON_SAMPLER_TYPE_TYPICAL_P: return "typ_p";
case COMMON_SAMPLER_TYPE_TOP_P: return "top_p";
case COMMON_SAMPLER_TYPE_MIN_P: return "min_p";
case COMMON_SAMPLER_TYPE_TEMPERATURE: return "temperature";
case COMMON_SAMPLER_TYPE_XTC: return "xtc";
case COMMON_SAMPLER_TYPE_INFILL: return "infill";
case COMMON_SAMPLER_TYPE_PENALTIES: return "penalties";
default : return "";
}
} | O3 | cpp | common_sampler_type_to_str[abi:cxx11](common_sampler_type):
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %esi
cmpl $0x9, %esi
ja 0xcd18e
leaq 0x26e0e(%rip), %rax # 0xf3ef8
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x271d5(%rip), %rsi # 0xf42cf
leaq 0x271d1(%rip), %rdx # 0xf42d2
jmp 0xcd181
leaq 0x271d5(%rip), %rsi # 0xf42df
leaq 0x271d3(%rip), %rdx # 0xf42e4
jmp 0xcd181
leaq 0x271d1(%rip), %rsi # 0xf42eb
leaq 0x271d5(%rip), %rdx # 0xf42f6
jmp 0xcd181
leaq 0x271a9(%rip), %rsi # 0xf42d3
leaq 0x271a7(%rip), %rdx # 0xf42d8
jmp 0xcd181
leaq 0x271bd(%rip), %rsi # 0xf42f7
leaq 0x271b9(%rip), %rdx # 0xf42fa
jmp 0xcd181
leaq 0x1975f(%rip), %rsi # 0xe68a9
leaq 0x1975e(%rip), %rdx # 0xe68af
jmp 0xcd181
leaq 0x2718b(%rip), %rsi # 0xf42e5
leaq 0x27189(%rip), %rdx # 0xf42ea
jmp 0xcd181
leaq 0x2716f(%rip), %rsi # 0xf42d9
leaq 0x2716d(%rip), %rdx # 0xf42de
jmp 0xcd181
leaq 0x27181(%rip), %rsi # 0xf42fb
leaq 0x27183(%rip), %rdx # 0xf4304
movq %rbx, %rdi
callq 0x21540
movq %rbx, %rax
popq %rbx
retq
leaq 0x17fbc(%rip), %rdx # 0xe5151
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0xcd184
| _Z26common_sampler_type_to_strB5cxx1119common_sampler_type:
push rbx
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
dec esi; switch 10 cases
cmp esi, 9
ja def_CD0F1; jumptable 00000000000CD0F1 default case, case 5
lea rax, jpt_CD0F1
movsxd rcx, ds:(jpt_CD0F1 - 0F3EF8h)[rax+rsi*4]
add rcx, rax
jmp rcx; switch jump
loc_CD0F3:
lea rsi, aDry; jumptable 00000000000CD0F1 case 1
lea rdx, aDry+3; ""
jmp short loc_CD181
loc_CD103:
lea rsi, aTopP_0; jumptable 00000000000CD0F1 case 3
lea rdx, aTopP_0+5; ""
jmp short loc_CD181
loc_CD113:
lea rsi, aTemperature; jumptable 00000000000CD0F1 case 7
lea rdx, aTemperature+0Bh; ""
jmp short loc_CD181
loc_CD123:
lea rsi, aTopK_0; jumptable 00000000000CD0F1 case 2
lea rdx, aTopK_0+5; ""
jmp short loc_CD181
loc_CD133:
lea rsi, aXtc; jumptable 00000000000CD0F1 case 8
lea rdx, aXtc+3; ""
jmp short loc_CD181
loc_CD143:
lea rsi, aSpmInfill+6; jumptable 00000000000CD0F1 case 9
lea rdx, aSpmInfill+0Ch; ""
jmp short loc_CD181
loc_CD153:
lea rsi, aMinP_0; jumptable 00000000000CD0F1 case 4
lea rdx, aMinP_0+5; ""
jmp short loc_CD181
loc_CD163:
lea rsi, aTypP; jumptable 00000000000CD0F1 case 6
lea rdx, aTypP+5; ""
jmp short loc_CD181
loc_CD173:
lea rsi, aPenalties; jumptable 00000000000CD0F1 case 10
lea rdx, aPenalties+9; ""
loc_CD181:
mov rdi, rbx
loc_CD184:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov rax, rbx
pop rbx
retn
def_CD0F1:
lea rdx, aExampleSpecifi+1Fh; jumptable 00000000000CD0F1 default case, case 5
mov rdi, rbx
mov rsi, rdx
jmp short loc_CD184
| _QWORD * common_sampler_type_to_str[abi:cxx11](_QWORD *a1, int a2)
{
char *v2; // rsi
char *v3; // rdx
*a1 = a1 + 2;
switch ( a2 )
{
case 1:
v2 = "dry";
v3 = "";
break;
case 2:
v2 = "top_k";
v3 = "";
break;
case 3:
v2 = "top_p";
v3 = "";
break;
case 4:
v2 = "min_p";
v3 = "";
break;
case 6:
v2 = "typ_p";
v3 = "";
break;
case 7:
v2 = "temperature";
v3 = "";
break;
case 8:
v2 = "xtc";
v3 = "";
break;
case 9:
v2 = "infill";
v3 = "";
break;
case 10:
v2 = "penalties";
v3 = "";
break;
default:
v3 = "";
v2 = "";
break;
}
std::string::_M_construct<char const*>((long long)a1, v2, (long long)v3);
return a1;
}
| common_sampler_type_to_str[abi:cxx11]:
PUSH RBX
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
DEC ESI
CMP ESI,0x9
JA 0x001cd18e
LEA RAX,[0x1f3ef8]
MOVSXD RCX,dword ptr [RAX + RSI*0x4]
ADD RCX,RAX
switchD:
JMP RCX
caseD_1:
LEA RSI,[0x1f42cf]
LEA RDX,[0x1f42d2]
JMP 0x001cd181
caseD_3:
LEA RSI,[0x1f42df]
LEA RDX,[0x1f42e4]
JMP 0x001cd181
caseD_7:
LEA RSI,[0x1f42eb]
LEA RDX,[0x1f42f6]
JMP 0x001cd181
caseD_2:
LEA RSI,[0x1f42d3]
LEA RDX,[0x1f42d8]
JMP 0x001cd181
caseD_8:
LEA RSI,[0x1f42f7]
LEA RDX,[0x1f42fa]
JMP 0x001cd181
caseD_9:
LEA RSI,[0x1e68a9]
LEA RDX,[0x1e68af]
JMP 0x001cd181
caseD_4:
LEA RSI,[0x1f42e5]
LEA RDX,[0x1f42ea]
JMP 0x001cd181
caseD_6:
LEA RSI,[0x1f42d9]
LEA RDX,[0x1f42de]
JMP 0x001cd181
caseD_a:
LEA RSI,[0x1f42fb]
LEA RDX,[0x1f4304]
LAB_001cd181:
MOV RDI,RBX
LAB_001cd184:
CALL 0x00121540
MOV RAX,RBX
POP RBX
RET
caseD_5:
LEA RDX,[0x1e5151]
MOV RDI,RBX
MOV RSI,RDX
JMP 0x001cd184
|
/* common_sampler_type_to_str[abi:cxx11](common_sampler_type) */
long * common_sampler_type_to_str_abi_cxx11_(long *param_1,int4 param_2)
{
char *pcVar1;
char *pcVar2;
*param_1 = (long)(param_1 + 2);
switch(param_2) {
case 1:
pcVar2 = "dry";
pcVar1 = "";
break;
case 2:
pcVar2 = "top_k";
pcVar1 = "";
break;
case 3:
pcVar2 = "top_p";
pcVar1 = "";
break;
case 4:
pcVar2 = "min_p";
pcVar1 = "";
break;
default:
pcVar1 = "";
pcVar2 = pcVar1;
break;
case 6:
pcVar2 = "typ_p";
pcVar1 = "";
break;
case 7:
pcVar2 = "temperature";
pcVar1 = "";
break;
case 8:
pcVar2 = "xtc";
pcVar1 = "";
break;
case 9:
pcVar2 = "infill";
pcVar1 = "";
break;
case 10:
pcVar2 = "penalties";
pcVar1 = "";
}
std::__cxx11::string::_M_construct<char_const*>(param_1,pcVar2,pcVar1);
return param_1;
}
| |
43,474 | my_strntoull_8bit | eloqsql/strings/ctype-simple.c | ulonglong my_strntoull_8bit(CHARSET_INFO *cs,
const char *nptr, size_t l, int base,
char **endptr, int *err)
{
int negative;
register ulonglong cutoff;
register uint cutlim;
register ulonglong i;
register const char *s, *e;
const char *save;
int overflow;
*err= 0; /* Initialize error indicator */
s = nptr;
e = nptr+l;
for(; s<e && my_isspace(cs,*s); s++);
if (s == e)
{
goto noconv;
}
if (*s == '-')
{
negative = 1;
++s;
}
else if (*s == '+')
{
negative = 0;
++s;
}
else
negative = 0;
save = s;
cutoff = (~(ulonglong) 0) / (unsigned long int) base;
cutlim = (uint) ((~(ulonglong) 0) % (unsigned long int) base);
overflow = 0;
i = 0;
for ( ; s != e; s++)
{
register uchar c= *s;
if (c>='0' && c<='9')
c -= '0';
else if (c>='A' && c<='Z')
c = c - 'A' + 10;
else if (c>='a' && c<='z')
c = c - 'a' + 10;
else
break;
if (c >= base)
break;
if (i > cutoff || (i == cutoff && c > cutlim))
overflow = 1;
else
{
i *= (ulonglong) base;
i += c;
}
}
if (s == save)
goto noconv;
if (endptr != NULL)
*endptr = (char *) s;
if (overflow)
{
err[0]= ERANGE;
return (~(ulonglong) 0);
}
return (negative ? -((longlong) i) : (longlong) i);
noconv:
err[0]= EDOM;
if (endptr != NULL)
*endptr = (char *) nptr;
return 0L;
} | O0 | c | my_strntoull_8bit:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq -0x68(%rbp), %rcx
movb %al, -0x76(%rbp)
jae 0x49f78
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x60(%rbp), %rcx
movzbl (%rcx), %ecx
movzbl 0x1(%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x76(%rbp)
movb -0x76(%rbp), %al
testb $0x1, %al
jne 0x49f81
jmp 0x49f91
jmp 0x49f83
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x49f49
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
jne 0x49fa0
jmp 0x4a161
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x49fc1
movl $0x1, -0x3c(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x49feb
movq -0x60(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x49fe2
movl $0x0, -0x3c(%rbp)
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x49fe9
movl $0x0, -0x3c(%rbp)
jmp 0x49feb
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x48(%rbp)
movslq -0x24(%rbp), %rcx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x4c(%rbp)
movl $0x0, -0x74(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x68(%rbp), %rax
je 0x4a105
movq -0x60(%rbp), %rax
movb (%rax), %al
movb %al, -0x75(%rbp)
movzbl -0x75(%rbp), %eax
cmpl $0x30, %eax
jl 0x4a060
movzbl -0x75(%rbp), %eax
cmpl $0x39, %eax
jg 0x4a060
movzbl -0x75(%rbp), %eax
subl $0x30, %eax
movb %al, -0x75(%rbp)
jmp 0x4a0a8
movzbl -0x75(%rbp), %eax
cmpl $0x41, %eax
jl 0x4a081
movzbl -0x75(%rbp), %eax
cmpl $0x5a, %eax
jg 0x4a081
movzbl -0x75(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x75(%rbp)
jmp 0x4a0a6
movzbl -0x75(%rbp), %eax
cmpl $0x61, %eax
jl 0x4a0a2
movzbl -0x75(%rbp), %eax
cmpl $0x7a, %eax
jg 0x4a0a2
movzbl -0x75(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x75(%rbp)
jmp 0x4a0a4
jmp 0x4a105
jmp 0x4a0a6
jmp 0x4a0a8
movzbl -0x75(%rbp), %eax
cmpl -0x24(%rbp), %eax
jl 0x4a0b3
jmp 0x4a105
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
ja 0x4a0d0
movq -0x58(%rbp), %rax
cmpq -0x48(%rbp), %rax
jne 0x4a0d9
movzbl -0x75(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jbe 0x4a0d9
movl $0x1, -0x74(%rbp)
jmp 0x4a0f2
movslq -0x24(%rbp), %rax
imulq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
movzbl -0x75(%rbp), %eax
addq -0x58(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x4a0f4
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x4a02b
movq -0x60(%rbp), %rax
cmpq -0x70(%rbp), %rax
jne 0x4a111
jmp 0x4a161
cmpq $0x0, -0x30(%rbp)
je 0x4a123
movq -0x60(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
cmpl $0x0, -0x74(%rbp)
je 0x4a13d
movq -0x38(%rbp), %rax
movl $0x22, (%rax)
movq $-0x1, -0x8(%rbp)
jmp 0x4a185
cmpl $0x0, -0x3c(%rbp)
je 0x4a14f
xorl %eax, %eax
subq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
jmp 0x4a157
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a185
movq -0x38(%rbp), %rax
movl $0x21, (%rax)
cmpq $0x0, -0x30(%rbp)
je 0x4a17d
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
| my_strntoull_8bit:
push rbp
mov rbp, rsp
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov [rbp+var_24], ecx
mov [rbp+var_30], r8
mov [rbp+var_38], r9
mov rax, [rbp+var_38]
mov dword ptr [rax], 0
mov rax, [rbp+var_18]
mov [rbp+var_60], rax
mov rax, [rbp+var_18]
add rax, [rbp+var_20]
mov [rbp+var_68], rax
loc_49F49:
mov rcx, [rbp+var_60]
xor eax, eax
cmp rcx, [rbp+var_68]
mov [rbp+var_76], al
jnb short loc_49F78
mov rax, [rbp+var_10]
mov rax, [rax+40h]
mov rcx, [rbp+var_60]
movzx ecx, byte ptr [rcx]
movzx eax, byte ptr [rax+rcx+1]
and eax, 8
cmp eax, 0
setnz al
mov [rbp+var_76], al
loc_49F78:
mov al, [rbp+var_76]
test al, 1
jnz short loc_49F81
jmp short loc_49F91
loc_49F81:
jmp short $+2
loc_49F83:
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_49F49
loc_49F91:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_68]
jnz short loc_49FA0
jmp loc_4A161
loc_49FA0:
mov rax, [rbp+var_60]
movsx eax, byte ptr [rax]
cmp eax, 2Dh ; '-'
jnz short loc_49FC1
mov [rbp+var_3C], 1
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_49FEB
loc_49FC1:
mov rax, [rbp+var_60]
movsx eax, byte ptr [rax]
cmp eax, 2Bh ; '+'
jnz short loc_49FE2
mov [rbp+var_3C], 0
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp short loc_49FE9
loc_49FE2:
mov [rbp+var_3C], 0
loc_49FE9:
jmp short $+2
loc_49FEB:
mov rax, [rbp+var_60]
mov [rbp+var_70], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov [rbp+var_48], rax
movsxd rcx, [rbp+var_24]
mov rax, 0FFFFFFFFFFFFFFFFh
xor edx, edx
div rcx
mov eax, edx
mov [rbp+var_4C], eax
mov [rbp+var_74], 0
mov [rbp+var_58], 0
loc_4A02B:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_68]
jz loc_4A105
mov rax, [rbp+var_60]
mov al, [rax]
mov [rbp+var_75], al
movzx eax, [rbp+var_75]
cmp eax, 30h ; '0'
jl short loc_4A060
movzx eax, [rbp+var_75]
cmp eax, 39h ; '9'
jg short loc_4A060
movzx eax, [rbp+var_75]
sub eax, 30h ; '0'
mov [rbp+var_75], al
jmp short loc_4A0A8
loc_4A060:
movzx eax, [rbp+var_75]
cmp eax, 41h ; 'A'
jl short loc_4A081
movzx eax, [rbp+var_75]
cmp eax, 5Ah ; 'Z'
jg short loc_4A081
movzx eax, [rbp+var_75]
sub eax, 41h ; 'A'
add eax, 0Ah
mov [rbp+var_75], al
jmp short loc_4A0A6
loc_4A081:
movzx eax, [rbp+var_75]
cmp eax, 61h ; 'a'
jl short loc_4A0A2
movzx eax, [rbp+var_75]
cmp eax, 7Ah ; 'z'
jg short loc_4A0A2
movzx eax, [rbp+var_75]
sub eax, 61h ; 'a'
add eax, 0Ah
mov [rbp+var_75], al
jmp short loc_4A0A4
loc_4A0A2:
jmp short loc_4A105
loc_4A0A4:
jmp short $+2
loc_4A0A6:
jmp short $+2
loc_4A0A8:
movzx eax, [rbp+var_75]
cmp eax, [rbp+var_24]
jl short loc_4A0B3
jmp short loc_4A105
loc_4A0B3:
mov rax, [rbp+var_58]
cmp rax, [rbp+var_48]
ja short loc_4A0D0
mov rax, [rbp+var_58]
cmp rax, [rbp+var_48]
jnz short loc_4A0D9
movzx eax, [rbp+var_75]
cmp eax, [rbp+var_4C]
jbe short loc_4A0D9
loc_4A0D0:
mov [rbp+var_74], 1
jmp short loc_4A0F2
loc_4A0D9:
movsxd rax, [rbp+var_24]
imul rax, [rbp+var_58]
mov [rbp+var_58], rax
movzx eax, [rbp+var_75]
add rax, [rbp+var_58]
mov [rbp+var_58], rax
loc_4A0F2:
jmp short $+2
loc_4A0F4:
mov rax, [rbp+var_60]
add rax, 1
mov [rbp+var_60], rax
jmp loc_4A02B
loc_4A105:
mov rax, [rbp+var_60]
cmp rax, [rbp+var_70]
jnz short loc_4A111
jmp short loc_4A161
loc_4A111:
cmp [rbp+var_30], 0
jz short loc_4A123
mov rcx, [rbp+var_60]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_4A123:
cmp [rbp+var_74], 0
jz short loc_4A13D
mov rax, [rbp+var_38]
mov dword ptr [rax], 22h ; '"'
mov [rbp+var_8], 0FFFFFFFFFFFFFFFFh
jmp short loc_4A185
loc_4A13D:
cmp [rbp+var_3C], 0
jz short loc_4A14F
xor eax, eax
sub rax, [rbp+var_58]
mov [rbp+var_80], rax
jmp short loc_4A157
loc_4A14F:
mov rax, [rbp+var_58]
mov [rbp+var_80], rax
loc_4A157:
mov rax, [rbp+var_80]
mov [rbp+var_8], rax
jmp short loc_4A185
loc_4A161:
mov rax, [rbp+var_38]
mov dword ptr [rax], 21h ; '!'
cmp [rbp+var_30], 0
jz short loc_4A17D
mov rcx, [rbp+var_18]
mov rax, [rbp+var_30]
mov [rax], rcx
loc_4A17D:
mov [rbp+var_8], 0
loc_4A185:
mov rax, [rbp+var_8]
pop rbp
retn
| long long my_strntoull_8bit(long long a1, _BYTE *a2, long long a3, int a4, _QWORD *a5, _DWORD *a6)
{
bool v8; // [rsp+Ah] [rbp-76h]
unsigned __int8 v9; // [rsp+Bh] [rbp-75h]
unsigned __int8 v10; // [rsp+Bh] [rbp-75h]
int v11; // [rsp+Ch] [rbp-74h]
_BYTE *v12; // [rsp+10h] [rbp-70h]
_BYTE *v13; // [rsp+18h] [rbp-68h]
_BYTE *v14; // [rsp+20h] [rbp-60h]
unsigned long long v15; // [rsp+28h] [rbp-58h]
unsigned long long v16; // [rsp+38h] [rbp-48h]
int v17; // [rsp+44h] [rbp-3Ch]
*a6 = 0;
v14 = a2;
v13 = &a2[a3];
while ( 1 )
{
v8 = 0;
if ( v14 < v13 )
v8 = (*(_BYTE *)(*(_QWORD *)(a1 + 64) + (unsigned __int8)*v14 + 1LL) & 8) != 0;
if ( !v8 )
break;
++v14;
}
if ( v14 == v13 )
goto LABEL_39;
if ( *v14 == 45 )
{
v17 = 1;
++v14;
}
else
{
v17 = 0;
if ( *v14 == 43 )
++v14;
}
v12 = v14;
v16 = 0xFFFFFFFFFFFFFFFFLL / a4;
v11 = 0;
v15 = 0LL;
while ( v14 != v13 )
{
v9 = *v14;
if ( (unsigned __int8)*v14 < 0x30u || v9 > 0x39u )
{
if ( v9 < 0x41u || v9 > 0x5Au )
{
if ( v9 < 0x61u || v9 > 0x7Au )
break;
v10 = v9 - 97 + 10;
}
else
{
v10 = v9 - 65 + 10;
}
}
else
{
v10 = v9 - 48;
}
if ( v10 >= a4 )
break;
if ( v15 > v16 || v15 == v16 && v10 > (unsigned int)(0xFFFFFFFFFFFFFFFFLL % a4) )
v11 = 1;
else
v15 = v15 * a4 + v10;
++v14;
}
if ( v14 == v12 )
{
LABEL_39:
*a6 = 33;
if ( a5 )
*a5 = a2;
return 0LL;
}
else
{
if ( a5 )
*a5 = v14;
if ( v11 )
{
*a6 = 34;
return -1LL;
}
else if ( v17 )
{
return -(long long)v15;
}
else
{
return v15;
}
}
}
| my_strntoull_8bit:
PUSH RBP
MOV RBP,RSP
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 qword ptr [RBP + -0x30],R8
MOV qword ptr [RBP + -0x38],R9
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x0
MOV RAX,qword ptr [RBP + -0x18]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x18]
ADD RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RBP + -0x68],RAX
LAB_00149f49:
MOV RCX,qword ptr [RBP + -0x60]
XOR EAX,EAX
CMP RCX,qword ptr [RBP + -0x68]
MOV byte ptr [RBP + -0x76],AL
JNC 0x00149f78
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX + 0x40]
MOV RCX,qword ptr [RBP + -0x60]
MOVZX ECX,byte ptr [RCX]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + 0x1]
AND EAX,0x8
CMP EAX,0x0
SETNZ AL
MOV byte ptr [RBP + -0x76],AL
LAB_00149f78:
MOV AL,byte ptr [RBP + -0x76]
TEST AL,0x1
JNZ 0x00149f81
JMP 0x00149f91
LAB_00149f81:
JMP 0x00149f83
LAB_00149f83:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00149f49
LAB_00149f91:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x68]
JNZ 0x00149fa0
JMP 0x0014a161
LAB_00149fa0:
MOV RAX,qword ptr [RBP + -0x60]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2d
JNZ 0x00149fc1
MOV dword ptr [RBP + -0x3c],0x1
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00149feb
LAB_00149fc1:
MOV RAX,qword ptr [RBP + -0x60]
MOVSX EAX,byte ptr [RAX]
CMP EAX,0x2b
JNZ 0x00149fe2
MOV dword ptr [RBP + -0x3c],0x0
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x00149fe9
LAB_00149fe2:
MOV dword ptr [RBP + -0x3c],0x0
LAB_00149fe9:
JMP 0x00149feb
LAB_00149feb:
MOV RAX,qword ptr [RBP + -0x60]
MOV qword ptr [RBP + -0x70],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV qword ptr [RBP + -0x48],RAX
MOVSXD RCX,dword ptr [RBP + -0x24]
MOV RAX,-0x1
XOR EDX,EDX
DIV RCX
MOV EAX,EDX
MOV dword ptr [RBP + -0x4c],EAX
MOV dword ptr [RBP + -0x74],0x0
MOV qword ptr [RBP + -0x58],0x0
LAB_0014a02b:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x68]
JZ 0x0014a105
MOV RAX,qword ptr [RBP + -0x60]
MOV AL,byte ptr [RAX]
MOV byte ptr [RBP + -0x75],AL
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x30
JL 0x0014a060
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x39
JG 0x0014a060
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x30
MOV byte ptr [RBP + -0x75],AL
JMP 0x0014a0a8
LAB_0014a060:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x41
JL 0x0014a081
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x5a
JG 0x0014a081
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x41
ADD EAX,0xa
MOV byte ptr [RBP + -0x75],AL
JMP 0x0014a0a6
LAB_0014a081:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x61
JL 0x0014a0a2
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,0x7a
JG 0x0014a0a2
MOVZX EAX,byte ptr [RBP + -0x75]
SUB EAX,0x61
ADD EAX,0xa
MOV byte ptr [RBP + -0x75],AL
JMP 0x0014a0a4
LAB_0014a0a2:
JMP 0x0014a105
LAB_0014a0a4:
JMP 0x0014a0a6
LAB_0014a0a6:
JMP 0x0014a0a8
LAB_0014a0a8:
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,dword ptr [RBP + -0x24]
JL 0x0014a0b3
JMP 0x0014a105
LAB_0014a0b3:
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x48]
JA 0x0014a0d0
MOV RAX,qword ptr [RBP + -0x58]
CMP RAX,qword ptr [RBP + -0x48]
JNZ 0x0014a0d9
MOVZX EAX,byte ptr [RBP + -0x75]
CMP EAX,dword ptr [RBP + -0x4c]
JBE 0x0014a0d9
LAB_0014a0d0:
MOV dword ptr [RBP + -0x74],0x1
JMP 0x0014a0f2
LAB_0014a0d9:
MOVSXD RAX,dword ptr [RBP + -0x24]
IMUL RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
MOVZX EAX,byte ptr [RBP + -0x75]
ADD RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x58],RAX
LAB_0014a0f2:
JMP 0x0014a0f4
LAB_0014a0f4:
MOV RAX,qword ptr [RBP + -0x60]
ADD RAX,0x1
MOV qword ptr [RBP + -0x60],RAX
JMP 0x0014a02b
LAB_0014a105:
MOV RAX,qword ptr [RBP + -0x60]
CMP RAX,qword ptr [RBP + -0x70]
JNZ 0x0014a111
JMP 0x0014a161
LAB_0014a111:
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0014a123
MOV RCX,qword ptr [RBP + -0x60]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0014a123:
CMP dword ptr [RBP + -0x74],0x0
JZ 0x0014a13d
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x22
MOV qword ptr [RBP + -0x8],-0x1
JMP 0x0014a185
LAB_0014a13d:
CMP dword ptr [RBP + -0x3c],0x0
JZ 0x0014a14f
XOR EAX,EAX
SUB RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
JMP 0x0014a157
LAB_0014a14f:
MOV RAX,qword ptr [RBP + -0x58]
MOV qword ptr [RBP + -0x80],RAX
LAB_0014a157:
MOV RAX,qword ptr [RBP + -0x80]
MOV qword ptr [RBP + -0x8],RAX
JMP 0x0014a185
LAB_0014a161:
MOV RAX,qword ptr [RBP + -0x38]
MOV dword ptr [RAX],0x21
CMP qword ptr [RBP + -0x30],0x0
JZ 0x0014a17d
MOV RCX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x30]
MOV qword ptr [RAX],RCX
LAB_0014a17d:
MOV qword ptr [RBP + -0x8],0x0
LAB_0014a185:
MOV RAX,qword ptr [RBP + -0x8]
POP RBP
RET
|
ulong my_strntoull_8bit(long param_1,byte *param_2,long param_3,int param_4,int8 *param_5,
int4 *param_6)
{
int1 auVar1 [16];
int1 auVar2 [16];
bool bVar3;
byte *pbVar4;
byte *pbVar5;
ulong uVar6;
bool bVar7;
ulong local_88;
byte local_7d;
byte *local_68;
ulong local_60;
*param_6 = 0;
pbVar5 = param_2 + param_3;
local_68 = param_2;
while( true ) {
bVar7 = false;
if (local_68 < pbVar5) {
bVar7 = (*(byte *)(*(long *)(param_1 + 0x40) + 1 + (ulong)*local_68) & 8) != 0;
}
if (!bVar7) break;
local_68 = local_68 + 1;
}
if (local_68 != pbVar5) {
if (*local_68 == 0x2d) {
bVar7 = true;
local_68 = local_68 + 1;
}
else {
if (*local_68 == 0x2b) {
local_68 = local_68 + 1;
}
bVar7 = false;
}
pbVar4 = local_68;
auVar1._8_8_ = 0;
auVar1._0_8_ = (long)param_4;
uVar6 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar1,0);
auVar2._8_8_ = 0;
auVar2._0_8_ = (long)param_4;
bVar3 = false;
local_60 = 0;
for (; local_68 != pbVar5; local_68 = local_68 + 1) {
local_7d = *local_68;
if ((local_7d < 0x30) || (0x39 < local_7d)) {
if ((local_7d < 0x41) || (0x5a < local_7d)) {
if ((local_7d < 0x61) || (0x7a < local_7d)) break;
local_7d = local_7d + 0xa9;
}
else {
local_7d = local_7d - 0x37;
}
}
else {
local_7d = local_7d - 0x30;
}
if (param_4 <= (int)(uint)local_7d) break;
if ((uVar6 < local_60) ||
((local_60 == uVar6 &&
(SUB164((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) % auVar2,0) < (uint)local_7d)))
) {
bVar3 = true;
}
else {
local_60 = (ulong)local_7d + (long)param_4 * local_60;
}
}
if (local_68 != pbVar4) {
if (param_5 != (int8 *)0x0) {
*param_5 = local_68;
}
if (bVar3) {
*param_6 = 0x22;
return 0xffffffffffffffff;
}
if (bVar7) {
local_88 = -local_60;
}
else {
local_88 = local_60;
}
return local_88;
}
}
*param_6 = 0x21;
if (param_5 != (int8 *)0x0) {
*param_5 = param_2;
}
return 0;
}
| |
43,475 | string_parse_kv_override(char const*, std::vector<llama_model_kv_override, std::allocator<llama_model_kv_override>>&) | monkey531[P]llama/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 0x1a300
testq %rax, %rax
je 0x72c34
movq %rax, %r15
movq %rax, %r12
subq %rbx, %r12
cmpq $0x80, %r12
jl 0x72c70
leaq 0xb97dd(%rip), %rax # 0x12c418
cmpl $0x0, (%rax)
js 0x72e1c
callq 0xcb3a7
leaq 0x7aff6(%rip), %rdx # 0xedc46
leaq 0x7b00f(%rip), %rcx # 0xedc66
xorl %ebp, %ebp
movq %rax, %rdi
movl $0x4, %esi
movq %rbx, %r8
xorl %eax, %eax
callq 0xcb444
jmp 0x72e1e
leaq 0xc(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a460
movb $0x0, 0xc(%rsp,%r12)
leaq 0x1(%r15), %r12
leaq 0x7afee(%rip), %rsi # 0xedc7f
movl $0x4, %edx
movq %r12, %rdi
callq 0x1a430
testl %eax, %eax
je 0x72d13
leaq 0x7afdb(%rip), %rsi # 0xedc84
movl $0x6, %edx
movq %r12, %rdi
callq 0x1a430
testl %eax, %eax
je 0x72d31
leaq 0x7afca(%rip), %rsi # 0xedc8b
movl $0x5, %edx
movq %r12, %rdi
callq 0x1a430
testl %eax, %eax
je 0x72d8c
leaq 0x7afe4(%rip), %rsi # 0xedcc1
movl $0x4, %edx
movq %r12, %rdi
callq 0x1a430
testl %eax, %eax
je 0x72de3
leaq 0xb971f(%rip), %rax # 0x12c418
cmpl $0x0, (%rax)
js 0x72e1c
callq 0xcb3a7
leaq 0x7aff7(%rip), %rdx # 0xedd05
jmp 0x72c50
addq $0x5, %r15
movl $0x0, 0x8(%rsp)
movq %r15, %rdi
callq 0x1aa60
movq %rax, 0x90(%rsp)
jmp 0x72d4e
addq $0x7, %r15
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
callq 0x1aac0
movsd %xmm0, 0x90(%rsp)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x72d74
leaq 0x8(%rsp), %rsi
movl $0x108, %edx # imm = 0x108
movq %rax, %rdi
callq 0x1a750
addq $0x108, 0x8(%r14) # imm = 0x108
jmp 0x72d84
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xb864a
movb $0x1, %bpl
jmp 0x72e1e
addq $0x6, %r15
movl $0x2, 0x8(%rsp)
leaq 0x72e4b(%rip), %rsi # 0xe5bea
movq %r15, %rdi
callq 0x1ac30
testl %eax, %eax
je 0x72e30
leaq 0x75b1d(%rip), %rsi # 0xe88d3
movq %r15, %rdi
callq 0x1ac30
testl %eax, %eax
je 0x72e5e
leaq 0xb964b(%rip), %rax # 0x12c418
cmpl $0x0, (%rax)
js 0x72e1c
callq 0xcb3a7
leaq 0x7aeb3(%rip), %rdx # 0xedc91
jmp 0x72c50
addq $0x5, %r15
movl $0x3, 0x8(%rsp)
movq %r15, %rdi
callq 0x1a3e0
cmpq $0x80, %rax
jb 0x72e3d
leaq 0xb9612(%rip), %rax # 0x12c418
cmpl $0x0, (%rax)
js 0x72e1c
callq 0xcb3a7
leaq 0x7aeaf(%rip), %rdx # 0xedcc6
jmp 0x72c50
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 0x72d4e
leaq 0x90(%rsp), %rbx
movl $0x7f, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1a460
movb $0x0, 0x7f(%rbx)
jmp 0x72d4e
movb $0x0, 0x90(%rsp)
jmp 0x72d4e
| _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_72C34
mov r15, rax
mov r12, rax
sub r12, rbx
cmp r12, 80h
jl short loc_72C70
loc_72C34:
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_72E1C
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv; "%s: malformed KV override '%s'\n"
loc_72C50:
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_72E1E
loc_72C70:
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_72D13
lea rsi, aFloat; "float:"
mov edx, 6
mov rdi, r12
call _strncmp
test eax, eax
jz short loc_72D31
lea rsi, aBool; "bool:"
mov edx, 5
mov rdi, r12
call _strncmp
test eax, eax
jz loc_72D8C
lea rsi, aStr; "str:"
mov edx, 4
mov rdi, r12
call _strncmp
test eax, eax
jz loc_72DE3
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js loc_72E1C
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidTypeFo; "%s: invalid type for KV override '%s'\n"
jmp loc_72C50
loc_72D13:
add r15, 5
mov [rsp+138h+var_130], 0
mov rdi, r15
call _atol
mov [rsp+138h+var_A8], rax
jmp short loc_72D4E
loc_72D31:
add r15, 7
mov [rsp+138h+var_130], 1
mov rdi, r15
call _atof
movsd [rsp+138h+var_A8], xmm0
loc_72D4E:
mov rax, [r14+8]
cmp rax, [r14+10h]
jz short loc_72D74
lea rsi, [rsp+138h+var_130]
mov edx, 108h
mov rdi, rax
call _memcpy
add qword ptr [r14+8], 108h
jmp short loc_72D84
loc_72D74:
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_72D84:
mov bpl, 1
jmp loc_72E1E
loc_72D8C:
add r15, 6
mov [rsp+138h+var_130], 2
lea rsi, aTrue; "true"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_72E30
lea rsi, aAdvancedOption+0ABh; "false"
mov rdi, r15
call _strcmp
test eax, eax
jz loc_72E5E
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_72E1C
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSInvalidBoolea; "%s: invalid boolean value for KV overri"...
jmp loc_72C50
loc_72DE3:
add r15, 5
mov [rsp+138h+var_130], 3
mov rdi, r15
call _strlen
cmp rax, 80h
jb short loc_72E3D
lea rax, common_log_verbosity_thold
cmp dword ptr [rax], 0
js short loc_72E1C
call _Z15common_log_mainv; common_log_main(void)
lea rdx, aSMalformedKvOv_0; "%s: malformed KV override '%s', value c"...
jmp loc_72C50
loc_72E1C:
xor ebp, ebp
loc_72E1E:
mov eax, ebp
add rsp, 110h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_72E30:
mov byte ptr [rsp+138h+var_A8], 1
jmp loc_72D4E
loc_72E3D:
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_72D4E
loc_72E5E:
mov byte ptr [rsp+138h+var_A8], 0
jmp loc_72D4E
| 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 0x0011a300
TEST RAX,RAX
JZ 0x00172c34
MOV R15,RAX
MOV R12,RAX
SUB R12,RBX
CMP R12,0x80
JL 0x00172c70
LAB_00172c34:
LEA RAX,[0x22c418]
CMP dword ptr [RAX],0x0
JS 0x00172e1c
CALL 0x001cb3a7
LEA RDX,[0x1edc46]
LAB_00172c50:
LEA RCX,[0x1edc66]
XOR EBP,EBP
MOV RDI,RAX
MOV ESI,0x4
MOV R8,RBX
XOR EAX,EAX
CALL 0x001cb444
JMP 0x00172e1e
LAB_00172c70:
LEA RDI,[RSP + 0xc]
MOV RSI,RBX
MOV RDX,R12
CALL 0x0011a460
MOV byte ptr [RSP + R12*0x1 + 0xc],0x0
LEA R12,[R15 + 0x1]
LEA RSI,[0x1edc7f]
MOV EDX,0x4
MOV RDI,R12
CALL 0x0011a430
TEST EAX,EAX
JZ 0x00172d13
LEA RSI,[0x1edc84]
MOV EDX,0x6
MOV RDI,R12
CALL 0x0011a430
TEST EAX,EAX
JZ 0x00172d31
LEA RSI,[0x1edc8b]
MOV EDX,0x5
MOV RDI,R12
CALL 0x0011a430
TEST EAX,EAX
JZ 0x00172d8c
LEA RSI,[0x1edcc1]
MOV EDX,0x4
MOV RDI,R12
CALL 0x0011a430
TEST EAX,EAX
JZ 0x00172de3
LEA RAX,[0x22c418]
CMP dword ptr [RAX],0x0
JS 0x00172e1c
CALL 0x001cb3a7
LEA RDX,[0x1edd05]
JMP 0x00172c50
LAB_00172d13:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x0
MOV RDI,R15
CALL 0x0011aa60
MOV qword ptr [RSP + 0x90],RAX
JMP 0x00172d4e
LAB_00172d31:
ADD R15,0x7
MOV dword ptr [RSP + 0x8],0x1
MOV RDI,R15
CALL 0x0011aac0
MOVSD qword ptr [RSP + 0x90],XMM0
LAB_00172d4e:
MOV RAX,qword ptr [R14 + 0x8]
CMP RAX,qword ptr [R14 + 0x10]
JZ 0x00172d74
LEA RSI,[RSP + 0x8]
MOV EDX,0x108
MOV RDI,RAX
CALL 0x0011a750
ADD qword ptr [R14 + 0x8],0x108
JMP 0x00172d84
LAB_00172d74:
LEA RDX,[RSP + 0x8]
MOV RDI,R14
MOV RSI,RAX
CALL 0x001b864a
LAB_00172d84:
MOV BPL,0x1
JMP 0x00172e1e
LAB_00172d8c:
ADD R15,0x6
MOV dword ptr [RSP + 0x8],0x2
LEA RSI,[0x1e5bea]
MOV RDI,R15
CALL 0x0011ac30
TEST EAX,EAX
JZ 0x00172e30
LEA RSI,[0x1e88d3]
MOV RDI,R15
CALL 0x0011ac30
TEST EAX,EAX
JZ 0x00172e5e
LEA RAX,[0x22c418]
CMP dword ptr [RAX],0x0
JS 0x00172e1c
CALL 0x001cb3a7
LEA RDX,[0x1edc91]
JMP 0x00172c50
LAB_00172de3:
ADD R15,0x5
MOV dword ptr [RSP + 0x8],0x3
MOV RDI,R15
CALL 0x0011a3e0
CMP RAX,0x80
JC 0x00172e3d
LEA RAX,[0x22c418]
CMP dword ptr [RAX],0x0
JS 0x00172e1c
CALL 0x001cb3a7
LEA RDX,[0x1edcc6]
JMP 0x00172c50
LAB_00172e1c:
XOR EBP,EBP
LAB_00172e1e:
MOV EAX,EBP
ADD RSP,0x110
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00172e30:
MOV byte ptr [RSP + 0x90],0x1
JMP 0x00172d4e
LAB_00172e3d:
LEA RBX,[RSP + 0x90]
MOV EDX,0x7f
MOV RDI,RBX
MOV RSI,R15
CALL 0x0011a460
MOV byte ptr [RBX + 0x7f],0x0
JMP 0x00172d4e
LAB_00172e5e:
MOV byte ptr [RSP + 0x90],0x0
JMP 0x00172d4e
|
/* 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_00172e1c;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\'\n";
goto LAB_00172c50;
}
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_00172d4e;
}
if (common_log_verbosity_thold < 0) goto LAB_00172e1c;
uVar3 = common_log_main();
pcVar2 = "%s: malformed KV override \'%s\', value cannot exceed 127 chars\n";
}
else {
if (common_log_verbosity_thold < 0) {
LAB_00172e1c:
uVar4 = 0;
goto LAB_00172e1e;
}
uVar3 = common_log_main();
pcVar2 = "%s: invalid type for KV override \'%s\'\n";
}
LAB_00172c50:
uVar4 = 0;
common_log_add(uVar3,4,pcVar2,"string_parse_kv_override",param_1);
goto LAB_00172e1e;
}
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_00172e1c;
uVar3 = common_log_main();
pcVar2 = "%s: invalid boolean value for KV override \'%s\'\n";
goto LAB_00172c50;
}
local_a8[0] = (double)((ulong)local_a8[0] & 0xffffffffffffff00);
}
}
}
LAB_00172d4e:
__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_00172e1e:
return uVar4 & 0xffffffff;
}
| |
43,476 | testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest-typed-test.cc | const char* TypedTestSuitePState::VerifyRegisteredTestNames(
const char* test_suite_name, const char* file, int line,
const char* registered_tests) {
RegisterTypeParameterizedTestSuite(test_suite_name, CodeLocation(file, line));
typedef RegisteredTestsMap::const_iterator RegisteredTestIter;
registered_ = true;
std::vector<std::string> name_vec = SplitIntoTestNames(registered_tests);
Message errors;
std::set<std::string> tests;
for (std::vector<std::string>::const_iterator name_it = name_vec.begin();
name_it != name_vec.end(); ++name_it) {
const std::string& name = *name_it;
if (tests.count(name) != 0) {
errors << "Test " << name << " is listed more than once.\n";
continue;
}
if (registered_tests_.count(name) != 0) {
tests.insert(name);
} else {
errors << "No test named " << name
<< " can be found in this test suite.\n";
}
}
for (RegisteredTestIter it = registered_tests_.begin();
it != registered_tests_.end(); ++it) {
if (tests.count(it->first) == 0) {
errors << "You forgot to list test " << it->first << ".\n";
}
}
const std::string& errors_str = errors.GetString();
if (!errors_str.empty()) {
fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(),
errors_str.c_str());
fflush(stderr);
posix::Abort();
}
return registered_tests;
} | O0 | cpp | testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int, char const*):
subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movl %ecx, 0x1ec(%rsp)
movq %r8, 0x1e0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x197(%rsp), %rdi
movq %rdi, 0x90(%rsp)
callq 0x16d00
movq 0x88(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0x198(%rsp), %rdi
callq 0x1dbb0
jmp 0xc413f
movl 0x1ec(%rsp), %edx
leaq 0x1b8(%rsp), %rdi
leaq 0x198(%rsp), %rsi
callq 0x1dc70
jmp 0xc415d
movq 0x80(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0xc46a0
jmp 0xc4174
leaq 0x1b8(%rsp), %rdi
callq 0x1dfc0
leaq 0x198(%rsp), %rdi
callq 0x1dfd0
leaq 0x197(%rsp), %rdi
callq 0x16790
movq 0x78(%rsp), %rax
movb $0x1, (%rax)
movq 0x1e0(%rsp), %rsi
leaq 0x168(%rsp), %rdi
callq 0xc4730
leaq 0x160(%rsp), %rdi
callq 0xc8d80
jmp 0xc41c7
leaq 0x130(%rsp), %rdi
callq 0xed030
leaq 0x168(%rsp), %rdi
callq 0xed040
movq %rax, 0x120(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0xed070
leaq 0x168(%rsp), %rdi
callq 0xed0f0
movq %rax, 0x118(%rsp)
leaq 0x128(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0xed0b0
xorb $-0x1, %al
testb $0x1, %al
jne 0xc4233
jmp 0xc441c
leaq 0x128(%rsp), %rdi
callq 0xed120
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rsi
leaq 0x130(%rsp), %rdi
callq 0xed130
movq %rax, 0x70(%rsp)
jmp 0xc4264
movq 0x70(%rsp), %rax
cmpq $0x0, %rax
je 0xc435d
leaq 0x588ca(%rip), %rsi # 0x11cb44
leaq 0x160(%rsp), %rdi
callq 0xec4b0
movq %rax, 0x68(%rsp)
jmp 0xc428e
movq 0x68(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x32aa0
movq %rax, 0x60(%rsp)
jmp 0xc42a7
movq 0x60(%rsp), %rdi
leaq 0x58897(%rip), %rsi # 0x11cb4a
callq 0xeb170
jmp 0xc42ba
jmp 0xc440a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0xc4319
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0xc430c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
leaq 0x1b8(%rsp), %rdi
callq 0x1dfc0
leaq 0x198(%rsp), %rdi
callq 0x1dfd0
leaq 0x197(%rsp), %rdi
callq 0x16790
jmp 0xc4686
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0xc4679
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
jmp 0xc465f
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
movq 0x110(%rsp), %rsi
callq 0xed190
movq %rax, 0x58(%rsp)
jmp 0xc437a
movq 0x58(%rsp), %rax
cmpq $0x0, %rax
je 0xc43bf
movq 0x110(%rsp), %rsi
leaq 0x130(%rsp), %rdi
callq 0xed1f0
movb %dl, 0x4f(%rsp)
movq %rax, 0x50(%rsp)
jmp 0xc43a5
movb 0x4f(%rsp), %al
movq 0x50(%rsp), %rcx
movq %rcx, 0x100(%rsp)
movb %al, 0x108(%rsp)
jmp 0xc4408
leaq 0x587a0(%rip), %rsi # 0x11cb66
leaq 0x160(%rsp), %rdi
callq 0xed250
movq %rax, 0x40(%rsp)
jmp 0xc43da
movq 0x40(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x32aa0
movq %rax, 0x38(%rsp)
jmp 0xc43f3
movq 0x38(%rsp), %rdi
leaq 0x58776(%rip), %rsi # 0x11cb75
callq 0xed290
jmp 0xc4406
jmp 0xc4408
jmp 0xc440a
leaq 0x128(%rsp), %rdi
callq 0xed2d0
jmp 0xc41fe
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0xed2f0
movq %rax, 0xf0(%rsp)
leaq 0xf8(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xed320
movq 0x78(%rsp), %rdi
addq $0x8, %rdi
callq 0xed360
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0xed320
leaq 0xf8(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xed340
xorb $-0x1, %al
testb $0x1, %al
jne 0xc4492
jmp 0xc4526
leaq 0xf8(%rsp), %rdi
callq 0xed390
movq %rax, %rsi
leaq 0x130(%rsp), %rdi
callq 0xed130
movq %rax, 0x30(%rsp)
jmp 0xc44b6
movq 0x30(%rsp), %rax
cmpq $0x0, %rax
jne 0xc4512
leaq 0x586d0(%rip), %rsi # 0x11cb98
leaq 0x160(%rsp), %rdi
callq 0xed3b0
movq %rax, 0x28(%rsp)
jmp 0xc44dc
leaq 0xf8(%rsp), %rdi
callq 0xed390
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x32aa0
movq %rax, 0x20(%rsp)
jmp 0xc44fd
movq 0x20(%rsp), %rdi
leaq 0x592b0(%rip), %rsi # 0x11d7b9
callq 0x32a60
jmp 0xc4510
jmp 0xc4512
jmp 0xc4514
leaq 0xf8(%rsp), %rdi
callq 0xed3f0
jmp 0xc4447
leaq 0xb8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0xbad90
jmp 0xc453d
leaq 0xb8(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x41750
testb $0x1, %al
jne 0xc4613
movq 0xc0a17(%rip), %rax # 0x184f80
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x1f0(%rsp), %rsi
movl 0x1ec(%rsp), %edx
leaq 0x98(%rsp), %rdi
callq 0xc13f0
jmp 0xc458f
leaq 0x98(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1f1e0
movq %rax, 0x8(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x1f1e0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x585ea(%rip), %rsi # 0x11cbb1
xorl %eax, %eax
callq 0x16aa0
movq 0x10(%rsp), %rdi
callq 0x1dfd0
movq 0xc09a1(%rip), %rax # 0x184f80
movq (%rax), %rdi
callq 0x16850
jmp 0xc45e9
callq 0xec570
jmp 0xc45f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x188(%rsp)
movl %eax, 0x184(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x1dfd0
jmp 0xc465f
movq 0x1e0(%rsp), %rax
movq %rax, (%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x1dfd0
leaq 0x130(%rsp), %rdi
callq 0xed420
leaq 0x160(%rsp), %rdi
callq 0x1e080
leaq 0x168(%rsp), %rdi
callq 0xeb700
movq (%rsp), %rax
addq $0x208, %rsp # imm = 0x208
retq
leaq 0x130(%rsp), %rdi
callq 0xed420
leaq 0x160(%rsp), %rdi
callq 0x1e080
leaq 0x168(%rsp), %rdi
callq 0xeb700
movq 0x188(%rsp), %rdi
callq 0x16cf0
nopw %cs:(%rax,%rax)
| _ZN7testing8internal20TypedTestSuitePState25VerifyRegisteredTestNamesEPKcS3_iS3_:
sub rsp, 208h
mov qword ptr [rsp+208h+var_8], rdi
mov qword ptr [rsp+208h+var_10], rsi
mov [rsp+208h+var_18], rdx
mov [rsp+208h+var_1C], ecx
mov qword ptr [rsp+208h+var_28], r8
mov rax, qword ptr [rsp+208h+var_8]
mov qword ptr [rsp+208h+var_190], rax; int
mov rax, qword ptr [rsp+208h+var_10]
mov qword ptr [rsp+208h+var_188], rax; int
mov rax, [rsp+208h+var_18]
mov [rsp+208h+var_180], rax; __int64
lea rdi, [rsp+208h+var_71]
mov qword ptr [rsp+208h+var_178], rdi; int
call __ZNSaIcEC1Ev; std::allocator<char>::allocator(void)
mov rsi, [rsp+208h+var_180]
mov rdx, qword ptr [rsp+208h+var_178]
lea rdi, [rsp+208h+var_71+1]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
jmp short $+2
loc_C413F:
mov edx, [rsp+208h+var_1C]
lea rdi, [rsp+208h+var_50]
lea rsi, [rsp+208h+var_71+1]
call _ZN7testing8internal12CodeLocationC2ENSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEi; testing::internal::CodeLocation::CodeLocation(std::string,int)
jmp short $+2
loc_C415D:
mov rdi, qword ptr [rsp+208h+var_188]
lea rsi, [rsp+208h+var_50]
call _ZN7testing8internal34RegisterTypeParameterizedTestSuiteEPKcNS0_12CodeLocationE; testing::internal::RegisterTypeParameterizedTestSuite(char const*,testing::internal::CodeLocation)
jmp short $+2
loc_C4174:
lea rdi, [rsp+208h+var_50]; this
call _ZN7testing8internal12CodeLocationD2Ev; testing::internal::CodeLocation::~CodeLocation()
lea rdi, [rsp+208h+var_71+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+208h+var_71]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
mov rax, qword ptr [rsp+208h+var_190]
mov byte ptr [rax], 1
mov rsi, qword ptr [rsp+208h+var_28]; int
lea rdi, [rsp+208h+var_A0]; int
call _ZN7testing8internalL18SplitIntoTestNamesB5cxx11EPKc; testing::internal::SplitIntoTestNames(char const*)
lea rdi, [rsp+208h+var_A8]; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
jmp short $+2
loc_C41C7:
lea rdi, [rsp+208h+var_D8]
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EEC2Ev; std::set<std::string>::set(void)
lea rdi, [rsp+208h+var_A0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE5beginEv; std::vector<std::string>::begin(void)
mov [rsp+208h+var_E8], rax
lea rdi, [rsp+208h+var_E0]
lea rsi, [rsp+208h+var_E8]
call _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEC2IPS6_EERKNS0_IT_NS_11__enable_ifIXsr3std10__are_sameISF_SE_EE7__valueESB_E6__typeEEE
loc_C41FE:
lea rdi, [rsp+208h+var_A0]
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE3endEv; std::vector<std::string>::end(void)
mov [rsp+208h+var_F0], rax
lea rdi, [rsp+208h+var_E0]
lea rsi, [rsp+208h+var_F0]
call _ZN9__gnu_cxxeqIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPS6_St6vectorIS6_SaIS6_EEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISD_T1_EERKNSG_ISE_SH_EE
xor al, 0FFh
test al, 1
jnz short loc_C4233
jmp loc_C441C
loc_C4233:
lea rdi, [rsp+208h+var_E0]
call _ZNK9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEdeEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*(void)
mov [rsp+208h+var_F8], rax
mov rsi, [rsp+208h+var_F8]
lea rdi, [rsp+208h+var_D8]
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE5countERKS5_; std::set<std::string>::count(std::string const&)
mov [rsp+208h+var_198], rax
jmp short $+2
loc_C4264:
mov rax, [rsp+208h+var_198]
cmp rax, 0
jz loc_C435D
lea rsi, aTest; "Test "
lea rdi, [rsp+208h+var_A8]
call _ZN7testing7MessagelsIA6_cEERS0_RKT_; testing::Message::operator<<<char [6]>(char [6] const&)
mov [rsp+208h+var_1A0], rax
jmp short $+2
loc_C428E:
mov rdi, [rsp+208h+var_1A0]
mov rsi, [rsp+208h+var_F8]
call _ZN7testing7MessagelsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS0_RKT_; testing::Message::operator<<<std::string>(std::string const&)
mov [rsp+208h+var_1A8], rax
jmp short $+2
loc_C42A7:
mov rdi, [rsp+208h+var_1A8]
lea rsi, aIsListedMoreTh; " is listed more than once.\n"
call _ZN7testing7MessagelsIA28_cEERS0_RKT_; testing::Message::operator<<<char [28]>(char [28] const&)
jmp short $+2
loc_C42BA:
jmp loc_C440A
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
jmp short loc_C4319
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
jmp short loc_C430C
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
lea rdi, [rsp+208h+var_50]; this
call _ZN7testing8internal12CodeLocationD2Ev; testing::internal::CodeLocation::~CodeLocation()
loc_C430C:
lea rdi, [rsp+208h+var_71+1]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
loc_C4319:
lea rdi, [rsp+208h+var_71]
call __ZNSaIcED1Ev; std::allocator<char>::~allocator()
jmp loc_C4686
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
jmp loc_C4679
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
jmp loc_C465F
loc_C435D:
mov rdi, qword ptr [rsp+208h+var_190]
add rdi, 8
mov rsi, [rsp+208h+var_F8]
call _ZNKSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationESt4lessIvESaISt4pairIKS5_S8_EEE5countERSC_; std::map<std::string,testing::internal::CodeLocation>::count(std::string const&)
mov [rsp+208h+var_1B0], rax
jmp short $+2
loc_C437A:
mov rax, [rsp+208h+var_1B0]
cmp rax, 0
jz short loc_C43BF
mov rsi, [rsp+208h+var_F8]
lea rdi, [rsp+208h+var_D8]
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE6insertERKS5_; std::set<std::string>::insert(std::string const&)
mov [rsp+208h+var_1B9], dl
mov [rsp+208h+var_1B8], rax
jmp short $+2
loc_C43A5:
mov al, [rsp+208h+var_1B9]
mov rcx, [rsp+208h+var_1B8]
mov [rsp+208h+var_108], rcx
mov [rsp+208h+var_100], al
jmp short loc_C4408
loc_C43BF:
lea rsi, aNoTestNamed; "No test named "
lea rdi, [rsp+208h+var_A8]
call _ZN7testing7MessagelsIA15_cEERS0_RKT_; testing::Message::operator<<<char [15]>(char [15] const&)
mov [rsp+208h+var_1C8], rax
jmp short $+2
loc_C43DA:
mov rdi, [rsp+208h+var_1C8]
mov rsi, [rsp+208h+var_F8]
call _ZN7testing7MessagelsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS0_RKT_; testing::Message::operator<<<std::string>(std::string const&)
mov [rsp+208h+var_1D0], rax
jmp short $+2
loc_C43F3:
mov rdi, [rsp+208h+var_1D0]
lea rsi, aCanBeFoundInTh; " can be found in this test suite.\n"
call _ZN7testing7MessagelsIA35_cEERS0_RKT_; testing::Message::operator<<<char [35]>(char [35] const&)
jmp short $+2
loc_C4406:
jmp short $+2
loc_C4408:
jmp short $+2
loc_C440A:
lea rdi, [rsp+208h+var_E0]
call _ZN9__gnu_cxx17__normal_iteratorIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt6vectorIS6_SaIS6_EEEppEv; __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(void)
jmp loc_C41FE
loc_C441C:
mov rdi, qword ptr [rsp+208h+var_190]
add rdi, 8
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationESt4lessIvESaISt4pairIKS5_S8_EEE5beginEv; std::map<std::string,testing::internal::CodeLocation>::begin(void)
mov [rsp+208h+var_118], rax
lea rdi, [rsp+208h+var_110]
lea rsi, [rsp+208h+var_118]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEEC2ERKSt17_Rb_tree_iteratorISB_E; std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::_Rb_tree_const_iterator(std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::CodeLocation>> const&)
loc_C4447:
mov rdi, qword ptr [rsp+208h+var_190]
add rdi, 8
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationESt4lessIvESaISt4pairIKS5_S8_EEE3endEv; std::map<std::string,testing::internal::CodeLocation>::end(void)
mov [rsp+208h+var_128], rax
lea rdi, [rsp+208h+var_120]
lea rsi, [rsp+208h+var_128]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEEC2ERKSt17_Rb_tree_iteratorISB_E; std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::_Rb_tree_const_iterator(std::_Rb_tree_iterator<std::pair<std::string const,testing::internal::CodeLocation>> const&)
lea rdi, [rsp+208h+var_110]
lea rsi, [rsp+208h+var_120]
call _ZSteqRKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEESE_; std::operator==(std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>> const&,std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>> const&)
xor al, 0FFh
test al, 1
jnz short loc_C4492
jmp loc_C4526
loc_C4492:
lea rdi, [rsp+208h+var_110]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEEptEv; std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator->(void)
mov rsi, rax
lea rdi, [rsp+208h+var_D8]
call _ZNKSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EE5countERKS5_; std::set<std::string>::count(std::string const&)
mov [rsp+208h+var_1D8], rax
jmp short $+2
loc_C44B6:
mov rax, [rsp+208h+var_1D8]
cmp rax, 0
jnz short loc_C4512
lea rsi, aYouForgotToLis; "You forgot to list test "
lea rdi, [rsp+208h+var_A8]
call _ZN7testing7MessagelsIA25_cEERS0_RKT_; testing::Message::operator<<<char [25]>(char [25] const&)
mov [rsp+208h+var_1E0], rax
jmp short $+2
loc_C44DC:
lea rdi, [rsp+208h+var_110]
call _ZNKSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEEptEv; std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator->(void)
mov rdi, [rsp+208h+var_1E0]
mov rsi, rax
call _ZN7testing7MessagelsINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEERS0_RKT_; testing::Message::operator<<<std::string>(std::string const&)
mov [rsp+208h+var_1E8], rax
jmp short $+2
loc_C44FD:
mov rdi, [rsp+208h+var_1E8]
lea rsi, aNoteRandomizin+32h; ".\n"
call _ZN7testing7MessagelsIA3_cEERS0_RKT_; testing::Message::operator<<<char [3]>(char [3] const&)
jmp short $+2
loc_C4510:
jmp short $+2
loc_C4512:
jmp short $+2
loc_C4514:
lea rdi, [rsp+208h+var_110]
call _ZNSt23_Rb_tree_const_iteratorISt4pairIKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN7testing8internal12CodeLocationEEEppEv; std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator++(void)
jmp loc_C4447
loc_C4526:
lea rdi, [rsp+208h+var_150]; int
lea rsi, [rsp+208h+var_A8]; int
call _ZNK7testing7Message9GetStringB5cxx11Ev; testing::Message::GetString(void)
jmp short $+2
loc_C453D:
lea rax, [rsp+208h+var_150]
mov [rsp+208h+var_130], rax
mov rdi, [rsp+208h+var_130]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5emptyEv; std::string::empty(void)
test al, 1
jnz loc_C4613
mov rax, cs:stderr_ptr
mov rax, [rax]
mov qword ptr [rsp+208h+var_1F0], rax; int
mov rsi, [rsp+208h+var_18]
mov edx, [rsp+208h+var_1C]
lea rdi, [rsp+208h+var_170]; __int64
call _ZN7testing8internal18FormatFileLocationB5cxx11EPKci; testing::internal::FormatFileLocation(char const*,int)
jmp short $+2
loc_C458F:
lea rdi, [rsp+208h+var_170]
mov [rsp+208h+var_1F8], rdi
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov [rsp+208h+var_200], rax
mov rdi, [rsp+208h+var_130]
call _ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE5c_strEv; std::string::c_str(void)
mov rdi, qword ptr [rsp+208h+var_1F0]
mov rdx, [rsp+208h+var_200]
mov rcx, rax
lea rsi, aSS; "%s %s"
xor eax, eax
call _fprintf
mov rdi, [rsp+208h+var_1F8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
mov rax, cs:stderr_ptr
mov rdi, [rax]; this
call _fflush
jmp short $+2
loc_C45E9:
call _ZN7testing8internal5posix5AbortEv; testing::internal::posix::Abort(void)
jmp short $+2
loc_C45F0:
mov rcx, rax
mov eax, edx
mov [rsp+208h+var_80], rcx
mov [rsp+208h+var_84], eax
lea rdi, [rsp+208h+var_150]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_C465F
loc_C4613:
mov rax, qword ptr [rsp+208h+var_28]
mov [rsp+208h+var_208], rax
lea rdi, [rsp+208h+var_150]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
lea rdi, [rsp+208h+var_D8]
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EED2Ev; std::set<std::string>::~set()
lea rdi, [rsp+208h+var_A8]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
lea rdi, [rsp+208h+var_A0]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
mov rax, [rsp+208h+var_208]
add rsp, 208h
retn
loc_C465F:
lea rdi, [rsp+208h+var_D8]
call _ZNSt3setINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESt4lessIS5_ESaIS5_EED2Ev; std::set<std::string>::~set()
lea rdi, [rsp+208h+var_A8]; this
call _ZN7testing7MessageD2Ev; testing::Message::~Message()
loc_C4679:
lea rdi, [rsp+208h+var_A0]; void *
call _ZNSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EED2Ev; std::vector<std::string>::~vector()
loc_C4686:
mov rdi, [rsp+208h+var_80]
call __Unwind_Resume
| long long testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(
testing::internal::TypedTestSuitePState *this,
const char *a2,
const char *a3,
int a4,
const char *a5)
{
int v5; // edx
int v6; // ecx
int v7; // r8d
int v8; // r9d
char v9; // dl
long long v10; // rax
long long v11; // rax
const char *v12; // rax
testing::internal::posix *v13; // rdi
void *v15; // [rsp+0h] [rbp-208h]
long long v16; // [rsp+0h] [rbp-208h]
int v17; // [rsp+8h] [rbp-200h]
const char *v18; // [rsp+8h] [rbp-200h]
int v19; // [rsp+10h] [rbp-1F8h]
char v20; // [rsp+18h] [rbp-1F0h]
int v21[2]; // [rsp+18h] [rbp-1F0h]
int v22; // [rsp+20h] [rbp-1E8h]
long long v23; // [rsp+20h] [rbp-1E8h]
int v24; // [rsp+28h] [rbp-1E0h]
long long v25; // [rsp+28h] [rbp-1E0h]
int v26; // [rsp+30h] [rbp-1D8h]
char v27; // [rsp+38h] [rbp-1D0h]
long long v28; // [rsp+38h] [rbp-1D0h]
int v29; // [rsp+40h] [rbp-1C8h]
long long v30; // [rsp+40h] [rbp-1C8h]
int v31; // [rsp+48h] [rbp-1C0h]
int v32; // [rsp+50h] [rbp-1B8h]
int v33; // [rsp+58h] [rbp-1B0h]
long long v34; // [rsp+60h] [rbp-1A8h]
long long v35; // [rsp+60h] [rbp-1A8h]
long long v36; // [rsp+68h] [rbp-1A0h]
long long v38[4]; // [rsp+98h] [rbp-170h] BYREF
int v39[8]; // [rsp+B8h] [rbp-150h] BYREF
int *v40; // [rsp+D8h] [rbp-130h]
long long v41; // [rsp+E0h] [rbp-128h] BYREF
_BYTE v42[8]; // [rsp+E8h] [rbp-120h] BYREF
long long v43; // [rsp+F0h] [rbp-118h] BYREF
_BYTE v44[8]; // [rsp+F8h] [rbp-110h] BYREF
long long v45; // [rsp+100h] [rbp-108h]
char v46; // [rsp+108h] [rbp-100h]
long long v47; // [rsp+110h] [rbp-F8h]
long long v48; // [rsp+118h] [rbp-F0h] BYREF
long long v49; // [rsp+120h] [rbp-E8h] BYREF
_BYTE v50[8]; // [rsp+128h] [rbp-E0h] BYREF
_BYTE v51[48]; // [rsp+130h] [rbp-D8h] BYREF
int v52; // [rsp+160h] [rbp-A8h] BYREF
int v53[7]; // [rsp+168h] [rbp-A0h] BYREF
int v54[8]; // [rsp+197h] [rbp-71h] BYREF
char v55[40]; // [rsp+1B8h] [rbp-50h] BYREF
int v56[3]; // [rsp+1E0h] [rbp-28h]
int v57; // [rsp+1ECh] [rbp-1Ch]
long long v58; // [rsp+1F0h] [rbp-18h]
int v59[2]; // [rsp+1F8h] [rbp-10h]
int v60[2]; // [rsp+200h] [rbp-8h]
*(_QWORD *)v60 = this;
*(_QWORD *)v59 = a2;
v58 = (long long)a3;
v57 = a4;
*(_QWORD *)v56 = a5;
std::allocator<char>::allocator();
std::string::basic_string<std::allocator<char>>((long long)v54 + 1, (long long)a3, (long long)v54);
testing::internal::CodeLocation::CodeLocation((long long)v55, (long long)v54 + 1, v57);
testing::internal::RegisterTypeParameterizedTestSuite(a2, v55);
testing::internal::CodeLocation::~CodeLocation((testing::internal::CodeLocation *)v55);
std::string::~string((char *)v54 + 1);
std::allocator<char>::~allocator(v54, v55);
*(_BYTE *)this = 1;
testing::internal::SplitIntoTestNames[abi:cxx11](
(int)v53,
v56[0],
v5,
v6,
v7,
v8,
v15,
v17,
v19,
v20,
v22,
v24,
v26,
v27,
v29,
v31,
v32,
v33,
v34);
testing::Message::Message((testing::Message *)&v52);
std::set<std::string>::set(v51);
v49 = std::vector<std::string>::begin(v53);
__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::__normal_iterator<std::string*>(v50, &v49);
while ( 1 )
{
v48 = std::vector<std::string>::end(v53);
if ( (ZN9__gnu_cxxeqIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPS6_St6vectorIS6_SaIS6_EEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISD_T1_EERKNSG_ISE_SH_EE(
v50,
&v48) & 1) != 0 )
break;
v47 = __gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator*(v50);
if ( std::set<std::string>::count(v51, v47) )
{
v36 = testing::Message::operator<<<char [6]>(&v52, "Test ");
v35 = testing::Message::operator<<<std::string>(v36, v47);
testing::Message::operator<<<char [28]>(v35, " is listed more than once.\n");
}
else if ( std::map<std::string,testing::internal::CodeLocation>::count((char *)this + 8, v47) )
{
v45 = std::set<std::string>::insert(v51, v47);
v46 = v9;
}
else
{
v30 = testing::Message::operator<<<char [15]>(&v52, "No test named ");
v28 = testing::Message::operator<<<std::string>(v30, v47);
testing::Message::operator<<<char [35]>(v28, " can be found in this test suite.\n");
}
__gnu_cxx::__normal_iterator<std::string const*,std::vector<std::string>>::operator++(v50);
}
v43 = std::map<std::string,testing::internal::CodeLocation>::begin((char *)this + 8);
std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::_Rb_tree_const_iterator(
v44,
&v43);
while ( 1 )
{
v41 = std::map<std::string,testing::internal::CodeLocation>::end((char *)this + 8);
std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::_Rb_tree_const_iterator(
v42,
&v41);
if ( (std::operator==(v44, v42) & 1) != 0 )
break;
v10 = std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator->(v44);
if ( !std::set<std::string>::count(v51, v10) )
{
v25 = testing::Message::operator<<<char [25]>(&v52, "You forgot to list test ");
v11 = std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator->(v44);
v23 = testing::Message::operator<<<std::string>(v25, v11);
testing::Message::operator<<<char [3]>(v23, (long long)".\n");
}
std::_Rb_tree_const_iterator<std::pair<std::string const,testing::internal::CodeLocation>>::operator++(v44);
}
testing::Message::GetString[abi:cxx11]((int)v39, (int)&v52);
v40 = v39;
if ( !std::string::empty((long long)v39) )
{
*(_QWORD *)v21 = stderr;
testing::internal::FormatFileLocation[abi:cxx11](v38, v58, v57);
v18 = (const char *)std::string::c_str((long long)v38);
v12 = (const char *)std::string::c_str((long long)v40);
fprintf(*(_QWORD *)v21, "%s %s", v18, v12);
std::string::~string(v38);
v13 = (testing::internal::posix *)stderr;
fflush(stderr);
testing::internal::posix::Abort(v13);
}
v16 = *(_QWORD *)v56;
std::string::~string(v39);
std::set<std::string>::~set(v51);
testing::Message::~Message((testing::Message *)&v52);
std::vector<std::string>::~vector(v53);
return v16;
}
| VerifyRegisteredTestNames:
SUB RSP,0x208
MOV qword ptr [RSP + 0x200],RDI
MOV qword ptr [RSP + 0x1f8],RSI
MOV qword ptr [RSP + 0x1f0],RDX
MOV dword ptr [RSP + 0x1ec],ECX
MOV qword ptr [RSP + 0x1e0],R8
MOV RAX,qword ptr [RSP + 0x200]
MOV qword ptr [RSP + 0x78],RAX
MOV RAX,qword ptr [RSP + 0x1f8]
MOV qword ptr [RSP + 0x80],RAX
MOV RAX,qword ptr [RSP + 0x1f0]
MOV qword ptr [RSP + 0x88],RAX
LEA RDI,[RSP + 0x197]
MOV qword ptr [RSP + 0x90],RDI
CALL 0x00116d00
MOV RSI,qword ptr [RSP + 0x88]
MOV RDX,qword ptr [RSP + 0x90]
LAB_001c4130:
LEA RDI,[RSP + 0x198]
CALL 0x0011dbb0
JMP 0x001c413f
LAB_001c413f:
MOV EDX,dword ptr [RSP + 0x1ec]
LAB_001c4146:
LEA RDI,[RSP + 0x1b8]
LEA RSI,[RSP + 0x198]
CALL 0x0011dc70
JMP 0x001c415d
LAB_001c415d:
MOV RDI,qword ptr [RSP + 0x80]
LEA RSI,[RSP + 0x1b8]
CALL 0x001c46a0
LAB_001c4172:
JMP 0x001c4174
LAB_001c4174:
LEA RDI,[RSP + 0x1b8]
CALL 0x0011dfc0
LEA RDI,[RSP + 0x198]
CALL 0x0011dfd0
LEA RDI,[RSP + 0x197]
CALL 0x00116790
MOV RAX,qword ptr [RSP + 0x78]
MOV byte ptr [RAX],0x1
MOV RSI,qword ptr [RSP + 0x1e0]
LEA RDI,[RSP + 0x168]
CALL 0x001c4730
LAB_001c41b8:
LEA RDI,[RSP + 0x160]
CALL 0x001c8d80
JMP 0x001c41c7
LAB_001c41c7:
LEA RDI,[RSP + 0x130]
CALL 0x001ed030
LEA RDI,[RSP + 0x168]
CALL 0x001ed040
MOV qword ptr [RSP + 0x120],RAX
LEA RDI,[RSP + 0x128]
LEA RSI,[RSP + 0x120]
CALL 0x001ed070
LAB_001c41fe:
LEA RDI,[RSP + 0x168]
CALL 0x001ed0f0
MOV qword ptr [RSP + 0x118],RAX
LEA RDI,[RSP + 0x128]
LEA RSI,[RSP + 0x118]
CALL 0x001ed0b0
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c4233
JMP 0x001c441c
LAB_001c4233:
LEA RDI,[RSP + 0x128]
CALL 0x001ed120
MOV qword ptr [RSP + 0x110],RAX
MOV RSI,qword ptr [RSP + 0x110]
LAB_001c4250:
LEA RDI,[RSP + 0x130]
CALL 0x001ed130
MOV qword ptr [RSP + 0x70],RAX
JMP 0x001c4264
LAB_001c4264:
MOV RAX,qword ptr [RSP + 0x70]
CMP RAX,0x0
JZ 0x001c435d
LEA RSI,[0x21cb44]
LEA RDI,[RSP + 0x160]
CALL 0x001ec4b0
MOV qword ptr [RSP + 0x68],RAX
JMP 0x001c428e
LAB_001c428e:
MOV RDI,qword ptr [RSP + 0x68]
MOV RSI,qword ptr [RSP + 0x110]
CALL 0x00132aa0
MOV qword ptr [RSP + 0x60],RAX
JMP 0x001c42a7
LAB_001c42a7:
MOV RDI,qword ptr [RSP + 0x60]
LEA RSI,[0x21cb4a]
CALL 0x001eb170
JMP 0x001c42ba
LAB_001c42ba:
JMP 0x001c440a
LAB_001c435d:
MOV RDI,qword ptr [RSP + 0x78]
ADD RDI,0x8
MOV RSI,qword ptr [RSP + 0x110]
CALL 0x001ed190
MOV qword ptr [RSP + 0x58],RAX
JMP 0x001c437a
LAB_001c437a:
MOV RAX,qword ptr [RSP + 0x58]
CMP RAX,0x0
JZ 0x001c43bf
MOV RSI,qword ptr [RSP + 0x110]
LEA RDI,[RSP + 0x130]
CALL 0x001ed1f0
MOV byte ptr [RSP + 0x4f],DL
MOV qword ptr [RSP + 0x50],RAX
JMP 0x001c43a5
LAB_001c43a5:
MOV AL,byte ptr [RSP + 0x4f]
MOV RCX,qword ptr [RSP + 0x50]
MOV qword ptr [RSP + 0x100],RCX
MOV byte ptr [RSP + 0x108],AL
JMP 0x001c4408
LAB_001c43bf:
LEA RSI,[0x21cb66]
LEA RDI,[RSP + 0x160]
CALL 0x001ed250
MOV qword ptr [RSP + 0x40],RAX
JMP 0x001c43da
LAB_001c43da:
MOV RDI,qword ptr [RSP + 0x40]
MOV RSI,qword ptr [RSP + 0x110]
CALL 0x00132aa0
MOV qword ptr [RSP + 0x38],RAX
JMP 0x001c43f3
LAB_001c43f3:
MOV RDI,qword ptr [RSP + 0x38]
LEA RSI,[0x21cb75]
CALL 0x001ed290
JMP 0x001c4406
LAB_001c4406:
JMP 0x001c4408
LAB_001c4408:
JMP 0x001c440a
LAB_001c440a:
LEA RDI,[RSP + 0x128]
CALL 0x001ed2d0
JMP 0x001c41fe
LAB_001c441c:
MOV RDI,qword ptr [RSP + 0x78]
ADD RDI,0x8
CALL 0x001ed2f0
MOV qword ptr [RSP + 0xf0],RAX
LEA RDI,[RSP + 0xf8]
LEA RSI,[RSP + 0xf0]
CALL 0x001ed320
LAB_001c4447:
MOV RDI,qword ptr [RSP + 0x78]
ADD RDI,0x8
CALL 0x001ed360
MOV qword ptr [RSP + 0xe0],RAX
LEA RDI,[RSP + 0xe8]
LEA RSI,[RSP + 0xe0]
CALL 0x001ed320
LEA RDI,[RSP + 0xf8]
LEA RSI,[RSP + 0xe8]
CALL 0x001ed340
XOR AL,0xff
TEST AL,0x1
JNZ 0x001c4492
JMP 0x001c4526
LAB_001c4492:
LEA RDI,[RSP + 0xf8]
CALL 0x001ed390
MOV RSI,RAX
LEA RDI,[RSP + 0x130]
CALL 0x001ed130
MOV qword ptr [RSP + 0x30],RAX
JMP 0x001c44b6
LAB_001c44b6:
MOV RAX,qword ptr [RSP + 0x30]
CMP RAX,0x0
JNZ 0x001c4512
LEA RSI,[0x21cb98]
LEA RDI,[RSP + 0x160]
CALL 0x001ed3b0
MOV qword ptr [RSP + 0x28],RAX
JMP 0x001c44dc
LAB_001c44dc:
LEA RDI,[RSP + 0xf8]
CALL 0x001ed390
MOV RDI,qword ptr [RSP + 0x28]
MOV RSI,RAX
CALL 0x00132aa0
MOV qword ptr [RSP + 0x20],RAX
JMP 0x001c44fd
LAB_001c44fd:
MOV RDI,qword ptr [RSP + 0x20]
LEA RSI,[0x21d7b9]
CALL 0x00132a60
JMP 0x001c4510
LAB_001c4510:
JMP 0x001c4512
LAB_001c4512:
JMP 0x001c4514
LAB_001c4514:
LEA RDI,[RSP + 0xf8]
CALL 0x001ed3f0
JMP 0x001c4447
LAB_001c4526:
LEA RDI,[RSP + 0xb8]
LEA RSI,[RSP + 0x160]
CALL 0x001bad90
JMP 0x001c453d
LAB_001c453d:
LEA RAX,[RSP + 0xb8]
MOV qword ptr [RSP + 0xd8],RAX
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x00141750
TEST AL,0x1
JNZ 0x001c4613
MOV RAX,qword ptr [0x00284f80]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RSP + 0x18],RAX
MOV RSI,qword ptr [RSP + 0x1f0]
MOV EDX,dword ptr [RSP + 0x1ec]
LAB_001c4580:
LEA RDI,[RSP + 0x98]
CALL 0x001c13f0
JMP 0x001c458f
LAB_001c458f:
LEA RDI,[RSP + 0x98]
MOV qword ptr [RSP + 0x10],RDI
CALL 0x0011f1e0
MOV qword ptr [RSP + 0x8],RAX
MOV RDI,qword ptr [RSP + 0xd8]
CALL 0x0011f1e0
MOV RDI,qword ptr [RSP + 0x18]
MOV RDX,qword ptr [RSP + 0x8]
MOV RCX,RAX
LEA RSI,[0x21cbb1]
XOR EAX,EAX
CALL 0x00116aa0
MOV RDI,qword ptr [RSP + 0x10]
CALL 0x0011dfd0
MOV RAX,qword ptr [0x00284f80]
MOV RDI,qword ptr [RAX]
CALL 0x00116850
JMP 0x001c45e9
LAB_001c45e9:
CALL 0x001ec570
LAB_001c45ee:
JMP 0x001c45f0
LAB_001c45f0:
MOV RCX,RAX
MOV EAX,EDX
MOV qword ptr [RSP + 0x188],RCX
MOV dword ptr [RSP + 0x184],EAX
LEA RDI,[RSP + 0xb8]
CALL 0x0011dfd0
JMP 0x001c465f
LAB_001c4613:
MOV RAX,qword ptr [RSP + 0x1e0]
MOV qword ptr [RSP],RAX
LEA RDI,[RSP + 0xb8]
CALL 0x0011dfd0
LEA RDI,[RSP + 0x130]
CALL 0x001ed420
LEA RDI,[RSP + 0x160]
CALL 0x0011e080
LEA RDI,[RSP + 0x168]
CALL 0x001eb700
MOV RAX,qword ptr [RSP]
ADD RSP,0x208
RET
LAB_001c465f:
LEA RDI,[RSP + 0x130]
CALL 0x001ed420
LEA RDI,[RSP + 0x160]
CALL 0x0011e080
LAB_001c4679:
LEA RDI,[RSP + 0x168]
CALL 0x001eb700
LAB_001c4686:
MOV RDI,qword ptr [RSP + 0x188]
CALL 0x00116cf0
|
/* testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames(char const*, char const*, int,
char const*) */
char * __thiscall
testing::internal::TypedTestSuitePState::VerifyRegisteredTestNames
(TypedTestSuitePState *this,char *param_1,char *param_2,int param_3,char *param_4)
{
FILE *__stream;
char *pcVar1;
byte bVar2;
string *psVar3;
long lVar4;
Message *pMVar5;
ulong uVar6;
int8 uVar7;
int8 uVar8;
int1 extraout_DL;
int1 auVar9 [12];
internal local_170 [32];
string local_150 [32];
string *local_130;
int8 local_128;
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>
local_120 [8];
int8 local_118;
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>
local_110 [8];
int8 local_108;
int1 local_100;
string *local_f8;
int8 local_f0;
int8 local_e8;
__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
local_e0 [8];
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
local_d8 [48];
Message local_a8 [8];
internal local_a0 [28];
int4 local_84;
int8 local_80;
allocator local_71;
string local_70 [32];
CodeLocation local_50 [40];
char *local_28;
int local_1c;
char *local_18;
char *local_10;
TypedTestSuitePState *local_8;
local_28 = param_4;
local_1c = param_3;
local_18 = param_2;
local_10 = param_1;
local_8 = this;
std::allocator<char>::allocator();
/* try { // try from 001c4130 to 001c413c has its CatchHandler @ 001c42bf */
std::__cxx11::string::string<std::allocator<char>>(local_70,param_2,&local_71);
/* try { // try from 001c4146 to 001c415a has its CatchHandler @ 001c42d5 */
CodeLocation::CodeLocation(local_50,local_70,local_1c);
/* try { // try from 001c415d to 001c4171 has its CatchHandler @ 001c42eb */
RegisterTypeParameterizedTestSuite(param_1,local_50);
CodeLocation::~CodeLocation(local_50);
std::__cxx11::string::~string(local_70);
std::allocator<char>::~allocator((allocator<char> *)&local_71);
*this = (TypedTestSuitePState)0x1;
SplitIntoTestNames_abi_cxx11_(local_a0,local_28);
/* try { // try from 001c41b8 to 001c41c4 has its CatchHandler @ 001c432b */
Message::Message(local_a8);
std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>::
set(local_d8);
local_e8 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::begin
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_a0);
__gnu_cxx::
__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::__normal_iterator<std::__cxx11::string*>(local_e0,(__normal_iterator *)&local_e8);
while( true ) {
local_f0 = std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::end
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)
local_a0);
bVar2 = _ZN9__gnu_cxxeqIPKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEPS6_St6vectorIS6_SaIS6_EEQrQT_T0__XeqfL0p_fL0p0_RSt14convertible_toIbEEEEbRKNS_17__normal_iteratorISD_T1_EERKNSG_ISE_SH_EE
(local_e0,&local_f0);
if (((bVar2 ^ 0xff) & 1) == 0) break;
local_f8 = (string *)
__gnu_cxx::
__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator*(local_e0);
/* try { // try from 001c4250 to 001c453a has its CatchHandler @ 001c4344 */
lVar4 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::count(local_d8,local_f8);
if (lVar4 == 0) {
lVar4 = std::
map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
::count((map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
*)(this + 8),local_f8);
if (lVar4 == 0) {
pMVar5 = Message::operator<<(local_a8,"No test named ");
pMVar5 = Message::operator<<(pMVar5,local_f8);
Message::operator<<(pMVar5," can be found in this test suite.\n");
}
else {
local_108 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::insert(local_d8,local_f8);
local_100 = extraout_DL;
}
}
else {
pMVar5 = Message::operator<<(local_a8,"Test ");
pMVar5 = Message::operator<<(pMVar5,local_f8);
Message::operator<<(pMVar5," is listed more than once.\n");
}
__gnu_cxx::
__normal_iterator<std::__cxx11::string_const*,std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>>
::operator++(local_e0);
}
local_118 = std::
map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
::begin((map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
*)(this + 8));
std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>::
_Rb_tree_const_iterator(local_110,(_Rb_tree_iterator *)&local_118);
while( true ) {
local_128 = std::
map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
::end((map<std::__cxx11::string,testing::internal::CodeLocation,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>>
*)(this + 8));
std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>::
_Rb_tree_const_iterator(local_120,(_Rb_tree_iterator *)&local_128);
bVar2 = std::operator==((_Rb_tree_const_iterator *)local_110,
(_Rb_tree_const_iterator *)local_120);
if (((bVar2 ^ 0xff) & 1) == 0) break;
psVar3 = (string *)
std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>
::operator->(local_110);
lVar4 = std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>
::count(local_d8,psVar3);
if (lVar4 == 0) {
pMVar5 = Message::operator<<(local_a8,"You forgot to list test ");
psVar3 = (string *)
std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>
::operator->(local_110);
pMVar5 = Message::operator<<(pMVar5,psVar3);
Message::operator<<(pMVar5,".\n");
}
std::
_Rb_tree_const_iterator<std::pair<std::__cxx11::string_const,testing::internal::CodeLocation>>::
operator++(local_110);
}
Message::GetString_abi_cxx11_();
local_130 = local_150;
uVar6 = std::__cxx11::string::empty(local_130);
pcVar1 = local_28;
if ((uVar6 & 1) != 0) {
std::__cxx11::string::~string(local_150);
std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>::
~set(local_d8);
Message::~Message(local_a8);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a0);
return pcVar1;
}
__stream = *(FILE **)PTR_stderr_00284f80;
/* try { // try from 001c4580 to 001c45ed has its CatchHandler @ 001c45f0 */
FormatFileLocation_abi_cxx11_(local_170,local_18,local_1c);
uVar7 = std::__cxx11::string::c_str((string *)local_170);
uVar8 = std::__cxx11::string::c_str(local_130);
fprintf(__stream,"%s %s",uVar7,uVar8);
std::__cxx11::string::~string((string *)local_170);
fflush(*(FILE **)PTR_stderr_00284f80);
auVar9 = posix::Abort();
local_84 = auVar9._8_4_;
local_80 = auVar9._0_8_;
/* catch() { ... } // from try @ 001c4580 with catch @ 001c45f0 */
std::__cxx11::string::~string(local_150);
std::
set<std::__cxx11::string,std::less<std::__cxx11::string>,std::allocator<std::__cxx11::string>>::
~set(local_d8);
Message::~Message(local_a8);
std::vector<std::__cxx11::string,std::allocator<std::__cxx11::string>>::~vector
((vector<std::__cxx11::string,std::allocator<std::__cxx11::string>> *)local_a0);
/* WARNING: Subroutine does not return */
_Unwind_Resume(local_80);
}
| |
43,477 | my_error_unregister | eloqsql/mysys/my_error.c | my_bool my_error_unregister(uint first, uint last)
{
struct my_err_head *meh_p;
struct my_err_head **search_meh_pp;
/* Search for the registration in the list. */
for (search_meh_pp= &my_errmsgs_list;
*search_meh_pp;
search_meh_pp= &(*search_meh_pp)->meh_next)
{
if (((*search_meh_pp)->meh_first == first) &&
((*search_meh_pp)->meh_last == last))
break;
}
if (! *search_meh_pp)
return TRUE;
/* Remove header from the chain. */
meh_p= *search_meh_pp;
*search_meh_pp= meh_p->meh_next;
my_free(meh_p);
return FALSE;
} | O0 | c | my_error_unregister:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x19e763(%rip), %rax # 0x1cc978
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2e252
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2e243
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2e243
jmp 0x2e252
jmp 0x2e245
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2e219
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2e262
movb $0x1, -0x1(%rbp)
jmp 0x2e288
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x25ed0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| my_error_unregister:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], edi
mov [rbp+var_C], esi
lea rax, my_errmsgs_list
mov [rbp+var_20], rax
loc_2E219:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jz short loc_2E252
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+10h]
cmp eax, [rbp+var_8]
jnz short loc_2E243
mov rax, [rbp+var_20]
mov rax, [rax]
mov eax, [rax+14h]
cmp eax, [rbp+var_C]
jnz short loc_2E243
jmp short loc_2E252
loc_2E243:
jmp short $+2
loc_2E245:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_20], rax
jmp short loc_2E219
loc_2E252:
mov rax, [rbp+var_20]
cmp qword ptr [rax], 0
jnz short loc_2E262
mov [rbp+var_1], 1
jmp short loc_2E288
loc_2E262:
mov rax, [rbp+var_20]
mov rax, [rax]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rcx, [rax]
mov rax, [rbp+var_20]
mov [rax], rcx
mov rdi, [rbp+var_18]
call my_free
mov [rbp+var_1], 0
loc_2E288:
mov al, [rbp+var_1]
add rsp, 20h
pop rbp
retn
| char my_error_unregister(int a1, int a2)
{
long long **i; // [rsp+0h] [rbp-20h]
long long v4; // [rsp+8h] [rbp-18h]
for ( i = &my_errmsgs_list; *i && (*((_DWORD *)*i + 4) != a1 || *((_DWORD *)*i + 5) != a2); i = (long long **)*i )
;
if ( !*i )
return 1;
v4 = (long long)*i;
*i = (long long *)**i;
my_free(v4);
return 0;
}
| my_error_unregister:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x8],EDI
MOV dword ptr [RBP + -0xc],ESI
LEA RAX,[0x2cc978]
MOV qword ptr [RBP + -0x20],RAX
LAB_0012e219:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JZ 0x0012e252
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x10]
CMP EAX,dword ptr [RBP + -0x8]
JNZ 0x0012e243
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x14]
CMP EAX,dword ptr [RBP + -0xc]
JNZ 0x0012e243
JMP 0x0012e252
LAB_0012e243:
JMP 0x0012e245
LAB_0012e245:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x20],RAX
JMP 0x0012e219
LAB_0012e252:
MOV RAX,qword ptr [RBP + -0x20]
CMP qword ptr [RAX],0x0
JNZ 0x0012e262
MOV byte ptr [RBP + -0x1],0x1
JMP 0x0012e288
LAB_0012e262:
MOV RAX,qword ptr [RBP + -0x20]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RAX]
MOV RAX,qword ptr [RBP + -0x20]
MOV qword ptr [RAX],RCX
MOV RDI,qword ptr [RBP + -0x18]
CALL 0x00125ed0
MOV byte ptr [RBP + -0x1],0x0
LAB_0012e288:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x20
POP RBP
RET
|
bool my_error_unregister(int param_1,int param_2)
{
long *plVar1;
int *puVar2;
int **local_28;
bool local_9;
for (local_28 = &my_errmsgs_list;
(*local_28 != (int *)0x0 &&
((*(int *)(*local_28 + 0x10) != param_1 || (*(int *)(*local_28 + 0x14) != param_2))));
local_28 = (int **)*local_28) {
}
puVar2 = *local_28;
if (puVar2 != (int *)0x0) {
plVar1 = (long *)*local_28;
*local_28 = (int *)*plVar1;
my_free(plVar1);
}
local_9 = puVar2 == (int *)0x0;
return local_9;
}
| |
43,478 | stbi__shiftsigned(unsigned int, int, int) | monkey531[P]llama/examples/llava/../../common/stb_image.h | static int stbi__shiftsigned(unsigned int v, int shift, int bits)
{
static unsigned int mul_table[9] = {
0,
0xff/*0b11111111*/, 0x55/*0b01010101*/, 0x49/*0b01001001*/, 0x11/*0b00010001*/,
0x21/*0b00100001*/, 0x41/*0b01000001*/, 0x81/*0b10000001*/, 0x01/*0b00000001*/,
};
static unsigned int shift_table[9] = {
0, 0,0,1,0,2,4,6,0,
};
if (shift < 0)
v <<= -shift;
else
v >>= shift;
STBI_ASSERT(v < 256);
v >>= (8-bits);
STBI_ASSERT(bits >= 0 && bits <= 8);
return (int) ((unsigned) v * mul_table[bits]) >> shift_table[bits];
} | O0 | c | stbi__shiftsigned(unsigned int, int, int):
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jge 0xa34f5
xorl %ecx, %ecx
subl -0x8(%rsp), %ecx
movl -0x4(%rsp), %eax
shll %cl, %eax
movl %eax, -0x4(%rsp)
jmp 0xa3503
movl -0x8(%rsp), %ecx
movl -0x4(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rsp)
movl $0x8, %ecx
subl -0xc(%rsp), %ecx
movl -0x4(%rsp), %eax
shrl %cl, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
movslq -0xc(%rsp), %rdx
leaq 0x6ed8a(%rip), %rcx # 0x1122b0
imull (%rcx,%rdx,4), %eax
movslq -0xc(%rsp), %rdx
leaq 0x6edaa(%rip), %rcx # 0x1122e0
movl (%rcx,%rdx,4), %ecx
sarl %cl, %eax
retq
nopl (%rax)
| _ZL17stbi__shiftsignedjii:
mov [rsp+var_4], edi
mov [rsp+var_8], esi
mov [rsp+var_C], edx
cmp [rsp+var_8], 0
jge short loc_A34F5
xor ecx, ecx
sub ecx, [rsp+var_8]
mov eax, [rsp+var_4]
shl eax, cl
mov [rsp+var_4], eax
jmp short loc_A3503
loc_A34F5:
mov ecx, [rsp+var_8]
mov eax, [rsp+var_4]
shr eax, cl
mov [rsp+var_4], eax
loc_A3503:
mov ecx, 8
sub ecx, [rsp+var_C]
mov eax, [rsp+var_4]
shr eax, cl
mov [rsp+var_4], eax
mov eax, [rsp+var_4]
movsxd rdx, [rsp+var_C]
lea rcx, _ZZL17stbi__shiftsignedjiiE9mul_table; stbi__shiftsigned(uint,int,int)::mul_table
imul eax, [rcx+rdx*4]
movsxd rdx, [rsp+var_C]
lea rcx, _ZZL17stbi__shiftsignedjiiE11shift_table; stbi__shiftsigned(uint,int,int)::shift_table
mov ecx, [rcx+rdx*4]
sar eax, cl
retn
| long long stbi__shiftsigned(unsigned int a1, int a2, int a3)
{
unsigned int v4; // [rsp+8h] [rbp-4h]
if ( a2 >= 0 )
v4 = a1 >> a2;
else
v4 = a1 << -(char)a2;
return (unsigned int)((int)(stbi__shiftsigned(unsigned int,int,int)::mul_table[a3] * (v4 >> (8 - a3))) >> stbi__shiftsigned(unsigned int,int,int)::shift_table[a3]);
}
| stbi__shiftsigned:
MOV dword ptr [RSP + -0x4],EDI
MOV dword ptr [RSP + -0x8],ESI
MOV dword ptr [RSP + -0xc],EDX
CMP dword ptr [RSP + -0x8],0x0
JGE 0x001a34f5
XOR ECX,ECX
SUB ECX,dword ptr [RSP + -0x8]
MOV EAX,dword ptr [RSP + -0x4]
SHL EAX,CL
MOV dword ptr [RSP + -0x4],EAX
JMP 0x001a3503
LAB_001a34f5:
MOV ECX,dword ptr [RSP + -0x8]
MOV EAX,dword ptr [RSP + -0x4]
SHR EAX,CL
MOV dword ptr [RSP + -0x4],EAX
LAB_001a3503:
MOV ECX,0x8
SUB ECX,dword ptr [RSP + -0xc]
MOV EAX,dword ptr [RSP + -0x4]
SHR EAX,CL
MOV dword ptr [RSP + -0x4],EAX
MOV EAX,dword ptr [RSP + -0x4]
MOVSXD RDX,dword ptr [RSP + -0xc]
LEA RCX,[0x2122b0]
IMUL EAX,dword ptr [RCX + RDX*0x4]
MOVSXD RDX,dword ptr [RSP + -0xc]
LEA RCX,[0x2122e0]
MOV ECX,dword ptr [RCX + RDX*0x4]
SAR EAX,CL
RET
|
/* stbi__shiftsigned(unsigned int, int, int) */
int stbi__shiftsigned(uint param_1,int param_2,int param_3)
{
uint local_4;
if (param_2 < 0) {
local_4 = param_1 << (-(byte)param_2 & 0x1f);
}
else {
local_4 = param_1 >> ((byte)param_2 & 0x1f);
}
return (int)((local_4 >> (8U - (char)param_3 & 0x1f)) *
*(int *)(stbi__shiftsigned(unsigned_int,int,int)::mul_table + (long)param_3 * 4)) >>
((byte)*(int4 *)
(stbi__shiftsigned(unsigned_int,int,int)::shift_table + (long)param_3 * 4) & 0x1f);
}
| |
43,479 | ma_update_at_original_place | eloqsql/storage/maria/ma_blockrec.c | static my_bool _ma_update_at_original_place(MARIA_HA *info,
pgcache_page_no_t page,
uint rownr,
uint length_on_head_page,
uint extent_count,
const uchar *extent_info,
const uchar *oldrec,
const uchar *record,
LSN undo_lsn)
{
MARIA_BITMAP_BLOCKS *blocks;
MARIA_BITMAP_BLOCK *block;
MARIA_ROW *cur_row= &info->cur_row, *new_row= &info->new_row;
MARIA_PINNED_PAGE page_link;
MARIA_SHARE *share= info->s;
ha_checksum old_checksum;
uint org_empty_size, empty_size;
uint block_size= info->s->block_size;
uchar *dir, *buff;
struct st_row_pos_info row_pos;
my_bool res;
uint rec_offset, length;
DBUG_ENTER("_ma_update_at_original_place");
#ifdef ENABLE_IF_PROBLEM_WITH_UPDATE
DBUG_DUMP("oldrec", oldrec, share->base.reclength);
DBUG_DUMP("newrec", record, share->base.reclength);
#endif
/*
Checksums of new and old rows were computed by callers already; new
row's was put into cur_row, old row's was put into new_row.
*/
old_checksum= new_row->checksum;
new_row->checksum= cur_row->checksum;
calc_record_size(info, record, new_row);
_ma_bitmap_flushable(info, 1);
buff= pagecache_read(share->pagecache,
&info->dfile, (pgcache_page_no_t) page, 0, 0,
share->page_type,
PAGECACHE_LOCK_WRITE, &page_link.link);
page_link.unlock= PAGECACHE_LOCK_WRITE_UNLOCK;
page_link.changed= buff != 0;
push_dynamic(&info->pinned_pages, (void*) &page_link);
if (!buff)
{
_ma_set_fatal_error(info, my_errno);
goto err;
}
org_empty_size= uint2korr(buff + EMPTY_SPACE_OFFSET);
dir= dir_entry_pos(buff, block_size, rownr);
if ((org_empty_size + cur_row->head_length) < length_on_head_page)
{
DBUG_PRINT("error",
("org_empty_size: %u head_length: %u length_on_page: %u",
org_empty_size, (uint) cur_row->head_length,
length_on_head_page));
_ma_set_fatal_error(info, HA_ERR_WRONG_IN_RECORD);
goto err;
}
/*
We can fit the new row in the same page as the original head part
of the row
*/
empty_size= org_empty_size;
if (extend_area_on_page(info, buff, dir, rownr,
length_on_head_page, &empty_size,
&rec_offset, &length, 1))
goto err;
row_pos.buff= buff;
row_pos.rownr= rownr;
row_pos.empty_space= empty_size;
row_pos.dir= dir;
row_pos.data= buff + rec_offset;
/* Delete old row */
if (*cur_row->tail_positions &&
delete_tails(info, cur_row->tail_positions))
goto err;
if (cur_row->extents_count && free_full_pages(info, cur_row))
goto err;
/* Change extent information to be usable by write_block_record() */
blocks= &cur_row->insert_blocks;
if (extent_to_bitmap_blocks(info, blocks, page, extent_count, extent_info))
goto err;
block= blocks->block;
block->empty_space= row_pos.empty_space;
block->org_bitmap_value=
_ma_free_size_to_head_pattern(&share->bitmap,
(enough_free_entries_on_page(share, buff) ?
org_empty_size : 0));
DBUG_ASSERT(block->org_bitmap_value ==
_ma_bitmap_get_page_bits(info, &info->s->bitmap, page));
block->used|= BLOCKUSED_USE_ORG_BITMAP;
/*
We have to use <= below as the new_row may be smaller than the original
row as the new row doesn't have transaction id
*/
DBUG_ASSERT(blocks->count > 1 ||
MY_MAX(new_row->total_length, share->base.min_block_length) <=
length_on_head_page);
/* Store same amount of data on head page as on original page */
row_pos.length= (length_on_head_page -
(extent_count + 1 - blocks->count) * ROW_EXTENT_SIZE);
set_if_bigger(row_pos.length, share->base.min_block_length);
if ((res= write_block_record(info, oldrec, record, new_row, blocks,
1, &row_pos, undo_lsn, old_checksum)))
goto err;
DBUG_RETURN(0);
err:
DBUG_ASSERT(!maria_assert_if_crashed_table);
_ma_mark_file_crashed(share);
if (info->non_flushable_state)
_ma_bitmap_flushable(info, -1);
_ma_unpin_all_pages_and_finalize_row(info, LSN_IMPOSSIBLE);
DBUG_RETURN(1);
} | O0 | c | ma_update_at_original_place:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq $0x140, %rax # imm = 0x140
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x7bc(%rax), %eax
movl %eax, -0x80(%rbp)
movq -0x50(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x74(%rbp)
movq -0x48(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq 0x18(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x750e0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x43840
movq -0x70(%rbp), %rax
movq 0x600(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x470, %rsi # imm = 0x470
movq -0x18(%rbp), %rdx
movq -0x70(%rbp), %rax
movl 0x7d4(%rax), %r9d
leaq -0x68(%rbp), %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x4, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2d970
movq %rax, -0x90(%rbp)
movl $0x6, -0x60(%rbp)
cmpq $0x0, -0x90(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movb %al, -0x58(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi # imm = 0x2E8
leaq -0x68(%rbp), %rsi
callq 0xda940
cmpq $0x0, -0x90(%rbp)
jne 0x7f82c
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
callq 0xf60c0
movq -0xd0(%rbp), %rdi
movl (%rax), %esi
callq 0x338b0
jmp 0x7fa9f
movq -0x90(%rbp), %rax
movzwl 0xa(%rax), %eax
movl %eax, -0x78(%rbp)
movq -0x90(%rbp), %rdi
movl -0x80(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x75000
movq %rax, -0x88(%rbp)
movl -0x78(%rbp), %eax
movq -0x48(%rbp), %rcx
addl 0xa0(%rcx), %eax
cmpl -0x20(%rbp), %eax
jae 0x7f87c
jmp 0x7f867
jmp 0x7f869
movq -0x10(%rbp), %rdi
movl $0x7f, %esi
callq 0x338b0
jmp 0x7fa9f
movl -0x78(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x20(%rbp), %r8d
leaq -0x7c(%rbp), %r9
leaq -0xc0(%rbp), %r10
leaq -0xc4(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movl $0x1, 0x10(%rsp)
callq 0x7a340
cmpb $0x0, %al
je 0x7f8cc
jmp 0x7fa9f
movq -0x90(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, -0x98(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x90(%rbp), %rax
movl -0xc0(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rax
cmpq $0x0, (%rax)
je 0x7f93d
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x76ae0
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7f93d
jmp 0x7fa9f
movq -0x48(%rbp), %rax
cmpl $0x0, 0xac(%rax)
je 0x7f964
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x76b70
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7f964
jmp 0x7fa9f
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %r8
callq 0x7c8c0
cmpb $0x0, %al
je 0x7f98d
jmp 0x7fa9f
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl -0x98(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x70(%rbp), %rax
addq $0xa10, %rax # imm = 0xA10
movq %rax, -0xd8(%rbp)
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x74670
movsbl %al, %eax
cmpl $0x0, %eax
je 0x7f9d9
movl -0x78(%rbp), %eax
movl %eax, -0xdc(%rbp)
jmp 0x7f9e3
xorl %eax, %eax
movl %eax, -0xdc(%rbp)
jmp 0x7f9e3
movq -0xd8(%rbp), %rdi
movl -0xdc(%rbp), %esi
callq 0x42500
movb %al, %cl
movq -0x40(%rbp), %rax
movb %cl, 0x15(%rax)
jmp 0x7fa00
movq -0x40(%rbp), %rax
movzbl 0x14(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x14(%rax)
jmp 0x7fa10
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movq -0x38(%rbp), %rdx
subl 0x8(%rdx), %ecx
imull $0x7, %ecx, %ecx
subl %ecx, %eax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movq -0x70(%rbp), %rcx
cmpq 0x3b8(%rcx), %rax
jae 0x7fa4f
movq -0x70(%rbp), %rax
movq 0x3b8(%rax), %rax
movl %eax, -0xa0(%rbp)
jmp 0x7fa51
movq -0x10(%rbp), %rdi
movq 0x10(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x20(%rbp), %r10
movl -0x74(%rbp), %eax
movl $0x1, %r9d
leaq -0xb8(%rbp), %r11
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x7cdd0
movb %al, -0xb9(%rbp)
cmpb $0x0, %al
je 0x7fa97
jmp 0x7fa9f
jmp 0x7fa99
movb $0x0, -0x1(%rbp)
jmp 0x7fad8
jmp 0x7faa1
jmp 0x7faa3
movq -0x70(%rbp), %rdi
callq 0x36250
movq -0x10(%rbp), %rax
cmpl $0x0, 0x644(%rax)
je 0x7fac7
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x43840
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x760f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
| _ma_update_at_original_place:
push rbp
mov rbp, rsp
sub rsp, 100h
mov rax, [rbp+arg_10]
mov rax, [rbp+arg_8]
mov rax, [rbp+arg_0]
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_1C], edx
mov [rbp+var_20], ecx
mov [rbp+var_24], r8d
mov [rbp+var_30], r9
mov rax, [rbp+var_10]
add rax, 80h
mov [rbp+var_48], rax
mov rax, [rbp+var_10]
add rax, 140h
mov [rbp+var_50], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov [rbp+var_70], rax
mov rax, [rbp+var_10]
mov rax, [rax]
mov eax, [rax+7BCh]
mov [rbp+var_80], eax
mov rax, [rbp+var_50]
mov eax, [rax+30h]
mov [rbp+var_74], eax
mov rax, [rbp+var_48]
mov ecx, [rax+30h]
mov rax, [rbp+var_50]
mov [rax+30h], ecx
mov rdi, [rbp+var_10]
mov rsi, [rbp+arg_8]
mov rdx, [rbp+var_50]
call calc_record_size
mov rdi, [rbp+var_10]
mov esi, 1
call _ma_bitmap_flushable
mov rax, [rbp+var_70]
mov rdi, [rax+600h]
mov rsi, [rbp+var_10]
add rsi, 470h
mov rdx, [rbp+var_18]
mov rax, [rbp+var_70]
mov r9d, [rax+7D4h]
lea rax, [rbp+var_68]
xor ecx, ecx
xor r8d, r8d
mov dword ptr [rsp+100h+var_100], 4
mov [rsp+100h+var_F8], rax
call pagecache_read
mov [rbp+var_90], rax
mov [rbp+var_60], 6
cmp [rbp+var_90], 0
setnz al
and al, 1
movzx eax, al
mov [rbp+var_58], al
mov rdi, [rbp+var_10]
add rdi, 2E8h
lea rsi, [rbp+var_68]
call insert_dynamic
cmp [rbp+var_90], 0
jnz short loc_7F82C
mov rax, [rbp+var_10]
mov [rbp+var_D0], rax
call _my_thread_var
mov rdi, [rbp+var_D0]
mov esi, [rax]
call _ma_set_fatal_error
jmp loc_7FA9F
loc_7F82C:
mov rax, [rbp+var_90]
movzx eax, word ptr [rax+0Ah]
mov [rbp+var_78], eax
mov rdi, [rbp+var_90]
mov esi, [rbp+var_80]
mov edx, [rbp+var_1C]
call dir_entry_pos
mov [rbp+var_88], rax
mov eax, [rbp+var_78]
mov rcx, [rbp+var_48]
add eax, [rcx+0A0h]
cmp eax, [rbp+var_20]
jnb short loc_7F87C
jmp short $+2
loc_7F867:
jmp short $+2
loc_7F869:
mov rdi, [rbp+var_10]
mov esi, 7Fh
call _ma_set_fatal_error
jmp loc_7FA9F
loc_7F87C:
mov eax, [rbp+var_78]
mov [rbp+var_7C], eax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_90]
mov rdx, [rbp+var_88]
mov ecx, [rbp+var_1C]
mov r8d, [rbp+var_20]
lea r9, [rbp+var_7C]
lea r10, [rbp+var_C0]
lea rax, [rbp+var_C4]
mov [rsp+100h+var_100], r10
mov [rsp+100h+var_F8], rax
mov [rsp+100h+var_F0], 1
call extend_area_on_page
cmp al, 0
jz short loc_7F8CC
jmp loc_7FA9F
loc_7F8CC:
mov rax, [rbp+var_90]
mov [rbp+var_B8], rax
mov eax, [rbp+var_1C]
mov [rbp+var_9C], eax
mov eax, [rbp+var_7C]
mov [rbp+var_98], eax
mov rax, [rbp+var_88]
mov [rbp+var_A8], rax
mov rax, [rbp+var_90]
mov ecx, [rbp+var_C0]
add rax, rcx
mov [rbp+var_B0], rax
mov rax, [rbp+var_48]
mov rax, [rax+28h]
cmp qword ptr [rax], 0
jz short loc_7F93D
mov rdi, [rbp+var_10]
mov rax, [rbp+var_48]
mov rsi, [rax+28h]
call delete_tails
movsx eax, al
cmp eax, 0
jz short loc_7F93D
jmp loc_7FA9F
loc_7F93D:
mov rax, [rbp+var_48]
cmp dword ptr [rax+0ACh], 0
jz short loc_7F964
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_48]
call free_full_pages
movsx eax, al
cmp eax, 0
jz short loc_7F964
jmp loc_7FA9F
loc_7F964:
mov rax, [rbp+var_48]
mov [rbp+var_38], rax
mov rdi, [rbp+var_10]
mov rsi, [rbp+var_38]
mov rdx, [rbp+var_18]
mov ecx, [rbp+var_24]
mov r8, [rbp+var_30]
call extent_to_bitmap_blocks
cmp al, 0
jz short loc_7F98D
jmp loc_7FA9F
loc_7F98D:
mov rax, [rbp+var_38]
mov rax, [rax]
mov [rbp+var_40], rax
mov ecx, [rbp+var_98]
mov rax, [rbp+var_40]
mov [rax+0Ch], ecx
mov rax, [rbp+var_70]
add rax, 0A10h
mov [rbp+var_D8], rax
mov rdi, [rbp+var_70]
mov rsi, [rbp+var_90]
call enough_free_entries_on_page
movsx eax, al
cmp eax, 0
jz short loc_7F9D9
mov eax, [rbp+var_78]
mov [rbp+var_DC], eax
jmp short loc_7F9E3
loc_7F9D9:
xor eax, eax
mov [rbp+var_DC], eax
jmp short $+2
loc_7F9E3:
mov rdi, [rbp+var_D8]
mov esi, [rbp+var_DC]
call _ma_free_size_to_head_pattern
mov cl, al
mov rax, [rbp+var_40]
mov [rax+15h], cl
jmp short $+2
loc_7FA00:
mov rax, [rbp+var_40]
movzx ecx, byte ptr [rax+14h]
or ecx, 2
mov [rax+14h], cl
jmp short $+2
loc_7FA10:
mov eax, [rbp+var_20]
mov ecx, [rbp+var_24]
add ecx, 1
mov rdx, [rbp+var_38]
sub ecx, [rdx+8]
imul ecx, 7
sub eax, ecx
mov [rbp+var_A0], eax
mov eax, [rbp+var_A0]
mov rcx, [rbp+var_70]
cmp rax, [rcx+3B8h]
jnb short loc_7FA4F
mov rax, [rbp+var_70]
mov rax, [rax+3B8h]
mov [rbp+var_A0], eax
loc_7FA4F:
jmp short $+2
loc_7FA51:
mov rdi, [rbp+var_10]
mov rsi, [rbp+arg_0]
mov rdx, [rbp+arg_8]
mov rcx, [rbp+var_50]
mov r8, [rbp+var_38]
mov r10, [rbp+arg_10]
mov eax, [rbp+var_74]
mov r9d, 1
lea r11, [rbp+var_B8]
mov [rsp+100h+var_100], r11
mov [rsp+100h+var_F8], r10
mov [rsp+100h+var_F0], eax
call write_block_record
mov [rbp+var_B9], al
cmp al, 0
jz short loc_7FA97
jmp short loc_7FA9F
loc_7FA97:
jmp short $+2
loc_7FA99:
mov [rbp+var_1], 0
jmp short loc_7FAD8
loc_7FA9F:
jmp short $+2
loc_7FAA1:
jmp short $+2
loc_7FAA3:
mov rdi, [rbp+var_70]
call _ma_mark_file_crashed
mov rax, [rbp+var_10]
cmp dword ptr [rax+644h], 0
jz short loc_7FAC7
mov rdi, [rbp+var_10]
mov esi, 0FFFFFFFFh
call _ma_bitmap_flushable
loc_7FAC7:
mov rdi, [rbp+var_10]
xor eax, eax
mov esi, eax
call _ma_unpin_all_pages_and_finalize_row_0
mov [rbp+var_1], 1
loc_7FAD8:
mov al, [rbp+var_1]
add rsp, 100h
pop rbp
retn
| char ma_update_at_original_place(
long long a1,
long long a2,
unsigned int a3,
unsigned int a4,
unsigned int a5,
long long a6,
long long a7,
long long a8,
long long *a9)
{
long long *v9; // rdi
int *v10; // rax
long long v11; // rdx
long long v12; // rcx
long long v13; // r8
int v14; // r9d
long long v15; // rdx
long long v16; // r8
int v17; // r9d
char v18; // al
_DWORD *v20; // [rsp+28h] [rbp-D8h]
long long *v21; // [rsp+30h] [rbp-D0h]
unsigned int v22; // [rsp+3Ch] [rbp-C4h] BYREF
int v23; // [rsp+40h] [rbp-C0h] BYREF
_QWORD v25[3]; // [rsp+48h] [rbp-B8h] BYREF
unsigned int v26; // [rsp+60h] [rbp-A0h]
unsigned int v27; // [rsp+64h] [rbp-9Ch]
unsigned int v28; // [rsp+68h] [rbp-98h]
_BYTE *v29; // [rsp+70h] [rbp-90h]
unsigned __int16 *v30; // [rsp+78h] [rbp-88h]
unsigned int v31; // [rsp+80h] [rbp-80h]
unsigned int v32; // [rsp+84h] [rbp-7Ch] BYREF
unsigned int v33; // [rsp+88h] [rbp-78h]
int v34; // [rsp+8Ch] [rbp-74h]
long long v35; // [rsp+90h] [rbp-70h]
char v36[8]; // [rsp+98h] [rbp-68h] BYREF
int v37; // [rsp+A0h] [rbp-60h]
bool v38; // [rsp+A8h] [rbp-58h]
unsigned long long v39; // [rsp+B0h] [rbp-50h]
long long v40; // [rsp+B8h] [rbp-48h]
long long v41; // [rsp+C0h] [rbp-40h]
long long *v42; // [rsp+C8h] [rbp-38h]
long long v43; // [rsp+D0h] [rbp-30h]
unsigned int v44; // [rsp+DCh] [rbp-24h]
unsigned int v45; // [rsp+E0h] [rbp-20h]
unsigned int v46; // [rsp+E4h] [rbp-1Ch]
long long v47; // [rsp+E8h] [rbp-18h]
long long *v48; // [rsp+F0h] [rbp-10h]
v48 = (long long *)a1;
v47 = a2;
v46 = a3;
v45 = a4;
v44 = a5;
v43 = a6;
v40 = a1 + 128;
v39 = a1 + 320;
v35 = *(_QWORD *)a1;
v31 = *(_DWORD *)(*(_QWORD *)a1 + 1980LL);
v34 = *(_DWORD *)(a1 + 368);
*(_DWORD *)(a1 + 368) = *(_DWORD *)(a1 + 176);
calc_record_size(v48, a8, v39);
ma_bitmap_flushable(v48, 1);
v29 = (_BYTE *)pagecache_read(
*(_QWORD **)(v35 + 1536),
(long long)(v48 + 142),
v47,
0,
0LL,
*(_DWORD *)(v35 + 2004),
4u,
v36);
v37 = 6;
v38 = v29 != 0LL;
v9 = v48 + 93;
insert_dynamic(v48 + 93, v36);
if ( v29 )
{
v33 = *((unsigned __int16 *)v29 + 5);
v30 = (unsigned __int16 *)dir_entry_pos((long long)v29, v31, v46);
if ( *(_DWORD *)(v40 + 160) + v33 >= v45 )
{
v32 = v33;
if ( !extend_area_on_page(v48, (long long)v29, v30, v46, v45, &v32, &v23, &v22, 1) )
{
v25[0] = v29;
v27 = v46;
v28 = v32;
v25[2] = v30;
v25[1] = &v29[v23];
if ( (!**(_QWORD **)(v40 + 40) || !delete_tails(v48, *(unsigned long long **)(v40 + 40)))
&& (!*(_DWORD *)(v40 + 172) || !free_full_pages(v48, v40)) )
{
v42 = (long long *)v40;
if ( !extent_to_bitmap_blocks(v48, v40, v47, v44, v43) )
{
v41 = *v42;
*(_DWORD *)(v41 + 12) = v28;
v20 = (_DWORD *)(v35 + 2576);
if ( enough_free_entries_on_page(v35, v29) )
v18 = ma_free_size_to_head_pattern(v20, v33);
else
v18 = ma_free_size_to_head_pattern(v20, 0);
*(_BYTE *)(v41 + 21) = v18;
*(_BYTE *)(v41 + 20) |= 2u;
v26 = v45 - 7 * (v44 + 1 - *((_DWORD *)v42 + 2));
if ( (unsigned long long)v26 < *(_QWORD *)(v35 + 952) )
v26 = *(_QWORD *)(v35 + 952);
if ( !write_block_record(v48, a7, a8, v39, v42, 1, (long long)v25, a9, v34) )
return 0;
}
}
}
}
else
{
ma_set_fatal_error(v48, 127, v15, v40, v16, v17);
}
}
else
{
v21 = v48;
v10 = (int *)my_thread_var(v9, v36);
ma_set_fatal_error(v21, *v10, v11, v12, v13, v14);
}
ma_mark_file_crashed(v35);
if ( *((_DWORD *)v48 + 401) )
ma_bitmap_flushable(v48, -1);
ma_unpin_all_pages_and_finalize_row_0((long long)v48, 0LL);
return 1;
}
| _ma_update_at_original_place:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x100
MOV RAX,qword ptr [RBP + 0x20]
MOV RAX,qword ptr [RBP + 0x18]
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [RBP + -0x10],RDI
MOV qword ptr [RBP + -0x18],RSI
MOV dword ptr [RBP + -0x1c],EDX
MOV dword ptr [RBP + -0x20],ECX
MOV dword ptr [RBP + -0x24],R8D
MOV qword ptr [RBP + -0x30],R9
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x80
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x10]
ADD RAX,0x140
MOV qword ptr [RBP + -0x50],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x70],RAX
MOV RAX,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RAX]
MOV EAX,dword ptr [RAX + 0x7bc]
MOV dword ptr [RBP + -0x80],EAX
MOV RAX,qword ptr [RBP + -0x50]
MOV EAX,dword ptr [RAX + 0x30]
MOV dword ptr [RBP + -0x74],EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV ECX,dword ptr [RAX + 0x30]
MOV RAX,qword ptr [RBP + -0x50]
MOV dword ptr [RAX + 0x30],ECX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + 0x18]
MOV RDX,qword ptr [RBP + -0x50]
CALL 0x001750e0
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x1
CALL 0x00143840
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,qword ptr [RAX + 0x600]
MOV RSI,qword ptr [RBP + -0x10]
ADD RSI,0x470
MOV RDX,qword ptr [RBP + -0x18]
MOV RAX,qword ptr [RBP + -0x70]
MOV R9D,dword ptr [RAX + 0x7d4]
LEA RAX,[RBP + -0x68]
XOR ECX,ECX
XOR R8D,R8D
MOV dword ptr [RSP],0x4
MOV qword ptr [RSP + 0x8],RAX
CALL 0x0012d970
MOV qword ptr [RBP + -0x90],RAX
MOV dword ptr [RBP + -0x60],0x6
CMP qword ptr [RBP + -0x90],0x0
SETNZ AL
AND AL,0x1
MOVZX EAX,AL
MOV byte ptr [RBP + -0x58],AL
MOV RDI,qword ptr [RBP + -0x10]
ADD RDI,0x2e8
LEA RSI,[RBP + -0x68]
CALL 0x001da940
CMP qword ptr [RBP + -0x90],0x0
JNZ 0x0017f82c
MOV RAX,qword ptr [RBP + -0x10]
MOV qword ptr [RBP + -0xd0],RAX
CALL 0x001f60c0
MOV RDI,qword ptr [RBP + -0xd0]
MOV ESI,dword ptr [RAX]
CALL 0x001338b0
JMP 0x0017fa9f
LAB_0017f82c:
MOV RAX,qword ptr [RBP + -0x90]
MOVZX EAX,word ptr [RAX + 0xa]
MOV dword ptr [RBP + -0x78],EAX
MOV RDI,qword ptr [RBP + -0x90]
MOV ESI,dword ptr [RBP + -0x80]
MOV EDX,dword ptr [RBP + -0x1c]
CALL 0x00175000
MOV qword ptr [RBP + -0x88],RAX
MOV EAX,dword ptr [RBP + -0x78]
MOV RCX,qword ptr [RBP + -0x48]
ADD EAX,dword ptr [RCX + 0xa0]
CMP EAX,dword ptr [RBP + -0x20]
JNC 0x0017f87c
JMP 0x0017f867
LAB_0017f867:
JMP 0x0017f869
LAB_0017f869:
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0x7f
CALL 0x001338b0
JMP 0x0017fa9f
LAB_0017f87c:
MOV EAX,dword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0x7c],EAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x90]
MOV RDX,qword ptr [RBP + -0x88]
MOV ECX,dword ptr [RBP + -0x1c]
MOV R8D,dword ptr [RBP + -0x20]
LEA R9,[RBP + -0x7c]
LEA R10,[RBP + -0xc0]
LEA RAX,[RBP + -0xc4]
MOV qword ptr [RSP],R10
MOV qword ptr [RSP + 0x8],RAX
MOV dword ptr [RSP + 0x10],0x1
CALL 0x0017a340
CMP AL,0x0
JZ 0x0017f8cc
JMP 0x0017fa9f
LAB_0017f8cc:
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [RBP + -0xb8],RAX
MOV EAX,dword ptr [RBP + -0x1c]
MOV dword ptr [RBP + -0x9c],EAX
MOV EAX,dword ptr [RBP + -0x7c]
MOV dword ptr [RBP + -0x98],EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0xa8],RAX
MOV RAX,qword ptr [RBP + -0x90]
MOV ECX,dword ptr [RBP + -0xc0]
ADD RAX,RCX
MOV qword ptr [RBP + -0xb0],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RAX,qword ptr [RAX + 0x28]
CMP qword ptr [RAX],0x0
JZ 0x0017f93d
MOV RDI,qword ptr [RBP + -0x10]
MOV RAX,qword ptr [RBP + -0x48]
MOV RSI,qword ptr [RAX + 0x28]
CALL 0x00176ae0
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0017f93d
JMP 0x0017fa9f
LAB_0017f93d:
MOV RAX,qword ptr [RBP + -0x48]
CMP dword ptr [RAX + 0xac],0x0
JZ 0x0017f964
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x48]
CALL 0x00176b70
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0017f964
JMP 0x0017fa9f
LAB_0017f964:
MOV RAX,qword ptr [RBP + -0x48]
MOV qword ptr [RBP + -0x38],RAX
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + -0x38]
MOV RDX,qword ptr [RBP + -0x18]
MOV ECX,dword ptr [RBP + -0x24]
MOV R8,qword ptr [RBP + -0x30]
CALL 0x0017c8c0
CMP AL,0x0
JZ 0x0017f98d
JMP 0x0017fa9f
LAB_0017f98d:
MOV RAX,qword ptr [RBP + -0x38]
MOV RAX,qword ptr [RAX]
MOV qword ptr [RBP + -0x40],RAX
MOV ECX,dword ptr [RBP + -0x98]
MOV RAX,qword ptr [RBP + -0x40]
MOV dword ptr [RAX + 0xc],ECX
MOV RAX,qword ptr [RBP + -0x70]
ADD RAX,0xa10
MOV qword ptr [RBP + -0xd8],RAX
MOV RDI,qword ptr [RBP + -0x70]
MOV RSI,qword ptr [RBP + -0x90]
CALL 0x00174670
MOVSX EAX,AL
CMP EAX,0x0
JZ 0x0017f9d9
MOV EAX,dword ptr [RBP + -0x78]
MOV dword ptr [RBP + -0xdc],EAX
JMP 0x0017f9e3
LAB_0017f9d9:
XOR EAX,EAX
MOV dword ptr [RBP + -0xdc],EAX
JMP 0x0017f9e3
LAB_0017f9e3:
MOV RDI,qword ptr [RBP + -0xd8]
MOV ESI,dword ptr [RBP + -0xdc]
CALL 0x00142500
MOV CL,AL
MOV RAX,qword ptr [RBP + -0x40]
MOV byte ptr [RAX + 0x15],CL
JMP 0x0017fa00
LAB_0017fa00:
MOV RAX,qword ptr [RBP + -0x40]
MOVZX ECX,byte ptr [RAX + 0x14]
OR ECX,0x2
MOV byte ptr [RAX + 0x14],CL
JMP 0x0017fa10
LAB_0017fa10:
MOV EAX,dword ptr [RBP + -0x20]
MOV ECX,dword ptr [RBP + -0x24]
ADD ECX,0x1
MOV RDX,qword ptr [RBP + -0x38]
SUB ECX,dword ptr [RDX + 0x8]
IMUL ECX,ECX,0x7
SUB EAX,ECX
MOV dword ptr [RBP + -0xa0],EAX
MOV EAX,dword ptr [RBP + -0xa0]
MOV RCX,qword ptr [RBP + -0x70]
CMP RAX,qword ptr [RCX + 0x3b8]
JNC 0x0017fa4f
MOV RAX,qword ptr [RBP + -0x70]
MOV RAX,qword ptr [RAX + 0x3b8]
MOV dword ptr [RBP + -0xa0],EAX
LAB_0017fa4f:
JMP 0x0017fa51
LAB_0017fa51:
MOV RDI,qword ptr [RBP + -0x10]
MOV RSI,qword ptr [RBP + 0x10]
MOV RDX,qword ptr [RBP + 0x18]
MOV RCX,qword ptr [RBP + -0x50]
MOV R8,qword ptr [RBP + -0x38]
MOV R10,qword ptr [RBP + 0x20]
MOV EAX,dword ptr [RBP + -0x74]
MOV R9D,0x1
LEA R11,[RBP + -0xb8]
MOV qword ptr [RSP],R11
MOV qword ptr [RSP + 0x8],R10
MOV dword ptr [RSP + 0x10],EAX
CALL 0x0017cdd0
MOV byte ptr [RBP + -0xb9],AL
CMP AL,0x0
JZ 0x0017fa97
JMP 0x0017fa9f
LAB_0017fa97:
JMP 0x0017fa99
LAB_0017fa99:
MOV byte ptr [RBP + -0x1],0x0
JMP 0x0017fad8
LAB_0017fa9f:
JMP 0x0017faa1
LAB_0017faa1:
JMP 0x0017faa3
LAB_0017faa3:
MOV RDI,qword ptr [RBP + -0x70]
CALL 0x00136250
MOV RAX,qword ptr [RBP + -0x10]
CMP dword ptr [RAX + 0x644],0x0
JZ 0x0017fac7
MOV RDI,qword ptr [RBP + -0x10]
MOV ESI,0xffffffff
CALL 0x00143840
LAB_0017fac7:
MOV RDI,qword ptr [RBP + -0x10]
XOR EAX,EAX
MOV ESI,EAX
CALL 0x001760f0
MOV byte ptr [RBP + -0x1],0x1
LAB_0017fad8:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x100
POP RBP
RET
|
int1
_ma_update_at_original_place
(long *param_1,int8 param_2,int4 param_3,uint param_4,int param_5,
int8 param_6,int8 param_7,int8 param_8,int8 param_9)
{
long *plVar1;
char cVar2;
int1 uVar3;
int4 *puVar4;
long lVar5;
int8 in_stack_fffffffffffffef8;
int4 uVar6;
uint local_e4;
int1 local_cc [4];
uint local_c8;
char local_c1;
long local_c0;
long local_b8;
int8 local_b0;
uint local_a8;
int4 local_a4;
uint local_a0;
long local_98;
int8 local_90;
int4 local_88;
uint local_84;
uint local_80;
int4 local_7c;
long local_78;
int1 local_70 [8];
int4 local_68;
int1 local_60;
long *local_58;
long *local_50;
long local_48;
long *local_40;
int8 local_38;
int local_2c;
uint local_28;
int4 local_24;
int8 local_20;
long *local_18;
uVar6 = (int4)((ulong)in_stack_fffffffffffffef8 >> 0x20);
local_50 = param_1 + 0x10;
local_58 = param_1 + 0x28;
local_78 = *param_1;
local_88 = *(int4 *)(*param_1 + 0x7bc);
local_7c = (int4)param_1[0x2e];
*(int *)(param_1 + 0x2e) = (int)param_1[0x16];
local_38 = param_6;
local_2c = param_5;
local_28 = param_4;
local_24 = param_3;
local_20 = param_2;
local_18 = param_1;
calc_record_size(param_1,param_8,local_58);
_ma_bitmap_flushable(local_18,1);
local_98 = pagecache_read(*(int8 *)(local_78 + 0x600),local_18 + 0x8e,local_20,0,0,
*(int4 *)(local_78 + 0x7d4),CONCAT44(uVar6,4),local_70);
local_68 = 6;
local_60 = local_98 != 0;
insert_dynamic(local_18 + 0x5d,local_70);
plVar1 = local_18;
if (local_98 == 0) {
puVar4 = (int4 *)_my_thread_var();
_ma_set_fatal_error(plVar1,*puVar4);
}
else {
local_80 = (uint)*(ushort *)(local_98 + 10);
local_90 = dir_entry_pos(local_98,local_88,local_24);
if (local_80 + (int)local_50[0x14] < local_28) {
_ma_set_fatal_error(local_18,0x7f);
}
else {
local_84 = local_80;
cVar2 = extend_area_on_page(local_18,local_98,local_90,local_24,local_28,&local_84,&local_c8,
local_cc,1);
if (cVar2 == '\0') {
local_c0 = local_98;
local_a4 = local_24;
local_a0 = local_84;
local_b0 = local_90;
local_b8 = local_98 + (ulong)local_c8;
if (((*(long *)local_50[5] == 0) ||
(cVar2 = delete_tails(local_18,local_50[5]), cVar2 == '\0')) &&
((*(int *)((long)local_50 + 0xac) == 0 ||
(cVar2 = free_full_pages(local_18,local_50), cVar2 == '\0')))) {
local_40 = local_50;
cVar2 = extent_to_bitmap_blocks(local_18,local_50,local_20,local_2c,local_38);
if (cVar2 == '\0') {
local_48 = *local_40;
*(uint *)(local_48 + 0xc) = local_a0;
lVar5 = local_78 + 0xa10;
cVar2 = enough_free_entries_on_page(local_78,local_98);
if (cVar2 == '\0') {
local_e4 = 0;
}
else {
local_e4 = local_80;
}
uVar3 = _ma_free_size_to_head_pattern(lVar5,local_e4);
*(int1 *)(local_48 + 0x15) = uVar3;
*(byte *)(local_48 + 0x14) = *(byte *)(local_48 + 0x14) | 2;
local_a8 = local_28 + ((local_2c + 1) - (int)local_40[1]) * -7;
if ((ulong)local_a8 < *(ulong *)(local_78 + 0x3b8)) {
local_a8 = (uint)*(int8 *)(local_78 + 0x3b8);
}
local_c1 = write_block_record(local_18,param_7,param_8,local_58,local_40,1,&local_c0,
param_9,local_7c);
if (local_c1 == '\0') {
return 0;
}
}
}
}
}
}
_ma_mark_file_crashed(local_78);
if (*(int *)((long)local_18 + 0x644) != 0) {
_ma_bitmap_flushable(local_18,0xffffffff);
}
_ma_unpin_all_pages_and_finalize_row(local_18,0);
return 1;
}
| |
43,480 | MyCTX_gcm::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int) | eloqsql/mysys_ssl/my_crypt.cc | int init(const EVP_CIPHER *cipher, int encrypt, const uchar *key, uint klen,
const uchar *iv, uint ivlen)
{
compile_time_assert(MY_AES_CTX_SIZE >= sizeof(MyCTX_gcm));
int res= MyCTX::init(cipher, encrypt, key, klen, iv, ivlen);
int real_ivlen= EVP_CIPHER_CTX_iv_length(ctx);
aad= iv + real_ivlen;
aadlen= ivlen - real_ivlen;
return res;
} | O3 | cpp | MyCTX_gcm::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char const*, unsigned int):
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %rdi, %rbx
movl 0x10(%rbp), %r12d
testq %rsi, %rsi
je 0x30513
movl %edx, %r9d
movq 0xc8(%rbx), %rdi
xorl %r13d, %r13d
xorl %edx, %edx
movq %r14, %r8
callq 0x2a7e0
cmpl $0x1, %eax
pushq $-0x65
popq %r15
cmovel %r13d, %r15d
movq 0xc8(%rbx), %rdi
callq 0x2a3e0
cltq
addq %rax, %r14
movq %r14, 0xd0(%rbx)
subl %eax, %r12d
movl %r12d, 0xd8(%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x66
popq %r15
jmp 0x304df
nop
| _ZN9MyCTX_gcm4initEPK13evp_cipher_stiPKhjS4_j:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
push rax
mov r14, r9
mov rbx, rdi
mov r12d, [rbp+arg_0]
test rsi, rsi
jz short loc_30513
mov r9d, edx
mov rdi, [rbx+0C8h]
xor r13d, r13d
xor edx, edx
mov r8, r14
call _EVP_CipherInit_ex
cmp eax, 1
push 0FFFFFFFFFFFFFF9Bh
pop r15
cmovz r15d, r13d
loc_304DF:
mov rdi, [rbx+0C8h]
call _EVP_CIPHER_CTX_get_iv_length
cdqe
add r14, rax
mov [rbx+0D0h], r14
sub r12d, eax
mov [rbx+0D8h], r12d
mov eax, r15d
add rsp, 8
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_30513:
push 0FFFFFFFFFFFFFF9Ah
pop r15
jmp short loc_304DF
| long long MyCTX_gcm::init(long long a1, long long a2, unsigned int a3, long long a4, long long a5, long long a6, int a7)
{
long long v7; // rax
unsigned int v9; // r15d
int iv_length; // eax
if ( a2 )
{
v9 = -101;
if ( (unsigned int)EVP_CipherInit_ex(*(_QWORD *)(a1 + 200), a2, 0LL, a4, a6, a3, v7) == 1 )
v9 = 0;
}
else
{
v9 = -102;
}
iv_length = EVP_CIPHER_CTX_get_iv_length(*(_QWORD *)(a1 + 200));
*(_QWORD *)(a1 + 208) = iv_length + a6;
*(_DWORD *)(a1 + 216) = a7 - iv_length;
return v9;
}
| init:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
PUSH RAX
MOV R14,R9
MOV RBX,RDI
MOV R12D,dword ptr [RBP + 0x10]
TEST RSI,RSI
JZ 0x00130513
MOV R9D,EDX
MOV RDI,qword ptr [RBX + 0xc8]
XOR R13D,R13D
XOR EDX,EDX
MOV R8,R14
CALL 0x0012a7e0
CMP EAX,0x1
PUSH -0x65
POP R15
CMOVZ R15D,R13D
LAB_001304df:
MOV RDI,qword ptr [RBX + 0xc8]
CALL 0x0012a3e0
CDQE
ADD R14,RAX
MOV qword ptr [RBX + 0xd0],R14
SUB R12D,EAX
MOV dword ptr [RBX + 0xd8],R12D
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_00130513:
PUSH -0x66
POP R15
JMP 0x001304df
|
/* MyCTX_gcm::init(evp_cipher_st const*, int, unsigned char const*, unsigned int, unsigned char
const*, unsigned int) */
int4 __thiscall
MyCTX_gcm::init(MyCTX_gcm *this,evp_cipher_st *param_1,int param_2,uchar *param_3,uint param_4,
uchar *param_5,uint param_6)
{
int iVar1;
int4 uVar2;
if (param_1 == (evp_cipher_st *)0x0) {
uVar2 = 0xffffff9a;
}
else {
iVar1 = EVP_CipherInit_ex(*(EVP_CIPHER_CTX **)(this + 200),param_1,(ENGINE *)0x0,param_3,param_5
,param_2);
uVar2 = 0xffffff9b;
if (iVar1 == 1) {
uVar2 = 0;
}
}
iVar1 = EVP_CIPHER_CTX_get_iv_length(*(int8 *)(this + 200));
*(uchar **)(this + 0xd0) = param_5 + iVar1;
*(uint *)(this + 0xd8) = param_6 - iVar1;
return uVar2;
}
| |
43,481 | mysql_close_options | eloqsql/libmariadb/libmariadb/mariadb_lib.c | static void mysql_close_options(MYSQL *mysql)
{
if (mysql->options.init_command)
{
char **begin= (char **)mysql->options.init_command->buffer;
char **end= begin + mysql->options.init_command->elements;
for (;begin < end; begin++)
free(*begin);
ma_delete_dynamic(mysql->options.init_command);
free(mysql->options.init_command);
}
free(mysql->options.user);
free(mysql->options.host);
free(mysql->options.password);
free(mysql->options.unix_socket);
free(mysql->options.db);
free(mysql->options.my_cnf_file);
free(mysql->options.my_cnf_group);
free(mysql->options.charset_dir);
free(mysql->options.charset_name);
free(mysql->options.bind_address);
free(mysql->options.ssl_key);
free(mysql->options.ssl_cert);
free(mysql->options.ssl_ca);
free(mysql->options.ssl_capath);
free(mysql->options.ssl_cipher);
if (mysql->options.extension)
{
struct mysql_async_context *ctxt;
if ((ctxt = mysql->options.extension->async_context))
{
my_context_destroy(&ctxt->async_context);
free(ctxt);
mysql->options.extension->async_context= 0;
}
free(mysql->options.extension->plugin_dir);
free(mysql->options.extension->default_auth);
free(mysql->options.extension->db_driver);
free(mysql->options.extension->ssl_crl);
free(mysql->options.extension->ssl_crlpath);
free(mysql->options.extension->tls_fp);
free(mysql->options.extension->tls_fp_list);
free(mysql->options.extension->tls_pw);
free(mysql->options.extension->tls_version);
free(mysql->options.extension->url);
free(mysql->options.extension->connection_handler);
free(mysql->options.extension->proxy_header);
if(ma_hashtbl_inited(&mysql->options.extension->connect_attrs))
ma_hashtbl_free(&mysql->options.extension->connect_attrs);
if (ma_hashtbl_inited(&mysql->options.extension->userdata))
ma_hashtbl_free(&mysql->options.extension->userdata);
free(mysql->options.extension->restricted_auth);
free(mysql->options.extension->rpl_host);
}
free(mysql->options.extension);
/* clear all pointer */
memset(&mysql->options, 0, sizeof(mysql->options));
} | O3 | c | mysql_close_options:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3d8(%rdi), %rdi
testq %rdi, %rdi
je 0x19a05
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x199f4
movq (%rdi), %r14
leaq (%r14,%rax,8), %r15
movq (%r14), %rdi
callq 0x13570
addq $0x8, %r14
cmpq %r15, %r14
jb 0x199dc
movq 0x3d8(%rbx), %rdi
callq 0x2f824
movq 0x3d8(%rbx), %rdi
callq 0x13570
movq 0x3b8(%rbx), %rdi
callq 0x13570
movq 0x3b0(%rbx), %rdi
callq 0x13570
movq 0x3c0(%rbx), %rdi
callq 0x13570
movq 0x3c8(%rbx), %rdi
callq 0x13570
movq 0x3d0(%rbx), %rdi
callq 0x13570
movq 0x3e0(%rbx), %rdi
callq 0x13570
movq 0x3e8(%rbx), %rdi
callq 0x13570
movq 0x3f0(%rbx), %rdi
callq 0x13570
movq 0x3f8(%rbx), %rdi
callq 0x13570
movq 0x448(%rbx), %rdi
callq 0x13570
movq 0x400(%rbx), %rdi
callq 0x13570
movq 0x408(%rbx), %rdi
callq 0x13570
movq 0x410(%rbx), %rdi
callq 0x13570
movq 0x418(%rbx), %rdi
callq 0x13570
movq 0x420(%rbx), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
testq %rax, %rax
je 0x19c2c
movq 0x28(%rax), %r14
testq %r14, %r14
je 0x19af9
leaq 0x38(%r14), %rdi
callq 0x2d809
movq %r14, %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq $0x0, 0x28(%rax)
movq 0x480(%rbx), %rax
movq (%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x88(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x10(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x90(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x98(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0xa0(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0xc0(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0xd0(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x130(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rdi
cmpq $0x0, 0x48(%rdi)
je 0x19be7
addq $0x30, %rdi
callq 0x30409
movq 0x480(%rbx), %rdi
cmpq $0x0, 0xf8(%rdi)
je 0x19c04
addq $0xe0, %rdi
callq 0x30409
movq 0x480(%rbx), %rdi
movq 0x150(%rdi), %rdi
callq 0x13570
movq 0x480(%rbx), %rax
movq 0x158(%rax), %rdi
callq 0x13570
movq 0x480(%rbx), %rdi
jmp 0x19c2e
xorl %edi, %edi
addq $0x390, %rbx # imm = 0x390
callq 0x13570
movl $0xf8, %edx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x13260
| mysql_close_options:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov rbx, rdi
mov rdi, [rdi+3D8h]
test rdi, rdi
jz short loc_19A05
mov eax, [rdi+8]
test rax, rax
jz short loc_199F4
mov r14, [rdi]
lea r15, [r14+rax*8]
loc_199DC:
mov rdi, [r14]
call _free
add r14, 8
cmp r14, r15
jb short loc_199DC
mov rdi, [rbx+3D8h]
loc_199F4:
call ma_delete_dynamic
mov rdi, [rbx+3D8h]
call _free
loc_19A05:
mov rdi, [rbx+3B8h]
call _free
mov rdi, [rbx+3B0h]
call _free
mov rdi, [rbx+3C0h]
call _free
mov rdi, [rbx+3C8h]
call _free
mov rdi, [rbx+3D0h]
call _free
mov rdi, [rbx+3E0h]
call _free
mov rdi, [rbx+3E8h]
call _free
mov rdi, [rbx+3F0h]
call _free
mov rdi, [rbx+3F8h]
call _free
mov rdi, [rbx+448h]
call _free
mov rdi, [rbx+400h]
call _free
mov rdi, [rbx+408h]
call _free
mov rdi, [rbx+410h]
call _free
mov rdi, [rbx+418h]
call _free
mov rdi, [rbx+420h]
call _free
mov rax, [rbx+480h]
test rax, rax
jz loc_19C2C
mov r14, [rax+28h]
test r14, r14
jz short loc_19AF9
lea rdi, [r14+38h]
call my_context_destroy
mov rdi, r14
call _free
mov rax, [rbx+480h]
mov qword ptr [rax+28h], 0
mov rax, [rbx+480h]
loc_19AF9:
mov rdi, [rax]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+8]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+88h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+10h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+18h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+90h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+98h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+0A0h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+0C0h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+0B0h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+0D0h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+130h]
call _free
mov rdi, [rbx+480h]
cmp qword ptr [rdi+48h], 0
jz short loc_19BE7
add rdi, 30h ; '0'
call ma_hashtbl_free
mov rdi, [rbx+480h]
loc_19BE7:
cmp qword ptr [rdi+0F8h], 0
jz short loc_19C04
add rdi, 0E0h
call ma_hashtbl_free
mov rdi, [rbx+480h]
loc_19C04:
mov rdi, [rdi+150h]
call _free
mov rax, [rbx+480h]
mov rdi, [rax+158h]
call _free
mov rdi, [rbx+480h]
jmp short loc_19C2E
loc_19C2C:
xor edi, edi
loc_19C2E:
add rbx, 390h
call _free
mov edx, 0F8h
mov rdi, rbx
xor esi, esi
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
jmp _memset
| long long mysql_close_options(_QWORD *a1)
{
long long v2; // rdi
_QWORD *v3; // r14
unsigned long long v4; // r15
_QWORD *v5; // rax
long long v6; // r14
_QWORD *v7; // rdi
long long v8; // rdi
v2 = a1[123];
if ( v2 )
{
if ( *(_DWORD *)(v2 + 8) )
{
v3 = *(_QWORD **)v2;
v4 = *(_QWORD *)v2 + 8LL * *(unsigned int *)(v2 + 8);
do
free(*v3++);
while ( (unsigned long long)v3 < v4 );
v2 = a1[123];
}
ma_delete_dynamic(v2);
free(a1[123]);
}
free(a1[119]);
free(a1[118]);
free(a1[120]);
free(a1[121]);
free(a1[122]);
free(a1[124]);
free(a1[125]);
free(a1[126]);
free(a1[127]);
free(a1[137]);
free(a1[128]);
free(a1[129]);
free(a1[130]);
free(a1[131]);
free(a1[132]);
v5 = (_QWORD *)a1[144];
if ( v5 )
{
v6 = v5[5];
if ( v6 )
{
my_context_destroy(v6 + 56);
free(v6);
*(_QWORD *)(a1[144] + 40LL) = 0LL;
v5 = (_QWORD *)a1[144];
}
free(*v5);
free(*(_QWORD *)(a1[144] + 8LL));
free(*(_QWORD *)(a1[144] + 136LL));
free(*(_QWORD *)(a1[144] + 16LL));
free(*(_QWORD *)(a1[144] + 24LL));
free(*(_QWORD *)(a1[144] + 144LL));
free(*(_QWORD *)(a1[144] + 152LL));
free(*(_QWORD *)(a1[144] + 160LL));
free(*(_QWORD *)(a1[144] + 192LL));
free(*(_QWORD *)(a1[144] + 176LL));
free(*(_QWORD *)(a1[144] + 208LL));
free(*(_QWORD *)(a1[144] + 304LL));
v7 = (_QWORD *)a1[144];
if ( v7[9] )
{
ma_hashtbl_free(v7 + 6);
v7 = (_QWORD *)a1[144];
}
if ( v7[31] )
{
ma_hashtbl_free(v7 + 28);
v7 = (_QWORD *)a1[144];
}
free(v7[42]);
free(*(_QWORD *)(a1[144] + 344LL));
v8 = a1[144];
}
else
{
v8 = 0LL;
}
free(v8);
return memset(a1 + 114, 0LL, 248LL);
}
| mysql_close_options:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x3d8]
TEST RDI,RDI
JZ 0x00119a05
MOV EAX,dword ptr [RDI + 0x8]
TEST RAX,RAX
JZ 0x001199f4
MOV R14,qword ptr [RDI]
LEA R15,[R14 + RAX*0x8]
LAB_001199dc:
MOV RDI,qword ptr [R14]
CALL 0x00113570
ADD R14,0x8
CMP R14,R15
JC 0x001199dc
MOV RDI,qword ptr [RBX + 0x3d8]
LAB_001199f4:
CALL 0x0012f824
MOV RDI,qword ptr [RBX + 0x3d8]
CALL 0x00113570
LAB_00119a05:
MOV RDI,qword ptr [RBX + 0x3b8]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3b0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3c0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3c8]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3d0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3e0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3e8]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3f0]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x3f8]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x448]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x400]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x408]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x410]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x418]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x420]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
TEST RAX,RAX
JZ 0x00119c2c
MOV R14,qword ptr [RAX + 0x28]
TEST R14,R14
JZ 0x00119af9
LEA RDI,[R14 + 0x38]
CALL 0x0012d809
MOV RDI,R14
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV qword ptr [RAX + 0x28],0x0
MOV RAX,qword ptr [RBX + 0x480]
LAB_00119af9:
MOV RDI,qword ptr [RAX]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x8]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x88]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x10]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x18]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x90]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x98]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0xa0]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0xc0]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0xb0]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0xd0]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x130]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x480]
CMP qword ptr [RDI + 0x48],0x0
JZ 0x00119be7
ADD RDI,0x30
CALL 0x00130409
MOV RDI,qword ptr [RBX + 0x480]
LAB_00119be7:
CMP qword ptr [RDI + 0xf8],0x0
JZ 0x00119c04
ADD RDI,0xe0
CALL 0x00130409
MOV RDI,qword ptr [RBX + 0x480]
LAB_00119c04:
MOV RDI,qword ptr [RDI + 0x150]
CALL 0x00113570
MOV RAX,qword ptr [RBX + 0x480]
MOV RDI,qword ptr [RAX + 0x158]
CALL 0x00113570
MOV RDI,qword ptr [RBX + 0x480]
JMP 0x00119c2e
LAB_00119c2c:
XOR EDI,EDI
LAB_00119c2e:
ADD RBX,0x390
CALL 0x00113570
MOV EDX,0xf8
MOV RDI,RBX
XOR ESI,ESI
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
JMP 0x00113260
|
void mysql_close_options(long param_1)
{
int8 *puVar1;
long *plVar2;
long lVar3;
void *pvVar4;
int8 *puVar5;
plVar2 = *(long **)(param_1 + 0x3d8);
if (plVar2 != (long *)0x0) {
if ((ulong)*(uint *)(plVar2 + 1) != 0) {
puVar5 = (int8 *)*plVar2;
puVar1 = puVar5 + *(uint *)(plVar2 + 1);
do {
free((void *)*puVar5);
puVar5 = puVar5 + 1;
} while (puVar5 < puVar1);
plVar2 = *(long **)(param_1 + 0x3d8);
}
ma_delete_dynamic(plVar2);
free(*(void **)(param_1 + 0x3d8));
}
free(*(void **)(param_1 + 0x3b8));
free(*(void **)(param_1 + 0x3b0));
free(*(void **)(param_1 + 0x3c0));
free(*(void **)(param_1 + 0x3c8));
free(*(void **)(param_1 + 0x3d0));
free(*(void **)(param_1 + 0x3e0));
free(*(void **)(param_1 + 1000));
free(*(void **)(param_1 + 0x3f0));
free(*(void **)(param_1 + 0x3f8));
free(*(void **)(param_1 + 0x448));
free(*(void **)(param_1 + 0x400));
free(*(void **)(param_1 + 0x408));
free(*(void **)(param_1 + 0x410));
free(*(void **)(param_1 + 0x418));
free(*(void **)(param_1 + 0x420));
puVar1 = *(int8 **)(param_1 + 0x480);
if (puVar1 == (int8 *)0x0) {
pvVar4 = (void *)0x0;
}
else {
pvVar4 = (void *)puVar1[5];
if (pvVar4 != (void *)0x0) {
my_context_destroy((long)pvVar4 + 0x38);
free(pvVar4);
*(int8 *)(*(long *)(param_1 + 0x480) + 0x28) = 0;
puVar1 = *(int8 **)(param_1 + 0x480);
}
free((void *)*puVar1);
free(*(void **)(*(long *)(param_1 + 0x480) + 8));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x88));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x10));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x18));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x90));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x98));
free(*(void **)(*(long *)(param_1 + 0x480) + 0xa0));
free(*(void **)(*(long *)(param_1 + 0x480) + 0xc0));
free(*(void **)(*(long *)(param_1 + 0x480) + 0xb0));
free(*(void **)(*(long *)(param_1 + 0x480) + 0xd0));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x130));
lVar3 = *(long *)(param_1 + 0x480);
if (*(long *)(lVar3 + 0x48) != 0) {
ma_hashtbl_free(lVar3 + 0x30);
lVar3 = *(long *)(param_1 + 0x480);
}
if (*(long *)(lVar3 + 0xf8) != 0) {
ma_hashtbl_free(lVar3 + 0xe0);
lVar3 = *(long *)(param_1 + 0x480);
}
free(*(void **)(lVar3 + 0x150));
free(*(void **)(*(long *)(param_1 + 0x480) + 0x158));
pvVar4 = *(void **)(param_1 + 0x480);
}
free(pvVar4);
memset((void *)(param_1 + 0x390),0,0xf8);
return;
}
| |
43,482 | ma_init_block_record | eloqsql/storage/maria/ma_blockrec.c | my_bool _ma_init_block_record(MARIA_HA *info)
{
MARIA_ROW *row= &info->cur_row, *new_row= &info->new_row;
MARIA_SHARE *share= info->s;
myf flag= MY_WME | (share->temporary ? MY_THREAD_SPECIFIC : 0);
uint default_extents;
DBUG_ENTER("_ma_init_block_record");
if (!my_multi_malloc(PSI_INSTRUMENT_ME, flag,
&row->empty_bits, share->base.pack_bytes,
&row->field_lengths,
share->base.max_field_lengths + 2,
&row->blob_lengths, sizeof(ulong) * share->base.blobs,
&row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&row->tail_positions, (sizeof(MARIA_RECORD_POS) *
(share->base.blobs + 2)),
&new_row->empty_bits, share->base.pack_bytes,
&new_row->field_lengths,
share->base.max_field_lengths + 2,
&new_row->blob_lengths,
sizeof(ulong) * share->base.blobs,
&new_row->null_field_lengths, (sizeof(uint) *
(share->base.fields -
share->base.blobs +
EXTRA_LENGTH_FIELDS)),
&info->log_row_parts,
sizeof(*info->log_row_parts) *
(TRANSLOG_INTERNAL_PARTS + 3 +
share->base.fields + 3),
&info->update_field_data,
(share->base.fields * 4 +
share->base.max_field_lengths + 1 + 4),
NullS, 0))
DBUG_RETURN(1);
/* Skip over bytes used to store length of field length for logging */
row->field_lengths+= 2;
new_row->field_lengths+= 2;
/* Reserve some initial space to avoid mallocs during execution */
default_extents= (ELEMENTS_RESERVED_FOR_MAIN_PART + 1 +
(AVERAGE_BLOB_SIZE /
FULL_PAGE_SIZE(share) /
BLOB_SEGMENT_MIN_SIZE));
if (my_init_dynamic_array(PSI_INSTRUMENT_ME, &info->bitmap_blocks,
sizeof(MARIA_BITMAP_BLOCK),
default_extents, 64, flag))
goto err;
info->cur_row.extents_buffer_length= default_extents * ROW_EXTENT_SIZE;
if (!(info->cur_row.extents= my_malloc(PSI_INSTRUMENT_ME,
info->cur_row.extents_buffer_length,
flag)))
goto err;
info->row_base_length= share->base_length;
info->row_flag= share->base.default_row_flag;
/*
We need to reserve 'EXTRA_LENGTH_FIELDS' number of parts in
null_field_lengths to allow splitting of rows in 'find_where_to_split_row'
*/
row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
new_row->null_field_lengths+= EXTRA_LENGTH_FIELDS;
DBUG_RETURN(0);
err:
_ma_end_block_record(info);
DBUG_RETURN(1);
} | O3 | c | ma_init_block_record:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
xorl %r14d, %r14d
cmpb $0x0, 0x7d9(%rsi)
setne %r14b
shll $0x10, %r14d
orq $0x10, %r14
leaq 0xc8(%rdi), %rdx
movl 0x3f4(%rsi), %ecx
leaq 0xd0(%rdi), %r8
movl 0x3c8(%rsi), %r11d
movl 0x3d4(%rsi), %eax
leal 0x2(%rax), %r9d
addq $0xe0, %rdi
movq %rdi, -0x78(%rbp)
movq %rsi, -0x30(%rbp)
movl 0x3f0(%rsi), %r15d
leal 0x8(%r11), %r10d
leal (%rax,%r11,4), %eax
addl $0x5, %eax
movq %rax, -0x58(%rbp)
subl %r15d, %r11d
leal 0x2(%r15), %r12d
shlq $0x3, %r15
addl $0x3, %r11d
shlq $0x2, %r11
shlq $0x3, %r12
shlq $0x4, %r10
leaq 0xd8(%rbx), %rax
movq %rax, -0x70(%rbp)
leaq 0xa8(%rbx), %rax
movq %rax, -0x68(%rbp)
leaq 0x188(%rbx), %rax
movq %rax, -0x60(%rbp)
leaq 0x190(%rbx), %rax
movq %rax, -0x50(%rbp)
leaq 0x1a0(%rbx), %rax
movq %rax, -0x48(%rbp)
leaq 0x198(%rbx), %rax
movq %rax, -0x40(%rbp)
leaq 0x318(%rbx), %rax
movq %rax, -0x38(%rbp)
leaq 0x3c8(%rbx), %r13
xorl %edi, %edi
movq %r14, %rsi
xorl %eax, %eax
pushq $0x0
pushq $0x0
pushq -0x58(%rbp)
pushq %r13
pushq %r10
pushq -0x38(%rbp)
pushq %r11
pushq -0x40(%rbp)
pushq %r15
pushq -0x48(%rbp)
pushq %r9
pushq -0x50(%rbp)
pushq %rcx
pushq -0x60(%rbp)
pushq %r12
pushq -0x68(%rbp)
pushq %r11
pushq -0x70(%rbp)
pushq %r15
pushq -0x78(%rbp)
callq 0x9f570
addq $0xa0, %rsp
movb $0x1, %r15b
testq %rax, %rax
je 0x46c12
addq $0x2, 0xd0(%rbx)
addq $0x2, 0x190(%rbx)
movq -0x30(%rbp), %r13
movl 0x7bc(%r13), %ecx
subl 0xc18(%r13), %ecx
addl $-0xc, %ecx
movl $0x100000, %eax # imm = 0x100000
xorl %edx, %edx
divl %ecx
movl %eax, %r12d
shrl $0x7, %r12d
addl $0x5, %r12d
leaq 0x2c0(%rbx), %rsi
subq $0x8, %rsp
xorl %edi, %edi
movl $0x18, %edx
xorl %ecx, %ecx
movl %r12d, %r8d
movl $0x40, %r9d
pushq %r14
callq 0x9480c
addq $0x10, %rsp
testb %al, %al
je 0x46bbc
movq %rbx, %rdi
callq 0x46c24
jmp 0x46c12
leal (,%r12,8), %esi
subl %r12d, %esi
movq %rsi, 0x118(%rbx)
xorl %edi, %edi
movq %r14, %rdx
callq 0xa2a95
movq %rax, 0x90(%rbx)
testq %rax, %rax
je 0x46bb2
movl 0x7c4(%r13), %eax
movq %rax, 0x610(%rbx)
movl 0x418(%r13), %eax
movl %eax, 0x618(%rbx)
addq $0xc, 0xd8(%rbx)
addq $0xc, 0x198(%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| _ma_init_block_record:
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 58h
mov rbx, rdi
mov rsi, [rdi]
xor r14d, r14d
cmp byte ptr [rsi+7D9h], 0
setnz r14b
shl r14d, 10h
or r14, 10h
lea rdx, [rdi+0C8h]
mov ecx, [rsi+3F4h]
lea r8, [rdi+0D0h]
mov r11d, [rsi+3C8h]
mov eax, [rsi+3D4h]
lea r9d, [rax+2]
add rdi, 0E0h
mov [rbp+var_78], rdi
mov [rbp+var_30], rsi
mov r15d, [rsi+3F0h]
lea r10d, [r11+8]
lea eax, [rax+r11*4]
add eax, 5
mov [rbp+var_58], rax
sub r11d, r15d
lea r12d, [r15+2]
shl r15, 3
add r11d, 3
shl r11, 2
shl r12, 3
shl r10, 4
lea rax, [rbx+0D8h]
mov [rbp+var_70], rax
lea rax, [rbx+0A8h]
mov [rbp+var_68], rax
lea rax, [rbx+188h]
mov [rbp+var_60], rax
lea rax, [rbx+190h]
mov [rbp+var_50], rax
lea rax, [rbx+1A0h]
mov [rbp+var_48], rax
lea rax, [rbx+198h]
mov [rbp+var_40], rax
lea rax, [rbx+318h]
mov [rbp+var_38], rax
lea r13, [rbx+3C8h]
xor edi, edi
mov rsi, r14
xor eax, eax
push 0
push 0
push [rbp+var_58]
push r13
push r10
push [rbp+var_38]
push r11
push [rbp+var_40]
push r15
push [rbp+var_48]
push r9
push [rbp+var_50]
push rcx
push [rbp+var_60]
push r12
push [rbp+var_68]
push r11
push [rbp+var_70]
push r15
push [rbp+var_78]
call my_multi_malloc
add rsp, 0A0h
mov r15b, 1
test rax, rax
jz loc_46C12
add qword ptr [rbx+0D0h], 2
add qword ptr [rbx+190h], 2
mov r13, [rbp+var_30]
mov ecx, [r13+7BCh]
sub ecx, [r13+0C18h]
add ecx, 0FFFFFFF4h
mov eax, offset xmmword_100000
xor edx, edx
div ecx
mov r12d, eax
shr r12d, 7
add r12d, 5
lea rsi, [rbx+2C0h]
sub rsp, 8
xor edi, edi
mov edx, 18h
xor ecx, ecx
mov r8d, r12d
mov r9d, 40h ; '@'
push r14
call init_dynamic_array2
add rsp, 10h
test al, al
jz short loc_46BBC
loc_46BB2:
mov rdi, rbx
call _ma_end_block_record
jmp short loc_46C12
loc_46BBC:
lea esi, ds:0[r12*8]
sub esi, r12d
mov [rbx+118h], rsi
xor edi, edi
mov rdx, r14
call my_malloc
mov [rbx+90h], rax
test rax, rax
jz short loc_46BB2
mov eax, [r13+7C4h]
mov [rbx+610h], rax
mov eax, [r13+418h]
mov [rbx+618h], eax
add qword ptr [rbx+0D8h], 0Ch
add qword ptr [rbx+198h], 0Ch
xor r15d, r15d
loc_46C12:
mov eax, r15d
add rsp, 58h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
| long long ma_init_block_record(long long a1)
{
long long v1; // r14
int v2; // r11d
int v3; // eax
long long v4; // r15
long long v5; // r10
int v6; // r11d
long long v7; // r12
long long v8; // rax
long long v9; // r15
unsigned int v10; // r12d
long long v11; // rsi
long long v12; // rax
long long v14; // [rsp+28h] [rbp-58h]
_DWORD *v15; // [rsp+50h] [rbp-30h]
v1 = ((unsigned __int8)(*(_BYTE *)(*(_QWORD *)a1 + 2009LL) != 0) << 16) | 0x10LL;
v2 = *(_DWORD *)(*(_QWORD *)a1 + 968LL);
v3 = *(_DWORD *)(*(_QWORD *)a1 + 980LL);
v15 = *(_DWORD **)a1;
v4 = *(unsigned int *)(*(_QWORD *)a1 + 1008LL);
v5 = (unsigned int)(v2 + 8);
v14 = (unsigned int)(v3 + 4 * v2 + 5);
v6 = v2 - v4;
v7 = (unsigned int)(v4 + 2);
v9 = 8 * v4;
v8 = my_multi_malloc(
0,
v1,
(int)a1 + 200,
*(_DWORD *)(*(_QWORD *)a1 + 1012LL),
(int)a1 + 208,
v3 + 2,
a1 + 224,
v9,
a1 + 216,
4LL * (unsigned int)(v6 + 3),
a1 + 168,
8 * v7,
a1 + 392,
*(unsigned int *)(*(_QWORD *)a1 + 1012LL),
a1 + 400,
(unsigned int)(v3 + 2),
a1 + 416,
v9,
a1 + 408,
4LL * (unsigned int)(v6 + 3),
a1 + 792,
16 * v5,
a1 + 968,
v14,
0LL,
0LL);
LOBYTE(v9) = 1;
if ( v8 )
{
*(_QWORD *)(a1 + 208) += 2LL;
*(_QWORD *)(a1 + 400) += 2LL;
v10 = (((unsigned int)&xmmword_100000 / (v15[495] - v15[774] - 12)) >> 7) + 5;
if ( (unsigned __int8)init_dynamic_array2(0, (int)a1 + 704, 24, 0, v10, 64, v1)
|| (v11 = 7 * v10, *(_QWORD *)(a1 + 280) = v11,
v12 = my_malloc(0LL, v11, v1),
(*(_QWORD *)(a1 + 144) = v12) == 0LL) )
{
ma_end_block_record(a1);
}
else
{
*(_QWORD *)(a1 + 1552) = (unsigned int)v15[497];
*(_DWORD *)(a1 + 1560) = v15[262];
*(_QWORD *)(a1 + 216) += 12LL;
*(_QWORD *)(a1 + 408) += 12LL;
LODWORD(v9) = 0;
}
}
return (unsigned int)v9;
}
| _ma_init_block_record:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x58
MOV RBX,RDI
MOV RSI,qword ptr [RDI]
XOR R14D,R14D
CMP byte ptr [RSI + 0x7d9],0x0
SETNZ R14B
SHL R14D,0x10
OR R14,0x10
LEA RDX,[RDI + 0xc8]
MOV ECX,dword ptr [RSI + 0x3f4]
LEA R8,[RDI + 0xd0]
MOV R11D,dword ptr [RSI + 0x3c8]
MOV EAX,dword ptr [RSI + 0x3d4]
LEA R9D,[RAX + 0x2]
ADD RDI,0xe0
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV R15D,dword ptr [RSI + 0x3f0]
LEA R10D,[R11 + 0x8]
LEA EAX,[RAX + R11*0x4]
ADD EAX,0x5
MOV qword ptr [RBP + -0x58],RAX
SUB R11D,R15D
LEA R12D,[R15 + 0x2]
SHL R15,0x3
ADD R11D,0x3
SHL R11,0x2
SHL R12,0x3
SHL R10,0x4
LEA RAX,[RBX + 0xd8]
MOV qword ptr [RBP + -0x70],RAX
LEA RAX,[RBX + 0xa8]
MOV qword ptr [RBP + -0x68],RAX
LEA RAX,[RBX + 0x188]
MOV qword ptr [RBP + -0x60],RAX
LEA RAX,[RBX + 0x190]
MOV qword ptr [RBP + -0x50],RAX
LEA RAX,[RBX + 0x1a0]
MOV qword ptr [RBP + -0x48],RAX
LEA RAX,[RBX + 0x198]
MOV qword ptr [RBP + -0x40],RAX
LEA RAX,[RBX + 0x318]
MOV qword ptr [RBP + -0x38],RAX
LEA R13,[RBX + 0x3c8]
XOR EDI,EDI
MOV RSI,R14
XOR EAX,EAX
PUSH 0x0
PUSH 0x0
PUSH qword ptr [RBP + -0x58]
PUSH R13
PUSH R10
PUSH qword ptr [RBP + -0x38]
PUSH R11
PUSH qword ptr [RBP + -0x40]
PUSH R15
PUSH qword ptr [RBP + -0x48]
PUSH R9
PUSH qword ptr [RBP + -0x50]
PUSH RCX
PUSH qword ptr [RBP + -0x60]
PUSH R12
PUSH qword ptr [RBP + -0x68]
PUSH R11
PUSH qword ptr [RBP + -0x70]
PUSH R15
PUSH qword ptr [RBP + -0x78]
CALL 0x0019f570
ADD RSP,0xa0
MOV R15B,0x1
TEST RAX,RAX
JZ 0x00146c12
ADD qword ptr [RBX + 0xd0],0x2
ADD qword ptr [RBX + 0x190],0x2
MOV R13,qword ptr [RBP + -0x30]
MOV ECX,dword ptr [R13 + 0x7bc]
SUB ECX,dword ptr [R13 + 0xc18]
ADD ECX,-0xc
MOV EAX,0x100000
XOR EDX,EDX
DIV ECX
MOV R12D,EAX
SHR R12D,0x7
ADD R12D,0x5
LEA RSI,[RBX + 0x2c0]
SUB RSP,0x8
XOR EDI,EDI
MOV EDX,0x18
XOR ECX,ECX
MOV R8D,R12D
MOV R9D,0x40
PUSH R14
CALL 0x0019480c
ADD RSP,0x10
TEST AL,AL
JZ 0x00146bbc
LAB_00146bb2:
MOV RDI,RBX
CALL 0x00146c24
JMP 0x00146c12
LAB_00146bbc:
LEA ESI,[R12*0x8]
SUB ESI,R12D
MOV qword ptr [RBX + 0x118],RSI
XOR EDI,EDI
MOV RDX,R14
CALL 0x001a2a95
MOV qword ptr [RBX + 0x90],RAX
TEST RAX,RAX
JZ 0x00146bb2
MOV EAX,dword ptr [R13 + 0x7c4]
MOV qword ptr [RBX + 0x610],RAX
MOV EAX,dword ptr [R13 + 0x418]
MOV dword ptr [RBX + 0x618],EAX
ADD qword ptr [RBX + 0xd8],0xc
ADD qword ptr [RBX + 0x198],0xc
XOR R15D,R15D
LAB_00146c12:
MOV EAX,R15D
ADD RSP,0x58
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
|
ulong _ma_init_block_record(long *param_1)
{
int iVar1;
uint uVar2;
long lVar3;
char cVar4;
ulong uVar5;
long lVar6;
int iVar7;
ulong uVar8;
long lVar9;
ulong uVar10;
lVar3 = *param_1;
uVar8 = (ulong)(*(char *)(lVar3 + 0x7d9) != '\0') << 0x10 | 0x10;
iVar1 = *(int *)(lVar3 + 0x3c8);
iVar7 = *(int *)(lVar3 + 0x3d4) + 2;
uVar2 = *(uint *)(lVar3 + 0x3f0);
lVar9 = (ulong)uVar2 << 3;
lVar6 = (ulong)((iVar1 - uVar2) + 3) << 2;
lVar6 = my_multi_malloc(0,uVar8,param_1 + 0x19,*(int4 *)(lVar3 + 0x3f4),param_1 + 0x1a,iVar7
,param_1 + 0x1c,lVar9,param_1 + 0x1b,lVar6,param_1 + 0x15,
(ulong)(uVar2 + 2) << 3,param_1 + 0x31,*(int4 *)(lVar3 + 0x3f4),
param_1 + 0x32,iVar7,param_1 + 0x34,lVar9,param_1 + 0x33,lVar6,
param_1 + 99,(ulong)(iVar1 + 8) << 4,param_1 + 0x79,
*(int *)(lVar3 + 0x3d4) + iVar1 * 4 + 5,0,0);
uVar10 = CONCAT71((int7)((ulong)lVar9 >> 8),1);
if (lVar6 != 0) {
param_1[0x1a] = param_1[0x1a] + 2;
param_1[0x32] = param_1[0x32] + 2;
iVar7 = (int)(0x100000 / (ulong)((*(int *)(lVar3 + 0x7bc) - *(int *)(lVar3 + 0xc18)) - 0xc) >> 7
) + 5;
cVar4 = init_dynamic_array2(0,param_1 + 0x58,0x18,0,iVar7,0x40,uVar8);
if (cVar4 == '\0') {
uVar5 = (ulong)(uint)(iVar7 * 7);
param_1[0x23] = uVar5;
lVar6 = my_malloc(0,uVar5,uVar8);
param_1[0x12] = lVar6;
if (lVar6 != 0) {
param_1[0xc2] = (ulong)*(uint *)(lVar3 + 0x7c4);
*(int4 *)(param_1 + 0xc3) = *(int4 *)(lVar3 + 0x418);
param_1[0x1b] = param_1[0x1b] + 0xc;
param_1[0x33] = param_1[0x33] + 0xc;
uVar10 = 0;
goto LAB_00146c12;
}
}
_ma_end_block_record(param_1);
}
LAB_00146c12:
return uVar10 & 0xffffffff;
}
| |
43,483 | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t) | llama.cpp/common/json.hpp | basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
[](const detail::json_ref<basic_json>& element_ref)
{
// The cast is to ensure op[size_type] is called, bearing in mind size_type may not be int;
// (many string types can be constructed from 0 via its null-pointer guise, so we get a
// broken call to op[key_type], the wrong semantics and a 4804 warning on Windows)
return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[static_cast<size_type>(0)].is_string();
});
// adjust type if type deduction is not wanted
if (!type_deduction)
{
// if array is wanted, do not create an object though possible
if (manual_type == value_t::array)
{
is_an_object = false;
}
// if object is wanted but impossible, throw an exception
if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
{
JSON_THROW(type_error::create(301, "cannot create object from initializer list", nullptr));
}
}
if (is_an_object)
{
// the initializer list is a list of pairs -> create object
m_data.m_type = value_t::object;
m_data.m_value = value_t::object;
for (auto& element_ref : init)
{
auto element = element_ref.moved_or_copied();
m_data.m_value.object->emplace(
std::move(*((*element.m_data.m_value.array)[0].m_data.m_value.string)),
std::move((*element.m_data.m_value.array)[1]));
}
}
else
{
// the initializer list describes an array -> create array
m_data.m_type = value_t::array;
m_data.m_value.array = create<array_t>(init.begin(), init.end());
}
set_parents();
assert_invariant();
} | O3 | cpp | nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>>>, bool, nlohmann::json_abi_v3_11_3::detail::value_t):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax,8), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r12, %rsi
callq 0xf147e
cmpq %r12, %rax
sete %cl
testb %r13b, %r13b
jne 0xe620b
cmpq %r12, %rax
sete %al
cmpb $0x2, %bpl
setne %cl
cmpb $0x1, %bpl
setne %dl
orb %al, %dl
je 0xe62cb
andb %al, %cl
testb %cl, %cl
je 0xe6295
movb $0x1, (%rbx)
movl $0x30, %edi
callq 0x25270
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0xe62af
shlq $0x3, %r15
leaq (%r15,%r15,2), %r12
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xf1350
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rdx), %rsi
addq $0x10, %rdx
callq 0xf13a2
movq %r15, %rdi
xorl %esi, %esi
callq 0xe6386
movq %r15, %rdi
callq 0xeb19e
addq $0x18, %r14
addq $-0x18, %r12
jne 0xe6253
jmp 0xe62af
movb $0x2, (%rbx)
movq %rsp, %rdi
movq %r14, (%rdi)
leaq 0x20(%rsp), %rsi
movq %r12, (%rsi)
callq 0xf142a
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xe6386
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x25790
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8da6c(%rip), %rsi # 0x173d55
leaq 0x8da8f(%rip), %rdx # 0x173d7f
movq %rsp, %rdi
callq 0x52736
movb $0x1, %bpl
movq %rsp, %rdx
movq %r14, %rdi
movl $0x12d, %esi # imm = 0x12D
xorl %ecx, %ecx
callq 0x65294
xorl %ebp, %ebp
leaq 0xf3fca(%rip), %rsi # 0x1da2e0
leaq -0x620bb(%rip), %rdx # 0x84262
movq %r14, %rdi
callq 0x25c00
jmp 0xe632b
jmp 0xe632b
jmp 0xe632b
movq %rax, %r15
jmp 0xe6375
movq %rax, %r15
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xe6386
movq %r14, %rdi
callq 0xeb19e
jmp 0xe6375
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe6363
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x251b0
testb %bpl, %bpl
jne 0xe636d
jmp 0xe6375
movq %rax, %r15
movq %r14, %rdi
callq 0x26150
movq %rbx, %rdi
callq 0xeb19e
movq %r15, %rdi
callq 0x25ca0
nop
| _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2ESt16initializer_listINS0_6detail8json_refISD_EEEbNSF_7value_tE:
push rbp; __int64
push r15; int
push r14; void *
push r13; int
push r12; __int64
push rbx; int
sub rsp, 28h
mov ebp, r8d
mov r13d, ecx
mov r15, rdx
mov r14, rsi
mov rbx, rdi
lea rax, [rdx+rdx*2]
lea r12, [rsi+rax*8]
xorps xmm0, xmm0
movups xmmword ptr [rdi], xmm0
mov rdi, rsi
mov rsi, r12
call _ZSt9__find_ifIPKN8nlohmann16json_abi_v3_11_36detail8json_refINS1_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEEN9__gnu_cxx5__ops12_Iter_negateIZNSG_C1ESt16initializer_listISH_EbNS2_7value_tEEUlRSI_E_EEET_ST_ST_T0_St26random_access_iterator_tag; std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const&)#1}>,std::random_access_iterator_tag)
cmp rax, r12
setz cl
test r13b, r13b
jnz short loc_E620B
cmp rax, r12
setz al
cmp bpl, 2
setnz cl
cmp bpl, 1
setnz dl
or dl, al
jz loc_E62CB
and cl, al
loc_E620B:
test cl, cl
jz loc_E6295
mov byte ptr [rbx], 1
mov edi, 30h ; '0'; unsigned __int64
call __Znwm; operator new(ulong)
mov rcx, rax
add rcx, 8
xorps xmm0, xmm0
movups xmmword ptr [rax], xmm0
xor edx, edx
mov [rax+10h], rdx
mov [rax+18h], rcx
mov [rax+20h], rcx
mov [rax+28h], rdx
mov [rbx+8], rax
test r15, r15
jz short loc_E62AF
shl r15, 3
lea r12, [r15+r15*2]
mov r15, rsp
loc_E6253:
mov rdi, r15
mov rsi, r14
call _ZNK8nlohmann16json_abi_v3_11_36detail8json_refINS0_10basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEE15moved_or_copiedEv; nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::moved_or_copied(void)
mov rdi, [rbx+8]
mov rax, [rsp+58h+var_50]
mov rdx, [rax]
mov rsi, [rdx+8]
add rdx, 10h
call _ZNSt3mapINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN8nlohmann16json_abi_v3_11_310basic_jsonIS_St6vectorS5_blmdSaNS7_14adl_serializerES9_IhSaIhEEvEESt4lessIvESaISt4pairIKS5_SD_EEE7emplaceIJS5_SD_EEESG_ISt17_Rb_tree_iteratorISI_EbEDpOT_; std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>::emplace<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> &&)
mov rdi, r15
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
add r14, 18h
add r12, 0FFFFFFFFFFFFFFE8h
jnz short loc_E6253
jmp short loc_E62AF
loc_E6295:
mov byte ptr [rbx], 2
mov rdi, rsp
mov [rdi], r14
lea rsi, [rsp+58h+var_38]
mov [rsi], r12
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6createIS3_ISD_SaISD_EEJPKNS0_6detail8json_refISD_EESL_EEEPT_DpOT0_; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*>(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>> const* &&)
mov [rbx+8], rax
loc_E62AF:
mov rdi, rbx
mov esi, 1
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
add rsp, 28h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_E62CB:
mov edi, 20h ; ' '; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea r12, [rsp+58h+var_48]
mov [r12-10h], r12
lea rsi, aCannotCreateOb; "cannot create object from initializer l"...
lea rdx, aCannotCreateOb+2Ah; ""
mov rdi, rsp
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEE12_M_constructIPKcEEvT_S8_St20forward_iterator_tag; std::string::_M_construct<char const*>(char const*,char const*,std::forward_iterator_tag)
mov bpl, 1
mov rdx, rsp
mov rdi, r14; this
mov esi, 12Dh; int
xor ecx, ecx
call _ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
xor ebp, ebp
lea rsi, _ZTIN8nlohmann16json_abi_v3_11_36detail10type_errorE; lptinfo
lea rdx, _ZN8nlohmann16json_abi_v3_11_36detail9exceptionD2Ev; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp short loc_E632B
jmp short loc_E632B
jmp short $+2
loc_E632B:
mov r15, rax
jmp short loc_E6375
mov r15, rax
mov r14, rsp
mov rdi, r14
xor esi, esi
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE16assert_invariantEb; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::assert_invariant(bool)
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
jmp short loc_E6375
mov r15, rax
mov rdi, [rsp+58h+var_58]; void *
cmp rdi, r12
jz short loc_E6363
mov rsi, [rsp+58h+var_48]
inc rsi; unsigned __int64
call __ZdlPvm; operator delete(void *,ulong)
loc_E6363:
test bpl, bpl
jnz short loc_E636D
jmp short loc_E6375
mov r15, rax
loc_E636D:
mov rdi, r14; void *
call ___cxa_free_exception
loc_E6375:
mov rdi, rbx
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonISt3mapSt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
mov rdi, r15
call __Unwind_Resume
| long long nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::basic_json(
long long a1,
char *a2,
long long a3,
char a4,
char a5)
{
char *v8; // r14
char *v9; // r12
long long v10; // rax
bool v11; // cl
bool v12; // al
long long v13; // rax
long long v14; // r12
nlohmann::json_abi_v3_11_3::detail::exception *exception; // r14
void *v17; // [rsp+0h] [rbp-58h] BYREF
long long v18; // [rsp+8h] [rbp-50h]
_QWORD v19[9]; // [rsp+10h] [rbp-48h] BYREF
v8 = a2;
v9 = &a2[24 * a3];
*(_OWORD *)a1 = 0LL;
v10 = std::__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::{lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const&)#1}>>(
a2,
v9);
v11 = v10 == (_QWORD)v9;
if ( !a4 )
{
v12 = v10 == (_QWORD)v9;
if ( !v12 && a5 == 1 )
{
exception = (nlohmann::json_abi_v3_11_3::detail::exception *)__cxa_allocate_exception(0x20uLL);
v17 = v19;
std::string::_M_construct<char const*>((long long)&v17, "cannot create object from initializer list", (long long)"");
ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_(
exception,
301,
&v17);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'nlohmann::json_abi_v3_11_3::detail::type_error,
(void (*)(void *))nlohmann::json_abi_v3_11_3::detail::exception::~exception);
}
v11 = v12 && a5 != 2;
}
if ( v11 )
{
*(_BYTE *)a1 = 1;
v13 = operator new(0x30uLL);
*(_OWORD *)v13 = 0LL;
*(_QWORD *)(v13 + 16) = 0LL;
*(_QWORD *)(v13 + 24) = v13 + 8;
*(_QWORD *)(v13 + 32) = v13 + 8;
*(_QWORD *)(v13 + 40) = 0LL;
*(_QWORD *)(a1 + 8) = v13;
if ( a3 )
{
v14 = 24 * a3;
do
{
nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::moved_or_copied(
&v17,
v8);
std::map<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>::emplace<std::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
*(_QWORD *)(a1 + 8),
*(_QWORD *)(*(_QWORD *)v18 + 8LL),
*(_QWORD *)v18 + 16LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
&v17,
0LL);
nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data(&v17);
v8 += 24;
v14 -= 24LL;
}
while ( v14 );
}
}
else
{
*(_BYTE *)a1 = 2;
v17 = a2;
v19[2] = v9;
*(_QWORD *)(a1 + 8) = nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>> const*>(&v17);
}
return nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::assert_invariant(
a1,
1LL);
}
| basic_json:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x28
MOV EBP,R8D
MOV R13D,ECX
MOV R15,RDX
MOV R14,RSI
MOV RBX,RDI
LEA RAX,[RDX + RDX*0x2]
LEA R12,[RSI + RAX*0x8]
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RDI],XMM0
LAB_001e61d7:
MOV RDI,RSI
MOV RSI,R12
CALL 0x001f147e
CMP RAX,R12
SETZ CL
TEST R13B,R13B
JNZ 0x001e620b
CMP RAX,R12
SETZ AL
CMP BPL,0x2
SETNZ CL
CMP BPL,0x1
SETNZ DL
OR DL,AL
JZ 0x001e62cb
AND CL,AL
LAB_001e620b:
TEST CL,CL
JZ 0x001e6295
MOV byte ptr [RBX],0x1
LAB_001e6216:
MOV EDI,0x30
CALL 0x00125270
MOV RCX,RAX
ADD RCX,0x8
XORPS XMM0,XMM0
MOVUPS xmmword ptr [RAX],XMM0
XOR EDX,EDX
MOV qword ptr [RAX + 0x10],RDX
MOV qword ptr [RAX + 0x18],RCX
MOV qword ptr [RAX + 0x20],RCX
MOV qword ptr [RAX + 0x28],RDX
MOV qword ptr [RBX + 0x8],RAX
TEST R15,R15
JZ 0x001e62af
SHL R15,0x3
LEA R12,[R15 + R15*0x2]
MOV R15,RSP
LAB_001e6253:
MOV RDI,R15
MOV RSI,R14
CALL 0x001f1350
MOV RDI,qword ptr [RBX + 0x8]
MOV RAX,qword ptr [RSP + 0x8]
MOV RDX,qword ptr [RAX]
MOV RSI,qword ptr [RDX + 0x8]
ADD RDX,0x10
LAB_001e6272:
CALL 0x001f13a2
MOV RDI,R15
XOR ESI,ESI
CALL 0x001e6386
MOV RDI,R15
CALL 0x001eb19e
ADD R14,0x18
ADD R12,-0x18
JNZ 0x001e6253
JMP 0x001e62af
LAB_001e6295:
MOV byte ptr [RBX],0x2
MOV RDI,RSP
MOV qword ptr [RDI],R14
LEA RSI,[RSP + 0x20]
MOV qword ptr [RSI],R12
LAB_001e62a6:
CALL 0x001f142a
LAB_001e62ab:
MOV qword ptr [RBX + 0x8],RAX
LAB_001e62af:
MOV RDI,RBX
MOV ESI,0x1
CALL 0x001e6386
ADD RSP,0x28
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_001e62cb:
MOV EDI,0x20
CALL 0x00125790
MOV R14,RAX
LEA R12,[RSP + 0x10]
MOV qword ptr [R12 + -0x10],R12
LAB_001e62e2:
LEA RSI,[0x273d55]
LEA RDX,[0x273d7f]
MOV RDI,RSP
CALL 0x00152736
MOV BPL,0x1
LAB_001e62fb:
MOV RDX,RSP
MOV RDI,R14
MOV ESI,0x12d
XOR ECX,ECX
CALL 0x00165294
XOR EBP,EBP
LEA RSI,[0x2da2e0]
LEA RDX,[0x184262]
MOV RDI,R14
CALL 0x00125c00
|
/* nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::string, bool, long,
unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer,
std::vector<unsigned char, std::allocator<unsigned char> >,
void>::basic_json(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,
std::vector, std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> > >, bool, nlohmann::json_abi_v3_11_3::detail::value_t) */
void nlohmann::json_abi_v3_11_3::
basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::basic_json(int8 *param_1,json_ref *param_2,long param_3,char param_4,char param_5)
{
json_ref *pjVar1;
json_ref *pjVar2;
int8 *puVar3;
vector *pvVar4;
int8 uVar5;
bool bVar6;
json_ref *local_58;
long *local_50;
json_ref local_48 [16];
json_ref *local_38;
pjVar1 = param_2 + param_3 * 0x18;
*param_1 = 0;
param_1[1] = 0;
/* try { // try from 001e61d7 to 001e61e1 has its CatchHandler @ 001e6329 */
pjVar2 = std::
__find_if<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,__gnu_cxx::__ops::_Iter_negate<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>::_Iter_negate(std::initializer_list<nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,bool,nlohmann::json_abi_v3_11_3::detail::value_t)::_lambda(nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const&)_1_>>
(param_2,pjVar1);
bVar6 = pjVar2 == pjVar1;
if (param_4 == '\0') {
if (param_5 == '\x01' && pjVar2 != pjVar1) {
uVar5 = __cxa_allocate_exception(0x20);
local_58 = local_48;
/* try { // try from 001e62e2 to 001e62f7 has its CatchHandler @ 001e636a */
std::__cxx11::string::_M_construct<char_const*>
(&local_58,"cannot create object from initializer list","");
/* try { // try from 001e62fb to 001e6324 has its CatchHandler @ 001e634a */
_ZN8nlohmann16json_abi_v3_11_36detail10type_error6createIDnTnNSt9enable_ifIXsr21is_basic_json_contextIT_EE5valueEiE4typeELi0EEES2_iRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEES5_
(uVar5,0x12d,&local_58,0);
/* WARNING: Subroutine does not return */
__cxa_throw(uVar5,&detail::type_error::typeinfo,detail::exception::~exception);
}
bVar6 = param_5 != '\x02' && pjVar2 == pjVar1;
}
if (bVar6) {
*(int1 *)param_1 = 1;
/* try { // try from 001e6216 to 001e621f has its CatchHandler @ 001e6327 */
puVar3 = (int8 *)operator_new(0x30);
*puVar3 = 0;
puVar3[1] = 0;
puVar3[2] = 0;
puVar3[3] = puVar3 + 1;
puVar3[4] = puVar3 + 1;
puVar3[5] = 0;
param_1[1] = puVar3;
if (param_3 != 0) {
param_3 = param_3 * 0x18;
do {
/* try { // try from 001e6253 to 001e625d has its CatchHandler @ 001e632b */
detail::
json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
::moved_or_copied();
/* try { // try from 001e6272 to 001e6276 has its CatchHandler @ 001e6330 */
std::
map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
::
emplace<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
((map<std::__cxx11::string,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::less<void>,std::allocator<std::pair<std::__cxx11::string_const,nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>>
*)param_1[1],*(string **)(*local_50 + 8),(basic_json *)(*local_50 + 0x10));
assert_invariant(SUB81(&local_58,0));
data::~data((data *)&local_58);
param_3 = param_3 + -0x18;
} while (param_3 != 0);
}
}
else {
*(int1 *)param_1 = 2;
local_58 = param_2;
local_38 = pjVar1;
/* try { // try from 001e62a6 to 001e62aa has its CatchHandler @ 001e6325 */
pvVar4 = create<std::vector<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>,std::allocator<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>>,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*,nlohmann::json_abi_v3_11_3::detail::json_ref<nlohmann::json_abi_v3_11_3::basic_json<std::map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>const*>
(&local_58,&local_38);
param_1[1] = pvVar4;
}
assert_invariant(SUB81(param_1,0));
return;
}
| |
43,484 | mysql_stmt_store_result_cont | eloqsql/libmariadb/libmariadb/mariadb_async.c | int STDCALL
mysql_stmt_store_result_cont(int *ret, MYSQL_STMT *stmt, int ready_status)
{
MK_ASYNC_CONT_BODY(
stmt->mysql,
1,
r_int)
} | O3 | c | mysql_stmt_store_result_cont:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rax
movq 0x480(%rax), %rcx
movq 0x28(%rcx), %r15
cmpb $0x0, 0x15(%r15)
je 0x2ef99
movb $0x1, 0x14(%r15)
movl %edx, 0x4(%r15)
leaq 0x38(%r15), %rdi
callq 0x303fb
movb $0x0, 0x14(%r15)
testl %eax, %eax
jle 0x2efff
movl (%r15), %r15d
jmp 0x2f078
movl $0x7de, 0x90(%rax) # imm = 0x7DE
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1ccdd(%rip), %rax # 0x4bc90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1ccc2(%rip), %rax # 0x4bca0
movq 0x70(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, (%rbx)
jmp 0x2f078
movb $0x0, 0x15(%r15)
js 0x2f00c
movl 0x8(%r15), %eax
jmp 0x2f073
movq 0x38(%r14), %rax
movl $0x7d8, 0x90(%rax) # imm = 0x7D8
movl $0x297, %edi # imm = 0x297
addq 0x38(%r14), %rdi
leaq 0x1cc66(%rip), %rax # 0x4bc90
movq (%rax), %rsi
movl $0x5, %edx
callq 0x13220
movq 0x38(%r14), %rax
xorl %r15d, %r15d
movb %r15b, 0x29c(%rax)
movl $0x97, %edi
addq 0x38(%r14), %rdi
leaq 0x1cc4b(%rip), %rax # 0x4bca0
movq 0x40(%rax), %rsi
movl $0x1ff, %edx # imm = 0x1FF
callq 0x13220
movq 0x38(%r14), %rax
movb %r15b, 0x296(%rax)
movl $0x1, %eax
movl %eax, (%rbx)
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| mysql_stmt_store_result_cont:
push rbp
mov rbp, rsp
push r15
push r14
push rbx
push rax
mov r14, rsi
mov rbx, rdi
mov rax, [rsi+38h]
mov rcx, [rax+480h]
mov r15, [rcx+28h]
cmp byte ptr [r15+15h], 0
jz short loc_2EF99
mov byte ptr [r15+14h], 1
mov [r15+4], edx
lea rdi, [r15+38h]
call my_context_continue
mov byte ptr [r15+14h], 0
test eax, eax
jle short loc_2EFFF
mov r15d, [r15]
jmp loc_2F078
loc_2EF99:
mov dword ptr [rax+90h], 7DEh
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+70h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov dword ptr [rbx], 1
jmp short loc_2F078
loc_2EFFF:
mov byte ptr [r15+15h], 0
js short loc_2F00C
mov eax, [r15+8]
jmp short loc_2F073
loc_2F00C:
mov rax, [r14+38h]
mov dword ptr [rax+90h], 7D8h
mov edi, 297h
add rdi, [r14+38h]
lea rax, SQLSTATE_UNKNOWN
mov rsi, [rax]
mov edx, 5
call _strncpy
mov rax, [r14+38h]
xor r15d, r15d
mov [rax+29Ch], r15b
mov edi, 97h
add rdi, [r14+38h]
lea rax, client_errors
mov rsi, [rax+40h]
mov edx, 1FFh
call _strncpy
mov rax, [r14+38h]
mov [rax+296h], r15b
mov eax, 1
loc_2F073:
mov [rbx], eax
xor r15d, r15d
loc_2F078:
mov eax, r15d
add rsp, 8
pop rbx
pop r14
pop r15
pop rbp
retn
| long long mysql_stmt_store_result_cont(int *a1, long long a2, unsigned int a3)
{
long long v3; // rax
unsigned int *v4; // r15
int v5; // eax
unsigned int v6; // r15d
int v7; // eax
v3 = *(_QWORD *)(a2 + 56);
v4 = *(unsigned int **)(*(_QWORD *)(v3 + 1152) + 40LL);
if ( *((_BYTE *)v4 + 21) )
{
*((_BYTE *)v4 + 20) = 1;
v4[1] = a3;
v5 = my_context_continue(v4 + 14);
*((_BYTE *)v4 + 20) = 0;
if ( v5 <= 0 )
{
*((_BYTE *)v4 + 21) = 0;
if ( v5 < 0 )
{
*(_DWORD *)(*(_QWORD *)(a2 + 56) + 144LL) = 2008;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[8], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
v7 = 1;
}
else
{
v7 = v4[2];
}
*a1 = v7;
return 0;
}
else
{
return *v4;
}
}
else
{
*(_DWORD *)(v3 + 144) = 2014;
strncpy(*(_QWORD *)(a2 + 56) + 663LL, SQLSTATE_UNKNOWN, 5LL);
v6 = 0;
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 668LL) = 0;
strncpy(*(_QWORD *)(a2 + 56) + 151LL, client_errors[14], 511LL);
*(_BYTE *)(*(_QWORD *)(a2 + 56) + 662LL) = 0;
*a1 = 1;
}
return v6;
}
| mysql_stmt_store_result_cont:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH RBX
PUSH RAX
MOV R14,RSI
MOV RBX,RDI
MOV RAX,qword ptr [RSI + 0x38]
MOV RCX,qword ptr [RAX + 0x480]
MOV R15,qword ptr [RCX + 0x28]
CMP byte ptr [R15 + 0x15],0x0
JZ 0x0012ef99
MOV byte ptr [R15 + 0x14],0x1
MOV dword ptr [R15 + 0x4],EDX
LEA RDI,[R15 + 0x38]
CALL 0x001303fb
MOV byte ptr [R15 + 0x14],0x0
TEST EAX,EAX
JLE 0x0012efff
MOV R15D,dword ptr [R15]
JMP 0x0012f078
LAB_0012ef99:
MOV dword ptr [RAX + 0x90],0x7de
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bc90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bca0]
MOV RSI,qword ptr [RAX + 0x70]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV dword ptr [RBX],0x1
JMP 0x0012f078
LAB_0012efff:
MOV byte ptr [R15 + 0x15],0x0
JS 0x0012f00c
MOV EAX,dword ptr [R15 + 0x8]
JMP 0x0012f073
LAB_0012f00c:
MOV RAX,qword ptr [R14 + 0x38]
MOV dword ptr [RAX + 0x90],0x7d8
MOV EDI,0x297
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bc90]
MOV RSI,qword ptr [RAX]
MOV EDX,0x5
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
XOR R15D,R15D
MOV byte ptr [RAX + 0x29c],R15B
MOV EDI,0x97
ADD RDI,qword ptr [R14 + 0x38]
LEA RAX,[0x14bca0]
MOV RSI,qword ptr [RAX + 0x40]
MOV EDX,0x1ff
CALL 0x00113220
MOV RAX,qword ptr [R14 + 0x38]
MOV byte ptr [RAX + 0x296],R15B
MOV EAX,0x1
LAB_0012f073:
MOV dword ptr [RBX],EAX
XOR R15D,R15D
LAB_0012f078:
MOV EAX,R15D
ADD RSP,0x8
POP RBX
POP R14
POP R15
POP RBP
RET
|
int4 mysql_stmt_store_result_cont(int4 *param_1,long param_2,int4 param_3)
{
int4 *puVar1;
int iVar2;
int4 uVar3;
puVar1 = *(int4 **)(*(long *)(*(long *)(param_2 + 0x38) + 0x480) + 0x28);
if (*(char *)((long)puVar1 + 0x15) == '\0') {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7de;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
uVar3 = 0;
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),
PTR_s_Commands_out_of_sync__you_can_t_r_0014bd10,0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
*param_1 = 1;
}
else {
*(int1 *)(puVar1 + 5) = 1;
puVar1[1] = param_3;
iVar2 = my_context_continue(puVar1 + 0xe);
*(int1 *)(puVar1 + 5) = 0;
if (iVar2 < 1) {
*(int1 *)((long)puVar1 + 0x15) = 0;
if (iVar2 < 0) {
*(int4 *)(*(long *)(param_2 + 0x38) + 0x90) = 0x7d8;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x297),SQLSTATE_UNKNOWN,5);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x29c) = 0;
strncpy((char *)(*(long *)(param_2 + 0x38) + 0x97),PTR_s_Client_run_out_of_memory_0014bce0,
0x1ff);
*(int1 *)(*(long *)(param_2 + 0x38) + 0x296) = 0;
uVar3 = 1;
}
else {
uVar3 = puVar1[2];
}
*param_1 = uVar3;
uVar3 = 0;
}
else {
uVar3 = *puVar1;
}
}
return uVar3;
}
| |
43,485 | ggml_graph_cpy | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_graph_cpy(struct ggml_cgraph * src, struct ggml_cgraph * dst) {
GGML_ASSERT(dst->size >= src->n_leafs);
GGML_ASSERT(dst->size >= src->n_nodes);
GGML_ASSERT(dst->visited_hash_table.size >= src->visited_hash_table.size);
dst->n_leafs = src->n_leafs;
dst->n_nodes = src->n_nodes;
dst->order = src->order;
for (int i = 0; i < src->n_leafs; ++i) {
dst->leafs[i] = src->leafs[i];
}
for (int i = 0; i < src->n_nodes; ++i) {
dst->nodes[i] = src->nodes[i];
}
if (src->grads) {
GGML_ASSERT(dst->grads != NULL);
for (int i = 0; i < src->n_nodes; ++i) {
dst->grads[i] = src->grads[i];
}
}
for (size_t i = 0; i < src->visited_hash_table.size; ++i) {
if (src->visited_hash_table.keys[i]) {
ggml_hash_insert(dst->visited_hash_table, src->visited_hash_table.keys[i]);
}
}
} | O1 | c | ggml_graph_cpy:
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %edx
movl 0x8(%rdi), %eax
cmpl %eax, %edx
jl 0x9636c
movq %rdi, %r14
movl 0x4(%rdi), %ecx
cmpl %ecx, %edx
jl 0x96371
movq %rsi, %rbx
movq 0x28(%rsi), %rdx
cmpq 0x28(%r14), %rdx
jb 0x96376
movl %eax, 0x8(%rbx)
movl %ecx, 0x4(%rbx)
movl 0x38(%r14), %eax
movl %eax, 0x38(%rbx)
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x962ea
xorl %ecx, %ecx
movq 0x20(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq 0x20(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x962d2
movslq 0x4(%r14), %rax
testq %rax, %rax
jle 0x9630d
xorl %ecx, %ecx
movq 0x10(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq 0x10(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x962f5
cmpq $0x0, 0x18(%r14)
je 0x96339
cmpq $0x0, 0x18(%rbx)
je 0x9637b
testl %eax, %eax
jle 0x96339
xorl %ecx, %ecx
movq 0x18(%r14), %rdx
movq (%rdx,%rcx,8), %rdx
movq 0x18(%rbx), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x96321
cmpq $0x0, 0x28(%r14)
je 0x96366
xorl %r15d, %r15d
movq 0x30(%r14), %rax
movq (%rax,%r15,8), %rdx
testq %rdx, %rdx
je 0x9635d
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x9600a
incq %r15
cmpq 0x28(%r14), %r15
jb 0x96343
popq %rbx
popq %r14
popq %r15
retq
callq 0xf2a8
callq 0xf263
callq 0xf21e
callq 0xf1d9
| ggml_graph_cpy:
push r15
push r14
push rbx
mov edx, [rsi]
mov eax, [rdi+8]
cmp edx, eax
jl loc_9636C
mov r14, rdi
mov ecx, [rdi+4]
cmp edx, ecx
jl loc_96371
mov rbx, rsi
mov rdx, [rsi+28h]
cmp rdx, [r14+28h]
jb loc_96376
mov [rbx+8], eax
mov [rbx+4], ecx
mov eax, [r14+38h]
mov [rbx+38h], eax
movsxd rax, dword ptr [r14+8]
test rax, rax
jle short loc_962EA
xor ecx, ecx
loc_962D2:
mov rdx, [r14+20h]
mov rdx, [rdx+rcx*8]
mov rsi, [rbx+20h]
mov [rsi+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_962D2
loc_962EA:
movsxd rax, dword ptr [r14+4]
test rax, rax
jle short loc_9630D
xor ecx, ecx
loc_962F5:
mov rdx, [r14+10h]
mov rdx, [rdx+rcx*8]
mov rsi, [rbx+10h]
mov [rsi+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_962F5
loc_9630D:
cmp qword ptr [r14+18h], 0
jz short loc_96339
cmp qword ptr [rbx+18h], 0
jz short loc_9637B
test eax, eax
jle short loc_96339
xor ecx, ecx
loc_96321:
mov rdx, [r14+18h]
mov rdx, [rdx+rcx*8]
mov rsi, [rbx+18h]
mov [rsi+rcx*8], rdx
inc rcx
cmp rax, rcx
jnz short loc_96321
loc_96339:
cmp qword ptr [r14+28h], 0
jz short loc_96366
xor r15d, r15d
loc_96343:
mov rax, [r14+30h]
mov rdx, [rax+r15*8]
test rdx, rdx
jz short loc_9635D
mov rdi, [rbx+28h]
mov rsi, [rbx+30h]
call ggml_hash_insert
loc_9635D:
inc r15
cmp r15, [r14+28h]
jb short loc_96343
loc_96366:
pop rbx
pop r14
pop r15
retn
loc_9636C:
call ggml_graph_cpy_cold_4
loc_96371:
call ggml_graph_cpy_cold_3
loc_96376:
call ggml_graph_cpy_cold_2
loc_9637B:
call ggml_graph_cpy_cold_1
| long long ggml_graph_cpy(long long a1, long long a2)
{
int v2; // eax
int v3; // ecx
long long v4; // rax
long long i; // rcx
long long result; // rax
long long j; // rcx
long long k; // rcx
unsigned long long v9; // r15
unsigned long long v10; // rdx
v2 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)a2 < v2 )
ggml_graph_cpy_cold_4();
v3 = *(_DWORD *)(a1 + 4);
if ( *(_DWORD *)a2 < v3 )
ggml_graph_cpy_cold_3();
if ( *(_QWORD *)(a2 + 40) < *(_QWORD *)(a1 + 40) )
ggml_graph_cpy_cold_2();
*(_DWORD *)(a2 + 8) = v2;
*(_DWORD *)(a2 + 4) = v3;
*(_DWORD *)(a2 + 56) = *(_DWORD *)(a1 + 56);
v4 = *(int *)(a1 + 8);
if ( v4 > 0 )
{
for ( i = 0LL; i != v4; ++i )
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * i) = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 8 * i);
}
result = *(int *)(a1 + 4);
if ( result > 0 )
{
for ( j = 0LL; j != result; ++j )
*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * j) = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * j);
}
if ( *(_QWORD *)(a1 + 24) )
{
if ( !*(_QWORD *)(a2 + 24) )
ggml_graph_cpy_cold_1();
if ( (int)result > 0 )
{
for ( k = 0LL; k != result; ++k )
*(_QWORD *)(*(_QWORD *)(a2 + 24) + 8 * k) = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 8 * k);
}
}
if ( *(_QWORD *)(a1 + 40) )
{
v9 = 0LL;
do
{
result = *(_QWORD *)(a1 + 48);
v10 = *(_QWORD *)(result + 8 * v9);
if ( v10 )
result = ggml_hash_insert(*(_QWORD *)(a2 + 40), *(_QWORD *)(a2 + 48), v10);
++v9;
}
while ( v9 < *(_QWORD *)(a1 + 40) );
}
return result;
}
| |||
43,486 | ggml_graph_cpy | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_graph_cpy(struct ggml_cgraph * src, struct ggml_cgraph * dst) {
GGML_ASSERT(dst->size >= src->n_leafs);
GGML_ASSERT(dst->size >= src->n_nodes);
GGML_ASSERT(dst->visited_hash_table.size >= src->visited_hash_table.size);
dst->n_leafs = src->n_leafs;
dst->n_nodes = src->n_nodes;
dst->order = src->order;
for (int i = 0; i < src->n_leafs; ++i) {
dst->leafs[i] = src->leafs[i];
}
for (int i = 0; i < src->n_nodes; ++i) {
dst->nodes[i] = src->nodes[i];
}
if (src->grads) {
GGML_ASSERT(dst->grads != NULL);
for (int i = 0; i < src->n_nodes; ++i) {
dst->grads[i] = src->grads[i];
}
}
for (size_t i = 0; i < src->visited_hash_table.size; ++i) {
if (src->visited_hash_table.keys[i]) {
ggml_hash_insert(dst->visited_hash_table, src->visited_hash_table.keys[i]);
}
}
} | O2 | c | ggml_graph_cpy:
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %eax
movl 0x8(%rdi), %ecx
cmpl %ecx, %eax
jl 0x6fddd
movq %rdi, %r14
movl 0x4(%rdi), %edx
cmpl %edx, %eax
jl 0x6fe15
movq %rsi, %rbx
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rsi)
jb 0x6fe4a
movl %ecx, 0x8(%rbx)
movl %edx, 0x4(%rbx)
movl 0x38(%r14), %ecx
movl %ecx, 0x38(%rbx)
movl 0x8(%r14), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x6fd59
movq 0x20(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x20(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0x6fd3f
movl 0x4(%r14), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x6fd7e
movq 0x10(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x10(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0x6fd64
cmpq $0x0, 0x18(%r14)
je 0x6fdac
cmpq $0x0, 0x18(%rbx)
je 0x6fe7f
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x6fdac
movq 0x18(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x18(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
jmp 0x6fd92
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x6fdd7
movq 0x30(%r14), %rcx
movq (%rcx,%r15,8), %rdx
testq %rdx, %rdx
je 0x6fdd2
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x6f9cd
movq 0x28(%r14), %rax
incq %r15
jmp 0x6fdaf
popq %rbx
popq %r14
popq %r15
retq
movq 0x66164(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x661b5(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a421(%rip), %rsi # 0x9a21e
leaq 0x31a7a(%rip), %rdx # 0xa187e
leaq 0x32463(%rip), %r8 # 0xa226e
movl $0x3e9e, %ecx # imm = 0x3E9E
jmp 0x6feb2
movq 0x6612c(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x6617d(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a3e9(%rip), %rsi # 0x9a21e
leaq 0x31a42(%rip), %rdx # 0xa187e
leaq 0x32445(%rip), %r8 # 0xa2288
movl $0x3e9f, %ecx # imm = 0x3E9F
jmp 0x6feb2
movq 0x660f7(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x66148(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a3b4(%rip), %rsi # 0x9a21e
leaq 0x31a0d(%rip), %rdx # 0xa187e
leaq 0x3242a(%rip), %r8 # 0xa22a2
movl $0x3ea0, %ecx # imm = 0x3EA0
jmp 0x6feb2
movq 0x660c2(%rip), %rax # 0xd5f48
movq (%rax), %rdi
callq 0xa6f0
movq 0x66113(%rip), %rax # 0xd5fa8
movq (%rax), %rdi
leaq 0x2a37f(%rip), %rsi # 0x9a21e
leaq 0x319d8(%rip), %rdx # 0xa187e
leaq 0x32432(%rip), %r8 # 0xa22df
movl $0x3eaf, %ecx # imm = 0x3EAF
xorl %eax, %eax
callq 0xa8b0
callq 0x67550
callq 0xa300
| ggml_graph_cpy:
push r15
push r14
push rbx
mov eax, [rsi]
mov ecx, [rdi+8]
cmp eax, ecx
jl loc_6FDDD
mov r14, rdi
mov edx, [rdi+4]
cmp eax, edx
jl loc_6FE15
mov rbx, rsi
mov rax, [r14+28h]
cmp [rsi+28h], rax
jb loc_6FE4A
mov [rbx+8], ecx
mov [rbx+4], edx
mov ecx, [r14+38h]
mov [rbx+38h], ecx
mov ecx, [r14+8]
xor edx, edx
test ecx, ecx
cmovle ecx, edx
loc_6FD3F:
cmp rcx, rdx
jz short loc_6FD59
mov rsi, [r14+20h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+20h]
mov [rdi+rdx*8], rsi
inc rdx
jmp short loc_6FD3F
loc_6FD59:
mov ecx, [r14+4]
xor edx, edx
test ecx, ecx
cmovle ecx, edx
loc_6FD64:
cmp rcx, rdx
jz short loc_6FD7E
mov rsi, [r14+10h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+10h]
mov [rdi+rdx*8], rsi
inc rdx
jmp short loc_6FD64
loc_6FD7E:
cmp qword ptr [r14+18h], 0
jz short loc_6FDAC
cmp qword ptr [rbx+18h], 0
jz loc_6FE7F
xor edx, edx
loc_6FD92:
cmp rcx, rdx
jz short loc_6FDAC
mov rsi, [r14+18h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+18h]
mov [rdi+rdx*8], rsi
inc rdx
jmp short loc_6FD92
loc_6FDAC:
xor r15d, r15d
loc_6FDAF:
cmp r15, rax
jnb short loc_6FDD7
mov rcx, [r14+30h]
mov rdx, [rcx+r15*8]
test rdx, rdx
jz short loc_6FDD2
mov rdi, [rbx+28h]
mov rsi, [rbx+30h]
call ggml_hash_insert
mov rax, [r14+28h]
loc_6FDD2:
inc r15
jmp short loc_6FDAF
loc_6FDD7:
pop rbx
pop r14
pop r15
retn
loc_6FDDD:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aDstSizeSrcNLea; "dst->size >= src->n_leafs"
mov ecx, 3E9Eh
jmp loc_6FEB2
loc_6FE15:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aDstSizeSrcNNod; "dst->size >= src->n_nodes"
mov ecx, 3E9Fh
jmp short loc_6FEB2
loc_6FE4A:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aDstVisitedHash; "dst->visited_hash_table.size >= src->vi"...
mov ecx, 3EA0h
jmp short loc_6FEB2
loc_6FE7F:
mov rax, cs:stdout_ptr
mov rdi, [rax]
call _fflush
mov rax, cs:stderr_ptr
mov rdi, [rax]
lea rsi, aGgmlAssertSDS; "GGML_ASSERT: %s:%d: %s\n"
lea rdx, aWorkspaceLlm4b_7; "/workspace/llm4binary/github/2025_star3"...
lea r8, aDstGradsNull; "dst->grads != NULL"
mov ecx, 3EAFh
loc_6FEB2:
xor eax, eax
call _fprintf
call ggml_print_backtrace
call _abort
| unsigned long long ggml_graph_cpy(long long a1, long long a2)
{
int v2; // ecx
int v3; // edx
unsigned long long result; // rax
long long v5; // rcx
long long v6; // rdx
long long v7; // rcx
long long v8; // rdx
long long i; // rdx
unsigned long long j; // r15
unsigned long long v11; // rdx
long long v12; // rdi
v2 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)a2 < v2 )
{
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16030LL,
"dst->size >= src->n_leafs");
goto LABEL_27;
}
v3 = *(_DWORD *)(a1 + 4);
if ( *(_DWORD *)a2 < v3 )
{
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16031LL,
"dst->size >= src->n_nodes");
goto LABEL_27;
}
result = *(_QWORD *)(a1 + 40);
if ( *(_QWORD *)(a2 + 40) < result )
{
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16032LL,
"dst->visited_hash_table.size >= src->visited_hash_table.size");
goto LABEL_27;
}
*(_DWORD *)(a2 + 8) = v2;
*(_DWORD *)(a2 + 4) = v3;
*(_DWORD *)(a2 + 56) = *(_DWORD *)(a1 + 56);
v5 = *(unsigned int *)(a1 + 8);
v6 = 0LL;
if ( (int)v5 <= 0 )
v5 = 0LL;
while ( v5 != v6 )
{
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * v6) = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 8 * v6);
++v6;
}
v7 = *(unsigned int *)(a1 + 4);
v8 = 0LL;
if ( (int)v7 <= 0 )
v7 = 0LL;
while ( v7 != v8 )
{
*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * v8) = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * v8);
++v8;
}
if ( *(_QWORD *)(a1 + 24) )
{
if ( *(_QWORD *)(a2 + 24) )
{
for ( i = 0LL; v7 != i; ++i )
*(_QWORD *)(*(_QWORD *)(a2 + 24) + 8 * i) = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 8 * i);
goto LABEL_17;
}
fflush(stdout);
v12 = stderr;
fprintf(
stderr,
"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
16047LL,
"dst->grads != NULL");
LABEL_27:
ggml_print_backtrace();
abort(v12);
}
LABEL_17:
for ( j = 0LL; j < result; ++j )
{
v11 = *(_QWORD *)(*(_QWORD *)(a1 + 48) + 8 * j);
if ( v11 )
{
ggml_hash_insert(*(_QWORD *)(a2 + 40), *(_QWORD *)(a2 + 48), v11);
result = *(_QWORD *)(a1 + 40);
}
}
return result;
}
| ggml_graph_cpy:
PUSH R15
PUSH R14
PUSH RBX
MOV EAX,dword ptr [RSI]
MOV ECX,dword ptr [RDI + 0x8]
CMP EAX,ECX
JL 0x0016fddd
MOV R14,RDI
MOV EDX,dword ptr [RDI + 0x4]
CMP EAX,EDX
JL 0x0016fe15
MOV RBX,RSI
MOV RAX,qword ptr [R14 + 0x28]
CMP qword ptr [RSI + 0x28],RAX
JC 0x0016fe4a
MOV dword ptr [RBX + 0x8],ECX
MOV dword ptr [RBX + 0x4],EDX
MOV ECX,dword ptr [R14 + 0x38]
MOV dword ptr [RBX + 0x38],ECX
MOV ECX,dword ptr [R14 + 0x8]
XOR EDX,EDX
TEST ECX,ECX
CMOVLE ECX,EDX
LAB_0016fd3f:
CMP RCX,RDX
JZ 0x0016fd59
MOV RSI,qword ptr [R14 + 0x20]
MOV RSI,qword ptr [RSI + RDX*0x8]
MOV RDI,qword ptr [RBX + 0x20]
MOV qword ptr [RDI + RDX*0x8],RSI
INC RDX
JMP 0x0016fd3f
LAB_0016fd59:
MOV ECX,dword ptr [R14 + 0x4]
XOR EDX,EDX
TEST ECX,ECX
CMOVLE ECX,EDX
LAB_0016fd64:
CMP RCX,RDX
JZ 0x0016fd7e
MOV RSI,qword ptr [R14 + 0x10]
MOV RSI,qword ptr [RSI + RDX*0x8]
MOV RDI,qword ptr [RBX + 0x10]
MOV qword ptr [RDI + RDX*0x8],RSI
INC RDX
JMP 0x0016fd64
LAB_0016fd7e:
CMP qword ptr [R14 + 0x18],0x0
JZ 0x0016fdac
CMP qword ptr [RBX + 0x18],0x0
JZ 0x0016fe7f
XOR EDX,EDX
LAB_0016fd92:
CMP RCX,RDX
JZ 0x0016fdac
MOV RSI,qword ptr [R14 + 0x18]
MOV RSI,qword ptr [RSI + RDX*0x8]
MOV RDI,qword ptr [RBX + 0x18]
MOV qword ptr [RDI + RDX*0x8],RSI
INC RDX
JMP 0x0016fd92
LAB_0016fdac:
XOR R15D,R15D
LAB_0016fdaf:
CMP R15,RAX
JNC 0x0016fdd7
MOV RCX,qword ptr [R14 + 0x30]
MOV RDX,qword ptr [RCX + R15*0x8]
TEST RDX,RDX
JZ 0x0016fdd2
MOV RDI,qword ptr [RBX + 0x28]
MOV RSI,qword ptr [RBX + 0x30]
CALL 0x0016f9cd
MOV RAX,qword ptr [R14 + 0x28]
LAB_0016fdd2:
INC R15
JMP 0x0016fdaf
LAB_0016fdd7:
POP RBX
POP R14
POP R15
RET
LAB_0016fddd:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a226e]
MOV ECX,0x3e9e
JMP 0x0016feb2
LAB_0016fe15:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a2288]
MOV ECX,0x3e9f
JMP 0x0016feb2
LAB_0016fe4a:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a22a2]
MOV ECX,0x3ea0
JMP 0x0016feb2
LAB_0016fe7f:
MOV RAX,qword ptr [0x001d5f48]
MOV RDI,qword ptr [RAX]
CALL 0x0010a6f0
MOV RAX,qword ptr [0x001d5fa8]
MOV RDI,qword ptr [RAX]
LEA RSI,[0x19a21e]
LEA RDX,[0x1a187e]
LEA R8,[0x1a22df]
MOV ECX,0x3eaf
LAB_0016feb2:
XOR EAX,EAX
CALL 0x0010a8b0
CALL 0x00167550
CALL 0x0010a300
|
void ggml_graph_cpy(long param_1,int *param_2)
{
int iVar1;
ulong uVar2;
int8 uVar3;
ulong uVar4;
FILE *__stream;
char *pcVar5;
ulong uVar6;
if (*param_2 < *(int *)(param_1 + 8)) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "dst->size >= src->n_leafs";
uVar3 = 0x3e9e;
}
else {
iVar1 = *(int *)(param_1 + 4);
if (*param_2 < iVar1) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "dst->size >= src->n_nodes";
uVar3 = 0x3e9f;
}
else {
uVar2 = *(ulong *)(param_1 + 0x28);
if (uVar2 <= *(ulong *)(param_2 + 10)) {
param_2[2] = *(int *)(param_1 + 8);
param_2[1] = iVar1;
param_2[0xe] = *(int *)(param_1 + 0x38);
uVar4 = 0;
uVar6 = (ulong)*(uint *)(param_1 + 8);
if ((int)*(uint *)(param_1 + 8) < 1) {
uVar6 = uVar4;
}
for (; uVar6 != uVar4; uVar4 = uVar4 + 1) {
*(int8 *)(*(long *)(param_2 + 8) + uVar4 * 8) =
*(int8 *)(*(long *)(param_1 + 0x20) + uVar4 * 8);
}
uVar4 = 0;
uVar6 = (ulong)*(uint *)(param_1 + 4);
if ((int)*(uint *)(param_1 + 4) < 1) {
uVar6 = uVar4;
}
for (; uVar6 != uVar4; uVar4 = uVar4 + 1) {
*(int8 *)(*(long *)(param_2 + 4) + uVar4 * 8) =
*(int8 *)(*(long *)(param_1 + 0x10) + uVar4 * 8);
}
if (*(long *)(param_1 + 0x18) != 0) {
if (*(long *)(param_2 + 6) == 0) {
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "dst->grads != NULL";
uVar3 = 0x3eaf;
goto LAB_0016feb2;
}
for (uVar4 = 0; uVar6 != uVar4; uVar4 = uVar4 + 1) {
*(int8 *)(*(long *)(param_2 + 6) + uVar4 * 8) =
*(int8 *)(*(long *)(param_1 + 0x18) + uVar4 * 8);
}
}
for (uVar6 = 0; uVar6 < uVar2; uVar6 = uVar6 + 1) {
if (*(long *)(*(long *)(param_1 + 0x30) + uVar6 * 8) != 0) {
ggml_hash_insert(*(int8 *)(param_2 + 10),*(int8 *)(param_2 + 0xc));
uVar2 = *(ulong *)(param_1 + 0x28);
}
}
return;
}
fflush(*(FILE **)PTR_stdout_001d5f48);
__stream = *(FILE **)PTR_stderr_001d5fa8;
pcVar5 = "dst->visited_hash_table.size >= src->visited_hash_table.size";
uVar3 = 0x3ea0;
}
}
LAB_0016feb2:
fprintf(__stream,"GGML_ASSERT: %s:%d: %s\n",
"/workspace/llm4binary/github/2025_star3/7CodeWizard[P]stablediffusion/ggml/src/ggml.c",
uVar3,pcVar5);
ggml_print_backtrace();
/* WARNING: Subroutine does not return */
abort();
}
| |
43,487 | ggml_graph_cpy | 7CodeWizard[P]stablediffusion/ggml/src/ggml.c | void ggml_graph_cpy(struct ggml_cgraph * src, struct ggml_cgraph * dst) {
GGML_ASSERT(dst->size >= src->n_leafs);
GGML_ASSERT(dst->size >= src->n_nodes);
GGML_ASSERT(dst->visited_hash_table.size >= src->visited_hash_table.size);
dst->n_leafs = src->n_leafs;
dst->n_nodes = src->n_nodes;
dst->order = src->order;
for (int i = 0; i < src->n_leafs; ++i) {
dst->leafs[i] = src->leafs[i];
}
for (int i = 0; i < src->n_nodes; ++i) {
dst->nodes[i] = src->nodes[i];
}
if (src->grads) {
GGML_ASSERT(dst->grads != NULL);
for (int i = 0; i < src->n_nodes; ++i) {
dst->grads[i] = src->grads[i];
}
}
for (size_t i = 0; i < src->visited_hash_table.size; ++i) {
if (src->visited_hash_table.keys[i]) {
ggml_hash_insert(dst->visited_hash_table, src->visited_hash_table.keys[i]);
}
}
} | O3 | c | ggml_graph_cpy:
pushq %r15
pushq %r14
pushq %rbx
movl (%rsi), %eax
movl 0x8(%rdi), %ecx
cmpl %ecx, %eax
jl 0x95225
movq %rdi, %r14
movl 0x4(%rdi), %edx
cmpl %edx, %eax
jl 0x9522a
movq %rsi, %rbx
movq 0x28(%r14), %rax
cmpq %rax, 0x28(%rsi)
jb 0x9522f
movl %ecx, 0x8(%rbx)
movl %edx, 0x4(%rbx)
movl 0x38(%r14), %ecx
movl %ecx, 0x38(%rbx)
movslq 0x8(%r14), %rcx
testq %rcx, %rcx
jle 0x951a2
xorl %edx, %edx
movq 0x20(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x20(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x9518a
movslq 0x4(%r14), %rcx
testq %rcx, %rcx
jle 0x951c5
xorl %edx, %edx
movq 0x10(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x10(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x951ad
cmpq $0x0, 0x18(%r14)
je 0x951f1
cmpq $0x0, 0x18(%rbx)
je 0x95234
testl %ecx, %ecx
jle 0x951f1
xorl %edx, %edx
movq 0x18(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
movq 0x18(%rbx), %rdi
movq %rsi, (%rdi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x951d9
testq %rax, %rax
je 0x9521f
xorl %r15d, %r15d
movq 0x30(%r14), %rcx
movq (%rcx,%r15,8), %rdx
testq %rdx, %rdx
je 0x95217
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x94eee
movq 0x28(%r14), %rax
incq %r15
cmpq %rax, %r15
jb 0x951f9
popq %rbx
popq %r14
popq %r15
retq
callq 0xf13f
callq 0xf0fa
callq 0xf0b5
callq 0xf070
| ggml_graph_cpy:
push r15
push r14
push rbx
mov eax, [rsi]
mov ecx, [rdi+8]
cmp eax, ecx
jl loc_95225
mov r14, rdi
mov edx, [rdi+4]
cmp eax, edx
jl loc_9522A
mov rbx, rsi
mov rax, [r14+28h]
cmp [rsi+28h], rax
jb loc_9522F
mov [rbx+8], ecx
mov [rbx+4], edx
mov ecx, [r14+38h]
mov [rbx+38h], ecx
movsxd rcx, dword ptr [r14+8]
test rcx, rcx
jle short loc_951A2
xor edx, edx
loc_9518A:
mov rsi, [r14+20h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+20h]
mov [rdi+rdx*8], rsi
inc rdx
cmp rcx, rdx
jnz short loc_9518A
loc_951A2:
movsxd rcx, dword ptr [r14+4]
test rcx, rcx
jle short loc_951C5
xor edx, edx
loc_951AD:
mov rsi, [r14+10h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+10h]
mov [rdi+rdx*8], rsi
inc rdx
cmp rcx, rdx
jnz short loc_951AD
loc_951C5:
cmp qword ptr [r14+18h], 0
jz short loc_951F1
cmp qword ptr [rbx+18h], 0
jz short loc_95234
test ecx, ecx
jle short loc_951F1
xor edx, edx
loc_951D9:
mov rsi, [r14+18h]
mov rsi, [rsi+rdx*8]
mov rdi, [rbx+18h]
mov [rdi+rdx*8], rsi
inc rdx
cmp rcx, rdx
jnz short loc_951D9
loc_951F1:
test rax, rax
jz short loc_9521F
xor r15d, r15d
loc_951F9:
mov rcx, [r14+30h]
mov rdx, [rcx+r15*8]
test rdx, rdx
jz short loc_95217
mov rdi, [rbx+28h]
mov rsi, [rbx+30h]
call ggml_hash_insert
mov rax, [r14+28h]
loc_95217:
inc r15
cmp r15, rax
jb short loc_951F9
loc_9521F:
pop rbx
pop r14
pop r15
retn
loc_95225:
call ggml_graph_cpy_cold_4
loc_9522A:
call ggml_graph_cpy_cold_3
loc_9522F:
call ggml_graph_cpy_cold_2
loc_95234:
call ggml_graph_cpy_cold_1
| unsigned long long ggml_graph_cpy(long long a1, long long a2)
{
int v2; // ecx
int v3; // edx
unsigned long long result; // rax
long long v5; // rcx
long long i; // rdx
long long v7; // rcx
long long j; // rdx
long long k; // rdx
unsigned long long m; // r15
unsigned long long v11; // rdx
v2 = *(_DWORD *)(a1 + 8);
if ( *(_DWORD *)a2 < v2 )
ggml_graph_cpy_cold_4();
v3 = *(_DWORD *)(a1 + 4);
if ( *(_DWORD *)a2 < v3 )
ggml_graph_cpy_cold_3();
result = *(_QWORD *)(a1 + 40);
if ( *(_QWORD *)(a2 + 40) < result )
ggml_graph_cpy_cold_2();
*(_DWORD *)(a2 + 8) = v2;
*(_DWORD *)(a2 + 4) = v3;
*(_DWORD *)(a2 + 56) = *(_DWORD *)(a1 + 56);
v5 = *(int *)(a1 + 8);
if ( v5 > 0 )
{
for ( i = 0LL; i != v5; ++i )
*(_QWORD *)(*(_QWORD *)(a2 + 32) + 8 * i) = *(_QWORD *)(*(_QWORD *)(a1 + 32) + 8 * i);
}
v7 = *(int *)(a1 + 4);
if ( v7 > 0 )
{
for ( j = 0LL; j != v7; ++j )
*(_QWORD *)(*(_QWORD *)(a2 + 16) + 8 * j) = *(_QWORD *)(*(_QWORD *)(a1 + 16) + 8 * j);
}
if ( *(_QWORD *)(a1 + 24) )
{
if ( !*(_QWORD *)(a2 + 24) )
ggml_graph_cpy_cold_1();
if ( (int)v7 > 0 )
{
for ( k = 0LL; k != v7; ++k )
*(_QWORD *)(*(_QWORD *)(a2 + 24) + 8 * k) = *(_QWORD *)(*(_QWORD *)(a1 + 24) + 8 * k);
}
}
if ( result )
{
for ( m = 0LL; m < result; ++m )
{
v11 = *(_QWORD *)(*(_QWORD *)(a1 + 48) + 8 * m);
if ( v11 )
{
ggml_hash_insert(*(_QWORD *)(a2 + 40), *(_QWORD *)(a2 + 48), v11);
result = *(_QWORD *)(a1 + 40);
}
}
}
return result;
}
| |||
43,488 | func_uni_gb2312_onechar | eloqsql/strings/ctype-gb2312.c | static int func_uni_gb2312_onechar(int code){
if ((code>=0x00A4)&&(code<=0x01DC))
return(tab_uni_gb23120[code-0x00A4]);
if ((code>=0x02C7)&&(code<=0x0451))
return(tab_uni_gb23121[code-0x02C7]);
if ((code>=0x2015)&&(code<=0x2312))
return(tab_uni_gb23122[code-0x2015]);
if ((code>=0x2460)&&(code<=0x2642))
return(tab_uni_gb23123[code-0x2460]);
if ((code>=0x3000)&&(code<=0x3129))
return(tab_uni_gb23124[code-0x3000]);
if ((code>=0x3220)&&(code<=0x3229))
return(tab_uni_gb23125[code-0x3220]);
if ((code>=0x4E00)&&(code<=0x9B54))
return(tab_uni_gb23126[code-0x4E00]);
if ((code>=0x9C7C)&&(code<=0x9CE2))
return(tab_uni_gb23127[code-0x9C7C]);
if ((code>=0x9E1F)&&(code<=0x9FA0))
return(tab_uni_gb23128[code-0x9E1F]);
if ((code>=0xFF01)&&(code<=0xFFE5))
return(tab_uni_gb23129[code-0xFF01]);
return(0);
} | O0 | c | func_uni_gb2312_onechar:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0xa4, -0x8(%rbp)
jl 0x3f4f7
cmpl $0x1dc, -0x8(%rbp) # imm = 0x1DC
jg 0x3f4f7
movl -0x8(%rbp), %eax
subl $0xa4, %eax
movslq %eax, %rcx
leaq 0xcf7d5(%rip), %rax # 0x10ecc0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x2c7, -0x8(%rbp) # imm = 0x2C7
jl 0x3f527
cmpl $0x451, -0x8(%rbp) # imm = 0x451
jg 0x3f527
movl -0x8(%rbp), %eax
subl $0x2c7, %eax # imm = 0x2C7
movslq %eax, %rcx
leaq 0xcfa25(%rip), %rax # 0x10ef40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x2015, -0x8(%rbp) # imm = 0x2015
jl 0x3f557
cmpl $0x2312, -0x8(%rbp) # imm = 0x2312
jg 0x3f557
movl -0x8(%rbp), %eax
subl $0x2015, %eax # imm = 0x2015
movslq %eax, %rcx
leaq 0xcfd15(%rip), %rax # 0x10f260
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x2460, -0x8(%rbp) # imm = 0x2460
jl 0x3f587
cmpl $0x2642, -0x8(%rbp) # imm = 0x2642
jg 0x3f587
movl -0x8(%rbp), %eax
subl $0x2460, %eax # imm = 0x2460
movslq %eax, %rcx
leaq 0xd02e5(%rip), %rax # 0x10f860
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x3000, -0x8(%rbp) # imm = 0x3000
jl 0x3f5b7
cmpl $0x3129, -0x8(%rbp) # imm = 0x3129
jg 0x3f5b7
movl -0x8(%rbp), %eax
subl $0x3000, %eax # imm = 0x3000
movslq %eax, %rcx
leaq 0xd0685(%rip), %rax # 0x10fc30
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x3220, -0x8(%rbp) # imm = 0x3220
jl 0x3f5e7
cmpl $0x3229, -0x8(%rbp) # imm = 0x3229
jg 0x3f5e7
movl -0x8(%rbp), %eax
subl $0x3220, %eax # imm = 0x3220
movslq %eax, %rcx
leaq 0xd08b5(%rip), %rax # 0x10fe90
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x4e00, -0x8(%rbp) # imm = 0x4E00
jl 0x3f617
cmpl $0x9b54, -0x8(%rbp) # imm = 0x9B54
jg 0x3f617
movl -0x8(%rbp), %eax
subl $0x4e00, %eax # imm = 0x4E00
movslq %eax, %rcx
leaq 0xd08a5(%rip), %rax # 0x10feb0
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x9c7c, -0x8(%rbp) # imm = 0x9C7C
jl 0x3f644
cmpl $0x9ce2, -0x8(%rbp) # imm = 0x9CE2
jg 0x3f644
movl -0x8(%rbp), %eax
subl $0x9c7c, %eax # imm = 0x9C7C
movslq %eax, %rcx
leaq 0xda325(%rip), %rax # 0x119960
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0x9e1f, -0x8(%rbp) # imm = 0x9E1F
jl 0x3f671
cmpl $0x9fa0, -0x8(%rbp) # imm = 0x9FA0
jg 0x3f671
movl -0x8(%rbp), %eax
subl $0x9e1f, %eax # imm = 0x9E1F
movslq %eax, %rcx
leaq 0xda3c8(%rip), %rax # 0x119a30
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
cmpl $0xff01, -0x8(%rbp) # imm = 0xFF01
jl 0x3f69e
cmpl $0xffe5, -0x8(%rbp) # imm = 0xFFE5
jg 0x3f69e
movl -0x8(%rbp), %eax
subl $0xff01, %eax # imm = 0xFF01
movslq %eax, %rcx
leaq 0xda6ab(%rip), %rax # 0x119d40
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
jmp 0x3f6a5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| func_uni_gb2312_onechar:
push rbp
mov rbp, rsp
mov [rbp+var_8], edi
cmp [rbp+var_8], 0A4h
jl short loc_3F4F7
cmp [rbp+var_8], 1DCh
jg short loc_3F4F7
mov eax, [rbp+var_8]
sub eax, 0A4h
movsxd rcx, eax
lea rax, tab_uni_gb23120
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F4F7:
cmp [rbp+var_8], 2C7h
jl short loc_3F527
cmp [rbp+var_8], 451h
jg short loc_3F527
mov eax, [rbp+var_8]
sub eax, 2C7h
movsxd rcx, eax
lea rax, tab_uni_gb23121
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F527:
cmp [rbp+var_8], 2015h
jl short loc_3F557
cmp [rbp+var_8], 2312h
jg short loc_3F557
mov eax, [rbp+var_8]
sub eax, 2015h
movsxd rcx, eax
lea rax, tab_uni_gb23122; "*!,!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F557:
cmp [rbp+var_8], 2460h
jl short loc_3F587
cmp [rbp+var_8], 2642h
jg short loc_3F587
mov eax, [rbp+var_8]
sub eax, 2460h
movsxd rcx, eax
lea rax, tab_uni_gb23123; "Y\"Z\"[\"\\\"]\"^\"_\"`\"a\"b\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F587:
cmp [rbp+var_8], 3000h
jl short loc_3F5B7
cmp [rbp+var_8], 3129h
jg short loc_3F5B7
mov eax, [rbp+var_8]
sub eax, 3000h
movsxd rcx, eax
lea rax, tab_uni_gb23124; "!!\"!#!(!"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F5B7:
cmp [rbp+var_8], 3220h
jl short loc_3F5E7
cmp [rbp+var_8], 3229h
jg short loc_3F5E7
mov eax, [rbp+var_8]
sub eax, 3220h
movsxd rcx, eax
lea rax, tab_uni_gb23125; "e\"f\"g\"h\"i\"j\"k\"l\"m\"n\""
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F5E7:
cmp [rbp+var_8], 4E00h
jl short loc_3F617
cmp [rbp+var_8], 9B54h
jg short loc_3F617
mov eax, [rbp+var_8]
sub eax, 4E00h
movsxd rcx, eax
lea rax, tab_uni_gb23126; ";R!6"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp loc_3F6A5
loc_3F617:
cmp [rbp+var_8], 9C7Ch
jl short loc_3F644
cmp [rbp+var_8], 9CE2h
jg short loc_3F644
mov eax, [rbp+var_8]
sub eax, 9C7Ch
movsxd rcx, eax
lea rax, tab_uni_gb23127
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3F6A5
loc_3F644:
cmp [rbp+var_8], 9E1Fh
jl short loc_3F671
cmp [rbp+var_8], 9FA0h
jg short loc_3F671
mov eax, [rbp+var_8]
sub eax, 9E1Fh
movsxd rcx, eax
lea rax, tab_uni_gb23128; "qD/p&<0pyC"
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3F6A5
loc_3F671:
cmp [rbp+var_8], 0FF01h
jl short loc_3F69E
cmp [rbp+var_8], 0FFE5h
jg short loc_3F69E
mov eax, [rbp+var_8]
sub eax, 0FF01h
movsxd rcx, eax
lea rax, tab_uni_gb23129; "!#\"###g!%#&#'#(#)#*#+#,#-#.#/#0#1#2#3#"...
movzx eax, word ptr [rax+rcx*2]
mov [rbp+var_4], eax
jmp short loc_3F6A5
loc_3F69E:
mov [rbp+var_4], 0
loc_3F6A5:
mov eax, [rbp+var_4]
pop rbp
retn
| long long func_uni_gb2312_onechar(int a1)
{
if ( a1 < 164 || a1 > 476 )
{
if ( a1 < 711 || a1 > 1105 )
{
if ( a1 < 8213 || a1 > 8978 )
{
if ( a1 < 9312 || a1 > 9794 )
{
if ( a1 < 12288 || a1 > 12585 )
{
if ( a1 < 12832 || a1 > 12841 )
{
if ( a1 < 19968 || a1 > 39764 )
{
if ( a1 < 40060 || a1 > 40162 )
{
if ( a1 < 40479 || a1 > 40864 )
{
if ( a1 < 65281 || a1 > 65509 )
return 0;
else
return tab_uni_gb23129[a1 - 65281];
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23128[2 * a1 - 80958];
}
}
else
{
return tab_uni_gb23127[a1 - 40060];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23126[2 * a1 - 39936];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23125[2 * a1 - 25664];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23124[2 * a1 - 24576];
}
}
else
{
return tab_uni_gb23123[a1 - 9312];
}
}
else
{
return *(unsigned __int16 *)&tab_uni_gb23122[2 * a1 - 16426];
}
}
else
{
return tab_uni_gb23121[a1 - 711];
}
}
else
{
return tab_uni_gb23120[a1 - 164];
}
}
| func_uni_gb2312_onechar:
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x8],EDI
CMP dword ptr [RBP + -0x8],0xa4
JL 0x0013f4f7
CMP dword ptr [RBP + -0x8],0x1dc
JG 0x0013f4f7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xa4
MOVSXD RCX,EAX
LEA RAX,[0x20ecc0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f4f7:
CMP dword ptr [RBP + -0x8],0x2c7
JL 0x0013f527
CMP dword ptr [RBP + -0x8],0x451
JG 0x0013f527
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2c7
MOVSXD RCX,EAX
LEA RAX,[0x20ef40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f527:
CMP dword ptr [RBP + -0x8],0x2015
JL 0x0013f557
CMP dword ptr [RBP + -0x8],0x2312
JG 0x0013f557
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2015
MOVSXD RCX,EAX
LEA RAX,[0x20f260]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f557:
CMP dword ptr [RBP + -0x8],0x2460
JL 0x0013f587
CMP dword ptr [RBP + -0x8],0x2642
JG 0x0013f587
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x2460
MOVSXD RCX,EAX
LEA RAX,[0x20f860]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f587:
CMP dword ptr [RBP + -0x8],0x3000
JL 0x0013f5b7
CMP dword ptr [RBP + -0x8],0x3129
JG 0x0013f5b7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3000
MOVSXD RCX,EAX
LEA RAX,[0x20fc30]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f5b7:
CMP dword ptr [RBP + -0x8],0x3220
JL 0x0013f5e7
CMP dword ptr [RBP + -0x8],0x3229
JG 0x0013f5e7
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x3220
MOVSXD RCX,EAX
LEA RAX,[0x20fe90]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f5e7:
CMP dword ptr [RBP + -0x8],0x4e00
JL 0x0013f617
CMP dword ptr [RBP + -0x8],0x9b54
JG 0x0013f617
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x4e00
MOVSXD RCX,EAX
LEA RAX,[0x20feb0]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f617:
CMP dword ptr [RBP + -0x8],0x9c7c
JL 0x0013f644
CMP dword ptr [RBP + -0x8],0x9ce2
JG 0x0013f644
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9c7c
MOVSXD RCX,EAX
LEA RAX,[0x219960]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f644:
CMP dword ptr [RBP + -0x8],0x9e1f
JL 0x0013f671
CMP dword ptr [RBP + -0x8],0x9fa0
JG 0x0013f671
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0x9e1f
MOVSXD RCX,EAX
LEA RAX,[0x219a30]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f671:
CMP dword ptr [RBP + -0x8],0xff01
JL 0x0013f69e
CMP dword ptr [RBP + -0x8],0xffe5
JG 0x0013f69e
MOV EAX,dword ptr [RBP + -0x8]
SUB EAX,0xff01
MOVSXD RCX,EAX
LEA RAX,[0x219d40]
MOVZX EAX,word ptr [RAX + RCX*0x2]
MOV dword ptr [RBP + -0x4],EAX
JMP 0x0013f6a5
LAB_0013f69e:
MOV dword ptr [RBP + -0x4],0x0
LAB_0013f6a5:
MOV EAX,dword ptr [RBP + -0x4]
POP RBP
RET
|
int2 func_uni_gb2312_onechar(int param_1)
{
int2 uVar1;
if ((param_1 < 0xa4) || (0x1dc < param_1)) {
if ((param_1 < 0x2c7) || (0x451 < param_1)) {
if ((param_1 < 0x2015) || (0x2312 < param_1)) {
if ((param_1 < 0x2460) || (0x2642 < param_1)) {
if ((param_1 < 0x3000) || (0x3129 < param_1)) {
if ((param_1 < 0x3220) || (0x3229 < param_1)) {
if ((param_1 < 0x4e00) || (0x9b54 < param_1)) {
if ((param_1 < 0x9c7c) || (0x9ce2 < param_1)) {
if ((param_1 < 0x9e1f) || (0x9fa0 < param_1)) {
if ((param_1 < 0xff01) || (0xffe5 < param_1)) {
uVar1 = 0;
}
else {
uVar1 = *(int2 *)(tab_uni_gb23129 + (long)(param_1 + -0xff01) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23128 + (long)(param_1 + -0x9e1f) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23127 + (long)(param_1 + -0x9c7c) * 2);
}
}
else {
uVar1 = *(int2 *)(&tab_uni_gb23126 + (long)(param_1 + -0x4e00) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23125 + (long)(param_1 + -0x3220) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23124 + (long)(param_1 + -0x3000) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23123 + (long)(param_1 + -0x2460) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23122 + (long)(param_1 + -0x2015) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23121 + (long)(param_1 + -0x2c7) * 2);
}
}
else {
uVar1 = *(int2 *)(tab_uni_gb23120 + (long)(param_1 + -0xa4) * 2);
}
return uVar1;
}
| |
43,489 | testing::internal::Int32FromEnvOrDie(char const*, int) | giladroyz[P]FindPeaks/build_O1/_deps/googletest-src/googletest/src/gtest.cc | int32_t Int32FromEnvOrDie(const char* var, int32_t default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == nullptr) {
return default_val;
}
int32_t result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
return result;
} | O1 | cpp | testing::internal::Int32FromEnvOrDie(char const*, int):
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0x8660
testq %rax, %rax
je 0x22c13
movq %rax, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1cd64
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0x20ea1(%rip), %rsi # 0x43a53
movl $0x22, %edx
movq %r12, %rdi
callq 0x85b0
testq %r15, %r15
je 0x22bd1
movq %r15, %rdi
callq 0x8200
movq %rax, %rdx
jmp 0x22bdd
movl $0x6, %edx
leaq 0x1da0c(%rip), %r15 # 0x405e9
movq %r12, %rdi
movq %r15, %rsi
callq 0x85b0
leaq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x17310
movl %eax, %ebp
testq %rbx, %rbx
je 0x22c0a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
testb %bpl, %bpl
je 0x22c22
movl 0x4(%rsp), %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x8650
movq %rax, %r14
testq %rbx, %rbx
je 0x22c3d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8990
nop
| _ZN7testing8internal17Int32FromEnvOrDieEPKci:
push rbp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov ebx, esi
mov r15, rdi
call _getenv
test rax, rax
jz short loc_22C13
mov r14, rax
lea rbx, [rsp+38h+var_30]
mov rdi, rbx; this
call _ZN7testing7MessageC2Ev; testing::Message::Message(void)
mov rbx, [rbx]
lea r12, [rbx+10h]
lea rsi, aTheValueOfEnvi; "The value of environment variable "
mov edx, 22h ; '"'
mov rdi, r12
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
test r15, r15
jz short loc_22BD1
mov rdi, r15
call _strlen
mov rdx, rax
jmp short loc_22BDD
loc_22BD1:
mov edx, 6
lea r15, aNull; "(null)"
loc_22BDD:
mov rdi, r12
mov rsi, r15
call __ZSt16__ostream_insertIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_PKS3_l; std::__ostream_insert<char,std::char_traits<char>>(std::ostream &,char const*,long)
lea rdi, [rsp+38h+var_30]; this
lea rdx, [rsp+38h+var_34]; char *
mov rsi, r14; testing::Message *
call _ZN7testing8internal10ParseInt32ERKNS_7MessageEPKcPi; testing::internal::ParseInt32(testing::Message const&,char const*,int *)
mov ebp, eax
test rbx, rbx
jz short loc_22C0A
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
loc_22C0A:
test bpl, bpl
jz short loc_22C22
mov ebx, dword ptr [rsp+38h+var_34]
loc_22C13:
mov eax, ebx
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
loc_22C22:
mov edi, 1
call _exit
mov r14, rax
test rbx, rbx
jz short loc_22C3D
mov rax, [rbx]
mov rdi, rbx
call qword ptr [rax+8]
loc_22C3D:
mov rdi, r14
call __Unwind_Resume
| long long testing::internal::Int32FromEnvOrDie(testing::internal *this, const char *a2)
{
unsigned int v2; // ebx
const char *v3; // r15
long long v4; // rax
const testing::Message *v5; // r14
long long v6; // rbx
long long v7; // rdx
int *v8; // rcx
char v9; // bp
char v11[4]; // [rsp+4h] [rbp-34h] BYREF
_QWORD v12[6]; // [rsp+8h] [rbp-30h] BYREF
v2 = (unsigned int)a2;
v3 = (const char *)this;
v4 = getenv(this);
if ( v4 )
{
v5 = (const testing::Message *)v4;
testing::Message::Message((testing::Message *)v12);
v6 = v12[0];
std::__ostream_insert<char,std::char_traits<char>>(v12[0] + 16LL, "The value of environment variable ", 34LL);
if ( this )
{
v7 = strlen(this);
}
else
{
v7 = 6LL;
v3 = "(null)";
}
std::__ostream_insert<char,std::char_traits<char>>(v6 + 16, v3, v7);
v9 = testing::internal::ParseInt32((testing::internal *)v12, v5, v11, v8);
if ( v6 )
(*(void ( **)(long long))(*(_QWORD *)v6 + 8LL))(v6);
if ( !v9 )
exit(1LL);
return *(unsigned int *)v11;
}
return v2;
}
| Int32FromEnvOrDie:
PUSH RBP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV EBX,ESI
MOV R15,RDI
CALL 0x00108660
TEST RAX,RAX
JZ 0x00122c13
MOV R14,RAX
LEA RBX,[RSP + 0x8]
MOV RDI,RBX
CALL 0x0011cd64
MOV RBX,qword ptr [RBX]
LEA R12,[RBX + 0x10]
LAB_00122bab:
LEA RSI,[0x143a53]
MOV EDX,0x22
MOV RDI,R12
CALL 0x001085b0
TEST R15,R15
JZ 0x00122bd1
MOV RDI,R15
CALL 0x00108200
MOV RDX,RAX
JMP 0x00122bdd
LAB_00122bd1:
MOV EDX,0x6
LEA R15,[0x1405e9]
LAB_00122bdd:
MOV RDI,R12
MOV RSI,R15
CALL 0x001085b0
LEA RDI,[RSP + 0x8]
LEA RDX,[RSP + 0x4]
MOV RSI,R14
CALL 0x00117310
LAB_00122bfa:
MOV EBP,EAX
TEST RBX,RBX
JZ 0x00122c0a
MOV RAX,qword ptr [RBX]
MOV RDI,RBX
CALL qword ptr [RAX + 0x8]
LAB_00122c0a:
TEST BPL,BPL
JZ 0x00122c22
MOV EBX,dword ptr [RSP + 0x4]
LAB_00122c13:
MOV EAX,EBX
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
LAB_00122c22:
MOV EDI,0x1
CALL 0x00108650
|
/* testing::internal::Int32FromEnvOrDie(char const*, int) */
int testing::internal::Int32FromEnvOrDie(char *param_1,int param_2)
{
char cVar1;
char *pcVar2;
size_t sVar3;
int local_34;
long *local_30;
pcVar2 = getenv(param_1);
if (pcVar2 != (char *)0x0) {
Message::Message((Message *)&local_30);
/* try { // try from 00122bab to 00122bf9 has its CatchHandler @ 00122c2c */
std::__ostream_insert<char,std::char_traits<char>>
((ostream *)(local_30 + 2),"The value of environment variable ",0x22);
if (param_1 == (char *)0x0) {
sVar3 = 6;
param_1 = "(null)";
}
else {
sVar3 = strlen(param_1);
}
std::__ostream_insert<char,std::char_traits<char>>((ostream *)(local_30 + 2),param_1,sVar3);
cVar1 = ParseInt32((Message *)&local_30,pcVar2,&local_34);
if (local_30 != (long *)0x0) {
(**(code **)(*local_30 + 8))(local_30);
}
param_2 = local_34;
if (cVar1 == '\0') {
/* WARNING: Subroutine does not return */
exit(1);
}
}
return param_2;
}
| |
43,490 | testing::internal::PortableLocaltime(long, tm*) | AlayaLite/build_O0/_deps/googletest-src/googletest/src/gtest.cc | static bool PortableLocaltime(time_t seconds, struct tm* out) {
#if defined(_MSC_VER)
return localtime_s(out, &seconds) == 0;
#elif defined(__MINGW32__) || defined(__MINGW64__)
// MINGW <time.h> provides neither localtime_r nor localtime_s, but uses
// Windows' localtime(), which has a thread-local tm buffer.
struct tm* tm_ptr = localtime(&seconds); // NOLINT
if (tm_ptr == nullptr) return false;
*out = *tm_ptr;
return true;
#elif defined(__STDC_LIB_EXT1__)
// Uses localtime_s when available as localtime_r is only available from
// C23 standard.
return localtime_s(&seconds, out) != nullptr;
#else
return localtime_r(&seconds, out) != nullptr;
#endif
} | O0 | cpp | testing::internal::PortableLocaltime(long, tm*):
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x14360
cmpq $0x0, %rax
setne %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| _ZN7testing8internalL17PortableLocaltimeElP2tm:
sub rsp, 18h
mov [rsp+18h+var_8], rdi
mov [rsp+18h+var_10], rsi
mov rsi, [rsp+18h+var_10]
lea rdi, [rsp+18h+var_8]
call _localtime_r
cmp rax, 0
setnz al
and al, 1
add rsp, 18h
retn
| bool testing::internal::PortableLocaltime(long long a1)
{
long long v2; // [rsp+10h] [rbp-8h] BYREF
v2 = a1;
return localtime_r(&v2) != 0;
}
| PortableLocaltime:
SUB RSP,0x18
MOV qword ptr [RSP + 0x10],RDI
MOV qword ptr [RSP + 0x8],RSI
MOV RSI,qword ptr [RSP + 0x8]
LEA RDI,[RSP + 0x10]
CALL 0x00114360
CMP RAX,0x0
SETNZ AL
AND AL,0x1
ADD RSP,0x18
RET
|
/* testing::internal::PortableLocaltime(long, tm*) */
bool testing::internal::PortableLocaltime(long param_1,tm *param_2)
{
tm *ptVar1;
long local_8;
local_8 = param_1;
ptVar1 = localtime_r(&local_8,param_2);
return ptVar1 != (tm *)0x0;
}
| |
43,491 | js__pstrcat | bluesky950520[P]quickjs/cutils.c | char *js__pstrcat(char *buf, int buf_size, const char *s)
{
int len;
len = strlen(buf);
if (len < buf_size)
js__pstrcpy(buf + len, buf_size - len, s);
return buf;
} | O3 | c | js__pstrcat:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0xe240
subl %eax, %ebp
jle 0x1afa8
jle 0x1afa8
cltq
addq %rbx, %rax
movb (%r14), %cl
testb %cl, %cl
je 0x1afa5
movl %ebp, %edx
addq %rax, %rdx
decq %rdx
cmpq %rax, %rdx
jbe 0x1afa5
incq %r14
movb %cl, (%rax)
incq %rax
movb (%r14), %cl
testb %cl, %cl
je 0x1afa5
incq %r14
cmpq %rdx, %rax
jb 0x1af91
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
| js__pstrcat:
push rbp
push r14
push rbx
mov r14, rdx
mov ebp, esi
mov rbx, rdi
call _strlen
sub ebp, eax
jle short loc_1AFA8
jle short loc_1AFA8
cdqe
add rax, rbx
mov cl, [r14]
test cl, cl
jz short loc_1AFA5
mov edx, ebp
add rdx, rax
dec rdx
cmp rdx, rax
jbe short loc_1AFA5
inc r14
loc_1AF91:
mov [rax], cl
inc rax
mov cl, [r14]
test cl, cl
jz short loc_1AFA5
inc r14
cmp rax, rdx
jb short loc_1AF91
loc_1AFA5:
mov byte ptr [rax], 0
loc_1AFA8:
mov rax, rbx
pop rbx
pop r14
pop rbp
retn
| long long js__pstrcat(long long a1, int a2, char *a3)
{
int v4; // eax
int v5; // ebp
_BYTE *v6; // rax
char v7; // cl
unsigned long long v8; // rdx
char *v9; // r14
v4 = strlen(a1);
v5 = a2 - v4;
if ( a2 > v4 )
{
v6 = (_BYTE *)(a1 + v4);
v7 = *a3;
if ( *a3 )
{
v8 = (unsigned long long)&v6[v5 - 1];
if ( v8 > (unsigned long long)v6 )
{
v9 = a3 + 1;
do
{
*v6++ = v7;
v7 = *v9;
if ( !*v9 )
break;
++v9;
}
while ( (unsigned long long)v6 < v8 );
}
}
*v6 = 0;
}
return a1;
}
| js__pstrcat:
PUSH RBP
PUSH R14
PUSH RBX
MOV R14,RDX
MOV EBP,ESI
MOV RBX,RDI
CALL 0x0010e240
SUB EBP,EAX
JLE 0x0011afa8
JLE 0x0011afa8
CDQE
ADD RAX,RBX
MOV CL,byte ptr [R14]
TEST CL,CL
JZ 0x0011afa5
MOV EDX,EBP
ADD RDX,RAX
DEC RDX
CMP RDX,RAX
JBE 0x0011afa5
INC R14
LAB_0011af91:
MOV byte ptr [RAX],CL
INC RAX
MOV CL,byte ptr [R14]
TEST CL,CL
JZ 0x0011afa5
INC R14
CMP RAX,RDX
JC 0x0011af91
LAB_0011afa5:
MOV byte ptr [RAX],0x0
LAB_0011afa8:
MOV RAX,RBX
POP RBX
POP R14
POP RBP
RET
|
char * js__pstrcat(char *param_1,int param_2,char *param_3)
{
int iVar1;
size_t sVar2;
char *pcVar3;
char cVar4;
char *pcVar5;
uint uVar6;
sVar2 = strlen(param_1);
iVar1 = (int)sVar2;
uVar6 = param_2 - iVar1;
if ((uVar6 != 0 && iVar1 <= param_2) && (uVar6 != 0 && iVar1 <= param_2)) {
pcVar3 = param_1 + iVar1;
cVar4 = *param_3;
if ((cVar4 != '\0') && (pcVar5 = pcVar3 + ((ulong)uVar6 - 1), pcVar3 < pcVar5)) {
param_3 = param_3 + 1;
do {
*pcVar3 = cVar4;
pcVar3 = pcVar3 + 1;
cVar4 = *param_3;
if (cVar4 == '\0') break;
param_3 = param_3 + 1;
} while (pcVar3 < pcVar5);
}
*pcVar3 = '\0';
}
return param_1;
}
| |
43,492 | JS_AddIntrinsicRegExp | bluesky950520[P]quickjs/quickjs.c | void JS_AddIntrinsicRegExp(JSContext *ctx)
{
JSValue obj;
JS_AddIntrinsicRegExpCompiler(ctx);
ctx->class_proto[JS_CLASS_REGEXP] = JS_NewObject(ctx);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_REGEXP], js_regexp_proto_funcs,
countof(js_regexp_proto_funcs));
obj = JS_NewGlobalCConstructor(ctx, "RegExp", js_regexp_constructor, 2,
ctx->class_proto[JS_CLASS_REGEXP]);
ctx->regexp_ctor = js_dup(obj);
JS_SetPropertyFunctionList(ctx, obj, js_regexp_funcs, countof(js_regexp_funcs));
ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR] =
JS_NewObjectProto(ctx, ctx->class_proto[JS_CLASS_ITERATOR]);
JS_SetPropertyFunctionList(ctx, ctx->class_proto[JS_CLASS_REGEXP_STRING_ITERATOR],
js_regexp_string_iterator_proto_funcs,
countof(js_regexp_string_iterator_proto_funcs));
} | O1 | c | JS_AddIntrinsicRegExp:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x14be0(%rip), %rax # 0x3294e
movq %rax, 0x1f0(%rdi)
movq 0x40(%rdi), %r14
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rdx
movl $0x1, %ecx
callq 0x202f1
movq %rax, 0x120(%r14)
movq %rdx, 0x128(%r14)
movq 0x40(%rbx), %rax
movq 0x120(%rax), %rsi
movq 0x128(%rax), %rdx
leaq 0xa8ede(%rip), %rcx # 0xc6c90
movq %rbx, %rdi
movl $0x13, %r8d
callq 0x32053
movq 0x40(%rbx), %rax
movq 0x120(%rax), %r12
movq 0x128(%rax), %r13
movups 0x48(%rbx), %xmm0
movups %xmm0, (%rsp)
leaq 0x14e01(%rip), %rsi # 0x32be2
leaq 0x7f8dd(%rip), %rbp # 0x9d6c5
movq %rbx, %rdi
movq %rbp, %rdx
movl $0x2, %ecx
movl $0x4, %r8d
xorl %r9d, %r9d
callq 0x203f2
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %rbp, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x35596
movq %r14, 0x10(%rsp)
cmpl $-0x9, %r15d
jb 0x1de2d
movq 0x10(%rsp), %rax
incl (%rax)
movq %r14, 0x78(%rbx)
movq %r15, 0x80(%rbx)
leaq 0xa90b1(%rip), %rcx # 0xc6ef0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x2, %r8d
callq 0x32053
movq 0x40(%rbx), %r14
movq 0x270(%r14), %rsi
movq 0x278(%r14), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
callq 0x202f1
movq %rax, 0x2e0(%r14)
movq %rdx, 0x2e8(%r14)
movq 0x40(%rbx), %rax
movq 0x2e0(%rax), %rsi
movq 0x2e8(%rax), %rdx
leaq 0xa9097(%rip), %rcx # 0xc6f30
movq %rbx, %rdi
movl $0x2, %r8d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32053
| JS_AddIntrinsicRegExp:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 18h
mov rbx, rdi
lea rax, js_compile_regexp
mov [rdi+1F0h], rax
mov r14, [rdi+40h]
mov rsi, [r14+10h]
mov rdx, [r14+18h]
mov ecx, 1
call JS_NewObjectProtoClass
mov [r14+120h], rax
mov [r14+128h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+120h]
mov rdx, [rax+128h]
lea rcx, js_regexp_proto_funcs
mov rdi, rbx
mov r8d, 13h
call JS_SetPropertyFunctionList
mov rax, [rbx+40h]
mov r12, [rax+120h]
mov r13, [rax+128h]
movups xmm0, xmmword ptr [rbx+48h]
movups [rsp+48h+var_48], xmm0
lea rsi, js_regexp_constructor
lea rbp, aRegexp; "RegExp"
mov rdi, rbx
mov rdx, rbp
mov ecx, 2
mov r8d, 4
xor r9d, r9d
call JS_NewCFunction3
mov r14, rax
mov r15, rdx
mov rdi, rbx
mov rsi, rax
mov rcx, rbp
mov r8, r12
mov r9, r13
call JS_NewGlobalCConstructor2
mov [rsp+48h+var_38], r14
cmp r15d, 0FFFFFFF7h
jb short loc_1DE2D
mov rax, [rsp+48h+var_38]
inc dword ptr [rax]
loc_1DE2D:
mov [rbx+78h], r14
mov [rbx+80h], r15
lea rcx, js_regexp_funcs
mov rdi, rbx
mov rsi, r14
mov rdx, r15
mov r8d, 2
call JS_SetPropertyFunctionList
mov r14, [rbx+40h]
mov rsi, [r14+270h]
mov rdx, [r14+278h]
mov rdi, rbx
mov ecx, 1
call JS_NewObjectProtoClass
mov [r14+2E0h], rax
mov [r14+2E8h], rdx
mov rax, [rbx+40h]
mov rsi, [rax+2E0h]
mov rdx, [rax+2E8h]
lea rcx, js_regexp_string_iterator_proto_funcs
mov rdi, rbx
mov r8d, 2
add rsp, 18h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
jmp JS_SetPropertyFunctionList
| long long JS_AddIntrinsicRegExp(_QWORD *a1)
{
_QWORD *v1; // r14
long long v2; // rdx
long long v3; // rax
long long v4; // r12
long long v5; // r13
_DWORD *v6; // r14
long long v7; // rdx
long long v8; // r15
_QWORD *v9; // r14
long long v10; // rdx
a1[62] = js_compile_regexp;
v1 = (_QWORD *)a1[8];
v1[36] = JS_NewObjectProtoClass(a1, v1[2], v1[3], 1LL);
v1[37] = v2;
JS_SetPropertyFunctionList(a1, *(_QWORD *)(a1[8] + 288LL), *(_QWORD *)(a1[8] + 296LL), &js_regexp_proto_funcs, 19LL);
v3 = a1[8];
v4 = *(_QWORD *)(v3 + 288);
v5 = *(_QWORD *)(v3 + 296);
v6 = (_DWORD *)JS_NewCFunction3(
(_DWORD)a1,
(unsigned int)js_regexp_constructor,
(unsigned int)"RegExp",
2,
4,
0,
a1[9],
a1[10]);
v8 = v7;
JS_NewGlobalCConstructor2(a1, v6, v7, "RegExp", v4, v5);
if ( (unsigned int)v8 >= 0xFFFFFFF7 )
++*v6;
a1[15] = v6;
a1[16] = v8;
JS_SetPropertyFunctionList(a1, v6, v8, &js_regexp_funcs, 2LL);
v9 = (_QWORD *)a1[8];
v9[92] = JS_NewObjectProtoClass(a1, v9[78], v9[79], 1LL);
v9[93] = v10;
return JS_SetPropertyFunctionList(
a1,
*(_QWORD *)(a1[8] + 736LL),
*(_QWORD *)(a1[8] + 744LL),
&js_regexp_string_iterator_proto_funcs,
2LL);
}
| JS_AddIntrinsicRegExp:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x18
MOV RBX,RDI
LEA RAX,[0x13294e]
MOV qword ptr [RDI + 0x1f0],RAX
MOV R14,qword ptr [RDI + 0x40]
MOV RSI,qword ptr [R14 + 0x10]
MOV RDX,qword ptr [R14 + 0x18]
MOV ECX,0x1
CALL 0x001202f1
MOV qword ptr [R14 + 0x120],RAX
MOV qword ptr [R14 + 0x128],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0x120]
MOV RDX,qword ptr [RAX + 0x128]
LEA RCX,[0x1c6c90]
MOV RDI,RBX
MOV R8D,0x13
CALL 0x00132053
MOV RAX,qword ptr [RBX + 0x40]
MOV R12,qword ptr [RAX + 0x120]
MOV R13,qword ptr [RAX + 0x128]
MOVUPS XMM0,xmmword ptr [RBX + 0x48]
MOVUPS xmmword ptr [RSP],XMM0
LEA RSI,[0x132be2]
LEA RBP,[0x19d6c5]
MOV RDI,RBX
MOV RDX,RBP
MOV ECX,0x2
MOV R8D,0x4
XOR R9D,R9D
CALL 0x001203f2
MOV R14,RAX
MOV R15,RDX
MOV RDI,RBX
MOV RSI,RAX
MOV RCX,RBP
MOV R8,R12
MOV R9,R13
CALL 0x00135596
MOV qword ptr [RSP + 0x10],R14
CMP R15D,-0x9
JC 0x0011de2d
MOV RAX,qword ptr [RSP + 0x10]
INC dword ptr [RAX]
LAB_0011de2d:
MOV qword ptr [RBX + 0x78],R14
MOV qword ptr [RBX + 0x80],R15
LEA RCX,[0x1c6ef0]
MOV RDI,RBX
MOV RSI,R14
MOV RDX,R15
MOV R8D,0x2
CALL 0x00132053
MOV R14,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [R14 + 0x270]
MOV RDX,qword ptr [R14 + 0x278]
MOV RDI,RBX
MOV ECX,0x1
CALL 0x001202f1
MOV qword ptr [R14 + 0x2e0],RAX
MOV qword ptr [R14 + 0x2e8],RDX
MOV RAX,qword ptr [RBX + 0x40]
MOV RSI,qword ptr [RAX + 0x2e0]
MOV RDX,qword ptr [RAX + 0x2e8]
LEA RCX,[0x1c6f30]
MOV RDI,RBX
MOV R8D,0x2
ADD RSP,0x18
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
JMP 0x00132053
|
void JS_AddIntrinsicRegExp(long param_1)
{
long lVar1;
int8 uVar2;
int8 uVar3;
int *piVar4;
int1 auVar5 [16];
*(code **)(param_1 + 0x1f0) = js_compile_regexp;
lVar1 = *(long *)(param_1 + 0x40);
auVar5 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x10),*(int8 *)(lVar1 + 0x18),1);
*(int1 (*) [16])(lVar1 + 0x120) = auVar5;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x120),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x128),js_regexp_proto_funcs,0x13);
uVar2 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x120);
uVar3 = *(int8 *)(*(long *)(param_1 + 0x40) + 0x128);
auVar5 = JS_NewCFunction3(param_1,js_regexp_constructor,"RegExp",2,4,0,
*(int4 *)(param_1 + 0x48),*(int4 *)(param_1 + 0x50));
piVar4 = auVar5._0_8_;
JS_NewGlobalCConstructor2(param_1,piVar4,auVar5._8_8_,"RegExp",uVar2,uVar3);
if (0xfffffff6 < auVar5._8_4_) {
*piVar4 = *piVar4 + 1;
}
*(int1 (*) [16])(param_1 + 0x78) = auVar5;
JS_SetPropertyFunctionList(param_1,piVar4,auVar5._8_8_,js_regexp_funcs,2);
lVar1 = *(long *)(param_1 + 0x40);
auVar5 = JS_NewObjectProtoClass
(param_1,*(int8 *)(lVar1 + 0x270),*(int8 *)(lVar1 + 0x278),1);
*(int1 (*) [16])(lVar1 + 0x2e0) = auVar5;
JS_SetPropertyFunctionList
(param_1,*(int8 *)(*(long *)(param_1 + 0x40) + 0x2e0),
*(int8 *)(*(long *)(param_1 + 0x40) + 0x2e8),
js_regexp_string_iterator_proto_funcs,2);
return;
}
| |
43,493 | slide_hash | 3fs/build_O3/src/apache-arrow-cpp/cpp/zlib_ep-prefix/src/zlib_ep/deflate.c | local void slide_hash(s)
deflate_state *s;
{
unsigned n, m;
Posf *p;
uInt wsize = s->w_size;
n = s->hash_size;
p = &s->head[n];
do {
m = *--p;
*p = (Pos)(m >= wsize ? m - wsize : NIL);
} while (--n);
n = wsize;
#ifndef FASTEST
p = &s->prev[n];
do {
m = *--p;
*p = (Pos)(m >= wsize ? m - wsize : NIL);
/* If n is not on any hash chain, prev[n] is garbage but
* its value will never be used.
*/
} while (--n);
#endif
} | O3 | c | slide_hash:
movl 0x50(%rdi), %eax
movl 0x84(%rdi), %ecx
movq 0x78(%rdi), %rdx
leaq (%rdx,%rcx,2), %rdx
addq $-0x2, %rdx
xorl %esi, %esi
movzwl (%rdx), %r8d
subl %eax, %r8d
cmovbl %esi, %r8d
movw %r8w, (%rdx)
addq $-0x2, %rdx
decl %ecx
jne 0x5581
movq 0x70(%rdi), %rcx
leaq (%rcx,%rax,2), %rcx
addq $-0x2, %rcx
xorl %edx, %edx
movl %eax, %esi
movzwl (%rcx), %edi
subl %eax, %edi
cmovbl %edx, %edi
movw %di, (%rcx)
addq $-0x2, %rcx
decl %esi
jne 0x55a8
retq
| slide_hash:
mov eax, [rdi+50h]
mov ecx, [rdi+84h]
mov rdx, [rdi+78h]
lea rdx, [rdx+rcx*2]
add rdx, 0FFFFFFFFFFFFFFFEh
xor esi, esi
loc_5581:
movzx r8d, word ptr [rdx]
sub r8d, eax
cmovb r8d, esi
mov [rdx], r8w
add rdx, 0FFFFFFFFFFFFFFFEh
dec ecx
jnz short loc_5581
mov rcx, [rdi+70h]
lea rcx, [rcx+rax*2]
add rcx, 0FFFFFFFFFFFFFFFEh
xor edx, edx
mov esi, eax
loc_55A8:
movzx edi, word ptr [rcx]
sub edi, eax
cmovb edi, edx
mov [rcx], di
add rcx, 0FFFFFFFFFFFFFFFEh
dec esi
jnz short loc_55A8
retn
| long long slide_hash(long long a1)
{
long long result; // rax
long long v2; // rcx
_WORD *v3; // rdx
unsigned int v4; // r8d
bool v5; // cf
__int16 v6; // r8
_WORD *v7; // rcx
int v8; // esi
unsigned int v9; // edi
__int16 v10; // di
result = *(unsigned int *)(a1 + 80);
v2 = *(unsigned int *)(a1 + 132);
v3 = (_WORD *)(*(_QWORD *)(a1 + 120) + 2 * v2 - 2);
do
{
v4 = (unsigned __int16)*v3;
v5 = v4 < (unsigned int)result;
v6 = v4 - result;
if ( v5 )
v6 = 0;
*v3-- = v6;
LODWORD(v2) = v2 - 1;
}
while ( (_DWORD)v2 );
v7 = (_WORD *)(*(_QWORD *)(a1 + 112) + 2 * result - 2);
v8 = result;
do
{
v9 = (unsigned __int16)*v7;
v5 = v9 < (unsigned int)result;
v10 = v9 - result;
if ( v5 )
v10 = 0;
*v7-- = v10;
--v8;
}
while ( v8 );
return result;
}
| slide_hash:
MOV EAX,dword ptr [RDI + 0x50]
MOV ECX,dword ptr [RDI + 0x84]
MOV RDX,qword ptr [RDI + 0x78]
LEA RDX,[RDX + RCX*0x2]
ADD RDX,-0x2
XOR ESI,ESI
LAB_00105581:
MOVZX R8D,word ptr [RDX]
SUB R8D,EAX
CMOVC R8D,ESI
MOV word ptr [RDX],R8W
ADD RDX,-0x2
DEC ECX
JNZ 0x00105581
MOV RCX,qword ptr [RDI + 0x70]
LEA RCX,[RCX + RAX*0x2]
ADD RCX,-0x2
XOR EDX,EDX
MOV ESI,EAX
LAB_001055a8:
MOVZX EDI,word ptr [RCX]
SUB EDI,EAX
CMOVC EDI,EDX
MOV word ptr [RCX],DI
ADD RCX,-0x2
DEC ESI
JNZ 0x001055a8
RET
|
void slide_hash(long param_1)
{
uint uVar1;
uint uVar2;
ulong uVar3;
ushort *puVar4;
ushort uVar5;
uVar1 = *(uint *)(param_1 + 0x50);
uVar3 = (ulong)*(uint *)(param_1 + 0x84);
puVar4 = (ushort *)(*(long *)(param_1 + 0x78) + uVar3 * 2);
do {
puVar4 = puVar4 + -1;
uVar5 = *puVar4 - (short)uVar1;
if (*puVar4 < uVar1) {
uVar5 = 0;
}
*puVar4 = uVar5;
uVar2 = (int)uVar3 - 1;
uVar3 = (ulong)uVar2;
} while (uVar2 != 0);
puVar4 = (ushort *)(*(long *)(param_1 + 0x70) + (ulong)uVar1 * 2);
uVar2 = uVar1;
do {
puVar4 = puVar4 + -1;
uVar5 = *puVar4 - (short)uVar1;
if (*puVar4 < uVar1) {
uVar5 = 0;
}
*puVar4 = uVar5;
uVar2 = uVar2 - 1;
} while (uVar2 != 0);
return;
}
| |
43,494 | llama_kv_cache_view_free | monkey531[P]llama/src/llama-kv-cache.cpp | void llama_kv_cache_view_free(struct llama_kv_cache_view * view) {
if (view->cells != nullptr) {
free(view->cells);
view->cells = nullptr;
}
if (view->cells_sequences != nullptr) {
free(view->cells_sequences);
view->cells_sequences = nullptr;
}
} | O3 | cpp | llama_kv_cache_view_free:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xac0d2
callq 0x68d40
movq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xac0e8
callq 0x68d40
movq $0x0, 0x20(%rbx)
popq %rbx
retq
| llama_kv_cache_view_free:
push rbx
mov rbx, rdi
mov rdi, [rdi+18h]
test rdi, rdi
jz short loc_AC0D2
call _free
mov qword ptr [rbx+18h], 0
loc_AC0D2:
mov rdi, [rbx+20h]
test rdi, rdi
jz short loc_AC0E8
call _free
mov qword ptr [rbx+20h], 0
loc_AC0E8:
pop rbx
retn
| long long llama_kv_cache_view_free(long long a1)
{
long long v2; // rdi
long long result; // rax
long long v4; // rdi
v2 = *(_QWORD *)(a1 + 24);
if ( v2 )
{
result = free(v2);
*(_QWORD *)(a1 + 24) = 0LL;
}
v4 = *(_QWORD *)(a1 + 32);
if ( v4 )
{
result = free(v4);
*(_QWORD *)(a1 + 32) = 0LL;
}
return result;
}
| llama_kv_cache_view_free:
PUSH RBX
MOV RBX,RDI
MOV RDI,qword ptr [RDI + 0x18]
TEST RDI,RDI
JZ 0x001ac0d2
CALL 0x00168d40
MOV qword ptr [RBX + 0x18],0x0
LAB_001ac0d2:
MOV RDI,qword ptr [RBX + 0x20]
TEST RDI,RDI
JZ 0x001ac0e8
CALL 0x00168d40
MOV qword ptr [RBX + 0x20],0x0
LAB_001ac0e8:
POP RBX
RET
|
void llama_kv_cache_view_free(long param_1)
{
if (*(void **)(param_1 + 0x18) != (void *)0x0) {
free(*(void **)(param_1 + 0x18));
*(int8 *)(param_1 + 0x18) = 0;
}
if (*(void **)(param_1 + 0x20) != (void *)0x0) {
free(*(void **)(param_1 + 0x20));
*(int8 *)(param_1 + 0x20) = 0;
}
return;
}
| |
43,495 | my_charlen_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_charlen_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
return 4;
}
return MY_CS_ILSEQ;
} | O0 | c | my_charlen_utf8mb4:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x13c7ca
movl $0xffffff9b, -0x4(%rbp) # imm = 0xFFFFFF9B
jmp 0x13c89f
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xf0, %eax
jge 0x13c7f3
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13cff0
movl %eax, -0x4(%rbp)
jmp 0x13c89f
movzbl -0x21(%rbp), %eax
cmpl $0xf5, %eax
jge 0x13c898
movq -0x18(%rbp), %rax
addq $0x4, %rax
cmpq -0x20(%rbp), %rax
jbe 0x13c81c
movl $0xffffff98, -0x4(%rbp) # imm = 0xFFFFFF98
jmp 0x13c89f
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x13c886
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x13c886
movq -0x18(%rbp), %rax
movzbl 0x3(%rax), %eax
xorl $0x80, %eax
cmpl $0x40, %eax
jge 0x13c886
movzbl -0x21(%rbp), %eax
cmpl $0xf1, %eax
jge 0x13c86c
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x90, %eax
jl 0x13c886
movzbl -0x21(%rbp), %eax
cmpl $0xf3, %eax
jle 0x13c88f
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x8f, %eax
jle 0x13c88f
movl $0x0, -0x4(%rbp)
jmp 0x13c89f
movl $0x4, -0x4(%rbp)
jmp 0x13c89f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| my_charlen_utf8mb4:
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_10], rdi
mov [rbp+var_18], rsi
mov [rbp+var_20], rdx
mov rax, [rbp+var_18]
cmp rax, [rbp+var_20]
jb short loc_13C7CA
mov [rbp+var_4], 0FFFFFF9Bh
jmp loc_13C89F
loc_13C7CA:
mov rax, [rbp+var_18]
mov al, [rax]
mov [rbp+var_21], al
movzx eax, [rbp+var_21]
cmp eax, 0F0h
jge short loc_13C7F3
mov rdi, [rbp+var_18]
mov rsi, [rbp+var_20]
call my_valid_mbcharlen_utf8mb3
mov [rbp+var_4], eax
jmp loc_13C89F
loc_13C7F3:
movzx eax, [rbp+var_21]
cmp eax, 0F5h
jge loc_13C898
mov rax, [rbp+var_18]
add rax, 4
cmp rax, [rbp+var_20]
jbe short loc_13C81C
mov [rbp+var_4], 0FFFFFF98h
jmp loc_13C89F
loc_13C81C:
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_13C886
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+2]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_13C886
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+3]
xor eax, 80h
cmp eax, 40h ; '@'
jge short loc_13C886
movzx eax, [rbp+var_21]
cmp eax, 0F1h
jge short loc_13C86C
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 90h
jl short loc_13C886
loc_13C86C:
movzx eax, [rbp+var_21]
cmp eax, 0F3h
jle short loc_13C88F
mov rax, [rbp+var_18]
movzx eax, byte ptr [rax+1]
cmp eax, 8Fh
jle short loc_13C88F
loc_13C886:
mov [rbp+var_4], 0
jmp short loc_13C89F
loc_13C88F:
mov [rbp+var_4], 4
jmp short loc_13C89F
loc_13C898:
mov [rbp+var_4], 0
loc_13C89F:
mov eax, [rbp+var_4]
add rsp, 30h
pop rbp
retn
| long long my_charlen_utf8mb4(long long a1, unsigned __int8 *a2, unsigned long long a3)
{
unsigned __int8 v4; // [rsp+Fh] [rbp-21h]
if ( (unsigned long long)a2 < a3 )
{
v4 = *a2;
if ( *a2 >= 0xF0u )
{
if ( v4 >= 0xF5u )
{
return 0;
}
else if ( (unsigned long long)(a2 + 4) <= a3 )
{
if ( (a2[1] ^ 0x80) < 64
&& (a2[2] ^ 0x80) < 64
&& (a2[3] ^ 0x80) < 64
&& (v4 >= 0xF1u || a2[1] >= 0x90u)
&& (v4 <= 0xF3u || a2[1] <= 0x8Fu) )
{
return 4;
}
else
{
return 0;
}
}
else
{
return (unsigned int)-104;
}
}
else
{
return (unsigned int)my_valid_mbcharlen_utf8mb3(a2, a3);
}
}
else
{
return (unsigned int)-101;
}
}
| |||
43,496 | my_charlen_utf8mb4 | eloqsql/strings/ctype-utf8.c | static int
my_charlen_utf8mb4(CHARSET_INFO *cs __attribute__((unused)),
const uchar *s, const uchar *e)
{
uchar c;
if (s >= e)
return MY_CS_TOOSMALL;
c= s[0];
if (c < 0xf0)
return my_valid_mbcharlen_utf8mb3(s, e);
if (c < 0xf5)
{
if (s + 4 > e) /* We need 4 characters */
return MY_CS_TOOSMALL4;
if (!IS_UTF8MB4_STEP2(c, s[1], s[2], s[3]))
return MY_CS_ILSEQ;
return 4;
}
return MY_CS_ILSEQ;
} | O3 | c | my_charlen_utf8mb4:
pushq %rbp
movq %rsp, %rbp
movl $0xffffff9b, %eax # imm = 0xFFFFFF9B
cmpq %rdx, %rsi
jae 0xcc506
movb (%rsi), %cl
cmpb $-0x11, %cl
ja 0xcc472
movl $0x1, %eax
testb %cl, %cl
jns 0xcc506
cmpb $-0x3e, %cl
jb 0xcc504
cmpb $-0x21, %cl
ja 0xcc4cb
leaq 0x2(%rsi), %rcx
movl $0xffffff9a, %eax # imm = 0xFFFFFF9A
cmpq %rdx, %rcx
ja 0xcc506
xorl %eax, %eax
cmpb $-0x40, 0x1(%rsi)
setl %al
addl %eax, %eax
jmp 0xcc506
cmpb $-0xc, %cl
ja 0xcc504
leaq 0x4(%rsi), %rdi
movl $0xffffff98, %eax # imm = 0xFFFFFF98
cmpq %rdx, %rdi
ja 0xcc506
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0xcc504
cmpb $-0x41, 0x2(%rsi)
jg 0xcc504
cmpb $-0x41, 0x3(%rsi)
jg 0xcc504
cmpb $-0x10, %cl
sete %sil
cmpb $-0x70, %dl
setb %dil
movl $0x0, %eax
testb %dil, %sil
jne 0xcc506
cmpb $-0xc, %cl
setne %al
cmpb $-0x70, %dl
setb %cl
orb %al, %cl
movzbl %cl, %eax
shll $0x2, %eax
jmp 0xcc506
leaq 0x3(%rsi), %rdi
movl $0xffffff99, %eax # imm = 0xFFFFFF99
cmpq %rdx, %rdi
ja 0xcc506
movb 0x1(%rsi), %dl
cmpb $-0x41, %dl
jg 0xcc504
cmpb $-0x41, 0x2(%rsi)
movl $0x0, %eax
jg 0xcc506
xorl %eax, %eax
cmpb $-0x60, %dl
setae %al
cmpb $-0x20, %cl
leal (%rax,%rax,2), %ecx
movl $0x3, %eax
cmovel %ecx, %eax
jmp 0xcc506
xorl %eax, %eax
popq %rbp
retq
| my_charlen_utf8mb4:
push rbp
mov rbp, rsp
mov eax, 0FFFFFF9Bh
cmp rsi, rdx
jnb loc_CC506
mov cl, [rsi]
cmp cl, 0EFh
ja short loc_CC472
mov eax, 1
test cl, cl
jns loc_CC506
cmp cl, 0C2h
jb loc_CC504
cmp cl, 0DFh
ja short loc_CC4CB
lea rcx, [rsi+2]
mov eax, 0FFFFFF9Ah
cmp rcx, rdx
ja loc_CC506
xor eax, eax
cmp byte ptr [rsi+1], 0C0h
setl al
add eax, eax
jmp loc_CC506
loc_CC472:
cmp cl, 0F4h
ja loc_CC504
lea rdi, [rsi+4]
mov eax, 0FFFFFF98h
cmp rdi, rdx
ja short loc_CC506
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_CC504
cmp byte ptr [rsi+2], 0BFh
jg short loc_CC504
cmp byte ptr [rsi+3], 0BFh
jg short loc_CC504
cmp cl, 0F0h
setz sil
cmp dl, 90h
setb dil
mov eax, 0
test sil, dil
jnz short loc_CC506
cmp cl, 0F4h
setnz al
cmp dl, 90h
setb cl
or cl, al
movzx eax, cl
shl eax, 2
jmp short loc_CC506
loc_CC4CB:
lea rdi, [rsi+3]
mov eax, 0FFFFFF99h
cmp rdi, rdx
ja short loc_CC506
mov dl, [rsi+1]
cmp dl, 0BFh
jg short loc_CC504
cmp byte ptr [rsi+2], 0BFh
mov eax, 0
jg short loc_CC506
xor eax, eax
cmp dl, 0A0h
setnb al
cmp cl, 0E0h
lea ecx, [rax+rax*2]
mov eax, 3
cmovz eax, ecx
jmp short loc_CC506
loc_CC504:
xor eax, eax
loc_CC506:
pop rbp
retn
| long long my_charlen_utf8mb4(long long a1, char *a2, unsigned long long a3)
{
long long result; // rax
char v4; // cl
char v5; // dl
char v6; // dl
result = 4294967195LL;
if ( (unsigned long long)a2 >= a3 )
return result;
v4 = *a2;
if ( (unsigned __int8)*a2 <= 0xEFu )
{
result = 1LL;
if ( v4 >= 0 )
return result;
if ( (unsigned __int8)v4 >= 0xC2u )
{
if ( (unsigned __int8)v4 <= 0xDFu )
{
result = 4294967194LL;
if ( (unsigned long long)(a2 + 2) <= a3 )
return 2 * (unsigned int)(a2[1] < -64);
return result;
}
result = 4294967193LL;
if ( (unsigned long long)(a2 + 3) > a3 )
return result;
v6 = a2[1];
if ( v6 <= -65 )
{
result = 0LL;
if ( a2[2] <= -65 )
{
result = 3LL;
if ( v4 == -32 )
return 3 * (unsigned int)((unsigned __int8)v6 >= 0xA0u);
}
return result;
}
}
return 0LL;
}
if ( (unsigned __int8)v4 > 0xF4u )
return 0LL;
result = 4294967192LL;
if ( (unsigned long long)(a2 + 4) > a3 )
return result;
v5 = a2[1];
if ( v5 > -65 || a2[2] > -65 || a2[3] > -65 )
return 0LL;
result = 0LL;
if ( (unsigned __int8)v5 >= 0x90u || v4 != -16 )
return 4 * (unsigned int)(v4 != -12 || (unsigned __int8)v5 < 0x90u);
return result;
}
| my_charlen_utf8mb4:
PUSH RBP
MOV RBP,RSP
MOV EAX,0xffffff9b
CMP RSI,RDX
JNC 0x001cc506
MOV CL,byte ptr [RSI]
CMP CL,0xef
JA 0x001cc472
MOV EAX,0x1
TEST CL,CL
JNS 0x001cc506
CMP CL,0xc2
JC 0x001cc504
CMP CL,0xdf
JA 0x001cc4cb
LEA RCX,[RSI + 0x2]
MOV EAX,0xffffff9a
CMP RCX,RDX
JA 0x001cc506
XOR EAX,EAX
CMP byte ptr [RSI + 0x1],0xc0
SETL AL
ADD EAX,EAX
JMP 0x001cc506
LAB_001cc472:
CMP CL,0xf4
JA 0x001cc504
LEA RDI,[RSI + 0x4]
MOV EAX,0xffffff98
CMP RDI,RDX
JA 0x001cc506
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cc504
CMP byte ptr [RSI + 0x2],0xbf
JG 0x001cc504
CMP byte ptr [RSI + 0x3],0xbf
JG 0x001cc504
CMP CL,0xf0
SETZ SIL
CMP DL,0x90
SETC DIL
MOV EAX,0x0
TEST SIL,DIL
JNZ 0x001cc506
CMP CL,0xf4
SETNZ AL
CMP DL,0x90
SETC CL
OR CL,AL
MOVZX EAX,CL
SHL EAX,0x2
JMP 0x001cc506
LAB_001cc4cb:
LEA RDI,[RSI + 0x3]
MOV EAX,0xffffff99
CMP RDI,RDX
JA 0x001cc506
MOV DL,byte ptr [RSI + 0x1]
CMP DL,0xbf
JG 0x001cc504
CMP byte ptr [RSI + 0x2],0xbf
MOV EAX,0x0
JG 0x001cc506
XOR EAX,EAX
CMP DL,0xa0
SETNC AL
CMP CL,0xe0
LEA ECX,[RAX + RAX*0x2]
MOV EAX,0x3
CMOVZ EAX,ECX
JMP 0x001cc506
LAB_001cc504:
XOR EAX,EAX
LAB_001cc506:
POP RBP
RET
|
ulong my_charlen_utf8mb4(int8 param_1,byte *param_2,byte *param_3)
{
byte bVar1;
byte bVar2;
if (param_3 <= param_2) {
return 0xffffff9b;
}
bVar1 = *param_2;
if (bVar1 < 0xf0) {
if (-1 < (char)bVar1) {
return 1;
}
if (0xc1 < bVar1) {
if (bVar1 < 0xe0) {
if (param_3 < param_2 + 2) {
return 0xffffff9a;
}
return (ulong)((uint)((char)param_2[1] < -0x40) * 2);
}
if (param_3 < param_2 + 3) {
return 0xffffff99;
}
if ((char)param_2[1] < -0x40) {
if (-0x41 < (char)param_2[2]) {
return 0;
}
if (bVar1 != 0xe0) {
return 3;
}
return (ulong)((uint)(0x9f < param_2[1]) * 3);
}
}
}
else if (bVar1 < 0xf5) {
if (param_3 < param_2 + 4) {
return 0xffffff98;
}
bVar2 = param_2[1];
if ((((char)bVar2 < -0x40) && ((char)param_2[2] < -0x40)) && ((char)param_2[3] < -0x40)) {
if (bVar1 == 0xf0 && bVar2 < 0x90) {
return 0;
}
return (ulong)(bVar2 < 0x90 || bVar1 != 0xf4) << 2;
}
}
return 0;
}
| |
43,497 | expect_tool_parameters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) | monkey531[P]llama/common/chat.cpp | static void expect_tool_parameters(const std::string & name, const json & parameters, const std::vector<std::string> & expected_properties) {
if (!parameters.is_object() || !parameters.contains("type") || parameters["type"] != "object" || !parameters.contains("properties") || !parameters.contains("required")) {
throw std::runtime_error("Parameters of tool " + name + " must be an object w/ required properties");
}
const auto & parameters_properties = parameters.at("properties");
const auto & parameters_required = parameters.at("required");
for (const auto & prop : expected_properties) {
if (!parameters_properties.contains(prop)) {
throw std::runtime_error("Parameters of tool " + name + " is missing property: " + prop);
}
if (std::find(parameters_required.begin(), parameters_required.end(), json(prop)) == parameters_required.end()) {
throw std::runtime_error("Parameters of tool " + name + " must have property marked as required: " + prop);
}
}
if (parameters_properties.size() != expected_properties.size()) {
throw std::runtime_error("Parameters of tool " + name + " must only have these properties:" + string_join(expected_properties, ", "));
}
} | O2 | cpp | expect_tool_parameters(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&):
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x8(%rsp)
cmpb $0x1, (%rsi)
jne 0x7e375
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x1af00(%rip), %rsi # 0x99015
movq %rbx, %rdi
callq 0x5f34c
testb %al, %al
je 0x7e375
leaq 0x1aee9(%rip), %rsi # 0x99015
movq %rbx, %rdi
callq 0x6012a
leaq 0x20ae5(%rip), %rsi # 0x9ec20
movq %rax, %rdi
callq 0x5fcf4
testb %al, %al
jne 0x7e375
leaq 0x29f38(%rip), %rsi # 0xa808a
movq %rbx, %rdi
callq 0x5f4d4
testb %al, %al
je 0x7e375
leaq 0x1aefa(%rip), %rsi # 0x99063
movq %rbx, %rdi
callq 0x82f46
testb %al, %al
je 0x7e375
leaq 0x29f0a(%rip), %rsi # 0xa808a
movq %rbx, %rdi
callq 0x83596
movq %rax, 0x58(%rsp)
leaq 0x1aecf(%rip), %rsi # 0x99063
movq %rbx, %rdi
callq 0x5fe80
movq %rax, %r13
movq (%r14), %r15
movq %r14, 0x50(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x80(%rsp)
leaq 0x60(%rsp), %r14
leaq 0x30(%rsp), %rbp
cmpq 0x80(%rsp), %r15
je 0x7e254
movq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0x836ea
testb %al, %al
je 0x7e2ff
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x48baa
leaq 0xc8(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x48e06
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b676
movq %rbp, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x8370c
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x48e06
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x48c30
movl %eax, %ebx
movq %r14, %rdi
callq 0x45632
testb %bl, %bl
jne 0x7e289
addq $0x20, %r15
jmp 0x7e1bd
movq 0x58(%rsp), %rdi
callq 0x44824
movq 0x50(%rsp), %rdx
movq 0x8(%rdx), %rcx
subq (%rdx), %rcx
sarq $0x5, %rcx
cmpq %rcx, %rax
jne 0x7e3d9
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x29dbc(%rip), %rsi # 0xa8057
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x302a9
leaq 0x29dfb(%rip), %rdx # 0xa80ac
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x40743
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x5a58d
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x63cfd(%rip), %rsi # 0xe1fe8
movq 0x63c7e(%rip), %rdx # 0xe1f70
movq %r14, %rdi
callq 0x20b30
jmp 0x7e482
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x29d46(%rip), %rsi # 0xa8057
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x302a9
leaq 0x29d6e(%rip), %rdx # 0xa8095
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x40743
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r15, %rdx
callq 0x5a58d
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x63c87(%rip), %rsi # 0xe1fe8
movq 0x63c08(%rip), %rdx # 0xe1f70
movq %r14, %rdi
callq 0x20b30
jmp 0x7e482
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r14
leaq 0x29cd0(%rip), %rsi # 0xa8057
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x302a9
leaq 0x29cce(%rip), %rdx # 0xa806b
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40743
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x63c23(%rip), %rsi # 0xe1fe8
movq 0x63ba4(%rip), %rdx # 0xe1f70
movq %r14, %rdi
callq 0x20b30
jmp 0x7e482
pushq $0x10
popq %rdi
callq 0x20390
movq %rax, %r15
leaq 0x29c6c(%rip), %rsi # 0xa8057
leaq 0x60(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x302a9
leaq 0x29cd4(%rip), %rdx # 0xa80d5
leaq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x40743
leaq 0x280e6(%rip), %rsi # 0xa64fd
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x262e2
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
movq 0x50(%rsp), %rsi
callq 0x6c17e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x40762
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x20aa0
xorl %ebp, %ebp
movq 0x63b75(%rip), %rsi # 0xe1fe8
movq 0x63af6(%rip), %rdx # 0xe1f70
movq %r15, %rdi
callq 0x20b30
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d78
jmp 0x7e497
movq %rax, %rbx
movb $0x1, %bpl
leaq 0xa8(%rsp), %rdi
callq 0x20d78
jmp 0x7e4ac
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x88(%rsp), %rdi
callq 0x20d78
jmp 0x7e4c1
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x20d78
jmp 0x7e4d3
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x20d78
testb %bpl, %bpl
jne 0x7e4ea
jmp 0x7e569
movq %rax, %rbx
movq %r15, %rdi
jmp 0x7e553
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d78
jmp 0x7e504
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
jmp 0x7e53f
jmp 0x7e54d
jmp 0x7e511
jmp 0x7e520
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d78
jmp 0x7e526
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x20d78
jmp 0x7e53a
jmp 0x7e534
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x60(%rsp), %rdi
callq 0x20d78
testb %bpl, %bpl
jne 0x7e550
jmp 0x7e569
jmp 0x7e54d
movq %rax, %rbx
movq %r14, %rdi
callq 0x20520
jmp 0x7e569
jmp 0x7e55c
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x45632
movq %rbx, %rdi
callq 0x20b90
nop
| _ZL22expect_tool_parametersRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEERKN8nlohmann16json_abi_v3_11_310basic_jsonINS8_11ordered_mapESt6vectorS4_blmdSaNS8_14adl_serializerESB_IhSaIhEEvEERKSB_IS4_SaIS4_EE:
push rbp
push r15
push r14
push r13
push r12
push rbx
sub rsp, 108h
mov [rsp+138h+var_130], rdi
cmp byte ptr [rsi], 1
jnz loc_7E375
mov r14, rdx
mov rbx, rsi
lea rsi, aType; "type"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_7E375
lea rsi, aType; "type"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEixIKcEERKSD_PT_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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[]<char const>(char const *)
lea rsi, aIsNotAnObject+0Ch; "object"
mov rdi, rax
call _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
test al, al
jnz loc_7E375
lea rsi, aMustBeAnObject+1Fh; "properties"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_7E375
lea rsi, aRequired; "required"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
test al, al
jz loc_7E375
lea rsi, aMustBeAnObject+1Fh; "properties"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov [rsp+138h+var_E0], rax
lea rsi, aRequired; "required"
mov rdi, rbx
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
mov r13, rax
mov r15, [r14]
mov [rsp+138h+var_E8], r14
mov rax, [r14+8]
mov [rsp+138h+var_B8], rax
lea r14, [rsp+138h+var_D8]
lea rbp, [rsp+138h+var_108]
loc_7E1BD:
cmp r15, [rsp+138h+var_B8]
jz loc_7E254
mov rdi, [rsp+138h+var_E0]
mov rsi, r15
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsERKS9_; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::contains(std::string const&)
test al, al
jz loc_7E2FF
lea rbx, [rsp+138h+var_50]
mov rdi, rbx
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE6cbeginEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cbegin(void)
lea r12, [rsp+138h+var_70]
mov rdi, r12
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cend(void)
mov rdi, r14
mov rsi, r15
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
mov rdi, rbp
mov rsi, rbx
mov rdx, r12
mov rcx, r14
call _ZSt4findIN8nlohmann16json_abi_v3_11_36detail9iter_implIKNS1_10basic_jsonINS1_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS1_14adl_serializerES6_IhSaIhEEvEEEESG_ET_SJ_SJ_RKT0_; std::find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>>(nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void> const&)
lea rbx, [rsp+138h+var_128]
mov rdi, rbx
mov rsi, r13
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4cendEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::cend(void)
mov rdi, rbp
mov rsi, rbx
call _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
mov ebx, eax
mov rdi, r14
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
test bl, bl
jnz short loc_7E289
add r15, 20h ; ' '
jmp loc_7E1BD
loc_7E254:
mov rdi, [rsp+138h+var_E0]
call _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4sizeEv; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::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 rdx, [rsp+138h+var_E8]
mov rcx, [rdx+8]
sub rcx, [rdx]
sar rcx, 5
cmp rax, rcx
jnz loc_7E3D9
add rsp, 108h
pop rbx
pop r12
pop r13
pop r14
pop r15
pop rbp
retn
loc_7E289:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustHaveProper; " must have property marked as required:"...
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_7E482
loc_7E2FF:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aIsMissingPrope; " is missing property: "
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
mov rdx, r15
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_RKS8_; std::operator+<char>(std::string&&,std::string const&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_7E482
loc_7E375:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r14, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_128]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustBeAnObject; " must be an object w/ required properti"...
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r14
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r14; void *
call ___cxa_throw
jmp loc_7E482
loc_7E3D9:
push 10h
pop rdi; thrown_size
call ___cxa_allocate_exception
mov r15, rax
lea rsi, aParametersOfTo; "Parameters of tool "
lea rdi, [rsp+138h+var_D8]
mov rdx, [rsp+138h+var_130]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEPKS5_RKS8_; std::operator+<char>(char const*,std::string const&)
lea rdx, aMustOnlyHaveTh; " must only have these properties:"
lea rdi, [rsp+138h+var_128]
lea rsi, [rsp+138h+var_D8]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_; std::operator+<char>(std::string&&,char const*)
lea rsi, aZuD+6; ", "
lea rdi, [rsp+138h+var_B0]
lea rdx, [rsp+138h+var_131]
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC2IS3_EEPKcRKS3_; std::string::basic_string<std::allocator<char>>(char const*,std::allocator<char> const&)
lea rdi, [rsp+138h+var_90]
lea rdx, [rsp+138h+var_B0]
mov rsi, [rsp+138h+var_E8]
call _Z11string_joinRKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EERKS5_; string_join(std::vector<std::string> const&,std::string const&)
lea rdi, [rsp+138h+var_108]
lea rsi, [rsp+138h+var_128]
lea rdx, [rsp+138h+var_90]
call _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_S9_; std::operator+<char>(std::string&&,std::string&)
mov bpl, 1
lea rsi, [rsp+138h+var_108]
mov rdi, r15
call __ZNSt13runtime_errorC1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE; std::runtime_error::runtime_error(std::string const&)
xor ebp, ebp
mov rsi, cs:lptinfo; lptinfo
mov rdx, cs:_ZNSt13runtime_errorD1Ev_ptr; void (*)(void *)
mov rdi, r15; void *
call ___cxa_throw
loc_7E482:
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E497
mov rbx, rax
mov bpl, 1
loc_7E497:
lea rdi, [rsp+138h+var_90]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E4AC
mov rbx, rax
mov bpl, 1
loc_7E4AC:
lea rdi, [rsp+138h+var_B0]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E4C1
mov rbx, rax
mov bpl, 1
loc_7E4C1:
lea rdi, [rsp+138h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E4D3
mov rbx, rax
mov bpl, 1
loc_7E4D3:
lea rdi, [rsp+138h+var_D8]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7E4EA
jmp loc_7E569
mov rbx, rax
loc_7E4EA:
mov rdi, r15
jmp short loc_7E553
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E504
mov rbx, rax
mov bpl, 1
loc_7E504:
lea rdi, [rsp+138h+var_128]
jmp short loc_7E53F
jmp short loc_7E54D
jmp short loc_7E511
jmp short loc_7E520
loc_7E511:
mov rbx, rax
lea rdi, [rsp+138h+var_108]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E526
loc_7E520:
mov rbx, rax
mov bpl, 1
loc_7E526:
lea rdi, [rsp+138h+var_128]; void *
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
jmp short loc_7E53A
jmp short $+2
loc_7E534:
mov rbx, rax
mov bpl, 1
loc_7E53A:
lea rdi, [rsp+138h+var_D8]; void *
loc_7E53F:
call _ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEED2Ev; std::string::~string()
test bpl, bpl
jnz short loc_7E550
jmp short loc_7E569
jmp short $+2
loc_7E54D:
mov rbx, rax
loc_7E550:
mov rdi, r14; void *
loc_7E553:
call ___cxa_free_exception
jmp short loc_7E569
jmp short $+2
loc_7E55C:
mov rbx, rax
lea rdi, [rsp+138h+var_D8]
call _ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE4dataD2Ev; nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,ulong,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<uchar>,void>::data::~data()
loc_7E569:
mov rdi, rbx
call __Unwind_Resume
| long long expect_tool_parameters(long long a1, _BYTE *a2, long long *a3)
{
long long v4; // rax
long long v5; // r13
long long v6; // r15
char v7; // bl
long long result; // rax
void *v9; // r14
void *v10; // r14
void *exception; // r14
void *v12; // r15
_QWORD v13[4]; // [rsp+10h] [rbp-128h] BYREF
_BYTE v14[32]; // [rsp+30h] [rbp-108h] BYREF
long long *v15; // [rsp+50h] [rbp-E8h]
unsigned __int8 *v16; // [rsp+58h] [rbp-E0h]
_OWORD v17[2]; // [rsp+60h] [rbp-D8h] BYREF
long long v18; // [rsp+80h] [rbp-B8h]
_QWORD v19[4]; // [rsp+88h] [rbp-B0h] BYREF
_QWORD v20[4]; // [rsp+A8h] [rbp-90h] BYREF
_BYTE v21[32]; // [rsp+C8h] [rbp-70h] BYREF
_BYTE v22[80]; // [rsp+E8h] [rbp-50h] BYREF
if ( *a2 != 1
|| !ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_((long long)a2)
|| (v4 = nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::operator[]<char const>(
(long long)a2,
(long long)"type"),
(unsigned __int8)ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_(
v4,
(long long)"object"))
|| !ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_((long long)a2)
|| !(unsigned __int8)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_(
a2,
"required") )
{
exception = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v13, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v14, (long long)v13, (long long)" must be an object w/ required properties");
std::runtime_error::runtime_error(exception, v14);
__cxa_throw(
exception,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v16 = (unsigned __int8 *)ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
a2,
"properties");
v5 = ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_(
(long long)a2,
(long long)"required");
v6 = *a3;
v15 = a3;
v18 = a3[1];
while ( v6 != v18 )
{
if ( !(unsigned __int8)nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::contains(
v16,
v6) )
{
v10 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" is missing property: ");
std::operator+<char>((long long)v14, (long long)v13, v6);
std::runtime_error::runtime_error(v10, v14);
__cxa_throw(
v10,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::cbegin(
(long long)v22,
v5);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::cend(
(long long)v21,
v5);
ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_(v17);
std::find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void> const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>>(
v14,
v22,
v21,
v17);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::cend(
(long long)v13,
v5);
v7 = ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_(v14);
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::string,bool,long,unsigned long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned char>,void>::data::~data((void **)v17);
if ( v7 )
{
v9 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" must have property marked as required: ");
std::operator+<char>((long long)v14, (long long)v13, v6);
std::runtime_error::runtime_error(v9, v14);
__cxa_throw(
v9,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
v6 += 32LL;
}
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>::size(v16);
if ( result != (v15[1] - *v15) >> 5 )
{
v12 = __cxa_allocate_exception(0x10uLL);
std::operator+<char>((long long)v17, (long long)"Parameters of tool ", a1);
std::operator+<char>((long long)v13, (long long)v17, (long long)" must only have these properties:");
std::string::basic_string<std::allocator<char>>(v19, (long long)", ");
string_join((long long)v20, v15, (long long)v19);
std::operator+<char>((long long)v14, v13, v20);
std::runtime_error::runtime_error(v12, v14);
__cxa_throw(
v12,
(struct type_info *)&`typeinfo for'std::runtime_error,
(void (*)(void *))&std::runtime_error::~runtime_error);
}
return result;
}
| expect_tool_parameters:
PUSH RBP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x108
MOV qword ptr [RSP + 0x8],RDI
CMP byte ptr [RSI],0x1
JNZ 0x0017e375
MOV R14,RDX
MOV RBX,RSI
LEA RSI,[0x199015]
MOV RDI,RBX
CALL 0x0015f34c
TEST AL,AL
JZ 0x0017e375
LEA RSI,[0x199015]
MOV RDI,RBX
CALL 0x0016012a
LEA RSI,[0x19ec20]
MOV RDI,RAX
CALL 0x0015fcf4
TEST AL,AL
JNZ 0x0017e375
LEA RSI,[0x1a808a]
MOV RDI,RBX
CALL 0x0015f4d4
TEST AL,AL
JZ 0x0017e375
LEA RSI,[0x199063]
MOV RDI,RBX
CALL 0x00182f46
TEST AL,AL
JZ 0x0017e375
LEA RSI,[0x1a808a]
MOV RDI,RBX
CALL 0x00183596
MOV qword ptr [RSP + 0x58],RAX
LEA RSI,[0x199063]
MOV RDI,RBX
CALL 0x0015fe80
MOV R13,RAX
MOV R15,qword ptr [R14]
MOV qword ptr [RSP + 0x50],R14
MOV RAX,qword ptr [R14 + 0x8]
MOV qword ptr [RSP + 0x80],RAX
LEA R14,[RSP + 0x60]
LEA RBP,[RSP + 0x30]
LAB_0017e1bd:
CMP R15,qword ptr [RSP + 0x80]
JZ 0x0017e254
MOV RDI,qword ptr [RSP + 0x58]
MOV RSI,R15
CALL 0x001836ea
TEST AL,AL
JZ 0x0017e2ff
LEA RBX,[RSP + 0xe8]
MOV RDI,RBX
MOV RSI,R13
CALL 0x00148baa
LEA R12,[RSP + 0xc8]
MOV RDI,R12
MOV RSI,R13
CALL 0x00148e06
MOV RDI,R14
MOV RSI,R15
CALL 0x0012b676
LAB_0017e211:
MOV RDI,RBP
MOV RSI,RBX
MOV RDX,R12
MOV RCX,R14
CALL 0x0018370c
LEA RBX,[RSP + 0x10]
MOV RDI,RBX
MOV RSI,R13
CALL 0x00148e06
LAB_0017e232:
MOV RDI,RBP
MOV RSI,RBX
CALL 0x00148c30
LAB_0017e23d:
MOV EBX,EAX
MOV RDI,R14
CALL 0x00145632
TEST BL,BL
JNZ 0x0017e289
ADD R15,0x20
JMP 0x0017e1bd
LAB_0017e254:
MOV RDI,qword ptr [RSP + 0x58]
CALL 0x00144824
MOV RDX,qword ptr [RSP + 0x50]
MOV RCX,qword ptr [RDX + 0x8]
SUB RCX,qword ptr [RDX]
SAR RCX,0x5
CMP RAX,RCX
JNZ 0x0017e3d9
ADD RSP,0x108
POP RBX
POP R12
POP R13
POP R14
POP R15
POP RBP
RET
LAB_0017e289:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0017e294:
LEA RSI,[0x1a8057]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001302a9
LAB_0017e2aa:
LEA RDX,[0x1a80ac]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00140743
LAB_0017e2c0:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
MOV RDX,R15
CALL 0x0015a58d
MOV BPL,0x1
LAB_0017e2d5:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R14
CALL 0x00120b30
LAB_0017e2ff:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0017e30a:
LEA RSI,[0x1a8057]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001302a9
LAB_0017e320:
LEA RDX,[0x1a8095]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00140743
LAB_0017e336:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
MOV RDX,R15
CALL 0x0015a58d
MOV BPL,0x1
LAB_0017e34b:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R14
CALL 0x00120b30
LAB_0017e375:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R14,RAX
LAB_0017e380:
LEA RSI,[0x1a8057]
LEA RDI,[RSP + 0x10]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001302a9
LAB_0017e396:
LEA RDX,[0x1a806b]
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
CALL 0x00140743
MOV BPL,0x1
LAB_0017e3af:
LEA RSI,[RSP + 0x30]
MOV RDI,R14
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R14
CALL 0x00120b30
LAB_0017e3d9:
PUSH 0x10
POP RDI
CALL 0x00120390
MOV R15,RAX
LAB_0017e3e4:
LEA RSI,[0x1a8057]
LEA RDI,[RSP + 0x60]
MOV RDX,qword ptr [RSP + 0x8]
CALL 0x001302a9
LAB_0017e3fa:
LEA RDX,[0x1a80d5]
LEA RDI,[RSP + 0x10]
LEA RSI,[RSP + 0x60]
CALL 0x00140743
LAB_0017e410:
LEA RSI,[0x1a64fd]
LEA RDI,[RSP + 0x88]
LEA RDX,[RSP + 0x7]
CALL 0x001262e2
LAB_0017e429:
LEA RDI,[RSP + 0xa8]
LEA RDX,[RSP + 0x88]
MOV RSI,qword ptr [RSP + 0x50]
CALL 0x0016c17e
LAB_0017e443:
LEA RDI,[RSP + 0x30]
LEA RSI,[RSP + 0x10]
LEA RDX,[RSP + 0xa8]
CALL 0x00140762
MOV BPL,0x1
LAB_0017e45d:
LEA RSI,[RSP + 0x30]
MOV RDI,R15
CALL 0x00120aa0
XOR EBP,EBP
MOV RSI,qword ptr [0x001e1fe8]
MOV RDX,qword ptr [0x001e1f70]
MOV RDI,R15
CALL 0x00120b30
|
/* expect_tool_parameters(std::__cxx11::string const&,
nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map, std::vector,
std::__cxx11::string, bool, long, unsigned long, double, std::allocator,
nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned
char> >, void> const&, std::vector<std::__cxx11::string, std::allocator<std::__cxx11::string > >
const&) */
void expect_tool_parameters(string *param_1,basic_json *param_2,vector *param_3)
{
char cVar1;
basic_json *pbVar2;
long lVar3;
runtime_error *prVar4;
string *psVar5;
allocator local_131;
string *local_130;
string local_128 [32];
string local_108 [32];
vector *local_e8;
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_e0;
data local_d8 [32];
string *local_b8;
string local_b0 [32];
vector local_90 [32];
int1 local_70 [32];
int1 local_50 [32];
local_130 = param_1;
if (*param_2 == (basic_json)0x1) {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA5_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,&DAT_00199015);
if (cVar1 != '\0') {
pbVar2 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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[]<char_const>
((basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)param_2,"type");
cVar1 = _ZN8nlohmann16json_abi_v3_11_3neIPKcTnNSt9enable_ifIXsr3std9is_scalarIT_EE5valueEiE4typeELi0EEEbRKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerESA_IhSaIhEEvEES5_
(pbVar2,"object");
if (cVar1 == '\0') {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,"properties");
if (cVar1 != '\0') {
cVar1 = _ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE8containsIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEEbOSJ_
(param_2,"required");
if (cVar1 != '\0') {
local_e0 = (basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
*)_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA11_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(param_2,"properties");
_ZNK8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvE2atIRA9_KcTnNSt9enable_ifIXsr6detail32is_usable_as_basic_json_key_typeISD_T_EE5valueEiE4typeELi0EEERKSD_OSJ_
(param_2,"required");
psVar5 = *(string **)param_3;
local_b8 = *(string **)(param_3 + 8);
local_e8 = param_3;
while( true ) {
if (psVar5 == local_b8) {
lVar3 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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(local_e0);
if (lVar3 == *(long *)(local_e8 + 8) - *(long *)local_e8 >> 5) {
return;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017e3e4 to 0017e3f9 has its CatchHandler @ 0017e4e7 */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 0017e3fa to 0017e40f has its CatchHandler @ 0017e4cd */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 0017e410 to 0017e428 has its CatchHandler @ 0017e4bb */
std::__cxx11::string::string<std::allocator<char>>(local_b0,", ",&local_131);
/* try { // try from 0017e429 to 0017e442 has its CatchHandler @ 0017e4a6 */
string_join(local_90,(string *)local_e8);
/* try { // try from 0017e443 to 0017e459 has its CatchHandler @ 0017e491 */
std::operator+(local_108,local_128);
/* try { // try from 0017e45d to 0017e481 has its CatchHandler @ 0017e482 */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
cVar1 = nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::contains(local_e0,psVar5);
if (cVar1 == '\0') break;
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cbegin();
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
_ZN8nlohmann16json_abi_v3_11_310basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES3_IhSaIhEEvEC2IRKS9_S9_TnNSt9enable_ifIXaantsr6detail13is_basic_jsonIT0_EE5valuesr6detail18is_compatible_typeISD_SI_EE5valueEiE4typeELi0EEEOT_
(local_d8,psVar5);
/* try { // try from 0017e211 to 0017e221 has its CatchHandler @ 0017e55a */
std::
find<nlohmann::json_abi_v3_11_3::detail::iter_impl<nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>const>,nlohmann::json_abi_v3_11_3::basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>>
(local_108,local_50,local_70,local_d8);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,bool,long,unsigned_long,double,std::allocator,nlohmann::json_abi_v3_11_3::adl_serializer,std::vector<unsigned_char,std::allocator<unsigned_char>>,void>
::cend();
/* try { // try from 0017e232 to 0017e23c has its CatchHandler @ 0017e55c */
cVar1 = _ZNK8nlohmann16json_abi_v3_11_36detail9iter_implIKNS0_10basic_jsonINS0_11ordered_mapESt6vectorNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEblmdSaNS0_14adl_serializerES5_IhSaIhEEvEEEeqISH_TnNSt9enable_ifIXoosr3std7is_sameIT_SH_EE5valuesr3std7is_sameISK_NS2_ISF_EEEE5valueEDnE4typeELDn0EEEbRKSK_
(local_108,local_128);
nlohmann::json_abi_v3_11_3::
basic_json<nlohmann::json_abi_v3_11_3::ordered_map,std::vector,std::__cxx11::string,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_d8);
if (cVar1 != '\0') {
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017e294 to 0017e2a9 has its CatchHandler @ 0017e54d */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 0017e2aa to 0017e2bf has its CatchHandler @ 0017e534 */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 0017e2c0 to 0017e2d1 has its CatchHandler @ 0017e520 */
std::operator+(local_108,local_128);
/* try { // try from 0017e2d5 to 0017e2f9 has its CatchHandler @ 0017e511 */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
psVar5 = psVar5 + 0x20;
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017e30a to 0017e31f has its CatchHandler @ 0017e54b */
std::operator+((char *)local_d8,(string *)"Parameters of tool ");
/* try { // try from 0017e320 to 0017e335 has its CatchHandler @ 0017e532 */
std::operator+(local_128,(char *)local_d8);
/* try { // try from 0017e336 to 0017e347 has its CatchHandler @ 0017e50f */
std::operator+(local_108,local_128);
/* try { // try from 0017e34b to 0017e36f has its CatchHandler @ 0017e50d */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
}
}
}
}
prVar4 = (runtime_error *)__cxa_allocate_exception(0x10);
/* try { // try from 0017e380 to 0017e395 has its CatchHandler @ 0017e50b */
std::operator+((char *)local_128,(string *)"Parameters of tool ");
/* try { // try from 0017e396 to 0017e3ab has its CatchHandler @ 0017e4fe */
std::operator+(local_108,(char *)local_128);
/* try { // try from 0017e3af to 0017e3d3 has its CatchHandler @ 0017e4ef */
std::runtime_error::runtime_error(prVar4,local_108);
/* WARNING: Subroutine does not return */
__cxa_throw(prVar4,PTR_typeinfo_001e1fe8,PTR__runtime_error_001e1f70);
}
| |
43,498 | my_open | eloqsql/mysys/my_open.c | File my_open(const char *FileName, int Flags, myf MyFlags)
/* Path-name of file */
/* Read | write .. */
/* Special flags */
{
File fd;
DBUG_ENTER("my_open");
DBUG_PRINT("my",("Name: '%s' Flags: %d MyFlags: %lu",
FileName, Flags, MyFlags));
if (!(MyFlags & (MY_WME | MY_FAE | MY_FFNF)))
MyFlags|= my_global_flags;
#if defined(_WIN32)
fd= my_win_open(FileName, Flags);
#else
if (MyFlags & MY_NOSYMLINKS)
fd = open_nosymlinks(FileName, Flags | O_CLOEXEC, my_umask);
else
fd = open(FileName, Flags | O_CLOEXEC, my_umask);
#endif
fd= my_register_filename(fd, FileName, FILE_BY_OPEN,
EE_FILENOTFOUND, MyFlags);
DBUG_RETURN(fd);
} | O3 | c | my_open:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
movq %rdi, %rbx
testb $0x19, %dl
jne 0x505b2
leaq 0x319afb(%rip), %rax # 0x36a0a8
movq (%rax), %r14
jmp 0x505b5
xorl %r14d, %r14d
orq %rdx, %r14
btl $0x9, %r14d
jb 0x505e1
orl $0x80000, %r15d # imm = 0x80000
leaq 0x2e6e4b(%rip), %rax # 0x337418
movl (%rax), %edx
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x25560
movl %eax, %r15d
jmp 0x5062d
leaq 0x2e6e30(%rip), %rax # 0x337418
movl (%rax), %r12d
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0x50c34
testq %rax, %rax
je 0x50627
movl -0x24(%rbp), %edi
orl $0xa0000, %r15d # imm = 0xA0000
movq %rax, %rsi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x252c0
movl %eax, %r15d
movl -0x24(%rbp), %edi
testl %edi, %edi
js 0x5062d
callq 0x255b0
jmp 0x5062d
movl $0xffffffff, %r15d # imm = 0xFFFFFFFF
movl %r15d, %edi
movq %rbx, %rsi
movl $0x1, %edx
movl $0x1d, %ecx
movq %r14, %r8
callq 0x50652
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| my_open:
push rbp
mov rbp, rsp
push r15
push r14
push r12
push rbx
sub rsp, 10h
mov r15d, esi
mov rbx, rdi
test dl, 19h
jnz short loc_505B2
lea rax, my_global_flags
mov r14, [rax]
jmp short loc_505B5
loc_505B2:
xor r14d, r14d
loc_505B5:
or r14, rdx
bt r14d, 9
jb short loc_505E1
or r15d, 80000h
lea rax, my_umask
mov edx, [rax]
mov rdi, rbx
mov esi, r15d
xor eax, eax
call _open64
mov r15d, eax
jmp short loc_5062D
loc_505E1:
lea rax, my_umask
mov r12d, [rax]
lea rsi, [rbp+var_24]
mov rdi, rbx
call my_open_parent_dir_nosymlinks
test rax, rax
jz short loc_50627
mov edi, [rbp+var_24]
or r15d, 0A0000h
mov rsi, rax
mov edx, r15d
mov ecx, r12d
xor eax, eax
call _openat64
mov r15d, eax
mov edi, [rbp+var_24]
test edi, edi
js short loc_5062D
call _close
jmp short loc_5062D
loc_50627:
mov r15d, 0FFFFFFFFh
loc_5062D:
mov edi, r15d
mov rsi, rbx
mov edx, 1
mov ecx, 1Dh
mov r8, r14
call my_register_filename
add rsp, 10h
pop rbx
pop r12
pop r14
pop r15
pop rbp
retn
| long long my_open(long long a1, int a2, long long a3)
{
long long v3; // r14
long long v4; // r14
unsigned int v5; // r15d
unsigned int v6; // r12d
long long v7; // rax
int v9[9]; // [rsp+Ch] [rbp-24h] BYREF
if ( (a3 & 0x19) != 0 )
v3 = 0LL;
else
v3 = my_global_flags;
v4 = a3 | v3;
if ( (v4 & 0x200) != 0 )
{
v6 = my_umask;
v7 = my_open_parent_dir_nosymlinks(a1, v9);
if ( v7 )
{
v5 = openat64((unsigned int)v9[0], v7, a2 | 0xA0000u, v6);
if ( v9[0] >= 0 )
close();
}
else
{
v5 = -1;
}
}
else
{
v5 = open64(a1, a2 | 0x80000u, my_umask);
}
return my_register_filename(v5, a1, 1LL, 29LL, v4);
}
| my_open:
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x10
MOV R15D,ESI
MOV RBX,RDI
TEST DL,0x19
JNZ 0x001505b2
LEA RAX,[0x46a0a8]
MOV R14,qword ptr [RAX]
JMP 0x001505b5
LAB_001505b2:
XOR R14D,R14D
LAB_001505b5:
OR R14,RDX
BT R14D,0x9
JC 0x001505e1
OR R15D,0x80000
LEA RAX,[0x437418]
MOV EDX,dword ptr [RAX]
MOV RDI,RBX
MOV ESI,R15D
XOR EAX,EAX
CALL 0x00125560
MOV R15D,EAX
JMP 0x0015062d
LAB_001505e1:
LEA RAX,[0x437418]
MOV R12D,dword ptr [RAX]
LEA RSI,[RBP + -0x24]
MOV RDI,RBX
CALL 0x00150c34
TEST RAX,RAX
JZ 0x00150627
MOV EDI,dword ptr [RBP + -0x24]
OR R15D,0xa0000
MOV RSI,RAX
MOV EDX,R15D
MOV ECX,R12D
XOR EAX,EAX
CALL 0x001252c0
MOV R15D,EAX
MOV EDI,dword ptr [RBP + -0x24]
TEST EDI,EDI
JS 0x0015062d
CALL 0x001255b0
JMP 0x0015062d
LAB_00150627:
MOV R15D,0xffffffff
LAB_0015062d:
MOV EDI,R15D
MOV RSI,RBX
MOV EDX,0x1
MOV ECX,0x1d
MOV R8,R14
CALL 0x00150652
ADD RSP,0x10
POP RBX
POP R12
POP R14
POP R15
POP RBP
RET
|
void my_open(char *param_1,uint param_2,ulong param_3)
{
uint uVar1;
int iVar2;
char *__file;
ulong uVar3;
int local_2c;
uVar1 = my_umask;
uVar3 = my_global_flags;
if ((param_3 & 0x19) != 0) {
uVar3 = 0;
}
if (((uint)(uVar3 | param_3) >> 9 & 1) == 0) {
iVar2 = open64(param_1,param_2 | 0x80000,(ulong)my_umask);
}
else {
__file = (char *)my_open_parent_dir_nosymlinks(param_1,&local_2c);
if (__file == (char *)0x0) {
iVar2 = -1;
}
else {
iVar2 = openat64(local_2c,__file,param_2 | 0xa0000,(ulong)uVar1);
if (-1 < local_2c) {
close(local_2c);
}
}
}
my_register_filename(iVar2,param_1,1,0x1d,uVar3 | param_3);
return;
}
| |
43,499 | maria_page_crc_check_index | eloqsql/storage/maria/ma_pagecrc.c | my_bool maria_page_crc_check_index(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;
uint length= _ma_get_page_used(share, page);
if (res)
return 1;
if (length > share->block_size - CRC_SIZE)
{
DBUG_PRINT("error", ("Wrong page length: %u", length));
my_errno= HA_ERR_WRONG_CRC;
return 1;
}
return maria_page_crc_check(page, (uint32) page_no, share,
MARIA_NO_CRC_NORMAL_PAGE,
length);
} | O0 | c | maria_page_crc_check_index:
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)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movl 0x744(%rcx), %ecx
movzbl -0x1(%rax,%rcx), %eax
movzwl %ax, %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl 0x744(%rdx), %edx
movzbl -0x2(%rcx,%rdx), %ecx
movzwl %cx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x36975
movb $0x1, -0x1(%rbp)
jmp 0x369bf
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
movl 0x7bc(%rcx), %ecx
subl $0x4, %ecx
cmpl %ecx, %eax
jbe 0x3699e
jmp 0x3698b
jmp 0x3698d
callq 0xc0d80
movl $0xb0, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x369bf
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %eax
movl %eax, %esi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %r8d
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x36590
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| maria_page_crc_check_index:
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
mov rax, [rbp+var_18]
mov rcx, [rbp+var_28]
mov ecx, [rcx+744h]
movzx eax, byte ptr [rax+rcx-1]
movzx eax, ax
mov rcx, [rbp+var_18]
mov rdx, [rbp+var_28]
mov edx, [rdx+744h]
movzx ecx, byte ptr [rcx+rdx-2]
movzx ecx, cx
shl ecx, 8
or eax, ecx
movzx eax, ax
mov [rbp+var_2C], eax
cmp [rbp+var_8], 0
jz short loc_36975
mov [rbp+var_1], 1
jmp short loc_369BF
loc_36975:
mov eax, [rbp+var_2C]
mov rcx, [rbp+var_28]
mov ecx, [rcx+7BCh]
sub ecx, 4
cmp eax, ecx
jbe short loc_3699E
jmp short $+2
loc_3698B:
jmp short $+2
loc_3698D:
call _my_thread_var
mov dword ptr [rax], 0B0h
mov [rbp+var_1], 1
jmp short loc_369BF
loc_3699E:
mov rdi, [rbp+var_18]
mov rax, [rbp+var_20]
mov eax, eax
mov esi, eax
mov rdx, [rbp+var_28]
mov r8d, [rbp+var_2C]
mov ecx, 0FFFFFFFFh
call maria_page_crc_check
mov [rbp+var_1], al
loc_369BF:
mov al, [rbp+var_1]
add rsp, 30h
pop rbp
retn
| char maria_page_crc_check_index(int a1, long long *a2)
{
unsigned int v3; // [rsp+4h] [rbp-2Ch]
long long v4; // [rsp+8h] [rbp-28h]
v4 = a2[2];
v3 = _byteswap_ushort(*(_WORD *)(*a2 + *(unsigned int *)(v4 + 1860) - 2));
if ( a1 )
return 1;
if ( v3 <= *(_DWORD *)(v4 + 1980) - 4 )
return maria_page_crc_check(*a2, a2[1], v4, -1, v3);
*(_DWORD *)my_thread_var() = 176;
return 1;
}
| maria_page_crc_check_index:
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
MOV RAX,qword ptr [RBP + -0x18]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x744]
MOVZX EAX,byte ptr [RAX + RCX*0x1 + -0x1]
MOVZX EAX,AX
MOV RCX,qword ptr [RBP + -0x18]
MOV RDX,qword ptr [RBP + -0x28]
MOV EDX,dword ptr [RDX + 0x744]
MOVZX ECX,byte ptr [RCX + RDX*0x1 + -0x2]
MOVZX ECX,CX
SHL ECX,0x8
OR EAX,ECX
MOVZX EAX,AX
MOV dword ptr [RBP + -0x2c],EAX
CMP dword ptr [RBP + -0x8],0x0
JZ 0x00136975
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001369bf
LAB_00136975:
MOV EAX,dword ptr [RBP + -0x2c]
MOV RCX,qword ptr [RBP + -0x28]
MOV ECX,dword ptr [RCX + 0x7bc]
SUB ECX,0x4
CMP EAX,ECX
JBE 0x0013699e
JMP 0x0013698b
LAB_0013698b:
JMP 0x0013698d
LAB_0013698d:
CALL 0x001c0d80
MOV dword ptr [RAX],0xb0
MOV byte ptr [RBP + -0x1],0x1
JMP 0x001369bf
LAB_0013699e:
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 R8D,dword ptr [RBP + -0x2c]
MOV ECX,0xffffffff
CALL 0x00136590
MOV byte ptr [RBP + -0x1],AL
LAB_001369bf:
MOV AL,byte ptr [RBP + -0x1]
ADD RSP,0x30
POP RBP
RET
|
int1 maria_page_crc_check_index(int param_1,long *param_2)
{
long lVar1;
long lVar2;
uint uVar3;
int4 *puVar4;
int1 local_9;
lVar1 = *param_2;
lVar2 = param_2[2];
uVar3 = (uint)CONCAT11(*(int1 *)(lVar1 + -2 + (ulong)*(uint *)(lVar2 + 0x744)),
*(int1 *)(lVar1 + -1 + (ulong)*(uint *)(lVar2 + 0x744)));
if (param_1 == 0) {
if (*(int *)(lVar2 + 0x7bc) - 4U < uVar3) {
puVar4 = (int4 *)_my_thread_var();
*puVar4 = 0xb0;
local_9 = 1;
}
else {
local_9 = maria_page_crc_check(lVar1,param_2[1] & 0xffffffff,lVar2,0xffffffff,uVar3);
}
}
else {
local_9 = 1;
}
return local_9;
}
|
Subsets and Splits
C++ Functions With Standard Library Dependencies
Identifies C++ functions that depend on standard library components, revealing patterns in how developers utilize STL libraries and potentially highlighting common coding practices or dependencies in the dataset.
C++ Standard Library Function Analysis
Filters C++ code examples that use standard library containers and types, providing useful insights into common programming patterns and data structures in the dataset.
Random Training Function Samples
Performs basic filtering and random sampling of assembly code data without revealing meaningful patterns or relationships.
Random Training Function Samples
Retrieves a random sample of 1000 records from the training dataset, providing basic data exploration but offering limited analytical value beyond seeing raw entries.